fix: preserve image toolbar hover bridge

docs/ARCHITECTURE.md

@@ -578,7 +578,7 @@ The vault backend (`src-tauri/src/vault/`) is split into focused submodules:
 | `rename.rs` | `rename_note` — renames files, updates `title` frontmatter, and updates wikilinks across the vault |
 | `image.rs` | `save_image` — saves base64-encoded attachments with sanitized filenames |
 | `migration.rs` | `flatten_vault`, `vault_health_check`, `migrate_is_a_to_type` |
-| `config_seed.rs` | Maintains vault AI guidance (`AGENTS.md` + `CLAUDE.md` shim), migrates legacy `config/agents.md`, repairs missing config files |
+| `config_seed.rs` | Maintains vault AI guidance (`AGENTS.md` + `CLAUDE.md` shim), migrates legacy `config/agents.md`, repairs missing root config/type files such as `config.md` and `note.md` |
 | `getting_started.rs` | Creates the Getting Started demo vault |
 
 ## Rust Backend Modules
@@ -615,7 +615,7 @@ The vault backend (`src-tauri/src/vault/`) is split into focused submodules:
 | `reload_vault` | Invalidate cache and full rescan from filesystem → `Vec<VaultEntry>` |
 | `reload_vault_entry` | Re-read a single file from disk → `VaultEntry` |
 | `check_vault_exists` | Check if vault path exists |
-| `create_empty_vault` | Create a git-backed vault, then seed root `AGENTS.md`, `CLAUDE.md`, and `config.md` defaults |
+| `create_empty_vault` | Create a git-backed vault, then seed root `AGENTS.md`, `CLAUDE.md`, `config.md`, and `note.md` defaults |
 | `create_getting_started_vault` | Clone the public Getting Started vault, refresh Tolaria-managed guidance/config defaults, and keep the cloned repo clean |
 | `get_vault_ai_guidance_status` | Report whether `AGENTS.md` and the `CLAUDE.md` shim are managed, missing, broken, or custom |
 | `restore_vault_ai_guidance` | Restore any missing/broken Tolaria-managed guidance files without overwriting custom ones |
@@ -659,7 +659,7 @@ The vault backend (`src-tauri/src/vault/`) is split into focused submodules:
 |---------|-------------|
 | `get_vault_settings` | Read `.laputa/settings.json` |
 | `save_vault_settings` | Write vault settings |
-| `repair_vault` | Flatten vault structure, migrate legacy frontmatter, restore config |
+| `repair_vault` | Flatten vault structure, migrate legacy frontmatter, restore root config/type defaults including `note.md` |
 
 ### AI & MCP
 

src-tauri/src/vault/config_seed.rs

@@ -19,6 +19,17 @@ sidebar label: Config
 Vault configuration files. These control how AI agents, tools, and other integrations interact with this vault.
 ";
 
+/// Content for `note.md` — restores the default Note type definition when missing.
+const NOTE_TYPE_DEFINITION: &str = "\
+---
+type: Type
+---
+
+# Note
+
+A Note is a general-purpose document — research notes, meeting notes, strategy docs, or anything that doesn't fit a more specific type.
+";
+
 const CLAUDE_MD_SHIM: &str = "@AGENTS.md
 
 This file is a Claude Code compatibility shim. Keep shared agent instructions in `AGENTS.md`.
@@ -113,8 +124,8 @@ fn classify_guidance_file(
     AiGuidanceFileState::Custom
 }
 
-fn guidance_paths(vault_path: &str) -> (PathBuf, PathBuf) {
-    let vault = Path::new(vault_path);
+fn guidance_paths(vault_path: &Path) -> (PathBuf, PathBuf) {
+    let vault = vault_path;
     (vault.join("AGENTS.md"), vault.join("CLAUDE.md"))
 }
 
@@ -137,7 +148,7 @@ fn guidance_file_needs_restore(state: AiGuidanceFileState) -> bool {
     )
 }
 
