chore: ratchet codescene thresholds to 9.68/9.33

.codescene-thresholds

@@ -1,2 +1,2 @@
 HOTSPOT_THRESHOLD=9.68
-AVERAGE_THRESHOLD=9.32
+AVERAGE_THRESHOLD=9.33

src-tauri/src/menu.rs

@@ -295,7 +295,7 @@ fn build_note_menu(app: &App) -> MenuResult {
         .build(app)?;
     let toggle_ai_chat = MenuItemBuilder::new("Toggle AI Panel")
         .id(VIEW_TOGGLE_AI_CHAT)
-        .accelerator("CmdOrCtrl+Shift+L")
+        .accelerator("Cmd+Shift+L")
         .build(app)?;
     let toggle_backlinks = MenuItemBuilder::new("Toggle Backlinks")
         .id(VIEW_TOGGLE_BACKLINKS)

src/App.tsx

@@ -187,7 +187,7 @@ function App() {
     onOpenFile: (relativePath) => conflictFlow.openConflictFileRef.current(relativePath),
   })
 
-  const notes = useNoteActions({ addEntry: vault.addEntry, removeEntry: vault.removeEntry, entries: vault.entries, setToastMessage, updateEntry: vault.updateEntry, vaultPath: resolvedPath, addPendingSave: vault.addPendingSave, removePendingSave: vault.removePendingSave, trackUnsaved: vault.trackUnsaved, clearUnsaved: vault.clearUnsaved, unsavedPaths: vault.unsavedPaths, markContentPending: (path, content) => appSave.contentChangeRef.current(path, content), onNewNotePersisted: vault.loadModifiedFiles, replaceEntry: vault.replaceEntry })
+  const notes = useNoteActions({ addEntry: vault.addEntry, removeEntry: vault.removeEntry, entries: vault.entries, setToastMessage, updateEntry: vault.updateEntry, vaultPath: resolvedPath, addPendingSave: vault.addPendingSave, removePendingSave: vault.removePendingSave, trackUnsaved: vault.trackUnsaved, clearUnsaved: vault.clearUnsaved, unsavedPaths: vault.unsavedPaths, markContentPending: (path, content) => appSave.contentChangeRef.current(path, content), onNewNotePersisted: vault.loadModifiedFiles, replaceEntry: vault.replaceEntry, onFrontmatterPersisted: vault.loadModifiedFiles })
 
   // Note window: auto-open the note from URL params once vault entries load
   const noteWindowOpenedRef = useRef(false)
@@ -381,7 +381,6 @@ function App() {
     handleUpdateFrontmatter: notes.handleUpdateFrontmatter,
     handleDeleteProperty: notes.handleDeleteProperty, setToastMessage,
     createTypeEntry: notes.createTypeEntrySilent,
-    onFrontmatterPersisted: vault.loadModifiedFiles,
     onBeforeAction: appSave.flushBeforeAction,
   })
 

src/components/FilterBuilder.test.tsx

@@ -1,5 +1,5 @@
 import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
-import { render, screen, fireEvent } from '@testing-library/react'
+import { render, screen, fireEvent, act } from '@testing-library/react'
 import { FilterBuilder } from './FilterBuilder'
 import type { FilterGroup } from '../types'
 
@@ -135,6 +135,23 @@ describe('FilterBuilder value inputs', () => {
     expect(screen.getByTestId('date-picker-trigger')).toHaveAttribute('title', 'Mar 28, 2026')
   })
 
