Bugfix: Detect conflicts for compound-scope shortcuts

- `scope-hierarchy.ts` only knew simple scopes, so `getActiveScopes('Main window/File list')` (and every other compound scope) returned `[]`, and `scopesOverlap` short-circuits to false on an empty chain. The 48 compound-scope commands could never conflict with anything, including each other: binding the same combo to two File-list commands showed no warning.
- Unify on one scope vocabulary: `scope-hierarchy.ts` now re-exports `CommandScope` from `commands/types.ts`, dropping the legacy simple-scope-only type (`File list`, `Navigation`, `Selection`, `Edit`, `View`, `Help`, `Settings window` — none of which the registry uses).
- Give compound scopes correct ancestry chains: `Brief mode` / `Full mode` sit under `Main window/File list` (the list renders in both modes, so a mode key collides with a File-list key), while Brief and Full stay siblings (the default `←`/`→` pairs must not conflict). `Network` / `Share browser` / `Volume chooser` are siblings of the file list (a pane shows one INSTEAD of the list).
- Drop the now-redundant `as CommandScope` casts in `conflict-detector.ts` and `KeyboardShortcutsSection.svelte`.
- Add a regression test over the full registry: default bindings produce zero conflicts.

Author: vdavid

apps/desktop/src/lib/settings/CLAUDE.md

@@ -291,8 +291,9 @@ in `types.ts` bridges this gap. Don't expose raw pixel values in the UI.
 
 ### Shortcuts conflict only when scopes overlap
 
-`⌘N` in "File list" scope and `⌘N` in "Settings window" scope do NOT conflict because their scope hierarchies don't
-overlap. Only warn when the same key combo is used in overlapping scopes (e.g., "File list" and "Main window").
+`⌘N` in `Main window/File list` and `⌘N` in `About window` do NOT conflict because their scope chains don't overlap.
+Only warn when the same key combo is used in overlapping scopes (for example, `Main window/File list` and
+`Main window`). See `lib/shortcuts/CLAUDE.md` § "Scope hierarchy" for the full chain model.
 
 ### No undo
 

apps/desktop/src/lib/settings/sections/KeyboardShortcutsSection.svelte

@@ -23,7 +23,6 @@
         findConflictsForShortcut,
         getConflictingCommandIds,
         getConflictCount,
-        type CommandScope,
     } from '$lib/shortcuts'
     import { confirmDialog } from '$lib/utils/confirm-dialog'
     import GlobalShortcutRow from '$lib/downloads/GlobalShortcutRow.svelte'