-fn build_ai_guidance_status(vault_path: &str) -> VaultAiGuidanceStatus {
+fn build_ai_guidance_status(vault_path: &Path) -> VaultAiGuidanceStatus {
     let (agents_path, claude_path) = guidance_paths(vault_path);
     let agents_state = classify_agents_file(&agents_path);
     let claude_state = classify_claude_file(&claude_path);
@@ -150,12 +161,12 @@ fn build_ai_guidance_status(vault_path: &str) -> VaultAiGuidanceStatus {
     }
 }
 
-fn sync_claude_shim_file(vault_path: &str) -> Result<bool, String> {
+fn sync_claude_shim_file(vault_path: &Path) -> Result<bool, String> {
     let (_, claude_path) = guidance_paths(vault_path);
     sync_managed_file(&claude_path, CLAUDE_MD_SHIM, claude_shim_can_be_replaced)
 }
 
-fn sync_ai_guidance_files(vault_path: &str) -> Result<bool, String> {
+fn sync_ai_guidance_files(vault_path: &Path) -> Result<bool, String> {
     let wrote_agents = sync_default_agents_file(vault_path)?;
     let wrote_claude = sync_claude_shim_file(vault_path)?;
     Ok(wrote_agents || wrote_claude)
@@ -203,34 +214,45 @@ fn cleanup_empty_config_dir(vault: &Path) -> Result<bool, String> {
     Ok(true)
 }
 
-pub(super) fn sync_default_agents_file(vault_path: &str) -> Result<bool, String> {
+pub(super) fn sync_default_agents_file(vault_path: &Path) -> Result<bool, String> {
     let (agents_path, _) = guidance_paths(vault_path);
     sync_managed_file(&agents_path, AGENTS_MD, root_agents_can_be_replaced)
 }
 
-pub fn get_ai_guidance_status(vault_path: &str) -> Result<VaultAiGuidanceStatus, String> {
+pub fn get_ai_guidance_status(
+    vault_path: impl AsRef<str>,
+) -> Result<VaultAiGuidanceStatus, String> {
+    Ok(build_ai_guidance_status(Path::new(vault_path.as_ref())))
+}
+
+pub fn restore_ai_guidance_files(
+    vault_path: impl AsRef<str>,
+) -> Result<VaultAiGuidanceStatus, String> {
+    let vault_path = Path::new(vault_path.as_ref());
+    sync_ai_guidance_files(vault_path)?;
     Ok(build_ai_guidance_status(vault_path))
 }
 
-pub fn restore_ai_guidance_files(vault_path: &str) -> Result<VaultAiGuidanceStatus, String> {
-    sync_ai_guidance_files(vault_path)?;
-    get_ai_guidance_status(vault_path)
-}
-
 /// Seed `AGENTS.md` at vault root if missing or empty (idempotent, per-file).
-/// Also seeds `config.md` type definition for sidebar visibility.
-pub fn seed_config_files(vault_path: &str) {
+/// Also seeds Tolaria-managed root type definitions used by repair/bootstrap flows.
+pub fn seed_config_files(vault_path: impl AsRef<str>) {
+    let vault_path = Path::new(vault_path.as_ref());
     if sync_ai_guidance_files(vault_path).unwrap_or(false) {
         log::info!("Seeded vault AI guidance files at vault root");
     }
 
-    ensure_config_type_definition(vault_path);
+    ensure_root_type_definitions(vault_path);
 }
 
-/// Ensure `config.md` exists at vault root (gives Config type a sidebar icon/color).
-fn ensure_config_type_definition(vault_path: &str) {
-    let path = Path::new(vault_path).join("config.md");
-    let _ = write_if_missing(&path, CONFIG_TYPE_DEFINITION);
+fn ensure_root_type_definition(vault_path: &Path, file_name: &str, content: &str) {
+    let path = vault_path.join(file_name);
+    let _ = write_if_missing(&path, content);
+}
+
+/// Ensure the default root type definitions exist for opened/repaired vaults.
+fn ensure_root_type_definitions(vault_path: &Path) {
+    ensure_root_type_definition(vault_path, "config.md", CONFIG_TYPE_DEFINITION);
+    ensure_root_type_definition(vault_path, "note.md", NOTE_TYPE_DEFINITION);
 }
 
 /// Migrate legacy `config/agents.md` → root `AGENTS.md` for existing vaults.
@@ -241,8 +263,8 @@ fn ensure_config_type_definition(vault_path: &str) {
 /// - Cleans up empty `config/` directory after migration.
 ///
 /// Always idempotent and silent.
-pub fn migrate_agents_md(vault_path: &str) {
-    let vault = Path::new(vault_path);
+pub fn migrate_agents_md(vault_path: impl AsRef<str>) {
+    let vault = Path::new(vault_path.as_ref());
     let root_agents = vault.join("AGENTS.md");
     let config_agents = vault.join("config").join("agents.md");
 
@@ -259,22 +281,23 @@ pub fn migrate_agents_md(vault_path: &str) {
         log::info!("Removed empty config/ directory");
     }
 
-    let _ = sync_ai_guidance_files(vault_path);
+    let _ = sync_ai_guidance_files(vault);
 }
 
-/// Repair config files: ensure `AGENTS.md` at vault root and `config.md` type definition.
+/// Repair config files: ensure `AGENTS.md` at vault root and root type definitions.
 /// Migrates legacy `config/agents.md` to root if present.
 /// Called by the "Repair Vault" command. Returns a status message.
-pub fn repair_config_files(vault_path: &str) -> Result<String, String> {
-    let vault = Path::new(vault_path);
+pub fn repair_config_files(vault_path: impl AsRef<str>) -> Result<String, String> {
+    let vault = Path::new(vault_path.as_ref());
     let root_agents = vault.join("AGENTS.md");
     let config_agents = vault.join("config").join("agents.md");
 
     migrate_legacy_agents_file(&root_agents, &config_agents)?;
     let _ = cleanup_empty_config_dir(vault)?;
-    sync_ai_guidance_files(vault_path)?;
+    sync_ai_guidance_files(vault)?;
 
     write_if_missing(&vault.join("config.md"), CONFIG_TYPE_DEFINITION)?;
+    write_if_missing(&vault.join("note.md"), NOTE_TYPE_DEFINITION)?;
 
     Ok("Config files repaired".to_string())
 }
@@ -417,15 +440,19 @@ mod tests {
     }
 
     #[test]
-    fn test_seed_config_files_creates_type_definition() {
+    fn test_seed_config_files_creates_type_definitions() {
         let (_dir, vault) = create_vault();
 
         seed_config_files(vault.to_str().unwrap());
 
         assert!(vault.join("config.md").exists());
-        let content = fs::read_to_string(vault.join("config.md")).unwrap();
-        assert!(content.contains("type: Type"));
-        assert!(content.contains("icon: gear-six"));
+        assert!(vault.join("note.md").exists());
+        let config_content = fs::read_to_string(vault.join("config.md")).unwrap();
+        let note_content = fs::read_to_string(vault.join("note.md")).unwrap();
+        assert!(config_content.contains("type: Type"));
+        assert!(config_content.contains("icon: gear-six"));
+        assert!(note_content.contains("type: Type"));
+        assert!(note_content.contains("# Note"));
         assert!(!vault.join("config").exists());
     }
 
@@ -543,10 +570,14 @@ mod tests {
         assert!(vault.join("AGENTS.md").exists());
         assert!(vault.join("CLAUDE.md").exists());
         assert!(vault.join("config.md").exists());
+        assert!(vault.join("note.md").exists());
         assert!(!vault.join("config").exists());
 
         let agents = read_root_agents(&vault);
         assert!(agents.contains("Tolaria Vault"));
+        let note_content = fs::read_to_string(vault.join("note.md")).unwrap();
+        assert!(note_content.contains("type: Type"));
+        assert!(note_content.contains("general-purpose document"));
     }
 
     #[test]

src/App.tsx

@@ -35,6 +35,7 @@ import { useGitRemoteStatus } from './hooks/useGitRemoteStatus'
 import { useViewMode, type ViewMode } from './hooks/useViewMode'
 import { useEntryActions } from './hooks/useEntryActions'
 import { useAppCommands } from './hooks/useAppCommands'
+import { triggerCommitEntryAction } from './utils/commitEntryAction'
 import { generateCommitMessage } from './utils/commitMessage'
 import { useDialogs } from './hooks/useDialogs'
 import { useVaultSwitcher } from './hooks/useVaultSwitcher'
@@ -660,6 +661,7 @@ function App() {
     onCheckpoint: () => commitFlow.runAutomaticCheckpoint(),
   })
   const recordAutoGitActivity = autoGit.recordActivity
+  const openCommitDialog = commitFlow.openCommitDialog
   const runAutomaticCheckpoint = commitFlow.runAutomaticCheckpoint
   const handleAppContentChange = appSave.handleContentChange
   const handleAppSave = appSave.handleSave
@@ -670,9 +672,13 @@ function App() {
     recordAutoGitActivity()
   }, [modifiedFilesSignature, recordAutoGitActivity])
 
-  const handleQuickCommitPush = useCallback(() => {
-    void runAutomaticCheckpoint({ savePendingBeforeCommit: true })
-  }, [runAutomaticCheckpoint])
+  const handleCommitPush = useCallback(() => {
+    triggerCommitEntryAction({
+      autoGitEnabled: settings.autogit_enabled === true,
+      openCommitDialog,
+      runAutomaticCheckpoint,
+    })
+  }, [openCommitDialog, runAutomaticCheckpoint, settings.autogit_enabled])
 
   const handleTrackedContentChange = useCallback((path: string, content: string) => {
     recordAutoGitActivity()
@@ -953,7 +959,7 @@ function App() {
     onOpenFeedback: openFeedback,
     onDeleteNote: deleteActions.handleDeleteNote,
     onArchiveNote: entryActions.handleArchiveNote, onUnarchiveNote: entryActions.handleUnarchiveNote,
-    onCommitPush: commitFlow.openCommitDialog,
+    onCommitPush: handleCommitPush,
     onPull: autoSync.triggerSync,
     onResolveConflicts: conflictFlow.handleOpenConflictResolver,
     onSetViewMode: handleSetViewMode,
@@ -1174,7 +1180,7 @@ function App() {
       </div>
       <UpdateBanner status={updateStatus} actions={updateActions} />
       <RenameDetectedBanner renames={detectedRenames} onUpdate={handleUpdateWikilinks} onDismiss={handleDismissRenames} />
-      <StatusBar noteCount={vault.entries.length} modifiedCount={vault.modifiedFiles.length} vaultPath={resolvedPath} vaults={vaultSwitcher.allVaults} onSwitchVault={vaultSwitcher.switchVault} onOpenSettings={dialogs.openSettings} onOpenFeedback={openFeedback} onOpenLocalFolder={vaultSwitcher.handleOpenLocalFolder} onCloneVault={dialogs.openCloneVault} onCloneGettingStarted={cloneGettingStartedVault} onClickPending={() => handleSetSelection({ kind: 'filter', filter: 'changes' })} onClickPulse={() => handleSetSelection({ kind: 'filter', filter: 'pulse' })} onCommitPush={handleQuickCommitPush} isOffline={networkStatus.isOffline} isGitVault={isGitVault} syncStatus={autoSync.syncStatus} lastSyncTime={autoSync.lastSyncTime} conflictCount={autoSync.conflictFiles.length} remoteStatus={autoSync.remoteStatus} onTriggerSync={autoSync.triggerSync} onPullAndPush={autoSync.pullAndPush} onOpenConflictResolver={conflictFlow.handleOpenConflictResolver} zoomLevel={zoom.zoomLevel} onZoomReset={zoom.zoomReset} buildNumber={buildNumber} onCheckForUpdates={handleCheckForUpdates} onRemoveVault={vaultSwitcher.removeVault} mcpStatus={mcpStatus} onInstallMcp={installMcp} aiAgentsStatus={aiAgentsStatus} vaultAiGuidanceStatus={vaultAiGuidanceStatus} defaultAiAgent={aiAgentPreferences.defaultAiAgent} onSetDefaultAiAgent={aiAgentPreferences.setDefaultAiAgent} onRestoreVaultAiGuidance={() => { void restoreVaultAiGuidance() }} />
+      <StatusBar noteCount={vault.entries.length} modifiedCount={vault.modifiedFiles.length} vaultPath={resolvedPath} vaults={vaultSwitcher.allVaults} onSwitchVault={vaultSwitcher.switchVault} onOpenSettings={dialogs.openSettings} onOpenFeedback={openFeedback} onOpenLocalFolder={vaultSwitcher.handleOpenLocalFolder} onCloneVault={dialogs.openCloneVault} onCloneGettingStarted={cloneGettingStartedVault} onClickPending={() => handleSetSelection({ kind: 'filter', filter: 'changes' })} onClickPulse={() => handleSetSelection({ kind: 'filter', filter: 'pulse' })} onCommitPush={handleCommitPush} isOffline={networkStatus.isOffline} isGitVault={isGitVault} syncStatus={autoSync.syncStatus} lastSyncTime={autoSync.lastSyncTime} conflictCount={autoSync.conflictFiles.length} remoteStatus={autoSync.remoteStatus} onTriggerSync={autoSync.triggerSync} onPullAndPush={autoSync.pullAndPush} onOpenConflictResolver={conflictFlow.handleOpenConflictResolver} zoomLevel={zoom.zoomLevel} onZoomReset={zoom.zoomReset} buildNumber={buildNumber} onCheckForUpdates={handleCheckForUpdates} onRemoveVault={vaultSwitcher.removeVault} mcpStatus={mcpStatus} onInstallMcp={installMcp} aiAgentsStatus={aiAgentsStatus} vaultAiGuidanceStatus={vaultAiGuidanceStatus} defaultAiAgent={aiAgentPreferences.defaultAiAgent} onSetDefaultAiAgent={aiAgentPreferences.setDefaultAiAgent} onRestoreVaultAiGuidance={() => { void restoreVaultAiGuidance() }} />
       <DeleteProgressNotice count={deleteActions.pendingDeleteCount} />
       <Toast message={toastMessage} onDismiss={() => setToastMessage(null)} />
       <QuickOpenPalette open={dialogs.showQuickOpen} entries={vault.entries} onSelect={notes.handleSelectNote} onClose={dialogs.closeQuickOpen} />

src/components/Editor.test.tsx

@@ -658,7 +658,7 @@ describe('wikilink autocomplete', () => {
     mockFilterSuggestionItems.mockImplementation((items: unknown[]) => items)
   })
 
-  it('shows correct noteType and color for typed entries, neutral for untyped', async () => {
+  it('shows Note chips and icons for explicit Note entries while keeping untyped entries neutral', async () => {
     const mixedEntries: VaultEntry[] = [
       { ...mockEntry, title: 'Test Project', filename: 'proj.md', path: '/vault/proj.md', isA: 'Project', aliases: [] },
       { ...mockEntry, title: 'Test Plain', filename: 'plain.md', path: '/vault/plain.md', isA: null, aliases: [] },
@@ -675,20 +675,24 @@ describe('wikilink autocomplete', () => {
       />
     )
     const items = await capturedGetItems!('Test')
-    // Typed entries should have noteType and color
+    // Typed entries should have noteType, color, and a left-side icon
     const project = items.find((i: { title: string }) => i.title === 'Test Project')
     expect(project).toBeDefined()
     expect(project!.noteType).toBe('Project')
     expect(project!.typeColor).toBeTruthy()
-    // Untyped entries (isA: null or 'Note') should have no noteType (grey/neutral)
+    expect(project!.TypeIcon).toBeTruthy()
+
+    const explicitNote = items.find((i: { title: string }) => i.title === 'Test Explicit')
+    expect(explicitNote).toBeDefined()
+    expect(explicitNote!.noteType).toBe('Note')
+    expect(explicitNote!.typeColor).toBeTruthy()
+    expect(explicitNote!.TypeIcon).toBeTruthy()
+
+    // Untyped entries should remain neutral
     const plainNote = items.find((i: { title: string }) => i.title === 'Test Plain')
     expect(plainNote).toBeDefined()
     expect(plainNote!.noteType).toBeUndefined()
     expect(plainNote!.typeColor).toBeUndefined()
-    const explicitNote = items.find((i: { title: string }) => i.title === 'Test Explicit')
-    expect(explicitNote).toBeDefined()
-    expect(explicitNote!.noteType).toBeUndefined()
-    expect(explicitNote!.typeColor).toBeUndefined()
     mockFilterSuggestionItems.mockImplementation((items: unknown[]) => items)
   })
 

src/components/NoteList.behavior.test.tsx

@@ -262,6 +262,23 @@ describe('NoteList filter pills', () => {
     expect(screen.queryByText('Open Project 1')).not.toBeInTheDocument()
   })
 
+  it('shows only explicit Note entries for the Notes type filter', () => {
+    const noteEntries = [
+      makeEntry({ title: 'Note Type', isA: 'Type', path: '/types/note.md', filename: 'note.md' }),
+      makeEntry({ title: 'Explicit Note', isA: 'Note', path: '/explicit-note.md', filename: 'explicit-note.md' }),
+      makeEntry({ title: 'Untyped Note', isA: null, path: '/untyped-note.md', filename: 'untyped-note.md' }),
+      makeEntry({ title: 'Archived Explicit Note', isA: 'Note', archived: true, path: '/archived-note.md', filename: 'archived-note.md' }),
+    ]
+
+    renderNoteList({ entries: noteEntries, selection: { kind: 'sectionGroup', type: 'Note' } })
+
+    expect(screen.getByText('Explicit Note')).toBeInTheDocument()
+    expect(screen.queryByText('Untyped Note')).not.toBeInTheDocument()
+    expect(screen.queryByText('Archived Explicit Note')).not.toBeInTheDocument()
+    expect(screen.getByTestId('filter-pill-open')).toHaveTextContent('1')
+    expect(screen.getByTestId('filter-pill-archived')).toHaveTextContent('1')
+  })
+
   it('shows the archived empty state when a section has no archived notes', () => {
     renderNoteList({
       entries: projectEntries.filter((entry) => !entry.archived),

src/components/Sidebar.test.tsx

@@ -780,6 +780,14 @@ describe('Sidebar', () => {
         icon: null, color: null, order: null, sidebarLabel: null, template: null, sort: null,
         outgoingLinks: [], properties: {},
       },
+      {
+        path: '/vault/binary-note.pdf', filename: 'binary-note.pdf', title: 'Binary Note',
+        isA: 'Note', aliases: [], belongsTo: [], relatedTo: [], status: null, owner: null,
+        cadence: null, archived: false, modifiedAt: 1700000000,
+        createdAt: null, fileSize: 150, snippet: '', wordCount: 0, relationships: {},
+        icon: null, color: null, order: null, sidebarLabel: null, template: null, sort: null,
+        outgoingLinks: [], properties: {}, fileKind: 'binary',
+      },
     ]
 
     it('shows Notes section when Note entries exist', () => {
@@ -787,13 +795,40 @@ describe('Sidebar', () => {
       expect(screen.getByText('Notes')).toBeInTheDocument()
     })
 
-    it('counts both explicit and untyped notes in Notes section chip', () => {
+    it('counts only explicit Note entries in the Notes section chip', () => {
       render(<Sidebar entries={noteEntries} selection={defaultSelection} onSelect={() => {}} />)
       const notesHeader = screen.getByText('Notes').closest('[class*="group/section"]')!
+      expect(notesHeader.textContent).toContain('1')
+    })
+
+    it('ignores non-markdown Note entries in the Notes section chip', () => {
+      render(<Sidebar entries={noteEntries} selection={defaultSelection} onSelect={() => {}} />)
+      const notesHeader = screen.getByText('Notes').closest('[class*="group/section"]')!
+      expect(notesHeader.textContent).toContain('1')
+      expect(notesHeader.textContent).not.toContain('2')
+    })
+
+    it('keeps the Notes section count aligned when an entry changes to or from Note', () => {
+      const { rerender } = render(<Sidebar entries={noteEntries} selection={defaultSelection} onSelect={() => {}} />)
+      let notesHeader = screen.getByText('Notes').closest('[class*="group/section"]')!
+      expect(notesHeader.textContent).toContain('1')
+
+      const withoutExplicitNote = noteEntries.map((entry) =>
+        entry.path === '/vault/explicit-note.md' ? { ...entry, isA: null } : entry,
+      )
+      rerender(<Sidebar entries={withoutExplicitNote} selection={defaultSelection} onSelect={() => {}} />)
+      notesHeader = screen.getByText('Notes').closest('[class*="group/section"]')!
+      expect(notesHeader.textContent).toBe('Notes')
+
+      const withNewExplicitNote = noteEntries.map((entry) =>
+        entry.path === '/vault/untyped-note.md' ? { ...entry, isA: 'Note' } : entry,
+      )
+      rerender(<Sidebar entries={withNewExplicitNote} selection={defaultSelection} onSelect={() => {}} />)
+      notesHeader = screen.getByText('Notes').closest('[class*="group/section"]')!
       expect(notesHeader.textContent).toContain('2')
     })
 
-    it('shows Notes section for untyped entries even without explicit Note entries', () => {
+    it('does not show Notes section for untyped entries without explicit Note entries', () => {
       const untypedOnly: VaultEntry[] = [
         {
           path: '/vault/plain.md', filename: 'plain.md', title: 'Plain Note',
@@ -805,7 +840,7 @@ describe('Sidebar', () => {
         },
       ]
       render(<Sidebar entries={untypedOnly} selection={defaultSelection} onSelect={() => {}} />)
-      expect(screen.getByText('Notes')).toBeInTheDocument()
+      expect(screen.queryByText('Notes')).not.toBeInTheDocument()
     })
   })
 
@@ -874,6 +909,88 @@ describe('Sidebar', () => {
     expect(topNav.children[0].textContent).toContain('All Notes')
   })
 
+  it('excludes attachments-folder markdown from top-nav note totals', () => {
+    const entries: VaultEntry[] = [
+      {
+        path: '/vault/note/real-note.md',
+        filename: 'real-note.md',
+        title: 'Real Note',
+        isA: 'Note',
+        aliases: [], belongsTo: [], relatedTo: [],
+        status: null, owner: null, cadence: null,
+        archived: false,
+        modifiedAt: 1700000000, createdAt: null,
+        fileSize: 310, snippet: '', wordCount: 120,
+        relationships: {}, icon: null, color: null, order: null,
+        sidebarLabel: null, template: null, sort: null, view: null,
+        outgoingLinks: [], properties: {},
+      },
+      {
+        path: '/vault/attachments/reference.md',
+        filename: 'reference.md',
+        title: 'Attachment Markdown',
+        isA: 'Note',
+        aliases: [], belongsTo: [], relatedTo: [],
+        status: null, owner: null, cadence: null,
+        archived: false,
+        modifiedAt: 1700000000, createdAt: null,
+        fileSize: 220, snippet: '', wordCount: 50,
+        relationships: {}, icon: null, color: null, order: null,
+        sidebarLabel: null, template: null, sort: null, view: null,
+        outgoingLinks: [], properties: {},
+      },
+      {
+        path: '/vault/attachments/nested/archive.md',
+        filename: 'archive.md',
+        title: 'Attachment Archive',
+        isA: 'Note',
+        aliases: [], belongsTo: [], relatedTo: [],
+        status: null, owner: null, cadence: null,
+        archived: true,
+        modifiedAt: 1700000000, createdAt: null,
+        fileSize: 180, snippet: '', wordCount: 25,
+        relationships: {}, icon: null, color: null, order: null,
+        sidebarLabel: null, template: null, sort: null, view: null,
+        outgoingLinks: [], properties: {},
+      },
+      {
+        path: '/vault/archive/real-archive.md',
+        filename: 'real-archive.md',
+        title: 'Real Archive',
+        isA: 'Note',
+        aliases: [], belongsTo: [], relatedTo: [],
+        status: null, owner: null, cadence: null,
+        archived: true,
+        modifiedAt: 1700000000, createdAt: null,
+        fileSize: 280, snippet: '', wordCount: 90,
+        relationships: {}, icon: null, color: null, order: null,
+        sidebarLabel: null, template: null, sort: null, view: null,
+        outgoingLinks: [], properties: {},
+      },
+      {
+        path: '/vault/attachments/image.png',
+        filename: 'image.png',
+        title: 'image.png',
+        isA: null,
+        aliases: [], belongsTo: [], relatedTo: [],
+        status: null, owner: null, cadence: null,
+        archived: false,
+        modifiedAt: 1700000000, createdAt: null,
+        fileSize: 1024, snippet: '', wordCount: 0,
+        relationships: {}, icon: null, color: null, order: null,
+        sidebarLabel: null, template: null, sort: null, view: null,
+        fileKind: 'binary',
+        outgoingLinks: [], properties: {},
+      },
+    ]
+
+    render(<Sidebar entries={entries} selection={defaultSelection} onSelect={() => {}} />)
+
+    const topNav = screen.getByTestId('sidebar-top-nav')
+    expect(topNav.children[1].textContent).toContain('All Notes1')
+    expect(topNav.children[2].textContent).toContain('Archive1')
+  })
+
   it('does not show inline entries — no child items in type sections', () => {
     const entriesWithEmoji: VaultEntry[] = [
       {

src/components/SingleEditorView.tsx

@@ -179,6 +179,7 @@ export function SingleEditorView({ editor, entries, onNavigateWikilink, onChange
       title: entry.title,
       aliases: [...new Set([entry.filename.replace(/\.md$/, ''), ...entry.aliases])],
       group: entry.isA || 'Note',
+      entryType: entry.isA,
       entryTitle: entry.title,
       path: entry.path,
     }))),

src/components/blockNoteFormattingToolbarHoverGuard.test.ts

@@ -0,0 +1,114 @@
+import { describe, expect, it } from 'vitest'
+import {
+  isWithinFormattingToolbarHoverBridge,
+  shouldSuppressFormattingToolbarHoverUpdate,
+} from './blockNoteFormattingToolbarHoverGuard'
+
+function rect(left: number, top: number, width: number, height: number) {
+  return DOMRect.fromRect({ x: left, y: top, width, height })
+}
+
+function setRect(element: HTMLElement, nextRect: DOMRect) {
+  element.getBoundingClientRect = () => nextRect
+}
+
+describe('blockNoteFormattingToolbarHoverGuard', () => {
+  it('treats the gap between the selected image block and toolbar as part of the hover bridge', () => {
+    expect(
+      isWithinFormattingToolbarHoverBridge(
+        { x: 368, y: 104 },
+        rect(300, 130, 140, 90),
+        rect(322, 78, 96, 24),
+      ),
+    ).toBe(true)
+  })
+
+  it('suppresses hover updates when the pointer is already over the toolbar', () => {
+    const container = document.createElement('div')
+    const block = document.createElement('div')
+    block.className = 'bn-block'
+    block.dataset.id = 'image-block'
+    const fileBlock = document.createElement('div')
+    fileBlock.dataset.fileBlock = 'true'
+    block.appendChild(fileBlock)
+    container.appendChild(block)
+    document.body.appendChild(container)
+
+    const toolbar = document.createElement('div')
+    toolbar.className = 'bn-formatting-toolbar'
+    const toolbarButton = document.createElement('button')
+    toolbar.appendChild(toolbarButton)
+    document.body.appendChild(toolbar)
+
+    setRect(fileBlock, rect(300, 130, 140, 90))
+    setRect(toolbar, rect(322, 78, 96, 24))
+
+    expect(
+      shouldSuppressFormattingToolbarHoverUpdate({
+        eventTarget: toolbarButton,
+        point: { x: 350, y: 90 },
+        container,
+        doc: document,
+        selectedFileBlockId: 'image-block',
+      }),
+    ).toBe(true)
+  })
+
+  it('suppresses hover updates while the pointer crosses the image-toolbar bridge', () => {
+    const container = document.createElement('div')
+    const block = document.createElement('div')
+    block.className = 'bn-block'
+    block.dataset.id = 'image-block'
+    const fileBlock = document.createElement('div')
+    fileBlock.dataset.fileBlock = 'true'
+    block.appendChild(fileBlock)
+    container.appendChild(block)
+    document.body.appendChild(container)
+
+    const toolbar = document.createElement('div')
+    toolbar.className = 'bn-formatting-toolbar'
+    document.body.appendChild(toolbar)
+
+    setRect(fileBlock, rect(300, 130, 140, 90))
+    setRect(toolbar, rect(322, 78, 96, 24))
+
+    expect(
+      shouldSuppressFormattingToolbarHoverUpdate({
+        eventTarget: document.body,
+        point: { x: 368, y: 104 },
+        container,
+        doc: document,
+        selectedFileBlockId: 'image-block',
+      }),
+    ).toBe(true)
+  })
+
+  it('leaves unrelated pointer movement alone', () => {
+    const container = document.createElement('div')
+    const block = document.createElement('div')
+    block.className = 'bn-block'
+    block.dataset.id = 'image-block'
+    const fileBlock = document.createElement('div')
+    fileBlock.dataset.fileBlock = 'true'
+    block.appendChild(fileBlock)
+    container.appendChild(block)
+    document.body.appendChild(container)
+
+    const toolbar = document.createElement('div')
+    toolbar.className = 'bn-formatting-toolbar'
+    document.body.appendChild(toolbar)
+
+    setRect(fileBlock, rect(300, 130, 140, 90))
+    setRect(toolbar, rect(322, 78, 96, 24))
+
+    expect(
+      shouldSuppressFormattingToolbarHoverUpdate({
+        eventTarget: document.body,
+        point: { x: 520, y: 220 },
+        container,
+        doc: document,
+        selectedFileBlockId: 'image-block',
+      }),
+    ).toBe(false)
+  })
+})

src/components/blockNoteFormattingToolbarHoverGuard.ts

@@ -0,0 +1,179 @@
+import { useEffect, useRef, type RefObject } from 'react'
+
+type RectLike = Pick<DOMRect, 'left' | 'right' | 'top' | 'bottom'>
+
+const HOVER_BRIDGE_PADDING_X = 8
+const HOVER_BRIDGE_PADDING_Y = 8
+
+function isVisibleRect(rect: RectLike) {
+  return rect.right > rect.left && rect.bottom > rect.top
+}
+
+function getSelectedFileBlockBridgeElement(
+  container: HTMLElement,
+  blockId: string,
+) {
+  const selectedBlock = container.querySelector<HTMLElement>(
+    `.bn-block[data-id="${blockId}"]`,
+  )
+
+  if (!selectedBlock) return null
+
+  return (
+    selectedBlock.querySelector<HTMLElement>(
+      '[data-file-block] .bn-visual-media-wrapper',
+    ) ??
+    selectedBlock.querySelector<HTMLElement>(
+      '[data-file-block] .bn-file-name-with-icon',
+    ) ??
+    selectedBlock.querySelector<HTMLElement>('[data-file-block] .bn-add-file-button') ??
+    selectedBlock.querySelector<HTMLElement>('[data-file-block]')
+  )
+}
+
+export function isWithinFormattingToolbarHoverBridge(
+  point: { x: number; y: number },
+  fileBlockRect: RectLike,
+  toolbarRect: RectLike,
+) {
+  if (!isVisibleRect(fileBlockRect) || !isVisibleRect(toolbarRect)) {
+    return false
+  }
+
+  const left = Math.min(fileBlockRect.left, toolbarRect.left) - HOVER_BRIDGE_PADDING_X
+  const right = Math.max(fileBlockRect.right, toolbarRect.right) + HOVER_BRIDGE_PADDING_X
+  const top = Math.min(fileBlockRect.top, toolbarRect.top) - HOVER_BRIDGE_PADDING_Y
+  const bottom = Math.max(fileBlockRect.bottom, toolbarRect.bottom) + HOVER_BRIDGE_PADDING_Y
+
+  return (
+    point.x >= left &&
+    point.x <= right &&
+    point.y >= top &&
+    point.y <= bottom
+  )
+}
+
+export function shouldSuppressFormattingToolbarHoverUpdate({
+  eventTarget,
+  point,
+  container,
+  doc,
+  selectedFileBlockId,
+}: {
+  eventTarget: EventTarget | null
+  point: { x: number; y: number }
+  container: HTMLElement | null
+  doc: Document
+  selectedFileBlockId: string | null
+}) {
+  if (!container || !selectedFileBlockId) return false
+
+  if (
+    eventTarget instanceof Element &&
+    eventTarget.closest('.bn-formatting-toolbar')
+  ) {
+    return true
+  }
+
+  const selectedFileBlock = getSelectedFileBlockBridgeElement(
+    container,
+    selectedFileBlockId,
+  )
+  const toolbar = doc.querySelector<HTMLElement>('.bn-formatting-toolbar')
+
+  if (!selectedFileBlock || !toolbar) return false
+
+  return isWithinFormattingToolbarHoverBridge(
+    point,
+    selectedFileBlock.getBoundingClientRect(),
+    toolbar.getBoundingClientRect(),
+  )
+}
+
+function useLastSelectedFormattingToolbarFileBlockId(
+  selectedFileBlockId: string | null,
+  isOpen: boolean,
+) {
+  const lastSelectedFileBlockIdRef = useRef<string | null>(selectedFileBlockId)
+
+  useEffect(() => {
+    if (selectedFileBlockId) {
+      lastSelectedFileBlockIdRef.current = selectedFileBlockId
+      return
+    }
+
+    if (!isOpen) {
+      lastSelectedFileBlockIdRef.current = null
+    }
+  }, [isOpen, selectedFileBlockId])
+
+  return lastSelectedFileBlockIdRef
+}
+
+function getFormattingToolbarHoverGuardEnvironment(container: HTMLElement | null) {
+  const doc = container?.ownerDocument
+  const view = doc?.defaultView
+
+  if (!container || !doc || !view) return null
+
+  return { container, doc, view }
+}
+
+function createFormattingToolbarHoverGuardHandler({
+  container,
+  doc,
+  selectedFileBlockIdRef,
+}: {
+  container: HTMLElement
+  doc: Document
+  selectedFileBlockIdRef: RefObject<string | null>
+}) {
+  return (event: MouseEvent) => {
+    if (
+      !shouldSuppressFormattingToolbarHoverUpdate({
+        eventTarget: event.target,
+        point: { x: event.clientX, y: event.clientY },
+        container,
+        doc,
+        selectedFileBlockId: selectedFileBlockIdRef.current,
+      })
+    ) {
+      return
+    }
+
+    event.stopPropagation()
+  }
+}
+
+export function useBlockNoteFormattingToolbarHoverGuard({
+  container,
+  selectedFileBlockId,
+  isOpen,
+}: {
+  container: HTMLElement | null
+  selectedFileBlockId: string | null
+  isOpen: boolean
+}) {
+  const lastSelectedFileBlockIdRef = useLastSelectedFormattingToolbarFileBlockId(
+    selectedFileBlockId,
+    isOpen,
+  )
+
+  useEffect(() => {
+    if (!isOpen) return
+
+    const environment = getFormattingToolbarHoverGuardEnvironment(container)
+    if (!environment) return
+
+    const handleMouseMove = createFormattingToolbarHoverGuardHandler({
+      container: environment.container,
+      doc: environment.doc,
+      selectedFileBlockIdRef: lastSelectedFileBlockIdRef,
+    })
+
+    environment.view.addEventListener('mousemove', handleMouseMove, true)
+    return () => {
+      environment.view.removeEventListener('mousemove', handleMouseMove, true)
+    }
+  }, [container, isOpen, lastSelectedFileBlockIdRef])
+}

src/components/note-list/useNoteListModel.tsx

@@ -8,7 +8,7 @@ import type {
   ViewFile,
 } from '../../types'
 import type { NoteListFilter } from '../../utils/noteListHelpers'
-import { countByFilter, countAllByFilter } from '../../utils/noteListHelpers'
+import { countByFilter, countAllByFilter, countAllNotesByFilter } from '../../utils/noteListHelpers'
 import { NoteItem } from '../NoteItem'
 import type { MultiSelectState } from '../../hooks/useMultiSelect'
 import { resolveHeaderTitle, type DeletedNoteEntry } from './noteListUtils'
@@ -76,7 +76,7 @@ function useFilterCounts(entries: VaultEntry[], selection: SidebarSelection) {
   return useMemo(() => {
     if (selection.kind === 'sectionGroup') return countByFilter(entries, selection.type)
     if (selection.kind === 'folder') return countAllByFilter(entries)
-    if (selection.kind === 'filter' && selection.filter === 'all') return countAllByFilter(entries)
+    if (selection.kind === 'filter' && selection.filter === 'all') return countAllNotesByFilter(entries)
     return { open: 0, archived: 0 }
   }, [entries, selection])
 }

src/components/sidebar/SidebarSections.tsx

@@ -20,6 +20,7 @@ import { TypeCustomizePopover } from '../TypeCustomizePopover'
 import { useDragRegion } from '../../hooks/useDragRegion'
 import { SidebarGroupHeader } from './SidebarGroupHeader'
 import { SidebarViewItem } from './SidebarViewItem'
+import { countByFilter } from '../../utils/noteListHelpers'
 
 export { SidebarTopNav } from './SidebarTopNav'
 export { FavoritesSection } from './FavoritesSection'
@@ -94,9 +95,7 @@ function SortableSection({
   sectionProps: SidebarSectionProps
 }) {
   const { attributes, listeners, setNodeRef, transform, transition, isDragging } = useSortable({ id: group.type })
-  const itemCount = sectionProps.entries.filter((entry) =>
-    !entry.archived && (group.type === 'Note' ? (entry.isA === 'Note' || !entry.isA) : entry.isA === group.type),
-  ).length
+  const itemCount = countByFilter(sectionProps.entries, group.type).open
   const isRenaming = sectionProps.renamingType === group.type
 
   return (

src/components/sidebar/sidebarHooks.ts

@@ -2,6 +2,7 @@ import { useState, useMemo, useEffect, useCallback, type RefObject } from 'react
 import type { VaultEntry } from '../../types'
 import { APP_STORAGE_KEYS, LEGACY_APP_STORAGE_KEYS, getAppStorageItem } from '../../constants/appStorage'
 import { buildTypeEntryMap } from '../../utils/typeColors'
+import { countAllNotesByFilter } from '../../utils/noteListHelpers'
 import { buildDynamicSections, sortSections } from '../../utils/sidebarSections'
 
 export type SidebarGroupKey = 'favorites' | 'views' | 'sections' | 'folders'
@@ -58,13 +59,8 @@ export function useSidebarCollapsed() {
 
 export function useEntryCounts(entries: VaultEntry[]) {
   return useMemo(() => {
-    let active = 0
-    let archived = 0
-    for (const entry of entries) {
-      if (entry.archived) archived++
-      else active++
-    }
-    return { activeCount: active, archivedCount: archived }
+    const counts = countAllNotesByFilter(entries)
+    return { activeCount: counts.open, archivedCount: counts.archived }
   }, [entries])
 }
 

src/components/tolariaEditorFormatting.tsx

@@ -54,6 +54,7 @@ import {
   filterTolariaFormattingToolbarItems,
   getTolariaBlockTypeSelectItems,
 } from './tolariaEditorFormattingConfig'
+import { useBlockNoteFormattingToolbarHoverGuard } from './blockNoteFormattingToolbarHoverGuard'
 
 type TolariaBasicTextStyle = 'bold' | 'italic' | 'strike' | 'code'
 
@@ -166,6 +167,13 @@ type TolariaSelectedBlock = ReturnType<
   BlockNoteEditor<BlockSchema, InlineContentSchema, StyleSchema>['getTextCursorPosition']
 >['block']
 
+const FORMATTING_TOOLBAR_FILE_BLOCK_TYPES = new Set([
+  'audio',
+  'file',
+  'image',
+  'video',
+])
+
 type TolariaBlockTypeSelectOption = ReturnType<
   typeof getTolariaBlockTypeSelectItems
 >[number] & {
@@ -263,6 +271,17 @@ function getTolariaBlockTypeSelectOptions(
     }))
 }
 
+function getFormattingToolbarBridgeBlockId(
+  editor: BlockNoteEditor<BlockSchema, InlineContentSchema, StyleSchema>,
+) {
+  const selectedBlock =
+    editor.getSelection()?.blocks[0] ?? editor.getTextCursorPosition().block
+
+  return FORMATTING_TOOLBAR_FILE_BLOCK_TYPES.has(selectedBlock.type)
+    ? selectedBlock.id
+    : null
+}
+
 function updateSelectedBlocksToType(
   editor: BlockNoteEditor<BlockSchema, InlineContentSchema, StyleSchema>,
   selectedBlocks: TolariaSelectedBlock[],
@@ -451,6 +470,19 @@ export function TolariaFormattingToolbarController(props: {
   })
 
   const isOpen = show || toolbarHasFocus || toolbarHovered || closeGraceActive
+  const currentBridgeBlockId = useEditorState({
+    editor,
+    selector: ({ editor }) => getFormattingToolbarBridgeBlockId(editor),
+  })
+
+  useBlockNoteFormattingToolbarHoverGuard({
+    container:
+      editor.domElement?.closest('.editor__blocknote-container') ??
+      editor.domElement ??
+      null,
+    selectedFileBlockId: currentBridgeBlockId,
+    isOpen,
+  })
 
   const position = useEditorState({
     editor,

src/hooks/useEditorSaveWithLinks.test.ts

@@ -2,6 +2,18 @@ import { describe, it, expect, vi, beforeEach, type Mock } from 'vitest'
 import { renderHook, act } from '@testing-library/react'
 import { useEditorSaveWithLinks } from './useEditorSaveWithLinks'
 
+const { startTransitionMock } = vi.hoisted(() => ({
+  startTransitionMock: vi.fn((callback: () => void) => callback()),
+}))
+
+vi.mock('react', async (importOriginal) => {
+  const actual = await importOriginal<typeof import('react')>()
+  return {
+    ...actual,
+    startTransition: startTransitionMock,
+  }
+})
+
 const mockHandleContentChange = vi.fn()
 const mockHandleSave = vi.fn()
 const mockSavePendingForPath = vi.fn()
@@ -25,6 +37,7 @@ describe('useEditorSaveWithLinks', () => {
     setTabs = vi.fn()
     setToastMessage = vi.fn()
     onAfterSave = vi.fn()
+    startTransitionMock.mockClear()
     mockHandleContentChange.mockClear()
     mockHandleSave.mockClear()
     mockSavePendingForPath.mockClear()
@@ -147,6 +160,8 @@ describe('useEditorSaveWithLinks', () => {
     expect(updateEntry).toHaveBeenCalledWith('/note.md', {
       isA: 'Project',
       status: 'Active',
+    })
+    expect(updateEntry).toHaveBeenCalledWith('/note.md', {
       title: 'Note',
       hasH1: false,
     })
@@ -172,6 +187,8 @@ describe('useEditorSaveWithLinks', () => {
     })
     expect(updateEntry).toHaveBeenCalledWith('/note.md', {
       isA: 'Essay',
+    })
+    expect(updateEntry).toHaveBeenCalledWith('/note.md', {
       title: 'Note',
       hasH1: false,
     })
@@ -181,6 +198,8 @@ describe('useEditorSaveWithLinks', () => {
     })
     expect(updateEntry).toHaveBeenCalledWith('/note.md', {
       isA: 'Note',
+    })
+    expect(updateEntry).toHaveBeenCalledWith('/note.md', {
       title: 'Note',
       hasH1: false,
     })
@@ -199,6 +218,20 @@ describe('useEditorSaveWithLinks', () => {
     expect(updateEntry).toHaveBeenCalledWith(path, expected)
   })
 
+  it('defers H1 title sync updates in a transition so typing stays responsive', () => {
+    const { result } = renderHookWithLinks()
+
+    act(() => {
+      result.current.handleContentChange('/old-title.md', '# Renamed Note\n\nBody')
+    })
+
+    expect(startTransitionMock).toHaveBeenCalledTimes(1)
+    expect(updateEntry).toHaveBeenCalledWith('/old-title.md', {
+      title: 'Renamed Note',
+      hasH1: true,
+    })
+  })
+
   it('spreads all properties from useEditorSave onto the return value', () => {
     const { result } = renderHookWithLinks()
 

src/hooks/useEditorSaveWithLinks.ts

@@ -1,4 +1,4 @@
-import { useCallback, useRef } from 'react'
+import { startTransition, useCallback, useRef } from 'react'
 import { useEditorSave } from './useEditorSave'
 import { extractOutgoingLinks, extractSnippet, countWords } from '../utils/wikilinks'
 import { contentToEntryPatch } from './frontmatterOps'
@@ -35,6 +35,7 @@ export function useEditorSaveWithLinks(config: {
   const { handleContentChange: rawOnChange } = editor
   const prevLinksKeyRef = useRef('')
   const prevFmKeyRef = useRef('')
+  const prevTitleKeyRef = useRef('')
   const handleContentChange = useCallback((path: string, content: string) => {
     rawOnChange(path, content)
     const links = extractOutgoingLinks(content)
@@ -45,19 +46,25 @@ export function useEditorSaveWithLinks(config: {
     }
     const frontmatterPatch = contentToEntryPatch(content)
     const filename = path.split('/').pop() ?? path
-    const fmPatch = {
-      ...frontmatterPatch,
-      ...deriveDisplayTitleState({
-        content,
-        filename,
-        frontmatterTitle: typeof frontmatterPatch.title === 'string' ? frontmatterPatch.title : null,
-      }),
-    }
+    const titlePatch = deriveDisplayTitleState({
+      content,
+      filename,
+      frontmatterTitle: typeof frontmatterPatch.title === 'string' ? frontmatterPatch.title : null,
+    })
+    const fmPatch = { ...frontmatterPatch }
+    delete fmPatch.title
     const fmKey = JSON.stringify(fmPatch)
     if (fmKey !== prevFmKeyRef.current) {
       prevFmKeyRef.current = fmKey
       if (Object.keys(fmPatch).length > 0) updateEntry(path, fmPatch)
     }
+    const titleKey = JSON.stringify(titlePatch)
+    if (titleKey !== prevTitleKeyRef.current) {
+      prevTitleKeyRef.current = titleKey
+      startTransition(() => {
+        updateEntry(path, titlePatch)
+      })
+    }
   }, [rawOnChange, updateEntry])
   return { ...editor, handleContentChange }
 }

src/hooks/useEditorTabSwap.rename.test.ts

@@ -67,6 +67,7 @@ describe('useEditorTabSwap untitled rename continuity', () => {
     await act(() => new Promise(r => setTimeout(r, 0)))
 
     expect(editor.replaceBlocks).not.toHaveBeenCalled()
+    expect(editor.tryParseMarkdownToBlocks).not.toHaveBeenCalled()
 
     act(() => {
       result.current.handleEditorChange()
@@ -104,4 +105,46 @@ describe('useEditorTabSwap untitled rename continuity', () => {
 
     expect(editor.tryParseMarkdownToBlocks).toHaveBeenCalled()
   })
+
+  it('keeps the live editor session when the renamed tab arrives one render after the path switch', async () => {
+    vi.spyOn(document, 'querySelector').mockReturnValue({ scrollTop: 0 } as unknown as Element)
+    vi.spyOn(window, 'requestAnimationFrame').mockImplementation((cb) => { cb(0); return 0 })
+
+    const editor = makeMockEditor('# Fresh Title\n\nBody typed live')
+    const onContentChange = vi.fn()
+    const untitledTab = makeTab('untitled-note-123.md', 'Untitled Note 123', 'Body')
+    const renamedTab = makeTab('fresh-title.md', 'Fresh Title', 'Body')
+
+    const { result, rerender } = renderHook(
+      ({ tabs, activeTabPath }) => useEditorTabSwap({
+        tabs,
+        activeTabPath,
+        editor: editor as never,
+        onContentChange,
+      }),
+      { initialProps: { tabs: [untitledTab], activeTabPath: untitledTab.entry.path } },
+    )
+
+    await act(() => new Promise(r => setTimeout(r, 0)))
+    editor.replaceBlocks.mockClear()
+    editor.tryParseMarkdownToBlocks.mockClear()
+
+    rerender({ tabs: [untitledTab], activeTabPath: renamedTab.entry.path })
+    await act(() => new Promise(r => setTimeout(r, 0)))
+
+    rerender({ tabs: [renamedTab], activeTabPath: renamedTab.entry.path })
+    await act(() => new Promise(r => setTimeout(r, 0)))
+
+    expect(editor.replaceBlocks).not.toHaveBeenCalled()
+    expect(editor.tryParseMarkdownToBlocks).not.toHaveBeenCalled()
+
+    act(() => {
+      result.current.handleEditorChange()
+    })
+
+    expect(onContentChange).toHaveBeenCalledWith(
+      'fresh-title.md',
+      expect.stringContaining('Body typed live'),
+    )
+  })
 })

src/hooks/useEditorTabSwap.ts

@@ -35,23 +35,36 @@ export function extractEditorBody(rawFileContent: string): string {
   return rawBody.trimStart()
 }
 
-/** Extract H1 text from the editor's first block, or null if not an H1. */
-export function getH1TextFromBlocks(blocks: unknown[]): string | null {
+type HeadingTextInline = { type?: string; text?: string }
+
+function extractH1Content(blocks: unknown[]): HeadingTextInline[] | null {
   const first = blocks?.[0] as {
     type?: string
     props?: { level?: number }
-    content?: Array<{ type?: string; text?: string }>
+    content?: HeadingTextInline[]
   } | undefined
-  const content = first?.type === 'heading' && first.props?.level === 1 && Array.isArray(first.content)
-    ? first.content
-    : null
+
+  if (!first) return null
+  if (first.type !== 'heading') return null
+  if (first.props?.level !== 1) return null
+  if (!Array.isArray(first.content)) return null
+  return first.content
+}
+
+/** Extract H1 text from the editor's first block, or null if not an H1. */
+export function getH1TextFromBlocks(blocks: unknown[]): string | null {
+  const content = extractH1Content(blocks)
   if (!content) return null
 
-  const text = content
-    .filter(item => item.type === 'text')
-    .map(item => item.text || '')
-    .join('')
-  return text.trim() || null
+  let text = ''
+  for (const item of content) {
+    if (item.type === 'text') {
+      text += item.text || ''
+    }
+  }
+
+  const trimmed = text.trim()
+  return trimmed || null
 }
 
 /** Replace the title: line in YAML frontmatter with a new title value. */
@@ -274,9 +287,11 @@ function normalizeTabBody(content: string): string {
 }
 
 function renameBodiesOverlap(currentBody: string, nextBody: string): boolean {
-  return currentBody === nextBody
-    || currentBody.startsWith(nextBody)
-    || nextBody.startsWith(currentBody)
+  const current = currentBody.trimEnd()
+  const next = nextBody.trimEnd()
+  return current === next
+    || current.startsWith(next)
+    || next.startsWith(current)
 }
 
 function isUntitledRenameTransition(
@@ -377,21 +392,52 @@ function cachePreviousTabOnPathChange(options: {
   cacheEditorState(cache, prevPath, editor.document)
 }
 
-function rememberPendingTabArrival(
+function shouldWaitForActiveTab(
+  pathChanged: boolean,
   activeTabPath: string | null,
   activeTab: Tab | undefined,
-  pendingTabArrivalPathRef: MutableRefObject<string | null>,
 ) {
-  if (!activeTabPath) {
-    pendingTabArrivalPathRef.current = null
+  return pathChanged && !!activeTabPath && !activeTab
+}
+
+function syncActivePathTransition(options: {
+  prevPath: string | null
+  pathChanged: boolean
+  activeTabPath: string | null
+  activeTab: Tab | undefined
+  cache: Map<string, CachedTabState>
+  editor: ReturnType<typeof useCreateBlockNote>
+  editorMountedRef: MutableRefObject<boolean>
+  prevActivePathRef: MutableRefObject<string | null>
+}) {
+  const {
+    prevPath,
+    pathChanged,
+    activeTabPath,
+    activeTab,
+    cache,
+    editor,
+    editorMountedRef,
+    prevActivePathRef,
+  } = options
+
+  cachePreviousTabOnPathChange({ prevPath, pathChanged, editorMountedRef, cache, editor })
+  if (shouldWaitForActiveTab(pathChanged, activeTabPath, activeTab)) return true
+
+  if (!preserveUntitledRenameState({
+    prevPath,
+    activeTabPath,
+    activeTab,
+    cache,
+    editor,
+    editorMountedRef,
+  })) {
+    prevActivePathRef.current = activeTabPath
     return false
   }
-  if (activeTab) {
-    pendingTabArrivalPathRef.current = null
-    return true
-  }
-  pendingTabArrivalPathRef.current = activeTabPath
-  return false
+
+  prevActivePathRef.current = activeTabPath
+  return true
 }
 
 function handleStableActivePath(options: {
@@ -399,7 +445,6 @@ function handleStableActivePath(options: {
   rawModeJustEnded: boolean
   activeTabPath: string | null
   activeTab: Tab | undefined
-  pendingTabArrival: boolean
   cache: Map<string, CachedTabState>
   editor: ReturnType<typeof useCreateBlockNote>
   editorMountedRef: MutableRefObject<boolean>
@@ -410,7 +455,6 @@ function handleStableActivePath(options: {
     rawModeJustEnded,
     activeTabPath,
     activeTab,
-    pendingTabArrival,
     cache,
     editor,
     editorMountedRef,
@@ -423,7 +467,6 @@ function handleStableActivePath(options: {
     rawSwapPendingRef.current = true
     return false
   }
-  if (pendingTabArrival) return false
   if (rawSwapPendingRef.current) return true
 
   cacheStableActivePath({
@@ -638,7 +681,81 @@ function scheduleTabSwap(options: {
   pendingSwapRef.current = doSwap
 }
 
-function useTabSwapEffect(options: {
+function runTabSwapEffect(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>
+  prevRawModeRef: MutableRefObject<boolean>
+  rawSwapPendingRef: MutableRefObject<boolean>
+  suppressChangeRef: MutableRefObject<boolean>
+}) {
+  const {
+    tabs,
+    activeTabPath,
+    editor,
+    rawMode,
+    tabCacheRef,
+    prevActivePathRef,
+    editorMountedRef,
+    pendingSwapRef,
+    prevRawModeRef,
+    rawSwapPendingRef,
+    suppressChangeRef,
+  } = options
+
+  const cache = tabCacheRef.current
+  const prevPath = prevActivePathRef.current
+  const pathChanged = prevPath !== activeTabPath
+  const activeTab = findActiveTab(tabs, activeTabPath)
+  const rawModeJustEnded = consumeRawModeTransition(prevRawModeRef, rawMode)
+
+  if (rawMode) return
+  if (syncActivePathTransition({
+    prevPath,
+    pathChanged,
+    activeTabPath,
+    activeTab,
+    cache,
+    editor,
+    editorMountedRef,
+    prevActivePathRef,
+  })) {
+    return
+  }
+
+  if (handleStableActivePath({
+    pathChanged,
+    rawModeJustEnded,
+    activeTabPath,
+    activeTab,
+    cache,
+    editor,
+    editorMountedRef,
+    rawSwapPendingRef,
+  })) {
+    return
+  }
+
+  if (!activeTabPath || !activeTab) return
+
+  scheduleTabSwap({
+    editor,
+    cache,
+    targetPath: activeTabPath,
+    activeTab,
+    pendingSwapRef,
+    prevActivePathRef,
+    rawSwapPendingRef,
+    suppressChangeRef,
+  })
+}
+
+function useTabSwapEffect(options: {
   tabs: Tab[]
   activeTabPath: string | null
   editor: ReturnType<typeof useCreateBlockNote>
@@ -647,7 +764,6 @@ function useTabSwapEffect(options: {
   prevActivePathRef: MutableRefObject<string | null>
   editorMountedRef: MutableRefObject<boolean>
   pendingSwapRef: MutableRefObject<(() => void) | null>
-  pendingTabArrivalPathRef: MutableRefObject<string | null>
   prevRawModeRef: MutableRefObject<boolean>
   rawSwapPendingRef: MutableRefObject<boolean>
   suppressChangeRef: MutableRefObject<boolean>
@@ -661,64 +777,22 @@ function useTabSwapEffect(options: {
     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 (preserveUntitledRenameState({
-      prevPath,
+    runTabSwapEffect({
+      tabs,
       activeTabPath,
-      activeTab,
-      cache,
       editor,
+      rawMode,
+      tabCacheRef,
       editorMountedRef,
-    })) {
-      return
-    }
-
-    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,
+      pendingSwapRef,
+      prevRawModeRef,
       rawSwapPendingRef,
       suppressChangeRef,
     })
@@ -727,7 +801,6 @@ function useTabSwapEffect(options: {
     editor,
     editorMountedRef,
     pendingSwapRef,
-    pendingTabArrivalPathRef,
     prevActivePathRef,
     prevRawModeRef,
     rawMode,
@@ -771,7 +844,6 @@ export function useEditorTabSwap({ tabs, activeTabPath, editor, onContentChange,
   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)
   const rawSwapPendingRef = useRef(false)
   const suppressChangeRef = useRef(false)
@@ -795,7 +867,6 @@ export function useEditorTabSwap({ tabs, activeTabPath, editor, onContentChange,
     prevActivePathRef,
     editorMountedRef,
     pendingSwapRef,
-    pendingTabArrivalPathRef,
     prevRawModeRef,
     rawSwapPendingRef,
     suppressChangeRef,

src/utils/commitEntryAction.test.ts

@@ -0,0 +1,32 @@
+import { describe, expect, it, vi } from 'vitest'
+import { triggerCommitEntryAction } from './commitEntryAction'
+
+describe('triggerCommitEntryAction', () => {
+  it('runs the automatic checkpoint when AutoGit is enabled', () => {
+    const openCommitDialog = vi.fn().mockResolvedValue(undefined)
+    const runAutomaticCheckpoint = vi.fn().mockResolvedValue(true)
+
+    triggerCommitEntryAction({
+      autoGitEnabled: true,
+      openCommitDialog,
+      runAutomaticCheckpoint,
+    })
+
+    expect(runAutomaticCheckpoint).toHaveBeenCalledWith({ savePendingBeforeCommit: true })
+    expect(openCommitDialog).not.toHaveBeenCalled()
+  })
+
+  it('opens the manual commit dialog when AutoGit is disabled', () => {
+    const openCommitDialog = vi.fn().mockResolvedValue(undefined)
+    const runAutomaticCheckpoint = vi.fn().mockResolvedValue(true)
+
+    triggerCommitEntryAction({
+      autoGitEnabled: false,
+      openCommitDialog,
+      runAutomaticCheckpoint,
+    })
+
+    expect(openCommitDialog).toHaveBeenCalledTimes(1)
+    expect(runAutomaticCheckpoint).not.toHaveBeenCalled()
+  })
+})

src/utils/commitEntryAction.ts

@@ -0,0 +1,21 @@
+type RunAutomaticCheckpoint = (options?: { savePendingBeforeCommit?: boolean }) => Promise<boolean>
+type OpenCommitDialog = () => Promise<void>
+
+interface CommitEntryActionConfig {
+  autoGitEnabled: boolean
+  openCommitDialog: OpenCommitDialog
+  runAutomaticCheckpoint: RunAutomaticCheckpoint
+}
+
+export function triggerCommitEntryAction({
+  autoGitEnabled,
+  openCommitDialog,
+  runAutomaticCheckpoint,
+}: CommitEntryActionConfig): void {
+  if (autoGitEnabled) {
+    void runAutomaticCheckpoint({ savePendingBeforeCommit: true })
+    return
+  }
+
+  void openCommitDialog()
+}

src/utils/noteListHelpers.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, it } from 'vitest'
-import { countAllByFilter, countByFilter, filterEntries } from './noteListHelpers'
+import { countAllByFilter, countAllNotesByFilter, countByFilter, filterEntries } from './noteListHelpers'
 import { allSelection, makeEntry, mockEntries } from '../test-utils/noteListTestUtils'
 
 describe('filterEntries', () => {
@@ -62,6 +62,17 @@ describe('filterEntries', () => {
     const result = filterEntries(entries, allSelection, 'archived')
     expect(result.map((entry) => entry.title)).toEqual(['Archived'])
   })
+
+  it('excludes attachments-folder markdown from the All Notes view', () => {
+    const entries = [
+      makeEntry({ path: '/vault/note/real-note.md', title: 'Real Note', isA: 'Note' }),
+      makeEntry({ path: '/vault/attachments/reference.md', title: 'Attachment Markdown', isA: 'Note' }),
+      makeEntry({ path: '/vault/attachments/nested/diagram.md', title: 'Nested Attachment Markdown', isA: 'Note' }),
+    ]
+
+    const result = filterEntries(entries, allSelection, 'open')
+    expect(result.map((entry) => entry.title)).toEqual(['Real Note'])
+  })
 })
 
 describe('countByFilter', () => {
@@ -102,3 +113,17 @@ describe('countAllByFilter', () => {
     expect(countAllByFilter(entries)).toEqual({ open: 1, archived: 0 })
   })
 })
+
+describe('countAllNotesByFilter', () => {
+  it('excludes attachments-folder files from All Notes totals', () => {
+    const entries = [
+      makeEntry({ path: '/vault/note/real-note.md', isA: 'Note' }),
+      makeEntry({ path: '/vault/attachments/reference.md', isA: 'Note' }),
+      makeEntry({ path: '/vault/attachments/archive.md', isA: 'Note', archived: true }),
+      makeEntry({ path: '/vault/attachments/image.png', fileKind: 'binary' }),
+      makeEntry({ path: '/vault/archive/real-archive.md', isA: 'Note', archived: true }),
+    ]
+
+    expect(countAllNotesByFilter(entries)).toEqual({ open: 1, archived: 1 })
+  })
+})

src/utils/noteListHelpers.ts

@@ -310,6 +310,7 @@ export function buildRelationshipGroups(
 
 const isActive = (e: VaultEntry) => !e.archived
 const isMarkdown = (e: VaultEntry) => e.fileKind === 'markdown' || !e.fileKind
+const ATTACHMENTS_FOLDER = 'attachments'
 
 function applySubFilter(entries: VaultEntry[], subFilter: NoteListFilter): VaultEntry[] {
   if (subFilter === 'archived') return entries.filter((e) => e.archived)
@@ -321,26 +322,46 @@ function isInFolder(entryPath: string, folderRelPath: string): boolean {
   return entryPath.includes(needle) || entryPath.startsWith(folderRelPath + '/')
 }
 
+export function isAllNotesEntry(entry: VaultEntry): boolean {
+  return isMarkdown(entry) && !isInFolder(entry.path, ATTACHMENTS_FOLDER)
+}
+
+function filterViewEntries(entries: VaultEntry[], filename: string, views?: ViewFile[]): VaultEntry[] {
+  const view = views?.find((candidate) => candidate.filename === filename)
+  if (!view) return []
+  return evaluateView(view.definition, entries.filter(isMarkdown))
+}
+
+function filterFolderEntries(entries: VaultEntry[], folderPath: string, subFilter?: NoteListFilter): VaultEntry[] {
+  // Folder view shows ALL files (text + binary), not just markdown
+  const folderEntries = entries.filter((entry) => isInFolder(entry.path, folderPath))
+  return subFilter ? applySubFilter(folderEntries, subFilter) : folderEntries.filter(isActive)
+}
+
+function filterSectionGroupEntries(entries: VaultEntry[], type: string, subFilter?: NoteListFilter): VaultEntry[] {
+  const typeEntries = entries.filter((entry) => isMarkdown(entry) && entry.isA === type)
+  return subFilter ? applySubFilter(typeEntries, subFilter) : typeEntries.filter(isActive)
+}
+
+function filterTopLevelEntries(
+  entries: VaultEntry[],
+  selection: Extract<SidebarSelection, { kind: 'filter' }>,
+  subFilter?: NoteListFilter,
+): VaultEntry[] {
+  const filterableEntries = selection.filter === 'all'
+    ? entries.filter(isAllNotesEntry)
+    : entries.filter(isMarkdown)
+  if (selection.filter === 'all' && subFilter) return applySubFilter(filterableEntries, subFilter)
+  return filterByFilterType(filterableEntries, selection.filter)
+}
+
 function filterByKind(entries: VaultEntry[], selection: SidebarSelection, subFilter?: NoteListFilter, views?: ViewFile[]): VaultEntry[] {
   if (selection.kind === 'entity') return []
-  if (selection.kind === 'view') {
-    const view = views?.find((v) => v.filename === selection.filename)
-    if (!view) return []
-    return evaluateView(view.definition, entries.filter(isMarkdown))
-  }
-  if (selection.kind === 'folder') {
-    // Folder view shows ALL files (text + binary), not just markdown
-    const folderEntries = entries.filter((e) => isInFolder(e.path, selection.path))
-    return subFilter ? applySubFilter(folderEntries, subFilter) : folderEntries.filter(isActive)
-  }
-  if (selection.kind === 'sectionGroup') {
-    const typeEntries = entries.filter((e) => isMarkdown(e) && e.isA === selection.type)
-    return subFilter ? applySubFilter(typeEntries, subFilter) : typeEntries.filter(isActive)
-  }
-  // Non-folder views: only markdown files
-  const mdEntries = entries.filter(isMarkdown)
-  if (selection.filter === 'all' && subFilter) return applySubFilter(mdEntries, subFilter)
-  return filterByFilterType(mdEntries, selection.filter)
+  if (selection.kind === 'view') return filterViewEntries(entries, selection.filename, views)
+  if (selection.kind === 'folder') return filterFolderEntries(entries, selection.path, subFilter)
+  if (selection.kind === 'sectionGroup') return filterSectionGroupEntries(entries, selection.type, subFilter)
+  if (selection.kind === 'filter') return filterTopLevelEntries(entries, selection, subFilter)
+  return []
 }
 
 function filterByFilterType(entries: VaultEntry[], filter: string): VaultEntry[] {
@@ -366,17 +387,25 @@ export function countByFilter(entries: VaultEntry[], type: string): Record<NoteL
   return { open, archived }
 }
 
-/** Count notes per sub-filter across all entries (no type filter). */
-export function countAllByFilter(entries: VaultEntry[]): Record<NoteListFilter, number> {
+function countEntriesByArchiveStatus(entries: VaultEntry[]): Record<NoteListFilter, number> {
   let open = 0, archived = 0
-  for (const e of entries) {
-    if (!isMarkdown(e)) continue
-    if (e.archived) archived++
+  for (const entry of entries) {
+    if (entry.archived) archived++
     else open++
   }
   return { open, archived }
 }
 
+/** Count notes per sub-filter across all entries (no type filter). */
+export function countAllByFilter(entries: VaultEntry[]): Record<NoteListFilter, number> {
+  return countEntriesByArchiveStatus(entries.filter(isMarkdown))
+}
+
+/** Count All Notes-eligible documents per sub-filter, excluding files under attachments/. */
+export function countAllNotesByFilter(entries: VaultEntry[]): Record<NoteListFilter, number> {
+  return countEntriesByArchiveStatus(entries.filter(isAllNotesEntry))
+}
+
 // --- Inbox ---
 
 /** Check if entry belongs in the Inbox (markdown only, not organized, not archived, not a Type). */

src/utils/rawEditorUtils.test.ts

@@ -99,6 +99,7 @@ describe('buildRawEditorBaseItems', () => {
         title: 'Project Alpha',
         aliases: ['project-alpha', 'Alpha'],
         group: 'Project',
+        entryType: 'Project',
         entryTitle: 'Project Alpha',
         path: 'projects/project-alpha.md',
       },

src/utils/rawEditorUtils.ts

@@ -8,6 +8,7 @@ export interface RawEditorBaseItem {
   title: string
   aliases: string[]
   group: string
+  entryType?: string | null
   entryTitle: string
   path: string
 }
@@ -59,6 +60,7 @@ export function buildRawEditorBaseItems(entries: VaultEntry[]): RawEditorBaseIte
     title: entry.title,
     aliases: [...new Set([entry.filename.replace(/\.md$/, ''), ...entry.aliases])],
     group: entry.isA || 'Note',
+    entryType: entry.isA,
     entryTitle: entry.title,
     path: entry.path,
   })))

src/utils/sidebarSections.ts

@@ -31,13 +31,10 @@ const isMarkdown = (e: VaultEntry) => e.fileKind === 'markdown' || !e.fileKind
 const isActive = (e: VaultEntry) => !e.archived
 const isSupportedSectionType = (type: string) => !isLegacyJournalingType(type)
 
-function resolveEntrySectionType(entry: VaultEntry): string {
-  return entry.isA || 'Note'
-}
-
 function shouldCollectActiveType(entry: VaultEntry): boolean {
   if (!isActive(entry) || !isMarkdown(entry)) return false
-  return isSupportedSectionType(resolveEntrySectionType(entry))
+  if (!entry.isA) return false
+  return isSupportedSectionType(entry.isA)
 }
 
 function shouldIncludeTypeDefinition(name: string, entry: VaultEntry): boolean {
@@ -45,12 +42,12 @@ function shouldIncludeTypeDefinition(name: string, entry: VaultEntry): boolean {
   return isSupportedSectionType(name)
 }
 
-/** Collect unique isA values from active (non-archived) markdown entries. Untyped entries count as 'Note'. */
+/** Collect unique explicit isA values from active (non-archived) markdown entries. */
 export function collectActiveTypes(entries: VaultEntry[]): Set<string> {
   const types = new Set<string>()
   for (const e of entries) {
     if (!shouldCollectActiveType(e)) continue
-    types.add(resolveEntrySectionType(e))
+    types.add(e.isA!)
   }
   return types
 }

src/utils/suggestionEnrichment.test.ts

@@ -76,8 +76,8 @@ describe('enrichSuggestionItems', () => {
     Project: makeEntry({ isA: 'Type', title: 'Project', color: 'blue', icon: 'wrench' }),
   }
 
-  function makeItem(title: string, group: string, path: string) {
-    return { title, aliases: [] as string[], group, entryTitle: title, path, onItemClick: vi.fn() }
+  function makeItem(title: string, group: string, path: string, entryType?: string | null) {
+    return { title, aliases: [] as string[], group, entryType, entryTitle: title, path, onItemClick: vi.fn() }
   }
 
   it('filters items by query', () => {
@@ -88,7 +88,7 @@ describe('enrichSuggestionItems', () => {
   })
 
   it('adds type metadata for non-Note groups', () => {
-    const items = [makeItem('My Project', 'Project', '/p.md')]
+    const items = [makeItem('My Project', 'Project', '/p.md', 'Project')]
     const result = enrichSuggestionItems(items, '', typeEntryMap)
     expect(result[0].noteType).toBe('Project')
     expect(result[0].typeColor).toBeDefined()
@@ -96,7 +96,15 @@ describe('enrichSuggestionItems', () => {
     expect(result[0].TypeIcon).toBeDefined()
   })
 
-  it('omits type metadata for Note group', () => {
+  it('preserves Note type metadata for explicit Note entries', () => {
+    const items = [makeItem('Explicit Note', 'Note', '/n.md', 'Note')]
+    const result = enrichSuggestionItems(items, '', {})
+    expect(result[0].noteType).toBe('Note')
+    expect(result[0].typeColor).toBeDefined()
+    expect(result[0].TypeIcon).toBeDefined()
+  })
+
+  it('keeps untyped Note-group entries neutral', () => {
     const items = [makeItem('Plain Note', 'Note', '/n.md')]
     const result = enrichSuggestionItems(items, '', {})
     expect(result[0].noteType).toBeUndefined()

src/utils/suggestionEnrichment.ts

@@ -13,6 +13,7 @@ interface BaseSuggestionItem {
   title: string
   aliases: string[]
   group: string
+  entryType?: string | null
   entryTitle: string
   path: string
 }
@@ -48,15 +49,15 @@ export function enrichSuggestionItems(
   )
   const sliced = filtered.slice(0, MAX_RESULTS)
   const final = disambiguateTitles(deduplicateByPath(sliced))
-  return final.map(({ group, ...rest }) => {
-    const noteType = group !== 'Note' ? group : undefined
-    const te = typeEntryMap[group]
+  return final.map(({ entryType, ...rest }) => {
+    const noteType = entryType ?? undefined
+    const te = noteType ? typeEntryMap[noteType] : undefined
     return {
       ...rest,
       noteType,
-      typeColor: noteType ? getTypeColor(group, te?.color) : undefined,
-      typeLightColor: noteType ? getTypeLightColor(group, te?.color) : undefined,
-      TypeIcon: noteType ? getTypeIcon(group, te?.icon) : undefined,
+      typeColor: noteType ? getTypeColor(noteType, te?.color) : undefined,
+      typeLightColor: noteType ? getTypeLightColor(noteType, te?.color) : undefined,
+      TypeIcon: noteType ? getTypeIcon(noteType, te?.icon) : undefined,
     }
   })
 }

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

@@ -65,6 +65,13 @@ function quickOpenSelectedTitle(page: Page) {
   return page.getByTestId('quick-open-palette').locator('[class*="bg-accent"] span.truncate').first()
 }
 
+async function focusHeadingEnd(page: Page, title: string) {
+  const heading = page.getByRole('heading', { name: title, level: 1 })
+  await expect(heading).toBeVisible({ timeout: 5_000 })
+  await heading.click()
+  await page.keyboard.press('End')
+}
+
 test('creating an untitled draft hides the legacy title section in the editor', async ({ page }) => {
   await page.locator('button[title="Create new note"]').click()
 
@@ -139,3 +146,29 @@ test('@smoke edited H1 titles drive note list, search, and wikilink autocomplete
   const suggestionMenu = page.locator('.wikilink-menu')
   await expect(suggestionMenu).toContainText(updatedTitle, { timeout: 5_000 })
 })
+
+test('@smoke rapid H1 typing stays stable while editing an existing note', async ({ page }) => {
+  const noteList = page.locator('[data-testid="note-list-container"]')
+  const firstTitle = 'Alpha Project Fast Typing Check'
+  const finalTitle = 'Alpha Project Fast Typing Flow'
+
+  await openNote(page, 'Alpha Project')
+  await focusHeadingEnd(page, 'Alpha Project')
+  await page.keyboard.type(' Fast Typing Check')
+
+  await expect(page.getByRole('heading', { name: firstTitle, level: 1 })).toBeVisible({ timeout: 5_000 })
+
+  for (let i = 0; i < ' Check'.length; i += 1) {
+    await page.keyboard.press('Backspace')
+  }
+  await page.keyboard.type(' Flow')
+  await page.keyboard.press('Meta+s')
+
+  await expect(page.getByRole('heading', { name: finalTitle, level: 1 })).toBeVisible({ timeout: 5_000 })
+  await expect(noteList.getByText(finalTitle, { exact: true })).toBeVisible({ timeout: 5_000 })
+  await expect(noteList.getByText('Alpha Project', { exact: true })).toHaveCount(0)
+
+  await openNote(page, 'Spring 2026')
+  await openNote(page, finalTitle)
+  await expect(page.getByRole('heading', { name: finalTitle, level: 1 })).toBeVisible({ timeout: 5_000 })
+})

tests/smoke/image-toolbar-hover.spec.ts

@@ -73,6 +73,24 @@ async function seedImageBlock(page: Page) {
   return image
 }
 
+async function moveMouseInSteps(
+  page: Page,
+  from: { x: number; y: number },
+  to: { x: number; y: number },
+  { steps, stepDelayMs }: { steps: number; stepDelayMs: number },
+) {
+  await page.mouse.move(from.x, from.y)
+
+  for (let step = 1; step <= steps; step += 1) {
+    const progress = step / steps
+    await page.mouse.move(
+      from.x + (to.x - from.x) * progress,
+      from.y + (to.y - from.y) * progress,
+    )
+    await page.waitForTimeout(stepDelayMs)
+  }
+}
+
 test.beforeEach(async ({ page }, testInfo) => {
   testInfo.setTimeout(90_000)
   tempVaultDir = createFixtureVaultCopy()
@@ -86,28 +104,34 @@ test.afterEach(async () => {
 test('image toolbar stays usable while the pointer crosses onto its controls', async ({ page }) => {
   const image = await seedImageBlock(page)
 
-  await image.click()
-
   const toolbar = page.locator('.bn-formatting-toolbar')
   const replaceButton = page.getByRole('button', { name: /Replace image/i })
 
-  await expect(toolbar).toBeVisible({ timeout: 5_000 })
-  await expect(replaceButton).toBeVisible()
-
   const imageBox = await image.boundingBox()
-  const replaceButtonBox = await replaceButton.boundingBox()
-
   expect(imageBox).not.toBeNull()
-  expect(replaceButtonBox).not.toBeNull()
 
   await page.mouse.move(
     imageBox!.x + imageBox!.width / 2,
     imageBox!.y + imageBox!.height / 2,
   )
-  await page.mouse.move(
-    replaceButtonBox!.x + replaceButtonBox!.width / 2,
-    replaceButtonBox!.y + replaceButtonBox!.height / 2,
-    { steps: 16 },
+
+  await expect(toolbar).toBeVisible({ timeout: 5_000 })
+  await expect(replaceButton).toBeVisible()
+
+  const replaceButtonBox = await replaceButton.boundingBox()
+  expect(replaceButtonBox).not.toBeNull()
+
+  await moveMouseInSteps(
+    page,
+    {
+      x: imageBox!.x + imageBox!.width / 2,
+      y: imageBox!.y + imageBox!.height / 2,
+    },
+    {
+      x: replaceButtonBox!.x + replaceButtonBox!.width / 2,
+      y: replaceButtonBox!.y + replaceButtonBox!.height / 2,
+    },
+    { steps: 12, stepDelayMs: 35 },
   )
 
   await expect(toolbar).toBeVisible()

tests/smoke/manual-commit-modal-autogit-off.spec.ts

@@ -0,0 +1,168 @@
+import { expect, test, type Page } from '@playwright/test'
+import { executeCommand, openCommandPalette } from './helpers'
+import { seedAutoGitSavedChange } from './testBridge'
+
+type MockHandler = (args?: Record<string, unknown>) => unknown
+
+function installCommitFlowMocks() {
+  type BrowserWindow = Window & typeof globalThis & {
+    __gitCommitMessages?: string[]
+    __gitPushCalls?: number
+    __mockHandlers?: Record<string, MockHandler>
+  }
+
+  const browserWindow = window as BrowserWindow
+  const dirtyPaths = new Set<string>()
+  let ahead = 0
+
+  const createModifiedFiles = () => [...dirtyPaths].map((path) => ({
+    path,
+    relativePath: path.split('/').pop() ?? path,
+    status: 'modified',
+  }))
+
+  const isPatched = (handlers?: Record<string, MockHandler> | null) =>
+    !handlers || (handlers as Record<string, unknown>).__manualCommitPatched === true
+
+  const patchSaveNoteContent = (handlers: Record<string, MockHandler>) => {
+    const originalSaveNoteContent = handlers.save_note_content
+    handlers.save_note_content = (args?: Record<string, unknown>) => {
+      const path = typeof args?.path === 'string' ? args.path : null
+      if (path) dirtyPaths.add(path)
+      return originalSaveNoteContent?.(args)
+    }
+  }
+
+  const patchGitHandlers = (handlers: Record<string, MockHandler>) => {
+    handlers.get_modified_files = () => createModifiedFiles()
+    handlers.git_commit = (args?: Record<string, unknown>) => {
+      const message = typeof args?.message === 'string' ? args.message : ''
+      browserWindow.__gitCommitMessages?.push(message)
+      dirtyPaths.clear()
+      ahead = 1
+      return `[main abc1234] ${message}`
+    }
+
+    handlers.git_push = () => {
+      browserWindow.__gitPushCalls = (browserWindow.__gitPushCalls ?? 0) + 1
+      ahead = 0
+      return { status: 'ok', message: 'Pushed to remote' }
+    }
+
+    handlers.git_remote_status = () => ({
+      branch: 'main',
+      ahead,
+      behind: 0,
+      hasRemote: true,
+    })
+  }
+
+  const markPatched = (handlers: Record<string, MockHandler>) => {
+    Object.defineProperty(handlers, '__manualCommitPatched', {
+      configurable: true,
+      enumerable: false,
+      value: true,
+    })
+  }
+
+  const patchHandlers = (handlers?: Record<string, MockHandler> | null) => {
+    if (isPatched(handlers)) {
+      return handlers ?? null
+    }
+
+    patchSaveNoteContent(handlers)
+    patchGitHandlers(handlers)
+    markPatched(handlers)
+    return handlers
+  }
+
+  browserWindow.__gitCommitMessages = []
+  browserWindow.__gitPushCalls = 0
+
+  let ref = patchHandlers(browserWindow.__mockHandlers) ?? null
+  Object.defineProperty(browserWindow, '__mockHandlers', {
+    configurable: true,
+    get() {
+      return patchHandlers(ref) ?? ref
+    },
+    set(value) {
+      ref = patchHandlers(value as Record<string, MockHandler> | undefined) ?? null
+    },
+  })
+}
+
+async function openFirstNote(page: Page) {
+  const noteList = page.locator('[data-testid="note-list-container"]')
+  await noteList.waitFor({ timeout: 5_000 })
+  await noteList.locator('.cursor-pointer').first().click()
+  await expect(page.locator('.bn-editor')).toBeVisible({ timeout: 5_000 })
+}
+
+async function setAutoGitEnabled(page: Page, enabled: boolean) {
+  await openCommandPalette(page)
+  await executeCommand(page, 'Open Settings')
+
+  const settingsPanel = page.getByTestId('settings-panel')
+  await expect(settingsPanel).toBeVisible({ timeout: 5_000 })
+
+  const toggle = page.getByRole('switch', { name: 'AutoGit' })
+  const isEnabled = (await toggle.getAttribute('aria-checked')) === 'true'
+  if (isEnabled !== enabled) {
+    await toggle.click()
+  }
+
+  await page.getByTestId('settings-save').click()
+  await expect(settingsPanel).not.toBeVisible({ timeout: 5_000 })
+}
+
+async function triggerCommitButton(page: Page) {
+  const commitButton = page.getByTestId('status-commit-push')
+  await commitButton.focus()
+  await expect(commitButton).toBeFocused()
+  await page.keyboard.press('Enter')
+}
+
+async function expectCommitMessage(page: Page, index: number, expectedMessage: string) {
+  await expect.poll(async () =>
+    page.evaluate(
+      ({ targetIndex }) => (window as Window & { __gitCommitMessages?: string[] }).__gitCommitMessages?.[targetIndex] ?? '',
+      { targetIndex: index },
+    ),
+  ).toBe(expectedMessage)
+}
+
+async function expectPushCount(page: Page, expectedCount: number) {
+  await expect.poll(async () =>
+    page.evaluate(() => (window as Window & { __gitPushCalls?: number }).__gitPushCalls ?? 0),
+  ).toBe(expectedCount)
+}
+
+test('@smoke commit entry opens the manual modal when AutoGit is off and switches back immediately when enabled', async ({ page }) => {
+  await page.addInitScript(installCommitFlowMocks)
+  await page.goto('/')
+  await page.waitForLoadState('networkidle')
+
+  await openFirstNote(page)
+  await setAutoGitEnabled(page, false)
+  await seedAutoGitSavedChange(page)
+  await triggerCommitButton(page)
+
+  await expect(page.getByRole('heading', { name: 'Commit & Push' })).toBeVisible()
+  const messageInput = page.locator('textarea[placeholder="Commit message..."]')
+  await expect(messageInput).toBeFocused()
+  await page.keyboard.press('Meta+A')
+  await page.keyboard.type('Manual commit from keyboard')
+  await page.keyboard.press('Meta+Enter')
+
+  await expect(page.locator('.fixed.bottom-8')).toContainText('Committed and pushed', { timeout: 5_000 })
+  await expectCommitMessage(page, 0, 'Manual commit from keyboard')
+  await expectPushCount(page, 1)
+
+  await setAutoGitEnabled(page, true)
+  await seedAutoGitSavedChange(page)
+  await triggerCommitButton(page)
+
+  await expect(messageInput).not.toBeVisible()
+  await expectCommitMessage(page, 1, 'Updated 1 note')
+  await expectPushCount(page, 2)
+})

tests/smoke/wikilink-path-fix.spec.ts

@@ -56,6 +56,7 @@ test.describe('Wikilink insertion and navigation', () => {
     await editor.click()
     await page.keyboard.press('End')
     await page.keyboard.press('Enter')
+    await page.waitForTimeout(200)
     await page.keyboard.type('[[Ma')
     await page.waitForTimeout(800)