+  it('keeps filter controls top-aligned when the date preview adds a second line', async () => {
+    vi.useFakeTimers()
+    vi.setSystemTime(new Date('2026-04-07T12:00:00Z'))
+
+    renderBuilder({
+      all: [{ field: 'created', op: 'after', value: '10 days ago' }],
+    })
+
+    fireEvent.focus(screen.getByTestId('date-value-input'))
+    await act(async () => {
+      await vi.advanceTimersByTimeAsync(300)
+    })
+
+    expect(screen.getByTestId('date-value-preview')).toHaveTextContent('Resolves to March 28, 2026')
+    expect(screen.getByTestId('filter-row')).toHaveClass('items-start')
+  })
+
   it('filters the field combobox as the user types', () => {
     render(
       <FilterBuilder

src/components/FilterBuilder.tsx

@@ -141,7 +141,7 @@ function FilterRow({ condition, fields, onUpdate, onRemove }: {
   const regexEnabled = regexSupported && condition.regex === true
   const invalidRegex = regexSupported && hasInvalidRegex(String(condition.value ?? ''), regexEnabled)
   return (
-    <div className="flex items-center gap-1.5">
+    <div className="flex items-start gap-1.5" data-testid="filter-row">
       <FilterFieldCombobox
         value={condition.field}
         fields={fields}

src/components/NoteItem.test.tsx

@@ -134,6 +134,46 @@ describe('NoteItem', () => {
     expect(onClickNote).toHaveBeenCalledWith(linkedProject, expect.objectContaining({ metaKey: true }))
   })
 
+  it('falls back to the built-in type icon for relationship chips when the Type has no custom icon', () => {
+    const linkedTopic = makeEntry({
+      path: '/vault/topic/ai.md',
+      filename: 'ai.md',
+      title: 'AI',
+      isA: 'topic',
+    })
+    const topicType = makeEntry({
+      path: '/vault/type/topic.md',
+      filename: 'topic.md',
+      title: 'Topic',
+      isA: 'Type',
+      color: 'green',
+      icon: null,
+    })
+    const sourceEntry = makeEntry({
+      path: '/vault/note/source.md',
+      filename: 'source.md',
+      title: 'Source',
+      isA: 'Note',
+      relationships: { Topics: ['[[topic/ai]]'] },
+    })
+
+    render(
+      <NoteItem
+        entry={sourceEntry}
+        isSelected={false}
+        typeEntryMap={{ Topic: topicType, topic: topicType }}
+        allEntries={[sourceEntry, linkedTopic, topicType]}
+        displayPropsOverride={['Topics']}
+        onClickNote={vi.fn()}
+      />,
+    )
+
+    const chip = screen.getByTestId('property-chip-topics-0')
+    expect(chip).toHaveTextContent('Ai')
+    expect(chip).toHaveStyle({ color: 'var(--accent-green)', backgroundColor: 'var(--accent-green-light)' })
+    expect(chip.querySelector('svg')).not.toBeNull()
+  })
+
   it('opens URL chips on Cmd+click only and keeps regular clicks inert', () => {
     const entry = makeEntry({
       path: '/vault/note/source.md',

src/components/NoteTitleIcon.test.tsx

@@ -10,18 +10,20 @@ describe('NoteTitleIcon', () => {
   })
 
   it('renders a Phosphor icon when the name is recognized', () => {
-    render(<NoteTitleIcon icon="cooking pot" testId="note-title-icon" />)
+    const { container } = render(<NoteTitleIcon icon="cooking pot" testId="note-title-icon" className="mr-1" />)
 
     const icon = screen.getByTestId('note-title-icon')
     expect(icon.tagName.toLowerCase()).toBe('svg')
+    expect(container.querySelector('span.inline-flex.mr-1')).not.toBeNull()
   })
 
   it('renders an image when the icon is an http url', () => {
-    render(<NoteTitleIcon icon="https://example.com/favicon.png" testId="note-title-icon" />)
+    const { container } = render(<NoteTitleIcon icon="https://example.com/favicon.png" testId="note-title-icon" className="mr-1" />)
 
     const icon = screen.getByTestId('note-title-icon')
     expect(icon.tagName.toLowerCase()).toBe('img')
     expect(icon).toHaveAttribute('src', 'https://example.com/favicon.png')
+    expect(container.querySelector('span.inline-flex.mr-1')).not.toBeNull()
   })
 
   it('renders nothing for an unrecognized icon value', () => {

src/components/NoteTitleIcon.tsx

@@ -9,6 +9,21 @@ interface NoteTitleIconProps {
   testId?: string
 }
 
+function IconWrapper({
+  children,
+  className,
+  size,
+}: Pick<NoteTitleIconProps, 'className' | 'size'> & { children: React.ReactNode }) {
+  return (
+    <span
+      className={cn('inline-flex shrink-0 items-center justify-center align-middle', className)}
+      style={{ width: size, height: size, lineHeight: 1 }}
+    >
+      {children}
+    </span>
+  )
+}
+
 export function NoteTitleIcon({ icon, size = 14, className, color, testId }: NoteTitleIconProps) {
   const resolved = resolveNoteIcon(icon)
 
@@ -16,39 +31,40 @@ export function NoteTitleIcon({ icon, size = 14, className, color, testId }: Not
 
   if (resolved.kind === 'emoji') {
     return (
-      <span
-        className={cn('inline-flex shrink-0 items-center justify-center', className)}
-        style={{ fontSize: size, lineHeight: 1 }}
-        data-testid={testId}
-      >
-        {resolved.value}
-      </span>
+      <IconWrapper className={className} size={size}>
+        <span style={{ fontSize: size, lineHeight: 1 }} data-testid={testId}>
+          {resolved.value}
+        </span>
+      </IconWrapper>
     )
   }
 
   if (resolved.kind === 'image') {
     return (
-      <img
-        src={resolved.src}
-        alt=""
-        aria-hidden="true"
-        className={cn('shrink-0 rounded-sm object-cover', className)}
-        style={{ width: size, height: size }}
-        onError={(event) => {
-          event.currentTarget.style.display = 'none'
-        }}
-        data-testid={testId}
-      />
+      <IconWrapper className={className} size={size}>
+        <img
+          src={resolved.src}
+          alt=""
+          aria-hidden="true"
+          className="block h-full w-full rounded-sm object-cover"
+          onError={(event) => {
+            event.currentTarget.style.display = 'none'
+          }}
+          data-testid={testId}
+        />
+      </IconWrapper>
     )
   }
 
   return (
-    <resolved.Icon
-      width={size}
-      height={size}
-      className={cn('shrink-0', className)}
-      style={color ? { color } : undefined}
-      data-testid={testId}
-    />
+    <IconWrapper className={className} size={size}>
+      <resolved.Icon
+        width={size}
+        height={size}
+        className="block"
+        style={color ? { color } : undefined}
+        data-testid={testId}
+      />
+    </IconWrapper>
   )
 }

src/components/editor-content/EditorContentLayout.test.tsx

@@ -117,4 +117,18 @@ describe('EditorContentLayout', () => {
     expect(titleRow?.querySelector('[data-testid="note-icon-display"]')).not.toBeNull()
     expect(titleRow?.querySelector('[data-testid="title-field-input"]')).not.toBeNull()
   })
+
+  it('shows the loading skeleton instead of stale editor chrome while switching tabs', () => {
+    const { container } = render(
+      <EditorContentLayout
+        {...createModel({
+          activeTab: null,
+          isLoadingNewTab: true,
+        })}
+      />,
+    )
+
+    expect(container.querySelector('.animate-pulse')).not.toBeNull()
+    expect(screen.queryByTestId('title-field-input')).not.toBeInTheDocument()
+  })
 })

src/components/editor-content/EditorContentLayout.tsx

@@ -302,7 +302,11 @@ export function EditorContentLayout(model: EditorContentModel) {
   } = model
 
   if (!activeTab) {
-    return <div className="flex flex-1 flex-col min-w-0 min-h-0" />
+    return (
+      <div className="flex flex-1 flex-col min-w-0 min-h-0">
+        {isLoadingNewTab && showEditor && <EditorLoadingSkeleton />}
+      </div>
+    )
   }
 
   return (

src/components/editor-content/editorContentState.test.ts

@@ -62,6 +62,26 @@ describe('deriveEditorContentState', () => {
       content: '---\ntitle: Legacy Project\n---\nBody without a heading',
     })
 
+    expect(state.hasH1).toBe(false)
+    expect(state.showTitleSection).toBe(false)
+  })
+
+  it('hides the legacy title section when a frontmatter title drives the display title', () => {
+    const state = deriveState({
+      entry: baseEntry,
+      content: '---\ntitle: Spring 2026\nstatus: Active\n---\n## Goals',
+    })
+
+    expect(state.hasH1).toBe(false)
+    expect(state.showTitleSection).toBe(false)
+  })
+
+  it('keeps the title section when the document title still comes from the filename', () => {
+    const state = deriveState({
+      entry: baseEntry,
+      content: '---\nstatus: Active\n---\nBody without a heading',
+    })
+
     expect(state.hasH1).toBe(false)
     expect(state.showTitleSection).toBe(true)
   })

src/components/editor-content/editorContentState.ts

@@ -1,5 +1,5 @@
 import type { NoteStatus, VaultEntry } from '../../types'
-import { extractH1TitleFromContent } from '../../utils/noteTitle'
+import { contentDefinesDisplayTitle, extractH1TitleFromContent } from '../../utils/noteTitle'
 import { countWords } from '../../utils/wikilinks'
 
 export interface EditorContentTab {
@@ -14,6 +14,19 @@ interface EditorContentStateInput {
   activeStatus: NoteStatus
 }
 
+interface TitleSectionState {
+  hasDisplayTitle: boolean
+  hasH1: boolean
+}
+
+interface VisibilityState {
+  effectiveRawMode: boolean
+  isDeletedPreview: boolean
+  isNonMarkdownText: boolean
+  showEditor: boolean
+  showTitleSection: boolean
+}
+
 export interface EditorContentState {
   freshEntry: VaultEntry | undefined
   isArchived: boolean
@@ -36,10 +49,53 @@ function contentHasTopLevelH1(activeTab: EditorContentTab | null): boolean {
   return activeTab ? extractH1TitleFromContent(activeTab.content) !== null : false
 }
 
+function contentDefinesTitle(activeTab: EditorContentTab | null): boolean {
+  return activeTab ? contentDefinesDisplayTitle(activeTab.content) : false
+}
+
 function resolveHasH1(activeTab: EditorContentTab | null, freshEntry: VaultEntry | undefined): boolean {
   return contentHasTopLevelH1(activeTab) || freshEntry?.hasH1 === true || activeTab?.entry.hasH1 === true
 }
 
+function resolveHasDisplayTitle(activeTab: EditorContentTab | null, hasH1: boolean): boolean {
+  return hasH1 || contentDefinesTitle(activeTab)
+}
+
+function deriveTitleSectionState(activeTab: EditorContentTab | null, freshEntry: VaultEntry | undefined): TitleSectionState {
+  const hasH1 = resolveHasH1(activeTab, freshEntry)
+  return {
+    hasDisplayTitle: resolveHasDisplayTitle(activeTab, hasH1),
+    hasH1,
+  }
+}
+
+function deriveVisibilityState(input: {
+  activeStatus: NoteStatus
+  activeTab: EditorContentTab | null
+  freshEntry: VaultEntry | undefined
+  hasDisplayTitle: boolean
+  rawMode: boolean
+}): VisibilityState {
+  const {
+    activeStatus,
+    activeTab,
+    freshEntry,
+    hasDisplayTitle,
+    rawMode,
+  } = input
+  const isDeletedPreview = !!activeTab && !freshEntry
+  const isNonMarkdownText = activeTab?.entry.fileKind === 'text'
+  const effectiveRawMode = rawMode || isNonMarkdownText
+
+  return {
+    isDeletedPreview,
+    isNonMarkdownText,
+    effectiveRawMode,
+    showEditor: !effectiveRawMode,
+    showTitleSection: !isDeletedPreview && !hasDisplayTitle && !isUnsavedUntitledDraft(activeTab, activeStatus),
+  }
+}
+
 function isUnsavedUntitledDraft(activeTab: EditorContentTab | null, activeStatus: NoteStatus): boolean {
   if (!activeTab) return false
   if (!activeTab.entry.filename.startsWith('untitled-')) return false
@@ -53,22 +109,20 @@ export function deriveEditorContentState({
   activeStatus,
 }: EditorContentStateInput): EditorContentState {
   const freshEntry = findFreshEntry(activeTab, entries)
-  const isDeletedPreview = !!activeTab && !freshEntry
-  const hasH1 = resolveHasH1(activeTab, freshEntry)
-  const isNonMarkdownText = activeTab?.entry.fileKind === 'text'
-  const effectiveRawMode = rawMode || isNonMarkdownText
-  const showEditor = !effectiveRawMode
-  const showTitleSection = !isDeletedPreview && !hasH1 && !isUnsavedUntitledDraft(activeTab, activeStatus)
+  const titleState = deriveTitleSectionState(activeTab, freshEntry)
+  const visibilityState = deriveVisibilityState({
+    activeStatus,
+    activeTab,
+    freshEntry,
+    hasDisplayTitle: titleState.hasDisplayTitle,
+    rawMode,
+  })
 
   return {
     freshEntry,
     isArchived: freshEntry?.archived ?? activeTab?.entry.archived ?? false,
-    hasH1,
-    isDeletedPreview,
-    isNonMarkdownText,
-    effectiveRawMode,
-    showEditor,
-    showTitleSection,
+    hasH1: titleState.hasH1,
+    ...visibilityState,
     path: activeTab?.entry.path ?? '',
     wordCount: activeTab ? countWords(activeTab.content) : 0,
   }

src/components/note-item/PropertyChips.tsx

@@ -1,17 +1,17 @@
-import { createElement, useMemo, useState, type CSSProperties, type MouseEvent } from 'react'
+import { createElement, useMemo, useState, type ComponentType, type CSSProperties, type MouseEvent, type ReactNode, type SVGAttributes } from 'react'
 import { Link } from '@phosphor-icons/react'
 import { cn } from '@/lib/utils'
 import type { VaultEntry } from '../../types'
-import { findIcon } from '../../utils/iconRegistry'
 import { resolveNoteIcon } from '../../utils/noteIcon'
 import { getTypeColor, getTypeLightColor } from '../../utils/typeColors'
 import { isUrlValue, normalizeUrl, openExternalUrl } from '../../utils/url'
 import { resolveEntry, wikilinkDisplay, wikilinkTarget } from '../../utils/wikilink'
+import { getTypeIcon } from './typeIcon'
 
 interface PropertyChipValue {
   label: string
   noteIcon: string | null
-  typeIcon: string | null
+  typeIcon: ComponentType<SVGAttributes<SVGSVGElement>> | null
   style?: CSSProperties
   action?: { kind: 'note'; entry: VaultEntry } | { kind: 'url'; url: string }
   tone: 'neutral' | 'relationship' | 'url'
@@ -46,8 +46,16 @@ function formatChipLabel(value: unknown): string | null {
   return raw.length > 40 ? `${raw.slice(0, 37)}…` : raw
 }
 
+function resolveTargetTypeEntry(targetEntry: VaultEntry, typeEntryMap: Record<string, VaultEntry>): VaultEntry | undefined {
+  return targetEntry.isA ? (typeEntryMap[targetEntry.isA] ?? typeEntryMap[targetEntry.isA.toLowerCase()]) : undefined
+}
+
+function findMatchingKey(values: Record<string, unknown>, propName: string): string | undefined {
+  return Object.keys(values).find((key) => key.toLowerCase() === propName.toLowerCase())
+}
+
 function resolveRelationshipChipStyle(targetEntry: VaultEntry, typeEntryMap: Record<string, VaultEntry>): CSSProperties | undefined {
-  const typeEntry = targetEntry.isA ? (typeEntryMap[targetEntry.isA] ?? typeEntryMap[targetEntry.isA.toLowerCase()]) : undefined
+  const typeEntry = resolveTargetTypeEntry(targetEntry, typeEntryMap)
   const color = getTypeColor(targetEntry.isA, typeEntry?.color)
   const backgroundColor = getTypeLightColor(targetEntry.isA, typeEntry?.color)
   if (color === 'var(--muted-foreground)' && backgroundColor === 'var(--muted)') return undefined
@@ -72,11 +80,11 @@ function resolveRelationshipChip(
     }
   }
 
-  const typeEntry = targetEntry.isA ? (typeEntryMap[targetEntry.isA] ?? typeEntryMap[targetEntry.isA.toLowerCase()]) : undefined
+  const typeEntry = resolveTargetTypeEntry(targetEntry, typeEntryMap)
   return {
     label,
     noteIcon: targetEntry.icon ?? null,
-    typeIcon: targetEntry.isA ? typeEntry?.icon ?? null : null,
+    typeIcon: targetEntry.isA ? getTypeIcon(targetEntry.isA, typeEntry?.icon) : null,
     style: resolveRelationshipChipStyle(targetEntry, typeEntryMap),
     action: { kind: 'note', entry: targetEntry },
     tone: 'relationship',
@@ -107,6 +115,30 @@ function resolveScalarChip(value: unknown): PropertyChipValue | null {
   }
 }
 
+function resolveRelationshipChipValues(
+  entry: VaultEntry,
+  propName: string,
+  allEntries: VaultEntry[],
+  typeEntryMap: Record<string, VaultEntry>,
+): PropertyChipValue[] | null {
+  const relationshipKey = findMatchingKey(entry.relationships, propName)
+  if (!relationshipKey) return null
+  return entry.relationships[relationshipKey]
+    .map((ref) => resolveRelationshipChip(ref, allEntries, typeEntryMap))
+    .filter((chip): chip is PropertyChipValue => chip !== null)
+}
+
+function resolveScalarChipValues(entry: VaultEntry, propName: string): PropertyChipValue[] {
+  const propertyKey = findMatchingKey(entry.properties, propName)
+  if (!propertyKey) return []
+
+  const rawValue = entry.properties[propertyKey]
+  const values = Array.isArray(rawValue) ? rawValue : [rawValue]
+  return values
+    .map((value) => resolveScalarChip(value))
+    .filter((chip): chip is PropertyChipValue => chip !== null)
+}
+
 function resolvePropertyChipValues(
   entry: VaultEntry,
   propName: string,
@@ -118,40 +150,24 @@ function resolvePropertyChipValues(
     return statusChip ? [statusChip] : []
   }
 
-  const relationshipKey = Object.keys(entry.relationships).find((key) => key.toLowerCase() === propName.toLowerCase())
-  if (relationshipKey) {
-    return entry.relationships[relationshipKey]
-      .map((ref) => resolveRelationshipChip(ref, allEntries, typeEntryMap))
-      .filter((chip): chip is PropertyChipValue => chip !== null)
-  }
-
-  const propertyKey = Object.keys(entry.properties).find((key) => key.toLowerCase() === propName.toLowerCase())
-  if (!propertyKey) return []
-
-  const rawValue = entry.properties[propertyKey]
-  const values = Array.isArray(rawValue) ? rawValue : [rawValue]
-  return values
-    .map((value) => resolveScalarChip(value))
-    .filter((chip): chip is PropertyChipValue => chip !== null)
+  return resolveRelationshipChipValues(entry, propName, allEntries, typeEntryMap) ?? resolveScalarChipValues(entry, propName)
 }
 
-function PropertyChipIcon({
-  noteIcon,
+function RelationshipTypeIcon({
   typeIcon,
-  tone,
 }: {
-  noteIcon?: string | null
-  typeIcon?: string | null
-  tone: PropertyChipValue['tone']
+  typeIcon?: ComponentType<SVGAttributes<SVGSVGElement>> | null
 }) {
-  const [imageFailed, setImageFailed] = useState(false)
-
-  if (tone === 'url') {
-    return <Link aria-hidden="true" width={11} height={11} className="shrink-0" />
-  }
+  if (!typeIcon) return null
+  return createElement(typeIcon, { 'aria-hidden': true, width: 11, height: 11, className: 'shrink-0' })
+}
 
+function renderResolvedNoteIcon(
+  noteIcon: string | null | undefined,
+  imageFailed: boolean,
+  onImageError: () => void,
+): ReactNode {
   const resolvedNoteIcon = resolveNoteIcon(noteIcon)
-  const TypeIcon = findIcon(typeIcon)
 
   if (resolvedNoteIcon.kind === 'emoji') {
     return (
@@ -165,20 +181,37 @@ function PropertyChipIcon({
     return <resolvedNoteIcon.Icon aria-hidden="true" width={11} height={11} className="shrink-0" />
   }
 
-  if (resolvedNoteIcon.kind === 'image' && !imageFailed) {
-    return (
-      <img
-        src={resolvedNoteIcon.src}
-        alt=""
-        aria-hidden="true"
-        className="h-[11px] w-[11px] shrink-0 rounded-sm object-cover"
-        onError={() => setImageFailed(true)}
-      />
-    )
+  if (resolvedNoteIcon.kind !== 'image' || imageFailed) return null
+
+  return (
+    <img
+      src={resolvedNoteIcon.src}
+      alt=""
+      aria-hidden="true"
+      className="h-[11px] w-[11px] shrink-0 rounded-sm object-cover"
+      onError={onImageError}
+    />
+  )
+}
+
+function PropertyChipIcon({
+  noteIcon,
+  typeIcon,
+  tone,
+}: {
+  noteIcon?: string | null
+  typeIcon?: ComponentType<SVGAttributes<SVGSVGElement>> | null
+  tone: PropertyChipValue['tone']
+}) {
+  const [imageFailed, setImageFailed] = useState(false)
+
+  if (tone === 'url') {
+    return <Link aria-hidden="true" width={11} height={11} className="shrink-0" />
   }
 
-  if (!TypeIcon) return null
-  return createElement(TypeIcon, { 'aria-hidden': true, width: 11, height: 11, className: 'shrink-0' })
+  const noteIconElement = renderResolvedNoteIcon(noteIcon, imageFailed, () => setImageFailed(true))
+  if (noteIconElement) return noteIconElement
+  return <RelationshipTypeIcon typeIcon={typeIcon} />
 }
 
 async function handleChipClick(

src/components/note-item/typeIcon.ts

@@ -0,0 +1,37 @@
+import type { ComponentType, SVGAttributes } from 'react'
+import {
+  ArrowsClockwise,
+  CalendarBlank,
+  FileText,
+  Flask,
+  StackSimple,
+  Tag,
+  Target,
+  Users,
+  Wrench,
+} from '@phosphor-icons/react'
+import { resolveIcon } from '../../utils/iconRegistry'
+
+const TYPE_ICON_MAP: Record<string, ComponentType<SVGAttributes<SVGSVGElement>>> = {
+  Project: Wrench,
+  project: Wrench,
+  Experiment: Flask,
+  experiment: Flask,
+  Responsibility: Target,
+  responsibility: Target,
+  Procedure: ArrowsClockwise,
+  procedure: ArrowsClockwise,
+  Person: Users,
+  person: Users,
+  Event: CalendarBlank,
+  event: CalendarBlank,
+  Topic: Tag,
+  topic: Tag,
+  Type: StackSimple,
+  type: StackSimple,
+}
+
+export function getTypeIcon(isA: string | null, customIcon?: string | null): ComponentType<SVGAttributes<SVGSVGElement>> {
+  if (customIcon) return resolveIcon(customIcon)
+  return (isA && TYPE_ICON_MAP[isA]) || FileText
+}

src/hooks/appKeyboardShortcuts.ts

@@ -38,8 +38,10 @@ const VIEW_MODE_KEYS: Record<string, ViewMode> = {
 }
 
 function isTextInputFocused(): boolean {
-  const tag = document.activeElement?.tagName
-  return tag === 'INPUT' || tag === 'TEXTAREA'
+  const active = document.activeElement
+  if (!(active instanceof HTMLElement)) return false
+  if (active.tagName === 'INPUT' || active.tagName === 'TEXTAREA') return true
+  return active.isContentEditable || active.closest('[contenteditable="true"]') !== null
 }
 
 function isCommandOrCtrlOnly(e: KeyboardEvent): boolean {
@@ -119,7 +121,8 @@ export function handleCommandKey(e: KeyboardEvent, keyMap: ShortcutMap): boolean
 }
 
 export function handleAiPanelKey(e: KeyboardEvent, onToggleAIChat?: () => void): boolean {
-  if (isCommandShiftOnly(e) === false || e.key.toLowerCase() !== 'l' || onToggleAIChat === undefined) return false
+  const matchesAiPanelShortcut = e.code === 'KeyL' || e.key.toLowerCase() === 'l'
+  if (isCommandShiftOnly(e) === false || matchesAiPanelShortcut === false || onToggleAIChat === undefined) return false
   e.preventDefault()
   onToggleAIChat()
   return true

src/hooks/useAppKeyboard.test.ts

@@ -2,9 +2,21 @@ import { describe, it, expect, vi, afterEach } from 'vitest'
 import { renderHook } from '@testing-library/react'
 import { useAppKeyboard } from './useAppKeyboard'
 
-function fireKey(key: string, mods: { altKey?: boolean; metaKey?: boolean; ctrlKey?: boolean; shiftKey?: boolean } = {}) {
+function fireKey(
+  key: string,
+  mods: { altKey?: boolean; metaKey?: boolean; ctrlKey?: boolean; shiftKey?: boolean; code?: string } = {},
+) {
+  fireKeyOnTarget(window, key, mods)
+}
+
+function fireKeyOnTarget(
+  target: EventTarget,
+  key: string,
+  mods: { altKey?: boolean; metaKey?: boolean; ctrlKey?: boolean; shiftKey?: boolean; code?: string } = {},
+) {
   const event = new KeyboardEvent('keydown', {
     key,
+    code: mods.code,
     altKey: mods.altKey ?? false,
     metaKey: mods.metaKey ?? false,
     ctrlKey: mods.ctrlKey ?? false,
@@ -12,7 +24,7 @@ function fireKey(key: string, mods: { altKey?: boolean; metaKey?: boolean; ctrlK
     bubbles: true,
     cancelable: true,
   })
-  window.dispatchEvent(event)
+  target.dispatchEvent(event)
 }
 
 function makeActions() {
@@ -130,6 +142,14 @@ describe('useAppKeyboard', () => {
     try { fn() } finally { document.body.removeChild(input) }
   }
 
+  function withFocusedContentEditable(fn: (editable: HTMLDivElement) => void) {
+    const editable = document.createElement('div')
+    editable.setAttribute('contenteditable', 'true')
+    document.body.appendChild(editable)
+    editable.focus()
+    try { fn(editable) } finally { document.body.removeChild(editable) }
+  }
+
   it('Cmd+Backspace does not delete note when text input is focused', () => {
     const actions = makeActions()
     renderHook(() => useAppKeyboard(actions))
@@ -139,6 +159,15 @@ describe('useAppKeyboard', () => {
     })
   })
 
+  it('Cmd+Backspace does not delete note when contenteditable is focused', () => {
+    const actions = makeActions()
+    renderHook(() => useAppKeyboard(actions))
+    withFocusedContentEditable((editable) => {
+      fireKeyOnTarget(editable, 'Backspace', { metaKey: true })
+      expect(actions.onDeleteNote).not.toHaveBeenCalled()
+    })
+  })
+
   it('Cmd+Backspace deletes note when no text input is focused', () => {
     const actions = makeActions()
     renderHook(() => useAppKeyboard(actions))
@@ -201,6 +230,25 @@ describe('useAppKeyboard', () => {
     })
   })
 
+  it('Cmd+Shift+L works when editor stops propagation', () => {
+    const actions = makeActions()
+    const onToggleAIChat = vi.fn()
+    renderHook(() => useAppKeyboard({ ...actions, onToggleAIChat }))
+    withFocusedContentEditable((editable) => {
+      editable.addEventListener('keydown', (event) => event.stopPropagation())
+      fireKeyOnTarget(editable, 'l', { metaKey: true, shiftKey: true })
+      expect(onToggleAIChat).toHaveBeenCalled()
+    })
+  })
+
+  it('Cmd+Shift+L matches by physical key code when the localized key differs', () => {
+    const actions = makeActions()
+    const onToggleAIChat = vi.fn()
+    renderHook(() => useAppKeyboard({ ...actions, onToggleAIChat }))
+    fireKey('¬', { code: 'KeyL', metaKey: true, shiftKey: true })
+    expect(onToggleAIChat).toHaveBeenCalled()
+  })
+
   it('Ctrl+Shift+L does not trigger toggle AI chat', () => {
     const actions = makeActions()
     const onToggleAIChat = vi.fn()

src/hooks/useAppKeyboard.ts

@@ -14,7 +14,7 @@ export function useAppKeyboard(actions: KeyboardActions) {
       onKeyDown(event)
     }
 
-    window.addEventListener('keydown', handleWindowKeyDown)
-    return () => window.removeEventListener('keydown', handleWindowKeyDown)
+    window.addEventListener('keydown', handleWindowKeyDown, true)
+    return () => window.removeEventListener('keydown', handleWindowKeyDown, true)
   }, [])
 }

src/hooks/useEditorSaveWithLinks.ts

@@ -36,11 +36,11 @@ export function useEditorSaveWithLinks(config: {
     const filename = path.split('/').pop() ?? path
     const fmPatch = {
       ...frontmatterPatch,
-      ...deriveDisplayTitleState(
+      ...deriveDisplayTitleState({
         content,
         filename,
-        typeof frontmatterPatch.title === 'string' ? frontmatterPatch.title : null,
-      ),
+        frontmatterTitle: typeof frontmatterPatch.title === 'string' ? frontmatterPatch.title : null,
+      }),
     }
     const fmKey = JSON.stringify(fmPatch)
     if (fmKey !== prevFmKeyRef.current) {

src/hooks/useEditorTabSwap.test.ts

@@ -185,6 +185,41 @@ function makeMockEditor(docRef: { current: unknown[] }) {
 describe('useEditorTabSwap raw mode sync', () => {
   afterEach(() => { vi.restoreAllMocks() })
 
+  it('swaps in the new note when the path updates before tabs catch up', async () => {
+    vi.spyOn(document, 'querySelector').mockReturnValue({ scrollTop: 0 } as unknown as Element)
+    vi.spyOn(window, 'requestAnimationFrame').mockImplementation((cb) => { cb(0); return 0 })
+
+    const docRef = { current: blocksA as unknown[] }
+    const mockEditor = makeMockEditor(docRef)
+    Object.defineProperty(mockEditor, 'document', { get: () => docRef.current })
+
+    const tabA = makeTab('a.md', 'Note A')
+    const tabB = makeTab('b.md', 'March 2024')
+
+    const { rerender } = renderHook(
+      ({ tabs, activeTabPath, rawMode }) => useEditorTabSwap({
+        tabs, activeTabPath, editor: mockEditor as never, rawMode,
+      }),
+      { initialProps: { tabs: [tabA], activeTabPath: 'a.md', rawMode: false as boolean } },
+    )
+
+    await act(() => new Promise(r => setTimeout(r, 0)))
+    mockEditor.tryParseMarkdownToBlocks.mockClear()
+    mockEditor.replaceBlocks.mockClear()
+
+    rerender({ tabs: [tabA], activeTabPath: 'b.md', rawMode: false })
+    await act(() => new Promise(r => setTimeout(r, 0)))
+    expect(mockEditor.tryParseMarkdownToBlocks).not.toHaveBeenCalled()
+
+    rerender({ tabs: [tabB], activeTabPath: 'b.md', rawMode: false })
+    await act(() => new Promise(r => setTimeout(r, 0)))
+
+    expect(mockEditor.tryParseMarkdownToBlocks).toHaveBeenCalledWith(
+      expect.stringContaining('March 2024'),
+    )
+    expect(mockEditor.replaceBlocks).toHaveBeenCalled()
+  })
+
   it('re-parses from tab.content when rawMode transitions from true to false', async () => {
     vi.spyOn(document, 'querySelector').mockReturnValue({ scrollTop: 0 } as unknown as Element)
     vi.spyOn(window, 'requestAnimationFrame').mockImplementation((cb) => { cb(0); return 0 })

src/hooks/useEditorTabSwap.ts

@@ -1,4 +1,4 @@
-import { useCallback, useEffect, useRef } from 'react'
+import { useCallback, useEffect, useRef, type MutableRefObject } from 'react'
 import type { useCreateBlockNote } from '@blocknote/react'
 import type { VaultEntry } from '../types'
 import { splitFrontmatter, preProcessWikilinks, injectWikilinks, restoreWikilinksInBlocks } from '../utils/wikilinks'
@@ -9,6 +9,10 @@ interface Tab {
   content: string
 }
 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any -- BlockNote block arrays
+type EditorBlocks = any[]
+type CachedTabState = { blocks: EditorBlocks; scrollTop: number }
+
 interface UseEditorTabSwapOptions {
   tabs: Tab[]
   activeTabPath: string | null
@@ -27,15 +31,17 @@ export function extractEditorBody(rawFileContent: string): string {
 
 /** Extract H1 text from the editor's first block, or null if not an H1. */
 export function getH1TextFromBlocks(blocks: unknown[]): string | null {
-  if (!blocks?.length) return null
-  const first = blocks[0] as {
+  const first = blocks?.[0] as {
     type?: string
     props?: { level?: number }
     content?: Array<{ type?: string; text?: string }>
-  }
-  if (first.type !== 'heading' || first.props?.level !== 1) return null
-  if (!Array.isArray(first.content)) return null
-  const text = first.content
+  } | undefined
+  const content = first?.type === 'heading' && first.props?.level === 1 && Array.isArray(first.content)
+    ? first.content
+    : null
+  if (!content) return null
+
+  const text = content
     .filter(item => item.type === 'text')
     .map(item => item.text || '')
     .join('')
@@ -47,6 +53,395 @@ export function replaceTitleInFrontmatter(frontmatter: string, newTitle: string)
   return frontmatter.replace(/^(title:\s*).+$/m, `$1${newTitle}`)
 }
 
+function readEditorScrollTop(): number {
+  const scrollEl = document.querySelector('.editor__blocknote-container')
+  return scrollEl?.scrollTop ?? 0
+}
+
+function cacheEditorState(
+  cache: Map<string, CachedTabState>,
+  path: string,
+  blocks: EditorBlocks,
+) {
+  cache.set(path, {
+    blocks,
+    scrollTop: readEditorScrollTop(),
+  })
+}
+
+function buildFastPathBlocks(preprocessed: string): EditorBlocks | null {
+  if (!preprocessed.trim()) {
+    return [{ type: 'paragraph', content: [] }]
+  }
+
+  const h1OnlyMatch = preprocessed.trim().match(/^# (.+)$/)
+  if (!h1OnlyMatch) return null
+
+  return [
+    { type: 'heading', props: { level: 1, textColor: 'default', backgroundColor: 'default', textAlignment: 'left' }, content: [{ type: 'text', text: h1OnlyMatch[1], styles: {} }], children: [] },
+    { type: 'paragraph', content: [], children: [] },
+  ]
+}
+
+async function parseMarkdownBlocks(
+  editor: ReturnType<typeof useCreateBlockNote>,
+  preprocessed: string,
+): Promise<EditorBlocks> {
+  const result = editor.tryParseMarkdownToBlocks(preprocessed)
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any -- tryParseMarkdownToBlocks returns sync or async BlockNote blocks
+  if (result && typeof (result as any).then === 'function') {
+    return (result as unknown as Promise<EditorBlocks>)
+  }
+  return result as EditorBlocks
+}
+
+async function resolveBlocksForTarget(
+  editor: ReturnType<typeof useCreateBlockNote>,
+  cache: Map<string, CachedTabState>,
+  targetPath: string,
+  content: string,
+): Promise<CachedTabState> {
+  const cached = cache.get(targetPath)
+  if (cached) return cached
+
+  const body = extractEditorBody(content)
+  const preprocessed = preProcessWikilinks(body)
+  const fastPathBlocks = buildFastPathBlocks(preprocessed)
+  if (fastPathBlocks) {
+    const nextState = { blocks: fastPathBlocks, scrollTop: 0 }
+    cache.set(targetPath, nextState)
+    return nextState
+  }
+
+  const parsed = await parseMarkdownBlocks(editor, preprocessed)
+  const withWikilinks = injectWikilinks(parsed)
+  if (withWikilinks.length > 0) {
+    cache.set(targetPath, { blocks: withWikilinks, scrollTop: 0 })
+  }
+  return { blocks: withWikilinks, scrollTop: 0 }
+}
+
+function applyBlocksToEditor(
+  editor: ReturnType<typeof useCreateBlockNote>,
+  blocks: EditorBlocks,
+  scrollTop: number,
+  suppressChangeRef: MutableRefObject<boolean>,
+) {
+  suppressChangeRef.current = true
+  try {
+    const current = editor.document
+    if (current.length > 0 && blocks.length > 0) {
+      editor.replaceBlocks(current, blocks)
+    } else if (blocks.length > 0) {
+      editor.insertBlocks(blocks, current[0], 'before')
+    }
+  } catch (err) {
+    console.error('applyBlocks failed, trying fallback:', err)
+    try {
+      const html = editor.blocksToHTMLLossy(blocks)
+      editor._tiptapEditor.commands.setContent(html)
+    } catch (err2) {
+      console.error('Fallback also failed:', err2)
+    }
+  } finally {
+    queueMicrotask(() => { suppressChangeRef.current = false })
+  }
+
+  requestAnimationFrame(() => {
+    const scrollEl = document.querySelector('.editor__blocknote-container')
+    if (scrollEl) scrollEl.scrollTop = scrollTop
+  })
+}
+
+function findActiveTab(tabs: Tab[], activeTabPath: string | null): Tab | undefined {
+  return activeTabPath
+    ? tabs.find(tab => tab.entry.path === activeTabPath)
+    : undefined
+}
+
+function useLatestRef<T>(value: T): MutableRefObject<T> {
+  const ref = useRef(value)
+  useEffect(() => {
+    ref.current = value
+  }, [value])
+  return ref
+}
+
+function useEditorMountState(
+  editor: ReturnType<typeof useCreateBlockNote>,
+  editorMountedRef: MutableRefObject<boolean>,
+  pendingSwapRef: MutableRefObject<(() => void) | null>,
+) {
+  useEffect(() => {
+    if (editor.prosemirrorView) {
+      editorMountedRef.current = true
+    }
+    const cleanup = editor.onMount(() => {
+      editorMountedRef.current = true
+      if (pendingSwapRef.current) {
+        const swap = pendingSwapRef.current
+        pendingSwapRef.current = null
+        queueMicrotask(swap)
+      }
+    })
+    return cleanup
+  }, [editor, editorMountedRef, pendingSwapRef])
+}
+
+function useEditorChangeHandler(options: {
+  editor: ReturnType<typeof useCreateBlockNote>
+  tabsRef: MutableRefObject<Tab[]>
+  onContentChangeRef: MutableRefObject<((path: string, content: string) => void) | undefined>
+  prevActivePathRef: MutableRefObject<string | null>
+  suppressChangeRef: MutableRefObject<boolean>
+}) {
+  const {
+    editor,
+    tabsRef,
+    onContentChangeRef,
+    prevActivePathRef,
+    suppressChangeRef,
+  } = options
+
+  return useCallback(() => {
+    if (suppressChangeRef.current) return
+    const path = prevActivePathRef.current
+    if (!path) return
+
+    const tab = tabsRef.current.find(t => t.entry.path === path)
+    if (!tab) return
+
+    const blocks = editor.document
+    const restored = restoreWikilinksInBlocks(blocks)
+    const bodyMarkdown = compactMarkdown(editor.blocksToMarkdownLossy(restored as typeof blocks))
+    const [frontmatter] = splitFrontmatter(tab.content)
+    onContentChangeRef.current?.(path, `${frontmatter}${bodyMarkdown}`)
+  }, [editor, onContentChangeRef, prevActivePathRef, suppressChangeRef, tabsRef])
+}
+
+function consumeRawModeTransition(
+  prevRawModeRef: MutableRefObject<boolean>,
+  rawMode: boolean | undefined,
+) {
+  const rawModeJustEnded = prevRawModeRef.current && !rawMode
+  prevRawModeRef.current = !!rawMode
+  return rawModeJustEnded
+}
+
+function cachePreviousTabOnPathChange(options: {
+  prevPath: string | null
+  pathChanged: boolean
+  editorMountedRef: MutableRefObject<boolean>
+  cache: Map<string, CachedTabState>
+  editor: ReturnType<typeof useCreateBlockNote>
+}) {
+  const { prevPath, pathChanged, editorMountedRef, cache, editor } = options
+  if (!prevPath || !pathChanged || !editorMountedRef.current) return
+  cacheEditorState(cache, prevPath, editor.document)
+}
+
+function rememberPendingTabArrival(
+  activeTabPath: string | null,
+  activeTab: Tab | undefined,
+  pendingTabArrivalPathRef: MutableRefObject<string | null>,
+) {
+  if (!activeTabPath) {
+    pendingTabArrivalPathRef.current = null
+    return false
+  }
+  if (activeTab) {
+    pendingTabArrivalPathRef.current = null
+    return true
+  }
+  pendingTabArrivalPathRef.current = activeTabPath
+  return false
+}
+
+function handleStableActivePath(options: {
+  pathChanged: boolean
+  rawModeJustEnded: boolean
+  activeTabPath: string | null
+  activeTab: Tab | undefined
+  pendingTabArrival: boolean
+  cache: Map<string, CachedTabState>
+  editor: ReturnType<typeof useCreateBlockNote>
+  editorMountedRef: MutableRefObject<boolean>
+  rawSwapPendingRef: MutableRefObject<boolean>
+}) {
+  const {
+    pathChanged,
+    rawModeJustEnded,
+    activeTabPath,
+    activeTab,
+    pendingTabArrival,
+    cache,
+    editor,
+    editorMountedRef,
+    rawSwapPendingRef,
+  } = options
+
+  if (pathChanged) return false
+  if (rawModeJustEnded && activeTabPath) {
+    cache.delete(activeTabPath)
+    rawSwapPendingRef.current = true
+    return false
+  }
+  if (pendingTabArrival) return false
+  if (rawSwapPendingRef.current) return true
+
+  if (activeTabPath && activeTab && editorMountedRef.current) {
+    cacheEditorState(cache, activeTabPath, editor.document)
+  }
+  return true
+}
+
+function scheduleTabSwap(options: {
+  editor: ReturnType<typeof useCreateBlockNote>
+  cache: Map<string, CachedTabState>
+  targetPath: string
+  activeTab: Tab
+  pendingSwapRef: MutableRefObject<(() => void) | null>
+  prevActivePathRef: MutableRefObject<string | null>
+  rawSwapPendingRef: MutableRefObject<boolean>
+  suppressChangeRef: MutableRefObject<boolean>
+}) {
+  const {
+    editor,
+    cache,
+    targetPath,
+    activeTab,
+    pendingSwapRef,
+    prevActivePathRef,
+    rawSwapPendingRef,
+    suppressChangeRef,
+  } = options
+
+  const doSwap = () => {
+    if (prevActivePathRef.current !== targetPath) return
+    rawSwapPendingRef.current = false
+    void resolveBlocksForTarget(editor, cache, targetPath, activeTab.content)
+      .then(({ blocks, scrollTop }) => {
+        if (prevActivePathRef.current !== targetPath) return
+        applyBlocksToEditor(editor, blocks, scrollTop, suppressChangeRef)
+      })
+      .catch((err: unknown) => {
+        console.error('Failed to parse/swap editor content:', err)
+      })
+  }
+
+  if (editor.prosemirrorView) {
+    queueMicrotask(doSwap)
+    return
+  }
+  pendingSwapRef.current = doSwap
+}
+
+function useTabSwapEffect(options: {
+  tabs: Tab[]
+  activeTabPath: string | null
+  editor: ReturnType<typeof useCreateBlockNote>
+  rawMode?: boolean
+  tabCacheRef: MutableRefObject<Map<string, CachedTabState>>
+  prevActivePathRef: MutableRefObject<string | null>
+  editorMountedRef: MutableRefObject<boolean>
+  pendingSwapRef: MutableRefObject<(() => void) | null>
+  pendingTabArrivalPathRef: MutableRefObject<string | null>
+  prevRawModeRef: MutableRefObject<boolean>
+  rawSwapPendingRef: MutableRefObject<boolean>
+  suppressChangeRef: MutableRefObject<boolean>
+}) {
+  const {
+    tabs,
+    activeTabPath,
+    editor,
+    rawMode,
+    tabCacheRef,
+    prevActivePathRef,
+    editorMountedRef,
+    pendingSwapRef,
+    pendingTabArrivalPathRef,
+    prevRawModeRef,
+    rawSwapPendingRef,
+    suppressChangeRef,
+  } = options
+
+  useEffect(() => {
+    const cache = tabCacheRef.current
+    const prevPath = prevActivePathRef.current
+    const pathChanged = prevPath !== activeTabPath
+    const activeTab = findActiveTab(tabs, activeTabPath)
+    const pendingTabArrival = activeTabPath !== null
+      && pendingTabArrivalPathRef.current === activeTabPath
+    const rawModeJustEnded = consumeRawModeTransition(prevRawModeRef, rawMode)
+
+    if (rawMode) return
+    cachePreviousTabOnPathChange({ prevPath, pathChanged, editorMountedRef, cache, editor })
+    prevActivePathRef.current = activeTabPath
+
+    if (handleStableActivePath({
+      pathChanged,
+      rawModeJustEnded,
+      activeTabPath,
+      activeTab,
+      pendingTabArrival,
+      cache,
+      editor,
+      editorMountedRef,
+      rawSwapPendingRef,
+    })) {
+      return
+    }
+
+    if (!rememberPendingTabArrival(activeTabPath, activeTab, pendingTabArrivalPathRef)) {
+      return
+    }
+    const targetPath = activeTabPath
+    const readyActiveTab = activeTab
+    if (!targetPath || !readyActiveTab) return
+
+    scheduleTabSwap({
+      editor,
+      cache,
+      targetPath,
+      activeTab: readyActiveTab,
+      pendingSwapRef,
+      prevActivePathRef,
+      rawSwapPendingRef,
+      suppressChangeRef,
+    })
+  }, [
+    activeTabPath,
+    editor,
+    editorMountedRef,
+    pendingSwapRef,
+    pendingTabArrivalPathRef,
+    prevActivePathRef,
+    prevRawModeRef,
+    rawMode,
+    rawSwapPendingRef,
+    suppressChangeRef,
+    tabCacheRef,
+    tabs,
+  ])
+}
+
+function useTabCacheCleanup(
+  tabs: Tab[],
+  tabCacheRef: MutableRefObject<Map<string, CachedTabState>>,
+) {
+  const tabPathsRef = useRef<Set<string>>(new Set())
+
+  useEffect(() => {
+    const currentPaths = new Set(tabs.map(t => t.entry.path))
+    for (const path of tabPathsRef.current) {
+      if (!currentPaths.has(path)) {
+        tabCacheRef.current.delete(path)
+      }
+    }
+    tabPathsRef.current = currentPaths
+  }, [tabs, tabCacheRef])
+}
+
 /**
  * Manages the tab content-swap machinery for the BlockNote editor.
  *
@@ -59,241 +454,40 @@ export function replaceTitleInFrontmatter(frontmatter: string, newTitle: string)
  * Returns `handleEditorChange`, the onChange callback for SingleEditorView.
  */
 export function useEditorTabSwap({ tabs, activeTabPath, editor, onContentChange, rawMode }: UseEditorTabSwapOptions) {
-  // Cache parsed blocks + scroll position per tab path for instant switching
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any -- BlockNote block arrays
-  const tabCacheRef = useRef<Map<string, { blocks: any[]; scrollTop: number }>>(new Map())
+  const tabCacheRef = useRef<Map<string, CachedTabState>>(new Map())
   const prevActivePathRef = useRef<string | null>(null)
   const editorMountedRef = useRef(false)
   const pendingSwapRef = useRef<(() => void) | null>(null)
+  const pendingTabArrivalPathRef = useRef<string | null>(null)
   const prevRawModeRef = useRef(!!rawMode)
-  // Guard: prevents a subsequent effect run from re-caching stale blocks
-  // while a raw-mode swap is still pending in a microtask/pendingSwap.
   const rawSwapPendingRef = useRef(false)
-
-  // Suppress onChange during programmatic content swaps (tab switching / initial load)
   const suppressChangeRef = useRef(false)
+  const onContentChangeRef = useLatestRef(onContentChange)
+  const tabsRef = useLatestRef(tabs)
+  const handleEditorChange = useEditorChangeHandler({
+    editor,
+    tabsRef,
+    onContentChangeRef,
+    prevActivePathRef,
+    suppressChangeRef,
+  })
 
-  // Keep refs to callbacks for the onChange handler
-  const onContentChangeRef = useRef(onContentChange)
-  onContentChangeRef.current = onContentChange
-  const tabsRef = useRef(tabs)
-  tabsRef.current = tabs
-
-  // Track editor mount state
-  useEffect(() => {
-    // Check if already mounted (prosemirrorView exists)
-    if (editor.prosemirrorView) {
-      editorMountedRef.current = true
-    }
-    const cleanup = editor.onMount(() => {
-      editorMountedRef.current = true
-      // Execute any pending content swap that was queued before mount.
-      // Defer via queueMicrotask so BlockNote's internal flushSync calls
-      // don't collide with React's commit phase.
-      if (pendingSwapRef.current) {
-        const swap = pendingSwapRef.current
-        pendingSwapRef.current = null
-        queueMicrotask(swap)
-      }
-    })
-    return cleanup
-  }, [editor])
-
-  // onChange handler: serialize editor blocks → markdown, reconstruct full file, call save
-  const handleEditorChange = useCallback(() => {
-    if (suppressChangeRef.current) return
-    const path = prevActivePathRef.current
-    if (!path) return
-
-    const tab = tabsRef.current.find(t => t.entry.path === path)
-    if (!tab) return
-
-    // Convert blocks → markdown, restoring wikilinks first
-    const blocks = editor.document
-    const restored = restoreWikilinksInBlocks(blocks)
-    const bodyMarkdown = compactMarkdown(editor.blocksToMarkdownLossy(restored as typeof blocks))
-
-    // Reconstruct full file: frontmatter + body (which now includes H1 if present)
-    const [frontmatter] = splitFrontmatter(tab.content)
-    const fullContent = `${frontmatter}${bodyMarkdown}`
-
-    onContentChangeRef.current?.(path, fullContent)
-  }, [editor])
-
-  // Swap document content when active tab changes.
-  // Uses queueMicrotask to defer BlockNote mutations outside React's commit phase,
-  // avoiding flushSync-inside-lifecycle errors that silently prevent content from rendering.
-  useEffect(() => {
-    const cache = tabCacheRef.current
-    const prevPath = prevActivePathRef.current
-    const pathChanged = prevPath !== activeTabPath
-
-    // Detect raw mode transition: true → false means we need to re-parse
-    // from tab.content since the cached blocks are stale.
-    const rawModeJustEnded = prevRawModeRef.current && !rawMode
-    prevRawModeRef.current = !!rawMode
-
-    // While raw mode is active the BlockNote editor is hidden — skip all
-    // swap logic to avoid touching the invisible editor.
-    if (rawMode) return
-
-    // Save current editor state + scroll position for the tab we're leaving
-    if (prevPath && pathChanged && editorMountedRef.current) {
-      const scrollEl = document.querySelector('.editor__blocknote-container')
-      cache.set(prevPath, {
-        blocks: editor.document,
-        scrollTop: scrollEl?.scrollTop ?? 0,
-      })
-    }
-    prevActivePathRef.current = activeTabPath
-
-    if (!pathChanged) {
-      if (rawModeJustEnded && activeTabPath) {
-        // Raw mode just ended — invalidate stale cached blocks so we
-        // re-parse from the latest tab.content below.
-        cache.delete(activeTabPath)
-        rawSwapPendingRef.current = true
-      } else {
-        // While a raw-mode swap is pending (scheduled via microtask), a second
-        // effect run can fire due to the tabs prop updating.  Skip re-caching
-        // stale editor.document to avoid poisoning the cache before doSwap runs.
-        if (rawSwapPendingRef.current) return
-
-        // When tab content updates but the active tab stays the same (e.g. after
-        // Cmd+S save), refresh the cache with the current editor blocks so a later
-        // tab switch doesn't revert to stale content. Do NOT re-apply blocks —
-        // the editor already shows the user's edits.
-        if (activeTabPath && editorMountedRef.current) {
-          const scrollEl = document.querySelector('.editor__blocknote-container')
-          cache.set(activeTabPath, {
-            blocks: editor.document,
-            scrollTop: scrollEl?.scrollTop ?? 0,
-          })
-        }
-        return
-      }
-    }
-
-    if (!activeTabPath) return
-
-    const tab = tabs.find(t => t.entry.path === activeTabPath)
-    if (!tab) return
-
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any -- BlockNote's PartialBlock generic is extremely complex
-    const applyBlocks = (blocks: any[], scrollTop = 0) => {
-      suppressChangeRef.current = true
-      try {
-        const current = editor.document
-        if (current.length > 0 && blocks.length > 0) {
-          editor.replaceBlocks(current, blocks)
-        } else if (blocks.length > 0) {
-          editor.insertBlocks(blocks, current[0], 'before')
-        }
-      } catch (err) {
-        console.error('applyBlocks failed, trying fallback:', err)
-        try {
-          const html = editor.blocksToHTMLLossy(blocks)
-          editor._tiptapEditor.commands.setContent(html)
-        } catch (err2) {
-          console.error('Fallback also failed:', err2)
-        }
-      } finally {
-        // Re-enable change detection on next microtask, after BlockNote
-        // finishes its internal state updates from the content swap
-        queueMicrotask(() => { suppressChangeRef.current = false })
-      }
-      // Restore scroll position after layout updates from the content swap
-      requestAnimationFrame(() => {
-        const scrollEl = document.querySelector('.editor__blocknote-container')
-        if (scrollEl) scrollEl.scrollTop = scrollTop
-      })
-    }
-
-    const targetPath = activeTabPath
-
-    const doSwap = () => {
-      // Guard: bail if user switched tabs since this swap was scheduled
-      if (prevActivePathRef.current !== targetPath) return
-      rawSwapPendingRef.current = false
-
-      if (cache.has(targetPath)) {
-        const cached = cache.get(targetPath)!
-        applyBlocks(cached.blocks, cached.scrollTop)
-        return
-      }
-
-      const body = extractEditorBody(tab.content)
-      const preprocessed = preProcessWikilinks(body)
-
-      // Fast path: empty body (e.g. newly created notes). Skip the
-      // potentially-async markdown parser and set a single empty paragraph
-      // so the editor is immediately interactive.
-      if (!preprocessed.trim()) {
-        const emptyDoc = [{ type: 'paragraph', content: [] }]
-        cache.set(targetPath, { blocks: emptyDoc, scrollTop: 0 })
-        applyBlocks(emptyDoc)
-        return
-      }
-
-      // Fast path: H1-only content (e.g. newly created notes that just have
-      // the title heading). Build blocks directly to stay instant.
-      const h1OnlyMatch = preprocessed.trim().match(/^# (.+)$/)
-      if (h1OnlyMatch) {
-        const h1Doc = [
-          { type: 'heading', props: { level: 1, textColor: 'default', backgroundColor: 'default', textAlignment: 'left' }, content: [{ type: 'text', text: h1OnlyMatch[1], styles: {} }], children: [] },
-          { type: 'paragraph', content: [], children: [] },
-        ]
-        cache.set(targetPath, { blocks: h1Doc, scrollTop: 0 })
-        applyBlocks(h1Doc)
-        return
-      }
-
-      try {
-        const result = editor.tryParseMarkdownToBlocks(preprocessed)
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any -- BlockNote block arrays
-        const handleBlocks = (blocks: any[]) => {
-          if (prevActivePathRef.current !== targetPath) return
-          const withWikilinks = injectWikilinks(blocks)
-          // Only cache non-empty results to avoid poisoning the cache
-          if (withWikilinks.length > 0) {
-            cache.set(targetPath, { blocks: withWikilinks, scrollTop: 0 })
-          }
-          applyBlocks(withWikilinks)
-        }
-        /* eslint-disable @typescript-eslint/no-explicit-any -- tryParseMarkdownToBlocks returns sync or async BlockNote blocks */
-        if (result && typeof (result as any).then === 'function') {
-          (result as unknown as Promise<any[]>).then(handleBlocks).catch((err: unknown) => {
-            console.error('Async markdown parse failed:', err)
-          })
-        } else {
-          handleBlocks(result as any[])
-        }
-        /* eslint-enable @typescript-eslint/no-explicit-any */
-      } catch (err) {
-        console.error('Failed to parse/swap editor content:', err)
-      }
-    }
-
-    if (editor.prosemirrorView) {
-      // Defer the swap outside React's commit phase so BlockNote's internal
-      // flushSync calls don't collide with React's rendering lifecycle.
-      queueMicrotask(doSwap)
-    } else {
-      pendingSwapRef.current = doSwap
-    }
-  }, [activeTabPath, tabs, editor, rawMode])
-
-  // Clean up cache entries when tabs are closed
-  const tabPathsRef = useRef<Set<string>>(new Set())
-  useEffect(() => {
-    const currentPaths = new Set(tabs.map(t => t.entry.path))
-    for (const path of tabPathsRef.current) {
-      if (!currentPaths.has(path)) {
-        tabCacheRef.current.delete(path)
-      }
-    }
-    tabPathsRef.current = currentPaths
-  }, [tabs])
+  useEditorMountState(editor, editorMountedRef, pendingSwapRef)
+  useTabSwapEffect({
+    tabs,
+    activeTabPath,
+    editor,
+    rawMode,
+    tabCacheRef,
+    prevActivePathRef,
+    editorMountedRef,
+    pendingSwapRef,
+    pendingTabArrivalPathRef,
+    prevRawModeRef,
+    rawSwapPendingRef,
+    suppressChangeRef,
+  })
+  useTabCacheCleanup(tabs, tabCacheRef)
 
   return { handleEditorChange, editorMountedRef }
 }

src/hooks/useNoteActions.hook.test.ts

@@ -641,4 +641,3 @@ describe('useNoteActions hook', () => {
     })
   })
 })
-

src/hooks/useNoteActions.persistence.test.ts

@@ -0,0 +1,58 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest'
+import { renderHook, act } from '@testing-library/react'
+import { useNoteActions, type NoteActionsConfig } from './useNoteActions'
+
+vi.mock('@tauri-apps/api/core', () => ({ invoke: vi.fn() }))
+vi.mock('../mock-tauri', () => ({
+  isTauri: vi.fn(() => false),
+  addMockEntry: vi.fn(),
+  updateMockContent: vi.fn(),
+  trackMockChange: vi.fn(),
+  mockInvoke: vi.fn().mockResolvedValue(''),
+}))
+vi.mock('./mockFrontmatterHelpers', () => ({
+  updateMockFrontmatter: vi.fn().mockReturnValue('---\nupdated: true\n---\n'),
+  deleteMockFrontmatterProperty: vi.fn().mockReturnValue('---\n---\n'),
+}))
+
+function makeConfig(onFrontmatterPersisted: () => void): NoteActionsConfig {
+  return {
+    addEntry: vi.fn(),
+    removeEntry: vi.fn(),
+    entries: [],
+    setToastMessage: vi.fn(),
+    updateEntry: vi.fn(),
+    vaultPath: '/test/vault',
+    onFrontmatterPersisted,
+  }
+}
+
+describe('useNoteActions frontmatter persistence', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+  })
+
+  it.each([
+    {
+      label: 'update',
+      run: async (result: ReturnType<typeof renderHook<typeof useNoteActions>>['result']) => {
+        await result.current.handleUpdateFrontmatter('/vault/note.md', '_list_properties_display', ['Owner', 'Status'])
+      },
+    },
+    {
+      label: 'delete',
+      run: async (result: ReturnType<typeof renderHook<typeof useNoteActions>>['result']) => {
+        await result.current.handleDeleteProperty('/vault/note.md', 'status')
+      },
+    },
+  ])('notifies after a frontmatter $label completes', async ({ run }) => {
+    const onFrontmatterPersisted = vi.fn()
+    const { result } = renderHook(() => useNoteActions(makeConfig(onFrontmatterPersisted)))
+
+    await act(async () => {
+      await run(result)
+    })
+
+    expect(onFrontmatterPersisted).toHaveBeenCalledTimes(1)
+  })
+})

src/hooks/useNoteActions.ts

@@ -27,6 +27,8 @@ export interface NoteActionsConfig {
   replaceEntry?: (oldPath: string, patch: Partial<VaultEntry> & { path: string }) => void
   /** Called after frontmatter is written to disk — used for live-reloading theme CSS vars. */
   onFrontmatterContentChanged?: (path: string, content: string) => void
+  /** Called after a frontmatter mutation is fully persisted, including follow-up renames. */
+  onFrontmatterPersisted?: () => void
 }
 
 function isTitleKey(key: string): boolean {
@@ -44,6 +46,12 @@ interface TitleRenameDeps {
   updateTabContent: (path: string, content: string) => void
 }
 
+function applyFrontmatterCallbacks(config: NoteActionsConfig, path: string, newContent: string | undefined): boolean {
+  if (!newContent) return false
+  config.onFrontmatterContentChanged?.(path, newContent)
+  return true
+}
+
 async function renameAfterTitleChange(path: string, newTitle: string, deps: TitleRenameDeps): Promise<void> {
   const oldTitle = deps.tabsRef.current.find(t => t.entry.path === path)?.entry.title
   const result = await performRename(path, newTitle, deps.vaultPath, oldTitle)
@@ -71,6 +79,20 @@ function navigateWikilink(entries: VaultEntry[], target: string, selectNote: (e:
   else console.warn(`Navigation target not found: ${target}`)
 }
 
+async function maybeRenameAfterFrontmatterUpdate(
+  path: string,
+  key: string,
+  value: FrontmatterValue,
+  deps: TitleRenameDeps,
+): Promise<void> {
+  if (!shouldRenameOnTitleUpdate(key, value)) return
+  try {
+    await renameAfterTitleChange(path, value, deps)
+  } catch (err) {
+    console.error('Failed to rename note after title change:', err)
+  }
+}
+
 export function useNoteActions(config: NoteActionsConfig) {
   const { entries, setToastMessage, updateEntry } = config
   const tabMgmt = useTabManagement()
@@ -108,25 +130,22 @@ export function useNoteActions(config: NoteActionsConfig) {
     createTypeEntrySilent: creation.createTypeEntrySilent,
     handleUpdateFrontmatter: useCallback(async (path: string, key: string, value: FrontmatterValue, options?: FrontmatterOpOptions) => {
       const newContent = await runFrontmatterOp('update', path, key, value, options)
-      if (newContent) config.onFrontmatterContentChanged?.(path, newContent)
-      if (shouldRenameOnTitleUpdate(key, value)) {
-        try {
-          await renameAfterTitleChange(path, value, {
-            vaultPath: config.vaultPath, tabsRef: rename.tabsRef, replaceEntry: config.replaceEntry,
-            setTabs, activeTabPathRef, handleSwitchTab, setToastMessage, updateTabContent,
-          })
-        } catch (err) {
-          console.error('Failed to rename note after title change:', err)
-        }
-      }
+      if (!applyFrontmatterCallbacks(config, path, newContent)) return
+      await maybeRenameAfterFrontmatterUpdate(path, key, value, {
+        vaultPath: config.vaultPath, tabsRef: rename.tabsRef, replaceEntry: config.replaceEntry,
+        setTabs, activeTabPathRef, handleSwitchTab, setToastMessage, updateTabContent,
+      })
+      config.onFrontmatterPersisted?.()
     }, [runFrontmatterOp, config, rename.tabsRef, setTabs, activeTabPathRef, handleSwitchTab, setToastMessage, updateTabContent]),
     handleDeleteProperty: useCallback(async (path: string, key: string, options?: FrontmatterOpOptions) => {
       const newContent = await runFrontmatterOp('delete', path, key, undefined, options)
-      if (newContent) config.onFrontmatterContentChanged?.(path, newContent)
+      if (!applyFrontmatterCallbacks(config, path, newContent)) return
+      config.onFrontmatterPersisted?.()
     }, [runFrontmatterOp, config]),
     handleAddProperty: useCallback(async (path: string, key: string, value: FrontmatterValue) => {
       const newContent = await runFrontmatterOp('update', path, key, value)
-      if (newContent) config.onFrontmatterContentChanged?.(path, newContent)
+      if (!applyFrontmatterCallbacks(config, path, newContent)) return
+      config.onFrontmatterPersisted?.()
     }, [runFrontmatterOp, config]),
     handleRenameNote: rename.handleRenameNote,
   }

src/hooks/useTabManagement.test.ts

@@ -33,6 +33,26 @@ const makeEntry = (overrides: Partial<VaultEntry> = {}): VaultEntry => ({
   ...overrides,
 })
 
+type HookState = { current: ReturnType<typeof useTabManagement> }
+
+async function selectNote(result: HookState, overrides: Partial<VaultEntry>) {
+  await act(async () => {
+    await result.current.handleSelectNote(makeEntry(overrides))
+  })
+}
+
+async function replaceActiveNote(result: HookState, overrides: Partial<VaultEntry>) {
+  await act(async () => {
+    await result.current.handleReplaceActiveTab(makeEntry(overrides))
+  })
+}
+
+function expectSingleActiveTab(result: HookState, path: string) {
+  expect(result.current.tabs).toHaveLength(1)
+  expect(result.current.tabs[0].entry.path).toBe(path)
+  expect(result.current.activeTabPath).toBe(path)
+}
+
 describe('useTabManagement (single-note model)', () => {
   beforeEach(() => {
     vi.clearAllMocks()
@@ -47,41 +67,47 @@ describe('useTabManagement (single-note model)', () => {
   describe('handleSelectNote', () => {
     it('opens a note and sets it active', async () => {
       const { result } = renderHook(() => useTabManagement())
-      const entry = makeEntry({ path: '/vault/note/a.md' })
+      await selectNote(result, { path: '/vault/note/a.md' })
+      expectSingleActiveTab(result, '/vault/note/a.md')
+    })
 
-      await act(async () => {
-        await result.current.handleSelectNote(entry)
+    it('switches the active path immediately while the next note is still loading', async () => {
+      const { mockInvoke } = await import('../mock-tauri')
+
+      let resolveContent: (value: string) => void
+      vi.mocked(mockInvoke).mockImplementationOnce(
+        () => new Promise<string>((resolve) => { resolveContent = resolve }),
+      )
+
+      const { result } = renderHook(() => useTabManagement())
+      void act(() => {
+        void result.current.handleSelectNote(makeEntry({ path: '/vault/note/pending.md', title: 'Pending' }))
       })
 
-      expect(result.current.tabs).toHaveLength(1)
-      expect(result.current.tabs[0].entry.path).toBe('/vault/note/a.md')
-      expect(result.current.activeTabPath).toBe('/vault/note/a.md')
+      expect(result.current.activeTabPath).toBe('/vault/note/pending.md')
+      expect(result.current.tabs).toEqual([])
+
+      await act(async () => {
+        resolveContent!('# Pending content')
+      })
+
+      expect(result.current.tabs[0].entry.path).toBe('/vault/note/pending.md')
+      expect(result.current.tabs[0].content).toBe('# Pending content')
     })
 
     it('replaces the current note when selecting a different one', async () => {
       const { result } = renderHook(() => useTabManagement())
-
-      await act(async () => {
-        await result.current.handleSelectNote(makeEntry({ path: '/vault/a.md', title: 'A' }))
-      })
-      await act(async () => {
-        await result.current.handleSelectNote(makeEntry({ path: '/vault/b.md', title: 'B' }))
-      })
-
-      expect(result.current.tabs).toHaveLength(1)
-      expect(result.current.tabs[0].entry.path).toBe('/vault/b.md')
-      expect(result.current.activeTabPath).toBe('/vault/b.md')
+      await selectNote(result, { path: '/vault/a.md', title: 'A' })
+      await selectNote(result, { path: '/vault/b.md', title: 'B' })
+      expectSingleActiveTab(result, '/vault/b.md')
     })
 
     it('is a no-op when selecting the already-open note', async () => {
       const { result } = renderHook(() => useTabManagement())
-      const entry = makeEntry({ path: '/vault/a.md' })
-
+      const entry = { path: '/vault/a.md' }
+      await selectNote(result, entry)
       await act(async () => {
-        await result.current.handleSelectNote(entry)
-      })
-      await act(async () => {
-        await result.current.handleSelectNote(entry)
+        await result.current.handleSelectNote(makeEntry(entry))
       })
 
       expect(result.current.tabs).toHaveLength(1)
@@ -93,11 +119,7 @@ describe('useTabManagement (single-note model)', () => {
       const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})
 
       const { result } = renderHook(() => useTabManagement())
-      const entry = makeEntry()
-
-      await act(async () => {
-        await result.current.handleSelectNote(entry)
-      })
+      await selectNote(result, {})
 
       expect(result.current.tabs).toHaveLength(1)
       expect(result.current.tabs[0].content).toBe('')
@@ -108,31 +130,17 @@ describe('useTabManagement (single-note model)', () => {
   describe('handleReplaceActiveTab', () => {
     it('replaces the current note with a new entry', async () => {
       const { result } = renderHook(() => useTabManagement())
-
-      await act(async () => {
-        await result.current.handleSelectNote(makeEntry({ path: '/vault/a.md', title: 'A' }))
-      })
-
-      const replacement = makeEntry({ path: '/vault/b.md', title: 'B' })
-      await act(async () => {
-        await result.current.handleReplaceActiveTab(replacement)
-      })
-
-      expect(result.current.tabs).toHaveLength(1)
-      expect(result.current.tabs[0].entry.path).toBe('/vault/b.md')
-      expect(result.current.activeTabPath).toBe('/vault/b.md')
+      await selectNote(result, { path: '/vault/a.md', title: 'A' })
+      await replaceActiveNote(result, { path: '/vault/b.md', title: 'B' })
+      expectSingleActiveTab(result, '/vault/b.md')
     })
 
     it('is a no-op when replacing with the same entry', async () => {
       const { result } = renderHook(() => useTabManagement())
-      const entry = makeEntry({ path: '/vault/a.md' })
-
+      const entry = { path: '/vault/a.md' }
+      await selectNote(result, entry)
       await act(async () => {
-        await result.current.handleSelectNote(entry)
-      })
-
-      await act(async () => {
-        await result.current.handleReplaceActiveTab(entry)
+        await result.current.handleReplaceActiveTab(makeEntry(entry))
       })
 
       expect(result.current.tabs).toHaveLength(1)
@@ -140,14 +148,8 @@ describe('useTabManagement (single-note model)', () => {
 
     it('opens a note when no note is active', async () => {
       const { result } = renderHook(() => useTabManagement())
-      const entry = makeEntry({ path: '/vault/a.md' })
-
-      await act(async () => {
-        await result.current.handleReplaceActiveTab(entry)
-      })
-
-      expect(result.current.tabs).toHaveLength(1)
-      expect(result.current.activeTabPath).toBe('/vault/a.md')
+      await replaceActiveNote(result, { path: '/vault/a.md' })
+      expectSingleActiveTab(result, '/vault/a.md')
     })
   })
 
@@ -189,10 +191,7 @@ describe('useTabManagement (single-note model)', () => {
   describe('closeAllTabs', () => {
     it('clears the note and active path', async () => {
       const { result } = renderHook(() => useTabManagement())
-
-      await act(async () => {
-        await result.current.handleSelectNote(makeEntry({ path: '/vault/a.md' }))
-      })
+      await selectNote(result, { path: '/vault/a.md' })
 
       act(() => {
         result.current.closeAllTabs()
@@ -212,9 +211,7 @@ describe('useTabManagement (single-note model)', () => {
       await vi.waitFor(() => expect(vi.mocked(mockInvoke)).toHaveBeenCalledTimes(1))
 
       const { result } = renderHook(() => useTabManagement())
-      await act(async () => {
-        await result.current.handleSelectNote(makeEntry({ path: '/vault/note/pre.md', title: 'Pre' }))
-      })
+      await selectNote(result, { path: '/vault/note/pre.md', title: 'Pre' })
 
       expect(result.current.tabs[0].content).toBe('# Prefetched content')
       expect(vi.mocked(mockInvoke)).toHaveBeenCalledTimes(1)
@@ -231,9 +228,7 @@ describe('useTabManagement (single-note model)', () => {
       vi.mocked(mockInvoke).mockResolvedValue('# Fresh')
 
       const { result } = renderHook(() => useTabManagement())
-      await act(async () => {
-        await result.current.handleSelectNote(makeEntry({ path: '/vault/note/stale.md', title: 'Stale' }))
-      })
+      await selectNote(result, { path: '/vault/note/stale.md', title: 'Stale' })
 
       expect(result.current.tabs[0].content).toBe('# Fresh')
       expect(vi.mocked(mockInvoke)).toHaveBeenCalledTimes(2)

src/hooks/useTabManagement.ts

@@ -49,6 +49,69 @@ async function loadNoteContent(path: string): Promise<string> {
 
 export type { Tab }
 
+function syncActiveTabPath(
+  activeTabPathRef: React.MutableRefObject<string | null>,
+  setActiveTabPath: React.Dispatch<React.SetStateAction<string | null>>,
+  path: string | null,
+) {
+  activeTabPathRef.current = path
+  setActiveTabPath(path)
+}
+
+function setSingleTab(
+  tabsRef: React.MutableRefObject<Tab[]>,
+  setTabs: React.Dispatch<React.SetStateAction<Tab[]>>,
+  nextTab: Tab,
+) {
+  tabsRef.current = [nextTab]
+  setTabs([nextTab])
+}
+
+function isAlreadyViewingPath(
+  tabsRef: React.MutableRefObject<Tab[]>,
+  activeTabPathRef: React.MutableRefObject<string | null>,
+  path: string,
+) {
+  return activeTabPathRef.current === path || tabsRef.current.some((tab) => tab.entry.path === path)
+}
+
+async function navigateToEntry(options: {
+  entry: VaultEntry
+  navSeqRef: React.MutableRefObject<number>
+  tabsRef: React.MutableRefObject<Tab[]>
+  activeTabPathRef: React.MutableRefObject<string | null>
+  setTabs: React.Dispatch<React.SetStateAction<Tab[]>>
+  setActiveTabPath: React.Dispatch<React.SetStateAction<string | null>>
+}) {
+  const {
+    entry,
+    navSeqRef,
+    tabsRef,
+    activeTabPathRef,
+    setTabs,
+    setActiveTabPath,
+  } = options
+
+  if (entry.fileKind === 'binary') return
+  if (isAlreadyViewingPath(tabsRef, activeTabPathRef, entry.path)) {
+    syncActiveTabPath(activeTabPathRef, setActiveTabPath, entry.path)
+    return
+  }
+
+  const seq = ++navSeqRef.current
+  syncActiveTabPath(activeTabPathRef, setActiveTabPath, entry.path)
+
+  try {
+    const content = await loadNoteContent(entry.path)
+    if (navSeqRef.current !== seq) return
+    setSingleTab(tabsRef, setTabs, { entry, content })
+  } catch (err) {
+    console.warn('Failed to load note content:', err)
+    if (navSeqRef.current !== seq) return
+    setSingleTab(tabsRef, setTabs, { entry, content: '' })
+  }
+}
+
 export function useTabManagement() {
   // Single-note model: tabs has 0 or 1 elements.
   const [tabs, setTabs] = useState<Tab[]>([])
@@ -63,64 +126,41 @@ export function useTabManagement() {
 
   /** Open a note — replaces the current note (single-note model). */
   const handleSelectNote = useCallback(async (entry: VaultEntry) => {
-    // Binary files cannot be opened
-    if (entry.fileKind === 'binary') return
-    // Already viewing this note — no-op
-    if (tabsRef.current.some(t => t.entry.path === entry.path)) {
-      setActiveTabPath(entry.path)
-      return
-    }
-    const seq = ++navSeqRef.current
-    try {
-      const content = await loadNoteContent(entry.path)
-      if (navSeqRef.current === seq) {
-        setTabs([{ entry, content }])
-        setActiveTabPath(entry.path)
-      }
-    } catch (err) {
-      console.warn('Failed to load note content:', err)
-      if (navSeqRef.current === seq) {
-        setTabs([{ entry, content: '' }])
-        setActiveTabPath(entry.path)
-      }
-    }
+    await navigateToEntry({
+      entry,
+      navSeqRef,
+      tabsRef,
+      activeTabPathRef,
+      setTabs,
+      setActiveTabPath,
+    })
   }, [])
 
-  const handleSwitchTab = useCallback((path: string) => { setActiveTabPath(path) }, [])
+  const handleSwitchTab = useCallback((path: string) => {
+    syncActiveTabPath(activeTabPathRef, setActiveTabPath, path)
+  }, [])
 
   /** Open a tab with known content — no IPC round-trip. Used for newly created notes. */
   const openTabWithContent = useCallback((entry: VaultEntry, content: string) => {
-    setTabs([{ entry, content }])
-    setActiveTabPath(entry.path)
+    setSingleTab(tabsRef, setTabs, { entry, content })
+    syncActiveTabPath(activeTabPathRef, setActiveTabPath, entry.path)
   }, [])
 
   const handleReplaceActiveTab = useCallback(async (entry: VaultEntry) => {
-    // Binary files cannot be opened
-    if (entry.fileKind === 'binary') return
-    // In single-note model, replace is the same as select
-    if (tabsRef.current.some(t => t.entry.path === entry.path)) {
-      setActiveTabPath(entry.path)
-      return
-    }
-    const seq = ++navSeqRef.current
-    try {
-      const content = await loadNoteContent(entry.path)
-      if (navSeqRef.current === seq) {
-        setTabs([{ entry, content }])
-        setActiveTabPath(entry.path)
-      }
-    } catch (err) {
-      console.warn('Failed to load note content:', err)
-      if (navSeqRef.current === seq) {
-        setTabs([{ entry, content: '' }])
-        setActiveTabPath(entry.path)
-      }
-    }
+    await navigateToEntry({
+      entry,
+      navSeqRef,
+      tabsRef,
+      activeTabPathRef,
+      setTabs,
+      setActiveTabPath,
+    })
   }, [])
 
   const closeAllTabs = useCallback(() => {
+    tabsRef.current = []
     setTabs([])
-    setActiveTabPath(null)
+    syncActiveTabPath(activeTabPathRef, setActiveTabPath, null)
   }, [])
 
   return {

src/utils/noteTitle.test.ts

@@ -1,5 +1,11 @@
 import { describe, expect, it } from 'vitest'
-import { deriveDisplayTitleState, extractH1TitleFromContent, filenameStemToTitle } from './noteTitle'
+import {
+  contentDefinesDisplayTitle,
+  deriveDisplayTitleState,
+  extractFrontmatterTitleFromContent,
+  extractH1TitleFromContent,
+  filenameStemToTitle,
+} from './noteTitle'
 
 describe('filenameStemToTitle', () => {
   it('converts kebab-case filenames into title case', () => {
@@ -23,10 +29,32 @@ describe('extractH1TitleFromContent', () => {
   })
 })
 
+describe('extractFrontmatterTitleFromContent', () => {
+  it('extracts the frontmatter title when present', () => {
+    const content = '---\ntitle: Legacy Title\nstatus: Active\n---\n## Body'
+    expect(extractFrontmatterTitleFromContent(content)).toBe('Legacy Title')
+  })
+
+  it('returns null when the frontmatter title is missing', () => {
+    expect(extractFrontmatterTitleFromContent('---\nstatus: Active\n---\n## Body')).toBeNull()
+  })
+})
+
+describe('contentDefinesDisplayTitle', () => {
+  it('returns true when the document title comes from frontmatter', () => {
+    const content = '---\ntitle: Spring 2026\n---\n## Goals'
+    expect(contentDefinesDisplayTitle(content)).toBe(true)
+  })
+
+  it('returns false when title still comes from the filename', () => {
+    expect(contentDefinesDisplayTitle('Body only')).toBe(false)
+  })
+})
+
 describe('deriveDisplayTitleState', () => {
   it('prefers H1 over frontmatter title and filename', () => {
     const content = '---\ntitle: Legacy Title\n---\n# Updated Title\n\nBody'
-    expect(deriveDisplayTitleState(content, 'legacy-title.md', 'Legacy Title')).toEqual({
+    expect(deriveDisplayTitleState({ content, filename: 'legacy-title.md', frontmatterTitle: 'Legacy Title' })).toEqual({
       title: 'Updated Title',
       hasH1: true,
     })
@@ -34,14 +62,22 @@ describe('deriveDisplayTitleState', () => {
 
   it('falls back to frontmatter title when no H1 is present', () => {
     const content = '---\ntitle: Legacy Title\n---\nBody'
-    expect(deriveDisplayTitleState(content, 'legacy-title.md', 'Legacy Title')).toEqual({
+    expect(deriveDisplayTitleState({ content, filename: 'legacy-title.md', frontmatterTitle: 'Legacy Title' })).toEqual({
       title: 'Legacy Title',
       hasH1: false,
     })
   })
 
+  it('reads the frontmatter title from content when no explicit title is passed', () => {
+    const content = '---\ntitle: Spring 2026\n---\n## Goals'
+    expect(deriveDisplayTitleState({ content, filename: 'spring-2026.md' })).toEqual({
+      title: 'Spring 2026',
+      hasH1: false,
+    })
+  })
+
   it('falls back to filename title when there is no H1 or frontmatter title', () => {
-    expect(deriveDisplayTitleState('Body only', 'renamed-note.md')).toEqual({
+    expect(deriveDisplayTitleState({ content: 'Body only', filename: 'renamed-note.md' })).toEqual({
       title: 'Renamed Note',
       hasH1: false,
     })

src/utils/noteTitle.ts

@@ -1,5 +1,22 @@
+import { parseFrontmatter } from './frontmatter'
 import { splitFrontmatter } from './wikilinks'
 
+interface ResolvedContentTitle {
+  source: 'h1' | 'frontmatter'
+  title: string
+}
+
+interface DisplayTitleInput {
+  content: string
+  filename: string
+  frontmatterTitle?: string | null
+}
+
+interface DisplayTitleState {
+  title: string
+  hasH1: boolean
+}
+
 function replaceWikilinkAliases(text: string): string {
   return text.replace(/\[\[[^|\]]+\|([^\]]+)\]\]/g, '$1')
 }
@@ -49,20 +66,46 @@ export function extractH1TitleFromContent(content: string): string | null {
   return null
 }
 
-export function deriveDisplayTitleState(
-  content: string,
-  filename: string,
-  frontmatterTitle?: string | null,
-): { title: string, hasH1: boolean } {
+export function extractFrontmatterTitleFromContent(content: string): string | null {
+  const title = parseFrontmatter(content).title
+  if (typeof title !== 'string') return null
+  const trimmed = title.trim()
+  return trimmed || null
+}
+
+function resolveContentTitle(content: string, frontmatterTitle?: string | null): ResolvedContentTitle | null {
   const h1Title = extractH1TitleFromContent(content)
   if (h1Title) {
-    return { title: h1Title, hasH1: true }
+    return { title: h1Title, source: 'h1' }
   }
 
-  const trimmedFrontmatterTitle = frontmatterTitle?.trim()
-  if (trimmedFrontmatterTitle) {
-    return { title: trimmedFrontmatterTitle, hasH1: false }
+  const resolvedFrontmatterTitle = frontmatterTitle?.trim() || extractFrontmatterTitleFromContent(content)
+  if (resolvedFrontmatterTitle) {
+    return { title: resolvedFrontmatterTitle, source: 'frontmatter' }
   }
 
-  return { title: filenameStemToTitle(filename), hasH1: false }
+  return null
+}
+
+export function contentDefinesDisplayTitle(content: string): boolean {
+  return resolveContentTitle(content) !== null
+}
+
+export function deriveDisplayTitleState({
+  content,
+  filename,
+  frontmatterTitle,
+}: DisplayTitleInput): DisplayTitleState {
+  const resolvedTitle = resolveContentTitle(content, frontmatterTitle)
+  if (resolvedTitle) {
+    return {
+      title: resolvedTitle.title,
+      hasH1: resolvedTitle.source === 'h1',
+    }
+  }
+
+  return {
+    title: filenameStemToTitle(filename),
+    hasH1: false,
+  }
 }

tests/fixtures/test-vault/quarter/spring-2026.md

@@ -0,0 +1,10 @@
+---
+title: Spring 2026
+Is A: Quarter
+Status: Active
+---
+
+## Goals
+
+- [[Alpha Project]]
+- [[Note B]]

tests/smoke/ai-panel-shortcut.spec.ts

@@ -8,9 +8,10 @@ test.describe('AI panel shortcut', () => {
     await expect(page.locator('[data-testid="note-list-container"]')).toBeVisible({ timeout: 5_000 })
   })
 
-  test('Cmd/Ctrl+Shift+L opens the AI panel', async ({ page }) => {
+  test('Cmd+Shift+L opens the AI panel from the editor', async ({ page }) => {
     await page.locator('.app__note-list .cursor-pointer').first().click()
-    await sendShortcut(page, 'L', ['Control', 'Shift'])
+    await page.locator('.bn-editor').click()
+    await sendShortcut(page, 'L', ['Meta', 'Shift'])
     await expect(page.getByTestId('ai-panel')).toBeVisible({ timeout: 3_000 })
     await expect(page.getByTitle('Close AI panel')).toBeVisible()
   })

tests/smoke/h1-title-decoupled.spec.ts

@@ -69,12 +69,17 @@ test('creating an untitled draft hides the legacy title section in the editor',
   await expect(page.locator('.title-section[data-title-ui-visible]')).toHaveCount(0)
 })
 
-test('@smoke older notes with an H1 do not render the legacy title section', async ({ page }) => {
+test('@smoke older notes with a document title do not render the legacy title section', async ({ page }) => {
   await openNote(page, 'Alpha Project')
 
   await expect(page.locator('.bn-editor')).toBeVisible({ timeout: 5_000 })
   await expect(page.getByTestId('title-field-input')).toHaveCount(0)
   await expect(page.locator('.title-section[data-title-ui-visible]')).toHaveCount(0)
+
+  await openNote(page, 'Spring 2026')
+  await expect(page.locator('.bn-editor')).toBeVisible({ timeout: 5_000 })
+  await expect(page.getByTestId('title-field-input')).toHaveCount(0)
+  await expect(page.locator('.title-section[data-title-ui-visible]')).toHaveCount(0)
 })
 
 test('@smoke edited H1 titles drive note list, search, and wikilink autocomplete', async ({ page }) => {