@@ -186,7 +185,7 @@
         const currentEditCommandId = editingShortcut.commandId
         const command = commands.find((c) => c.id === currentEditCommandId)
         if (command) {
-            const conflicts = findConflictsForShortcut(combo, command.scope as CommandScope, command.id)
+            const conflicts = findConflictsForShortcut(combo, command.scope, command.id)
             if (conflicts.length > 0) {
                 conflictWarning = { shortcut: combo, conflictingCommand: conflicts[0] }
                 return // Don't auto-save, wait for user decision

apps/desktop/src/lib/shortcuts/CLAUDE.md

@@ -66,17 +66,27 @@ handler) can't drift. The settings side scrolls the row into its nested list and
 
 ### Scope hierarchy (`scope-hierarchy.ts`)
 
-Defines which shortcuts are active in each context:
-
-- `App` scope: global, always active
-- `Main window` → inherits `App`
-- `File list` → inherits `Main window` → inherits `App`
-
-When "File list" is focused, shortcuts from all three scopes can trigger.
-
-Note: the command registry uses compound scopes like `'Main window/File list'`, `'Main window/Brief mode'`,
-`'Main window/Full mode'`, `'Main window/Network'` that are distinct from the simple scope hierarchy defined in
-`scope-hierarchy.ts`. These compound scopes represent specific UI contexts within the main window.
+`CommandScope` is the single scope vocabulary — `scope-hierarchy.ts` re-exports it from `../commands/types.ts`, so the
+registry's `scope` strings and the hierarchy keys are the same type. `scopeHierarchy` holds each scope's ancestry chain
+(most specific first); two scopes "overlap" (and so can conflict) when one chain contains the other.
+
+The chains mirror what renders together in the app:
+
+- `App` → global, always active.
+- `Main window` → inherits `App`.
+- `Main window/File list` → inherits `Main window` → `App`.
+- `Main window/Brief mode` and `Main window/Full mode` → sit UNDER `Main window/File list` (→ `Main window` → `App`).
+  The file list renders in both view modes, so a mode-scoped key genuinely collides with a File-list key. Brief and Full
+  stay siblings (neither chain contains the other), so they don't conflict with each other — the registry binds `←`/`→`
+  in both on purpose, and the modes never coexist.
+- `Main window/Network`, `Main window/Share browser`, `Main window/Volume chooser` → siblings of `Main window/File list`
+  (under `Main window` → `App`, but not under the file list). A pane shows one of them INSTEAD of the file list, so
+  their keys don't collide with File-list keys.
+- `Command palette` → inherits `Main window` → `App` (it overlays the main window).
+- `About window` and `Onboarding` → inherit `App` only (standalone/modal contexts).
+
+`getActiveScopes(unknown)` returns `[]`, and `scopesOverlap` treats an empty chain as non-overlapping, so a typo'd scope
+silently can't conflict rather than throwing.
 
 ### Conflict detection (`conflict-detector.ts`)
 
@@ -85,7 +95,9 @@ Two commands conflict if:
 1. They share the same key combo, AND
 2. Their scopes overlap (via hierarchy)
 
-Example: `⌘N` in "File list" and `⌘N` in "Main window" conflict because "File list" inherits from "Main window".
+Example: `⌘N` in `Main window/File list` and `⌘N` in `Main window` conflict because the File-list chain contains
+`Main window`. Two `Main window/File list` commands sharing a combo also conflict (same scope). `←` in
+`Main window/Brief mode` and `←` in `Main window/Full mode` do NOT, because Brief and Full are siblings.
 
 ### Key capture (`key-capture.ts`)
 
@@ -221,8 +233,8 @@ are part of the app's behavior, not user data.
 
 ### Scope overlap is transitive
 
-If "File list" inherits "Main window" and "Main window" inherits "App", then "File list" also inherits "App". The
-`getActiveScopes()` function returns all ancestors, not just the immediate parent.
+If `Main window/File list` inherits `Main window` and `Main window` inherits `App`, then `Main window/File list` also
+inherits `App`. `getActiveScopes()` returns the full ancestry chain, not just the immediate parent.
 
 ### No chorded shortcuts
 

apps/desktop/src/lib/shortcuts/conflict-detector-registry.test.ts

@@ -0,0 +1,24 @@
+/**
+ * Regression test for conflict detection over the REAL command registry with
+ * default bindings (no mocks). Guards two things at once:
+ *
+ * 1. Compound-scope commands (`Main window/File list`, `Main window/Brief mode`,
+ *    …) participate in conflict detection. Before the scope hierarchy learned the
+ *    compound chains, `getActiveScopes` returned `[]` for these and the 48
+ *    compound-scope commands could never conflict with anything.
+ * 2. The shipped default bindings don't introduce conflicts. If a future default
+ *    edit binds the same combo to two overlapping-scope commands, this test
+ *    fails and surfaces exactly which combo.
+ */
+
+import { describe, it, expect } from 'vitest'
+import { getAllConflicts } from './conflict-detector'
+
+describe('conflict-detector over the real registry (default bindings)', () => {
+  it('reports no conflicts for the shipped defaults', () => {
+    const conflicts = getAllConflicts()
+    // Surface the offending combos in the failure message rather than a bare count.
+    const summary = conflicts.map((c) => `${c.shortcut}: ${c.commandIds.join(', ')}`)
+    expect(summary).toEqual([])
+  })
+})

apps/desktop/src/lib/shortcuts/conflict-detector.test.ts

@@ -77,9 +77,9 @@ describe('conflict-detector', () => {
     it('returns commands sharing the same shortcut in overlapping scopes', () => {
       setCommands(
         makeCommand({ id: 'a', shortcuts: ['⌘N'], scope: 'Main window' }),
-        makeCommand({ id: 'b', shortcuts: ['⌘N'], scope: 'File list' }),
+        makeCommand({ id: 'b', shortcuts: ['⌘N'], scope: 'Main window/File list' }),
       )
-      const conflicts = findConflictsForShortcut('⌘N', 'File list')
+      const conflicts = findConflictsForShortcut('⌘N', 'Main window/File list')
       const ids = conflicts.map((c) => c.id)
       expect(ids).toContain('a')
       expect(ids).toContain('b')
@@ -107,9 +107,9 @@ describe('conflict-detector', () => {
     it('returns empty array when scopes do not overlap', () => {
       setCommands(
         makeCommand({ id: 'a', shortcuts: ['⌘N'], scope: 'About window' }),
-        makeCommand({ id: 'b', shortcuts: ['⌘N'], scope: 'Settings window' }),
+        makeCommand({ id: 'b', shortcuts: ['⌘N'], scope: 'Command palette' }),
       )
-      // About window and Settings window don't overlap
+      // About window and Command palette don't overlap
       const conflicts = findConflictsForShortcut('⌘N', 'About window')
       const ids = conflicts.map((c) => c.id)
       expect(ids).toContain('a')
@@ -180,7 +180,7 @@ describe('conflict-detector', () => {
     it('does not report a conflict when scopes do not overlap', () => {
       setCommands(
         makeCommand({ id: 'a', shortcuts: ['⌘N'], scope: 'About window' }),
-        makeCommand({ id: 'b', shortcuts: ['⌘N'], scope: 'Settings window' }),
+        makeCommand({ id: 'b', shortcuts: ['⌘N'], scope: 'Command palette' }),
       )
       expect(getAllConflicts()).toEqual([])
     })
@@ -199,12 +199,12 @@ describe('conflict-detector', () => {
 
     it('handles three commands sharing a shortcut with partial scope overlap', () => {
       // a: App (overlaps with everything)
-      // b: About window (overlaps with App but not Settings window)
-      // c: Settings window (overlaps with App but not About window)
+      // b: About window (overlaps with App but not Command palette)
+      // c: Command palette (overlaps with App but not About window)
       setCommands(
         makeCommand({ id: 'a', shortcuts: ['⌘N'], scope: 'App' }),
         makeCommand({ id: 'b', shortcuts: ['⌘N'], scope: 'About window' }),
-        makeCommand({ id: 'c', shortcuts: ['⌘N'], scope: 'Settings window' }),
+        makeCommand({ id: 'c', shortcuts: ['⌘N'], scope: 'Command palette' }),
       )
       const conflicts = getAllConflicts()
       expect(conflicts).toHaveLength(1)
@@ -226,6 +226,54 @@ describe('conflict-detector', () => {
       const shortcuts = conflicts.map((c) => c.shortcut).sort()
       expect(shortcuts).toEqual(['⌘A', '⌘B'])
     })
+
+    // ----------------------------------------------------------------------
+    // Compound-scope conflicts (the regression these tests guard)
+    // ----------------------------------------------------------------------
+
+    it('detects a conflict between two File-list commands sharing a combo', () => {
+      setCommands(
+        makeCommand({ id: 'a', shortcuts: ['⌘K'], scope: 'Main window/File list' }),
+        makeCommand({ id: 'b', shortcuts: ['⌘K'], scope: 'Main window/File list' }),
+      )
+      const conflicts = getAllConflicts()
+      expect(conflicts).toHaveLength(1)
+      expect(conflicts[0].commandIds).toContain('a')
+      expect(conflicts[0].commandIds).toContain('b')
+    })
+
+    it('detects a conflict between a Main-window command and a File-list command sharing a combo', () => {
+      setCommands(
+        makeCommand({ id: 'a', shortcuts: ['⌘K'], scope: 'Main window' }),
+        makeCommand({ id: 'b', shortcuts: ['⌘K'], scope: 'Main window/File list' }),
+      )
+      const conflicts = getAllConflicts()
+      expect(conflicts).toHaveLength(1)
+      expect(conflicts[0].commandIds).toContain('a')
+      expect(conflicts[0].commandIds).toContain('b')
+    })
+
+    it('does NOT report a conflict for the default Brief/Full ←/→ pairs', () => {
+      // The registry binds ← and → in BOTH Brief and Full mode on purpose; the
+      // modes are mutually exclusive, so they must never be flagged as conflicts.
+      setCommands(
+        makeCommand({ id: 'nav.left', shortcuts: ['←'], scope: 'Main window/Brief mode' }),
+        makeCommand({ id: 'nav.right', shortcuts: ['→'], scope: 'Main window/Brief mode' }),
+        makeCommand({ id: 'nav.firstInFull', shortcuts: ['←'], scope: 'Main window/Full mode' }),
+        makeCommand({ id: 'nav.lastInFull', shortcuts: ['→'], scope: 'Main window/Full mode' }),
+      )
+      expect(getAllConflicts()).toEqual([])
+    })
+
+    it('does NOT report a conflict between a Network command and a File-list command (sibling views)', () => {
+      // Enter is bound on both network.selectHost and nav.open, but a pane shows
+      // the network browser INSTEAD of the file list, so they never coexist.
+      setCommands(
+        makeCommand({ id: 'network.selectHost', shortcuts: ['Enter'], scope: 'Main window/Network' }),
+        makeCommand({ id: 'nav.open', shortcuts: ['Enter'], scope: 'Main window/File list' }),
+      )
+      expect(getAllConflicts()).toEqual([])
+    })
   })
 
   // ========================================================================

apps/desktop/src/lib/shortcuts/conflict-detector.ts

@@ -40,7 +40,7 @@ export function getAllConflicts(): ShortcutConflict[] {
   for (const cmd of commands) {
     // Filter out empty shortcuts (used during editing)
     const shortcuts = getEffectiveShortcuts(cmd.id).filter((s) => s)
-    const scope = cmd.scope as CommandScope
+    const scope = cmd.scope
 
     for (const shortcut of shortcuts) {
       // Create a unique key for this shortcut
@@ -62,10 +62,9 @@ export function getAllConflicts(): ShortcutConflict[] {
         // Check for actual scope overlap between all pairs
         const actualConflicts: Command[] = []
         for (const c of conflictingCommands) {
-          const cScope = c.scope as CommandScope
           // Check if this command conflicts with any other
           const hasOverlap = conflictingCommands.some(
-            (other) => other.id !== c.id && scopesOverlap(cScope, other.scope),
+            (other) => other.id !== c.id && scopesOverlap(c.scope, other.scope),
           )
           if (hasOverlap) {
             actualConflicts.push(c)

apps/desktop/src/lib/shortcuts/scope-hierarchy.ts

@@ -3,42 +3,50 @@
  * Determines which scopes' shortcuts are active in a given context.
  */
 
-/** All available command scopes */
-export type CommandScope =
-  | 'App' // Global, works everywhere
-  | 'Main window' // Main window context
-  | 'File list' // File list focused
-  | 'Command palette' // Command palette open
-  | 'Navigation' // Navigation context
-  | 'Selection' // Selection operations
-  | 'Edit' // Edit operations
-  | 'View' // View operations
-  | 'Help' // Help operations
-  | 'About window' // About window context
-  | 'Settings window' // Settings window context
+import type { CommandScope } from '$lib/commands/types'
+
+export type { CommandScope }
 
 /**
  * Scope hierarchy - when a scope is active, these scopes' shortcuts also trigger.
- * Order matters: more specific scopes are listed first for priority.
+ * Each entry is the scope's ancestry chain, most specific first. Two scopes
+ * "overlap" (and so can conflict) when one chain contains the other.
+ *
+ * The chains mirror what actually renders together in the running app:
+ *
+ * - `Main window/Brief mode` / `Main window/Full mode` sit UNDER
+ *   `Main window/File list`: the file list renders in both view modes, so a
+ *   mode-scoped key genuinely collides with a File-list key. Brief and Full stay
+ *   siblings (neither chain contains the other), so they don't conflict with each
+ *   other — the registry binds ←/→ in both on purpose, and the modes never coexist.
+ * - `Main window/Network`, `Main window/Share browser`, and
+ *   `Main window/Volume chooser` are siblings of `Main window/File list`: a pane
+ *   shows one of them INSTEAD of the file list, so their keys don't collide with
+ *   File-list keys (they share only `Main window` + `App`).
+ *
+ * `Command palette` inherits `Main window` (it overlays the main window, so its
+ * keys can collide with Main-window keys). `Onboarding` is a modal under `App`
+ * only. (The registry has no `Onboarding` commands today; the chain is here so
+ * the union stays exhaustive.)
  */
 const scopeHierarchy: Record<CommandScope, CommandScope[]> = {
   App: ['App'],
   'Main window': ['Main window', 'App'],
-  'File list': ['File list', 'Main window', 'App'],
-  'Command palette': ['Command palette', 'Main window', 'App'],
-  Navigation: ['Navigation', 'Main window', 'App'],
-  Selection: ['Selection', 'Main window', 'App'],
-  Edit: ['Edit', 'Main window', 'App'],
-  View: ['View', 'Main window', 'App'],
-  Help: ['Help', 'Main window', 'App'],
+  'Main window/File list': ['Main window/File list', 'Main window', 'App'],
+  'Main window/Brief mode': ['Main window/Brief mode', 'Main window/File list', 'Main window', 'App'],
+  'Main window/Full mode': ['Main window/Full mode', 'Main window/File list', 'Main window', 'App'],
+  'Main window/Network': ['Main window/Network', 'Main window', 'App'],
+  'Main window/Share browser': ['Main window/Share browser', 'Main window', 'App'],
+  'Main window/Volume chooser': ['Main window/Volume chooser', 'Main window', 'App'],
   'About window': ['About window', 'App'],
-  'Settings window': ['Settings window', 'App'],
+  Onboarding: ['Onboarding', 'App'],
+  'Command palette': ['Command palette', 'Main window', 'App'],
 }
 
 /**
  * Get all scopes that are active when the given scope is current.
  * Returns scopes in priority order (most specific first).
- * Returns empty array for unknown/compound scopes (like 'Main window/File list').
+ * Returns empty array for an unknown scope.
  */
 export function getActiveScopes(current: string): CommandScope[] {
   if (current in scopeHierarchy) {
@@ -54,8 +62,8 @@ export function getActiveScopes(current: string): CommandScope[] {
 export function scopesOverlap(scopeA: string, scopeB: string): boolean {
   const activeA = getActiveScopes(scopeA)
   const activeB = getActiveScopes(scopeB)
-  // They overlap if either hierarchy includes the other scope
-  // If either scope is unknown (empty activeScopes), treat them as non-overlapping
+  // They overlap if one scope's ancestry chain contains the other.
+  // If either scope is unknown (empty chain), treat them as non-overlapping.
   if (activeA.length === 0 || activeB.length === 0) {
     return false
   }