From ae220457bab482d8e4a87a8f48a05a50b30aaad8 Mon Sep 17 00:00:00 2001
From: Siya <57148521+siyabendoezdemir@users.noreply.github.com>
Date: Sat, 10 Oct 2026 14:48:59 +0000
Subject: [PATCH 01/11] fix(keys): a page or view that loads no longer takes
 the keyboard (KS-16)

Electron gives a web contents the keyboard whenever its page commits a navigation
(focusOnNavigation). That held for a tab hidden behind another and for one that never had
the keyboard, so a slow page finishing its load took the keys from the open command bar,
from a sidebar field being typed in, or from the page in front (keys typed after it went
to the page that loaded). Every web contents Orbit makes now turns it off: tab pages,
pages a tab or Peek opens with window.open, and Orbit's own views (uiWebPreferences).
Orbit already gives a page the keyboard itself when the user selects, opens or clicks it.

keys.spec.ts types where the keyboard is while a slow page commits; the three tests fail
with focusOnNavigation on and pass with it off.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 FEATURES.md               |  6 +--
 docs/feature-status.json  |  1 +
 src/main/keys/focus.ts    | 12 +++++
 src/main/peek/index.ts    |  2 +
 src/main/tabs/commands.ts |  2 +
 src/main/tabs/runtime.ts  |  4 ++
 src/main/windows.ts       |  3 ++
 tests/e2e/keys.spec.ts    | 94 +++++++++++++++++++++++++++++++++++++++
 8 files changed, 121 insertions(+), 3 deletions(-)
 create mode 100644 src/main/keys/focus.ts
 create mode 100644 tests/e2e/keys.spec.ts

diff --git a/FEATURES.md b/FEATURES.md
index 135ecf10..fa1b5af9 100644
--- a/FEATURES.md
+++ b/FEATURES.md
@@ -4,11 +4,11 @@
 
 Every row is one behaviour from the clean-room spec. Status per ID: **spec’d** (every row) → **built** → **tested** (a unit or e2e test names the ID) → **feels right** (lead sign-off after a hands-on review against `feel.md`).
 
-**Totals:** 475 spec’d · 201 built (71 partial) · 280 tested · 0 feel right. 10 more are out of scope and not counted.
+**Totals:** 475 spec’d · 201 built (72 partial) · 281 tested · 0 feel right. 10 more are out of scope and not counted.
 
 | Priority | Spec’d | Built | Tested |
 |---|---|---|---|
-| P0 | 174 | 131 | 158 |
+| P0 | 174 | 131 | 159 |
 | P1 | 221 | 61 | 111 |
 | P2 | 80 | 9 | 11 |
 
@@ -361,7 +361,7 @@ Spec: `spec/shortcuts.md`
 | KS-13 | Developer tools | P1 | – | – | – |  |
 | KS-14 | Canvases, notes, capture and Tweaks | P2 | – | – | – |  |
 | KS-15 | Standard app and window keys | P1 | – | – | – |  |
-| KS-16 | Text-editing keys keep their meaning | P0 | – | – | – |  |
+| KS-16 | Text-editing keys keep their meaning | P0 | 🟡 partial | ✅ e2e | – | typed keys never go astray: a page or Orbit view that loads (a slow page, a background tab, a reload) no longer takes the keyboard from the command bar, a sidebar field or the page in front (focus-on-navigation off for every web contents Orbit makes); ⌘←/⌘→ act outside text fields only; the full text-editing and IME audit is still to do |
 | KS-17 | Mouse, trackpad and modifier-click bindings | P0 | – | – | – |  |
 | KS-18 | Shortcut hints everywhere | P1 | – | – | – |  |
 | KS-19 | Keys inside overlays | P0 | 🟡 partial | ✅ e2e | – | command bar: ⌘T/⌘L/⌘W/Esc handled by the bar first (ActionRegistry.intercept); other overlays belong to their lanes |
diff --git a/docs/feature-status.json b/docs/feature-status.json
index eefdb856..79bf8a39 100644
--- a/docs/feature-status.json
+++ b/docs/feature-status.json
@@ -136,6 +136,7 @@
   "KS-04": {"built": "yes", "note": "⌘T/⌘L/Alt+D, Esc, ⌘T/⌘L again, ↑/↓ (⌃N/⌃P), Enter, Tab, ⌫, ⇧Enter (option), ⌘⌥⌫ / Shift+Delete, ⌘⌥V"},
   "KS-07": {"built": "yes", "note": "Space shortcuts wired through the action table"},
   "KS-19": {"built": "partial", "note": "command bar: ⌘T/⌘L/⌘W/Esc handled by the bar first (ActionRegistry.intercept); other overlays belong to their lanes"},
+  "KS-16": {"built": "partial", "note": "typed keys never go astray: a page or Orbit view that loads (a slow page, a background tab, a reload) no longer takes the keyboard from the command bar, a sidebar field or the page in front (focus-on-navigation off for every web contents Orbit makes); ⌘←/⌘→ act outside text fields only; the full text-editing and IME audit is still to do"},
   "FL-13": {"built": "yes", "note": "strip of pages, 1:1 tracking, commit thresholds, settle/rubber-band springs, one-page slides for clicks and keys, reduced motion cross-fade"},
   "FL-14": {"built": "yes", "note": "theme blends with the gesture/spring in OKLab; 200 ms preset blends; light/dark cross-fade"},
   "FL-16": {"built": "yes", "note": "motion spring (0.97→1, 4 px drop), 100 ms exit (80 ms after choosing a row) while focus returns at once; fade only with reduced motion; centred in the window"},
diff --git a/src/main/keys/focus.ts b/src/main/keys/focus.ts
new file mode 100644
index 00000000..383b839f
--- /dev/null
+++ b/src/main/keys/focus.ts
@@ -0,0 +1,12 @@
+/**
+ * KS-16: the keyboard moves only when the user asks.
+ *
+ * Electron hands a web contents the keyboard each time its page commits a navigation
+ * (`focusOnNavigation`, on unless turned off). That holds for a page hidden behind another tab
+ * and for one that never had the keyboard, so a slow page finishing its load took the keyboard
+ * from the open command bar, from a field in the sidebar, or from the page being typed in, and
+ * the keys after it went to that page. Every web contents Orbit makes for its windows (pages and
+ * Orbit's own views) turns it off: Orbit gives a page the keyboard itself when the user selects,
+ * opens or clicks it.
+ */
+export const KEEP_KEYBOARD = { focusOnNavigation: false } as const satisfies Electron.WebPreferences
diff --git a/src/main/peek/index.ts b/src/main/peek/index.ts
index 39c3f991..4c42e002 100644
--- a/src/main/peek/index.ts
+++ b/src/main/peek/index.ts
@@ -15,6 +15,7 @@ import { layoutLeaves, MAX_PANES, SPLIT_FULL_MESSAGE } from '../../shared/split'
 import type { OrbitState, SpaceId, Tab, TabId, WindowId } from '../../shared/state'
 import { insertItem, sectionOf, splitOfTab } from '../../shared/tree'
 import type { MainContext } from '../context'
+import { KEEP_KEYBOARD } from '../keys/focus'
 import { openMiniWindow } from '../miniwindow'
 import type { CallContext } from '../registry'
 import { activateInDraft, todayInsertIndex } from '../tabs/model'
@@ -649,6 +650,7 @@ export function registerPeek(ctx: MainContext): void {
         return {
           action: 'allow',
           outlivesOpener: true,
+          overrideBrowserWindowOptions: { webPreferences: KEEP_KEYBOARD },
           createWindow: (options) => {
             const guest = (options as { webContents?: WebContents }).webContents
             let created: WebContents | undefined
diff --git a/src/main/tabs/commands.ts b/src/main/tabs/commands.ts
index 4b8720ff..56db6f44 100644
--- a/src/main/tabs/commands.ts
+++ b/src/main/tabs/commands.ts
@@ -24,6 +24,7 @@ import {
 } from '../../shared/tree'
 import { engineForWindow, parseInput } from '../../shared/url'
 import type { MainContext } from '../context'
+import { KEEP_KEYBOARD } from '../keys/focus'
 import type { CallContext } from '../registry'
 import { tabSplitMenuItems } from '../split/menu'
 import { TabMaintenance } from './maintenance'
@@ -465,6 +466,7 @@ export function registerTabs(ctx: MainContext): { ops: TabOps; maintenance: TabM
       return {
         action: 'allow',
         outlivesOpener: true,
+        overrideBrowserWindowOptions: { webPreferences: KEEP_KEYBOARD },
         createWindow: (options) => {
           const windowId = windows.windowOfTab(openerTabId) ?? windows.focusedWindowId()
           const spaceId = windowId ? ops.spaceOfWindow(windowId) : opener.spaceId
diff --git a/src/main/tabs/runtime.ts b/src/main/tabs/runtime.ts
index 7afb3a84..7f84451c 100644
--- a/src/main/tabs/runtime.ts
+++ b/src/main/tabs/runtime.ts
@@ -15,6 +15,7 @@ import { isPrivateProfileId } from '../../shared/private'
 import type { Tab, TabId } from '../../shared/state'
 import { isAwayFromPinned, sameDocUrl } from '../../shared/tabs'
 import type { MainContext } from '../context'
+import { KEEP_KEYBOARD } from '../keys/focus'
 import { showPageContextMenu } from './context-menu'
 import { FaviconStore } from './favicon-store'
 import { isIco, readIco } from './ico'
@@ -213,6 +214,8 @@ export class TabRuntime {
         scrollBounce: true,
         navigateOnDragDrop: false,
         safeDialogs: true,
+        // A page that loads never takes the keyboard (KS-16).
+        ...KEEP_KEYBOARD,
       },
     })
     this.adopt(tabId, view)
@@ -538,6 +541,7 @@ export class TabRuntime {
     return {
       action: 'allow',
       outlivesOpener: true,
+      overrideBrowserWindowOptions: { webPreferences: KEEP_KEYBOARD },
       createWindow: (options) => {
         const guest = (options as { webContents?: WebContents }).webContents
         // No page after all (only links the browser opens come without one): Orbit loads it.
diff --git a/src/main/windows.ts b/src/main/windows.ts
index 4a900879..e2980f32 100644
--- a/src/main/windows.ts
+++ b/src/main/windows.ts
@@ -17,6 +17,7 @@ import type {
 import { paletteFor } from '../shared/theme'
 import { splitLeaves, splitOfTab } from '../shared/tree'
 import type { MainContext } from './context'
+import { KEEP_KEYBOARD } from './keys/focus'
 import { focusIsEditable } from './nav/focus'
 import { fastSwitchPanes } from './split/layout'
 
@@ -168,6 +169,8 @@ export function uiWebPreferences(windowId: WindowId, view: RendererView): Electr
     nodeIntegration: false,
     spellcheck: false,
     additionalArguments: [`--orbit-window-id=${windowId}`, `--orbit-view=${view}`],
+    // A view that (re)loads never takes the keyboard (KS-16).
+    ...KEEP_KEYBOARD,
   }
 }
 
diff --git a/tests/e2e/keys.spec.ts b/tests/e2e/keys.spec.ts
new file mode 100644
index 00000000..6dc0513d
--- /dev/null
+++ b/tests/e2e/keys.spec.ts
@@ -0,0 +1,94 @@
+import { expect, test } from '@playwright/test'
+import { launchOrbit, MOD, type Orbit, run, state, viewPage } from './helpers'
+import { cmd, type NavFixtures, openTab, startNavFixtures } from './nav-support'
+
+let fx: NavFixtures
+let orbit: Orbit
+
+test.beforeAll(async () => {
+  fx = await startNavFixtures()
+})
+test.afterAll(async () => {
+  await fx.close()
+})
+test.beforeEach(async () => {
+  orbit = await launchOrbit()
+})
+test.afterEach(async () => {
+  await orbit.app.close()
+})
+
+/**
+ * Types each key wherever the keyboard is, as the keyboard does (to the web contents that has
+ * focus, not to a page the test picks); returns the URL of what took each key.
+ */
+function typeAnywhere(keys: string[]): Promise<string[]> {
+  return orbit.app.evaluate(
+    ({ webContents }, list) =>
+      list.map((key) => {
+        const contents = webContents.getFocusedWebContents()
+        if (!contents) return '(nothing)'
+        contents.sendInputEvent({ type: 'keyDown', keyCode: key })
+        if ([...key].length === 1) contents.sendInputEvent({ type: 'char', keyCode: key })
+        contents.sendInputEvent({ type: 'keyUp', keyCode: key })
+        return contents.getURL()
+      }),
+    keys,
+  )
+}
+
+/** Starts a slow load in a tab: the page commits only when the test releases it. */
+async function slowLoad(tabId: string, path: string): Promise<void> {
+  await cmd(orbit.app, 'tabs.navigate', { tabId, url: fx.url(path) })
+  await expect.poll(() => fx.hits(path)).toBe(1)
+}
+
+/** Lets the slow page in and waits until its tab has finished loading. */
+async function finishLoad(tabId: string, path: string): Promise<void> {
+  fx.release(path)
+  await expect.poll(async () => (await state(orbit.app)).tabs[tabId]?.loading).toBe(false)
+  await expect.poll(async () => (await state(orbit.app)).tabs[tabId]?.url).toBe(fx.url(path))
+}
+
+test('[KS-16] keys typed into the command bar while a slow page finishes loading all reach the bar', async () => {
+  const { app, shell } = orbit
+  const id = await openTab(app, fx.url('/page/Start'))
+  await slowLoad(id, '/slow/Late')
+  await shell.keyboard.press(`${MOD}+T`)
+  const input = (await viewPage(app, 'overlay')).getByTestId('command-input')
+  await expect(input).toBeFocused()
+  const before = await typeAnywhere(['a', 'b', 'c'])
+  await finishLoad(id, '/slow/Late')
+  const after = await typeAnywhere(['d', 'e', 'f'])
+  // Every key went to the command bar's view, none to the page that finished loading.
+  expect(new Set([...before, ...after]).size).toBe(1)
+  expect(after[0]).toContain('view=overlay')
+  await expect(input).toHaveValue('abcdef')
+})
+
+test('[KS-16] a page that finishes loading leaves a sidebar field being typed in alone', async () => {
+  const { app, shell } = orbit
+  const id = await openTab(app, fx.url('/page/Start'))
+  await slowLoad(id, '/slow/Renamed')
+  // Double-clicking the tab's row gives the sidebar the keyboard and opens the name field.
+  await run(app, 'tabs.focusSidebar')
+  await shell.locator(`[data-testid="tab-row"][data-tab-id="${id}"]`).dblclick()
+  const field = shell.getByTestId('rename-field')
+  await expect(field).toBeFocused()
+  await typeAnywhere(['a', 'b'])
+  await finishLoad(id, '/slow/Renamed')
+  await typeAnywhere(['c', 'd'])
+  await expect(field).toBeVisible()
+  await expect(field).toHaveValue('abcd')
+})
+
+test('[KS-16] a tab in the background that loads again does not take the keyboard from the page in front', async () => {
+  const { app } = orbit
+  const back = await openTab(app, fx.url('/page/Back'))
+  await slowLoad(back, '/slow/BackAgain')
+  const front = await openTab(app, fx.url('/page/Front'))
+  await expect.poll(async () => (await state(app)).tabs[front]?.loading).toBe(false)
+  expect(await typeAnywhere(['a'])).toEqual([fx.url('/page/Front')])
+  await finishLoad(back, '/slow/BackAgain')
+  expect(await typeAnywhere(['b', 'c'])).toEqual([fx.url('/page/Front'), fx.url('/page/Front')])
+})

From 755e235d93aed776b7d33881e69b8f29b0509365 Mon Sep 17 00:00:00 2001
From: Siya <57148521+siyabendoezdemir@users.noreply.github.com>
Date: Sat, 10 Oct 2026 14:59:52 +0000
Subject: [PATCH 02/11] feat(keys): one live keymap with remapping, several
 bindings and persistence (KS-01, KS-18)

Every action's bindings now come from one keymap: the defaults in
src/shared/actions.ts with the user's changes from settings.shortcuts on
top. The key router, the macOS menu bar (rebuilt after a remap), the
command bar's action rows and the tooltips read it live, so a remap
reaches every hint without a restart.

- keys.bind / keys.unbind / keys.reset / keys.resetAll: replace a
  binding or add one (up to 5 per action), take one off (the command bar
  and menus still run the action), reset to the defaults. A binding needs
  a modifier except F1-F12; keys the system keeps are refused; a key
  another action has is reported as a conflict until the caller asks to
  clear or swap it; fixed actions (Settings, the recent-tab switcher)
  keep theirs.
- Bindings that type or edit text (Shift+letter, the caret keys) act
  only outside text fields, like Cmd+Left already did; a Ctrl+Alt press
  that typed an AltGr character acts only outside text fields; plain keys
  belong to an input method while it composes.
- settings.shortcuts and settings.shortcutPriority are cleaned on load.
- keys.record lets Settings -> Shortcuts record a binding in main.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 FEATURES.md                                   |  18 +-
 docs/feature-status.json                      |   2 +
 src/main/archive/index.ts                     |   8 +-
 src/main/commandbar/sources.ts                |   6 +-
 src/main/features.ts                          |   3 +
 src/main/keys/bindings.ts                     | 187 ++++++++
 src/main/keys/index.ts                        |  69 +++
 src/main/keys/router.ts                       |  68 +++
 src/main/persist.ts                           |   2 +
 src/main/windows.ts                           |   6 +
 src/renderer/src/keys/live.ts                 |  33 ++
 src/renderer/src/library/LibraryButton.tsx    |  10 +-
 src/renderer/src/mini/MiniApp.tsx             |   5 +-
 src/renderer/src/overlay/PeekLayer.tsx        |   3 +
 .../src/overlay/find/PageToolsApp.tsx         |   5 +
 src/renderer/src/shell/ContentArea.tsx        |  15 +-
 src/renderer/src/shell/chrome/Address.tsx     |   3 +
 src/renderer/src/shell/chrome/NavButtons.tsx  |   5 +
 .../src/shell/sidebar/SidebarItems.tsx        |   5 +-
 src/renderer/src/shell/sidebar/SpaceBar.tsx   |   4 +-
 src/renderer/src/shell/sidebar/TopBar.tsx     |   3 +
 src/renderer/src/shortcuts.ts                 |   3 +
 src/shared/actions.ts                         | 270 +++++------
 src/shared/commands/keys.ts                   |  60 +++
 src/shared/keymap.ts                          | 428 ++++++++++++++++++
 src/shared/rpc.ts                             |   4 +-
 src/shared/state.ts                           |   8 +
 tests/e2e/keys.spec.ts                        | 111 ++++-
 tests/unit/keymap-bindings.test.ts            | 139 ++++++
 tests/unit/keymap-remap.test.ts               | 235 ++++++++++
 30 files changed, 1564 insertions(+), 154 deletions(-)
 create mode 100644 src/main/keys/bindings.ts
 create mode 100644 src/main/keys/index.ts
 create mode 100644 src/main/keys/router.ts
 create mode 100644 src/renderer/src/keys/live.ts
 create mode 100644 src/shared/commands/keys.ts
 create mode 100644 src/shared/keymap.ts
 create mode 100644 tests/unit/keymap-bindings.test.ts
 create mode 100644 tests/unit/keymap-remap.test.ts

diff --git a/FEATURES.md b/FEATURES.md
index fa1b5af9..3947961a 100644
--- a/FEATURES.md
+++ b/FEATURES.md
@@ -4,12 +4,12 @@
 
 Every row is one behaviour from the clean-room spec. Status per ID: **spec’d** (every row) → **built** → **tested** (a unit or e2e test names the ID) → **feels right** (lead sign-off after a hands-on review against `feel.md`).
 
-**Totals:** 475 spec’d · 201 built (72 partial) · 281 tested · 0 feel right. 10 more are out of scope and not counted.
+**Totals:** 475 spec’d · 201 built (74 partial) · 285 tested · 0 feel right. 10 more are out of scope and not counted.
 
 | Priority | Spec’d | Built | Tested |
 |---|---|---|---|
-| P0 | 174 | 131 | 159 |
-| P1 | 221 | 61 | 111 |
+| P0 | 174 | 131 | 161 |
+| P1 | 221 | 61 | 113 |
 | P2 | 80 | 9 | 11 |
 
 P0 = milestone-1 core experience, P1 = parity, P2 = later.
@@ -346,9 +346,9 @@ Spec: `spec/shortcuts.md`
 
 | ID | Feature | P | Built | Tested | Feels right | Notes |
 |---|---|---|---|---|---|---|
-| KS-01 | One keymap, remapping and persistence | P0 | – | ✅ e2e | – |  |
-| KS-02 | Conflicts with web pages ("prefer websites" vs "prefer Orbit") | P0 | – | – | – |  |
-| KS-03 | Platform mapping rules | P0 | – | – | – |  |
+| KS-01 | One keymap, remapping and persistence | P0 | 🟡 partial | ✅ e2e+unit | – | one keymap keyed by action id (src/shared/actions.ts + src/shared/keymap.ts): the key router, macOS menu bar (rebuilt on a remap), tooltips and command-bar rows read the live bindings; remap, several bindings per action (up to 5), none (command bar and menus still run it), a modifier required except F1-F12, system keys refused, conflicts reported (clear or swap), reset; stored per device in settings.shortcuts, cleaned on load, kept across a restart (Space keys too); the Settings → Shortcuts page comes with ST-08 |
+| KS-02 | Conflicts with web pages ("prefer websites" vs "prefer Orbit") | P0 | – | ✅ unit | – |  |
+| KS-03 | Platform mapping rules | P0 | – | ✅ unit | – |  |
 | KS-04 | Command bar and address | P0 | ✅ | ✅ e2e | – | ⌘T/⌘L/Alt+D, Esc, ⌘T/⌘L again, ↑/↓ (⌃N/⌃P), Enter, Tab, ⌫, ⇧Enter (option), ⌘⌥⌫ / Shift+Delete, ⌘⌥V |
 | KS-05 | Tabs and windows | P0 | – | – | – |  |
 | KS-06 | Switching tabs | P0 | – | – | – |  |
@@ -361,9 +361,9 @@ Spec: `spec/shortcuts.md`
 | KS-13 | Developer tools | P1 | – | – | – |  |
 | KS-14 | Canvases, notes, capture and Tweaks | P2 | – | – | – |  |
 | KS-15 | Standard app and window keys | P1 | – | – | – |  |
-| KS-16 | Text-editing keys keep their meaning | P0 | 🟡 partial | ✅ e2e | – | typed keys never go astray: a page or Orbit view that loads (a slow page, a background tab, a reload) no longer takes the keyboard from the command bar, a sidebar field or the page in front (focus-on-navigation off for every web contents Orbit makes); ⌘←/⌘→ act outside text fields only; the full text-editing and IME audit is still to do |
+| KS-16 | Text-editing keys keep their meaning | P0 | 🟡 partial | ✅ e2e+unit | – | typed keys never go astray: a page or Orbit view that loads (a slow page, a background tab, a reload) no longer takes the keyboard from the command bar, a sidebar field or the page in front (focus-on-navigation off for every web contents Orbit makes); ⌘←/⌘→ act outside text fields only; the full text-editing and IME audit is still to do |
 | KS-17 | Mouse, trackpad and modifier-click bindings | P0 | – | – | – |  |
-| KS-18 | Shortcut hints everywhere | P1 | – | – | – |  |
+| KS-18 | Shortcut hints everywhere | P1 | 🟡 partial | ✅ e2e | – | button tooltips (address, copy link, site controls, sidebar toggle, back/forward/reload, find, zoom, Library, Clear, Space dots, Peek, Mini Window Open in…), the empty-window hint, command-bar rows and macOS menu items follow a remap without a restart; context menus and the shortcut sheet (OB-12) to come |
 | KS-19 | Keys inside overlays | P0 | 🟡 partial | ✅ e2e | – | command bar: ⌘T/⌘L/⌘W/Esc handled by the bar first (ActionRegistry.intercept); other overlays belong to their lanes |
 | KS-20 | Shortcuts in special windows | P1 | – | – | – |  |
 
@@ -542,7 +542,7 @@ Spec: `spec/settings.md`
 | ST-05 | Per-profile: auto-archive timing | P1 | ✅ | ✅ e2e+unit | – | 12 hours (default), 24 hours, 7 days, 30 days per profile; no Never; other profiles follow Default until set |
 | ST-06 | Per-profile: default search engine and custom engines | P0 | ✅ | ✅ e2e+unit | – | per-profile default engine (8 built-ins), custom engines with keyword and %s URL, Make default from the row menu; no extension override in Electron, so that row does not exist |
 | ST-07 | Per-profile: download location, new-document app, data shortcuts | P1 | – | – | – |  |
-| ST-08 | Shortcuts section (remapping) | P1 | – | – | – |  |
+| ST-08 | Shortcuts section (remapping) | P1 | – | ✅ unit | – |  |
 | ST-09 | Links section | P1 | ✅ | ✅ e2e+unit | – | links from other apps open in a Mini Window (default), the most recent Space or one Space; routing rules (address contains / is exactly → a Space; first match wins; add, edit, reorder, remove); Peek options |
 | ST-10 | Advanced section | P1 | 🟡 partial | ✅ e2e+unit | – | tab sleep timer (TB-16), picture in picture, graphics acceleration; no site customizations, full-URL toggle, sounds or haptics, or edge-drag settings because those features don't exist yet |
 | ST-11 | Appearance section | P1 | 🟡 partial | ✅ e2e | – | Theme mode: Light / Dark / Match system (AP-01). Not built: window material (AP-10, Windows), app icon (AP-09), page defaults (P2) |
diff --git a/docs/feature-status.json b/docs/feature-status.json
index 79bf8a39..59365038 100644
--- a/docs/feature-status.json
+++ b/docs/feature-status.json
@@ -137,6 +137,8 @@
   "KS-07": {"built": "yes", "note": "Space shortcuts wired through the action table"},
   "KS-19": {"built": "partial", "note": "command bar: ⌘T/⌘L/⌘W/Esc handled by the bar first (ActionRegistry.intercept); other overlays belong to their lanes"},
   "KS-16": {"built": "partial", "note": "typed keys never go astray: a page or Orbit view that loads (a slow page, a background tab, a reload) no longer takes the keyboard from the command bar, a sidebar field or the page in front (focus-on-navigation off for every web contents Orbit makes); ⌘←/⌘→ act outside text fields only; the full text-editing and IME audit is still to do"},
+  "KS-01": {"built": "partial", "note": "one keymap keyed by action id (src/shared/actions.ts + src/shared/keymap.ts): the key router, macOS menu bar (rebuilt on a remap), tooltips and command-bar rows read the live bindings; remap, several bindings per action (up to 5), none (command bar and menus still run it), a modifier required except F1-F12, system keys refused, conflicts reported (clear or swap), reset; stored per device in settings.shortcuts, cleaned on load, kept across a restart (Space keys too); the Settings → Shortcuts page comes with ST-08"},
+  "KS-18": {"built": "partial", "note": "button tooltips (address, copy link, site controls, sidebar toggle, back/forward/reload, find, zoom, Library, Clear, Space dots, Peek, Mini Window Open in…), the empty-window hint, command-bar rows and macOS menu items follow a remap without a restart; context menus and the shortcut sheet (OB-12) to come"},
   "FL-13": {"built": "yes", "note": "strip of pages, 1:1 tracking, commit thresholds, settle/rubber-band springs, one-page slides for clicks and keys, reduced motion cross-fade"},
   "FL-14": {"built": "yes", "note": "theme blends with the gesture/spring in OKLab; 200 ms preset blends; light/dark cross-fade"},
   "FL-16": {"built": "yes", "note": "motion spring (0.97→1, 4 px drop), 100 ms exit (80 ms after choosing a row) while focus returns at once; fade only with reduced motion; centred in the window"},
diff --git a/src/main/archive/index.ts b/src/main/archive/index.ts
index d565fad1..31ddb03a 100644
--- a/src/main/archive/index.ts
+++ b/src/main/archive/index.ts
@@ -385,8 +385,11 @@ export function registerArchive(ctx: MainContext): ArchiveApi {
   // ---- Recently Closed (AR-09) ----
 
   const reopenAction = ACTIONS_BY_ID['tab.reopenClosed']
-  const reopenShortcut = reopenAction ? shortcutsFor(reopenAction, process.platform)[0] : undefined
-  const reopenKey = reopenShortcut ? toElectronAccelerator(reopenShortcut) : undefined
+  // Read as the menu opens: the user may have remapped it (KS-01, KS-18).
+  const reopenKeyNow = () => {
+    const shortcut = reopenAction ? shortcutsFor(reopenAction, process.platform)[0] : undefined
+    return shortcut ? toElectronAccelerator(shortcut) : undefined
+  }
   // The app menu's Recently Closed submenu follows the list (macOS has the only app menu).
   watchRecentlyClosed(ctx, () => {
     if (process.platform === 'darwin') installMenu(ctx)
@@ -395,6 +398,7 @@ export function registerArchive(ctx: MainContext): ArchiveApi {
     const windowId = windowOf(c)
     await refreshRecentlyClosed(ctx)
     const list = recentlyClosedItems(ctx, () => windowId)
+    const reopenKey = reopenKeyNow()
     const items: MenuItemConstructorOptions[] = [
       ...list,
       { type: 'separator' },
diff --git a/src/main/commandbar/sources.ts b/src/main/commandbar/sources.ts
index cd39c489..46619cf7 100644
--- a/src/main/commandbar/sources.ts
+++ b/src/main/commandbar/sources.ts
@@ -5,6 +5,7 @@
  */
 import { ACTIONS, formatAccelerator, shortcutsFor } from '../../shared/actions'
 import { isFolderId, isSplitId, isTabId } from '../../shared/ids'
+import { keymapVersion } from '../../shared/keymap'
 import type { ArchivedTab, FolderId, ItemId, OrbitState, ProfileId, SpaceId, Tab, TabId } from '../../shared/state'
 import { splitLeaves } from '../../shared/tree'
 import { type ArchiveSource, archiveSource } from '../archive/inbox'
@@ -59,6 +60,8 @@ export class SourceCache {
   private spaceDocs: SpaceDoc[] = []
   private names: Record<SpaceId, string> = {}
   private actionDocs: ActionDoc[] | undefined
+  /** The keymap the action docs' shortcuts were read from: a remap builds them again (KS-18). */
+  private actionDocsKeymap = -1
 
   /** Every tab in every Space (pinned, Favorites, Today, folders, splits). */
   tabs(state: OrbitState): TabDoc[] {
@@ -148,7 +151,8 @@ export class SourceCache {
 
   /** Visible actions that have a handler, with their shortcut for this platform (CB-13). */
   actions(has: (id: string) => boolean, platform: string): ActionDoc[] {
-    if (this.actionDocs) return this.actionDocs
+    if (this.actionDocs && this.actionDocsKeymap === keymapVersion()) return this.actionDocs
+    this.actionDocsKeymap = keymapVersion()
     this.actionDocs = ACTIONS.filter((a) => !a.hidden && !NOT_IN_BAR.has(a.id) && has(a.id)).map((a) => {
       const accel = shortcutsFor(a, platform)[0]
       const titleLower = a.title.toLowerCase()
diff --git a/src/main/features.ts b/src/main/features.ts
index fcfb1441..14149ee5 100644
--- a/src/main/features.ts
+++ b/src/main/features.ts
@@ -6,6 +6,7 @@ import { registerDownloads } from './downloads'
 import { registerExtensions } from './extensions'
 import { registerHistory } from './history'
 import { registerImport } from './import'
+import { registerKeys } from './keys'
 import { registerMedia } from './media'
 import { registerMiniWindow } from './miniwindow'
 import { registerNav } from './nav'
@@ -19,6 +20,8 @@ import { registerUpdates } from './updates'
 
 /** Every feature module registers its commands, actions and hooks here, in dependency order. */
 export function registerFeatures(ctx: MainContext): void {
+  // First: the user's key bindings, so whatever reads a shortcut as it registers reads theirs (KS-01).
+  registerKeys(ctx)
   registerCore(ctx)
   const { ops } = registerTabs(ctx)
   registerNav(ctx, ops)
diff --git a/src/main/keys/bindings.ts b/src/main/keys/bindings.ts
new file mode 100644
index 00000000..8e5d2317
--- /dev/null
+++ b/src/main/keys/bindings.ts
@@ -0,0 +1,187 @@
+import {
+  ACTIONS,
+  ACTIONS_BY_ID,
+  type ActionDef,
+  buildKeymap,
+  defaultPriorityFor,
+  defaultShortcutsFor,
+} from '../../shared/actions'
+import type { BindRequest, BindResult, ShortcutPriority } from '../../shared/commands/keys'
+import { bindingProblem, type CustomBindings, canonicalAccelerator, formatAccelerator } from '../../shared/keymap'
+import type { Settings } from '../../shared/state'
+
+/**
+ * The user's key bindings (KS-01) and priorities (KS-02) as `settings.shortcuts` and
+ * `settings.shortcutPriority` keep them. Pure: each change takes the stored map and returns the
+ * next one, which src/main/keys/index.ts saves.
+ */
+
+/** Most bindings one action keeps (KS-01: aliases such as Back = ⌘[ and ⌘←). */
+export const MAX_BINDINGS = 5
+
+type Bindings = Record<string, string[]>
+
+const isRecord = (v: unknown): v is Record<string, unknown> => typeof v === 'object' && v !== null && !Array.isArray(v)
+
+const canon = (list: readonly string[]): string[] =>
+  list.map((a) => canonicalAccelerator(a)).filter((a): a is string => a !== undefined)
+
+const sameList = (a: readonly string[], b: readonly string[]) => a.length === b.length && a.every((x, i) => x === b[i])
+
+const copy = (custom: CustomBindings | undefined): Bindings =>
+  Object.fromEntries(Object.entries(custom ?? {}).map(([id, list]) => [id, [...list]]))
+
+/** Stores an action's list, or drops its entry when the list is its defaults again. */
+function settle(custom: Bindings, action: ActionDef, list: string[], platform: string): void {
+  if (sameList(list, canon(defaultShortcutsFor(action, platform)))) delete custom[action.id]
+  else custom[action.id] = list
+}
+
+/**
+ * The stored bindings made safe to use (on load): actions that exist and can change, bindings
+ * Orbit can use (KS-01 validation), each binding on one action (the first in the action list
+ * keeps it; fixed actions' keys are never taken), at most MAX_BINDINGS each. Undefined when
+ * nothing differs from the defaults.
+ */
+export function normalizeShortcuts(value: unknown, platform: string): Bindings | undefined {
+  if (!isRecord(value)) return undefined
+  const out: Bindings = {}
+  const taken = new Set<string>()
+  for (const action of ACTIONS)
+    if (action.fixed) for (const key of canon(defaultShortcutsFor(action, platform))) taken.add(key)
+  for (const action of ACTIONS) {
+    const raw = value[action.id]
+    if (action.fixed || !Array.isArray(raw)) continue
+    const list: string[] = []
+    for (const accel of raw) {
+      if (typeof accel !== 'string' || bindingProblem(accel, platform) !== undefined) continue
+      const key = canonicalAccelerator(accel) as string
+      if (taken.has(key) || list.length >= MAX_BINDINGS) continue
+      taken.add(key)
+      list.push(key)
+    }
+    settle(out, action, list, platform)
+  }
+  return Object.keys(out).length > 0 ? out : undefined
+}
+
+/** The stored priorities made safe to use: known actions, known values, only where they differ from the default. */
+export function normalizePriorities(value: unknown, platform: string): Record<string, ShortcutPriority> | undefined {
+  if (!isRecord(value)) return undefined
+  const out: Record<string, ShortcutPriority> = {}
+  for (const [id, priority] of Object.entries(value)) {
+    const action = ACTIONS_BY_ID[id]
+    if (!action || action.fixed || (priority !== 'websites' && priority !== 'orbit')) continue
+    if (priority !== defaultPriorityFor(action, platform)) out[id] = priority
+  }
+  return Object.keys(out).length > 0 ? out : undefined
+}
+
+const fail = (custom: Bindings, problem: string): { custom: Bindings; result: BindResult } => ({
+  custom,
+  result: { ok: false, problem },
+})
+
+/** Gives an action a binding (ST-08): see BindRequest. The map is unchanged unless the result is ok. */
+export function bind(
+  stored: CustomBindings | undefined,
+  req: BindRequest,
+  platform: string,
+): { custom: Bindings; result: BindResult } {
+  const custom = copy(stored)
+  const action = ACTIONS_BY_ID[req.actionId]
+  if (!action) return fail(custom, 'That action no longer exists.')
+  if (action.fixed) return fail(custom, `${action.title} keeps its shortcut.`)
+  const problem = bindingProblem(req.accel, platform)
+  if (problem) return fail(custom, problem)
+  const accel = canonicalAccelerator(req.accel) as string
+  const replace = req.replace === undefined ? undefined : canonicalAccelerator(req.replace)
+  const keymap = buildKeymap(custom, platform)
+  const mine = canon(keymap.lists.get(action.id) ?? [])
+  const owner = keymap.direct.get(accel) ?? keymap.outsideText.get(accel)
+  if (owner && owner.id !== action.id) {
+    if (owner.fixed) {
+      return fail(custom, `${formatAccelerator(accel, platform)} is kept for ${owner.title}.`)
+    }
+    if (!req.onConflict) {
+      return { custom, result: { ok: false, conflict: { actionId: owner.id, title: owner.title } } }
+    }
+    const theirs = canon(keymap.lists.get(owner.id) ?? [])
+    const at = theirs.indexOf(accel)
+    // Swap: the other action gets the binding this one gives up, where the taken one was.
+    if (req.onConflict === 'swap' && replace && mine.includes(replace) && !theirs.includes(replace)) {
+      theirs.splice(at, 1, replace)
+    } else {
+      theirs.splice(at, 1)
+    }
+    settle(custom, owner, theirs, platform)
+  }
+  let list = replace && mine.includes(replace) ? mine.map((a) => (a === replace ? accel : a)) : [...mine, accel]
+  list = [...new Set(list)]
+  if (list.length > MAX_BINDINGS) return fail(copy(stored), `An action can have up to ${MAX_BINDINGS} shortcuts.`)
+  settle(custom, action, list, platform)
+  return { custom, result: { ok: true } }
+}
+
+/** Takes one binding off an action. */
+export function unbind(
+  stored: CustomBindings | undefined,
+  actionId: string,
+  accel: string,
+  platform: string,
+): Bindings {
+  const custom = copy(stored)
+  const action = ACTIONS_BY_ID[actionId]
+  const key = canonicalAccelerator(accel)
+  if (!action || action.fixed || !key) return custom
+  const list = canon(buildKeymap(custom, platform).lists.get(actionId) ?? [])
+  if (list.includes(key))
+    settle(
+      custom,
+      action,
+      list.filter((a) => a !== key),
+      platform,
+    )
+  return custom
+}
+
+/** Puts an action's defaults back, taking each default binding back from any action given it since. */
+export function reset(stored: CustomBindings | undefined, actionId: string, platform: string): Bindings {
+  const custom = copy(stored)
+  const action = ACTIONS_BY_ID[actionId]
+  if (!action || action.fixed) return custom
+  delete custom[actionId]
+  const defaults = new Set(canon(defaultShortcutsFor(action, platform)))
+  for (const [id, list] of Object.entries(custom)) {
+    const other = ACTIONS_BY_ID[id]
+    if (!other) continue
+    const kept = canon(list).filter((a) => !defaults.has(a))
+    if (kept.length !== list.length) settle(custom, other, kept, platform)
+  }
+  return custom
+}
+
+/** Sets who gets an action's keys first (KS-02); the default needs no entry. */
+export function setPriority(
+  stored: Readonly<Record<string, ShortcutPriority>> | undefined,
+  actionId: string,
+  priority: ShortcutPriority,
+  platform: string,
+): Record<string, ShortcutPriority> {
+  const out = { ...(stored ?? {}) }
+  const action = ACTIONS_BY_ID[actionId]
+  if (!action || action.fixed || (priority !== 'websites' && priority !== 'orbit')) return out
+  if (priority === defaultPriorityFor(action, platform)) delete out[actionId]
+  else out[actionId] = priority
+  return out
+}
+
+/** The keys lane's fields of loaded settings (KS-01, KS-02), made safe. Called from normalizeState. */
+export function normalizeKeySettings(settings: Settings, platform: string): void {
+  const shortcuts = normalizeShortcuts(settings.shortcuts, platform)
+  if (shortcuts) settings.shortcuts = shortcuts
+  else delete settings.shortcuts
+  const priorities = normalizePriorities(settings.shortcutPriority, platform)
+  if (priorities) settings.shortcutPriority = priorities
+  else delete settings.shortcutPriority
+}
diff --git a/src/main/keys/index.ts b/src/main/keys/index.ts
new file mode 100644
index 00000000..0bd7f08e
--- /dev/null
+++ b/src/main/keys/index.ts
@@ -0,0 +1,69 @@
+import type { BindResult, ShortcutPriority } from '../../shared/commands/keys'
+import { onKeymapChange, setCustomBindings } from '../../shared/keymap'
+import type { MainContext } from '../context'
+import { installMenu } from '../menu'
+import { bind, reset, setPriority, unbind } from './bindings'
+import { keyRouter } from './router'
+
+/**
+ * The keymap in main (KS-01): the user's bindings follow `settings.shortcuts`, the menu bar is
+ * built again after a remap, and the keys.* commands change bindings and priorities for Settings →
+ * Shortcuts (ST-08). Registered before every other feature, so whatever reads a shortcut while it
+ * starts reads the user's.
+ */
+export function registerKeys(ctx: MainContext): void {
+  const { store, commands } = ctx
+  const platform = process.platform
+  setCustomBindings(store.state.settings.shortcuts)
+  store.subscribe((next, prev) => {
+    if (next.settings.shortcuts !== prev.settings.shortcuts) setCustomBindings(next.settings.shortcuts)
+  })
+  // The macOS menu bar shows each item's binding (KS-18).
+  onKeymapChange(() => installMenu(ctx))
+
+  const saveBindings = (custom: Record<string, string[]>) =>
+    store.update((d) => {
+      if (Object.keys(custom).length > 0) d.settings.shortcuts = custom
+      else delete d.settings.shortcuts
+    })
+  const savePriorities = (chosen: Record<string, ShortcutPriority>) =>
+    store.update((d) => {
+      if (Object.keys(chosen).length > 0) d.settings.shortcutPriority = chosen
+      else delete d.settings.shortcutPriority
+    })
+  const text = (v: unknown): v is string => typeof v === 'string' && v.length > 0 && v.length <= 128
+
+  commands.register('keys.bind', (args): BindResult => {
+    if (!text(args?.actionId) || !text(args.accel)) return { ok: false, problem: 'Nothing to bind.' }
+    const req = {
+      actionId: args.actionId,
+      accel: args.accel,
+      ...(text(args.replace) ? { replace: args.replace } : {}),
+      ...(args.onConflict === 'clear' || args.onConflict === 'swap' ? { onConflict: args.onConflict } : {}),
+    }
+    const { custom, result } = bind(store.state.settings.shortcuts, req, platform)
+    if (result.ok) saveBindings(custom)
+    return result
+  })
+  commands.register('keys.unbind', ({ actionId, accel }) => {
+    if (!text(actionId) || !text(accel)) return
+    saveBindings(unbind(store.state.settings.shortcuts, actionId, accel, platform))
+  })
+  commands.register('keys.reset', ({ actionId }) => {
+    if (!text(actionId)) return
+    saveBindings(reset(store.state.settings.shortcuts, actionId, platform))
+    const chosen = { ...(store.state.settings.shortcutPriority ?? {}) }
+    delete chosen[actionId]
+    savePriorities(chosen)
+  })
+  commands.register('keys.resetAll', () => {
+    saveBindings({})
+    savePriorities({})
+  })
+  commands.register('keys.setPriority', ({ actionId, priority }) => {
+    if (!text(actionId)) return
+    savePriorities(setPriority(store.state.settings.shortcutPriority, actionId, priority, platform))
+  })
+  keyRouter.init(ctx)
+  commands.register('keys.record', ({ on }, c) => keyRouter.setRecording(on ? c.windowId : undefined))
+}
diff --git a/src/main/keys/router.ts b/src/main/keys/router.ts
new file mode 100644
index 00000000..8d674f97
--- /dev/null
+++ b/src/main/keys/router.ts
@@ -0,0 +1,68 @@
+import { type WebContents, webContents } from 'electron'
+import type { RecordedKey } from '../../shared/commands/keys'
+import { acceleratorFromInput, modifiersOf } from '../../shared/keymap'
+import type { WindowId } from '../../shared/state'
+import type { MainContext } from '../context'
+
+/**
+ * The keys lane's part of the key router (src/main/windows.ts `attachShortcuts` calls it): a
+ * window where Settings → Shortcuts is recording a new binding gets its key presses reported
+ * instead of acted on (ST-08).
+ */
+export class KeyRouter {
+  private ctx: MainContext | undefined
+  /** The window whose key presses are being recorded (the Settings window), if any. */
+  private recordingIn: WindowId | undefined
+
+  init(ctx: MainContext): void {
+    this.ctx = ctx
+  }
+
+  /** Starts (with the window) or stops recording. Closing the window stops it too. */
+  setRecording(windowId: WindowId | undefined): void {
+    this.recordingIn = windowId
+    if (!windowId || !this.ctx) return
+    for (const contents of webContents.getAllWebContents()) {
+      if (this.ctx.windows.windowIdFor(contents) !== windowId) continue
+      contents.once('destroyed', () => {
+        if (this.recordingIn === windowId) this.recordingIn = undefined
+      })
+    }
+  }
+
+  /**
+   * While the window of `contents` is recording, reports a key press to the page as
+   * `keys.recorded` and returns true: the caller then keeps the key from the page, the menus and
+   * every shortcut.
+   */
+  record(contents: WebContents, windowOf: () => WindowId | undefined, input: Electron.Input): boolean {
+    if (!this.recordingIn || windowOf() !== this.recordingIn) return false
+    if (input.type !== 'keyDown' && input.type !== 'keyUp') return true
+    const press = {
+      key: input.key,
+      code: input.code,
+      meta: input.meta,
+      control: input.control,
+      alt: input.alt,
+      shift: input.shift,
+    }
+    // A modifier's own release clears it from what is held.
+    const held =
+      input.type === 'keyUp'
+        ? {
+            meta: input.meta && input.key !== 'Meta',
+            control: input.control && input.key !== 'Control',
+            alt: input.alt && input.key !== 'Alt',
+            shift: input.shift && input.key !== 'Shift',
+          }
+        : press
+    const recorded: RecordedKey = { modifiers: modifiersOf(held) }
+    const accel = input.type === 'keyDown' ? acceleratorFromInput(press) : undefined
+    if (accel) recorded.accel = accel
+    if (!contents.isDestroyed()) contents.send('orbit:keys.recorded', recorded)
+    return true
+  }
+}
+
+/** The one key router extension for the app. */
+export const keyRouter = new KeyRouter()
diff --git a/src/main/persist.ts b/src/main/persist.ts
index 8eb0fc79..78b406b5 100644
--- a/src/main/persist.ts
+++ b/src/main/persist.ts
@@ -19,6 +19,7 @@ import type { ItemId, OrbitState, ProfileId, SpaceId, SplitLayout, TabId } from
 import { STATE_SCHEMA } from '../shared/state'
 import { normalizeSpaceTheme } from '../shared/theme'
 import { fallbackTitle } from '../shared/url'
+import { normalizeKeySettings } from './keys/bindings'
 import { normalizeSettingsPrefs } from './settings/normalize'
 import type { Store } from './store'
 
@@ -159,6 +160,7 @@ export function normalizeState(input: Partial<OrbitState>): OrbitState {
     if (d.state === 'progressing' || d.state === 'paused') d.state = 'interrupted'
   }
   normalizeSettingsPrefs(state)
+  normalizeKeySettings(state.settings, process.platform)
   return state
 }
 
diff --git a/src/main/windows.ts b/src/main/windows.ts
index e2980f32..1375c095 100644
--- a/src/main/windows.ts
+++ b/src/main/windows.ts
@@ -18,6 +18,7 @@ import { paletteFor } from '../shared/theme'
 import { splitLeaves, splitOfTab } from '../shared/tree'
 import type { MainContext } from './context'
 import { KEEP_KEYBOARD } from './keys/focus'
+import { keyRouter } from './keys/router'
 import { focusIsEditable } from './nav/focus'
 import { fastSwitchPanes } from './split/layout'
 
@@ -1055,6 +1056,11 @@ export class WindowManager {
   /** Global keyboard shortcuts: every Orbit-owned web contents routes key presses through the action map. */
   attachShortcuts(contents: WebContents): void {
     contents.on('before-input-event', (event, input) => {
+      // Settings → Shortcuts is recording a new binding here (keys lane, ST-08): the key runs nothing.
+      if (keyRouter.record(contents, () => this.windowIdFor(contents), input)) {
+        event.preventDefault()
+        return
+      }
       if (input.type !== 'keyDown') return
       const action = actionForInput(input, process.platform)
       if (!action || !this.ctx.actions.has(action.id)) {
diff --git a/src/renderer/src/keys/live.ts b/src/renderer/src/keys/live.ts
new file mode 100644
index 00000000..eb32c454
--- /dev/null
+++ b/src/renderer/src/keys/live.ts
@@ -0,0 +1,33 @@
+import { useSyncExternalStore } from 'react'
+import { ACTIONS_BY_ID, formatAccelerator, shortcutsFor } from '../../../shared/actions'
+import { keymapVersion, onKeymapChange, setCustomBindings } from '../../../shared/keymap'
+import { useMirror } from '../store'
+
+/**
+ * The keymap in an Orbit renderer (KS-01, KS-18): the user's bindings follow the state mirror's
+ * `settings.shortcuts`, and hints read them through `shortcutLabel` while `useKeymap` re-renders
+ * a component after a remap.
+ */
+export function followKeymap(): void {
+  const apply = () => setCustomBindings(useMirror.getState().state?.settings.shortcuts)
+  apply()
+  useMirror.subscribe(apply)
+}
+
+/** Re-renders the component when the user changes a binding; returns the keymap's version. */
+export function useKeymap(): number {
+  return useSyncExternalStore(onKeymapChange, keymapVersion)
+}
+
+/** The action's first shortcut as this platform shows it ("⇧⌘T", "Ctrl+Shift+T"), or '' when it has none. */
+export function shortcutLabel(actionId: string): string {
+  const action = ACTIONS_BY_ID[actionId]
+  const accel = action ? shortcutsFor(action, window.orbit.platform)[0] : undefined
+  return accel ? formatAccelerator(accel, window.orbit.platform) : ''
+}
+
+/** `shortcutLabel` that follows remaps: the component re-renders when the binding changes. */
+export function useShortcutLabel(actionId: string): string {
+  useKeymap()
+  return shortcutLabel(actionId)
+}
diff --git a/src/renderer/src/library/LibraryButton.tsx b/src/renderer/src/library/LibraryButton.tsx
index 802d463a..7fc0f92c 100644
--- a/src/renderer/src/library/LibraryButton.tsx
+++ b/src/renderer/src/library/LibraryButton.tsx
@@ -1,19 +1,17 @@
 import { LibraryBig } from 'lucide-react'
 import { useEffect, useState } from 'react'
-import { ACTIONS_BY_ID, formatAccelerator, shortcutsFor } from '../../../shared/actions'
 import { invoke } from '../api'
+import { useShortcutLabel } from '../keys/live'
 import './library-button.css'
 
-const action = ACTIONS_BY_ID['app.library']
-const accel = action ? shortcutsFor(action, window.orbit.platform)[0] : undefined
-const TITLE = accel ? `Library (${formatAccelerator(accel, window.orbit.platform)})` : 'Library'
-
 /**
  * The Library button at the left of the sidebar's bottom bar (SB-09, AR-02): opens the Library, or
  * closes it when it is open (shown pressed). A hover gets its view ready, so the first open is quick.
  */
 export function LibraryButton() {
   const [open, setOpen] = useState(false)
+  // The tooltip follows a remapped shortcut (KS-18).
+  const shortcut = useShortcutLabel('app.library')
   useEffect(() => {
     let heard = false
     const off = window.orbit.on('library.state', (payload) => {
@@ -31,7 +29,7 @@ export function LibraryButton() {
       className={`icon-button spacebar__library${open ? ' is-open' : ''}`}
       aria-label="Library"
       aria-pressed={open}
-      title={TITLE}
+      title={shortcut ? `Library (${shortcut})` : 'Library'}
       data-testid="library-button"
       onPointerEnter={() => void invoke('library.prepare', {})}
       onClick={() => void invoke('library.toggle', {})}
diff --git a/src/renderer/src/mini/MiniApp.tsx b/src/renderer/src/mini/MiniApp.tsx
index c571e80c..3ec37aa0 100644
--- a/src/renderer/src/mini/MiniApp.tsx
+++ b/src/renderer/src/mini/MiniApp.tsx
@@ -4,6 +4,7 @@ import type { Tab } from '../../../shared/state'
 import { NEUTRAL_THEME, paletteFor } from '../../../shared/theme'
 import { displayHost } from '../../../shared/url'
 import { invoke, isMac, perfMark } from '../api'
+import { useShortcutLabel } from '../keys/live'
 import { activeTabId } from '../selectors'
 import { useOrbit, useWindow } from '../store'
 import { paletteVars, useDark } from '../theme'
@@ -20,6 +21,8 @@ const CARD_RADIUS = 10
  */
 export function MiniApp() {
   const win = useWindow()
+  // "Open in…" shows the shortcut that moves the page into a Space, as the user has it (MW-05, KS-18).
+  const moveShortcut = useShortcutLabel('peek.expand')
   const live = useOrbit((s) => {
     const id = win ? activeTabId(s, win.id) : null
     return id ? s.tabs[id] : undefined
@@ -93,7 +96,7 @@ export function MiniApp() {
             type="button"
             className="mini__pill mini__open-in"
             data-testid="mini-open-in"
-            title={`Move this page into a Space (${isMac ? '⌘O' : 'Ctrl+O'})`}
+            title={moveShortcut ? `Move this page into a Space (${moveShortcut})` : 'Move this page into a Space'}
             onClick={(e) => {
               const r = e.currentTarget.getBoundingClientRect()
               void invoke('mini.menu', { menu: 'open-in', x: r.left, y: r.bottom + 4 })
diff --git a/src/renderer/src/overlay/PeekLayer.tsx b/src/renderer/src/overlay/PeekLayer.tsx
index 68112b1b..365df8b8 100644
--- a/src/renderer/src/overlay/PeekLayer.tsx
+++ b/src/renderer/src/overlay/PeekLayer.tsx
@@ -23,6 +23,7 @@ import {
 } from '../../../shared/peek-geometry'
 import type { OverlayState } from '../../../shared/state'
 import { invoke, perfMark } from '../api'
+import { useKeymap } from '../keys/live'
 import './peek.css'
 
 type PeekOverlay = Extract<OverlayState, { kind: 'peek' }>
@@ -403,6 +404,8 @@ class PeekAnimator {
  * itself is a native view main keeps exactly on the card.
  */
 export function PeekLayer({ overlay }: { overlay: PeekOverlay }) {
+  // The buttons' tooltips follow remapped shortcuts (KS-18).
+  useKeymap()
   const backdropRef = useRef<HTMLDivElement>(null)
   const cardRef = useRef<HTMLDivElement>(null)
   const controlsRef = useRef<HTMLDivElement>(null)
diff --git a/src/renderer/src/overlay/find/PageToolsApp.tsx b/src/renderer/src/overlay/find/PageToolsApp.tsx
index 2513e3a1..86b3f735 100644
--- a/src/renderer/src/overlay/find/PageToolsApp.tsx
+++ b/src/renderer/src/overlay/find/PageToolsApp.tsx
@@ -2,6 +2,7 @@ import { ChevronDown, ChevronUp, X } from 'lucide-react'
 import { type CSSProperties, useEffect, useRef, useState } from 'react'
 import type { FindState, ZoomIndicator } from '../../../../shared/nav'
 import { invoke, runAction } from '../../api'
+import { useKeymap } from '../../keys/live'
 import { withShortcut } from '../../shell/chrome/shortcut-label'
 import { useWindow } from '../../store'
 import { paletteVars, usePalette } from '../../theme'
@@ -55,6 +56,8 @@ export function PageToolsApp() {
 }
 
 function FindBar({ state }: { state: FindState }) {
+  // The tooltips follow remapped shortcuts (KS-18).
+  useKeymap()
   const input = useRef<HTMLInputElement>(null)
   const composing = useRef(false)
   const [empty, setEmpty] = useState(state.query === '')
@@ -176,6 +179,8 @@ function FindBar({ state }: { state: FindState }) {
 }
 
 function ZoomPill({ zoom }: { zoom: ZoomIndicator }) {
+  // The tooltips follow remapped shortcuts (KS-18).
+  useKeymap()
   return (
     <div
       className="zoom-pill"
diff --git a/src/renderer/src/shell/ContentArea.tsx b/src/renderer/src/shell/ContentArea.tsx
index 1cace8c9..d665ec66 100644
--- a/src/renderer/src/shell/ContentArea.tsx
+++ b/src/renderer/src/shell/ContentArea.tsx
@@ -1,10 +1,10 @@
 import { Command } from 'lucide-react'
 import { memo, useEffect, useLayoutEffect, useMemo, useRef, useState } from 'react'
-import { formatAccelerator } from '../../../shared/actions'
 import { type DividerBox, layoutBoxes, layoutLeaves, leaf, nodeAt } from '../../../shared/split'
 import type { OrbitState, SplitLayout, WindowState } from '../../../shared/state'
 import { splitOfTab } from '../../../shared/tree'
 import { invoke } from '../api'
+import { useShortcutLabel } from '../keys/live'
 import { activeTabId } from '../selectors'
 import { useOrbit } from '../store'
 import { DROP_PANE, type DropPreview, dividerKey, FRAME_RADIUS, PaneEngine } from './split/engine'
@@ -205,14 +205,19 @@ function Divider({
 }
 
 function EmptyState() {
-  const shortcut = formatAccelerator(window.orbit.platform === 'darwin' ? 'Cmd+T' : 'Ctrl+T', window.orbit.platform)
+  // The New Tab shortcut as the user has it (KS-18).
+  const shortcut = useShortcutLabel('tab.new')
   return (
     <div className="pane pane--empty" data-testid="empty-state">
       <div className="frame__empty">
         <Command size={28} strokeWidth={1.4} />
-        <p>
-          Press <kbd>{shortcut}</kbd> to open a tab
-        </p>
+        {shortcut ? (
+          <p>
+            Press <kbd>{shortcut}</kbd> to open a tab
+          </p>
+        ) : (
+          <p>Open a tab from the sidebar</p>
+        )}
       </div>
     </div>
   )
diff --git a/src/renderer/src/shell/chrome/Address.tsx b/src/renderer/src/shell/chrome/Address.tsx
index 8383f7d6..83e37d51 100644
--- a/src/renderer/src/shell/chrome/Address.tsx
+++ b/src/renderer/src/shell/chrome/Address.tsx
@@ -4,6 +4,7 @@ import { connectionOf, peekShown, shownTabId } from '../../../../shared/nav'
 import { SITE_PANEL } from '../../../../shared/site'
 import { displayHost } from '../../../../shared/url'
 import { invoke, runAction } from '../../api'
+import { useKeymap } from '../../keys/live'
 import { useOrbit } from '../../store'
 import { withShortcut } from './shortcut-label'
 
@@ -18,6 +19,8 @@ const COPIED_MS = 1200
  * to open pop-ups without a click, a button says so and offers them (NV-09).
  */
 export function Address({ windowId }: { windowId: string }) {
+  // The tooltips follow remapped shortcuts (KS-18).
+  useKeymap()
   // Only the URL: the display re-renders on navigations, not on title, favicon or progress changes.
   // While a Peek shows, it is the Peek's page (PK-11). A navigation Orbit started shows where it is
   // going before it commits, and after the user stopped it (NV-04).
diff --git a/src/renderer/src/shell/chrome/NavButtons.tsx b/src/renderer/src/shell/chrome/NavButtons.tsx
index cbea23b3..9ab16513 100644
--- a/src/renderer/src/shell/chrome/NavButtons.tsx
+++ b/src/renderer/src/shell/chrome/NavButtons.tsx
@@ -4,6 +4,7 @@ import type { NavDirection } from '../../../../shared/commands/nav'
 import { shownTabId } from '../../../../shared/nav'
 import { sectionOf } from '../../../../shared/tree'
 import { invoke, isMac } from '../../api'
+import { useKeymap } from '../../keys/live'
 import { useOrbitShallow } from '../../store'
 import { playPress } from './press'
 import { rasterizeSvgIcons } from './raster'
@@ -56,6 +57,8 @@ export function NavButtons({ windowId }: { windowId: string }) {
  * long-press or right-click shows the tab's history in that direction (NV-01).
  */
 function HistoryButton({ direction, enabled }: { direction: NavDirection; enabled: boolean }) {
+  // The tooltips follow remapped shortcuts (KS-18).
+  useKeymap()
   const ref = useRef<HTMLButtonElement>(null)
   const hold = useRef<{ timer: number; opened: boolean } | null>(null)
   const label = direction === 'back' ? 'Back' : 'Forward'
@@ -143,6 +146,8 @@ function HistoryButton({ direction, enabled }: { direction: NavDirection; enable
  * ⌘-click or middle-click duplicates the tab (SB-03, NV-03, NV-04).
  */
 function ReloadButton({ enabled, loading }: { enabled: boolean; loading: boolean }) {
+  // The tooltips follow remapped shortcuts (KS-18).
+  useKeymap()
   const ref = useRef<HTMLButtonElement>(null)
   const duplicate = (foreground: boolean) => {
     playPress(ref.current, 'reload')
diff --git a/src/renderer/src/shell/sidebar/SidebarItems.tsx b/src/renderer/src/shell/sidebar/SidebarItems.tsx
index aa7deffa..cda630bd 100644
--- a/src/renderer/src/shell/sidebar/SidebarItems.tsx
+++ b/src/renderer/src/shell/sidebar/SidebarItems.tsx
@@ -17,6 +17,7 @@ import type { Space, SpaceId } from '../../../../shared/state'
 import { containerKey, locate, sectionOf, splitOfTab } from '../../../../shared/tree'
 import { engineForSpace, parseInput } from '../../../../shared/url'
 import { invoke, isMac, runAction } from '../../api'
+import { useShortcutLabel } from '../../keys/live'
 import { activeTabId } from '../../selectors'
 import { getOrbitState, useOrbit } from '../../store'
 import { DragGhost } from './DragGhost'
@@ -224,6 +225,8 @@ const PinnedSection = memo(function PinnedSection({ space }: { space: Space }) {
 function TodayBlock({ space }: { space: Space }) {
   const y = useRowShift('divider')
   const hasToday = space.today.length > 0
+  // The button's tooltip follows a remapped shortcut (KS-18).
+  const clearShortcut = useShortcutLabel('tabs.clearToday')
   return (
     <motion.div
       className="today-block"
@@ -241,7 +244,7 @@ function TodayBlock({ space }: { space: Space }) {
             type="button"
             className="sidebar__clear"
             data-testid="clear-today"
-            title={`Archive all Today tabs (${isMac ? '⌘⇧K' : 'Ctrl+Shift+K'})`}
+            title={clearShortcut ? `Archive all Today tabs (${clearShortcut})` : 'Archive all Today tabs'}
             onClick={() => void invoke('tabs.clearToday', { spaceId: space.id })}
           >
             <ArrowDown size={11} strokeWidth={2.4} />
diff --git a/src/renderer/src/shell/sidebar/SpaceBar.tsx b/src/renderer/src/shell/sidebar/SpaceBar.tsx
index 8ed071ae..18da5677 100644
--- a/src/renderer/src/shell/sidebar/SpaceBar.tsx
+++ b/src/renderer/src/shell/sidebar/SpaceBar.tsx
@@ -13,6 +13,7 @@ import { DEFAULT_PROFILE_ID } from '../../../../shared/defaults'
 import type { SpaceId, WindowState } from '../../../../shared/state'
 import { primaryColor } from '../../../../shared/theme'
 import { invoke } from '../../api'
+import { useKeymap } from '../../keys/live'
 import { LibraryButton } from '../../library/LibraryButton'
 import { useOrbit } from '../../store'
 import { switcher } from '../spaces/switcher'
@@ -208,8 +209,9 @@ const SpaceTarget = memo(function SpaceTarget(props: {
     const id = s.spaces[spaceId]?.profileId
     return id && id !== DEFAULT_PROFILE_ID ? s.profiles[id]?.name : undefined
   })
+  // The shortcut comes from the keymap, so it follows remaps (AP-16, KS-18; review F14).
+  useKeymap()
   if (name === undefined) return null
-  // The shortcut comes from the action table, so it follows remaps (AP-16; review F14).
   const action = index < 9 ? ACTIONS_BY_ID[`space.goto.${index + 1}`] : undefined
   const accel = action ? shortcutsFor(action, window.orbit.platform)[0] : undefined
   const shortcut = accel ? formatAccelerator(accel, window.orbit.platform) : ''
diff --git a/src/renderer/src/shell/sidebar/TopBar.tsx b/src/renderer/src/shell/sidebar/TopBar.tsx
index d779fe88..6cd5fa47 100644
--- a/src/renderer/src/shell/sidebar/TopBar.tsx
+++ b/src/renderer/src/shell/sidebar/TopBar.tsx
@@ -1,6 +1,7 @@
 import { PanelLeft } from 'lucide-react'
 import type { WindowState } from '../../../../shared/state'
 import { isMac, runAction } from '../../api'
+import { useKeymap } from '../../keys/live'
 import { Address } from '../chrome/Address'
 import { NavButtons } from '../chrome/NavButtons'
 import { PermissionPrompt, useActivePrompt } from '../chrome/PermissionPrompt'
@@ -15,6 +16,8 @@ import '../chrome/chrome.css'
  * A site's permission prompt hangs under the address display (NV-15).
  */
 export function TopBar({ win, floating = false }: { win: WindowState; floating?: boolean }) {
+  // The tooltips follow remapped shortcuts (KS-18).
+  useKeymap()
   const prompt = useActivePrompt(win.id)
   return (
     <div className={`topbar${isMac ? ' topbar--mac' : ''}${prompt ? ' has-prompt' : ''}`} data-testid="topbar">
diff --git a/src/renderer/src/shortcuts.ts b/src/renderer/src/shortcuts.ts
index b7d4e328..0cf2e5e1 100644
--- a/src/renderer/src/shortcuts.ts
+++ b/src/renderer/src/shortcuts.ts
@@ -1,4 +1,5 @@
 import { actionForInput } from '../../shared/actions'
+import { followKeymap } from './keys/live'
 
 /**
  * Fallback shortcut router for Orbit's own UI pages. Real key presses are
@@ -7,6 +8,8 @@ import { actionForInput } from '../../shared/actions'
  * input from automation) is mapped through the same keymap.
  */
 export function installShortcutFallback(): void {
+  // This page's hints and this fallback use the user's bindings (KS-01).
+  followKeymap()
   window.addEventListener(
     'keydown',
     (e) => {
diff --git a/src/shared/actions.ts b/src/shared/actions.ts
index 47fbd3bf..39a37132 100644
--- a/src/shared/actions.ts
+++ b/src/shared/actions.ts
@@ -1,17 +1,39 @@
 /**
  * User-facing actions: things a person can trigger from a keyboard shortcut,
  * the app menu or the command bar. Handlers live in the main process
- * (src/main/actions.ts registry); each feature registers its own.
+ * (src/main/registry.ts ActionRegistry); each feature registers its own.
  *
- * Shortcuts use accelerator strings: modifiers Cmd, Ctrl, Alt, Shift joined by
- * "+" with a key name (A-Z, 0-9, [ ] , . / ; ' ` - = \, Left Right Up Down,
- * Tab Enter Escape Backspace Delete Space F1-F12 Home End PageUp PageDown).
- * `mac` applies on macOS and `other` on Linux/Windows.
+ * This list is the one keymap (KS-01): each action's stable id, its title, and its default
+ * shortcuts, `mac` on macOS and `other` on Linux/Windows (accelerator strings, see
+ * src/shared/keymap.ts). The key router, the menus, tooltips, command-bar rows, the shortcut
+ * sheet and Settings → Shortcuts all read an action's shortcuts through `shortcutsFor`, which
+ * gives the user's own bindings where they changed them, so a remap reaches every one at once.
  *
- * The final shortcut set follows spec/keyboard-shortcuts.md (KS-* IDs).
+ * The default set follows the KS-* tables of the shortcuts spec.
  */
 
+import type { ShortcutPriority } from './commands/keys'
 import { SETTINGS_ACTIONS, SETTINGS_LANE_ACTIONS } from './commands/settings'
+import {
+  acceleratorFromInput,
+  type CustomBindings,
+  canonicalAccelerator,
+  customBindings,
+  editsText,
+  type KeyInput,
+  keymapVersion,
+  typedWithAltGr,
+} from './keymap'
+
+export {
+  formatAccelerator,
+  type KeyInput,
+  keyName,
+  matchesAccelerator,
+  type ParsedAccelerator,
+  parseAccelerator,
+  toElectronAccelerator,
+} from './keymap'
 
 export interface ActionDef {
   id: string
@@ -30,6 +52,19 @@ export interface ActionDef {
    */
   macOutsideText?: string[]
   otherOutsideText?: string[]
+  /**
+   * The shortcuts can't be changed (KS-01 "fixed": OS conventions such as ⌘, for Settings, and keys
+   * that belong to an overlay such as the recent-tab switcher's). Settings → Shortcuts shows them
+   * without a way to record new ones.
+   */
+  fixed?: boolean
+  /**
+   * KS-02 "prefer websites": when a page also handles one of the action's keys, the page gets the
+   * first press, and pressing again within about a second runs the action. `true` on every
+   * platform, 'other' on Windows and Linux only. Otherwise the action runs and the page never sees
+   * the key ("prefer Orbit", the default). Users choose per action in Settings → Shortcuts.
+   */
+  preferWebsites?: boolean | 'other'
 }
 
 const numbered = (
@@ -80,6 +115,7 @@ export const ACTIONS: ActionDef[] = [
     mac: ['Ctrl+Tab'],
     other: ['Ctrl+Tab'],
     hidden: true,
+    fixed: true,
   },
   {
     id: 'tab.recentBack',
@@ -88,6 +124,7 @@ export const ACTIONS: ActionDef[] = [
     mac: ['Ctrl+Shift+Tab', 'Ctrl+`'],
     other: ['Ctrl+Shift+Tab'],
     hidden: true,
+    fixed: true,
   },
   { id: 'tab.togglePin', title: 'Pin / Unpin Tab', category: 'Tabs', mac: ['Cmd+D'], other: ['Ctrl+D'] },
   { id: 'tab.duplicate', title: 'Duplicate Tab', category: 'Tabs' },
@@ -105,6 +142,8 @@ export const ACTIONS: ActionDef[] = [
     mac: ['Cmd+Shift+C'],
     other: ['Ctrl+Shift+C'],
     keywords: ['link', 'share'],
+    // NV-17: on Windows and Linux the page gets Ctrl+Shift+C first (KS-02).
+    preferWebsites: 'other',
   },
   {
     id: 'tab.copyUrlMarkdown',
@@ -249,7 +288,15 @@ export const ACTIONS: ActionDef[] = [
   },
 
   // Sidebar & window
-  { id: 'sidebar.toggle', title: 'Toggle Sidebar', category: 'Sidebar', mac: ['Cmd+S'], other: ['Ctrl+S'] },
+  {
+    id: 'sidebar.toggle',
+    title: 'Toggle Sidebar',
+    category: 'Sidebar',
+    mac: ['Cmd+S'],
+    other: ['Ctrl+S'],
+    // SB-11: a web editor's ⌘S / Ctrl+S gets the first press (KS-02).
+    preferWebsites: true,
+  },
   { id: 'window.new', title: 'New Window', category: 'Window', mac: ['Cmd+N'], other: ['Ctrl+N'] },
   {
     id: 'window.newMini',
@@ -282,6 +329,8 @@ export const ACTIONS: ActionDef[] = [
     mac: ['Cmd+,'],
     other: ['Ctrl+,'],
     keywords: ['preferences'],
+    // An OS convention (KS-12).
+    fixed: true,
   },
   {
     id: 'app.archive',
@@ -416,119 +465,109 @@ export const ACTIONS: ActionDef[] = [
 
 export const ACTIONS_BY_ID: Record<string, ActionDef> = Object.fromEntries(ACTIONS.map((a) => [a.id, a]))
 
-export function shortcutsFor(action: ActionDef, platform: string): string[] {
-  return (platform === 'darwin' ? action.mac : action.other) ?? []
+/** The action's shortcuts as Orbit ships them (KS-03): `mac` on macOS, `other` elsewhere. */
+export function defaultShortcutsFor(action: ActionDef, platform: string): string[] {
+  const mac = platform === 'darwin'
+  return [
+    ...((mac ? action.mac : action.other) ?? []),
+    ...((mac ? action.macOutsideText : action.otherOutsideText) ?? []),
+  ]
 }
 
-// ---- Accelerator matching ----
-
-export interface KeyInput {
-  key: string
-  code: string
-  meta: boolean
-  control: boolean
-  alt: boolean
-  shift: boolean
+/** Who gets the action's keys first by default when a page also handles them (KS-02). */
+export function defaultPriorityFor(action: ActionDef, platform: string): ShortcutPriority {
+  const prefer = action.preferWebsites
+  return prefer === true || (prefer === 'other' && platform !== 'darwin') ? 'websites' : 'orbit'
 }
 
-const CODE_NAMES: Record<string, string> = {
-  BracketLeft: '[',
-  BracketRight: ']',
-  Comma: ',',
-  Period: '.',
-  Slash: '/',
-  Backslash: '\\',
-  Semicolon: ';',
-  Quote: "'",
-  Backquote: '`',
-  Minus: '-',
-  Equal: '=',
-  ArrowLeft: 'Left',
-  ArrowRight: 'Right',
-  ArrowUp: 'Up',
-  ArrowDown: 'Down',
-  NumpadAdd: '=',
-  NumpadSubtract: '-',
-  NumpadEnter: 'Enter',
+/** Who gets the action's keys first: the user's choice (`settings.shortcutPriority`), else the default. */
+export function priorityFor(
+  action: ActionDef,
+  platform: string,
+  chosen?: Readonly<Record<string, ShortcutPriority>>,
+): ShortcutPriority {
+  return (!action.fixed && chosen?.[action.id]) || defaultPriorityFor(action, platform)
 }
 
-/** Shifted ASCII symbols (US positions) → the unshifted key they share, so "Cmd+Shift+=" matches "+". */
-const SHIFTED_SYMBOLS: Record<string, string> = {
-  '+': '=',
-  _: '-',
-  '{': '[',
-  '}': ']',
-  '<': ',',
-  '>': '.',
-  '?': '/',
-  ':': ';',
-  '"': "'",
-  '~': '`',
-  '|': '\\',
+/** A keymap: which action each binding runs, and each action's bindings (KS-01). */
+export interface Keymap {
+  /** Each action's bindings, in their written order. */
+  lists: Map<string, string[]>
+  /** Binding (canonical) → action, for keys that never edit text. */
+  direct: Map<string, ActionDef>
+  /** Binding (canonical) → action, for keys that edit text in a field (KS-16): they act only outside one. */
+  outsideText: Map<string, ActionDef>
 }
-const ASCII_SYMBOL = /^[!-/:-@[-`{-~]$/
+
+/** Whether the user's list for an action applies: fixed actions keep their defaults. */
+const ownsList = (action: ActionDef, custom: CustomBindings) => !action.fixed && custom[action.id] !== undefined
 
 /**
- * Key name for an input, matched against accelerator keys. Like Chrome:
- *  - letters follow the keyboard layout (`key`), so AZERTY's Cmd+Z is undo, not the physical W key;
- *  - digits use the physical key (`code`), so AZERTY's unshifted digit row still selects tabs;
- *  - ASCII symbols follow the layout too (Dvorak's "." sits on the physical E key);
- *  - anything else (macOS Option combos, Cyrillic and other non-Latin layouts, dead keys) falls
- *    back to the physical key, so Cmd+Option+V or Ctrl+T on a Russian layout still work.
+ * The keymap for a platform with the user's bindings `custom`: theirs where they changed an
+ * action, the defaults elsewhere. A binding belongs to one action: fixed actions keep theirs first,
+ * then the user's own bindings win over a default that came later (the default is left off its
+ * action).
  */
-export function keyName(input: Pick<KeyInput, 'key' | 'code'>): string {
-  const { code, key } = input
-  if (/^[a-z]$/i.test(key)) return key.toUpperCase()
-  if (code.startsWith('Digit') && code.length === 6) return code.slice(5)
-  if (code.startsWith('Numpad') && code.length === 7 && /\d/.test(code[6] ?? '')) return code.slice(6)
-  if (ASCII_SYMBOL.test(key)) return SHIFTED_SYMBOLS[key] ?? key
-  if (code.startsWith('Key') && code.length === 4) return code.slice(3)
-  if (CODE_NAMES[code]) return CODE_NAMES[code] as string
-  if (key === ' ') return 'Space'
-  return key.length === 1 ? key.toUpperCase() : key
+export function buildKeymap(custom: CustomBindings, platform: string): Keymap {
+  const owner = new Map<string, ActionDef>()
+  const lists = new Map<string, string[]>()
+  const claim = (action: ActionDef, accels: readonly string[]) => {
+    const list: string[] = []
+    for (const accel of accels) {
+      const key = canonicalAccelerator(accel)
+      if (!key || owner.has(key)) continue
+      owner.set(key, action)
+      list.push(accel)
+    }
+    lists.set(action.id, list)
+  }
+  for (const action of ACTIONS) if (action.fixed) claim(action, defaultShortcutsFor(action, platform))
+  for (const action of ACTIONS) if (ownsList(action, custom)) claim(action, custom[action.id] ?? [])
+  for (const action of ACTIONS) {
+    if (!action.fixed && !ownsList(action, custom)) claim(action, defaultShortcutsFor(action, platform))
+  }
+  const direct = new Map<string, ActionDef>()
+  const outsideText = new Map<string, ActionDef>()
+  for (const [key, action] of owner) (editsText(key, platform) ? outsideText : direct).set(key, action)
+  return { lists, direct, outsideText }
 }
 
-export interface ParsedAccelerator {
-  cmd: boolean
-  ctrl: boolean
-  alt: boolean
-  shift: boolean
-  key: string
-}
+let current: { version: number; platform: string; keymap: Keymap } | undefined
 
-export function parseAccelerator(accel: string): ParsedAccelerator {
-  const parts = accel.split('+')
-  // "Cmd+=" style keys are never "+" themselves; a trailing empty part means the key was "+".
-  const key = parts.pop() || '+'
-  const mods = new Set(parts.map((p) => p.toLowerCase()))
-  return {
-    cmd: mods.has('cmd') || mods.has('command') || mods.has('meta'),
-    ctrl: mods.has('ctrl') || mods.has('control'),
-    alt: mods.has('alt') || mods.has('option'),
-    shift: mods.has('shift'),
-    key: key.length === 1 ? key.toUpperCase() : key,
+/** The keymap in use now (KS-01): rebuilt when the user's bindings change. */
+function liveIndex(platform: string): Keymap {
+  const version = keymapVersion()
+  if (current?.version !== version || current.platform !== platform) {
+    current = { version, platform, keymap: buildKeymap(customBindings(), platform) }
   }
+  return current.keymap
 }
 
-export function matchesAccelerator(input: KeyInput, accel: string): boolean {
-  const a = parseAccelerator(accel)
-  return (
-    a.cmd === input.meta &&
-    a.ctrl === input.control &&
-    a.alt === input.alt &&
-    a.shift === input.shift &&
-    a.key === keyName(input)
-  )
+/**
+ * The action's shortcuts on this platform as they are now (KS-01): the user's bindings if they
+ * changed them, else the defaults. The first is the one hints show.
+ */
+export function shortcutsFor(action: ActionDef, platform: string): string[] {
+  return liveIndex(platform).lists.get(action.id) ?? []
+}
+
+/** The action that owns a binding now, if any (Settings → Shortcuts' conflict check). */
+export function actionForAccelerator(accel: string, platform: string): ActionDef | undefined {
+  const key = canonicalAccelerator(accel)
+  if (!key) return undefined
+  const keymap = liveIndex(platform)
+  return keymap.direct.get(key) ?? keymap.outsideText.get(key)
 }
 
+/** An IME is composing: only keys with ⌘ or Ctrl may act (KS-16). */
+const composingPlainKey = (input: KeyInput) => !!input.isComposing && !input.meta && !input.control
+
 /** Returns the action bound to this key press on the given platform, if any. */
 export function actionForInput(input: KeyInput, platform: string): ActionDef | undefined {
-  for (const action of ACTIONS) {
-    for (const accel of shortcutsFor(action, platform)) {
-      if (matchesAccelerator(input, accel)) return action
-    }
-  }
-  return undefined
+  // A key that typed a character through AltGr acts only outside text fields (KS-03).
+  if (composingPlainKey(input) || typedWithAltGr(input, platform)) return undefined
+  const key = acceleratorFromInput(input)
+  return key ? liveIndex(platform).direct.get(key) : undefined
 }
 
 /**
@@ -536,30 +575,9 @@ export function actionForInput(input: KeyInput, platform: string): ActionDef | u
  * The caller checks where focus is before running it.
  */
 export function outsideTextActionFor(input: KeyInput, platform: string): ActionDef | undefined {
-  for (const action of ACTIONS) {
-    const keys = (platform === 'darwin' ? action.macOutsideText : action.otherOutsideText) ?? []
-    if (keys.some((accel) => matchesAccelerator(input, accel))) return action
-  }
-  return undefined
-}
-
-/** Display form of an accelerator, e.g. "⌘⇧T" on macOS or "Ctrl+Shift+T" elsewhere. */
-export function formatAccelerator(accel: string, platform: string): string {
-  const a = parseAccelerator(accel)
-  const keyLabel = (
-    { Left: '←', Right: '→', Up: '↑', Down: '↓', Enter: '↩', Escape: 'Esc', Space: 'Space' } as Record<string, string>
-  )[a.key]
-  if (platform === 'darwin') {
-    return `${a.ctrl ? '⌃' : ''}${a.alt ? '⌥' : ''}${a.shift ? '⇧' : ''}${a.cmd ? '⌘' : ''}${keyLabel ?? a.key}`
-  }
-  return [a.ctrl && 'Ctrl', a.alt && 'Alt', a.shift && 'Shift', a.cmd && 'Meta', keyLabel ?? a.key]
-    .filter(Boolean)
-    .join('+')
-}
-
-/** Electron menu accelerator form ("CommandOrControl" etc.). */
-export function toElectronAccelerator(accel: string): string {
-  const a = parseAccelerator(accel)
-  const key = a.key === '=' ? '=' : a.key === '+' ? 'Plus' : a.key
-  return [a.cmd && 'Command', a.ctrl && 'Control', a.alt && 'Alt', a.shift && 'Shift', key].filter(Boolean).join('+')
+  if (composingPlainKey(input)) return undefined
+  const key = acceleratorFromInput(input)
+  if (!key) return undefined
+  const keymap = liveIndex(platform)
+  return keymap.outsideText.get(key) ?? (typedWithAltGr(input, platform) ? keymap.direct.get(key) : undefined)
 }
diff --git a/src/shared/commands/keys.ts b/src/shared/commands/keys.ts
new file mode 100644
index 00000000..91474928
--- /dev/null
+++ b/src/shared/commands/keys.ts
@@ -0,0 +1,60 @@
+/**
+ * Owned by the keys lane: the keymap's commands (KS-01, KS-02) and Settings → Shortcuts (ST-08).
+ * Bindings are accelerator strings (src/shared/keymap.ts); actions are ids from src/shared/actions.ts.
+ */
+
+/** Who gets a key first when a page also handles it (KS-02). */
+export type ShortcutPriority = 'websites' | 'orbit'
+
+/** Another action that already has the binding asked for (ST-08 conflict warning). */
+export interface BindingConflict {
+  actionId: string
+  title: string
+}
+
+export type BindResult =
+  | { ok: true }
+  /** The binding can't be used: no modifier, a key Orbit doesn't bind, one the system keeps… */
+  | { ok: false; problem: string }
+  /** Another action has it; ask again with `onConflict` to take it. */
+  | { ok: false; conflict: BindingConflict }
+
+export interface BindRequest {
+  actionId: string
+  /** The new binding, e.g. "Cmd+Shift+B". */
+  accel: string
+  /** One of the action's bindings the new one takes the place of; without it, the new one is added. */
+  replace?: string
+  /**
+   * When another action has `accel`: 'clear' takes it off that action; 'swap' gives that action
+   * `replace` in its place (or clears it when there is nothing to give). Without it, the conflict
+   * is returned and nothing changes.
+   */
+  onConflict?: 'clear' | 'swap'
+}
+
+/** What main reports to Settings → Shortcuts while it records a binding. */
+export interface RecordedKey {
+  /** The binding the press made, written as `canonicalAccelerator` writes it; absent for a lone modifier. */
+  accel?: string
+  /** The modifiers held, e.g. "Cmd+Shift" ("" for none), to show while the user builds a combination. */
+  modifiers: string
+}
+
+export interface KeyCommands {
+  /** Gives an action a binding (KS-01, ST-08). See BindRequest. */
+  'keys.bind': { args: BindRequest; result: BindResult }
+  /** Takes one binding off an action; the command bar and menus still reach it (KS-01). */
+  'keys.unbind': { args: { actionId: string; accel: string }; result: void }
+  /** Puts an action's bindings back to its defaults, taking each back from any action that has it now. */
+  'keys.reset': { args: { actionId: string }; result: void }
+  /** Puts every action's bindings and priorities back to the defaults. */
+  'keys.resetAll': { args: Record<string, never>; result: void }
+  /**
+   * Settings → Shortcuts records a binding: while on, each key press in the Settings window is
+   * sent to it as `keys.recorded` (a RecordedKey) and runs nothing. Off when the window closes.
+   */
+  'keys.record': { args: { on: boolean }; result: void }
+  /** Who gets the action's keys first when a page also handles them (KS-02). */
+  'keys.setPriority': { args: { actionId: string; priority: ShortcutPriority }; result: void }
+}
diff --git a/src/shared/keymap.ts b/src/shared/keymap.ts
new file mode 100644
index 00000000..9f73bdf2
--- /dev/null
+++ b/src/shared/keymap.ts
@@ -0,0 +1,428 @@
+/**
+ * The keymap's building blocks (KS-01, KS-03): accelerator strings, how a key press matches them,
+ * what a new binding must look like, and the bindings the user changed on this device.
+ *
+ * An accelerator is modifiers (Cmd, Ctrl, Alt, Shift) joined by "+" with a key name: A–Z, 0–9,
+ * [ ] , . / ; ' ` - = \, Left Right Up Down, Tab Enter Escape Backspace Delete Space Home End
+ * PageUp PageDown Insert, F1–F24. Cmd is ⌘ on macOS and the Windows/Super key elsewhere.
+ *
+ * Each action's default bindings are its `mac` / `other` lists (src/shared/actions.ts). The user's
+ * changes are `settings.shortcuts`: for each action they changed, its whole list of bindings (an
+ * empty list when they took every key away; the command bar and menus still reach the action).
+ * Main and every Orbit renderer keep this module's copy in step with that setting
+ * (`setCustomBindings`), so a remap reaches the key router, the menus, tooltips, command-bar rows
+ * and the shortcut sheet at once.
+ */
+
+export interface KeyInput {
+  key: string
+  code: string
+  meta: boolean
+  control: boolean
+  alt: boolean
+  shift: boolean
+  /** An input method (IME) is composing text: keys without ⌘ or Ctrl belong to it (KS-16). */
+  isComposing?: boolean
+}
+
+const CODE_NAMES: Record<string, string> = {
+  BracketLeft: '[',
+  BracketRight: ']',
+  Comma: ',',
+  Period: '.',
+  Slash: '/',
+  Backslash: '\\',
+  Semicolon: ';',
+  Quote: "'",
+  Backquote: '`',
+  Minus: '-',
+  Equal: '=',
+  ArrowLeft: 'Left',
+  ArrowRight: 'Right',
+  ArrowUp: 'Up',
+  ArrowDown: 'Down',
+  NumpadAdd: '=',
+  NumpadSubtract: '-',
+  NumpadEnter: 'Enter',
+}
+
+/** Shifted ASCII symbols (US positions) → the unshifted key they share, so "Cmd+Shift+=" matches "+". */
+const SHIFTED_SYMBOLS: Record<string, string> = {
+  '+': '=',
+  _: '-',
+  '{': '[',
+  '}': ']',
+  '<': ',',
+  '>': '.',
+  '?': '/',
+  ':': ';',
+  '"': "'",
+  '~': '`',
+  '|': '\\',
+}
+const ASCII_SYMBOL = /^[!-/:-@[-`{-~]$/
+
+/**
+ * Key name for an input, matched against accelerator keys. Like Chrome:
+ *  - letters follow the keyboard layout (`key`), so AZERTY's Cmd+Z is undo, not the physical W key;
+ *  - digits use the physical key (`code`), so AZERTY's unshifted digit row still selects tabs;
+ *  - ASCII symbols follow the layout too (Dvorak's "." sits on the physical E key);
+ *  - anything else (macOS Option combos, Cyrillic and other non-Latin layouts, dead keys) falls
+ *    back to the physical key, so Cmd+Option+V or Ctrl+T on a Russian layout still work.
+ */
+export function keyName(input: Pick<KeyInput, 'key' | 'code'>): string {
+  const { code, key } = input
+  if (/^[a-z]$/i.test(key)) return key.toUpperCase()
+  if (code.startsWith('Digit') && code.length === 6) return code.slice(5)
+  if (code.startsWith('Numpad') && code.length === 7 && /\d/.test(code[6] ?? '')) return code.slice(6)
+  if (ASCII_SYMBOL.test(key)) return SHIFTED_SYMBOLS[key] ?? key
+  if (code.startsWith('Key') && code.length === 4) return code.slice(3)
+  if (CODE_NAMES[code]) return CODE_NAMES[code] as string
+  if (key === ' ') return 'Space'
+  return key.length === 1 ? key.toUpperCase() : key
+}
+
+export interface ParsedAccelerator {
+  cmd: boolean
+  ctrl: boolean
+  alt: boolean
+  shift: boolean
+  key: string
+}
+
+export function parseAccelerator(accel: string): ParsedAccelerator {
+  const parts = accel.split('+')
+  // "Cmd+=" style keys are never "+" themselves; a trailing empty part means the key was "+".
+  const key = parts.pop() || '+'
+  const mods = new Set(parts.map((p) => p.toLowerCase()))
+  return {
+    cmd: mods.has('cmd') || mods.has('command') || mods.has('meta'),
+    ctrl: mods.has('ctrl') || mods.has('control'),
+    alt: mods.has('alt') || mods.has('option'),
+    shift: mods.has('shift'),
+    key: key.length === 1 ? key.toUpperCase() : key,
+  }
+}
+
+export function matchesAccelerator(input: KeyInput, accel: string): boolean {
+  const a = parseAccelerator(accel)
+  return (
+    a.cmd === input.meta &&
+    a.ctrl === input.control &&
+    a.alt === input.alt &&
+    a.shift === input.shift &&
+    a.key === keyName(input)
+  )
+}
+
+const KEY_LABELS: Record<string, string> = {
+  Left: '←',
+  Right: '→',
+  Up: '↑',
+  Down: '↓',
+  Enter: '↩',
+  Escape: 'Esc',
+  Space: 'Space',
+}
+const MAC_KEY_LABELS: Record<string, string> = { Backspace: '⌫', Delete: '⌦', Tab: '⇥', PageUp: '⇞', PageDown: '⇟' }
+
+/** Display form of an accelerator, e.g. "⌘⇧T" on macOS or "Ctrl+Shift+T" elsewhere. */
+export function formatAccelerator(accel: string, platform: string): string {
+  const a = parseAccelerator(accel)
+  const keyLabel = KEY_LABELS[a.key] ?? (platform === 'darwin' ? MAC_KEY_LABELS[a.key] : undefined)
+  if (platform === 'darwin') {
+    return `${a.ctrl ? '⌃' : ''}${a.alt ? '⌥' : ''}${a.shift ? '⇧' : ''}${a.cmd ? '⌘' : ''}${keyLabel ?? a.key}`
+  }
+  return [a.ctrl && 'Ctrl', a.alt && 'Alt', a.shift && 'Shift', a.cmd && 'Meta', keyLabel ?? a.key]
+    .filter(Boolean)
+    .join('+')
+}
+
+/** Electron menu accelerator form ("CommandOrControl" etc.). */
+export function toElectronAccelerator(accel: string): string {
+  const a = parseAccelerator(accel)
+  const key = a.key === '=' ? '=' : a.key === '+' ? 'Plus' : a.key
+  return [a.cmd && 'Command', a.ctrl && 'Control', a.alt && 'Alt', a.shift && 'Shift', key].filter(Boolean).join('+')
+}
+
+// ---- Bindings: one written form, and what a new one must be (KS-01, ST-08) ----
+
+const NAMED_KEYS = [
+  'Left',
+  'Right',
+  'Up',
+  'Down',
+  'Tab',
+  'Enter',
+  'Escape',
+  'Backspace',
+  'Delete',
+  'Space',
+  'Home',
+  'End',
+  'PageUp',
+  'PageDown',
+  'Insert',
+]
+const NAMED_BY_LOWER = new Map([
+  ...NAMED_KEYS.map((k): [string, string] => [k.toLowerCase(), k]),
+  ['esc', 'Escape'],
+  ['return', 'Enter'],
+  ['plus', '='],
+])
+const SYMBOL_KEYS = new Set(['[', ']', ',', '.', '/', ';', "'", '`', '-', '=', '\\'])
+const FUNCTION_KEY = /^F([1-9]|1\d|2[0-4])$/
+const MODIFIER_NAMES: Record<string, 'Cmd' | 'Ctrl' | 'Alt' | 'Shift'> = {
+  cmd: 'Cmd',
+  command: 'Cmd',
+  meta: 'Cmd',
+  ctrl: 'Ctrl',
+  control: 'Ctrl',
+  alt: 'Alt',
+  option: 'Alt',
+  shift: 'Shift',
+}
+
+/** The key part of an accelerator in its one written form, or undefined if Orbit doesn't bind it. */
+function canonicalKey(raw: string): string | undefined {
+  if (raw.length === 1) {
+    const upper = raw.toUpperCase()
+    if (/^[A-Z0-9]$/.test(upper)) return upper
+    const base = SHIFTED_SYMBOLS[raw] ?? raw
+    return SYMBOL_KEYS.has(base) ? base : undefined
+  }
+  const named = NAMED_BY_LOWER.get(raw.toLowerCase())
+  if (named) return named
+  const fKey = raw.toUpperCase()
+  return FUNCTION_KEY.test(fKey) ? fKey : undefined
+}
+
+/**
+ * An accelerator in its one written form: modifiers in the order Cmd, Ctrl, Alt, Shift, then the key
+ * ("Shift+Cmd+t" → "Cmd+Shift+T", "Cmd++" → "Cmd+="). Undefined when it isn't one Orbit can bind:
+ * an unknown modifier or key, or a modifier twice.
+ */
+export function canonicalAccelerator(accel: string): string | undefined {
+  if (typeof accel !== 'string' || accel.length === 0 || accel.length > 64) return undefined
+  const parts = accel.split('+')
+  // "Cmd++": the key is "+" itself.
+  let rawKey = parts.pop() ?? ''
+  if (rawKey === '' && parts.length > 0 && parts[parts.length - 1] === '') {
+    parts.pop()
+    rawKey = '+'
+  }
+  const key = canonicalKey(rawKey)
+  if (!key) return undefined
+  const mods = new Set<string>()
+  for (const part of parts) {
+    const mod = MODIFIER_NAMES[part.toLowerCase()]
+    if (!mod || mods.has(mod)) return undefined
+    mods.add(mod)
+  }
+  return [...(['Cmd', 'Ctrl', 'Alt', 'Shift'] as const).filter((m) => mods.has(m)), key].join('+')
+}
+
+/** Keys that are only modifiers (or locks): pressed alone they make no binding. */
+const MODIFIER_KEYS = new Set([
+  'Shift',
+  'Control',
+  'Alt',
+  'AltGraph',
+  'Meta',
+  'OS',
+  'Super',
+  'Hyper',
+  'Fn',
+  'FnLock',
+  'CapsLock',
+  'NumLock',
+  'ScrollLock',
+  'Symbol',
+  'SymbolLock',
+])
+
+/** The modifiers held in a key press, as a binding writes them; "" when none. */
+export function modifiersOf(input: Pick<KeyInput, 'meta' | 'control' | 'alt' | 'shift'>): string {
+  return [input.meta && 'Cmd', input.control && 'Ctrl', input.alt && 'Alt', input.shift && 'Shift']
+    .filter(Boolean)
+    .join('+')
+}
+
+/**
+ * The binding a key press makes (written as `canonicalAccelerator` writes it), e.g. for Settings →
+ * Shortcuts recording a new one (ST-08). Undefined for a modifier pressed on its own and for keys
+ * Orbit doesn't bind.
+ */
+export function acceleratorFromInput(input: KeyInput): string | undefined {
+  if (MODIFIER_KEYS.has(input.key)) return undefined
+  const mods = modifiersOf(input)
+  return canonicalAccelerator(mods ? `${mods}+${keyName(input)}` : keyName(input))
+}
+
+/** Function keys F1–F12 may be bound with no modifier (KS-01). */
+const BARE_KEY = /^F([1-9]|1[0-2])$/
+
+/** Keys the system or Orbit keeps for themselves (KS-15, KS-12): not offered as bindings. */
+const RESERVED: Record<'mac' | 'other', Record<string, string>> = {
+  mac: {
+    'Cmd+Q': 'Quit Orbit',
+    'Cmd+H': 'Hide Orbit',
+    'Cmd+Alt+H': 'Hide Others',
+    'Cmd+M': 'Minimize',
+    'Cmd+`': 'switching between Orbit windows',
+    'Cmd+Shift+/': 'Help menu search',
+    'Cmd+Tab': 'switching apps',
+    'Cmd+Space': 'system search',
+  },
+  other: {
+    'Alt+F4': 'closing the window',
+    'Alt+Tab': 'switching apps',
+    'Alt+F': 'the app menu',
+  },
+}
+
+/** What keeps a binding from being used, as Settings → Shortcuts says it; undefined when it is fine. */
+export function bindingProblem(accel: string, platform: string): string | undefined {
+  const canonical = canonicalAccelerator(accel)
+  if (!canonical) return "Orbit can't use that key for a shortcut."
+  const a = parseAccelerator(canonical)
+  const mac = platform === 'darwin'
+  if (!a.cmd && !a.ctrl && !a.alt && !a.shift && !BARE_KEY.test(a.key)) {
+    return mac
+      ? 'A shortcut starts with ⇧, ⌃, ⌥ or ⌘ (F1–F12 can be used on their own).'
+      : 'A shortcut starts with Shift, Ctrl or Alt (F1–F12 can be used on their own).'
+  }
+  const taken = RESERVED[mac ? 'mac' : 'other'][canonical]
+  if (taken) return `${formatAccelerator(canonical, platform)} is kept for ${taken}.`
+  return undefined
+}
+
+// ---- Keys that type or edit text (KS-03, KS-16) ----
+
+const MAC_TEXT_COMMANDS = new Set(['Cmd+A', 'Cmd+C', 'Cmd+X', 'Cmd+V', 'Cmd+Z', 'Cmd+Shift+Z', 'Cmd+Alt+Shift+V'])
+const OTHER_TEXT_COMMANDS = new Set([
+  'Ctrl+A',
+  'Ctrl+C',
+  'Ctrl+X',
+  'Ctrl+V',
+  'Ctrl+Z',
+  'Ctrl+Y',
+  'Ctrl+Shift+Z',
+  'Ctrl+Shift+V',
+  'Ctrl+Insert',
+  'Shift+Insert',
+  'Shift+Delete',
+])
+
+type Modifier = 'cmd' | 'ctrl' | 'alt' | 'shift'
+
+/** True when every modifier the binding holds is one of `allowed` (none held counts). */
+function holdsOnly(a: ParsedAccelerator, ...allowed: Modifier[]): boolean {
+  return (['cmd', 'ctrl', 'alt', 'shift'] as const).every((m) => !a[m] || allowed.includes(m))
+}
+
+/** Caret, selection and deletion keys with the modifiers that make them edit text, per platform. */
+function editingKeyEdits(a: ParsedAccelerator, mac: boolean): boolean | undefined {
+  switch (a.key) {
+    case 'Left':
+    case 'Right':
+    case 'Up':
+    case 'Down':
+      // macOS: ⌘ moves by line, ⌥ by word, ⇧ selects (⌘⌥ arrows edit nothing). Elsewhere Ctrl
+      // moves by word and Shift selects; Alt+←/→ go back and forward.
+      return mac ? holdsOnly(a, 'cmd', 'shift') || holdsOnly(a, 'alt', 'shift') : holdsOnly(a, 'ctrl', 'shift')
+    case 'Home':
+    case 'End':
+      return mac ? holdsOnly(a, 'shift') : holdsOnly(a, 'ctrl', 'shift')
+    case 'PageUp':
+    case 'PageDown':
+      // Ctrl+PageUp/PageDown switch tabs, even from a field.
+      return holdsOnly(a, 'shift')
+    case 'Backspace':
+    case 'Delete':
+      // One of ⌘ (to line start), ⌥ (word) or ⇧ on macOS; Ctrl (word) elsewhere. ⌘⇧⌫ and
+      // Ctrl+Shift+Delete edit nothing (they clear browsing data).
+      return mac
+        ? holdsOnly(a, 'cmd') || holdsOnly(a, 'alt') || holdsOnly(a, 'shift')
+        : holdsOnly(a, 'ctrl') || holdsOnly(a, 'shift')
+    case 'Enter':
+    case 'Space':
+      return mac ? holdsOnly(a, 'alt', 'shift') : holdsOnly(a, 'shift')
+    case 'Tab':
+      return holdsOnly(a, 'shift')
+    case 'Insert':
+      return holdsOnly(a, 'ctrl', 'shift')
+    default:
+      return undefined
+  }
+}
+
+/**
+ * Whether a binding is a key that types or edits text in a field on this platform (KS-16): a
+ * printable key with no ⌘ or Ctrl (Shift types capitals; macOS's ⌥ types symbols), the caret,
+ * selection and deletion keys with the modifiers that move by word or line, and the clipboard and
+ * undo commands. Such a binding runs its action only while keyboard focus is outside text fields,
+ * and the key is never taken from the field.
+ */
+export function editsText(accel: string, platform: string): boolean {
+  const canonical = canonicalAccelerator(accel)
+  if (!canonical) return false
+  const mac = platform === 'darwin'
+  if ((mac ? MAC_TEXT_COMMANDS : OTHER_TEXT_COMMANDS).has(canonical)) return true
+  const a = parseAccelerator(canonical)
+  if (FUNCTION_KEY.test(a.key) || a.key === 'Escape') return false
+  const editing = editingKeyEdits(a, mac)
+  if (editing !== undefined) return editing
+  // A printable key types a character unless ⌘ or Ctrl is held (outside macOS, Alt too).
+  return mac ? !a.cmd && !a.ctrl : !a.cmd && !a.ctrl && !a.alt
+}
+
+/**
+ * Whether this key press typed a character that a plain press of the same key would not: on
+ * Windows, AltGr arrives as Ctrl+Alt, so a Ctrl+Alt binding must not fire when the press made "ń"
+ * or "@" in a text field (KS-03).
+ */
+export function typedWithAltGr(input: KeyInput, platform: string): boolean {
+  if (platform === 'darwin' || !input.control || !input.alt || input.meta) return false
+  if ([...input.key].length !== 1) return false
+  if (input.code.startsWith('Key') && input.key.toUpperCase() === input.code.slice(3)) return false
+  if (input.code.startsWith('Digit') && input.key === input.code.slice(5)) return false
+  // The symbol the key carries on a US layout, shifted or not: "[" from BracketLeft is no AltGr character.
+  const symbol = CODE_NAMES[input.code]
+  if (symbol !== undefined && symbol.length === 1 && (SHIFTED_SYMBOLS[input.key] ?? input.key) === symbol) return false
+  return true
+}
+
+// ---- The user's bindings on this device (KS-01) ----
+
+/** Action id → its whole binding list, for actions whose bindings the user changed. */
+export type CustomBindings = Readonly<Record<string, readonly string[]>>
+
+const NONE: CustomBindings = Object.freeze({})
+let custom: CustomBindings = NONE
+let version = 0
+const listeners = new Set<() => void>()
+
+/** Takes the user's bindings (`settings.shortcuts`) as they are now; listeners hear of a change. */
+export function setCustomBindings(next: CustomBindings | undefined): void {
+  const value = next ?? NONE
+  if (value === custom) return
+  custom = value
+  version++
+  for (const listener of [...listeners]) listener()
+}
+
+export function customBindings(): CustomBindings {
+  return custom
+}
+
+/** Goes up by one each time the user's bindings change: caches of hints compare it. */
+export function keymapVersion(): number {
+  return version
+}
+
+/** Calls `listener` after each change of the user's bindings; returns the unsubscribe. */
+export function onKeymapChange(listener: () => void): () => void {
+  listeners.add(listener)
+  return () => listeners.delete(listener)
+}
diff --git a/src/shared/rpc.ts b/src/shared/rpc.ts
index dda1c93f..5eebe940 100644
--- a/src/shared/rpc.ts
+++ b/src/shared/rpc.ts
@@ -15,6 +15,7 @@ import type { DownloadCommands } from './commands/downloads'
 import type { ExtensionCommands } from './commands/extensions'
 import type { HistoryCommands } from './commands/history'
 import type { ImportCommands } from './commands/import'
+import type { KeyCommands } from './commands/keys'
 import type { MediaCommands, MediaEvents } from './commands/media'
 import type { NavCommands } from './commands/nav'
 import type { PeekCommands, PeekEvents } from './commands/peek'
@@ -39,7 +40,8 @@ export interface OrbitCommands
     DownloadCommands,
     ImportCommands,
     NavCommands,
-    MediaCommands {}
+    MediaCommands,
+    KeyCommands {}
 
 export interface OrbitEvents extends CoreEvents, PeekEvents, MediaEvents {}
 
diff --git a/src/shared/state.ts b/src/shared/state.ts
index 07c483de..62cf241e 100644
--- a/src/shared/state.ts
+++ b/src/shared/state.ts
@@ -333,6 +333,14 @@ export interface Settings {
   countFavoritesInShortcuts: boolean
   /** ⌘9 selects the last tab (true) or the 9th item (false) (TB-04). */
   lastTabOnCmd9: boolean
+  /**
+   * Key bindings the user changed on this device (KS-01, ST-08): action id → its whole list of
+   * bindings (accelerator strings; empty when every key was taken away). Actions not listed use
+   * their defaults. Kept by src/main/keys; never synced.
+   */
+  shortcuts?: Record<string, string[]>
+  /** Who gets an action's keys first when a page also handles them, where the user chose (KS-02). */
+  shortcutPriority?: Record<string, 'websites' | 'orbit'>
   /** Use graphics acceleration when available (ST-12). Takes effect at the next start. */
   hardwareAcceleration: boolean
   /** Secure DNS (ST-12): the engine's automatic upgrade, off, or always one DNS-over-HTTPS provider. */
diff --git a/tests/e2e/keys.spec.ts b/tests/e2e/keys.spec.ts
index 6dc0513d..9ef0b4e9 100644
--- a/tests/e2e/keys.spec.ts
+++ b/tests/e2e/keys.spec.ts
@@ -1,6 +1,7 @@
 import { expect, test } from '@playwright/test'
-import { launchOrbit, MOD, type Orbit, run, state, viewPage } from './helpers'
+import { action, isMac, launchOrbit, MOD, type Orbit, run, state, viewPage } from './helpers'
 import { cmd, type NavFixtures, openTab, startNavFixtures } from './nav-support'
+import { activeSpace, createSpace } from './spaces-support'
 
 let fx: NavFixtures
 let orbit: Orbit
@@ -92,3 +93,111 @@ test('[KS-16] a tab in the background that loads again does not take the keyboar
   await finishLoad(back, '/slow/BackAgain')
   expect(await typeAnywhere(['b', 'c'])).toEqual([fx.url('/page/Front'), fx.url('/page/Front')])
 })
+
+// ---------- One keymap: remapping, several bindings, persistence (KS-01, KS-18) ----------
+
+/** The primary modifier as bindings write it. */
+const PRIMARY = isMac ? 'Cmd' : 'Ctrl'
+const SHIFT_B = isMac ? '⇧⌘B' : 'Ctrl+Shift+B'
+
+async function sidebarVisible(): Promise<boolean | undefined> {
+  return Object.values((await state(orbit.app)).windows)[0]?.sidebar.visible
+}
+
+/** Opens the command bar, types `text` and returns the top row once it is the action `title`. */
+async function actionRow(text: string, title: string) {
+  await orbit.shell.keyboard.press(`${MOD}+T`)
+  const overlay = await viewPage(orbit.app, 'overlay')
+  await expect(overlay.getByTestId('command-input')).toBeFocused()
+  await overlay.keyboard.type(text)
+  const top = overlay.getByTestId('command-result').first()
+  await expect(top).toHaveAttribute('data-kind', 'action')
+  await expect(top.getByTestId('command-result-title')).toHaveText(title)
+  return { overlay, top }
+}
+
+/** ⌘⇧B toggles the sidebar, and ⌘S no longer does. */
+async function onlyShiftBToggles(): Promise<void> {
+  const { shell } = orbit
+  await shell.keyboard.press(`${MOD}+Shift+B`)
+  await expect.poll(sidebarVisible).toBe(false)
+  // Were ⌘S still bound, these two presses would toggle twice and leave the sidebar hidden.
+  await shell.keyboard.press(`${MOD}+S`)
+  await shell.keyboard.press(`${MOD}+Shift+B`)
+  await expect.poll(sidebarVisible).toBe(true)
+}
+
+test('[KS-01][KS-18] remapping Toggle Sidebar to ⌘⇧B moves the key and every hint, and the remap and a Space key survive a restart', async () => {
+  const { app, shell, userData } = orbit
+  const bound = await run(app, 'keys.bind', {
+    actionId: 'sidebar.toggle',
+    accel: `${PRIMARY}+Shift+B`,
+    replace: `${PRIMARY}+S`,
+  })
+  expect(bound).toEqual({ ok: true })
+  // A bare function key may be a binding on its own: Space 2 moves to F8.
+  const defaultSpaceKey = isMac ? 'Ctrl+2' : 'Alt+2'
+  expect(await run(app, 'keys.bind', { actionId: 'space.goto.2', accel: 'F8', replace: defaultSpaceKey })).toEqual({
+    ok: true,
+  })
+  // The sidebar button's tooltip follows the remap at once.
+  await expect(shell.getByTestId('toggle-sidebar')).toHaveAttribute('title', `Hide sidebar (${SHIFT_B})`)
+  await onlyShiftBToggles()
+  // So does the command bar's row for the action.
+  const { overlay, top } = await actionRow('Toggle Sidebar', 'Toggle Sidebar')
+  await expect(top.getByTestId('command-shortcut')).toHaveText(SHIFT_B)
+  await overlay.keyboard.press('Escape')
+  if (isMac) {
+    const menuKey = await app.evaluate(
+      ({ Menu }) =>
+        Menu.getApplicationMenu()
+          ?.items.find((i) => i.label === 'View')
+          ?.submenu?.items.find((i) => i.label === 'Toggle Sidebar')?.accelerator,
+    )
+    expect(menuKey).toBe('Command+Shift+B')
+  }
+  const first = await activeSpace(app)
+  const second = await createSpace(app, { name: 'Second', activate: false })
+  await shell.keyboard.press('F8')
+  await expect.poll(() => activeSpace(app)).toBe(second)
+
+  await orbit.app.close()
+  orbit = await launchOrbit({ userData })
+  expect((await state(orbit.app)).settings.shortcuts).toEqual({
+    'sidebar.toggle': [`${PRIMARY}+Shift+B`],
+    'space.goto.2': ['F8'],
+  })
+  await expect(orbit.shell.getByTestId('toggle-sidebar')).toHaveAttribute('title', `Hide sidebar (${SHIFT_B})`)
+  await onlyShiftBToggles()
+  await action(orbit.app, 'space.goto.1')
+  await expect.poll(() => activeSpace(orbit.app)).toBe(first)
+  await orbit.shell.keyboard.press('F8')
+  await expect.poll(() => activeSpace(orbit.app)).toBe(second)
+})
+
+test('[KS-01] an action keeps several bindings, or none and the command bar still runs it; a binding needs a modifier and a free key', async () => {
+  const { app, shell } = orbit
+  expect(await run(app, 'keys.bind', { actionId: 'sidebar.toggle', accel: 'F7' })).toEqual({ ok: true })
+  await shell.keyboard.press('F7')
+  await expect.poll(sidebarVisible).toBe(false)
+  await shell.keyboard.press(`${MOD}+S`)
+  await expect.poll(sidebarVisible).toBe(true)
+
+  // No modifier, or a key another action has: refused, and nothing changes.
+  const bare = await run(app, 'keys.bind', { actionId: 'sidebar.toggle', accel: 'B' })
+  expect(bare).toMatchObject({ ok: false, problem: expect.stringContaining('A shortcut starts with') })
+  const taken = await run(app, 'keys.bind', { actionId: 'sidebar.toggle', accel: `${PRIMARY}+T` })
+  expect(taken).toEqual({ ok: false, conflict: { actionId: 'tab.new', title: 'New Tab' } })
+  expect((await state(app)).settings.shortcuts).toEqual({ 'sidebar.toggle': [`${PRIMARY}+S`, 'F7'] })
+
+  await run(app, 'keys.unbind', { actionId: 'sidebar.toggle', accel: `${PRIMARY}+S` })
+  await run(app, 'keys.unbind', { actionId: 'sidebar.toggle', accel: 'F7' })
+  expect((await state(app)).settings.shortcuts).toEqual({ 'sidebar.toggle': [] })
+  await expect(shell.getByTestId('toggle-sidebar')).toHaveAttribute('title', 'Hide sidebar')
+  // ⌘S does nothing now; the command bar's row, with no shortcut shown, still toggles the sidebar.
+  await shell.keyboard.press(`${MOD}+S`)
+  const { overlay, top } = await actionRow('Toggle Sidebar', 'Toggle Sidebar')
+  await expect(top.getByTestId('command-shortcut')).toHaveCount(0)
+  await overlay.keyboard.press('Enter')
+  await expect.poll(sidebarVisible).toBe(false)
+})
diff --git a/tests/unit/keymap-bindings.test.ts b/tests/unit/keymap-bindings.test.ts
new file mode 100644
index 00000000..66c49ced
--- /dev/null
+++ b/tests/unit/keymap-bindings.test.ts
@@ -0,0 +1,139 @@
+import { describe, expect, it } from 'vitest'
+import { actionForInput, outsideTextActionFor } from '../../src/shared/actions'
+import {
+  acceleratorFromInput,
+  bindingProblem,
+  canonicalAccelerator,
+  editsText,
+  formatAccelerator,
+  type KeyInput,
+  typedWithAltGr,
+} from '../../src/shared/keymap'
+
+const press = (key: string, code: string, mods: Partial<KeyInput> = {}): KeyInput => ({
+  key,
+  code,
+  meta: false,
+  control: false,
+  alt: false,
+  shift: false,
+  ...mods,
+})
+
+describe('[KS-01] bindings have one written form', () => {
+  it('orders modifiers and names keys one way', () => {
+    expect(canonicalAccelerator('Shift+Cmd+t')).toBe('Cmd+Shift+T')
+    expect(canonicalAccelerator('control+option+shift+n')).toBe('Ctrl+Alt+Shift+N')
+    expect(canonicalAccelerator('Command+Meta+K')).toBeUndefined()
+    expect(canonicalAccelerator('Cmd++')).toBe('Cmd+=')
+    expect(canonicalAccelerator('Cmd+Shift+=')).toBe('Cmd+Shift+=')
+    expect(canonicalAccelerator('Ctrl+Shift+{')).toBe('Ctrl+Shift+[')
+    expect(canonicalAccelerator('alt+left')).toBe('Alt+Left')
+    expect(canonicalAccelerator('Cmd+esc')).toBe('Cmd+Escape')
+    expect(canonicalAccelerator('f5')).toBe('F5')
+    expect(canonicalAccelerator('Shift+F24')).toBe('Shift+F24')
+  })
+
+  it('refuses what is not a binding', () => {
+    for (const bad of ['', 'Cmd+', 'Hyper+A', 'Cmd+Cmd+A', 'Cmd+Ö', 'Cmd+F25', 'Cmd+MediaPlayPause', 'Cmd+Shift']) {
+      expect(canonicalAccelerator(bad), bad).toBeUndefined()
+    }
+  })
+
+  it('reads a key press as the binding it makes, and nothing for a lone modifier', () => {
+    expect(acceleratorFromInput(press('b', 'KeyB', { meta: true, shift: true }))).toBe('Cmd+Shift+B')
+    expect(acceleratorFromInput(press('B', 'KeyB', { control: true, shift: true }))).toBe('Ctrl+Shift+B')
+    expect(acceleratorFromInput(press('+', 'Equal', { meta: true, shift: true }))).toBe('Cmd+Shift+=')
+    expect(acceleratorFromInput(press('F7', 'F7'))).toBe('F7')
+    expect(acceleratorFromInput(press('Shift', 'ShiftLeft', { shift: true }))).toBeUndefined()
+    expect(acceleratorFromInput(press('Meta', 'MetaLeft', { meta: true }))).toBeUndefined()
+  })
+})
+
+describe('[KS-01] what a new binding must be', () => {
+  it('needs a modifier, except F1–F12 on their own', () => {
+    expect(bindingProblem('B', 'darwin')).toBe('A shortcut starts with ⇧, ⌃, ⌥ or ⌘ (F1–F12 can be used on their own).')
+    expect(bindingProblem('Enter', 'linux')).toBe(
+      'A shortcut starts with Shift, Ctrl or Alt (F1–F12 can be used on their own).',
+    )
+    expect(bindingProblem('F7', 'darwin')).toBeUndefined()
+    expect(bindingProblem('F12', 'linux')).toBeUndefined()
+    expect(bindingProblem('F13', 'linux')).toBeDefined()
+    expect(bindingProblem('Shift+F13', 'linux')).toBeUndefined()
+    expect(bindingProblem('Shift+B', 'darwin')).toBeUndefined()
+    expect(bindingProblem('Cmd+Shift+B', 'darwin')).toBeUndefined()
+  })
+
+  it('keeps the system’s own keys', () => {
+    expect(bindingProblem('Cmd+Q', 'darwin')).toBe('⌘Q is kept for Quit Orbit.')
+    expect(bindingProblem('Cmd+M', 'darwin')).toBe('⌘M is kept for Minimize.')
+    expect(bindingProblem('Cmd+Q', 'linux')).toBeUndefined()
+    expect(bindingProblem('Alt+F4', 'win32')).toBe('Alt+F4 is kept for closing the window.')
+    expect(bindingProblem('Alt+F', 'linux')).toBe('Alt+F is kept for the app menu.')
+  })
+
+  it('says when Orbit cannot use the key at all', () => {
+    expect(bindingProblem('Cmd+Ö', 'darwin')).toBe("Orbit can't use that key for a shortcut.")
+  })
+
+  it('shows bindings as each platform writes them', () => {
+    expect(formatAccelerator('Cmd+Shift+B', 'darwin')).toBe('⇧⌘B')
+    expect(formatAccelerator('Cmd+Shift+Backspace', 'darwin')).toBe('⇧⌘⌫')
+    expect(formatAccelerator('Ctrl+Shift+Delete', 'linux')).toBe('Ctrl+Shift+Delete')
+    expect(formatAccelerator('Ctrl+PageDown', 'linux')).toBe('Ctrl+PageDown')
+  })
+})
+
+describe('[KS-16] keys that edit text act only outside text fields', () => {
+  it('knows the caret, selection, clipboard and undo keys of each platform', () => {
+    for (const accel of ['Cmd+Left', 'Cmd+Shift+Right', 'Alt+Left', 'Cmd+Z', 'Cmd+Shift+Z', 'Cmd+A', 'Cmd+V']) {
+      expect(editsText(accel, 'darwin'), accel).toBe(true)
+    }
+    for (const accel of ['Ctrl+Left', 'Ctrl+Shift+Right', 'Ctrl+Z', 'Ctrl+Y', 'Ctrl+Backspace', 'Shift+Insert']) {
+      expect(editsText(accel, 'linux'), accel).toBe(true)
+    }
+    // Back and forward, tab and Space switching, clearing data: they edit nothing.
+    for (const accel of ['Cmd+[', 'Cmd+Alt+Left', 'Cmd+Alt+Down', 'Cmd+Shift+Backspace', 'Ctrl+Tab', 'F5']) {
+      expect(editsText(accel, 'darwin'), accel).toBe(false)
+    }
+    for (const accel of ['Alt+Left', 'Ctrl+PageDown', 'Ctrl+Alt+Right', 'Ctrl+Shift+Delete', 'Alt+2']) {
+      expect(editsText(accel, 'linux'), accel).toBe(false)
+    }
+  })
+
+  it('counts a printable key with Shift, or macOS’s ⌥, as typing', () => {
+    expect(editsText('Shift+K', 'darwin')).toBe(true)
+    expect(editsText('Alt+K', 'darwin')).toBe(true)
+    expect(editsText('Alt+K', 'linux')).toBe(false)
+    expect(editsText('Shift+F3', 'linux')).toBe(false)
+  })
+
+  it('leaves keys to an input method while it composes, unless ⌘ or Ctrl is held', () => {
+    expect(actionForInput(press('F5', 'F5', { isComposing: true }), 'linux')).toBeUndefined()
+    expect(actionForInput(press('F5', 'F5'), 'linux')?.id).toBe('nav.reload')
+    expect(actionForInput(press('t', 'KeyT', { control: true, isComposing: true }), 'linux')?.id).toBe('tab.new')
+  })
+})
+
+describe('[KS-03] AltGr typing is not a Ctrl+Alt shortcut', () => {
+  it('tells AltGr characters from the key’s own', () => {
+    // Polish AltGr+N types ń; German AltGr+Q types @ and AltGr+7 types {.
+    expect(typedWithAltGr(press('ń', 'KeyN', { control: true, alt: true }), 'win32')).toBe(true)
+    expect(typedWithAltGr(press('@', 'KeyQ', { control: true, alt: true }), 'linux')).toBe(true)
+    expect(typedWithAltGr(press('{', 'Digit7', { control: true, alt: true }), 'linux')).toBe(true)
+    expect(typedWithAltGr(press('n', 'KeyN', { control: true, alt: true }), 'win32')).toBe(false)
+    expect(typedWithAltGr(press('2', 'Digit2', { control: true, alt: true }), 'linux')).toBe(false)
+    expect(typedWithAltGr(press('[', 'BracketLeft', { control: true, alt: true }), 'linux')).toBe(false)
+    expect(typedWithAltGr(press('ArrowLeft', 'ArrowLeft', { control: true, alt: true }), 'linux')).toBe(false)
+    expect(typedWithAltGr(press('ń', 'KeyN', { meta: true, alt: true }), 'darwin')).toBe(false)
+  })
+
+  it('runs a Ctrl+Alt action only outside text fields when the press typed a character', () => {
+    const altGrN = press('ń', 'KeyN', { control: true, alt: true })
+    expect(actionForInput(altGrN, 'win32')).toBeUndefined()
+    expect(outsideTextActionFor(altGrN, 'win32')?.id).toBe('window.newMini')
+    const plain = press('n', 'KeyN', { control: true, alt: true })
+    expect(actionForInput(plain, 'win32')?.id).toBe('window.newMini')
+    expect(outsideTextActionFor(plain, 'win32')).toBeUndefined()
+  })
+})
diff --git a/tests/unit/keymap-remap.test.ts b/tests/unit/keymap-remap.test.ts
new file mode 100644
index 00000000..aaf26180
--- /dev/null
+++ b/tests/unit/keymap-remap.test.ts
@@ -0,0 +1,235 @@
+import { afterEach, describe, expect, it, vi } from 'vitest'
+import {
+  bind,
+  MAX_BINDINGS,
+  normalizeKeySettings,
+  normalizePriorities,
+  normalizeShortcuts,
+  reset,
+  setPriority,
+  unbind,
+} from '../../src/main/keys/bindings'
+import {
+  ACTIONS_BY_ID,
+  actionForAccelerator,
+  actionForInput,
+  buildKeymap,
+  priorityFor,
+  shortcutsFor,
+} from '../../src/shared/actions'
+import { keymapVersion, onKeymapChange, setCustomBindings } from '../../src/shared/keymap'
+import type { Settings } from '../../src/shared/state'
+
+const action = (id: string) => {
+  const found = ACTIONS_BY_ID[id]
+  if (!found) throw new Error(`no action ${id}`)
+  return found
+}
+const cmdS = { key: 's', code: 'KeyS', meta: true, control: false, alt: false, shift: false }
+const cmdShiftB = { key: 'b', code: 'KeyB', meta: true, control: false, alt: false, shift: true }
+
+afterEach(() => setCustomBindings(undefined))
+
+describe('[KS-01] one keymap with the user’s bindings', () => {
+  it('uses the user’s list for an action they changed and the defaults elsewhere', () => {
+    const keymap = buildKeymap({ 'sidebar.toggle': ['Cmd+Shift+B'] }, 'darwin')
+    expect(keymap.lists.get('sidebar.toggle')).toEqual(['Cmd+Shift+B'])
+    expect(keymap.direct.get('Cmd+Shift+B')?.id).toBe('sidebar.toggle')
+    expect(keymap.direct.get('Cmd+S')).toBeUndefined()
+    expect(keymap.lists.get('tab.new')).toEqual(['Cmd+T'])
+  })
+
+  it('gives a key the user took for another action to that action only', () => {
+    const keymap = buildKeymap({ 'sidebar.toggle': ['Cmd+D'] }, 'darwin')
+    expect(keymap.direct.get('Cmd+D')?.id).toBe('sidebar.toggle')
+    expect(keymap.lists.get('tab.togglePin')).toEqual([])
+  })
+
+  it('never lets a binding take a fixed action’s key (⌘, stays Settings)', () => {
+    const keymap = buildKeymap({ 'tab.new': ['Cmd+,'], 'tab.recent': ['Cmd+J'] }, 'darwin')
+    expect(keymap.direct.get('Cmd+,')?.id).toBe('app.settings')
+    expect(keymap.lists.get('tab.new')).toEqual([])
+    // A fixed action keeps its own keys whatever is stored for it.
+    expect(keymap.lists.get('tab.recent')).toEqual(['Ctrl+Tab'])
+  })
+
+  it('keeps an action with no bindings: the command bar and menus still reach it', () => {
+    const keymap = buildKeymap({ 'sidebar.toggle': [] }, 'linux')
+    expect(keymap.lists.get('sidebar.toggle')).toEqual([])
+    expect(keymap.direct.get('Ctrl+S')).toBeUndefined()
+  })
+
+  it('puts a binding that types text with the keys that act only outside text fields (KS-16)', () => {
+    const keymap = buildKeymap({ 'tab.new': ['Shift+K'] }, 'darwin')
+    expect(keymap.outsideText.get('Shift+K')?.id).toBe('tab.new')
+    expect(keymap.direct.get('Shift+K')).toBeUndefined()
+    // ⌘← on macOS: Back, outside text fields only.
+    expect(keymap.outsideText.get('Cmd+Left')?.id).toBe('nav.back')
+  })
+
+  it('follows the user’s bindings live, and tells listeners', () => {
+    const heard = vi.fn()
+    const off = onKeymapChange(heard)
+    const before = keymapVersion()
+    expect(actionForInput(cmdS, 'darwin')?.id).toBe('sidebar.toggle')
+    setCustomBindings({ 'sidebar.toggle': ['Cmd+Shift+B'] })
+    expect(keymapVersion()).toBe(before + 1)
+    expect(heard).toHaveBeenCalledTimes(1)
+    expect(actionForInput(cmdS, 'darwin')).toBeUndefined()
+    expect(actionForInput(cmdShiftB, 'darwin')?.id).toBe('sidebar.toggle')
+    expect(shortcutsFor(action('sidebar.toggle'), 'darwin')).toEqual(['Cmd+Shift+B'])
+    expect(actionForAccelerator('Shift+Cmd+b', 'darwin')?.id).toBe('sidebar.toggle')
+    // The same map again is no change.
+    setCustomBindings({ 'sidebar.toggle': ['Cmd+Shift+B'] })
+    expect(heard).toHaveBeenCalledTimes(2)
+    const same = { 'sidebar.toggle': ['Cmd+Shift+B'] }
+    setCustomBindings(same)
+    setCustomBindings(same)
+    expect(heard).toHaveBeenCalledTimes(3)
+    off()
+    setCustomBindings(undefined)
+    expect(heard).toHaveBeenCalledTimes(3)
+    expect(actionForInput(cmdS, 'darwin')?.id).toBe('sidebar.toggle')
+  })
+})
+
+describe('[KS-01][ST-08] changing bindings', () => {
+  it('replaces a binding, or adds another (aliases)', () => {
+    const replaced = bind(undefined, { actionId: 'sidebar.toggle', accel: 'Cmd+Shift+B', replace: 'Cmd+S' }, 'darwin')
+    expect(replaced.result).toEqual({ ok: true })
+    expect(replaced.custom).toEqual({ 'sidebar.toggle': ['Cmd+Shift+B'] })
+    const added = bind(undefined, { actionId: 'sidebar.toggle', accel: 'shift+cmd+b' }, 'darwin')
+    expect(added.custom).toEqual({ 'sidebar.toggle': ['Cmd+S', 'Cmd+Shift+B'] })
+  })
+
+  it('drops an action’s entry when its bindings are the defaults again', () => {
+    const { custom } = bind(
+      { 'sidebar.toggle': ['Cmd+Shift+B'] },
+      { actionId: 'sidebar.toggle', accel: 'Cmd+S', replace: 'Cmd+Shift+B' },
+      'darwin',
+    )
+    expect(custom).toEqual({})
+  })
+
+  it('reports a conflict and changes nothing until asked to clear or swap', () => {
+    const asked = bind(undefined, { actionId: 'sidebar.toggle', accel: 'Cmd+D', replace: 'Cmd+S' }, 'darwin')
+    expect(asked.result).toEqual({ ok: false, conflict: { actionId: 'tab.togglePin', title: 'Pin / Unpin Tab' } })
+    expect(asked.custom).toEqual({})
+
+    const cleared = bind(
+      undefined,
+      { actionId: 'sidebar.toggle', accel: 'Cmd+D', replace: 'Cmd+S', onConflict: 'clear' },
+      'darwin',
+    )
+    expect(cleared.result).toEqual({ ok: true })
+    expect(cleared.custom).toEqual({ 'sidebar.toggle': ['Cmd+D'], 'tab.togglePin': [] })
+
+    const swapped = bind(
+      undefined,
+      { actionId: 'sidebar.toggle', accel: 'Cmd+D', replace: 'Cmd+S', onConflict: 'swap' },
+      'darwin',
+    )
+    expect(swapped.custom).toEqual({ 'sidebar.toggle': ['Cmd+D'], 'tab.togglePin': ['Cmd+S'] })
+    const keymap = buildKeymap(swapped.custom, 'darwin')
+    expect(keymap.direct.get('Cmd+S')?.id).toBe('tab.togglePin')
+    expect(keymap.direct.get('Cmd+D')?.id).toBe('sidebar.toggle')
+  })
+
+  it('refuses bindings Orbit can’t use and keys a fixed action keeps', () => {
+    expect(bind(undefined, { actionId: 'sidebar.toggle', accel: 'B' }, 'darwin').result).toEqual({
+      ok: false,
+      problem: 'A shortcut starts with ⇧, ⌃, ⌥ or ⌘ (F1–F12 can be used on their own).',
+    })
+    expect(bind(undefined, { actionId: 'sidebar.toggle', accel: 'Cmd+,' }, 'darwin').result).toEqual({
+      ok: false,
+      problem: '⌘, is kept for Settings.',
+    })
+    expect(bind(undefined, { actionId: 'app.settings', accel: 'Cmd+Shift+B' }, 'darwin').result).toEqual({
+      ok: false,
+      problem: 'Settings keeps its shortcut.',
+    })
+    expect(bind(undefined, { actionId: 'no.such', accel: 'Cmd+Shift+B' }, 'darwin').result).toMatchObject({
+      ok: false,
+    })
+    expect(bind(undefined, { actionId: 'sidebar.toggle', accel: 'F7' }, 'linux').result).toEqual({ ok: true })
+  })
+
+  it(`keeps at most ${MAX_BINDINGS} bindings on an action`, () => {
+    let custom = {}
+    for (const n of [1, 2, 3, 4]) custom = bind(custom, { actionId: 'tab.new', accel: `F${n}` }, 'darwin').custom
+    expect(custom).toEqual({ 'tab.new': ['Cmd+T', 'F1', 'F2', 'F3', 'F4'] })
+    const more = bind(custom, { actionId: 'tab.new', accel: 'F6' }, 'darwin')
+    expect(more.result).toEqual({ ok: false, problem: `An action can have up to ${MAX_BINDINGS} shortcuts.` })
+    expect(more.custom).toEqual(custom)
+  })
+
+  it('takes a binding off, leaving the action without keys', () => {
+    expect(unbind(undefined, 'sidebar.toggle', 'Ctrl+S', 'linux')).toEqual({ 'sidebar.toggle': [] })
+    expect(unbind(undefined, 'sidebar.toggle', 'Ctrl+Q', 'linux')).toEqual({})
+    expect(unbind(undefined, 'app.settings', 'Ctrl+,', 'linux')).toEqual({})
+  })
+
+  it('resets an action, taking its default keys back from the action given them', () => {
+    const { custom } = bind(undefined, { actionId: 'sidebar.toggle', accel: 'Cmd+D', onConflict: 'clear' }, 'darwin')
+    expect(custom).toEqual({ 'sidebar.toggle': ['Cmd+S', 'Cmd+D'], 'tab.togglePin': [] })
+    expect(reset(custom, 'tab.togglePin', 'darwin')).toEqual({})
+    expect(reset(custom, 'sidebar.toggle', 'darwin')).toEqual({ 'tab.togglePin': [] })
+  })
+})
+
+describe('[KS-01] stored bindings survive a restart only as Orbit can use them', () => {
+  it('keeps what is valid and drops the rest', () => {
+    expect(normalizeShortcuts(undefined, 'darwin')).toBeUndefined()
+    expect(normalizeShortcuts(['Cmd+B'], 'darwin')).toBeUndefined()
+    expect(
+      normalizeShortcuts(
+        {
+          'sidebar.toggle': ['shift+cmd+b', 'B', 42, 'Cmd+Q', 'Cmd+Shift+B'],
+          'space.goto.2': ['F8'],
+          'no.such': ['Cmd+Shift+Y'],
+          'app.settings': ['Cmd+Shift+U'],
+          'tab.new': 'Cmd+T',
+          // Taken already by an action earlier in the list.
+          'space.rename': ['Cmd+Shift+B'],
+          'tab.close': ['Cmd+W'],
+        },
+        'darwin',
+      ),
+    ).toEqual({ 'sidebar.toggle': ['Cmd+Shift+B'], 'space.goto.2': ['F8'] })
+  })
+
+  it('keeps no more than the most bindings an action can have', () => {
+    const many = ['F1', 'F2', 'F3', 'F4', 'F5', 'F6', 'F7']
+    expect(normalizeShortcuts({ 'tab.new': many }, 'linux')).toEqual({ 'tab.new': many.slice(0, MAX_BINDINGS) })
+  })
+
+  it('cleans settings in place', () => {
+    const settings = {
+      shortcuts: { 'sidebar.toggle': ['Ctrl+S'] },
+      shortcutPriority: { 'sidebar.toggle': 'orbit', 'tab.new': 'sometimes' },
+    } as unknown as Settings
+    normalizeKeySettings(settings, 'linux')
+    expect(settings.shortcuts).toBeUndefined()
+    expect(settings.shortcutPriority).toEqual({ 'sidebar.toggle': 'orbit' })
+  })
+})
+
+describe('[KS-02] who gets an action’s keys first', () => {
+  it('has defaults per action and platform', () => {
+    expect(priorityFor(action('sidebar.toggle'), 'darwin')).toBe('websites')
+    expect(priorityFor(action('sidebar.toggle'), 'linux')).toBe('websites')
+    expect(priorityFor(action('tab.copyUrl'), 'darwin')).toBe('orbit')
+    expect(priorityFor(action('tab.copyUrl'), 'win32')).toBe('websites')
+    expect(priorityFor(action('tab.new'), 'linux')).toBe('orbit')
+  })
+
+  it('stores only a choice that differs from the default', () => {
+    expect(setPriority(undefined, 'sidebar.toggle', 'orbit', 'linux')).toEqual({ 'sidebar.toggle': 'orbit' })
+    expect(setPriority({ 'sidebar.toggle': 'orbit' }, 'sidebar.toggle', 'websites', 'linux')).toEqual({})
+    expect(setPriority(undefined, 'app.settings', 'websites', 'linux')).toEqual({})
+    expect(priorityFor(action('tab.new'), 'linux', { 'tab.new': 'websites' })).toBe('websites')
+    expect(normalizePriorities({ 'tab.new': 'orbit', 'tab.close': 'websites', x: 'orbit' }, 'linux')).toEqual({
+      'tab.close': 'websites',
+    })
+  })
+})

From 08c9904d1d7baf7664988336ed403394606fa999 Mon Sep 17 00:00:00 2001
From: Siya <57148521+siyabendoezdemir@users.noreply.github.com>
Date: Sat, 10 Oct 2026 15:17:30 +0000
Subject: [PATCH 03/11] feat(keys): default keys checked against the spec
 tables; Close Window and F6 (KS-03, KS-05)

- Every default binding is checked against the spec's shortcut tables on macOS, Windows and
  Linux (unit test), with no key bound twice and each one a binding Orbit accepts.
- Close Window is an action: Cmd+Shift+W / Ctrl+Shift+W closes the window, or the Mini Window,
  Settings or onboarding window that has focus; the macOS File menu item runs it.
- F6 moves the keyboard between the sidebar and the page.
- F12 opens DevTools on macOS too; F1 opens Help on Windows and Linux.
- The macOS menu shows bindings that edit text without registering them, so a text field
  keeps them.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 FEATURES.md                        |  28 ++---
 docs/feature-status.json           |   2 +
 src/main/keys/index.ts             |   2 +
 src/main/keys/window-keys.ts       |  25 +++++
 src/main/menu.ts                   |   8 +-
 src/main/miniwindow/index.ts       |   1 +
 src/shared/actions.ts              |  13 ++-
 src/shared/commands/settings.ts    |   9 +-
 tests/e2e/keys.spec.ts             |  60 +++++++++++
 tests/unit/keymap-defaults.test.ts | 161 +++++++++++++++++++++++++++++
 tests/unit/keymap-remap.test.ts    |   2 +-
 11 files changed, 292 insertions(+), 19 deletions(-)
 create mode 100644 src/main/keys/window-keys.ts
 create mode 100644 tests/unit/keymap-defaults.test.ts

diff --git a/FEATURES.md b/FEATURES.md
index 3947961a..2360889c 100644
--- a/FEATURES.md
+++ b/FEATURES.md
@@ -4,12 +4,12 @@
 
 Every row is one behaviour from the clean-room spec. Status per ID: **spec’d** (every row) → **built** → **tested** (a unit or e2e test names the ID) → **feels right** (lead sign-off after a hands-on review against `feel.md`).
 
-**Totals:** 475 spec’d · 201 built (74 partial) · 285 tested · 0 feel right. 10 more are out of scope and not counted.
+**Totals:** 475 spec’d · 201 built (76 partial) · 291 tested · 0 feel right. 10 more are out of scope and not counted.
 
 | Priority | Spec’d | Built | Tested |
 |---|---|---|---|
-| P0 | 174 | 131 | 161 |
-| P1 | 221 | 61 | 113 |
+| P0 | 174 | 131 | 164 |
+| P1 | 221 | 61 | 116 |
 | P2 | 80 | 9 | 11 |
 
 P0 = milestone-1 core experience, P1 = parity, P2 = later.
@@ -348,19 +348,19 @@ Spec: `spec/shortcuts.md`
 |---|---|---|---|---|---|---|
 | KS-01 | One keymap, remapping and persistence | P0 | 🟡 partial | ✅ e2e+unit | – | one keymap keyed by action id (src/shared/actions.ts + src/shared/keymap.ts): the key router, macOS menu bar (rebuilt on a remap), tooltips and command-bar rows read the live bindings; remap, several bindings per action (up to 5), none (command bar and menus still run it), a modifier required except F1-F12, system keys refused, conflicts reported (clear or swap), reset; stored per device in settings.shortcuts, cleaned on load, kept across a restart (Space keys too); the Settings → Shortcuts page comes with ST-08 |
 | KS-02 | Conflicts with web pages ("prefer websites" vs "prefer Orbit") | P0 | – | ✅ unit | – |  |
-| KS-03 | Platform mapping rules | P0 | – | ✅ unit | – |  |
-| KS-04 | Command bar and address | P0 | ✅ | ✅ e2e | – | ⌘T/⌘L/Alt+D, Esc, ⌘T/⌘L again, ↑/↓ (⌃N/⌃P), Enter, Tab, ⌫, ⇧Enter (option), ⌘⌥⌫ / Shift+Delete, ⌘⌥V |
-| KS-05 | Tabs and windows | P0 | – | – | – |  |
-| KS-06 | Switching tabs | P0 | – | – | – |  |
-| KS-07 | Spaces | P0 | ✅ | ✅ e2e | – | Space shortcuts wired through the action table |
+| KS-03 | Platform mapping rules | P0 | 🟡 partial | ✅ e2e+unit | – | every default checked against the spec tables on macOS, Windows and Linux (unit test): ⌘ → Ctrl, ⌥ → Alt, ⌃ keys (⌃Tab, the split keys) stay Ctrl; the Windows/Linux exceptions Alt+1–9 for Spaces, Ctrl+H, Alt+←/→, Alt+D, F5, F3, Ctrl+F4 and F1; Alt+F4 and Alt+F are kept for the system; a Ctrl+Alt key that typed an AltGr character acts only outside text fields; letters and symbols follow the layout; F11 / Alt+Shift+F come with full screen (KS-08); the Linux desktop-clash hint and the macOS Mission Control hint come with ST-08 |
+| KS-04 | Command bar and address | P0 | ✅ | ✅ e2e+unit | – | ⌘T/⌘L/Alt+D, Esc, ⌘T/⌘L again, ↑/↓ (⌃N/⌃P), Enter, Tab, ⌫, ⇧Enter (option), ⌘⌥⌫ / Shift+Delete, ⌘⌥V |
+| KS-05 | Tabs and windows | P0 | 🟡 partial | ✅ e2e+unit | – | ⌘N, ⌘⇧N, ⌘⌥N, ⌘W / Ctrl+W / Ctrl+F4, ⌘⇧W / Ctrl+Shift+W (closes the window, or the Mini Window, Settings or onboarding window that has focus; Alt+F4 is the system's), ⌘⇧T, ⌘D, ⌘⇧C, ⌘⇧⌥C, ⌘S, ⌘⇧K, ⌘⇧E, F6 (keyboard between the sidebar and the page), Duplicate and Reset to Pinned assignable; ⌘Z (sidebar undo) is not remappable yet; the blank window (⌃⌘N, TB-17) and the top toolbar (⌘⇧D, SB-17) are not built |
+| KS-06 | Switching tabs | P0 | – | ✅ e2e+unit | – |  |
+| KS-07 | Spaces | P0 | ✅ | ✅ e2e+unit | – | Space shortcuts wired through the action table |
 | KS-08 | Page navigation and page tools | P0 | 🟡 partial | ✅ e2e+unit | – | Back, Forward, Reload, hard reload, Stop, find (Cmd+F, Cmd+G, Shift+Cmd+G, F3, Ctrl+G), Cmd+J and zoom keys done; print, save page, reader mode and the rest come with their NV items |
-| KS-09 | Split view | P0 | – | – | – |  |
-| KS-10 | Peek and Mini Window | P1 | – | – | – |  |
-| KS-11 | Media | P1 | 🟡 partial | ✅ e2e | – | Space and arrows in the focused player, Cmd/Ctrl+scroll and pinch zoom (tested), hardware media keys via Chromium (untested), Mute Tab action assignable; the calendar meeting shortcut (P2) belongs to TB-21/FV-09 |
-| KS-12 | Library, history, downloads, settings, extensions, help | P1 | – | ✅ e2e | – |  |
-| KS-13 | Developer tools | P1 | – | – | – |  |
+| KS-09 | Split view | P0 | – | ✅ unit | – |  |
+| KS-10 | Peek and Mini Window | P1 | – | ✅ unit | – |  |
+| KS-11 | Media | P1 | 🟡 partial | ✅ e2e+unit | – | Space and arrows in the focused player, Cmd/Ctrl+scroll and pinch zoom (tested), hardware media keys via Chromium (untested), Mute Tab action assignable; the calendar meeting shortcut (P2) belongs to TB-21/FV-09 |
+| KS-12 | Library, history, downloads, settings, extensions, help | P1 | – | ✅ e2e+unit | – |  |
+| KS-13 | Developer tools | P1 | – | ✅ unit | – |  |
 | KS-14 | Canvases, notes, capture and Tweaks | P2 | – | – | – |  |
-| KS-15 | Standard app and window keys | P1 | – | – | – |  |
+| KS-15 | Standard app and window keys | P1 | – | ✅ unit | – |  |
 | KS-16 | Text-editing keys keep their meaning | P0 | 🟡 partial | ✅ e2e+unit | – | typed keys never go astray: a page or Orbit view that loads (a slow page, a background tab, a reload) no longer takes the keyboard from the command bar, a sidebar field or the page in front (focus-on-navigation off for every web contents Orbit makes); ⌘←/⌘→ act outside text fields only; the full text-editing and IME audit is still to do |
 | KS-17 | Mouse, trackpad and modifier-click bindings | P0 | – | – | – |  |
 | KS-18 | Shortcut hints everywhere | P1 | 🟡 partial | ✅ e2e | – | button tooltips (address, copy link, site controls, sidebar toggle, back/forward/reload, find, zoom, Library, Clear, Space dots, Peek, Mini Window Open in…), the empty-window hint, command-bar rows and macOS menu items follow a remap without a restart; context menus and the shortcut sheet (OB-12) to come |
diff --git a/docs/feature-status.json b/docs/feature-status.json
index 59365038..1929ee39 100644
--- a/docs/feature-status.json
+++ b/docs/feature-status.json
@@ -139,6 +139,8 @@
   "KS-16": {"built": "partial", "note": "typed keys never go astray: a page or Orbit view that loads (a slow page, a background tab, a reload) no longer takes the keyboard from the command bar, a sidebar field or the page in front (focus-on-navigation off for every web contents Orbit makes); ⌘←/⌘→ act outside text fields only; the full text-editing and IME audit is still to do"},
   "KS-01": {"built": "partial", "note": "one keymap keyed by action id (src/shared/actions.ts + src/shared/keymap.ts): the key router, macOS menu bar (rebuilt on a remap), tooltips and command-bar rows read the live bindings; remap, several bindings per action (up to 5), none (command bar and menus still run it), a modifier required except F1-F12, system keys refused, conflicts reported (clear or swap), reset; stored per device in settings.shortcuts, cleaned on load, kept across a restart (Space keys too); the Settings → Shortcuts page comes with ST-08"},
   "KS-18": {"built": "partial", "note": "button tooltips (address, copy link, site controls, sidebar toggle, back/forward/reload, find, zoom, Library, Clear, Space dots, Peek, Mini Window Open in…), the empty-window hint, command-bar rows and macOS menu items follow a remap without a restart; context menus and the shortcut sheet (OB-12) to come"},
+  "KS-03": {"built": "partial", "note": "every default checked against the spec tables on macOS, Windows and Linux (unit test): ⌘ → Ctrl, ⌥ → Alt, ⌃ keys (⌃Tab, the split keys) stay Ctrl; the Windows/Linux exceptions Alt+1–9 for Spaces, Ctrl+H, Alt+←/→, Alt+D, F5, F3, Ctrl+F4 and F1; Alt+F4 and Alt+F are kept for the system; a Ctrl+Alt key that typed an AltGr character acts only outside text fields; letters and symbols follow the layout; F11 / Alt+Shift+F come with full screen (KS-08); the Linux desktop-clash hint and the macOS Mission Control hint come with ST-08"},
+  "KS-05": {"built": "partial", "note": "⌘N, ⌘⇧N, ⌘⌥N, ⌘W / Ctrl+W / Ctrl+F4, ⌘⇧W / Ctrl+Shift+W (closes the window, or the Mini Window, Settings or onboarding window that has focus; Alt+F4 is the system's), ⌘⇧T, ⌘D, ⌘⇧C, ⌘⇧⌥C, ⌘S, ⌘⇧K, ⌘⇧E, F6 (keyboard between the sidebar and the page), Duplicate and Reset to Pinned assignable; ⌘Z (sidebar undo) is not remappable yet; the blank window (⌃⌘N, TB-17) and the top toolbar (⌘⇧D, SB-17) are not built"},
   "FL-13": {"built": "yes", "note": "strip of pages, 1:1 tracking, commit thresholds, settle/rubber-band springs, one-page slides for clicks and keys, reduced motion cross-fade"},
   "FL-14": {"built": "yes", "note": "theme blends with the gesture/spring in OKLab; 200 ms preset blends; light/dark cross-fade"},
   "FL-16": {"built": "yes", "note": "motion spring (0.97→1, 4 px drop), 100 ms exit (80 ms after choosing a row) while focus returns at once; fade only with reduced motion; centred in the window"},
diff --git a/src/main/keys/index.ts b/src/main/keys/index.ts
index 0bd7f08e..383c8e20 100644
--- a/src/main/keys/index.ts
+++ b/src/main/keys/index.ts
@@ -4,6 +4,7 @@ import type { MainContext } from '../context'
 import { installMenu } from '../menu'
 import { bind, reset, setPriority, unbind } from './bindings'
 import { keyRouter } from './router'
+import { registerWindowKeys } from './window-keys'
 
 /**
  * The keymap in main (KS-01): the user's bindings follow `settings.shortcuts`, the menu bar is
@@ -64,6 +65,7 @@ export function registerKeys(ctx: MainContext): void {
     if (!text(actionId)) return
     savePriorities(setPriority(store.state.settings.shortcutPriority, actionId, priority, platform))
   })
+  registerWindowKeys(ctx)
   keyRouter.init(ctx)
   commands.register('keys.record', ({ on }, c) => keyRouter.setRecording(on ? c.windowId : undefined))
 }
diff --git a/src/main/keys/window-keys.ts b/src/main/keys/window-keys.ts
new file mode 100644
index 00000000..40626372
--- /dev/null
+++ b/src/main/keys/window-keys.ts
@@ -0,0 +1,25 @@
+import { webContents } from 'electron'
+import type { MainContext } from '../context'
+
+/**
+ * Window keys from the keymap's tables that no feature had yet (KS-05): Close Window
+ * (⌘⇧W / Ctrl+Shift+W) and F6, which moves the keyboard between the sidebar and the page (SB-22).
+ * Settings, onboarding and Mini Windows close themselves through their own action interceptors.
+ */
+export function registerWindowKeys(ctx: MainContext): void {
+  const { actions, windows } = ctx
+  actions.register('window.close', (c) => {
+    const windowId = c.windowId ?? windows.focusedWindowId()
+    const win = windowId ? windows.get(windowId) : undefined
+    if (win && !win.isDestroyed()) win.close()
+    // A page's pop-up or detached DevTools in front.
+    else windows.closeFocusedForeign()
+  })
+  actions.register('focus.cycle', (c) => {
+    const windowId = c.windowId ?? windows.focusedWindowId()
+    const win = windowId ? windows.get(windowId) : undefined
+    if (!windowId || !win || win.isDestroyed()) return
+    if (webContents.getFocusedWebContents() === win.webContents) windows.focusActiveTab(windowId)
+    else void actions.run('sidebar.focus', { windowId })
+  })
+}
diff --git a/src/main/menu.ts b/src/main/menu.ts
index f76b9b9d..35450819 100644
--- a/src/main/menu.ts
+++ b/src/main/menu.ts
@@ -1,5 +1,6 @@
 import { app, Menu, type MenuItemConstructorOptions } from 'electron'
 import { ACTIONS_BY_ID, shortcutsFor, toElectronAccelerator } from '../shared/actions'
+import { editsText } from '../shared/keymap'
 import { keepForMenu } from './archive/menus'
 import { recentlyClosedItems } from './archive/recently-closed'
 import type { MainContext } from './context'
@@ -22,10 +23,13 @@ export function installMenu(ctx: MainContext): void {
     return {
       label: label ?? action?.title ?? id,
       accelerator: accel ? toElectronAccelerator(accel) : undefined,
+      // A binding that types or edits text (KS-16) is only shown: the router runs it outside text
+      // fields, and the menu must not take it from one.
+      ...(accel && editsText(accel, 'darwin') ? { registerAccelerator: false } : {}),
       click: () => {
         const windowId = ctx.windows.focusedWindowId()
         // With a page's popup or detached DevTools focused, Close Tab closes that window instead.
-        if (!windowId && id === 'tab.close' && ctx.windows.closeFocusedForeign()) return
+        if (!windowId && (id === 'tab.close' || id === 'window.close') && ctx.windows.closeFocusedForeign()) return
         void ctx.actions.run(id, { windowId })
       },
     }
@@ -59,7 +63,7 @@ export function installMenu(ctx: MainContext): void {
         item('window.newPrivate'),
         { type: 'separator' },
         item('tab.close'),
-        { role: 'close', label: 'Close Window', accelerator: 'Command+Shift+W' },
+        item('window.close'),
         item('tab.reopenClosed'),
         // The last ~10 closed tabs (archive lane, AR-09); rebuilt as tabs close and come back.
         { label: 'Recently Closed', submenu: recentlyClosedItems(ctx) },
diff --git a/src/main/miniwindow/index.ts b/src/main/miniwindow/index.ts
index ad4f051d..4fcb7d92 100644
--- a/src/main/miniwindow/index.ts
+++ b/src/main/miniwindow/index.ts
@@ -696,6 +696,7 @@ export function registerMiniWindow(ctx: MainContext): void {
     if (!mini) return false
     switch (id) {
       case 'tab.close':
+      case 'window.close':
         closeWindow(mini)
         return true
       case 'peek.expand':
diff --git a/src/shared/actions.ts b/src/shared/actions.ts
index 39a37132..40ed95ed 100644
--- a/src/shared/actions.ts
+++ b/src/shared/actions.ts
@@ -282,7 +282,7 @@ export const ACTIONS: ActionDef[] = [
     id: 'devtools.toggle',
     title: 'Developer Tools',
     category: 'Developer',
-    mac: ['Cmd+Alt+I'],
+    mac: ['Cmd+Alt+I', 'F12'],
     other: ['Ctrl+Shift+I', 'F12'],
     keywords: ['inspect', 'console'],
   },
@@ -298,6 +298,17 @@ export const ACTIONS: ActionDef[] = [
     preferWebsites: true,
   },
   { id: 'window.new', title: 'New Window', category: 'Window', mac: ['Cmd+N'], other: ['Ctrl+N'] },
+  // Alt+F4 closes the window too, as the system's key (KS-05).
+  { id: 'window.close', title: 'Close Window', category: 'Window', mac: ['Cmd+Shift+W'], other: ['Ctrl+Shift+W'] },
+  {
+    // Keyboard focus between the sidebar and the page (KS-05, SB-22).
+    id: 'focus.cycle',
+    title: 'Move Focus Between Sidebar and Page',
+    category: 'Sidebar',
+    mac: ['F6'],
+    other: ['F6'],
+    keywords: ['keyboard', 'accessibility', 'focus sidebar', 'focus page'],
+  },
   {
     id: 'window.newMini',
     title: 'New Mini Window',
diff --git a/src/shared/commands/settings.ts b/src/shared/commands/settings.ts
index 5fee0b59..277f4901 100644
--- a/src/shared/commands/settings.ts
+++ b/src/shared/commands/settings.ts
@@ -138,7 +138,14 @@ export const SETTINGS_LANE_ACTIONS: ActionDef[] = [
   // Runs the first-run flow again over the open windows, keeping all data (OB-14).
   { id: 'onboarding.reset', title: 'Reset Onboarding', category: 'App', keywords: ['welcome', 'first run', 'setup'] },
   // Help and feedback (OB-13): the project's public pages, in a tab. Orbit has no support server.
-  { id: 'help.open', title: 'Help', category: 'App', keywords: ['documentation', 'user guide', 'support', 'readme'] },
+  {
+    id: 'help.open',
+    title: 'Help',
+    category: 'App',
+    // Windows and Linux: F1 (KS-15); macOS has ⌘? for the Help menu.
+    other: ['F1'],
+    keywords: ['documentation', 'user guide', 'support', 'readme'],
+  },
   {
     id: 'help.reportBug',
     title: 'Report a Bug',
diff --git a/tests/e2e/keys.spec.ts b/tests/e2e/keys.spec.ts
index 9ef0b4e9..4c50ebce 100644
--- a/tests/e2e/keys.spec.ts
+++ b/tests/e2e/keys.spec.ts
@@ -201,3 +201,63 @@ test('[KS-01] an action keeps several bindings, or none and the command bar stil
   await overlay.keyboard.press('Enter')
   await expect.poll(sidebarVisible).toBe(false)
 })
+
+// ---------- Platform mapping and the window keys (KS-03, KS-05) ----------
+
+/** Presses a key wherever the keyboard is (the focused web contents), as a person would. */
+function pressAnywhere(keyCode: string, modifiers: ('shift' | 'control' | 'alt' | 'meta')[] = []): Promise<string> {
+  return orbit.app.evaluate(
+    ({ webContents }, [code, mods]) => {
+      const contents = webContents.getFocusedWebContents()
+      if (!contents) return '(nothing)'
+      contents.sendInputEvent({ type: 'keyDown', keyCode: code, modifiers: mods })
+      contents.sendInputEvent({ type: 'keyUp', keyCode: code, modifiers: mods })
+      return contents.getURL()
+    },
+    [keyCode, modifiers] as const,
+  )
+}
+
+/** The URL of the web contents that has the keyboard. */
+function focusedUrl(): Promise<string | undefined> {
+  return orbit.app.evaluate(({ webContents }) => webContents.getFocusedWebContents()?.getURL())
+}
+
+test('[KS-03][KS-06][KS-07] Linux and Windows: Alt+2 switches to Space 2 and Ctrl+2 selects the second sidebar item (macOS: ⌃2 and ⌘2)', async () => {
+  const { app, shell } = orbit
+  const space = await activeSpace(app)
+  const second = (await run(app, 'tabs.create', { url: fx.url('/page/Second'), activate: false })) as string
+  const first = (await run(app, 'tabs.create', { url: fx.url('/page/First'), activate: false })) as string
+  expect((await state(app)).spaces[space]?.today.slice(0, 2)).toEqual([first, second])
+  const other = await createSpace(app, { name: 'Other', activate: false })
+  await shell.keyboard.press(`${MOD}+2`)
+  await expect
+    .poll(async () => {
+      const win = Object.values((await state(app)).windows)[0]
+      return win?.activeTab[space]
+    })
+    .toBe(second)
+  await shell.keyboard.press(isMac ? 'Control+2' : 'Alt+2')
+  await expect.poll(() => activeSpace(app)).toBe(other)
+})
+
+test('[KS-05] ⌘⇧W / Ctrl+Shift+W closes the window, and F6 moves the keyboard between the page and the sidebar', async () => {
+  const { app } = orbit
+  const id = await openTab(app, fx.url('/page/Focus'))
+  await expect.poll(async () => (await state(app)).tabs[id]?.loading).toBe(false)
+  await cmd(app, 'tabs.focusPage', {})
+  await expect.poll(focusedUrl).toBe(fx.url('/page/Focus'))
+  expect(await pressAnywhere('F6')).toBe(fx.url('/page/Focus'))
+  await expect.poll(focusedUrl).toContain('view=shell')
+  await pressAnywhere('F6')
+  await expect.poll(focusedUrl).toBe(fx.url('/page/Focus'))
+
+  const firstWindow = Object.keys((await state(app)).windows)[0]
+  await action(app, 'window.new')
+  await expect.poll(async () => Object.keys((await state(app)).windows).length).toBe(2)
+  // The window closes on the key going down: the page is gone before the key comes up.
+  await orbit.shell.keyboard.press(`${MOD}+Shift+W`).catch(() => {})
+  await expect
+    .poll(async () => Object.keys((await state(app)).windows))
+    .toEqual([expect.not.stringMatching(`^${firstWindow}$`)])
+})
diff --git a/tests/unit/keymap-defaults.test.ts b/tests/unit/keymap-defaults.test.ts
new file mode 100644
index 00000000..ec018ce4
--- /dev/null
+++ b/tests/unit/keymap-defaults.test.ts
@@ -0,0 +1,161 @@
+import { describe, expect, it } from 'vitest'
+import { ACTIONS, ACTIONS_BY_ID, actionForInput, defaultShortcutsFor } from '../../src/shared/actions'
+import { bindingProblem, canonicalAccelerator, type KeyInput } from '../../src/shared/keymap'
+
+/**
+ * The default keymap against the shortcut tables of the spec (KS-03 audit): every row Orbit binds,
+ * on macOS and on Windows/Linux. Rows for features no lane has built yet (blank window, top
+ * toolbar, save page, full screen keys, reader mode, developer mode, notes, canvases, extensions)
+ * are left out; so are keys that belong to an open overlay (KS-04's Esc, Tab, arrows).
+ */
+const TABLE: [id: string, mac: string[], other: string[]][] = [
+  // KS-04
+  ['tab.new', ['Cmd+T'], ['Ctrl+T']],
+  ['url.edit', ['Cmd+L'], ['Ctrl+L', 'Alt+D']],
+  ['tab.pasteAsNewTab', ['Cmd+Alt+V'], ['Ctrl+Alt+V']],
+  // KS-05
+  ['window.new', ['Cmd+N'], ['Ctrl+N']],
+  ['window.newPrivate', ['Cmd+Shift+N'], ['Ctrl+Shift+N']],
+  ['window.newMini', ['Cmd+Alt+N'], ['Ctrl+Alt+N']],
+  ['tab.close', ['Cmd+W'], ['Ctrl+W', 'Ctrl+F4']],
+  ['window.close', ['Cmd+Shift+W'], ['Ctrl+Shift+W']],
+  ['tab.reopenClosed', ['Cmd+Shift+T'], ['Ctrl+Shift+T']],
+  ['tab.togglePin', ['Cmd+D'], ['Ctrl+D']],
+  ['tab.copyUrl', ['Cmd+Shift+C'], ['Ctrl+Shift+C']],
+  ['tab.copyUrlMarkdown', ['Cmd+Alt+Shift+C'], ['Ctrl+Alt+Shift+C']],
+  ['sidebar.toggle', ['Cmd+S'], ['Ctrl+S']],
+  ['tabs.clearToday', ['Cmd+Shift+K'], ['Ctrl+Shift+K']],
+  ['sidebar.focus', ['Cmd+Shift+E'], ['Ctrl+Shift+E']],
+  ['focus.cycle', ['F6'], ['F6']],
+  ['tab.duplicate', [], []],
+  ['tab.resetToPinned', [], []],
+  // KS-06
+  ...[1, 2, 3, 4, 5, 6, 7, 8, 9].map((n): [string, string[], string[]] => [
+    `tab.goto.${n}`,
+    [`Cmd+${n}`],
+    [`Ctrl+${n}`],
+  ]),
+  ['tab.next', ['Cmd+Alt+Down', 'Cmd+Shift+]'], ['Ctrl+Alt+Down', 'Ctrl+PageDown']],
+  ['tab.previous', ['Cmd+Alt+Up', 'Cmd+Shift+['], ['Ctrl+Alt+Up', 'Ctrl+PageUp']],
+  ['tab.recent', ['Ctrl+Tab'], ['Ctrl+Tab']],
+  ['tab.recentBack', ['Ctrl+Shift+Tab', 'Ctrl+`'], ['Ctrl+Shift+Tab']],
+  // KS-07: ⌃1–9 on macOS, Alt+1–9 elsewhere (Ctrl+1–9 is tabs).
+  ...[1, 2, 3, 4, 5, 6, 7, 8, 9].map((n): [string, string[], string[]] => [
+    `space.goto.${n}`,
+    [`Ctrl+${n}`],
+    [`Alt+${n}`],
+  ]),
+  ['space.next', ['Cmd+Alt+Right'], ['Ctrl+Alt+Right']],
+  ['space.previous', ['Cmd+Alt+Left'], ['Ctrl+Alt+Left']],
+  ['space.new', [], []],
+  // KS-08 (⌘← and ⌘→ act outside text fields only, KS-16)
+  ['nav.back', ['Cmd+[', 'Cmd+Left'], ['Alt+Left']],
+  ['nav.forward', ['Cmd+]', 'Cmd+Right'], ['Alt+Right']],
+  ['nav.reload', ['Cmd+R'], ['Ctrl+R', 'F5']],
+  ['nav.hardReload', ['Cmd+Shift+R'], ['Ctrl+Shift+R', 'Shift+F5', 'Ctrl+F5']],
+  ['nav.stop', ['Cmd+.'], []],
+  ['page.find', ['Cmd+F'], ['Ctrl+F']],
+  ['page.findNext', ['Cmd+G'], ['F3', 'Ctrl+G']],
+  ['page.findPrevious', ['Cmd+Shift+G'], ['Shift+F3', 'Ctrl+Shift+G']],
+  ['page.jumpToSelection', ['Cmd+J'], []],
+  // Ctrl+Shift+= adds a split pane on Windows/Linux (KS-09), so Ctrl++ is not zoom there.
+  ['page.zoomIn', ['Cmd+=', 'Cmd+Shift+='], ['Ctrl+=']],
+  ['page.zoomOut', ['Cmd+-'], ['Ctrl+-']],
+  ['page.zoomReset', ['Cmd+0'], ['Ctrl+0']],
+  ['page.print', ['Cmd+P'], ['Ctrl+P']],
+  ['page.viewSource', ['Cmd+Alt+U'], ['Ctrl+U']],
+  ['site.controls', [], []],
+  // KS-09
+  ['split.add', ['Ctrl+Shift+='], ['Ctrl+Shift+=']],
+  ['split.close', ['Ctrl+Shift+-'], ['Ctrl+Shift+-']],
+  ...[1, 2, 3, 4].map((n): [string, string[], string[]] => [
+    `split.focus.${n}`,
+    [`Ctrl+Shift+${n}`],
+    [`Ctrl+Shift+${n}`],
+  ]),
+  ['split.focusNext', ['Ctrl+Shift+]'], ['Ctrl+Shift+]']],
+  ['split.focusPrevious', ['Ctrl+Shift+['], ['Ctrl+Shift+[']],
+  ['split.addRight', [], []],
+  // KS-10
+  ['peek.expand', ['Cmd+O'], ['Ctrl+O']],
+  ['mini.chooseSpace', ['Cmd+Alt+O', 'Cmd+Shift+O'], ['Ctrl+Alt+O']],
+  // KS-11
+  ['tab.toggleMute', [], []],
+  // KS-12
+  ['app.history', ['Cmd+Y'], ['Ctrl+H']],
+  ['app.library', ['Cmd+Shift+L'], []],
+  ['app.archive', [], []],
+  ['app.settings', ['Cmd+,'], ['Ctrl+,']],
+  ['settings.clearBrowsingData', ['Cmd+Shift+Backspace'], ['Ctrl+Shift+Delete']],
+  // KS-13
+  ['devtools.toggle', ['Cmd+Alt+I', 'F12'], ['Ctrl+Shift+I', 'F12']],
+  // KS-15: F1 opens help on Windows and Linux; macOS's ⌘? is the system's Help menu search.
+  ['help.open', [], ['F1']],
+]
+
+const canonical = (list: readonly string[]) => list.map((a) => canonicalAccelerator(a) ?? `(invalid ${a})`)
+
+describe('[KS-03] the default keymap follows the spec tables on each platform', () => {
+  it.each(TABLE)('%s', (id, mac, other) => {
+    const action = ACTIONS_BY_ID[id]
+    expect(action, id).toBeDefined()
+    if (!action) return
+    expect(canonical(defaultShortcutsFor(action, 'darwin'))).toEqual(canonical(mac))
+    expect(canonical(defaultShortcutsFor(action, 'linux'))).toEqual(canonical(other))
+    expect(canonical(defaultShortcutsFor(action, 'win32'))).toEqual(canonical(other))
+  })
+
+  it('binds each key once per platform, each a binding Orbit accepts', () => {
+    for (const platform of ['darwin', 'linux', 'win32']) {
+      const seen = new Map<string, string>()
+      for (const action of ACTIONS) {
+        for (const accel of defaultShortcutsFor(action, platform)) {
+          const key = canonicalAccelerator(accel)
+          expect(key, `${action.id}: ${accel}`).toBeDefined()
+          expect(bindingProblem(accel, platform), `${action.id}: ${accel} on ${platform}`).toBeUndefined()
+          expect(
+            seen.get(key as string),
+            `${accel}: ${seen.get(key as string)} and ${action.id} on ${platform}`,
+          ).toBeUndefined()
+          seen.set(key as string, action.id)
+        }
+      }
+    }
+  })
+
+  const press = (key: string, code: string, mods: Partial<KeyInput>): KeyInput => ({
+    key,
+    code,
+    meta: false,
+    control: false,
+    alt: false,
+    shift: false,
+    ...mods,
+  })
+
+  it('Linux: Alt+2 is Space 2 and Ctrl+2 the second sidebar item; macOS: ⌃2 and ⌘2', () => {
+    expect(actionForInput(press('2', 'Digit2', { alt: true }), 'linux')?.id).toBe('space.goto.2')
+    expect(actionForInput(press('2', 'Digit2', { control: true }), 'linux')?.id).toBe('tab.goto.2')
+    expect(actionForInput(press('2', 'Digit2', { control: true }), 'darwin')?.id).toBe('space.goto.2')
+    expect(actionForInput(press('2', 'Digit2', { meta: true }), 'darwin')?.id).toBe('tab.goto.2')
+  })
+
+  it('Windows/Linux exceptions: Ctrl+H history, Alt+←/→, Alt+D, F5, F3, Ctrl+F4', () => {
+    const linux = (input: KeyInput) => actionForInput(input, 'win32')?.id
+    expect(linux(press('h', 'KeyH', { control: true }))).toBe('app.history')
+    expect(linux(press('ArrowLeft', 'ArrowLeft', { alt: true }))).toBe('nav.back')
+    expect(linux(press('ArrowRight', 'ArrowRight', { alt: true }))).toBe('nav.forward')
+    expect(linux(press('d', 'KeyD', { alt: true }))).toBe('url.edit')
+    expect(linux(press('F5', 'F5', {}))).toBe('nav.reload')
+    expect(linux(press('F3', 'F3', {}))).toBe('page.findNext')
+    expect(linux(press('F4', 'F4', { control: true }))).toBe('tab.close')
+  })
+
+  it('shortcuts that use ⌃ on macOS use Ctrl elsewhere too (⌃Tab, the split keys)', () => {
+    for (const id of ['tab.recent', 'split.add', 'split.close', 'split.focus.1', 'split.focusNext']) {
+      const action = ACTIONS_BY_ID[id]
+      if (!action) throw new Error(id)
+      expect(defaultShortcutsFor(action, 'darwin')[0], id).toBe(defaultShortcutsFor(action, 'linux')[0])
+    }
+  })
+})
diff --git a/tests/unit/keymap-remap.test.ts b/tests/unit/keymap-remap.test.ts
index aaf26180..dffa07a2 100644
--- a/tests/unit/keymap-remap.test.ts
+++ b/tests/unit/keymap-remap.test.ts
@@ -158,7 +158,7 @@ describe('[KS-01][ST-08] changing bindings', () => {
     let custom = {}
     for (const n of [1, 2, 3, 4]) custom = bind(custom, { actionId: 'tab.new', accel: `F${n}` }, 'darwin').custom
     expect(custom).toEqual({ 'tab.new': ['Cmd+T', 'F1', 'F2', 'F3', 'F4'] })
-    const more = bind(custom, { actionId: 'tab.new', accel: 'F6' }, 'darwin')
+    const more = bind(custom, { actionId: 'tab.new', accel: 'F9' }, 'darwin')
     expect(more.result).toEqual({ ok: false, problem: `An action can have up to ${MAX_BINDINGS} shortcuts.` })
     expect(more.custom).toEqual(custom)
   })

From 7174f11a2cd2a3c2428c3950a046de0b30f0f5d0 Mon Sep 17 00:00:00 2001
From: Siya <57148521+siyabendoezdemir@users.noreply.github.com>
Date: Sat, 10 Oct 2026 15:36:58 +0000
Subject: [PATCH 04/11] feat(keys): pages that use Orbit's keys get them first
 where the action prefers websites (KS-02, KS-16)

- before-input-event leaves the press of an action that prefers websites to a
  tab's page; an isolated-world watcher reports whether the page called
  preventDefault. Left alone, the action runs; used, a toast offers the action
  and a second press within a second runs it. Held-key repeats stay the page's.
- Cmd+S / Ctrl+S (Toggle Sidebar) prefers websites everywhere; Ctrl+Shift+C
  (Copy URL) on Windows and Linux (NV-17). Settings' per-action priority wins.
- In a page text field, Cmd+[ / Cmd+] (Alt+Left / Alt+Right) go to the page
  first and go back or forward only when the page leaves them alone (KS-16).
- The macOS menu runs a let-through key's action once.
- e2e: fixture pages that use and ignore the keys, priority set to Orbit,
  Copy URL, the text-field rule, and Cmd+Z undoing typing in a field.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 FEATURES.md                     |  14 +--
 docs/feature-status.json        |   7 +-
 src/main/keys/page-keys.ts      | 105 ++++++++++++++++++
 src/main/keys/router.ts         | 138 ++++++++++++++++++++++-
 src/main/menu.ts                |   3 +
 src/main/windows.ts             |   4 +
 src/shared/actions.ts           |   9 ++
 tests/e2e/keys.spec.ts          | 187 +++++++++++++++++++++++++++++++-
 tests/unit/keymap-remap.test.ts |  10 ++
 9 files changed, 461 insertions(+), 16 deletions(-)
 create mode 100644 src/main/keys/page-keys.ts

diff --git a/FEATURES.md b/FEATURES.md
index 2360889c..484ee8a8 100644
--- a/FEATURES.md
+++ b/FEATURES.md
@@ -4,11 +4,11 @@
 
 Every row is one behaviour from the clean-room spec. Status per ID: **spec’d** (every row) → **built** → **tested** (a unit or e2e test names the ID) → **feels right** (lead sign-off after a hands-on review against `feel.md`).
 
-**Totals:** 475 spec’d · 201 built (76 partial) · 291 tested · 0 feel right. 10 more are out of scope and not counted.
+**Totals:** 475 spec’d · 203 built (75 partial) · 291 tested · 0 feel right. 10 more are out of scope and not counted.
 
 | Priority | Spec’d | Built | Tested |
 |---|---|---|---|
-| P0 | 174 | 131 | 164 |
+| P0 | 174 | 133 | 164 |
 | P1 | 221 | 61 | 116 |
 | P2 | 80 | 9 | 11 |
 
@@ -30,7 +30,7 @@ Spec: `spec/sidebar.md`
 | SB-08 | Empty sidebar area: double-click, drag, right-click | P1 | – | – | – |  |
 | SB-09 | Bottom bar: Library, Space switcher, "+" menu | P0 | 🟡 partial | ✅ e2e | – | switcher, + menu and the Library button (opens the Library); the recent-files hover popover belongs to the downloads lane |
 | SB-10 | Transient trays above the bottom bar | P1 | 🟡 partial | ✅ e2e | – | media tray and call controls (media lane), above the bottom bar, pushing the list up; download progress and the update banner belong to other lanes |
-| SB-11 | Show / hide the sidebar | P0 | ✅ | ✅ e2e | – | Cmd+S / Ctrl+S, toggle button, View menu and command bar; the sidebar slides out as the card widens (one curve, reversible mid-way); the page views, which can't move in step, keep out of its way while it slides (where they end as it shows, where they were as it hides; the page colour fills the rest); back at the same width, scroll and selected tab; per window, persisted; new windows show it |
+| SB-11 | Show / hide the sidebar | P0 | ✅ | ✅ e2e | – | Cmd+S / Ctrl+S, toggle button, View menu and command bar; the sidebar slides out as the card widens (one curve, reversible mid-way); the page views, which can't move in step, keep out of its way while it slides (where they end as it shows, where they were as it hides; the page colour fills the rest); back at the same width, scroll and selected tab; per window, persisted; new windows show it; a page that uses Cmd+S / Ctrl+S itself gets the first press, and a second press within a second or the toast's button toggles the sidebar (KS-02) |
 | SB-12 | Hover to reveal the hidden sidebar | P0 | ✅ | ✅ e2e | – | left 6 px edge brings a floating card in its own view over the page, which never moves; main decides whether the pointer moved (not from where it was when the sidebar hid, so Cmd+S at the edge doesn't) and reads it for 300 ms after it leaves a page or the shell, so a flick to the edge (or onto the Linux resize border) brings the card; 0 ms dwell; stays while hovered (16 px band), while a field in it is edited or the command bar is open; goes 400 ms after the pointer moves on, at once on a click into the page (the click reaches the page); not over full-screen video; stays out while the pointer is on another window over it, until it comes back (review A-F1) |
 | SB-13 | Feedback when things happen while the sidebar is hidden | P1 | – | – | – |  |
 | SB-14 | Resize the sidebar width | P0 | ✅ | ✅ e2e | – | drag the edge 1:1 with a live width, clamped 180-420 with no drift; double-click resets to 248; 40 px past the minimum hides (width kept); saved per window |
@@ -244,7 +244,7 @@ Spec: `spec/navigation.md`
 | NV-14 | Crashed or unresponsive tab | P1 | – | ✅ e2e | – |  |
 | NV-15 | Permission prompts | P0 | ✅ | ✅ e2e+unit | – | prompt under the address display, as wide as it (over the page's top-left while the sidebar is hidden), for the shown tab or else a split view pane that waits: camera, mic, location, notifications, clipboard, MIDI, idle, windows, fonts, local network, serial/USB/HID choosers, screen share, file access; Allow while visiting / Allow this time / Never allow, or Block / Allow; a press answers only once the prompt has shown for 500 ms and 500 ms after the press before; Esc dismisses; kept per profile and site (private in memory); a frame from another site can't ask for notifications or use the page's; pages read undecided as default/prompt (a PermissionStatus change event doesn't fire for a decision made in Orbit, and the patched getters and requestPermission show their source to toString); a notification click brings its tab forward (page notifications, not service-worker ones; only from a frame allowed notifications, once per 500 ms); Peek, Mini Window and pop-ups ask in a dialog over their own window (Allow, Block, Not Now; Esc keeps nothing; the same request asks once); the recording indicators wait on TB-15; toolbar anchor waits on SB-17, Site settings is ST-13 |
 | NV-16 | Site controls panel | P0 | 🟡 partial | ✅ e2e+unit | – | button at the address's right end and the Site Controls action (never shows the hidden sidebar): host and connection, switches for permissions the site used or asked for (pop-ups too), devices, zoom with reset, Reset permissions, Clear cookies and site data, Reload hint; Esc or a click outside closes; auto PiP, Peek, Developer mode, Tweaks, extensions, capture and the all-sites link wait on their features |
-| NV-17 | Copy the current URL | P0 | 🟡 partial | ✅ e2e | – | copy button = Cmd+Shift+C (clean URL, Copied toast); one-time shortcut tip when the URL is copied from the command bar; the Win/Linux page-first offer waits on KS-02 |
+| NV-17 | Copy the current URL | P0 | ✅ | ✅ e2e | – | copy button = Cmd+Shift+C (clean URL, Copied toast); one-time shortcut tip when the URL is copied from the command bar; on Windows/Linux a page that uses Ctrl+Shift+C gets it first and a toast offers Copy URL, a second press within a second copies (KS-02) |
 | NV-18 | Links from other apps (Orbit as the default browser) | P0 | ✅ | ✅ e2e | – | summary of MW-02/05/09/10/11: links from other apps open a Mini Window or follow routing rules, else a Today tab in the most recent Space; never in a private window (e2e); a launch with --private-window takes its links to a private window (NV-11); rules UI is ST-09, Archive restores AR-05 |
 | NV-19 | Links that open other apps (external protocols) | P1 | – | – | – |  |
 | NV-20 | Full screen | P1 | – | ✅ e2e | – |  |
@@ -347,7 +347,7 @@ Spec: `spec/shortcuts.md`
 | ID | Feature | P | Built | Tested | Feels right | Notes |
 |---|---|---|---|---|---|---|
 | KS-01 | One keymap, remapping and persistence | P0 | 🟡 partial | ✅ e2e+unit | – | one keymap keyed by action id (src/shared/actions.ts + src/shared/keymap.ts): the key router, macOS menu bar (rebuilt on a remap), tooltips and command-bar rows read the live bindings; remap, several bindings per action (up to 5), none (command bar and menus still run it), a modifier required except F1-F12, system keys refused, conflicts reported (clear or swap), reset; stored per device in settings.shortcuts, cleaned on load, kept across a restart (Space keys too); the Settings → Shortcuts page comes with ST-08 |
-| KS-02 | Conflicts with web pages ("prefer websites" vs "prefer Orbit") | P0 | – | ✅ unit | – |  |
+| KS-02 | Conflicts with web pages ("prefer websites" vs "prefer Orbit") | P0 | 🟡 partial | ✅ e2e+unit | – | who gets a key first, per action: Toggle Sidebar (Cmd+S / Ctrl+S, SB-11) prefers websites on every platform, Copy URL (Ctrl+Shift+C, NV-17) on Windows/Linux, every other action prefers Orbit (the page never sees the key); with prefer websites the page's main frame gets the first press: left alone, the action runs; used (preventDefault), a toast offers the action and a second press within a second runs it; a held key's repeats stay the page's; a press into a frame Orbit can't see into counts as used; keys.setPriority changes it (the Settings → Shortcuts option comes with ST-08); Esc leaving page full screen keeps Chromium's rule and nothing holds Cmd+E yet |
 | KS-03 | Platform mapping rules | P0 | 🟡 partial | ✅ e2e+unit | – | every default checked against the spec tables on macOS, Windows and Linux (unit test): ⌘ → Ctrl, ⌥ → Alt, ⌃ keys (⌃Tab, the split keys) stay Ctrl; the Windows/Linux exceptions Alt+1–9 for Spaces, Ctrl+H, Alt+←/→, Alt+D, F5, F3, Ctrl+F4 and F1; Alt+F4 and Alt+F are kept for the system; a Ctrl+Alt key that typed an AltGr character acts only outside text fields; letters and symbols follow the layout; F11 / Alt+Shift+F come with full screen (KS-08); the Linux desktop-clash hint and the macOS Mission Control hint come with ST-08 |
 | KS-04 | Command bar and address | P0 | ✅ | ✅ e2e+unit | – | ⌘T/⌘L/Alt+D, Esc, ⌘T/⌘L again, ↑/↓ (⌃N/⌃P), Enter, Tab, ⌫, ⇧Enter (option), ⌘⌥⌫ / Shift+Delete, ⌘⌥V |
 | KS-05 | Tabs and windows | P0 | 🟡 partial | ✅ e2e+unit | – | ⌘N, ⌘⇧N, ⌘⌥N, ⌘W / Ctrl+W / Ctrl+F4, ⌘⇧W / Ctrl+Shift+W (closes the window, or the Mini Window, Settings or onboarding window that has focus; Alt+F4 is the system's), ⌘⇧T, ⌘D, ⌘⇧C, ⌘⇧⌥C, ⌘S, ⌘⇧K, ⌘⇧E, F6 (keyboard between the sidebar and the page), Duplicate and Reset to Pinned assignable; ⌘Z (sidebar undo) is not remappable yet; the blank window (⌃⌘N, TB-17) and the top toolbar (⌘⇧D, SB-17) are not built |
@@ -361,7 +361,7 @@ Spec: `spec/shortcuts.md`
 | KS-13 | Developer tools | P1 | – | ✅ unit | – |  |
 | KS-14 | Canvases, notes, capture and Tweaks | P2 | – | – | – |  |
 | KS-15 | Standard app and window keys | P1 | – | ✅ unit | – |  |
-| KS-16 | Text-editing keys keep their meaning | P0 | 🟡 partial | ✅ e2e+unit | – | typed keys never go astray: a page or Orbit view that loads (a slow page, a background tab, a reload) no longer takes the keyboard from the command bar, a sidebar field or the page in front (focus-on-navigation off for every web contents Orbit makes); ⌘←/⌘→ act outside text fields only; the full text-editing and IME audit is still to do |
+| KS-16 | Text-editing keys keep their meaning | P0 | ✅ | ✅ e2e+unit | – | typed keys never go astray: a page or Orbit view that loads (a slow page, a background tab, a reload) no longer takes the keyboard from the command bar, a sidebar field or the page in front (focus-on-navigation off for every web contents Orbit makes); ⌘←/⌘→ act outside text fields only; ⌘[ / ⌘] (Alt+←/→) from a page's text field go back or forward only when the page leaves them alone (a press into a frame Orbit can't see into stays the page's); ⌘Z in a page field is the page's undo (tabs lane, tested here); no shortcut on a plain key runs while an input method composes (unit test: e2e can't drive a composition through the key router) |
 | KS-17 | Mouse, trackpad and modifier-click bindings | P0 | – | – | – |  |
 | KS-18 | Shortcut hints everywhere | P1 | 🟡 partial | ✅ e2e | – | button tooltips (address, copy link, site controls, sidebar toggle, back/forward/reload, find, zoom, Library, Clear, Space dots, Peek, Mini Window Open in…), the empty-window hint, command-bar rows and macOS menu items follow a remap without a restart; context menus and the shortcut sheet (OB-12) to come |
 | KS-19 | Keys inside overlays | P0 | 🟡 partial | ✅ e2e | – | command bar: ⌘T/⌘L/⌘W/Esc handled by the bar first (ActionRegistry.intercept); other overlays belong to their lanes |
@@ -542,7 +542,7 @@ Spec: `spec/settings.md`
 | ST-05 | Per-profile: auto-archive timing | P1 | ✅ | ✅ e2e+unit | – | 12 hours (default), 24 hours, 7 days, 30 days per profile; no Never; other profiles follow Default until set |
 | ST-06 | Per-profile: default search engine and custom engines | P0 | ✅ | ✅ e2e+unit | – | per-profile default engine (8 built-ins), custom engines with keyword and %s URL, Make default from the row menu; no extension override in Electron, so that row does not exist |
 | ST-07 | Per-profile: download location, new-document app, data shortcuts | P1 | – | – | – |  |
-| ST-08 | Shortcuts section (remapping) | P1 | – | ✅ unit | – |  |
+| ST-08 | Shortcuts section (remapping) | P1 | – | ✅ e2e+unit | – |  |
 | ST-09 | Links section | P1 | ✅ | ✅ e2e+unit | – | links from other apps open in a Mini Window (default), the most recent Space or one Space; routing rules (address contains / is exactly → a Space; first match wins; add, edit, reorder, remove); Peek options |
 | ST-10 | Advanced section | P1 | 🟡 partial | ✅ e2e+unit | – | tab sleep timer (TB-16), picture in picture, graphics acceleration; no site customizations, full-URL toggle, sounds or haptics, or edge-drag settings because those features don't exist yet |
 | ST-11 | Appearance section | P1 | 🟡 partial | ✅ e2e | – | Theme mode: Light / Dark / Match system (AP-01). Not built: window material (AP-10, Windows), app icon (AP-09), page defaults (P2) |
diff --git a/docs/feature-status.json b/docs/feature-status.json
index 1929ee39..2e05ab6a 100644
--- a/docs/feature-status.json
+++ b/docs/feature-status.json
@@ -7,7 +7,7 @@
   "SB-06": {"built": "yes", "note": "title row: inline rename, hover profile badge and … menu (pinned caret is PN-09)"},
   "SB-07": {"built": "yes", "note": "+ New Tab row with press animation opens the command bar"},
   "SB-09": {"built": "partial", "note": "switcher, + menu and the Library button (opens the Library); the recent-files hover popover belongs to the downloads lane"},
-  "SB-11": {"built": "yes", "note": "Cmd+S / Ctrl+S, toggle button, View menu and command bar; the sidebar slides out as the card widens (one curve, reversible mid-way); the page views, which can't move in step, keep out of its way while it slides (where they end as it shows, where they were as it hides; the page colour fills the rest); back at the same width, scroll and selected tab; per window, persisted; new windows show it"},
+  "SB-11": {"built": "yes", "note": "Cmd+S / Ctrl+S, toggle button, View menu and command bar; the sidebar slides out as the card widens (one curve, reversible mid-way); the page views, which can't move in step, keep out of its way while it slides (where they end as it shows, where they were as it hides; the page colour fills the rest); back at the same width, scroll and selected tab; per window, persisted; new windows show it; a page that uses Cmd+S / Ctrl+S itself gets the first press, and a second press within a second or the toast's button toggles the sidebar (KS-02)"},
   "SB-12": {"built": "yes", "note": "left 6 px edge brings a floating card in its own view over the page, which never moves; main decides whether the pointer moved (not from where it was when the sidebar hid, so Cmd+S at the edge doesn't) and reads it for 300 ms after it leaves a page or the shell, so a flick to the edge (or onto the Linux resize border) brings the card; 0 ms dwell; stays while hovered (16 px band), while a field in it is edited or the command bar is open; goes 400 ms after the pointer moves on, at once on a click into the page (the click reaches the page); not over full-screen video; stays out while the pointer is on another window over it, until it comes back (review A-F1)"},
   "SB-14": {"built": "yes", "note": "drag the edge 1:1 with a live width, clamped 180-420 with no drift; double-click resets to 248; 40 px past the minimum hides (width kept); saved per window"},
   "SB-19": {"built": "yes", "note": "8 px margins (6 px with the sidebar hidden), 10 px corners on every page and pane while loading, hidden or floating; fine edge and shadow; native and video full screen drop the frame; the card and the page view take the page background colour so resizes show no white"},
@@ -136,8 +136,9 @@
   "KS-04": {"built": "yes", "note": "⌘T/⌘L/Alt+D, Esc, ⌘T/⌘L again, ↑/↓ (⌃N/⌃P), Enter, Tab, ⌫, ⇧Enter (option), ⌘⌥⌫ / Shift+Delete, ⌘⌥V"},
   "KS-07": {"built": "yes", "note": "Space shortcuts wired through the action table"},
   "KS-19": {"built": "partial", "note": "command bar: ⌘T/⌘L/⌘W/Esc handled by the bar first (ActionRegistry.intercept); other overlays belong to their lanes"},
-  "KS-16": {"built": "partial", "note": "typed keys never go astray: a page or Orbit view that loads (a slow page, a background tab, a reload) no longer takes the keyboard from the command bar, a sidebar field or the page in front (focus-on-navigation off for every web contents Orbit makes); ⌘←/⌘→ act outside text fields only; the full text-editing and IME audit is still to do"},
+  "KS-16": {"built": "yes", "note": "typed keys never go astray: a page or Orbit view that loads (a slow page, a background tab, a reload) no longer takes the keyboard from the command bar, a sidebar field or the page in front (focus-on-navigation off for every web contents Orbit makes); ⌘←/⌘→ act outside text fields only; ⌘[ / ⌘] (Alt+←/→) from a page's text field go back or forward only when the page leaves them alone (a press into a frame Orbit can't see into stays the page's); ⌘Z in a page field is the page's undo (tabs lane, tested here); no shortcut on a plain key runs while an input method composes (unit test: e2e can't drive a composition through the key router)"},
   "KS-01": {"built": "partial", "note": "one keymap keyed by action id (src/shared/actions.ts + src/shared/keymap.ts): the key router, macOS menu bar (rebuilt on a remap), tooltips and command-bar rows read the live bindings; remap, several bindings per action (up to 5), none (command bar and menus still run it), a modifier required except F1-F12, system keys refused, conflicts reported (clear or swap), reset; stored per device in settings.shortcuts, cleaned on load, kept across a restart (Space keys too); the Settings → Shortcuts page comes with ST-08"},
+  "KS-02": {"built": "partial", "note": "who gets a key first, per action: Toggle Sidebar (Cmd+S / Ctrl+S, SB-11) prefers websites on every platform, Copy URL (Ctrl+Shift+C, NV-17) on Windows/Linux, every other action prefers Orbit (the page never sees the key); with prefer websites the page's main frame gets the first press: left alone, the action runs; used (preventDefault), a toast offers the action and a second press within a second runs it; a held key's repeats stay the page's; a press into a frame Orbit can't see into counts as used; keys.setPriority changes it (the Settings → Shortcuts option comes with ST-08); Esc leaving page full screen keeps Chromium's rule and nothing holds Cmd+E yet"},
   "KS-18": {"built": "partial", "note": "button tooltips (address, copy link, site controls, sidebar toggle, back/forward/reload, find, zoom, Library, Clear, Space dots, Peek, Mini Window Open in…), the empty-window hint, command-bar rows and macOS menu items follow a remap without a restart; context menus and the shortcut sheet (OB-12) to come"},
   "KS-03": {"built": "partial", "note": "every default checked against the spec tables on macOS, Windows and Linux (unit test): ⌘ → Ctrl, ⌥ → Alt, ⌃ keys (⌃Tab, the split keys) stay Ctrl; the Windows/Linux exceptions Alt+1–9 for Spaces, Ctrl+H, Alt+←/→, Alt+D, F5, F3, Ctrl+F4 and F1; Alt+F4 and Alt+F are kept for the system; a Ctrl+Alt key that typed an AltGr character acts only outside text fields; letters and symbols follow the layout; F11 / Alt+Shift+F come with full screen (KS-08); the Linux desktop-clash hint and the macOS Mission Control hint come with ST-08"},
   "KS-05": {"built": "partial", "note": "⌘N, ⌘⇧N, ⌘⌥N, ⌘W / Ctrl+W / Ctrl+F4, ⌘⇧W / Ctrl+Shift+W (closes the window, or the Mini Window, Settings or onboarding window that has focus; Alt+F4 is the system's), ⌘⇧T, ⌘D, ⌘⇧C, ⌘⇧⌥C, ⌘S, ⌘⇧K, ⌘⇧E, F6 (keyboard between the sidebar and the page), Duplicate and Reset to Pinned assignable; ⌘Z (sidebar undo) is not remappable yet; the blank window (⌃⌘N, TB-17) and the top toolbar (⌘⇧D, SB-17) are not built"},
@@ -194,7 +195,7 @@
   "NV-15": {"built": "yes", "note": "prompt under the address display, as wide as it (over the page's top-left while the sidebar is hidden), for the shown tab or else a split view pane that waits: camera, mic, location, notifications, clipboard, MIDI, idle, windows, fonts, local network, serial/USB/HID choosers, screen share, file access; Allow while visiting / Allow this time / Never allow, or Block / Allow; a press answers only once the prompt has shown for 500 ms and 500 ms after the press before; Esc dismisses; kept per profile and site (private in memory); a frame from another site can't ask for notifications or use the page's; pages read undecided as default/prompt (a PermissionStatus change event doesn't fire for a decision made in Orbit, and the patched getters and requestPermission show their source to toString); a notification click brings its tab forward (page notifications, not service-worker ones; only from a frame allowed notifications, once per 500 ms); Peek, Mini Window and pop-ups ask in a dialog over their own window (Allow, Block, Not Now; Esc keeps nothing; the same request asks once); the recording indicators wait on TB-15; toolbar anchor waits on SB-17, Site settings is ST-13"},
   "NV-16": {"built": "partial", "note": "button at the address's right end and the Site Controls action (never shows the hidden sidebar): host and connection, switches for permissions the site used or asked for (pop-ups too), devices, zoom with reset, Reset permissions, Clear cookies and site data, Reload hint; Esc or a click outside closes; auto PiP, Peek, Developer mode, Tweaks, extensions, capture and the all-sites link wait on their features"},
   "NV-18": {"built": "yes", "note": "summary of MW-02/05/09/10/11: links from other apps open a Mini Window or follow routing rules, else a Today tab in the most recent Space; never in a private window (e2e); a launch with --private-window takes its links to a private window (NV-11); rules UI is ST-09, Archive restores AR-05"},
-  "NV-17": {"built": "partial", "note": "copy button = Cmd+Shift+C (clean URL, Copied toast); one-time shortcut tip when the URL is copied from the command bar; the Win/Linux page-first offer waits on KS-02"},
+  "NV-17": {"built": "yes", "note": "copy button = Cmd+Shift+C (clean URL, Copied toast); one-time shortcut tip when the URL is copied from the command bar; on Windows/Linux a page that uses Ctrl+Shift+C gets it first and a toast offers Copy URL, a second press within a second copies (KS-02)"},
   "KS-08": {"built": "partial", "note": "Back, Forward, Reload, hard reload, Stop, find (Cmd+F, Cmd+G, Shift+Cmd+G, F3, Ctrl+G), Cmd+J and zoom keys done; print, save page, reader mode and the rest come with their NV items"},
   "FL-15": {"built": "partial", "note": "top row: Back/Forward nudge, Reload glyph turns once, press to 0.94 with pop release, restarts on repeat, none when disabled or reduced motion"},
   "FL-23": {"built": "yes", "note": "after 150 ms, a 48x4 theme-accent pill sweeping on a 1.2 s cycle (a pulse with reduced motion); on load end it fills (80 ms) and fades (150 ms), gone 180 ms after; never moves page content"},
diff --git a/src/main/keys/page-keys.ts b/src/main/keys/page-keys.ts
new file mode 100644
index 00000000..9c4334ab
--- /dev/null
+++ b/src/main/keys/page-keys.ts
@@ -0,0 +1,105 @@
+import type { WebContents } from 'electron'
+
+/** Isolated world for the keys lane's page script (KS-02, KS-16): the page can't see or change it. */
+export const KEYS_WORLD = 1020
+
+/**
+ * Notes, for each trusted key press in the page's main frame, whether the page called
+ * preventDefault on it once every one of its own handlers has run, and whether keyboard focus was
+ * in a text field. `__orbitKeys.verdict` answers for one press. Lives in the page's document, so
+ * it is installed again for each new document.
+ */
+const WATCH = `(() => {
+  if (window.__orbitKeys) return true
+  const seen = []
+  let waiters = []
+  const editable = () => {
+    const el = document.activeElement
+    if (!el || el === document.body || el === document.documentElement) return false
+    if (el.isContentEditable) return true
+    const tag = el.tagName
+    if (tag === 'TEXTAREA' || tag === 'SELECT') return true
+    if (tag !== 'INPUT') return false
+    const type = (el.getAttribute('type') || 'text').toLowerCase()
+    return !['button', 'checkbox', 'color', 'file', 'hidden', 'image', 'radio', 'range', 'reset', 'submit'].includes(type)
+  }
+  addEventListener('keydown', (e) => {
+    if (!e.isTrusted) return
+    const sig = [e.metaKey, e.ctrlKey, e.altKey, e.shiftKey, e.code].join(',')
+    const at = Date.now()
+    const inField = editable()
+    // After the whole dispatch: the page's handlers have all had the event.
+    setTimeout(() => {
+      seen.push({ sig, at, inField, prevented: e.defaultPrevented })
+      if (seen.length > 16) seen.shift()
+      const woken = waiters
+      waiters = []
+      for (const wake of woken) wake()
+    }, 0)
+  }, true)
+  window.__orbitKeys = {
+    verdict(sig, since, wait) {
+      return new Promise((resolve) => {
+        let done = false
+        const answer = () => {
+          const r = seen.find((x) => x.sig === sig && x.at >= since)
+          if (!r) return false
+          done = true
+          resolve({ seen: true, prevented: r.prevented, inField: r.inField })
+          return true
+        }
+        if (answer()) return
+        const wake = () => {
+          if (!done && !answer()) waiters.push(wake)
+        }
+        waiters.push(wake)
+        setTimeout(() => {
+          if (done) return
+          done = true
+          resolve({ seen: false })
+        }, wait)
+      })
+    },
+  }
+  return true
+})()`
+
+/** Puts the watcher in a tab's page, now and in each document it loads (KS-02). */
+export function watchPageKeys(contents: WebContents): void {
+  const install = () => {
+    if (contents.isDestroyed()) return
+    contents.executeJavaScriptInIsolatedWorld(KEYS_WORLD, [{ code: WATCH }]).catch(() => {})
+  }
+  contents.on('dom-ready', install)
+}
+
+/** What the page did with a key press. */
+export type PageVerdict =
+  /** The press reached the page's main frame: whether it called preventDefault, and whether focus was in a text field. */
+  | { seen: true; prevented: boolean; inField: boolean }
+  /** Not within the wait: the page stopped it before any handler, or focus is in a frame. */
+  | { seen: false }
+  /** The page has no watcher (still loading, or a page Orbit can't script). */
+  | undefined
+
+/** How long to wait for the page's answer before taking it that the page kept the key. */
+export const VERDICT_WAIT_MS = 250
+
+/**
+ * What the page did with the key press `input`, pressed at `pressedAt` (main's clock, which the
+ * page shares). Asked as the press is let through to the page.
+ */
+export async function pageVerdict(
+  contents: WebContents,
+  input: Electron.Input,
+  pressedAt: number,
+): Promise<PageVerdict> {
+  const sig = [input.meta, input.control, input.alt, input.shift, input.code].join(',')
+  const code = `window.__orbitKeys ? window.__orbitKeys.verdict(${JSON.stringify(sig)}, ${pressedAt - 10}, ${VERDICT_WAIT_MS}) : null`
+  try {
+    const verdict = (await contents.executeJavaScriptInIsolatedWorld(KEYS_WORLD, [{ code }])) as PageVerdict | null
+    return verdict ?? undefined
+  } catch {
+    return undefined
+  }
+}
diff --git a/src/main/keys/router.ts b/src/main/keys/router.ts
index 8d674f97..5642c729 100644
--- a/src/main/keys/router.ts
+++ b/src/main/keys/router.ts
@@ -1,21 +1,53 @@
 import { type WebContents, webContents } from 'electron'
+import { type ActionDef, formatAccelerator, priorityFor } from '../../shared/actions'
 import type { RecordedKey } from '../../shared/commands/keys'
 import { acceleratorFromInput, modifiersOf } from '../../shared/keymap'
 import type { WindowId } from '../../shared/state'
 import type { MainContext } from '../context'
+import { pageVerdict, watchPageKeys } from './page-keys'
+
+/** A second press of the same keys within this long after the page took the first runs the action (KS-02). */
+export const AGAIN_MS = 1000
+
+/** How long after the router ran an action the page left alone the macOS menu doesn't run it again. */
+const MENU_DOUBLE_MS = 500
+
+/** A key press left to a page first, waiting for what the page did with it. */
+interface FirstPress {
+  actionId: string
+  /** Until when another press of the same keys runs the action: set once the page's answer is in. */
+  until: number
+  /** The macOS menu ran the action: the page left the key alone. */
+  menuRan?: boolean
+}
 
 /**
- * The keys lane's part of the key router (src/main/windows.ts `attachShortcuts` calls it): a
- * window where Settings → Shortcuts is recording a new binding gets its key presses reported
- * instead of acted on (ST-08).
+ * The keys lane's part of the key router (src/main/windows.ts `attachShortcuts` calls it):
+ * - a window where Settings → Shortcuts records a new binding gets its key presses reported
+ *   instead of acted on (ST-08);
+ * - an action that prefers websites leaves the first press to a web page that handles the keys
+ *   itself (KS-02).
  */
 export class KeyRouter {
   private ctx: MainContext | undefined
   /** The window whose key presses are being recorded (the Settings window), if any. */
   private recordingIn: WindowId | undefined
+  /** First presses left to pages, by web contents and binding. */
+  private firstPresses = new Map<string, FirstPress>()
+  /** When the router last ran each action because a page left its keys alone. */
+  private ranAfterPage = new Map<string, number>()
 
   init(ctx: MainContext): void {
     this.ctx = ctx
+    ctx.hooks.tabCreated.push((_tabId, contents) => watchPageKeys(contents))
+    // An action run some other way after a page took its keys (the toast's button, the command
+    // bar): the next press of the keys is a first press again. Watches only; never handles.
+    ctx.actions.intercept((id) => {
+      for (const [key, first] of this.firstPresses) {
+        if (first.actionId === id && first.until !== Number.POSITIVE_INFINITY) this.firstPresses.delete(key)
+      }
+      return false
+    })
   }
 
   /** Starts (with the window) or stops recording. Closing the window stops it too. */
@@ -62,6 +94,106 @@ export class KeyRouter {
     if (!contents.isDestroyed()) contents.send('orbit:keys.recorded', recorded)
     return true
   }
+
+  /**
+   * Keys a web page may use (KS-02, KS-16). Returns true when the press goes to the page: the
+   * caller lets it through and runs nothing now. Applies to a tab's page and:
+   * - an action that prefers websites: if the page leaves the press alone, the action runs then.
+   *   If the page used it, a toast offers the action, and pressing the same keys again within
+   *   about a second runs it: for that press this returns false, and the caller runs the action
+   *   at once and keeps the key from the page. A held key's repeats stay the page's.
+   * - an action that prefers Orbit but leaves its keys to text fields (Back and Forward's ⌘[ ⌘]):
+   *   the action runs unless focus was in a text field and the page used the press, or the press
+   *   went into a frame Orbit can't see into.
+   */
+  leaveToPage(
+    contents: WebContents,
+    input: Electron.Input,
+    action: ActionDef,
+    windowOf: () => WindowId | undefined,
+  ): boolean {
+    const ctx = this.ctx
+    if (!ctx?.tabs.tabIdFor(contents)) return false
+    const priority = priorityFor(action, process.platform, ctx.store.state.settings.shortcutPriority)
+    if (priority === 'orbit' && !action.pageFirstInFields) return false
+    const key = `${contents.id} ${acceleratorFromInput(input) ?? ''}`
+    const windowId = windowOf()
+    // Until the page's answer is in, the macOS menu may run the action instead (`menuRuns`).
+    const first: FirstPress = { actionId: action.id, until: Number.POSITIVE_INFINITY }
+    if (priority === 'orbit') {
+      this.firstPresses.set(key, first)
+      void pageVerdict(contents, input, Date.now()).then((verdict) => {
+        if (this.firstPresses.get(key) === first) this.firstPresses.delete(key)
+        if (first.menuRan || contents.isDestroyed()) return
+        if (verdict && (!verdict.seen || (verdict.prevented && verdict.inField))) return
+        this.ran(action, windowId)
+      })
+      return true
+    }
+    const earlier = this.firstPresses.get(key)
+    if (earlier && Date.now() <= earlier.until) {
+      if (input.isAutoRepeat) return true
+      this.firstPresses.delete(key)
+      return false
+    }
+    if (input.isAutoRepeat) return true
+    // Until the page's answer is in, another press counts as the second one.
+    this.firstPresses.set(key, first)
+    void pageVerdict(contents, input, Date.now()).then((verdict) => {
+      // Whether a second press came (and ran the action) before the answer.
+      const waiting = this.firstPresses.get(key) === first
+      if (first.menuRan || contents.isDestroyed()) {
+        if (waiting) this.firstPresses.delete(key)
+        return
+      }
+      if (!verdict || (verdict.seen && !verdict.prevented)) {
+        // The page left the key alone: the press is the action's, besides any second press's.
+        if (waiting) this.firstPresses.delete(key)
+        this.ran(action, windowId)
+        return
+      }
+      if (!waiting) return
+      first.until = Date.now() + AGAIN_MS
+      setTimeout(() => {
+        if (this.firstPresses.get(key) === first) this.firstPresses.delete(key)
+      }, AGAIN_MS + 50)
+      if (windowId) this.offer(windowId, action, input)
+    })
+    return true
+  }
+
+  /** Runs an action whose keys the page left alone. */
+  private ran(action: ActionDef, windowId: WindowId | undefined): void {
+    this.ranAfterPage.set(action.id, Date.now())
+    void this.ctx?.actions.run(action.id, { windowId })
+  }
+
+  /**
+   * Whether the macOS menu bar should run an action it was asked to. A key the router let through
+   * to a page reaches the menu when the page leaves it alone: the menu runs the action then, and
+   * the router doesn't run it a second time when the page's answer comes.
+   */
+  menuRuns(actionId: string): boolean {
+    for (const [key, first] of this.firstPresses) {
+      if (first.actionId !== actionId || first.until !== Number.POSITIVE_INFINITY) continue
+      first.menuRan = true
+      this.firstPresses.delete(key)
+      return true
+    }
+    const ran = this.ranAfterPage.get(actionId)
+    this.ranAfterPage.delete(actionId)
+    return ran === undefined || Date.now() - ran > MENU_DOUBLE_MS
+  }
+
+  /** The toast after a page used an action's keys: the action, a click away (KS-02). */
+  private offer(windowId: WindowId, action: ActionDef, input: Electron.Input): void {
+    const accel = acceleratorFromInput(input)
+    const keys = accel ? formatAccelerator(accel, process.platform) : 'the shortcut'
+    this.ctx?.windows.sendToWindow(windowId, 'toast', {
+      message: `The page used ${keys}`,
+      action: { label: action.title, command: 'action.run', args: { id: action.id } },
+    })
+  }
 }
 
 /** The one key router extension for the app. */
diff --git a/src/main/menu.ts b/src/main/menu.ts
index 35450819..ed7be71b 100644
--- a/src/main/menu.ts
+++ b/src/main/menu.ts
@@ -4,6 +4,7 @@ import { editsText } from '../shared/keymap'
 import { keepForMenu } from './archive/menus'
 import { recentlyClosedItems } from './archive/recently-closed'
 import type { MainContext } from './context'
+import { keyRouter } from './keys/router'
 
 /**
  * The macOS menu bar, built from the shared action list so menu labels and
@@ -27,6 +28,8 @@ export function installMenu(ctx: MainContext): void {
       // fields, and the menu must not take it from one.
       ...(accel && editsText(accel, 'darwin') ? { registerAccelerator: false } : {}),
       click: () => {
+        // A key let through to a page that left it alone reaches the menu too: it runs once (KS-02).
+        if (!keyRouter.menuRuns(id)) return
         const windowId = ctx.windows.focusedWindowId()
         // With a page's popup or detached DevTools focused, Close Tab closes that window instead.
         if (!windowId && (id === 'tab.close' || id === 'window.close') && ctx.windows.closeFocusedForeign()) return
diff --git a/src/main/windows.ts b/src/main/windows.ts
index 1375c095..295d37a5 100644
--- a/src/main/windows.ts
+++ b/src/main/windows.ts
@@ -1067,6 +1067,10 @@ export class WindowManager {
         this.runOutsideText(contents, input)
         return
       }
+      // A web page may get the action's keys first (keys lane, KS-02, KS-16).
+      if (keyRouter.leaveToPage(contents, input, action, () => this.windowIdFor(contents) ?? this.focusedWindowId())) {
+        return
+      }
       event.preventDefault()
       const windowId = this.windowIdFor(contents) ?? this.focusedWindowId()
       // Close Tab in a window that isn't an Orbit window (a page's popup) closes that window.
diff --git a/src/shared/actions.ts b/src/shared/actions.ts
index 40ed95ed..964e351d 100644
--- a/src/shared/actions.ts
+++ b/src/shared/actions.ts
@@ -65,6 +65,11 @@ export interface ActionDef {
    * the key ("prefer Orbit", the default). Users choose per action in Settings → Shortcuts.
    */
   preferWebsites?: boolean | 'other'
+  /**
+   * With "prefer Orbit", the keys still go first to a page whose text field has focus, and the
+   * action runs only when the page leaves them alone (Back and Forward's ⌘[ and ⌘], KS-16).
+   */
+  pageFirstInFields?: boolean
 }
 
 const numbered = (
@@ -218,6 +223,8 @@ export const ACTIONS: ActionDef[] = [
     mac: ['Cmd+['],
     other: ['Alt+Left'],
     macOutsideText: ['Cmd+Left'],
+    // A text field's page may use ⌘[ / Alt+← (an editor's outdent): it goes there first (KS-16).
+    pageFirstInFields: true,
   },
   {
     id: 'nav.forward',
@@ -226,6 +233,8 @@ export const ACTIONS: ActionDef[] = [
     mac: ['Cmd+]'],
     other: ['Alt+Right'],
     macOutsideText: ['Cmd+Right'],
+    // A text field's page may use ⌘] / Alt+→ (an editor's indent): it goes there first (KS-16).
+    pageFirstInFields: true,
   },
   { id: 'nav.reload', title: 'Reload Page', category: 'Navigation', mac: ['Cmd+R'], other: ['Ctrl+R', 'F5'] },
   {
diff --git a/tests/e2e/keys.spec.ts b/tests/e2e/keys.spec.ts
index 4c50ebce..c57772f2 100644
--- a/tests/e2e/keys.spec.ts
+++ b/tests/e2e/keys.spec.ts
@@ -1,6 +1,6 @@
-import { expect, test } from '@playwright/test'
-import { action, isMac, launchOrbit, MOD, type Orbit, run, state, viewPage } from './helpers'
-import { cmd, type NavFixtures, openTab, startNavFixtures } from './nav-support'
+import { expect, type Page, test } from '@playwright/test'
+import { action, isMac, launchOrbit, MOD, type Orbit, run, state, tabPage, viewPage } from './helpers'
+import { cmd, type NavFixtures, openTab, pressInPage, startNavFixtures, visit } from './nav-support'
 import { activeSpace, createSpace } from './spaces-support'
 
 let fx: NavFixtures
@@ -261,3 +261,184 @@ test('[KS-05] ⌘⇧W / Ctrl+Shift+W closes the window, and F6 moves the keyboar
     .poll(async () => Object.keys((await state(app)).windows))
     .toEqual([expect.not.stringMatching(`^${firstWindow}$`)])
 })
+
+// ---------- Pages that use Orbit's keys (KS-02) ----------
+
+const SAVE = isMac ? '⌘S' : 'Ctrl+S'
+
+/**
+ * Opens a page with the keyboard. It counts its presses of ⌘/Ctrl + `code` (with Shift when
+ * `shift`), and with `use` takes them for itself (preventDefault), as a web editor does with ⌘S.
+ */
+async function pageWithKeys(title: string, keys: { code: string; shift?: boolean; use: boolean }): Promise<Page> {
+  const { app } = orbit
+  const id = await openTab(app, fx.url(`/page/${title}`))
+  await expect.poll(async () => (await state(app)).tabs[id]?.loading).toBe(false)
+  const page = await tabPage(app, `/page/${title}`)
+  await page.evaluate(
+    ({ code, shift, use }) => {
+      const w = window as unknown as { presses: number }
+      w.presses = 0
+      addEventListener('keydown', (e) => {
+        if (e.code !== code || !(e.metaKey || e.ctrlKey) || e.shiftKey !== shift) return
+        w.presses++
+        if (use) e.preventDefault()
+      })
+    },
+    { shift: false, ...keys },
+  )
+  await cmd(app, 'tabs.focusPage', {})
+  await expect.poll(focusedUrl).toBe(fx.url(`/page/${title}`))
+  return page
+}
+
+/**
+ * ⌘/Ctrl + `key` (and Shift), pressed as the keyboard does. Playwright's own key presses reach
+ * the page's renderer without passing Orbit's key router, so they can't show who gets the key.
+ */
+function pressMod(key: string, shift = false): Promise<string> {
+  return pressAnywhere(key, [isMac ? 'meta' : 'control', ...(shift ? (['shift'] as const) : [])])
+}
+
+function presses(page: Page): Promise<number> {
+  return page.evaluate(() => (window as unknown as { presses: number }).presses)
+}
+
+test('[KS-02][SB-11] a page that uses ⌘S / Ctrl+S gets the first press and a toast offers Toggle Sidebar; a second press within a second runs it', async () => {
+  const { app, shell } = orbit
+  const page = await pageWithKeys('Editor', { code: 'KeyS', use: true })
+  await pressMod('s')
+  await expect.poll(() => presses(page)).toBe(1)
+  const toast = shell.getByTestId('toast').filter({ hasText: `The page used ${SAVE}` })
+  await expect(toast).toHaveCount(1)
+  expect(await sidebarVisible()).toBe(true)
+  // The toast's button runs the action.
+  await expect(toast.getByTestId('toast-action')).toHaveText('Toggle Sidebar')
+  await toast.getByTestId('toast-action').click()
+  await expect.poll(sidebarVisible).toBe(false)
+  await action(app, 'sidebar.toggle')
+  await expect.poll(sidebarVisible).toBe(true)
+
+  // Pressed again soon after the page took it, the key toggles the sidebar and stays from the page.
+  await cmd(app, 'tabs.focusPage', {})
+  await expect.poll(focusedUrl).toBe(fx.url('/page/Editor'))
+  await pressMod('s')
+  await expect.poll(() => presses(page)).toBe(2)
+  await expect(toast).toHaveCount(1)
+  await pressMod('s')
+  await expect.poll(sidebarVisible).toBe(false)
+  expect(await presses(page)).toBe(2)
+})
+
+test('[KS-02][SB-11] a page that leaves ⌘S / Ctrl+S alone sees each press, and each press toggles the sidebar', async () => {
+  const page = await pageWithKeys('Reader', { code: 'KeyS', use: false })
+  await pressMod('s')
+  await expect.poll(sidebarVisible).toBe(false)
+  expect(await presses(page)).toBe(1)
+  await pressMod('s')
+  await expect.poll(sidebarVisible).toBe(true)
+  expect(await presses(page)).toBe(2)
+})
+
+test('[KS-02][ST-08] set to prefer Orbit, ⌘S / Ctrl+S toggles the sidebar at once and the page never sees it', async () => {
+  const { app } = orbit
+  await run(app, 'keys.setPriority', { actionId: 'sidebar.toggle', priority: 'orbit' })
+  expect((await state(app)).settings.shortcutPriority).toEqual({ 'sidebar.toggle': 'orbit' })
+  const page = await pageWithKeys('Editor', { code: 'KeyS', use: true })
+  await pressMod('s')
+  await expect.poll(sidebarVisible).toBe(false)
+  expect(await presses(page)).toBe(0)
+  // Back to the default: the page has the first press again.
+  await run(app, 'keys.setPriority', { actionId: 'sidebar.toggle', priority: 'websites' })
+  expect((await state(app)).settings.shortcutPriority).toBeUndefined()
+  await pressMod('s')
+  await expect.poll(() => presses(page)).toBe(1)
+  expect(await sidebarVisible()).toBe(false)
+})
+
+test('[KS-02][NV-17] Windows and Linux: a page that uses Ctrl+Shift+C gets it first and the toast offers Copy URL (macOS copies at once)', async () => {
+  const { app, shell } = orbit
+  const clipboard = () => app.evaluate(({ clipboard }) => clipboard.readText())
+  await app.evaluate(({ clipboard }) => clipboard.writeText('before'))
+  const page = await pageWithKeys('Sheet', { code: 'KeyC', shift: true, use: true })
+  await pressMod('c', true)
+  if (isMac) {
+    await expect.poll(clipboard).toBe(fx.url('/page/Sheet'))
+    expect(await presses(page)).toBe(0)
+    return
+  }
+  await expect.poll(() => presses(page)).toBe(1)
+  const toast = shell.getByTestId('toast').filter({ hasText: 'The page used Ctrl+Shift+C' })
+  await expect(toast.getByTestId('toast-action')).toHaveText('Copy URL')
+  expect(await clipboard()).toBe('before')
+  await pressMod('c', true)
+  await expect.poll(clipboard).toBe(fx.url('/page/Sheet'))
+  expect(await presses(page)).toBe(1)
+})
+
+test('[KS-16][NV-01] in a page text field, ⌘[ / Alt+← goes back only when the page leaves the key alone', async () => {
+  const { app } = orbit
+  const [key, mods] = isMac ? (['[', ['meta']] as const) : (['Left', ['alt']] as const)
+  const id = await openTab(app, fx.url('/page/FieldA'))
+  await visit(app, id, fx.url('/page/FieldB'))
+  await visit(app, id, fx.url('/page/FieldC'))
+  const c = await tabPage(app, '/page/FieldC')
+  // An editor that outdents with the key while its field has focus.
+  await c.evaluate(() => {
+    addEventListener('keydown', (e) => {
+      if (document.activeElement?.id === 'box' && (e.code === 'BracketLeft' || e.code === 'ArrowLeft'))
+        e.preventDefault()
+    })
+  })
+  await c.focus('#box')
+  await pressInPage(app, '/page/FieldC', key, [...mods])
+  await expect
+    .poll(() => c.evaluate(() => (window as unknown as { __keys: string[] }).__keys))
+    .toContain(isMac ? '[' : 'ArrowLeft')
+  // Outside the field the key is Orbit's: one page back. Had the first press gone back too, this
+  // would land on A.
+  await c.evaluate(() => (document.activeElement as HTMLElement | null)?.blur())
+  await pressInPage(app, '/page/FieldC', key, [...mods])
+  await expect.poll(async () => (await state(app)).tabs[id]?.url).toBe(fx.url('/page/FieldB'))
+  // In the field of a page that leaves the key alone, it goes back.
+  const b = await tabPage(app, '/page/FieldB')
+  await b.focus('#box')
+  await pressInPage(app, '/page/FieldB', key, [...mods])
+  await expect.poll(async () => (await state(app)).tabs[id]?.url).toBe(fx.url('/page/FieldA'))
+})
+
+/**
+ * Waits until main has had the answers to every page script it sent `urlPart`'s page before now:
+ * the page answers in order.
+ */
+function pageScriptsAnswered(urlPart: string): Promise<void> {
+  return orbit.app.evaluate(async ({ webContents }, part) => {
+    const page = webContents.getAllWebContents().find((w) => w.getURL().includes(part))
+    await page?.executeJavaScriptInIsolatedWorld(999, [{ code: '1' }])
+  }, urlPart)
+}
+
+test('[KS-16][TB-18] ⌘Z / Ctrl+Z in a page text field undoes the typing, not the last sidebar change', async () => {
+  const { app } = orbit
+  const mod = isMac ? 'meta' : 'control'
+  const a = await openTab(app, fx.url('/page/UndoA'))
+  const b = await openTab(app, fx.url('/page/UndoB'))
+  const id = await openTab(app, fx.url('/page/Typing'))
+  await expect.poll(async () => (await state(app)).tabs[id]?.loading).toBe(false)
+  await cmd(app, 'tabs.close', { tabId: a })
+  await cmd(app, 'tabs.close', { tabId: b })
+  const urls = async () => Object.values((await state(app)).tabs).map((t) => t.url)
+  expect(await urls()).toEqual([fx.url('/page/Typing')])
+  const page = await tabPage(app, '/page/Typing')
+  await page.focus('#box')
+  await page.keyboard.type('hello')
+  await expect(page.locator('#box')).toHaveValue('hello')
+  await pressInPage(app, '/page/Typing', 'z', [mod])
+  await expect(page.locator('#box')).toHaveValue('')
+  await pageScriptsAnswered('/page/Typing')
+  expect(await urls()).toEqual([fx.url('/page/Typing')])
+  // Outside the field the key undoes the last sidebar change: B comes back, and only B.
+  await page.evaluate(() => (document.activeElement as HTMLElement | null)?.blur())
+  await pressInPage(app, '/page/Typing', 'z', [mod])
+  await expect.poll(async () => (await urls()).sort()).toEqual([fx.url('/page/Typing'), fx.url('/page/UndoB')].sort())
+})
diff --git a/tests/unit/keymap-remap.test.ts b/tests/unit/keymap-remap.test.ts
index dffa07a2..e754ab85 100644
--- a/tests/unit/keymap-remap.test.ts
+++ b/tests/unit/keymap-remap.test.ts
@@ -10,6 +10,7 @@ import {
   unbind,
 } from '../../src/main/keys/bindings'
 import {
+  ACTIONS,
   ACTIONS_BY_ID,
   actionForAccelerator,
   actionForInput,
@@ -233,3 +234,12 @@ describe('[KS-02] who gets an action’s keys first', () => {
     })
   })
 })
+
+describe('[KS-16] keys a page’s text field may use', () => {
+  it('Back and Forward go to a focused text field first; no other action does', () => {
+    expect(ACTIONS.filter((a) => a.pageFirstInFields).map((a) => a.id)).toEqual(['nav.back', 'nav.forward'])
+    // They prefer Orbit: outside text fields the page never has them first.
+    expect(priorityFor(action('nav.back'), 'darwin')).toBe('orbit')
+    expect(priorityFor(action('nav.forward'), 'linux')).toBe('orbit')
+  })
+})

From b57561168ec452b31375534d20d6d173ea34689a Mon Sep 17 00:00:00 2001
From: Siya <57148521+siyabendoezdemir@users.noreply.github.com>
Date: Sat, 10 Oct 2026 16:06:56 +0000
Subject: [PATCH 05/11] fix(keys): pages that are loading never hold Orbit's
 keys; W in the tab switcher; tab, window, split and overlay keys checked
 (KS-02, KS-05, KS-06, KS-09, KS-19)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- KS-02: Electron runs no isolated-world script in a page while its main frame
  loads, so a loading page can't say what it did with a key press. Orbit now
  takes the keys at once then (pageCanAnswer), and every answer it waits for
  has a 1 s limit. Before, ⌘S on a page that was on its way did nothing.
- KS-06 / TB-05: W with ⌃ held while switching to a recent tab closes the
  highlighted tab; the next tab in the switcher takes the highlight.
- KS-05: Rename Tab, Archive Tab and Move Tab to Space… are assignable
  actions with no default keys.
- Main side of Settings → Shortcuts (ST-08): keys.setOptions (Go to Tab
  options) and keys.systemClashes (macOS Mission Control and GNOME
  workspace keys), with unit tests for the parsers.
- e2e tests for KS-05, KS-06, KS-09 and KS-19 from a page; feature status
  for KS-02, KS-05, KS-06, KS-09, KS-19 and TB-05.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 FEATURES.md                        |  16 +-
 docs/feature-status.json           |  10 +-
 src/main/keys/index.ts             |  14 ++
 src/main/keys/page-keys.ts         |  23 ++-
 src/main/keys/router.ts            |  21 ++-
 src/main/keys/system.ts            | 135 ++++++++++++++++
 src/main/keys/tab-keys.ts          |  52 +++++++
 src/main/tabs/commands.ts          |  19 +++
 src/main/tabs/runtime.ts           |   4 +-
 src/main/windows.ts                |   5 +
 src/shared/actions.ts              |   4 +
 src/shared/commands/keys.ts        |  20 +++
 tests/e2e/keys.spec.ts             | 238 +++++++++++++++++++++++++++++
 tests/unit/keymap-defaults.test.ts |   4 +
 tests/unit/keymap-system.test.ts   |  70 +++++++++
 15 files changed, 620 insertions(+), 15 deletions(-)
 create mode 100644 src/main/keys/system.ts
 create mode 100644 src/main/keys/tab-keys.ts
 create mode 100644 tests/unit/keymap-system.test.ts

diff --git a/FEATURES.md b/FEATURES.md
index 484ee8a8..f538ab79 100644
--- a/FEATURES.md
+++ b/FEATURES.md
@@ -4,11 +4,11 @@
 
 Every row is one behaviour from the clean-room spec. Status per ID: **spec’d** (every row) → **built** → **tested** (a unit or e2e test names the ID) → **feels right** (lead sign-off after a hands-on review against `feel.md`).
 
-**Totals:** 475 spec’d · 203 built (75 partial) · 291 tested · 0 feel right. 10 more are out of scope and not counted.
+**Totals:** 475 spec’d · 205 built (75 partial) · 291 tested · 0 feel right. 10 more are out of scope and not counted.
 
 | Priority | Spec’d | Built | Tested |
 |---|---|---|---|
-| P0 | 174 | 133 | 164 |
+| P0 | 174 | 135 | 164 |
 | P1 | 221 | 61 | 116 |
 | P2 | 80 | 9 | 11 |
 
@@ -59,7 +59,7 @@ Spec: `spec/tabs.md`
 | TB-02 | Create a new tab | P0 | ✅ | ✅ e2e | – | Cmd+T / + New Tab / link drop (a local file address dropped opens nothing, D49) / Cmd+Alt+V paste; background link tabs gesture-gated |
 | TB-03 | Where new tabs are inserted | P0 | ✅ | ✅ e2e+unit | – | single rule todayInsertIndex(): top of Today |
 | TB-04 | Switching between tabs (pointer and keyboard) | P0 | ✅ | ✅ e2e+unit | – | click, Cmd+1-9 (Favorites setting, Cmd+9 last), Cmd+Alt+Up/Down skip collapsed rows |
-| TB-05 | Recent-tab switcher (Ctrl+Tab) | P1 | 🟡 partial | ✅ e2e | – | Ctrl+Tab / Ctrl+Shift+Tab step through the 5 most recent tabs while Ctrl is held (keyboard only); no overlay list yet |
+| TB-05 | Recent-tab switcher (Ctrl+Tab) | P1 | 🟡 partial | ✅ e2e | – | Ctrl+Tab / Ctrl+Shift+Tab step through the 5 most recent tabs while Ctrl is held (keyboard only); W with Ctrl held closes the highlighted tab (keys lane, KS-06); no overlay list yet |
 | TB-06 | Closing a tab | P0 | ✅ | ✅ e2e+unit | – | Today -> Archive, pinned/Favorites unload; next selection below/above/MRU; middle-click; Cmd+W closes window when empty |
 | TB-07 | Reopen the last closed tab | P0 | ✅ | ✅ e2e | – | Cmd+Shift+T stack with full history; Cmd+Z reopens too |
 | TB-08 | Reorder tabs by drag and drop | P0 | ✅ | ✅ e2e+unit | – | pointer drag, 4px threshold, rows spring apart, ghost lift/settle, auto-scroll, Escape cancel, undo; no haptics |
@@ -347,14 +347,14 @@ Spec: `spec/shortcuts.md`
 | ID | Feature | P | Built | Tested | Feels right | Notes |
 |---|---|---|---|---|---|---|
 | KS-01 | One keymap, remapping and persistence | P0 | 🟡 partial | ✅ e2e+unit | – | one keymap keyed by action id (src/shared/actions.ts + src/shared/keymap.ts): the key router, macOS menu bar (rebuilt on a remap), tooltips and command-bar rows read the live bindings; remap, several bindings per action (up to 5), none (command bar and menus still run it), a modifier required except F1-F12, system keys refused, conflicts reported (clear or swap), reset; stored per device in settings.shortcuts, cleaned on load, kept across a restart (Space keys too); the Settings → Shortcuts page comes with ST-08 |
-| KS-02 | Conflicts with web pages ("prefer websites" vs "prefer Orbit") | P0 | 🟡 partial | ✅ e2e+unit | – | who gets a key first, per action: Toggle Sidebar (Cmd+S / Ctrl+S, SB-11) prefers websites on every platform, Copy URL (Ctrl+Shift+C, NV-17) on Windows/Linux, every other action prefers Orbit (the page never sees the key); with prefer websites the page's main frame gets the first press: left alone, the action runs; used (preventDefault), a toast offers the action and a second press within a second runs it; a held key's repeats stay the page's; a press into a frame Orbit can't see into counts as used; keys.setPriority changes it (the Settings → Shortcuts option comes with ST-08); Esc leaving page full screen keeps Chromium's rule and nothing holds Cmd+E yet |
+| KS-02 | Conflicts with web pages ("prefer websites" vs "prefer Orbit") | P0 | 🟡 partial | ✅ e2e+unit | – | who gets a key first, per action: Toggle Sidebar (Cmd+S / Ctrl+S, SB-11) prefers websites on every platform, Copy URL (Ctrl+Shift+C, NV-17) on Windows/Linux, every other action prefers Orbit (the page never sees the key); with prefer websites the page's main frame gets the first press: left alone, the action runs; used (preventDefault), a toast offers the action and a second press within a second runs it; a held key's repeats stay the page's; a press into a frame Orbit can't see into counts as used; while a page's main frame loads, Orbit takes the keys at once (Electron runs no isolated-world script in a loading page, so the page can't say in time what it did); keys.setPriority changes it (the Settings → Shortcuts option comes with ST-08); Esc leaving page full screen keeps Chromium's rule and nothing holds Cmd+E yet |
 | KS-03 | Platform mapping rules | P0 | 🟡 partial | ✅ e2e+unit | – | every default checked against the spec tables on macOS, Windows and Linux (unit test): ⌘ → Ctrl, ⌥ → Alt, ⌃ keys (⌃Tab, the split keys) stay Ctrl; the Windows/Linux exceptions Alt+1–9 for Spaces, Ctrl+H, Alt+←/→, Alt+D, F5, F3, Ctrl+F4 and F1; Alt+F4 and Alt+F are kept for the system; a Ctrl+Alt key that typed an AltGr character acts only outside text fields; letters and symbols follow the layout; F11 / Alt+Shift+F come with full screen (KS-08); the Linux desktop-clash hint and the macOS Mission Control hint come with ST-08 |
 | KS-04 | Command bar and address | P0 | ✅ | ✅ e2e+unit | – | ⌘T/⌘L/Alt+D, Esc, ⌘T/⌘L again, ↑/↓ (⌃N/⌃P), Enter, Tab, ⌫, ⇧Enter (option), ⌘⌥⌫ / Shift+Delete, ⌘⌥V |
-| KS-05 | Tabs and windows | P0 | 🟡 partial | ✅ e2e+unit | – | ⌘N, ⌘⇧N, ⌘⌥N, ⌘W / Ctrl+W / Ctrl+F4, ⌘⇧W / Ctrl+Shift+W (closes the window, or the Mini Window, Settings or onboarding window that has focus; Alt+F4 is the system's), ⌘⇧T, ⌘D, ⌘⇧C, ⌘⇧⌥C, ⌘S, ⌘⇧K, ⌘⇧E, F6 (keyboard between the sidebar and the page), Duplicate and Reset to Pinned assignable; ⌘Z (sidebar undo) is not remappable yet; the blank window (⌃⌘N, TB-17) and the top toolbar (⌘⇧D, SB-17) are not built |
-| KS-06 | Switching tabs | P0 | – | ✅ e2e+unit | – |  |
+| KS-05 | Tabs and windows | P0 | 🟡 partial | ✅ e2e+unit | – | ⌘N, ⌘⇧N, ⌘⌥N, ⌘W / Ctrl+W / Ctrl+F4, ⌘⇧W / Ctrl+Shift+W (closes the window, or the Mini Window, Settings or onboarding window that has focus; Alt+F4 is the system's), ⌘⇧T (a closed tab comes back in its place), ⌘D (pins; again, back to the top of Today), ⌘⇧C, ⌘⇧⌥C, ⌘S, ⌘⇧K, ⌘⇧E, F6 (keyboard between the sidebar and the page), tested from a page; Duplicate Tab, Reset Tab, Rename Tab (shows a hidden sidebar to edit the name), Archive Tab, Move Tab to Space… (the command bar on its Move to rows) and Favorite This Tab have no keys until the user gives them some; ⌘Z (sidebar undo) is not remappable yet; the blank window (⌃⌘N, TB-17) and the top toolbar (⌘⇧D, SB-17) are not built |
+| KS-06 | Switching tabs | P0 | ✅ | ✅ e2e+unit | – | ⌘1–⌘8 / Ctrl+1–8 (Favorites counted first unless turned off), ⌘9 / Ctrl+9 the last item or, set so, the ninth, ⌘⌥↓/↑ / Ctrl+Alt+↓/↑ and the ⌘⇧] / ⌘⇧[ (Ctrl+PgDn / Ctrl+PgUp) aliases, all tested from a page; while ⌃ is held, Tab and ⇧Tab (⌃` on macOS) step through recent tabs, W closes the highlighted tab (the next one in the switcher takes its place) and letting go settles; the switcher has no on-screen list yet (TB-05) |
 | KS-07 | Spaces | P0 | ✅ | ✅ e2e+unit | – | Space shortcuts wired through the action table |
 | KS-08 | Page navigation and page tools | P0 | 🟡 partial | ✅ e2e+unit | – | Back, Forward, Reload, hard reload, Stop, find (Cmd+F, Cmd+G, Shift+Cmd+G, F3, Ctrl+G), Cmd+J and zoom keys done; print, save page, reader mode and the rest come with their NV items |
-| KS-09 | Split view | P0 | – | ✅ unit | – |  |
+| KS-09 | Split view | P0 | ✅ | ✅ e2e+unit | – | ⌃⇧= adds a pane the command bar fills, ⌃⇧− closes the focused pane, ⌃⇧1–4 focus a pane, ⌃⇧] / ⌃⇧[ the next / previous pane (Ctrl+Shift on Windows/Linux), ⌘L / Ctrl+L changes the focused pane's address (SV-15), Add Right/Left/Above/Below Split from the command bar; tested from a page |
 | KS-10 | Peek and Mini Window | P1 | – | ✅ unit | – |  |
 | KS-11 | Media | P1 | 🟡 partial | ✅ e2e+unit | – | Space and arrows in the focused player, Cmd/Ctrl+scroll and pinch zoom (tested), hardware media keys via Chromium (untested), Mute Tab action assignable; the calendar meeting shortcut (P2) belongs to TB-21/FV-09 |
 | KS-12 | Library, history, downloads, settings, extensions, help | P1 | – | ✅ e2e+unit | – |  |
@@ -364,7 +364,7 @@ Spec: `spec/shortcuts.md`
 | KS-16 | Text-editing keys keep their meaning | P0 | ✅ | ✅ e2e+unit | – | typed keys never go astray: a page or Orbit view that loads (a slow page, a background tab, a reload) no longer takes the keyboard from the command bar, a sidebar field or the page in front (focus-on-navigation off for every web contents Orbit makes); ⌘←/⌘→ act outside text fields only; ⌘[ / ⌘] (Alt+←/→) from a page's text field go back or forward only when the page leaves them alone (a press into a frame Orbit can't see into stays the page's); ⌘Z in a page field is the page's undo (tabs lane, tested here); no shortcut on a plain key runs while an input method composes (unit test: e2e can't drive a composition through the key router) |
 | KS-17 | Mouse, trackpad and modifier-click bindings | P0 | – | – | – |  |
 | KS-18 | Shortcut hints everywhere | P1 | 🟡 partial | ✅ e2e | – | button tooltips (address, copy link, site controls, sidebar toggle, back/forward/reload, find, zoom, Library, Clear, Space dots, Peek, Mini Window Open in…), the empty-window hint, command-bar rows and macOS menu items follow a remap without a restart; context menus and the shortcut sheet (OB-12) to come |
-| KS-19 | Keys inside overlays | P0 | 🟡 partial | ✅ e2e | – | command bar: ⌘T/⌘L/⌘W/Esc handled by the bar first (ActionRegistry.intercept); other overlays belong to their lanes |
+| KS-19 | Keys inside overlays | P0 | 🟡 partial | ✅ e2e | – | the open overlay takes its keys first: command bar (⌘T/⌘L/⌘W/Esc), find bar (Enter/⇧Enter/Esc, NV-05), Peek (Esc, ⌘O, ⌘W, PK-09; Esc closes the Peek and the tab under it keeps loading), the recent-tab switcher (Tab/⇧Tab/`, W, letting go of ⌃), permission prompt and site controls (Esc), the sidebar with keyboard focus (arrows, Enter, Esc back to the page, SB-22); Esc then stops a loading page, as before, even one that uses Esc itself: Electron runs no isolated-world script in a page while it loads, so Orbit can't learn in time whether the page used the key (needs a lead decision: a script in the page's own world or a preload channel, D40) |
 | KS-20 | Shortcuts in special windows | P1 | – | – | – |  |
 
 ## Interaction feel and motion targets (prefix FL)
diff --git a/docs/feature-status.json b/docs/feature-status.json
index 2e05ab6a..07a1df12 100644
--- a/docs/feature-status.json
+++ b/docs/feature-status.json
@@ -23,7 +23,7 @@
   "TB-02": {"built": "yes", "note": "Cmd+T / + New Tab / link drop (a local file address dropped opens nothing, D49) / Cmd+Alt+V paste; background link tabs gesture-gated"},
   "TB-03": {"built": "yes", "note": "single rule todayInsertIndex(): top of Today"},
   "TB-04": {"built": "yes", "note": "click, Cmd+1-9 (Favorites setting, Cmd+9 last), Cmd+Alt+Up/Down skip collapsed rows"},
-  "TB-05": {"built": "partial", "note": "Ctrl+Tab / Ctrl+Shift+Tab step through the 5 most recent tabs while Ctrl is held (keyboard only); no overlay list yet"},
+  "TB-05": {"built": "partial", "note": "Ctrl+Tab / Ctrl+Shift+Tab step through the 5 most recent tabs while Ctrl is held (keyboard only); W with Ctrl held closes the highlighted tab (keys lane, KS-06); no overlay list yet"},
   "TB-06": {"built": "yes", "note": "Today -> Archive, pinned/Favorites unload; next selection below/above/MRU; middle-click; Cmd+W closes window when empty"},
   "TB-07": {"built": "yes", "note": "Cmd+Shift+T stack with full history; Cmd+Z reopens too"},
   "TB-08": {"built": "yes", "note": "pointer drag, 4px threshold, rows spring apart, ghost lift/settle, auto-scroll, Escape cancel, undo; no haptics"},
@@ -135,13 +135,14 @@
   "CB-23": {"built": "partial", "note": "private (non-persistent) profiles: no history/archive rows, and their tabs, folders and Spaces never show in normal windows; ⌘L on an empty Space acts like ⌘T; split-pane and Mini Window variants not done"},
   "KS-04": {"built": "yes", "note": "⌘T/⌘L/Alt+D, Esc, ⌘T/⌘L again, ↑/↓ (⌃N/⌃P), Enter, Tab, ⌫, ⇧Enter (option), ⌘⌥⌫ / Shift+Delete, ⌘⌥V"},
   "KS-07": {"built": "yes", "note": "Space shortcuts wired through the action table"},
-  "KS-19": {"built": "partial", "note": "command bar: ⌘T/⌘L/⌘W/Esc handled by the bar first (ActionRegistry.intercept); other overlays belong to their lanes"},
+  "KS-19": {"built": "partial", "note": "the open overlay takes its keys first: command bar (⌘T/⌘L/⌘W/Esc), find bar (Enter/⇧Enter/Esc, NV-05), Peek (Esc, ⌘O, ⌘W, PK-09; Esc closes the Peek and the tab under it keeps loading), the recent-tab switcher (Tab/⇧Tab/`, W, letting go of ⌃), permission prompt and site controls (Esc), the sidebar with keyboard focus (arrows, Enter, Esc back to the page, SB-22); Esc then stops a loading page, as before, even one that uses Esc itself: Electron runs no isolated-world script in a page while it loads, so Orbit can't learn in time whether the page used the key (needs a lead decision: a script in the page's own world or a preload channel, D40)"},
   "KS-16": {"built": "yes", "note": "typed keys never go astray: a page or Orbit view that loads (a slow page, a background tab, a reload) no longer takes the keyboard from the command bar, a sidebar field or the page in front (focus-on-navigation off for every web contents Orbit makes); ⌘←/⌘→ act outside text fields only; ⌘[ / ⌘] (Alt+←/→) from a page's text field go back or forward only when the page leaves them alone (a press into a frame Orbit can't see into stays the page's); ⌘Z in a page field is the page's undo (tabs lane, tested here); no shortcut on a plain key runs while an input method composes (unit test: e2e can't drive a composition through the key router)"},
   "KS-01": {"built": "partial", "note": "one keymap keyed by action id (src/shared/actions.ts + src/shared/keymap.ts): the key router, macOS menu bar (rebuilt on a remap), tooltips and command-bar rows read the live bindings; remap, several bindings per action (up to 5), none (command bar and menus still run it), a modifier required except F1-F12, system keys refused, conflicts reported (clear or swap), reset; stored per device in settings.shortcuts, cleaned on load, kept across a restart (Space keys too); the Settings → Shortcuts page comes with ST-08"},
-  "KS-02": {"built": "partial", "note": "who gets a key first, per action: Toggle Sidebar (Cmd+S / Ctrl+S, SB-11) prefers websites on every platform, Copy URL (Ctrl+Shift+C, NV-17) on Windows/Linux, every other action prefers Orbit (the page never sees the key); with prefer websites the page's main frame gets the first press: left alone, the action runs; used (preventDefault), a toast offers the action and a second press within a second runs it; a held key's repeats stay the page's; a press into a frame Orbit can't see into counts as used; keys.setPriority changes it (the Settings → Shortcuts option comes with ST-08); Esc leaving page full screen keeps Chromium's rule and nothing holds Cmd+E yet"},
+  "KS-02": {"built": "partial", "note": "who gets a key first, per action: Toggle Sidebar (Cmd+S / Ctrl+S, SB-11) prefers websites on every platform, Copy URL (Ctrl+Shift+C, NV-17) on Windows/Linux, every other action prefers Orbit (the page never sees the key); with prefer websites the page's main frame gets the first press: left alone, the action runs; used (preventDefault), a toast offers the action and a second press within a second runs it; a held key's repeats stay the page's; a press into a frame Orbit can't see into counts as used; while a page's main frame loads, Orbit takes the keys at once (Electron runs no isolated-world script in a loading page, so the page can't say in time what it did); keys.setPriority changes it (the Settings → Shortcuts option comes with ST-08); Esc leaving page full screen keeps Chromium's rule and nothing holds Cmd+E yet"},
   "KS-18": {"built": "partial", "note": "button tooltips (address, copy link, site controls, sidebar toggle, back/forward/reload, find, zoom, Library, Clear, Space dots, Peek, Mini Window Open in…), the empty-window hint, command-bar rows and macOS menu items follow a remap without a restart; context menus and the shortcut sheet (OB-12) to come"},
   "KS-03": {"built": "partial", "note": "every default checked against the spec tables on macOS, Windows and Linux (unit test): ⌘ → Ctrl, ⌥ → Alt, ⌃ keys (⌃Tab, the split keys) stay Ctrl; the Windows/Linux exceptions Alt+1–9 for Spaces, Ctrl+H, Alt+←/→, Alt+D, F5, F3, Ctrl+F4 and F1; Alt+F4 and Alt+F are kept for the system; a Ctrl+Alt key that typed an AltGr character acts only outside text fields; letters and symbols follow the layout; F11 / Alt+Shift+F come with full screen (KS-08); the Linux desktop-clash hint and the macOS Mission Control hint come with ST-08"},
-  "KS-05": {"built": "partial", "note": "⌘N, ⌘⇧N, ⌘⌥N, ⌘W / Ctrl+W / Ctrl+F4, ⌘⇧W / Ctrl+Shift+W (closes the window, or the Mini Window, Settings or onboarding window that has focus; Alt+F4 is the system's), ⌘⇧T, ⌘D, ⌘⇧C, ⌘⇧⌥C, ⌘S, ⌘⇧K, ⌘⇧E, F6 (keyboard between the sidebar and the page), Duplicate and Reset to Pinned assignable; ⌘Z (sidebar undo) is not remappable yet; the blank window (⌃⌘N, TB-17) and the top toolbar (⌘⇧D, SB-17) are not built"},
+  "KS-05": {"built": "partial", "note": "⌘N, ⌘⇧N, ⌘⌥N, ⌘W / Ctrl+W / Ctrl+F4, ⌘⇧W / Ctrl+Shift+W (closes the window, or the Mini Window, Settings or onboarding window that has focus; Alt+F4 is the system's), ⌘⇧T (a closed tab comes back in its place), ⌘D (pins; again, back to the top of Today), ⌘⇧C, ⌘⇧⌥C, ⌘S, ⌘⇧K, ⌘⇧E, F6 (keyboard between the sidebar and the page), tested from a page; Duplicate Tab, Reset Tab, Rename Tab (shows a hidden sidebar to edit the name), Archive Tab, Move Tab to Space… (the command bar on its Move to rows) and Favorite This Tab have no keys until the user gives them some; ⌘Z (sidebar undo) is not remappable yet; the blank window (⌃⌘N, TB-17) and the top toolbar (⌘⇧D, SB-17) are not built"},
+  "KS-06": {"built": "yes", "note": "⌘1–⌘8 / Ctrl+1–8 (Favorites counted first unless turned off), ⌘9 / Ctrl+9 the last item or, set so, the ninth, ⌘⌥↓/↑ / Ctrl+Alt+↓/↑ and the ⌘⇧] / ⌘⇧[ (Ctrl+PgDn / Ctrl+PgUp) aliases, all tested from a page; while ⌃ is held, Tab and ⇧Tab (⌃` on macOS) step through recent tabs, W closes the highlighted tab (the next one in the switcher takes its place) and letting go settles; the switcher has no on-screen list yet (TB-05)"},
   "FL-13": {"built": "yes", "note": "strip of pages, 1:1 tracking, commit thresholds, settle/rubber-band springs, one-page slides for clicks and keys, reduced motion cross-fade"},
   "FL-14": {"built": "yes", "note": "theme blends with the gesture/spring in OKLab; 200 ms preset blends; light/dark cross-fade"},
   "FL-16": {"built": "yes", "note": "motion spring (0.97→1, 4 px drop), 100 ms exit (80 ms after choosing a row) while focus returns at once; fade only with reduced motion; centred in the window"},
@@ -197,6 +198,7 @@
   "NV-18": {"built": "yes", "note": "summary of MW-02/05/09/10/11: links from other apps open a Mini Window or follow routing rules, else a Today tab in the most recent Space; never in a private window (e2e); a launch with --private-window takes its links to a private window (NV-11); rules UI is ST-09, Archive restores AR-05"},
   "NV-17": {"built": "yes", "note": "copy button = Cmd+Shift+C (clean URL, Copied toast); one-time shortcut tip when the URL is copied from the command bar; on Windows/Linux a page that uses Ctrl+Shift+C gets it first and a toast offers Copy URL, a second press within a second copies (KS-02)"},
   "KS-08": {"built": "partial", "note": "Back, Forward, Reload, hard reload, Stop, find (Cmd+F, Cmd+G, Shift+Cmd+G, F3, Ctrl+G), Cmd+J and zoom keys done; print, save page, reader mode and the rest come with their NV items"},
+  "KS-09": {"built": "yes", "note": "⌃⇧= adds a pane the command bar fills, ⌃⇧− closes the focused pane, ⌃⇧1–4 focus a pane, ⌃⇧] / ⌃⇧[ the next / previous pane (Ctrl+Shift on Windows/Linux), ⌘L / Ctrl+L changes the focused pane's address (SV-15), Add Right/Left/Above/Below Split from the command bar; tested from a page"},
   "FL-15": {"built": "partial", "note": "top row: Back/Forward nudge, Reload glyph turns once, press to 0.94 with pop release, restarts on repeat, none when disabled or reduced motion"},
   "FL-23": {"built": "yes", "note": "after 150 ms, a 48x4 theme-accent pill sweeping on a 1.2 s cycle (a pulse with reduced motion); on load end it fills (80 ms) and fades (150 ms), gone 180 ms after; never moves page content"},
   "FL-02": {"built": "yes", "note": "260 ms standard curve drives the sidebar column and the card margins together; interruptible; reduced motion snaps"},
diff --git a/src/main/keys/index.ts b/src/main/keys/index.ts
index 383c8e20..9d975823 100644
--- a/src/main/keys/index.ts
+++ b/src/main/keys/index.ts
@@ -4,6 +4,8 @@ import type { MainContext } from '../context'
 import { installMenu } from '../menu'
 import { bind, reset, setPriority, unbind } from './bindings'
 import { keyRouter } from './router'
+import { setSystemClashesForTest, systemClashes } from './system'
+import { registerTabKeys } from './tab-keys'
 import { registerWindowKeys } from './window-keys'
 
 /**
@@ -65,7 +67,19 @@ export function registerKeys(ctx: MainContext): void {
     if (!text(actionId)) return
     savePriorities(setPriority(store.state.settings.shortcutPriority, actionId, priority, platform))
   })
+  commands.register('keys.setOptions', ({ countFavorites, lastTabOnCmd9 }) =>
+    store.update((d) => {
+      if (typeof countFavorites === 'boolean') d.settings.countFavoritesInShortcuts = countFavorites
+      if (typeof lastTabOnCmd9 === 'boolean') d.settings.lastTabOnCmd9 = lastTabOnCmd9
+    }),
+  )
+  commands.register('keys.systemClashes', () => systemClashes())
   registerWindowKeys(ctx)
+  registerTabKeys(ctx)
   keyRouter.init(ctx)
   commands.register('keys.record', ({ on }, c) => keyRouter.setRecording(on ? c.windowId : undefined))
+  // Tests say which keys the system keeps instead of asking it.
+  if (ctx.e2e) {
+    ;(globalThis as unknown as { __orbitKeys: unknown }).__orbitKeys = { setSystemClashes: setSystemClashesForTest }
+  }
 }
diff --git a/src/main/keys/page-keys.ts b/src/main/keys/page-keys.ts
index 9c4334ab..fca33688 100644
--- a/src/main/keys/page-keys.ts
+++ b/src/main/keys/page-keys.ts
@@ -85,6 +85,18 @@ export type PageVerdict =
 /** How long to wait for the page's answer before taking it that the page kept the key. */
 export const VERDICT_WAIT_MS = 250
 
+/** How long main waits for an answer at all: a page whose renderer is busy or hung answers late. */
+const ANSWER_WAIT_MS = 1000
+
+/**
+ * Whether the page can say at once what it did with a key press. Electron runs no isolated-world
+ * script in a page while its main frame loads (the script waits until the load ends), so a page
+ * on its way, or one still loading the first document's resources, can't answer in time.
+ */
+export function pageCanAnswer(contents: WebContents): boolean {
+  return !contents.isDestroyed() && !contents.isCrashed() && !contents.isLoadingMainFrame()
+}
+
 /**
  * What the page did with the key press `input`, pressed at `pressedAt` (main's clock, which the
  * page shares). Asked as the press is let through to the page.
@@ -94,12 +106,21 @@ export async function pageVerdict(
   input: Electron.Input,
   pressedAt: number,
 ): Promise<PageVerdict> {
+  if (!pageCanAnswer(contents)) return undefined
   const sig = [input.meta, input.control, input.alt, input.shift, input.code].join(',')
   const code = `window.__orbitKeys ? window.__orbitKeys.verdict(${JSON.stringify(sig)}, ${pressedAt - 10}, ${VERDICT_WAIT_MS}) : null`
+  let timer: NodeJS.Timeout | undefined
   try {
-    const verdict = (await contents.executeJavaScriptInIsolatedWorld(KEYS_WORLD, [{ code }])) as PageVerdict | null
+    const verdict = (await Promise.race([
+      contents.executeJavaScriptInIsolatedWorld(KEYS_WORLD, [{ code }]),
+      new Promise((resolve) => {
+        timer = setTimeout(() => resolve(null), ANSWER_WAIT_MS)
+      }),
+    ])) as PageVerdict | null
     return verdict ?? undefined
   } catch {
     return undefined
+  } finally {
+    clearTimeout(timer)
   }
 }
diff --git a/src/main/keys/router.ts b/src/main/keys/router.ts
index 5642c729..24c661be 100644
--- a/src/main/keys/router.ts
+++ b/src/main/keys/router.ts
@@ -4,7 +4,7 @@ import type { RecordedKey } from '../../shared/commands/keys'
 import { acceleratorFromInput, modifiersOf } from '../../shared/keymap'
 import type { WindowId } from '../../shared/state'
 import type { MainContext } from '../context'
-import { pageVerdict, watchPageKeys } from './page-keys'
+import { pageCanAnswer, pageVerdict, watchPageKeys } from './page-keys'
 
 /** A second press of the same keys within this long after the page took the first runs the action (KS-02). */
 export const AGAIN_MS = 1000
@@ -95,6 +95,21 @@ export class KeyRouter {
     return true
   }
 
+  /**
+   * W, with Control still held, while switching to a recent tab (⌃Tab) closes the highlighted tab
+   * (KS-06, TB-05); a held W closes one. Returns true when the press was the switcher's: the
+   * caller keeps it from the page and every shortcut (Ctrl+W, Ctrl+Shift+W).
+   */
+  switcherKey(input: Electron.Input, windowOf: () => WindowId | undefined): boolean {
+    if (input.type !== 'keyDown' || !input.control || input.meta || input.alt) return false
+    if (input.code !== 'KeyW' && input.key.toLowerCase() !== 'w') return false
+    const windowId = windowOf()
+    const recent = this.ctx?.tabs.recentSwitch
+    if (!windowId || !recent?.active(windowId)) return false
+    if (!input.isAutoRepeat) recent.closeHighlighted(windowId)
+    return true
+  }
+
   /**
    * Keys a web page may use (KS-02, KS-16). Returns true when the press goes to the page: the
    * caller lets it through and runs nothing now. Applies to a tab's page and:
@@ -105,6 +120,8 @@ export class KeyRouter {
    * - an action that prefers Orbit but leaves its keys to text fields (Back and Forward's ⌘[ ⌘]):
    *   the action runs unless focus was in a text field and the page used the press, or the press
    *   went into a frame Orbit can't see into.
+   * A page whose main frame is loading can't say what it did with a press in time: Orbit takes
+   * the keys at once then.
    */
   leaveToPage(
     contents: WebContents,
@@ -116,6 +133,8 @@ export class KeyRouter {
     if (!ctx?.tabs.tabIdFor(contents)) return false
     const priority = priorityFor(action, process.platform, ctx.store.state.settings.shortcutPriority)
     if (priority === 'orbit' && !action.pageFirstInFields) return false
+    // A page that is loading can't say in time what it did with the key: Orbit takes it at once.
+    if (!pageCanAnswer(contents)) return false
     const key = `${contents.id} ${acceleratorFromInput(input) ?? ''}`
     const windowId = windowOf()
     // Until the page's answer is in, the macOS menu may run the action instead (`menuRuns`).
diff --git a/src/main/keys/system.ts b/src/main/keys/system.ts
new file mode 100644
index 00000000..214078b0
--- /dev/null
+++ b/src/main/keys/system.ts
@@ -0,0 +1,135 @@
+import { execFile } from 'node:child_process'
+import type { SystemClash } from '../../shared/commands/keys'
+import { canonicalAccelerator } from '../../shared/keymap'
+
+/**
+ * Keys the operating system keeps for itself, so Orbit never receives them (KS-03): macOS's
+ * Mission Control "Switch to Desktop N" (⌃1–⌃9 when turned on) and GNOME's workspace keys
+ * (Ctrl+Alt+←/→ on many setups). Settings → Shortcuts shows them next to the actions they block.
+ * Other desktops and Windows report nothing.
+ */
+
+const run = (file: string, args: string[]): Promise<string> =>
+  new Promise((resolve) => {
+    execFile(file, args, { timeout: 3000 }, (error, stdout) => resolve(error ? '' : String(stdout)))
+  })
+
+/** macOS virtual key codes of the digit keys. */
+const MAC_DIGITS: Record<number, string> = {
+  18: '1',
+  19: '2',
+  20: '3',
+  21: '4',
+  23: '5',
+  22: '6',
+  26: '7',
+  28: '8',
+  25: '9',
+}
+
+/**
+ * The Mission Control desktop keys turned on, from `defaults read com.apple.symbolichotkeys
+ * AppleSymbolicHotKeys` (entries 118–126 are Switch to Desktop 1–9).
+ */
+export function missionControlClashes(plist: string): SystemClash[] {
+  const out: SystemClash[] = []
+  const entry =
+    /(?:^|[\s{;])"?(\d+)"?\s*=\s*\{\s*enabled\s*=\s*(\d+);\s*value\s*=\s*\{\s*parameters\s*=\s*\(\s*(\d+),\s*(\d+),\s*(\d+)\s*\);/g
+  for (const m of plist.matchAll(entry)) {
+    const id = Number(m[1])
+    if (id < 118 || id > 126 || m[2] !== '1') continue
+    const digit = MAC_DIGITS[Number(m[4])]
+    const mask = Number(m[5])
+    if (!digit) continue
+    const mods = [
+      mask & 1048576 ? 'Cmd' : '',
+      mask & 262144 ? 'Ctrl' : '',
+      mask & 524288 ? 'Alt' : '',
+      mask & 131072 ? 'Shift' : '',
+    ].filter(Boolean)
+    const accel = canonicalAccelerator([...mods, digit].join('+'))
+    if (accel) out.push({ accel, owner: `Mission Control: Switch to Desktop ${id - 117}` })
+  }
+  return out
+}
+
+const GNOME_KEYS: Record<string, string> = {
+  Left: 'Left',
+  Right: 'Right',
+  Up: 'Up',
+  Down: 'Down',
+  Page_Up: 'PageUp',
+  Page_Down: 'PageDown',
+  Home: 'Home',
+  End: 'End',
+}
+
+/** A GNOME accelerator ("<Control><Alt>Left") as a binding, when Orbit could have it. */
+export function gnomeAccelerator(text: string): string | undefined {
+  const mods: string[] = []
+  let rest = text.trim()
+  for (;;) {
+    const m = /^<([A-Za-z0-9]+)>/.exec(rest)
+    if (!m) break
+    rest = rest.slice(m[0].length)
+    const name = (m[1] ?? '').toLowerCase()
+    if (name === 'control' || name === 'primary' || name === 'ctrl') mods.push('Ctrl')
+    else if (name === 'alt' || name === 'mod1') mods.push('Alt')
+    else if (name === 'shift') mods.push('Shift')
+    // Super (the Windows key) and the rest are keys Orbit never binds.
+    else return undefined
+  }
+  const key = GNOME_KEYS[rest] ?? (/^F([1-9]|1[0-2])$/.test(rest) ? rest : /^[a-z0-9]$/i.test(rest) ? rest : undefined)
+  if (!key || mods.length === 0) return undefined
+  return canonicalAccelerator([...mods, key].join('+'))
+}
+
+const GNOME_SETTINGS: [key: string, owner: string][] = [
+  ['switch-to-workspace-left', 'GNOME: Switch to workspace on the left'],
+  ['switch-to-workspace-right', 'GNOME: Switch to workspace on the right'],
+  ['switch-to-workspace-up', 'GNOME: Switch to workspace above'],
+  ['switch-to-workspace-down', 'GNOME: Switch to workspace below'],
+  ['move-to-workspace-left', 'GNOME: Move window one workspace to the left'],
+  ['move-to-workspace-right', 'GNOME: Move window one workspace to the right'],
+]
+
+/** GNOME's window manager keys, from `gsettings get org.gnome.desktop.wm.keybindings <key>` (a list such as ['<Super>Page_Up', '<Control><Alt>Left']). */
+export function gnomeClashes(values: Record<string, string>): SystemClash[] {
+  const out: SystemClash[] = []
+  for (const [key, owner] of GNOME_SETTINGS) {
+    for (const m of (values[key] ?? '').matchAll(/'([^']*)'/g)) {
+      const accel = gnomeAccelerator(m[1] ?? '')
+      if (accel) out.push({ accel, owner })
+    }
+  }
+  return out
+}
+
+async function detect(platform: string): Promise<SystemClash[]> {
+  if (platform === 'darwin') {
+    return missionControlClashes(await run('defaults', ['read', 'com.apple.symbolichotkeys', 'AppleSymbolicHotKeys']))
+  }
+  if (platform === 'linux') {
+    const values: Record<string, string> = {}
+    for (const [key] of GNOME_SETTINGS) {
+      values[key] = await run('gsettings', ['get', 'org.gnome.desktop.wm.keybindings', key])
+    }
+    return gnomeClashes(values)
+  }
+  return []
+}
+
+let found: Promise<SystemClash[]> | undefined
+let override: SystemClash[] | undefined
+
+/** The system's keys that Orbit can't receive, looked up once per run. */
+export function systemClashes(platform = process.platform): Promise<SystemClash[]> {
+  if (override) return Promise.resolve(override)
+  found ??= detect(platform).catch(() => [])
+  return found
+}
+
+/** Tests: what the system keeps, instead of asking it. */
+export function setSystemClashesForTest(list: SystemClash[] | undefined): void {
+  override = list
+}
diff --git a/src/main/keys/tab-keys.ts b/src/main/keys/tab-keys.ts
new file mode 100644
index 00000000..5f3867ed
--- /dev/null
+++ b/src/main/keys/tab-keys.ts
@@ -0,0 +1,52 @@
+import { sectionOf, splitOfTab } from '../../shared/tree'
+import type { MainContext } from '../context'
+import type { CallContext } from '../registry'
+import { activeTabOf } from '../windows'
+
+/**
+ * Tab actions from KS-05's table that have no keys until the user gives them some (Settings →
+ * Shortcuts): Rename Tab (TB-12), Archive Tab and Move Tab to Space (TB-11). Each acts on the
+ * selected tab of a main window.
+ */
+export function registerTabKeys(ctx: MainContext): void {
+  const { actions, commands, store, windows } = ctx
+
+  const selected = (c: CallContext) => {
+    const windowId = c.windowId ?? windows.focusedWindowId()
+    if (!windowId || store.state.windows[windowId]?.kind !== 'main') return undefined
+    const tabId = activeTabOf(store.state, windowId)
+    return tabId ? { windowId, tabId } : undefined
+  }
+
+  // The name is edited in the tab's sidebar row (a split's in its split row): a hidden sidebar shows.
+  actions.register('tab.rename', (c) => {
+    const at = selected(c)
+    if (!at) return
+    const { windowId, tabId } = at
+    if (!store.state.windows[windowId]?.sidebar.visible) {
+      void commands.run('window.setSidebar', { visible: true }, { windowId })
+    }
+    windows.sendToWindow(windowId, 'sidebar:rename', { id: splitOfTab(store.state, tabId) ?? tabId })
+  })
+
+  // A Today tab closes into the Archive (TB-06); a pinned tab or Favorite leaves the sidebar for it (PN-06).
+  actions.register('tab.archive', (c) => {
+    const at = selected(c)
+    if (!at) return
+    const { windowId, tabId } = at
+    const section = sectionOf(store.state, splitOfTab(store.state, tabId) ?? tabId)
+    if (section === 'pinned' || section === 'favorite') void commands.run('tabs.delete', { id: tabId }, { windowId })
+    else void commands.run('tabs.close', { tabId }, { windowId })
+  })
+
+  // The command bar, on its "Move to [Space]" rows.
+  actions.register('tab.pickSpace', (c) => {
+    const at = selected(c)
+    if (!at) return
+    void commands.run(
+      'overlay.open',
+      { overlay: { kind: 'commandbar', mode: 'new-tab', query: 'Move to ' } },
+      { windowId: at.windowId },
+    )
+  })
+}
diff --git a/src/main/tabs/commands.ts b/src/main/tabs/commands.ts
index 56db6f44..903e74ef 100644
--- a/src/main/tabs/commands.ts
+++ b/src/main/tabs/commands.ts
@@ -664,6 +664,25 @@ export function registerTabs(ctx: MainContext): { ops: TabOps; maintenance: TabM
   actions.register('tab.recent', stepRecent(1))
   actions.register('tab.recentBack', stepRecent(-1))
   tabs.onControlUp = endRecent
+  // W, with Control still held, closes the highlighted tab; the next one in the switcher takes its
+  // place and switching goes on (TB-05, keys lane KS-06).
+  tabs.recentSwitch = {
+    active: (windowId) => recent?.windowId === windowId,
+    closeHighlighted: (windowId) => {
+      const r = recent
+      if (!r || r.windowId !== windowId) return
+      const closing = r.order[r.index]
+      if (!closing) return
+      r.order.splice(r.index, 1)
+      r.times.delete(closing)
+      if (r.index >= r.order.length) r.index = 0
+      ops.closeTabs([closing], 'closed')
+      const next = r.order[r.index]
+      if (next && store.state.tabs[next]) ops.activate(windowId, next)
+      if (r.timer) clearTimeout(r.timer)
+      r.timer = setTimeout(endRecent, 1500)
+    },
+  }
   commands.register('tabs.endRecentSwitch', () => endRecent())
   for (let n = 1; n <= 9; n++) {
     actions.register(`tab.goto.${n}`, (c) => {
diff --git a/src/main/tabs/runtime.ts b/src/main/tabs/runtime.ts
index 7f84451c..e745a838 100644
--- a/src/main/tabs/runtime.ts
+++ b/src/main/tabs/runtime.ts
@@ -12,7 +12,7 @@ import {
 import { framesMayOpen } from '../../shared/link-routing'
 import { reopenReferrerPolicy } from '../../shared/nav'
 import { isPrivateProfileId } from '../../shared/private'
-import type { Tab, TabId } from '../../shared/state'
+import type { Tab, TabId, WindowId } from '../../shared/state'
 import { isAwayFromPinned, sameDocUrl } from '../../shared/tabs'
 import type { MainContext } from '../context'
 import { KEEP_KEYBOARD } from '../keys/focus'
@@ -158,6 +158,8 @@ export class TabRuntime {
   onPageClosed?: (tabId: TabId) => void
   /** Control was released in a page (ends recent-tab switching, TB-05). */
   onControlUp?: () => void
+  /** Recent-tab switching in a window (TB-05): whether it is going on, and closing its highlighted tab (W, KS-06). */
+  recentSwitch?: { active: (windowId: WindowId) => boolean; closeHighlighted: (windowId: WindowId) => void }
   /** A page tried to open a tab or pop-up without a user gesture. */
   onPopupBlocked?: (tabId: TabId, url: string, referrer: Referrer) => void
   /** True when the tab's site may open pop-ups without a click (allowed in site controls, NV-09). */
diff --git a/src/main/windows.ts b/src/main/windows.ts
index 295d37a5..fd1407d5 100644
--- a/src/main/windows.ts
+++ b/src/main/windows.ts
@@ -1062,6 +1062,11 @@ export class WindowManager {
         return
       }
       if (input.type !== 'keyDown') return
+      // W while switching to a recent tab closes the highlighted tab (keys lane, KS-06).
+      if (keyRouter.switcherKey(input, () => this.windowIdFor(contents) ?? this.focusedWindowId())) {
+        event.preventDefault()
+        return
+      }
       const action = actionForInput(input, process.platform)
       if (!action || !this.ctx.actions.has(action.id)) {
         this.runOutsideText(contents, input)
diff --git a/src/shared/actions.ts b/src/shared/actions.ts
index 964e351d..af60142a 100644
--- a/src/shared/actions.ts
+++ b/src/shared/actions.ts
@@ -133,6 +133,10 @@ export const ACTIONS: ActionDef[] = [
   },
   { id: 'tab.togglePin', title: 'Pin / Unpin Tab', category: 'Tabs', mac: ['Cmd+D'], other: ['Ctrl+D'] },
   { id: 'tab.duplicate', title: 'Duplicate Tab', category: 'Tabs' },
+  // KS-05's assignable tab actions (no default keys).
+  { id: 'tab.rename', title: 'Rename Tab', category: 'Tabs' },
+  { id: 'tab.archive', title: 'Archive Tab', category: 'Tabs' },
+  { id: 'tab.pickSpace', title: 'Move Tab to Space…', category: 'Tabs', keywords: ['move to', 'space'] },
   { id: 'tab.resetToPinned', title: 'Reset Tab', category: 'Tabs', keywords: ['pinned url', 'home', 'go back'] },
   {
     id: 'tab.favorite',
diff --git a/src/shared/commands/keys.ts b/src/shared/commands/keys.ts
index 91474928..8bc2cd99 100644
--- a/src/shared/commands/keys.ts
+++ b/src/shared/commands/keys.ts
@@ -41,6 +41,22 @@ export interface RecordedKey {
   modifiers: string
 }
 
+/** A key the operating system keeps for itself, so Orbit never receives it (KS-03). */
+export interface SystemClash {
+  /** The binding, written as `canonicalAccelerator` writes it. */
+  accel: string
+  /** What has it, e.g. "Mission Control: Switch to Desktop 1". */
+  owner: string
+}
+
+/** The Go to Tab options (TB-04, FV-10, ST-08). */
+export interface TabNumberOptions {
+  /** ⌘1–⌘8 count Favorites first. */
+  countFavorites?: boolean
+  /** ⌘9 goes to the last item (true) or the ninth (false). */
+  lastTabOnCmd9?: boolean
+}
+
 export interface KeyCommands {
   /** Gives an action a binding (KS-01, ST-08). See BindRequest. */
   'keys.bind': { args: BindRequest; result: BindResult }
@@ -57,4 +73,8 @@ export interface KeyCommands {
   'keys.record': { args: { on: boolean }; result: void }
   /** Who gets the action's keys first when a page also handles them (KS-02). */
   'keys.setPriority': { args: { actionId: string; priority: ShortcutPriority }; result: void }
+  /** The Go to Tab options of Settings → Shortcuts (ST-08). */
+  'keys.setOptions': { args: TabNumberOptions; result: void }
+  /** Keys the operating system keeps, so Orbit never receives them (KS-03): shown in Settings → Shortcuts. */
+  'keys.systemClashes': { args: Record<string, never>; result: SystemClash[] }
 }
diff --git a/tests/e2e/keys.spec.ts b/tests/e2e/keys.spec.ts
index c57772f2..93b36c93 100644
--- a/tests/e2e/keys.spec.ts
+++ b/tests/e2e/keys.spec.ts
@@ -407,6 +407,20 @@ test('[KS-16][NV-01] in a page text field, ⌘[ / Alt+← goes back only when th
   await expect.poll(async () => (await state(app)).tabs[id]?.url).toBe(fx.url('/page/FieldA'))
 })
 
+test('[KS-02][KS-16] while a page is on its way, Orbit takes its keys at once: ⌘S / Ctrl+S toggles the sidebar, and ⌘[ / Alt+← in a text field goes back', async () => {
+  const { app } = orbit
+  const [key, mods] = isMac ? (['[', ['meta']] as const) : (['Left', ['alt']] as const)
+  const id = await openTab(app, fx.url('/page/WayA'))
+  await visit(app, id, fx.url('/page/WayB'))
+  const b = await tabPage(app, '/page/WayB')
+  await b.focus('#box')
+  await slowLoad(id, '/slow/WayC')
+  await pressInPage(app, '/page/WayB', 's', [isMac ? 'meta' : 'control'])
+  await expect.poll(sidebarVisible).toBe(false)
+  await pressInPage(app, '/page/WayB', key, [...mods])
+  await expect.poll(async () => (await state(app)).tabs[id]?.url).toBe(fx.url('/page/WayA'))
+})
+
 /**
  * Waits until main has had the answers to every page script it sent `urlPart`'s page before now:
  * the page answers in order.
@@ -442,3 +456,227 @@ test('[KS-16][TB-18] ⌘Z / Ctrl+Z in a page text field undoes the typing, not t
   await pressInPage(app, '/page/Typing', 'z', [mod])
   await expect.poll(async () => (await urls()).sort()).toEqual([fx.url('/page/Typing'), fx.url('/page/UndoB')].sort())
 })
+
+// ---------- Tab, window, split and overlay keys (KS-05, KS-06, KS-09, KS-19) ----------
+
+type Mod = 'shift' | 'control' | 'alt' | 'meta'
+
+/** Key events, each sent to whatever has the keyboard at that moment, as the keyboard does. */
+function keyEvents(events: [type: 'keyDown' | 'keyUp', keyCode: string, modifiers: Mod[]][]): Promise<void> {
+  return orbit.app.evaluate(({ webContents }, list) => {
+    for (const [type, keyCode, modifiers] of list) {
+      webContents.getFocusedWebContents()?.sendInputEvent({ type, keyCode, modifiers })
+    }
+  }, events)
+}
+
+/** Selects a tab and gives its page the keyboard. */
+async function selectPage(tabId: string, url: string): Promise<void> {
+  await cmd(orbit.app, 'tabs.activate', { tabId })
+  await cmd(orbit.app, 'tabs.focusPage', {})
+  await expect.poll(focusedUrl).toBe(url)
+}
+
+/** The active tab of the first window. */
+async function activeTab(): Promise<string | undefined> {
+  const win = Object.values((await state(orbit.app)).windows)[0]
+  return win?.activeTab[win.spaceId] ?? undefined
+}
+
+test('[KS-05][PN-02][TB-07] from a page: ⌘D pins a Today tab and ⌘D again puts it back on top of Today; ⌘⇧T after ⌘W restores a closed tab in its place', async () => {
+  const { app } = orbit
+  const spaceId = await activeSpace(app)
+  const today = async () => (await state(app)).spaces[spaceId]?.today ?? []
+  const pinned = async () => (await state(app)).spaces[spaceId]?.pinned ?? []
+  const c = await openTab(app, fx.url('/page/Third'))
+  const b = await openTab(app, fx.url('/page/Second'))
+  const a = await openTab(app, fx.url('/page/First'))
+  expect(await today()).toEqual([a, b, c])
+  await selectPage(b, fx.url('/page/Second'))
+  await pressMod('D')
+  await expect.poll(pinned).toEqual([b])
+  expect(await today()).toEqual([a, c])
+  await pressMod('D')
+  await expect.poll(today).toEqual([b, a, c])
+  expect(await pinned()).toEqual([])
+  // The bottom tab closes and comes back where it was, selected.
+  await selectPage(c, fx.url('/page/Third'))
+  await pressMod('W')
+  await expect.poll(today).toEqual([b, a])
+  // The keyboard is somewhere else now (the next selected tab).
+  await expect
+    .poll(async () => {
+      const url = await focusedUrl()
+      return !!url && url !== fx.url('/page/Third')
+    })
+    .toBe(true)
+  await pressMod('T', true)
+  await expect.poll(async () => (await today()).length).toBe(3)
+  const back = (await today())[2] as string
+  expect((await state(app)).tabs[back]?.url).toBe(fx.url('/page/Third'))
+  await expect.poll(activeTab).toBe(back)
+})
+
+test('[KS-06][TB-04][FV-10] from a page, with 2 Favorites, 1 pinned and 2 Today tabs: ⌘3 is the pinned tab, ⌘9 the last Today tab, ⌘⌥↓ goes on to the first Today tab, the ⌘⇧] / Ctrl+PgDn aliases step too, and ⌘9 can be the ninth item', async () => {
+  const { app } = orbit
+  const spaceId = await activeSpace(app)
+  const favorites = { kind: 'favorites', profileId: 'p-default' }
+  await cmd(app, 'tabs.create', { url: fx.url('/page/Fav1'), container: favorites, activate: false })
+  await cmd(app, 'tabs.create', { url: fx.url('/page/Fav2'), container: favorites, activate: false })
+  const pin = await cmd<string>(app, 'tabs.create', {
+    url: fx.url('/page/Pin'),
+    container: { kind: 'pinned', spaceId },
+    activate: false,
+  })
+  const last = await openTab(app, fx.url('/page/TodayLast'))
+  const first = await openTab(app, fx.url('/page/TodayFirst'))
+  await selectPage(first, fx.url('/page/TodayFirst'))
+  const mod: Mod = isMac ? 'meta' : 'control'
+  await pressMod('3')
+  await expect.poll(activeTab).toBe(pin)
+  await pressMod('9')
+  await expect.poll(activeTab).toBe(last)
+  await selectPage(pin, fx.url('/page/Pin'))
+  await pressAnywhere('Down', [mod, 'alt'])
+  await expect.poll(activeTab).toBe(first)
+  await expect.poll(focusedUrl).toBe(fx.url('/page/TodayFirst'))
+  if (isMac) await pressAnywhere(']', ['meta', 'shift'])
+  else await pressAnywhere('PageDown', ['control'])
+  await expect.poll(activeTab).toBe(last)
+  await expect.poll(focusedUrl).toBe(fx.url('/page/TodayLast'))
+  if (isMac) await pressAnywhere('[', ['meta', 'shift'])
+  else await pressAnywhere('PageUp', ['control'])
+  await expect.poll(activeTab).toBe(first)
+  // With eleven items, ⌘9 is the last one, or the ninth when set so (Settings → Shortcuts).
+  const more: string[] = []
+  for (let n = 1; n <= 6; n++) {
+    more.push(await cmd<string>(app, 'tabs.create', { url: fx.url(`/page/More${n}`), activate: false }))
+  }
+  await expect.poll(focusedUrl).toBe(fx.url('/page/TodayFirst'))
+  await pressMod('9')
+  await expect.poll(activeTab).toBe(last)
+  await cmd(app, 'keys.setOptions', { lastTabOnCmd9: false })
+  await expect.poll(focusedUrl).toBe(fx.url('/page/TodayLast'))
+  await pressMod('9')
+  // Favorites 1–2, pinned 3, then Today from the top: More6 … More1, TodayFirst, TodayLast.
+  await expect.poll(activeTab).toBe(more[0])
+})
+
+test('[KS-06][TB-05] holding ⌃: Tab and ⇧Tab step through recent tabs, W closes the highlighted one and switching goes on from the next, and letting go settles', async () => {
+  const { app } = orbit
+  const a = await openTab(app, fx.url('/page/RecentA'))
+  const b = await openTab(app, fx.url('/page/RecentB'))
+  const c = await openTab(app, fx.url('/page/RecentC'))
+  const d = await openTab(app, fx.url('/page/RecentD'))
+  // Most recent first: D, A, C, B. The sidebar shows D, C, B, A.
+  await selectPage(a, fx.url('/page/RecentA'))
+  await selectPage(d, fx.url('/page/RecentD'))
+  const ctrl: Mod[] = ['control']
+  const tab = (mods: Mod[]): [type: 'keyDown' | 'keyUp', keyCode: string, modifiers: Mod[]][] => [
+    ['keyDown', 'Tab', mods],
+    ['keyUp', 'Tab', mods],
+  ]
+  await keyEvents([['keyDown', 'Control', ctrl], ...tab(ctrl)])
+  await expect.poll(activeTab).toBe(a)
+  await keyEvents(tab(ctrl))
+  await expect.poll(activeTab).toBe(c)
+  await keyEvents([['keyDown', 'Shift', ['control', 'shift']], ...tab(['control', 'shift']), ['keyUp', 'Shift', ctrl]])
+  await expect.poll(activeTab).toBe(a)
+  // W closes A; C, next in the switcher, is highlighted in its place.
+  await keyEvents([
+    ['keyDown', 'W', ctrl],
+    ['keyUp', 'W', ctrl],
+  ])
+  await expect.poll(async () => (await state(app)).tabs[a]).toBeUndefined()
+  await expect.poll(activeTab).toBe(c)
+  await keyEvents(tab(ctrl))
+  await expect.poll(activeTab).toBe(b)
+  await keyEvents([['keyUp', 'Control', []]])
+  // Settled on B: a quick ⌃Tab goes back to D, the tab used before it.
+  await keyEvents([['keyDown', 'Control', ctrl], ...tab(ctrl), ['keyUp', 'Control', []]])
+  await expect.poll(activeTab).toBe(d)
+  expect(Object.keys((await state(app)).tabs).sort()).toEqual([b, c, d].sort())
+})
+
+test('[KS-09][SV-02][SV-16] from a page: ⌃⇧= then Enter on a result shows two panes, ⌃⇧1 focuses the left pane, ⌃⇧] and ⌃⇧[ step, and ⌃⇧− closes the focused pane', async () => {
+  const { app, shell } = orbit
+  const left = await openTab(app, fx.url('/page/LeftPane'))
+  await selectPage(left, fx.url('/page/LeftPane'))
+  const split: Mod[] = ['control', 'shift']
+  await pressAnywhere('=', split)
+  const input = (await viewPage(app, 'overlay')).getByTestId('command-input')
+  await expect(input).toBeFocused()
+  await input.fill(fx.url('/page/RightPane'))
+  await input.press('Enter')
+  await expect(shell.getByTestId('split-row').getByTestId('split-segment')).toHaveCount(2)
+  const right = (await activeTab()) as string
+  expect(right).not.toBe(left)
+  await expect.poll(focusedUrl).toBe(fx.url('/page/RightPane'))
+  await pressAnywhere('1', split)
+  await expect.poll(activeTab).toBe(left)
+  await expect.poll(focusedUrl).toBe(fx.url('/page/LeftPane'))
+  await pressAnywhere(']', split)
+  await expect.poll(activeTab).toBe(right)
+  await expect.poll(focusedUrl).toBe(fx.url('/page/RightPane'))
+  await pressAnywhere('[', split)
+  await expect.poll(activeTab).toBe(left)
+  await expect.poll(focusedUrl).toBe(fx.url('/page/LeftPane'))
+  await pressAnywhere('-', split)
+  await expect.poll(async () => (await state(app)).tabs[left]).toBeUndefined()
+  await expect.poll(activeTab).toBe(right)
+})
+
+test('[KS-19][PK-09][NV-04] with a Peek open, Esc closes the Peek and the tab under it keeps loading', async () => {
+  const { app } = orbit
+  const id = await openTab(app, fx.url('/page/Under'))
+  await slowLoad(id, '/slow/UnderNext')
+  await cmd(app, 'peek.open', { url: fx.url('/page/Peeked') })
+  await expect.poll(focusedUrl).toBe(fx.url('/page/Peeked'))
+  await pressAnywhere('Escape')
+  await expect.poll(async () => Object.values((await state(app)).windows)[0]?.overlay.kind).toBe('none')
+  expect((await state(app)).tabs[id]?.loading).toBe(true)
+  await finishLoad(id, '/slow/UnderNext')
+})
+
+test('[KS-05][TB-12][TB-11] Rename Tab, Move Tab to Space… and Archive Tab have no keys until given some, then work from a page', async () => {
+  const { app, shell } = orbit
+  const spaceId = await activeSpace(app)
+  await createSpace(app, { name: 'Other', activate: false })
+  for (const [actionId, accel] of [
+    ['tab.rename', 'F2'],
+    ['tab.pickSpace', 'F7'],
+    ['tab.archive', 'F8'],
+  ]) {
+    expect(await run(app, 'keys.bind', { actionId, accel })).toEqual({ ok: true })
+  }
+  const id = await cmd<string>(app, 'tabs.create', {
+    url: fx.url('/page/Named'),
+    container: { kind: 'pinned', spaceId },
+  })
+  await expect.poll(async () => (await state(app)).tabs[id]?.loading).toBe(false)
+  await selectPage(id, fx.url('/page/Named'))
+  // Renaming shows a hidden sidebar: the name is edited in the tab's row.
+  await action(app, 'sidebar.toggle')
+  await expect.poll(sidebarVisible).toBe(false)
+  await pressAnywhere('F2')
+  await expect.poll(sidebarVisible).toBe(true)
+  const field = shell.getByTestId('rename-field')
+  await expect(field).toBeFocused()
+  await field.fill('Mine')
+  await field.press('Enter')
+  await expect(shell.locator(`[data-testid="tab-row"][data-tab-id="${id}"]`).getByTestId('tab-title')).toHaveText(
+    'Mine',
+  )
+  await selectPage(id, fx.url('/page/Named'))
+  await pressAnywhere('F7')
+  const overlay = await viewPage(app, 'overlay')
+  await expect(overlay.getByTestId('command-input')).toHaveValue('Move to ')
+  await expect(overlay.getByTestId('command-result').first().getByTestId('command-result-title')).toHaveText(
+    'Move to Other',
+  )
+  await overlay.getByTestId('command-input').press('Escape')
+  await selectPage(id, fx.url('/page/Named'))
+  await pressAnywhere('F8')
+  await expect.poll(async () => (await state(app)).spaces[spaceId]?.pinned).toEqual([])
+  expect((await state(app)).archive.at(-1)?.url).toBe(fx.url('/page/Named'))
+})
diff --git a/tests/unit/keymap-defaults.test.ts b/tests/unit/keymap-defaults.test.ts
index ec018ce4..c8ff81a4 100644
--- a/tests/unit/keymap-defaults.test.ts
+++ b/tests/unit/keymap-defaults.test.ts
@@ -29,6 +29,10 @@ const TABLE: [id: string, mac: string[], other: string[]][] = [
   ['focus.cycle', ['F6'], ['F6']],
   ['tab.duplicate', [], []],
   ['tab.resetToPinned', [], []],
+  ['tab.rename', [], []],
+  ['tab.pickSpace', [], []],
+  ['tab.archive', [], []],
+  ['tab.favorite', [], []],
   // KS-06
   ...[1, 2, 3, 4, 5, 6, 7, 8, 9].map((n): [string, string[], string[]] => [
     `tab.goto.${n}`,
diff --git a/tests/unit/keymap-system.test.ts b/tests/unit/keymap-system.test.ts
new file mode 100644
index 00000000..bd40af46
--- /dev/null
+++ b/tests/unit/keymap-system.test.ts
@@ -0,0 +1,70 @@
+import { describe, expect, it } from 'vitest'
+import { gnomeAccelerator, gnomeClashes, missionControlClashes } from '../../src/main/keys/system'
+
+/**
+ * Keys the operating system keeps (KS-03, ST-08): what Settings → Shortcuts reads from macOS's
+ * Mission Control settings and GNOME's window manager keys.
+ */
+
+/** One entry as `defaults read com.apple.symbolichotkeys AppleSymbolicHotKeys` prints it. */
+const entry = (id: number, enabled: number, key: number, mask: number) => `    ${id} =     {
+        enabled = ${enabled};
+        value =         {
+            parameters =             (
+                65535,
+                ${key},
+                ${mask}
+            );
+            type = standard;
+        };
+    };`
+
+describe('[KS-03][ST-08] Mission Control desktop keys', () => {
+  it('reads the Switch to Desktop keys that are turned on', () => {
+    const plist = [
+      '{',
+      entry(32, 1, 126, 8650752), // Mission Control itself: not a desktop key
+      entry(118, 1, 18, 262144), // Desktop 1: ⌃1
+      entry(119, 1, 19, 262144), // Desktop 2: ⌃2
+      entry(120, 0, 20, 262144), // Desktop 3: turned off
+      entry(121, 1, 21, 262144 + 131072), // Desktop 4: ⌃⇧4
+      entry(126, 1, 25, 524288), // Desktop 9: ⌥9
+      '}',
+    ].join('\n')
+    expect(missionControlClashes(plist)).toEqual([
+      { accel: 'Ctrl+1', owner: 'Mission Control: Switch to Desktop 1' },
+      { accel: 'Ctrl+2', owner: 'Mission Control: Switch to Desktop 2' },
+      { accel: 'Ctrl+Shift+4', owner: 'Mission Control: Switch to Desktop 4' },
+      { accel: 'Alt+9', owner: 'Mission Control: Switch to Desktop 9' },
+    ])
+  })
+
+  it('reads nothing from an empty or unreadable answer', () => {
+    expect(missionControlClashes('')).toEqual([])
+    expect(missionControlClashes('The domain/default pair does not exist')).toEqual([])
+  })
+})
+
+describe('[KS-03][ST-08] GNOME workspace keys', () => {
+  it('turns GNOME accelerators into bindings Orbit could have had', () => {
+    expect(gnomeAccelerator('<Control><Alt>Left')).toBe('Ctrl+Alt+Left')
+    expect(gnomeAccelerator('<Primary><Alt>Page_Down')).toBe('Ctrl+Alt+PageDown')
+    expect(gnomeAccelerator('<Shift><Control><Alt>Right')).toBe('Ctrl+Alt+Shift+Right')
+    // Super is a key Orbit never binds; a bare key isn't a shortcut.
+    expect(gnomeAccelerator('<Super>Page_Up')).toBeUndefined()
+    expect(gnomeAccelerator('Left')).toBeUndefined()
+  })
+
+  it('lists every workspace key gsettings reports, with what it does', () => {
+    expect(
+      gnomeClashes({
+        'switch-to-workspace-left': "['<Super>Page_Up', '<Control><Alt>Left']\n",
+        'switch-to-workspace-right': "['<Super>Page_Down', '<Control><Alt>Right']\n",
+        'move-to-workspace-left': '@as []\n',
+      }),
+    ).toEqual([
+      { accel: 'Ctrl+Alt+Left', owner: 'GNOME: Switch to workspace on the left' },
+      { accel: 'Ctrl+Alt+Right', owner: 'GNOME: Switch to workspace on the right' },
+    ])
+  })
+})

From df416679f8e515ef4c954f9b07b95ef122edceaf Mon Sep 17 00:00:00 2001
From: Siya <57148521+siyabendoezdemir@users.noreply.github.com>
Date: Sat, 10 Oct 2026 16:31:20 +0000
Subject: [PATCH 06/11] =?UTF-8?q?feat(keys):=20Settings=20=E2=86=92=20Shor?=
 =?UTF-8?q?tcuts:=20search,=20record,=20conflicts,=20reset,=20priorities?=
 =?UTF-8?q?=20and=20Go=20to=20Tab=20options=20(ST-08)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Settings gets a Shortcuts section, added through the section registry. It lists every action main
has registered, grouped, with a search by name, search words or keys. Click a key and press the new
one: the router records it (keys.record), so Orbit's own keys run nothing while Settings listens.
Esc cancels, Backspace removes the binding, + adds another (up to five). A key another action has
opens a dialog offering Swap (when replacing) or Remove from the other action. Right-click an action
for Reset to Default, Remove Shortcut and Prefer Websites / Prefer Orbit (KS-02). Reset All asks
first. Also on the page: the Go to Tab options (Include Favorites, the last or ninth item on ⌘9), and
keys the system keeps marked on their rows (KS-03). keys.available names the registered actions;
settings.shortcuts opens the section from the command bar (KS-12).

The right-click menu closes when the list under it moves, not on a late scroll event from a scroll
made just before it opened.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 FEATURES.md                                  |  10 +-
 docs/feature-status.json                     |   7 +-
 src/main/keys/bindings.ts                    |  11 +-
 src/main/keys/index.ts                       |   2 +
 src/renderer/src/keys/ShortcutsPage.tsx      | 702 +++++++++++++++++++
 src/renderer/src/keys/live.ts                |  11 +
 src/renderer/src/keys/shortcut-list.ts       | 139 ++++
 src/renderer/src/keys/shortcuts.css          | 209 ++++++
 src/renderer/src/keys/shortcuts.settings.tsx |  13 +
 src/renderer/src/shortcuts.ts                |   5 +-
 src/shared/commands/keys.ts                  |   2 +
 src/shared/commands/settings.ts              |   8 +
 src/shared/keymap.ts                         |   3 +
 tests/e2e/keys.spec.ts                       | 157 +++++
 tests/unit/keymap-settings.test.ts           |  84 +++
 15 files changed, 1350 insertions(+), 13 deletions(-)
 create mode 100644 src/renderer/src/keys/ShortcutsPage.tsx
 create mode 100644 src/renderer/src/keys/shortcut-list.ts
 create mode 100644 src/renderer/src/keys/shortcuts.css
 create mode 100644 src/renderer/src/keys/shortcuts.settings.tsx
 create mode 100644 tests/unit/keymap-settings.test.ts

diff --git a/FEATURES.md b/FEATURES.md
index f538ab79..08eab06a 100644
--- a/FEATURES.md
+++ b/FEATURES.md
@@ -4,7 +4,7 @@
 
 Every row is one behaviour from the clean-room spec. Status per ID: **spec’d** (every row) → **built** → **tested** (a unit or e2e test names the ID) → **feels right** (lead sign-off after a hands-on review against `feel.md`).
 
-**Totals:** 475 spec’d · 205 built (75 partial) · 291 tested · 0 feel right. 10 more are out of scope and not counted.
+**Totals:** 475 spec’d · 205 built (76 partial) · 291 tested · 0 feel right. 10 more are out of scope and not counted.
 
 | Priority | Spec’d | Built | Tested |
 |---|---|---|---|
@@ -346,9 +346,9 @@ Spec: `spec/shortcuts.md`
 
 | ID | Feature | P | Built | Tested | Feels right | Notes |
 |---|---|---|---|---|---|---|
-| KS-01 | One keymap, remapping and persistence | P0 | 🟡 partial | ✅ e2e+unit | – | one keymap keyed by action id (src/shared/actions.ts + src/shared/keymap.ts): the key router, macOS menu bar (rebuilt on a remap), tooltips and command-bar rows read the live bindings; remap, several bindings per action (up to 5), none (command bar and menus still run it), a modifier required except F1-F12, system keys refused, conflicts reported (clear or swap), reset; stored per device in settings.shortcuts, cleaned on load, kept across a restart (Space keys too); the Settings → Shortcuts page comes with ST-08 |
-| KS-02 | Conflicts with web pages ("prefer websites" vs "prefer Orbit") | P0 | 🟡 partial | ✅ e2e+unit | – | who gets a key first, per action: Toggle Sidebar (Cmd+S / Ctrl+S, SB-11) prefers websites on every platform, Copy URL (Ctrl+Shift+C, NV-17) on Windows/Linux, every other action prefers Orbit (the page never sees the key); with prefer websites the page's main frame gets the first press: left alone, the action runs; used (preventDefault), a toast offers the action and a second press within a second runs it; a held key's repeats stay the page's; a press into a frame Orbit can't see into counts as used; while a page's main frame loads, Orbit takes the keys at once (Electron runs no isolated-world script in a loading page, so the page can't say in time what it did); keys.setPriority changes it (the Settings → Shortcuts option comes with ST-08); Esc leaving page full screen keeps Chromium's rule and nothing holds Cmd+E yet |
-| KS-03 | Platform mapping rules | P0 | 🟡 partial | ✅ e2e+unit | – | every default checked against the spec tables on macOS, Windows and Linux (unit test): ⌘ → Ctrl, ⌥ → Alt, ⌃ keys (⌃Tab, the split keys) stay Ctrl; the Windows/Linux exceptions Alt+1–9 for Spaces, Ctrl+H, Alt+←/→, Alt+D, F5, F3, Ctrl+F4 and F1; Alt+F4 and Alt+F are kept for the system; a Ctrl+Alt key that typed an AltGr character acts only outside text fields; letters and symbols follow the layout; F11 / Alt+Shift+F come with full screen (KS-08); the Linux desktop-clash hint and the macOS Mission Control hint come with ST-08 |
+| KS-01 | One keymap, remapping and persistence | P0 | 🟡 partial | ✅ e2e+unit | – | one keymap keyed by action id (src/shared/actions.ts + src/shared/keymap.ts): the key router, macOS menu bar (rebuilt on a remap), tooltips and command-bar rows read the live bindings; remap, several bindings per action (up to 5), none (command bar and menus still run it), a modifier required except F1-F12, system keys refused, conflicts reported (clear or swap), reset; stored per device in settings.shortcuts, cleaned on load, kept across a restart (Space keys too); Settings → Shortcuts (ST-08) lists every action with a search, records new keys on a click and resets on right-click; the shortcut sheet (OB-12) to come |
+| KS-02 | Conflicts with web pages ("prefer websites" vs "prefer Orbit") | P0 | 🟡 partial | ✅ e2e+unit | – | who gets a key first, per action: Toggle Sidebar (Cmd+S / Ctrl+S, SB-11) prefers websites on every platform, Copy URL (Ctrl+Shift+C, NV-17) on Windows/Linux, every other action prefers Orbit (the page never sees the key); with prefer websites the page's main frame gets the first press: left alone, the action runs; used (preventDefault), a toast offers the action and a second press within a second runs it; a held key's repeats stay the page's; a press into a frame Orbit can't see into counts as used; while a page's main frame loads, Orbit takes the keys at once (Electron runs no isolated-world script in a loading page, so the page can't say in time what it did); Settings → Shortcuts sets it per action (right-click → Prefer Websites / Prefer Orbit; a “Websites first” tag on the row); Esc leaving page full screen keeps Chromium's rule and nothing holds Cmd+E yet |
+| KS-03 | Platform mapping rules | P0 | 🟡 partial | ✅ e2e+unit | – | every default checked against the spec tables on macOS, Windows and Linux (unit test): ⌘ → Ctrl, ⌥ → Alt, ⌃ keys (⌃Tab, the split keys) stay Ctrl; the Windows/Linux exceptions Alt+1–9 for Spaces, Ctrl+H, Alt+←/→, Alt+D, F5, F3, Ctrl+F4 and F1; Alt+F4 and Alt+F are kept for the system; a Ctrl+Alt key that typed an AltGr character acts only outside text fields; letters and symbols follow the layout; F11 / Alt+Shift+F come with full screen (KS-08); keys the system keeps (macOS Mission Control “Switch to Desktop N” ⌃1–⌃9 when turned on, GNOME’s workspace keys) are marked in Settings → Shortcuts, which says where to turn them off; no first-run suggestion |
 | KS-04 | Command bar and address | P0 | ✅ | ✅ e2e+unit | – | ⌘T/⌘L/Alt+D, Esc, ⌘T/⌘L again, ↑/↓ (⌃N/⌃P), Enter, Tab, ⌫, ⇧Enter (option), ⌘⌥⌫ / Shift+Delete, ⌘⌥V |
 | KS-05 | Tabs and windows | P0 | 🟡 partial | ✅ e2e+unit | – | ⌘N, ⌘⇧N, ⌘⌥N, ⌘W / Ctrl+W / Ctrl+F4, ⌘⇧W / Ctrl+Shift+W (closes the window, or the Mini Window, Settings or onboarding window that has focus; Alt+F4 is the system's), ⌘⇧T (a closed tab comes back in its place), ⌘D (pins; again, back to the top of Today), ⌘⇧C, ⌘⇧⌥C, ⌘S, ⌘⇧K, ⌘⇧E, F6 (keyboard between the sidebar and the page), tested from a page; Duplicate Tab, Reset Tab, Rename Tab (shows a hidden sidebar to edit the name), Archive Tab, Move Tab to Space… (the command bar on its Move to rows) and Favorite This Tab have no keys until the user gives them some; ⌘Z (sidebar undo) is not remappable yet; the blank window (⌃⌘N, TB-17) and the top toolbar (⌘⇧D, SB-17) are not built |
 | KS-06 | Switching tabs | P0 | ✅ | ✅ e2e+unit | – | ⌘1–⌘8 / Ctrl+1–8 (Favorites counted first unless turned off), ⌘9 / Ctrl+9 the last item or, set so, the ninth, ⌘⌥↓/↑ / Ctrl+Alt+↓/↑ and the ⌘⇧] / ⌘⇧[ (Ctrl+PgDn / Ctrl+PgUp) aliases, all tested from a page; while ⌃ is held, Tab and ⇧Tab (⌃` on macOS) step through recent tabs, W closes the highlighted tab (the next one in the switcher takes its place) and letting go settles; the switcher has no on-screen list yet (TB-05) |
@@ -542,7 +542,7 @@ Spec: `spec/settings.md`
 | ST-05 | Per-profile: auto-archive timing | P1 | ✅ | ✅ e2e+unit | – | 12 hours (default), 24 hours, 7 days, 30 days per profile; no Never; other profiles follow Default until set |
 | ST-06 | Per-profile: default search engine and custom engines | P0 | ✅ | ✅ e2e+unit | – | per-profile default engine (8 built-ins), custom engines with keyword and %s URL, Make default from the row menu; no extension override in Electron, so that row does not exist |
 | ST-07 | Per-profile: download location, new-document app, data shortcuts | P1 | – | – | – |  |
-| ST-08 | Shortcuts section (remapping) | P1 | – | ✅ e2e+unit | – |  |
+| ST-08 | Shortcuts section (remapping) | P1 | 🟡 partial | ✅ e2e+unit | – | Settings → Shortcuts: every action Orbit has (the action table, as main registers it) in groups with a search by name, search words or keys; click a key, press the new one (a modifier first except F1–F12; system and reserved keys refused, with the reason); + adds another (up to 5), ⌫ while listening removes one, Esc cancels; a key another action has asks: Swap (when replacing) or Remove from the other; right-click: Reset to Default, Remove Shortcut, Prefer Websites / Prefer Orbit (KS-02); Reset All asks first; Go to Tab: Include Favorites in ordering and ⌘9 last or ninth item; actions with no keys (Duplicate Tab…) show Record Shortcut; keys the system keeps are marked (KS-03); Settings search finds rows; stored per device. Not built: the Esc → exit full screen row, which comes when full screen (NV-20) registers that as an action |
 | ST-09 | Links section | P1 | ✅ | ✅ e2e+unit | – | links from other apps open in a Mini Window (default), the most recent Space or one Space; routing rules (address contains / is exactly → a Space; first match wins; add, edit, reorder, remove); Peek options |
 | ST-10 | Advanced section | P1 | 🟡 partial | ✅ e2e+unit | – | tab sleep timer (TB-16), picture in picture, graphics acceleration; no site customizations, full-URL toggle, sounds or haptics, or edge-drag settings because those features don't exist yet |
 | ST-11 | Appearance section | P1 | 🟡 partial | ✅ e2e | – | Theme mode: Light / Dark / Match system (AP-01). Not built: window material (AP-10, Windows), app icon (AP-09), page defaults (P2) |
diff --git a/docs/feature-status.json b/docs/feature-status.json
index 07a1df12..42eb15f8 100644
--- a/docs/feature-status.json
+++ b/docs/feature-status.json
@@ -137,10 +137,10 @@
   "KS-07": {"built": "yes", "note": "Space shortcuts wired through the action table"},
   "KS-19": {"built": "partial", "note": "the open overlay takes its keys first: command bar (⌘T/⌘L/⌘W/Esc), find bar (Enter/⇧Enter/Esc, NV-05), Peek (Esc, ⌘O, ⌘W, PK-09; Esc closes the Peek and the tab under it keeps loading), the recent-tab switcher (Tab/⇧Tab/`, W, letting go of ⌃), permission prompt and site controls (Esc), the sidebar with keyboard focus (arrows, Enter, Esc back to the page, SB-22); Esc then stops a loading page, as before, even one that uses Esc itself: Electron runs no isolated-world script in a page while it loads, so Orbit can't learn in time whether the page used the key (needs a lead decision: a script in the page's own world or a preload channel, D40)"},
   "KS-16": {"built": "yes", "note": "typed keys never go astray: a page or Orbit view that loads (a slow page, a background tab, a reload) no longer takes the keyboard from the command bar, a sidebar field or the page in front (focus-on-navigation off for every web contents Orbit makes); ⌘←/⌘→ act outside text fields only; ⌘[ / ⌘] (Alt+←/→) from a page's text field go back or forward only when the page leaves them alone (a press into a frame Orbit can't see into stays the page's); ⌘Z in a page field is the page's undo (tabs lane, tested here); no shortcut on a plain key runs while an input method composes (unit test: e2e can't drive a composition through the key router)"},
-  "KS-01": {"built": "partial", "note": "one keymap keyed by action id (src/shared/actions.ts + src/shared/keymap.ts): the key router, macOS menu bar (rebuilt on a remap), tooltips and command-bar rows read the live bindings; remap, several bindings per action (up to 5), none (command bar and menus still run it), a modifier required except F1-F12, system keys refused, conflicts reported (clear or swap), reset; stored per device in settings.shortcuts, cleaned on load, kept across a restart (Space keys too); the Settings → Shortcuts page comes with ST-08"},
-  "KS-02": {"built": "partial", "note": "who gets a key first, per action: Toggle Sidebar (Cmd+S / Ctrl+S, SB-11) prefers websites on every platform, Copy URL (Ctrl+Shift+C, NV-17) on Windows/Linux, every other action prefers Orbit (the page never sees the key); with prefer websites the page's main frame gets the first press: left alone, the action runs; used (preventDefault), a toast offers the action and a second press within a second runs it; a held key's repeats stay the page's; a press into a frame Orbit can't see into counts as used; while a page's main frame loads, Orbit takes the keys at once (Electron runs no isolated-world script in a loading page, so the page can't say in time what it did); keys.setPriority changes it (the Settings → Shortcuts option comes with ST-08); Esc leaving page full screen keeps Chromium's rule and nothing holds Cmd+E yet"},
+  "KS-01": {"built": "partial", "note": "one keymap keyed by action id (src/shared/actions.ts + src/shared/keymap.ts): the key router, macOS menu bar (rebuilt on a remap), tooltips and command-bar rows read the live bindings; remap, several bindings per action (up to 5), none (command bar and menus still run it), a modifier required except F1-F12, system keys refused, conflicts reported (clear or swap), reset; stored per device in settings.shortcuts, cleaned on load, kept across a restart (Space keys too); Settings → Shortcuts (ST-08) lists every action with a search, records new keys on a click and resets on right-click; the shortcut sheet (OB-12) to come"},
+  "KS-02": {"built": "partial", "note": "who gets a key first, per action: Toggle Sidebar (Cmd+S / Ctrl+S, SB-11) prefers websites on every platform, Copy URL (Ctrl+Shift+C, NV-17) on Windows/Linux, every other action prefers Orbit (the page never sees the key); with prefer websites the page's main frame gets the first press: left alone, the action runs; used (preventDefault), a toast offers the action and a second press within a second runs it; a held key's repeats stay the page's; a press into a frame Orbit can't see into counts as used; while a page's main frame loads, Orbit takes the keys at once (Electron runs no isolated-world script in a loading page, so the page can't say in time what it did); Settings → Shortcuts sets it per action (right-click → Prefer Websites / Prefer Orbit; a “Websites first” tag on the row); Esc leaving page full screen keeps Chromium's rule and nothing holds Cmd+E yet"},
   "KS-18": {"built": "partial", "note": "button tooltips (address, copy link, site controls, sidebar toggle, back/forward/reload, find, zoom, Library, Clear, Space dots, Peek, Mini Window Open in…), the empty-window hint, command-bar rows and macOS menu items follow a remap without a restart; context menus and the shortcut sheet (OB-12) to come"},
-  "KS-03": {"built": "partial", "note": "every default checked against the spec tables on macOS, Windows and Linux (unit test): ⌘ → Ctrl, ⌥ → Alt, ⌃ keys (⌃Tab, the split keys) stay Ctrl; the Windows/Linux exceptions Alt+1–9 for Spaces, Ctrl+H, Alt+←/→, Alt+D, F5, F3, Ctrl+F4 and F1; Alt+F4 and Alt+F are kept for the system; a Ctrl+Alt key that typed an AltGr character acts only outside text fields; letters and symbols follow the layout; F11 / Alt+Shift+F come with full screen (KS-08); the Linux desktop-clash hint and the macOS Mission Control hint come with ST-08"},
+  "KS-03": {"built": "partial", "note": "every default checked against the spec tables on macOS, Windows and Linux (unit test): ⌘ → Ctrl, ⌥ → Alt, ⌃ keys (⌃Tab, the split keys) stay Ctrl; the Windows/Linux exceptions Alt+1–9 for Spaces, Ctrl+H, Alt+←/→, Alt+D, F5, F3, Ctrl+F4 and F1; Alt+F4 and Alt+F are kept for the system; a Ctrl+Alt key that typed an AltGr character acts only outside text fields; letters and symbols follow the layout; F11 / Alt+Shift+F come with full screen (KS-08); keys the system keeps (macOS Mission Control “Switch to Desktop N” ⌃1–⌃9 when turned on, GNOME’s workspace keys) are marked in Settings → Shortcuts, which says where to turn them off; no first-run suggestion"},
   "KS-05": {"built": "partial", "note": "⌘N, ⌘⇧N, ⌘⌥N, ⌘W / Ctrl+W / Ctrl+F4, ⌘⇧W / Ctrl+Shift+W (closes the window, or the Mini Window, Settings or onboarding window that has focus; Alt+F4 is the system's), ⌘⇧T (a closed tab comes back in its place), ⌘D (pins; again, back to the top of Today), ⌘⇧C, ⌘⇧⌥C, ⌘S, ⌘⇧K, ⌘⇧E, F6 (keyboard between the sidebar and the page), tested from a page; Duplicate Tab, Reset Tab, Rename Tab (shows a hidden sidebar to edit the name), Archive Tab, Move Tab to Space… (the command bar on its Move to rows) and Favorite This Tab have no keys until the user gives them some; ⌘Z (sidebar undo) is not remappable yet; the blank window (⌃⌘N, TB-17) and the top toolbar (⌘⇧D, SB-17) are not built"},
   "KS-06": {"built": "yes", "note": "⌘1–⌘8 / Ctrl+1–8 (Favorites counted first unless turned off), ⌘9 / Ctrl+9 the last item or, set so, the ninth, ⌘⌥↓/↑ / Ctrl+Alt+↓/↑ and the ⌘⇧] / ⌘⇧[ (Ctrl+PgDn / Ctrl+PgUp) aliases, all tested from a page; while ⌃ is held, Tab and ⇧Tab (⌃` on macOS) step through recent tabs, W closes the highlighted tab (the next one in the switcher takes its place) and letting go settles; the switcher has no on-screen list yet (TB-05)"},
   "FL-13": {"built": "yes", "note": "strip of pages, 1:1 tracking, commit thresholds, settle/rubber-band springs, one-page slides for clicks and keys, reduced motion cross-fade"},
@@ -263,6 +263,7 @@
   "ST-20": {"built": "partial", "note": "per-profile rows carry the profile's name; download location, passwords and site permissions don't exist yet"},
   "AP-01": {"built": "yes", "note": "Light / Dark / Match system in Settings and the Space theme picker; about 200 ms cross-fade, no flash"},
   "OB-02": {"built": "yes", "note": "audit and e2e: no account UI anywhere, onboarding included; a first run sends nothing off the computer, with or without onboarding, except Chromium's spell-check dictionary download (see tests)"},
+  "ST-08": {"built": "partial", "note": "Settings → Shortcuts: every action Orbit has (the action table, as main registers it) in groups with a search by name, search words or keys; click a key, press the new one (a modifier first except F1–F12; system and reserved keys refused, with the reason); + adds another (up to 5), ⌫ while listening removes one, Esc cancels; a key another action has asks: Swap (when replacing) or Remove from the other; right-click: Reset to Default, Remove Shortcut, Prefer Websites / Prefer Orbit (KS-02); Reset All asks first; Go to Tab: Include Favorites in ordering and ⌘9 last or ninth item; actions with no keys (Duplicate Tab…) show Record Shortcut; keys the system keeps are marked (KS-03); Settings search finds rows; stored per device. Not built: the Esc → exit full screen row, which comes when full screen (NV-20) registers that as an action"},
   "ST-09": {"built": "yes", "note": "links from other apps open in a Mini Window (default), the most recent Space or one Space; routing rules (address contains / is exactly → a Space; first match wins; add, edit, reorder, remove); Peek options"},
   "ST-10": {"built": "partial", "note": "tab sleep timer (TB-16), picture in picture, graphics acceleration; no site customizations, full-URL toggle, sounds or haptics, or edge-drag settings because those features don't exist yet"},
   "ST-12": {"built": "partial", "note": "privacy promise (Orbit sends nothing); Clear browsing data per profile (⌘⇧⌫ / Ctrl+Shift+Delete): history by time range; cookies and site data, and the cache, always from all time (Electron has no range), so they start ticked only for All time; Secure DNS (Automatic, Off, Cloudflare, Google, Quad9); graphics acceleration lives in Advanced. No HTTPS-first or Safe Browsing (not in Electron), no per-site clearing here"},
diff --git a/src/main/keys/bindings.ts b/src/main/keys/bindings.ts
index 8e5d2317..094eeb93 100644
--- a/src/main/keys/bindings.ts
+++ b/src/main/keys/bindings.ts
@@ -7,7 +7,13 @@ import {
   defaultShortcutsFor,
 } from '../../shared/actions'
 import type { BindRequest, BindResult, ShortcutPriority } from '../../shared/commands/keys'
-import { bindingProblem, type CustomBindings, canonicalAccelerator, formatAccelerator } from '../../shared/keymap'
+import {
+  bindingProblem,
+  type CustomBindings,
+  canonicalAccelerator,
+  formatAccelerator,
+  MAX_BINDINGS,
+} from '../../shared/keymap'
 import type { Settings } from '../../shared/state'
 
 /**
@@ -16,8 +22,7 @@ import type { Settings } from '../../shared/state'
  * next one, which src/main/keys/index.ts saves.
  */
 
-/** Most bindings one action keeps (KS-01: aliases such as Back = ⌘[ and ⌘←). */
-export const MAX_BINDINGS = 5
+export { MAX_BINDINGS }
 
 type Bindings = Record<string, string[]>
 
diff --git a/src/main/keys/index.ts b/src/main/keys/index.ts
index 9d975823..1108ed0a 100644
--- a/src/main/keys/index.ts
+++ b/src/main/keys/index.ts
@@ -1,3 +1,4 @@
+import { ACTIONS } from '../../shared/actions'
 import type { BindResult, ShortcutPriority } from '../../shared/commands/keys'
 import { onKeymapChange, setCustomBindings } from '../../shared/keymap'
 import type { MainContext } from '../context'
@@ -73,6 +74,7 @@ export function registerKeys(ctx: MainContext): void {
       if (typeof lastTabOnCmd9 === 'boolean') d.settings.lastTabOnCmd9 = lastTabOnCmd9
     }),
   )
+  commands.register('keys.available', () => ACTIONS.filter((a) => ctx.actions.has(a.id)).map((a) => a.id))
   commands.register('keys.systemClashes', () => systemClashes())
   registerWindowKeys(ctx)
   registerTabKeys(ctx)
diff --git a/src/renderer/src/keys/ShortcutsPage.tsx b/src/renderer/src/keys/ShortcutsPage.tsx
new file mode 100644
index 00000000..8dac789e
--- /dev/null
+++ b/src/renderer/src/keys/ShortcutsPage.tsx
@@ -0,0 +1,702 @@
+import { Check, Lock, Plus, Search, X } from 'lucide-react'
+import {
+  memo,
+  type MouseEvent as ReactMouseEvent,
+  type ReactNode,
+  useCallback,
+  useEffect,
+  useLayoutEffect,
+  useMemo,
+  useRef,
+  useState,
+} from 'react'
+import { ACTIONS, ACTIONS_BY_ID, formatAccelerator, shortcutsFor } from '../../../shared/actions'
+import type { BindingConflict, BindResult, RecordedKey, ShortcutPriority } from '../../../shared/commands/keys'
+import { acceleratorFromInput, MAX_BINDINGS, modifiersOf } from '../../../shared/keymap'
+import { invoke } from '../api'
+import { Button, Dialog, Select, SettingGroup, SettingRow, Switch } from '../settings/controls'
+import { useMainValue } from '../settings/hooks'
+import { useOrbit } from '../store'
+import { setRecordingKeys, useKeymap } from './live'
+import {
+  clashesOf,
+  entryMatches,
+  formatModifiers,
+  type ShortcutEntry,
+  searchWords,
+  shortcutGroups,
+} from './shortcut-list'
+import './shortcuts.css'
+
+const platform = window.orbit.platform
+const mac = platform === 'darwin'
+const keys = (accel: string) => formatAccelerator(accel, platform)
+
+/** A binding being recorded: a new one for `actionId`, or one in place of `replace`. */
+interface Recording {
+  actionId: string
+  replace?: string
+  /** Modifiers held now ("Cmd+Shift"), shown while the user builds a combination. */
+  held: string
+  /** Tells one recording from the next, for answers that come back late. */
+  session: number
+}
+
+/** The keys asked for belong to another action: Settings asks what to do (ST-08). */
+interface Conflict {
+  actionId: string
+  accel: string
+  replace?: string
+  other: BindingConflict
+}
+
+function bindKeys(
+  actionId: string,
+  accel: string,
+  replace?: string,
+  onConflict?: 'clear' | 'swap',
+): Promise<BindResult> {
+  return invoke('keys.bind', {
+    actionId,
+    accel,
+    ...(replace ? { replace } : {}),
+    ...(onConflict ? { onConflict } : {}),
+  })
+}
+
+/**
+ * Recording a binding: main sends each key press in this window as `keys.recorded` and runs
+ * nothing while it records (src/main/keys/router.ts). Esc cancels, ⌫ / Delete removes the binding
+ * being changed; a press that makes a binding gives it to the action, or asks about a conflict.
+ */
+function useRecorder() {
+  const [recording, setRecording] = useState<Recording>()
+  const [problem, setProblem] = useState<{ actionId: string; text: string }>()
+  const [conflict, setConflict] = useState<Conflict>()
+  const current = useRef<Recording | undefined>(undefined)
+  const busy = useRef(false)
+  const sessions = useRef(0)
+
+  const update = useCallback((next: Recording | undefined) => {
+    current.current = next
+    setRecording(next)
+  }, [])
+
+  const stop = useCallback(() => {
+    if (!current.current) return
+    update(undefined)
+    setRecordingKeys(false)
+    void invoke('keys.record', { on: false })
+  }, [update])
+
+  const start = useCallback(
+    (actionId: string, replace?: string) => {
+      const was = current.current
+      setProblem(undefined)
+      setConflict(undefined)
+      update({ actionId, ...(replace ? { replace } : {}), held: '', session: ++sessions.current })
+      setRecordingKeys(true)
+      if (!was) void invoke('keys.record', { on: true })
+    },
+    [update],
+  )
+
+  const pressed = useCallback(
+    (key: RecordedKey) => {
+      const rec = current.current
+      if (!rec || busy.current) return
+      if (!key.accel) {
+        if (key.modifiers !== rec.held) update({ ...rec, held: key.modifiers })
+        return
+      }
+      const accel = key.accel
+      if (accel === 'Escape') return stop()
+      if (accel === 'Backspace' || accel === 'Delete') {
+        if (rec.replace) void invoke('keys.unbind', { actionId: rec.actionId, accel: rec.replace })
+        return stop()
+      }
+      busy.current = true
+      void bindKeys(rec.actionId, accel, rec.replace)
+        .then((result) => {
+          if (current.current?.session !== rec.session) return
+          if (result.ok) {
+            setProblem(undefined)
+            return stop()
+          }
+          if ('problem' in result) {
+            // Not a binding Orbit can use: say why and keep listening.
+            setProblem({ actionId: rec.actionId, text: result.problem })
+            update({ ...rec, held: '' })
+            return
+          }
+          stop()
+          setConflict({
+            actionId: rec.actionId,
+            accel,
+            ...(rec.replace ? { replace: rec.replace } : {}),
+            other: result.conflict,
+          })
+        })
+        .finally(() => {
+          busy.current = false
+        })
+    },
+    [stop, update],
+  )
+
+  const active = recording !== undefined
+  useEffect(() => {
+    if (!active) return
+    const offMain = window.orbit.on('keys.recorded', (payload) => pressed(payload as RecordedKey))
+    // Key presses main didn't take (synthetic input) are recorded the same way.
+    const fromPage = (e: KeyboardEvent) => {
+      e.preventDefault()
+      e.stopPropagation()
+      const input = { key: e.key, code: e.code, meta: e.metaKey, control: e.ctrlKey, alt: e.altKey, shift: e.shiftKey }
+      const accel = e.type === 'keydown' ? acceleratorFromInput(input) : undefined
+      pressed({ modifiers: modifiersOf(input), ...(accel ? { accel } : {}) })
+    }
+    // A click anywhere but on the binding being recorded stops recording.
+    const onPointer = (e: MouseEvent) => {
+      if (!(e.target instanceof Element) || !e.target.closest('[data-recording]')) stop()
+    }
+    window.addEventListener('keydown', fromPage, true)
+    window.addEventListener('keyup', fromPage, true)
+    document.addEventListener('mousedown', onPointer, true)
+    window.addEventListener('blur', stop)
+    return () => {
+      offMain()
+      window.removeEventListener('keydown', fromPage, true)
+      window.removeEventListener('keyup', fromPage, true)
+      document.removeEventListener('mousedown', onPointer, true)
+      window.removeEventListener('blur', stop)
+    }
+  }, [active, pressed, stop])
+  // Leaving the page (another section, a search, closing Settings) stops recording.
+  useEffect(() => stop, [stop])
+
+  const resolve = useCallback((c: Conflict, how: 'clear' | 'swap') => {
+    setConflict(undefined)
+    void bindKeys(c.actionId, c.accel, c.replace, how).then((result) => {
+      if (!result.ok && 'problem' in result) setProblem({ actionId: c.actionId, text: result.problem })
+    })
+  }, [])
+
+  return { recording, problem, conflict, start, stop, resolve, dismiss: () => setConflict(undefined) }
+}
+
+/** The first binding of an action as this platform shows it, or ''. */
+function firstKeys(actionId: string): string {
+  const action = ACTIONS_BY_ID[actionId]
+  const accel = action ? shortcutsFor(action, platform)[0] : undefined
+  return accel ? keys(accel) : ''
+}
+
+/**
+ * Settings → Shortcuts (ST-08): every action with its keys, a search, recording new keys,
+ * conflicts, Reset to Default and the per-action priority on right-click (KS-02), and the Go to
+ * Tab options (TB-04, FV-10).
+ */
+export function ShortcutsPage() {
+  const version = useKeymap()
+  const priorities = useOrbit((s) => s.settings.shortcutPriority)
+  const lastTabOnCmd9 = useOrbit((s) => s.settings.lastTabOnCmd9)
+  const countFavorites = useOrbit((s) => s.settings.countFavoritesInShortcuts)
+  const [clashes] = useMainValue(() => invoke('keys.systemClashes', {}))
+  // Only actions Orbit has: the table also names some that no feature runs yet.
+  const [available] = useMainValue(() => invoke('keys.available', {}))
+  const [query, setQuery] = useState('')
+  const [menu, setMenu] = useState<{ actionId: string; x: number; y: number }>()
+  const [confirmReset, setConfirmReset] = useState(false)
+  const recorder = useRecorder()
+  const { recording, problem, conflict, start, stop } = recorder
+
+  // biome-ignore lint/correctness/useExhaustiveDependencies: the keymap's version stands for the bindings
+  const groups = useMemo(() => {
+    if (!available) return []
+    const has = new Set(available)
+    return shortcutGroups(
+      platform,
+      { ...(priorities ? { priorities } : {}), lastTabOnCmd9 },
+      ACTIONS.filter((a) => has.has(a.id)),
+    )
+  }, [version, priorities, lastTabOnCmd9, available])
+  const words = searchWords(query)
+  const shown = groups
+    .map((g) => ({ ...g, entries: g.entries.filter((e) => entryMatches(e, words, platform)) }))
+    .filter((g) => g.entries.length > 0)
+  const entries = useMemo(() => new Map(groups.flatMap((g) => g.entries.map((e) => [e.action.id, e]))), [groups])
+  const allDefault = groups.every((g) => g.entries.every((e) => e.isDefault))
+  const clashing = groups.flatMap((g) => g.entries.flatMap((e) => clashesOf(e, clashes)))
+
+  const goto = firstKeys('tab.goto.1') && firstKeys('tab.goto.8')
+  const range = goto ? `${firstKeys('tab.goto.1')}–${firstKeys('tab.goto.8')}` : 'Go to Tab 1–8'
+  const nine = firstKeys('tab.goto.9') || 'Go to Tab 9'
+  const favoritesText = `${range} count your Favorites first, then pinned and Today tabs.`
+  const lastText = 'The last item, or the ninth.'
+  const has = (text: string) => words.every((w) => text.toLowerCase().includes(w))
+  const showFavorites = has(`Go to Tab Include Favorites in ordering ${favoritesText}`)
+  const showLast = has(`Go to Tab ${nine} goes to ${lastText}`)
+  const resetText = 'Reset all shortcuts'
+  const showReset = has(`${resetText} default`)
+
+  const onContextMenu = (e: ReactMouseEvent) => {
+    const target = e.target as Element
+    if (target.closest('.ks-menu')) return
+    const row = target.closest('[data-setting]')
+    const actionId = row?.querySelector<HTMLElement>('[data-shortcut-action]')?.dataset.shortcutAction
+    const entry = actionId ? entries.get(actionId) : undefined
+    if (!entry || entry.action.fixed) return
+    e.preventDefault()
+    stop()
+    // From the keyboard (⇧F10, the menu key) the menu opens at the row's keys.
+    let { clientX: x, clientY: y } = e
+    if (x === 0 && y === 0) {
+      const rect = (row?.querySelector('[data-shortcut-action]') ?? target).getBoundingClientRect()
+      x = rect.left
+      y = rect.bottom
+    }
+    setMenu({ actionId: entry.action.id, x, y })
+  }
+
+  const menuEntry = menu ? entries.get(menu.actionId) : undefined
+
+  return (
+    <div className="ks-page" onContextMenu={onContextMenu}>
+      {/* .st-groups with no rows: Settings search (ST-02), which searches every page, hides them. */}
+      <div className="st-group ks-search-bar">
+        <label className="ks-search">
+          <Search size={14} aria-hidden="true" />
+          <input
+            type="search"
+            value={query}
+            placeholder="Search shortcuts"
+            aria-label="Search shortcuts"
+            spellCheck={false}
+            data-testid="shortcuts-search"
+            onChange={(e) => setQuery(e.target.value)}
+          />
+          {query && (
+            <button type="button" className="ks-search__clear" aria-label="Clear search" onClick={() => setQuery('')}>
+              <X size={11} />
+            </button>
+          )}
+        </label>
+      </div>
+      <div className="st-group ks-head">
+        <p className="ks-intro">
+          Click a shortcut, then press the new keys. Right-click an action to reset it, or to choose whether websites or
+          Orbit get its keys first.
+        </p>
+        {clashing.length > 0 && (
+          <p className="ks-notice" role="note" data-testid="shortcuts-system-notice">
+            {mac
+              ? 'macOS keeps some of these keys for itself, so they never reach Orbit (marked below). Turn them off in System Settings → Keyboard → Keyboard Shortcuts, or give those actions other keys here.'
+              : 'Your desktop keeps some of these keys for itself, so they never reach Orbit (marked below). Change them in your desktop’s keyboard settings, or give those actions other keys here.'}
+          </p>
+        )}
+      </div>
+
+      {(showFavorites || showLast) && (
+        <SettingGroup title="Go to Tab">
+          {showFavorites && (
+            <SettingRow id="shortcut-count-favorites" label="Include Favorites in ordering" description={favoritesText}>
+              <Switch
+                label="Include Favorites in ordering"
+                checked={countFavorites}
+                testId="shortcut-count-favorites"
+                onChange={(next) => void invoke('keys.setOptions', { countFavorites: next })}
+              />
+            </SettingRow>
+          )}
+          {showLast && (
+            <SettingRow id="shortcut-last-tab" label={`${nine} goes to`} description={lastText}>
+              <Select
+                label={`${nine} goes to`}
+                value={lastTabOnCmd9 ? 'last' : 'ninth'}
+                options={[
+                  { value: 'last', label: 'The last item' },
+                  { value: 'ninth', label: 'The ninth item' },
+                ]}
+                testId="shortcut-last-tab"
+                onChange={(next) => void invoke('keys.setOptions', { lastTabOnCmd9: next === 'last' })}
+              />
+            </SettingRow>
+          )}
+        </SettingGroup>
+      )}
+
+      {shown.map((group) => (
+        <SettingGroup key={group.category} title={group.category}>
+          {group.entries.map((entry) => {
+            const id = entry.action.id
+            const mine = recording?.actionId === id ? recording : undefined
+            const clash = clashesOf(entry, clashes)[0]
+            return (
+              <ShortcutRow
+                key={id}
+                actionId={id}
+                title={entry.title}
+                bindings={entry.bindings.join(' ')}
+                fixed={!!entry.action.fixed}
+                websites={entry.priority === 'websites'}
+                recording={mine ? (mine.replace ?? '') : undefined}
+                held={mine?.held ?? ''}
+                problem={problem?.actionId === id ? problem.text : undefined}
+                clash={
+                  clash
+                    ? `${keys(clash.accel)} never reaches Orbit: your system uses it for ${clash.owner}.`
+                    : undefined
+                }
+                start={start}
+                stop={stop}
+              />
+            )
+          })}
+        </SettingGroup>
+      ))}
+      {available && shown.length === 0 && (
+        <p className="ks-empty" data-testid="shortcuts-no-results">
+          No shortcuts match “{query}”.
+        </p>
+      )}
+
+      {showReset && (
+        <SettingGroup>
+          <SettingRow
+            id="shortcuts-reset-all"
+            label={resetText}
+            description="Every action gets back the keys Orbit comes with, and the keys go first to whoever they went to at first."
+          >
+            <Button testId="shortcuts-reset-all" disabled={allDefault} onClick={() => setConfirmReset(true)}>
+              Reset All…
+            </Button>
+          </SettingRow>
+        </SettingGroup>
+      )}
+
+      {menu && menuEntry && (
+        <ShortcutMenu
+          entry={menuEntry}
+          x={menu.x}
+          y={menu.y}
+          onClose={() => setMenu(undefined)}
+          onPriority={(priority) => void invoke('keys.setPriority', { actionId: menu.actionId, priority })}
+        />
+      )}
+
+      {conflict && <ConflictDialog conflict={conflict} onClose={recorder.dismiss} onResolve={recorder.resolve} />}
+
+      {confirmReset && (
+        <Dialog
+          title="Reset all shortcuts?"
+          description="Every shortcut you changed goes back to the one Orbit comes with."
+          testId="shortcuts-reset-all-dialog"
+          onClose={() => setConfirmReset(false)}
+          actions={
+            <>
+              <Button onClick={() => setConfirmReset(false)}>Cancel</Button>
+              <Button
+                kind="danger"
+                testId="shortcuts-reset-all-confirm"
+                onClick={() => void invoke('keys.resetAll', {}).finally(() => setConfirmReset(false))}
+              >
+                Reset All
+              </Button>
+            </>
+          }
+        />
+      )}
+    </div>
+  )
+}
+
+/** One action's row: its name, and its keys to click and record (ST-08). */
+const ShortcutRow = memo(function ShortcutRow({
+  actionId,
+  title,
+  bindings,
+  fixed,
+  websites,
+  recording,
+  held,
+  problem,
+  clash,
+  start,
+  stop,
+}: {
+  actionId: string
+  title: string
+  /** Its bindings, space-separated. */
+  bindings: string
+  fixed: boolean
+  websites: boolean
+  /** Recording: '' for a new binding, else the binding being changed. */
+  recording: string | undefined
+  held: string
+  problem?: string
+  clash?: string
+  start: (actionId: string, replace?: string) => void
+  stop: () => void
+}) {
+  const list = bindings ? bindings.split(' ') : []
+  const adding = recording === ''
+  const listening = held ? `${formatModifiers(held, platform)}…` : 'Type shortcut'
+  const remove = mac ? '⌫' : 'Backspace'
+  let description: ReactNode
+  if (problem) {
+    description = (
+      <span className="ks-problem" role="alert" data-testid="shortcut-problem">
+        {problem}
+      </span>
+    )
+  } else if (recording !== undefined) {
+    description = adding
+      ? 'Press the keys to add. Esc cancels.'
+      : `Press the new keys. Esc cancels; ${remove} removes this shortcut.`
+  } else if (clash) {
+    description = (
+      <span className="ks-clash" data-testid="shortcut-clash">
+        {clash}
+      </span>
+    )
+  } else if (fixed) {
+    description = 'This shortcut can’t be changed.'
+  }
+  const toggle = (replace?: string) => {
+    if (recording === (replace ?? '')) stop()
+    else start(actionId, replace)
+  }
+  const keysRef = useRef<HTMLDivElement>(null)
+  const listeningNow = recording !== undefined
+  // The row says what to do while it records: all of it in view.
+  useEffect(() => {
+    if (listeningNow) keysRef.current?.closest('[data-setting]')?.scrollIntoView({ block: 'nearest' })
+  }, [listeningNow])
+  return (
+    <SettingRow
+      id={`shortcut-${actionId}`}
+      label={
+        <>
+          {title}
+          {websites && (
+            <span className="ks-tag" title="A page that uses these keys gets them first; press again to run the action">
+              Websites first
+            </span>
+          )}
+        </>
+      }
+      description={description}
+    >
+      <div ref={keysRef} className="ks-bindings" data-shortcut-action={actionId} data-testid="shortcut-bindings">
+        {fixed
+          ? list.map((accel) => (
+              <span key={accel} className="ks-chip ks-chip--fixed" data-testid="shortcut-binding">
+                <Lock size={10} aria-hidden="true" />
+                {keys(accel)}
+              </span>
+            ))
+          : list.map((accel, i) => {
+              const on = recording === accel
+              return (
+                <button
+                  // biome-ignore lint/suspicious/noArrayIndexKey: a changed binding keeps its place and its focus
+                  key={i}
+                  type="button"
+                  className={`ks-chip${on ? ' ks-chip--recording' : ''}`}
+                  data-testid="shortcut-binding"
+                  data-recording={on ? '' : undefined}
+                  aria-label={on ? `${title}: type the new shortcut` : `${title}: ${keys(accel)}. Change`}
+                  aria-pressed={on}
+                  title="Click, then press the new keys"
+                  onClick={() => toggle(accel)}
+                >
+                  {on ? listening : keys(accel)}
+                </button>
+              )
+            })}
+        {!fixed && (adding || list.length < MAX_BINDINGS) && (
+          <button
+            type="button"
+            className={
+              adding || list.length === 0 ? `ks-chip ks-chip--empty${adding ? ' ks-chip--recording' : ''}` : 'ks-add'
+            }
+            data-testid={list.length === 0 ? 'shortcut-record' : 'shortcut-add'}
+            data-recording={adding ? '' : undefined}
+            aria-label={adding ? `${title}: type the new shortcut` : `Add a shortcut for ${title}`}
+            aria-pressed={adding}
+            title={list.length === 0 ? 'Click, then press the keys' : 'Add another shortcut'}
+            onClick={() => toggle()}
+          >
+            {adding ? listening : list.length === 0 ? 'Record Shortcut' : <Plus size={13} aria-hidden="true" />}
+          </button>
+        )}
+      </div>
+    </SettingRow>
+  )
+})
+
+/** Asks what to do when the keys pressed belong to another action: swap, clear it there, or cancel. */
+function ConflictDialog({
+  conflict,
+  onClose,
+  onResolve,
+}: {
+  conflict: Conflict
+  onClose: () => void
+  onResolve: (c: Conflict, how: 'clear' | 'swap') => void
+}) {
+  const { accel, replace, other } = conflict
+  const title = ACTIONS_BY_ID[conflict.actionId]?.title ?? 'this action'
+  return (
+    <Dialog
+      title={`${keys(accel)} is used by “${other.title}”`}
+      description={
+        replace
+          ? `Swap gives “${other.title}” ${keys(replace)} instead. Remove takes ${keys(accel)} away from it.`
+          : `Remove takes ${keys(accel)} away from “${other.title}” and gives it to “${title}”.`
+      }
+      testId="shortcut-conflict"
+      onClose={onClose}
+      actions={
+        <>
+          <Button testId="shortcut-conflict-cancel" onClick={onClose}>
+            Cancel
+          </Button>
+          <Button
+            kind={replace ? 'normal' : 'primary'}
+            testId="shortcut-conflict-clear"
+            onClick={() => onResolve(conflict, 'clear')}
+          >
+            {`Remove from “${other.title}”`}
+          </Button>
+          {replace && (
+            <Button kind="primary" testId="shortcut-conflict-swap" onClick={() => onResolve(conflict, 'swap')}>
+              Swap
+            </Button>
+          )}
+        </>
+      }
+    />
+  )
+}
+
+/** The menu a right-click on an action opens: Reset to Default, Remove Shortcuts and the priority (KS-02). */
+function ShortcutMenu({
+  entry,
+  x,
+  y,
+  onClose,
+  onPriority,
+}: {
+  entry: ShortcutEntry
+  x: number
+  y: number
+  onClose: () => void
+  onPriority: (priority: ShortcutPriority) => void
+}) {
+  const ref = useRef<HTMLDivElement>(null)
+  const closeRef = useRef(onClose)
+  closeRef.current = onClose
+  const id = entry.action.id
+  useLayoutEffect(() => {
+    const menu = ref.current
+    if (!menu) return
+    // Kept inside the window.
+    const { width, height } = menu.getBoundingClientRect()
+    menu.style.left = `${Math.max(4, Math.min(x, window.innerWidth - width - 4))}px`
+    menu.style.top = `${Math.max(4, Math.min(y, window.innerHeight - height - 4))}px`
+    menu.querySelector<HTMLButtonElement>('[role^="menuitem"]:not(:disabled)')?.focus({ preventScroll: true })
+  }, [x, y])
+  useEffect(() => {
+    const close = () => closeRef.current()
+    // The menu closes once the list under it moves. Where each scroller holding it is as it opens:
+    // the scroll event of a scroll made just before the right-click can come in after it.
+    const where = (el: Element) => `${el.scrollLeft},${el.scrollTop}`
+    const at = new Map<Element, string>()
+    for (let el = ref.current?.parentElement; el; el = el.parentElement) at.set(el, where(el))
+    const onScroll = (e: Event) => {
+      const el = e.target === document ? document.scrollingElement : e.target
+      if (el instanceof Element && at.has(el) && at.get(el) !== where(el)) close()
+    }
+    const onDown = (e: MouseEvent) => {
+      if (!ref.current?.contains(e.target as Node)) close()
+    }
+    document.addEventListener('mousedown', onDown, true)
+    window.addEventListener('blur', close)
+    window.addEventListener('resize', close)
+    document.addEventListener('scroll', onScroll, true)
+    return () => {
+      document.removeEventListener('mousedown', onDown, true)
+      window.removeEventListener('blur', close)
+      window.removeEventListener('resize', close)
+      document.removeEventListener('scroll', onScroll, true)
+    }
+  }, [])
+  const run = (fn: () => void) => () => {
+    onClose()
+    fn()
+  }
+  const item = (
+    label: string,
+    testId: string,
+    onSelect: () => void,
+    options: { disabled?: boolean; checked?: boolean } = {},
+  ) => (
+    <button
+      type="button"
+      role={options.checked === undefined ? 'menuitem' : 'menuitemradio'}
+      aria-checked={options.checked}
+      className="st-menu__item ks-menu__item"
+      disabled={options.disabled}
+      data-testid={testId}
+      onClick={run(onSelect)}
+    >
+      <span className="ks-menu__check" aria-hidden="true">
+        {options.checked && <Check size={12} strokeWidth={2.5} />}
+      </span>
+      {label}
+    </button>
+  )
+  return (
+    <div
+      ref={ref}
+      className="st-menu__list ks-menu"
+      role="menu"
+      aria-label={`${entry.title} shortcut`}
+      data-testid="shortcut-menu"
+      style={{ left: x, top: y }}
+      onKeyDown={(e) => {
+        if (e.key === 'Escape') {
+          e.preventDefault()
+          onClose()
+          return
+        }
+        if (e.key !== 'ArrowDown' && e.key !== 'ArrowUp') return
+        e.preventDefault()
+        const all = [...e.currentTarget.querySelectorAll<HTMLButtonElement>('[role^="menuitem"]:not(:disabled)')]
+        const i = all.indexOf(document.activeElement as HTMLButtonElement)
+        all[(i + (e.key === 'ArrowDown' ? 1 : all.length - 1)) % all.length]?.focus()
+      }}
+    >
+      {item('Reset to Default', 'shortcut-menu-reset', () => void invoke('keys.reset', { actionId: id }), {
+        disabled: entry.isDefault,
+      })}
+      {item(
+        entry.bindings.length > 1 ? 'Remove Shortcuts' : 'Remove Shortcut',
+        'shortcut-menu-remove',
+        () => {
+          void (async () => {
+            for (const accel of entry.bindings) await invoke('keys.unbind', { actionId: id, accel })
+          })()
+        },
+        { disabled: entry.bindings.length === 0 },
+      )}
+      <div className="ks-menu__sep" role="separator" />
+      {item('Prefer Websites', 'shortcut-menu-websites', () => onPriority('websites'), {
+        checked: entry.priority === 'websites',
+      })}
+      {item('Prefer Orbit', 'shortcut-menu-orbit', () => onPriority('orbit'), { checked: entry.priority === 'orbit' })}
+    </div>
+  )
+}
diff --git a/src/renderer/src/keys/live.ts b/src/renderer/src/keys/live.ts
index eb32c454..cc9d59fa 100644
--- a/src/renderer/src/keys/live.ts
+++ b/src/renderer/src/keys/live.ts
@@ -31,3 +31,14 @@ export function useShortcutLabel(actionId: string): string {
   useKeymap()
   return shortcutLabel(actionId)
 }
+
+let recording = false
+
+/** Settings → Shortcuts is recording a new binding (ST-08): no key press in this page runs an action. */
+export function setRecordingKeys(on: boolean): void {
+  recording = on
+}
+
+export function recordingKeys(): boolean {
+  return recording
+}
diff --git a/src/renderer/src/keys/shortcut-list.ts b/src/renderer/src/keys/shortcut-list.ts
new file mode 100644
index 00000000..2f773cdf
--- /dev/null
+++ b/src/renderer/src/keys/shortcut-list.ts
@@ -0,0 +1,139 @@
+import {
+  ACTIONS,
+  type ActionDef,
+  defaultPriorityFor,
+  defaultShortcutsFor,
+  formatAccelerator,
+  priorityFor,
+  shortcutsFor,
+} from '../../../shared/actions'
+import type { ShortcutPriority, SystemClash } from '../../../shared/commands/keys'
+import { canonicalAccelerator } from '../../../shared/keymap'
+
+/**
+ * What Settings → Shortcuts lists (ST-08): every action with its bindings as they are now, in
+ * groups, and the search that filters them. Pure, so it is unit-tested.
+ */
+
+/** The list's groups, in order. */
+export const CATEGORY_ORDER: readonly ActionDef['category'][] = [
+  'Tabs',
+  'Navigation',
+  'Page',
+  'Sidebar',
+  'Spaces',
+  'Split View',
+  'Window',
+  'Developer',
+  'App',
+]
+
+export interface ShortcutEntry {
+  action: ActionDef
+  /** The name the list shows. */
+  title: string
+  /** The action's bindings now, written as `canonicalAccelerator` writes them. */
+  bindings: string[]
+  /** Who gets the keys first when a page also uses them (KS-02). */
+  priority: ShortcutPriority
+  /** Bindings and priority are what Orbit ships. */
+  isDefault: boolean
+}
+
+export interface ShortcutGroup {
+  category: ActionDef['category']
+  entries: ShortcutEntry[]
+}
+
+export interface ListOptions {
+  /** The user's priorities (`settings.shortcutPriority`). */
+  priorities?: Readonly<Record<string, ShortcutPriority>>
+  /** ⌘9 goes to the last item (Go to Last Tab) or the ninth (Go to Tab 9). */
+  lastTabOnCmd9: boolean
+}
+
+const canon = (list: readonly string[]): string[] =>
+  list.map((a) => canonicalAccelerator(a)).filter((a): a is string => a !== undefined)
+
+const sameList = (a: readonly string[], b: readonly string[]) => a.length === b.length && a.every((x, i) => x === b[i])
+
+/** The name an action has in the list. */
+export function shortcutTitle(action: ActionDef, options: Pick<ListOptions, 'lastTabOnCmd9'>): string {
+  if (action.id === 'tab.goto.9' && !options.lastTabOnCmd9) return 'Go to Tab 9'
+  return action.title
+}
+
+/** One action's row as it is now. */
+export function shortcutEntry(action: ActionDef, platform: string, options: ListOptions): ShortcutEntry {
+  const bindings = canon(shortcutsFor(action, platform))
+  const priority = priorityFor(action, platform, options.priorities)
+  return {
+    action,
+    title: shortcutTitle(action, options),
+    bindings,
+    priority,
+    isDefault:
+      sameList(bindings, canon(defaultShortcutsFor(action, platform))) &&
+      priority === defaultPriorityFor(action, platform),
+  }
+}
+
+/** Every action, in its group, in the order the action table lists them. */
+export function shortcutGroups(platform: string, options: ListOptions, actions = ACTIONS): ShortcutGroup[] {
+  const byCategory = new Map<ActionDef['category'], ShortcutEntry[]>()
+  for (const action of actions) {
+    const list = byCategory.get(action.category) ?? []
+    list.push(shortcutEntry(action, platform, options))
+    byCategory.set(action.category, list)
+  }
+  return CATEGORY_ORDER.flatMap((category) => {
+    const entries = byCategory.get(category)
+    return entries?.length ? [{ category, entries }] : []
+  })
+}
+
+/** The words of a search, lower case. */
+export function searchWords(query: string): string[] {
+  return query.toLowerCase().split(/\s+/).filter(Boolean)
+}
+
+/**
+ * Whether a row matches every word typed: its name, group and search words, and its keys as this
+ * platform shows them ("⌘S", "Ctrl+S") or writes them ("cmd+s").
+ */
+export function entryMatches(entry: ShortcutEntry, words: readonly string[], platform: string): boolean {
+  if (words.length === 0) return true
+  const text = [
+    entry.title,
+    entry.action.category,
+    ...(entry.action.keywords ?? []),
+    ...entry.bindings.map((a) => formatAccelerator(a, platform)),
+    ...entry.bindings,
+  ]
+    .join(' ')
+    .toLowerCase()
+  return words.every((w) => text.includes(w))
+}
+
+/** The modifiers held while recording ("Cmd+Shift") as this platform shows them: "⇧⌘" or "Ctrl+Shift+". */
+export function formatModifiers(modifiers: string, platform: string): string {
+  const held = new Set(modifiers.split('+').filter(Boolean))
+  if (platform === 'darwin') {
+    return `${held.has('Ctrl') ? '⌃' : ''}${held.has('Alt') ? '⌥' : ''}${held.has('Shift') ? '⇧' : ''}${held.has('Cmd') ? '⌘' : ''}`
+  }
+  const names = [
+    held.has('Ctrl') && 'Ctrl',
+    held.has('Alt') && 'Alt',
+    held.has('Shift') && 'Shift',
+    held.has('Cmd') && 'Meta',
+  ]
+  return names
+    .filter(Boolean)
+    .map((n) => `${n}+`)
+    .join('')
+}
+
+/** The keys of a row that the system keeps for itself, with what has them (KS-03). */
+export function clashesOf(entry: ShortcutEntry, clashes: readonly SystemClash[] | undefined): SystemClash[] {
+  return (clashes ?? []).filter((c) => entry.bindings.includes(c.accel))
+}
diff --git a/src/renderer/src/keys/shortcuts.css b/src/renderer/src/keys/shortcuts.css
new file mode 100644
index 00000000..6f596861
--- /dev/null
+++ b/src/renderer/src/keys/shortcuts.css
@@ -0,0 +1,209 @@
+/* Settings → Shortcuts (ST-08). Colours come from the Settings window's palette (settings.css). */
+
+.st-group.ks-search-bar {
+  position: sticky;
+  top: 0;
+  z-index: 2;
+  margin: -8px -4px 10px;
+  padding: 8px 4px;
+  background: var(--surface);
+}
+
+.ks-search {
+  display: flex;
+  align-items: center;
+  gap: 6px;
+  height: 30px;
+  padding: 0 8px;
+  border: 1px solid var(--st-border);
+  border-radius: 8px;
+  background: var(--st-field);
+  color: var(--text-muted);
+}
+
+.ks-search:focus-within {
+  box-shadow: 0 0 0 2px color-mix(in oklab, var(--accent) 55%, transparent);
+}
+
+.ks-search input {
+  flex: 1;
+  min-width: 0;
+  border: 0;
+  outline: 0;
+  background: transparent;
+  color: var(--text);
+  font: inherit;
+  user-select: text;
+}
+
+.ks-search input::-webkit-search-cancel-button {
+  display: none;
+}
+
+.ks-search input::placeholder {
+  color: var(--text-muted);
+}
+
+.ks-search__clear {
+  display: grid;
+  place-items: center;
+  width: 18px;
+  height: 18px;
+  border-radius: 50%;
+  background: var(--hover);
+  color: var(--text-muted);
+}
+
+.ks-head {
+  display: flex;
+  flex-direction: column;
+  gap: 10px;
+}
+
+.ks-intro {
+  margin: 0 4px;
+  color: var(--text-muted);
+  font-size: 12px;
+  line-height: 1.45;
+}
+
+.ks-notice {
+  margin: 0;
+  padding: 8px 10px;
+  border-radius: 8px;
+  background: color-mix(in oklab, #e3a008 16%, transparent);
+  color: var(--text);
+  font-size: 12px;
+  line-height: 1.45;
+}
+
+.ks-bindings {
+  display: flex;
+  flex-wrap: wrap;
+  justify-content: flex-end;
+  align-items: center;
+  gap: 4px;
+  max-width: 210px;
+}
+
+.ks-chip {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  gap: 4px;
+  min-width: 30px;
+  height: 24px;
+  padding: 0 8px;
+  border: 1px solid var(--st-border);
+  border-radius: 6px;
+  background: var(--st-field);
+  color: var(--text);
+  font-size: 12px;
+  font-weight: 500;
+  white-space: nowrap;
+  outline: none;
+}
+
+button.ks-chip:hover {
+  background: var(--hover);
+}
+
+.ks-chip:focus-visible,
+.ks-add:focus-visible {
+  box-shadow: 0 0 0 2px color-mix(in oklab, var(--accent) 60%, transparent);
+}
+
+.ks-chip--empty {
+  border-style: dashed;
+  background: transparent;
+  color: var(--text-muted);
+  font-weight: 400;
+}
+
+.ks-chip--recording,
+.ks-chip--recording:hover {
+  min-width: 104px;
+  border-style: solid;
+  border-color: var(--accent);
+  background: color-mix(in oklab, var(--accent) 10%, var(--st-field));
+  box-shadow: 0 0 0 2px color-mix(in oklab, var(--accent) 35%, transparent);
+  color: var(--text-muted);
+}
+
+.ks-chip--fixed {
+  background: transparent;
+  color: var(--text-muted);
+}
+
+.ks-add {
+  display: grid;
+  place-items: center;
+  width: 24px;
+  height: 24px;
+  border-radius: 6px;
+  color: var(--text-muted);
+  outline: none;
+}
+
+.ks-add:hover {
+  background: var(--hover);
+  color: var(--text);
+}
+
+.ks-tag {
+  padding: 1px 7px;
+  border-radius: 999px;
+  background: color-mix(in oklab, var(--accent) 16%, transparent);
+  color: var(--text);
+  font-size: 11px;
+  font-weight: 500;
+  white-space: nowrap;
+}
+
+.ks-problem {
+  color: #c62f2f;
+}
+
+.settings[data-dark] .ks-problem {
+  color: #ff7a7a;
+}
+
+.ks-clash {
+  color: #9a6200;
+}
+
+.settings[data-dark] .ks-clash {
+  color: #f2bd5c;
+}
+
+.ks-empty {
+  margin: 40px 0;
+  color: var(--text-muted);
+  text-align: center;
+}
+
+/* The right-click menu: placed at the pointer (or under the row's keys from the keyboard). */
+.st-menu__list.ks-menu {
+  position: fixed;
+  right: auto;
+  z-index: 20;
+}
+
+.ks-menu__item {
+  display: flex;
+  align-items: center;
+  gap: 6px;
+}
+
+.ks-menu__check {
+  display: grid;
+  place-items: center;
+  width: 12px;
+  color: var(--accent);
+}
+
+.ks-menu__sep {
+  height: 1px;
+  margin: 4px 2px;
+  background: var(--divider);
+}
diff --git a/src/renderer/src/keys/shortcuts.settings.tsx b/src/renderer/src/keys/shortcuts.settings.tsx
new file mode 100644
index 00000000..d9fc2e4a
--- /dev/null
+++ b/src/renderer/src/keys/shortcuts.settings.tsx
@@ -0,0 +1,13 @@
+import { Keyboard } from 'lucide-react'
+import type { SettingsSection } from '../settings/registry'
+import { ShortcutsPage } from './ShortcutsPage'
+
+/** Settings → Shortcuts (ST-08): the keys lane's section of the Settings window. */
+export default {
+  id: 'shortcuts',
+  label: 'Shortcuts',
+  icon: Keyboard,
+  order: 40,
+  component: ShortcutsPage,
+  keywords: ['keyboard shortcuts', 'keyboard', 'remap', 'key bindings', 'hotkeys'],
+} satisfies SettingsSection
diff --git a/src/renderer/src/shortcuts.ts b/src/renderer/src/shortcuts.ts
index 0cf2e5e1..437d5702 100644
--- a/src/renderer/src/shortcuts.ts
+++ b/src/renderer/src/shortcuts.ts
@@ -1,5 +1,5 @@
 import { actionForInput } from '../../shared/actions'
-import { followKeymap } from './keys/live'
+import { followKeymap, recordingKeys } from './keys/live'
 
 /**
  * Fallback shortcut router for Orbit's own UI pages. Real key presses are
@@ -13,7 +13,8 @@ export function installShortcutFallback(): void {
   window.addEventListener(
     'keydown',
     (e) => {
-      if (e.defaultPrevented || e.isComposing) return
+      // Settings → Shortcuts takes the keys while it records a new binding (ST-08).
+      if (e.defaultPrevented || e.isComposing || recordingKeys()) return
       const action = actionForInput(
         { key: e.key, code: e.code, meta: e.metaKey, control: e.ctrlKey, alt: e.altKey, shift: e.shiftKey },
         window.orbit.platform,
diff --git a/src/shared/commands/keys.ts b/src/shared/commands/keys.ts
index 8bc2cd99..9ad0bb44 100644
--- a/src/shared/commands/keys.ts
+++ b/src/shared/commands/keys.ts
@@ -75,6 +75,8 @@ export interface KeyCommands {
   'keys.setPriority': { args: { actionId: string; priority: ShortcutPriority }; result: void }
   /** The Go to Tab options of Settings → Shortcuts (ST-08). */
   'keys.setOptions': { args: TabNumberOptions; result: void }
+  /** The ids of the actions Orbit runs (the action table also names some no feature runs yet): Settings → Shortcuts lists these. */
+  'keys.available': { args: Record<string, never>; result: string[] }
   /** Keys the operating system keeps, so Orbit never receives them (KS-03): shown in Settings → Shortcuts. */
   'keys.systemClashes': { args: Record<string, never>; result: SystemClash[] }
 }
diff --git a/src/shared/commands/settings.ts b/src/shared/commands/settings.ts
index 277f4901..a90e0a5e 100644
--- a/src/shared/commands/settings.ts
+++ b/src/shared/commands/settings.ts
@@ -93,6 +93,14 @@ export const SETTINGS_ACTIONS: SettingsActionDef[] = [
     settings: { section: 'appearance' },
     keywords: ['theme', 'dark mode', 'light mode', 'match system'],
   },
+  // Keys lane: Settings → Shortcuts (ST-08, KS-12).
+  {
+    id: 'settings.shortcuts',
+    title: 'Shortcut Settings',
+    category: 'App',
+    settings: { section: 'shortcuts' },
+    keywords: ['keyboard shortcuts', 'shortcuts', 'remap keys', 'key bindings', 'hotkeys'],
+  },
   {
     id: 'settings.links',
     title: 'Link Settings',
diff --git a/src/shared/keymap.ts b/src/shared/keymap.ts
index 9f73bdf2..b25117cd 100644
--- a/src/shared/keymap.ts
+++ b/src/shared/keymap.ts
@@ -259,6 +259,9 @@ export function acceleratorFromInput(input: KeyInput): string | undefined {
   return canonicalAccelerator(mods ? `${mods}+${keyName(input)}` : keyName(input))
 }
 
+/** Most bindings one action keeps (KS-01: aliases such as Back = ⌘[ and ⌘←). */
+export const MAX_BINDINGS = 5
+
 /** Function keys F1–F12 may be bound with no modifier (KS-01). */
 const BARE_KEY = /^F([1-9]|1[0-2])$/
 
diff --git a/tests/e2e/keys.spec.ts b/tests/e2e/keys.spec.ts
index 93b36c93..f7424f08 100644
--- a/tests/e2e/keys.spec.ts
+++ b/tests/e2e/keys.spec.ts
@@ -1,6 +1,7 @@
 import { expect, type Page, test } from '@playwright/test'
 import { action, isMac, launchOrbit, MOD, type Orbit, run, state, tabPage, viewPage } from './helpers'
 import { cmd, type NavFixtures, openTab, pressInPage, startNavFixtures, visit } from './nav-support'
+import { openSettings, osWindows, pageOfView } from './settings-support'
 import { activeSpace, createSpace } from './spaces-support'
 
 let fx: NavFixtures
@@ -680,3 +681,159 @@ test('[KS-05][TB-12][TB-11] Rename Tab, Move Tab to Space… and Archive Tab hav
   await expect.poll(async () => (await state(app)).spaces[spaceId]?.pinned).toEqual([])
   expect((await state(app)).archive.at(-1)?.url).toBe(fx.url('/page/Named'))
 })
+
+// ---------- Settings → Shortcuts (ST-08) ----------
+
+/**
+ * A key press in the Settings window as the keyboard sends it there, through Orbit's key router
+ * (which records it while Settings → Shortcuts listens for a new binding).
+ */
+function pressInSettings(keyCode: string, modifiers: Mod[] = []): Promise<void> {
+  return orbit.app.evaluate(
+    ({ webContents }, [code, mods]) => {
+      const contents = webContents.getAllWebContents().find((c) => c.getURL().includes('view=settings'))
+      if (!contents) throw new Error('no Settings window')
+      contents.sendInputEvent({ type: 'keyDown', keyCode: code, modifiers: mods })
+      contents.sendInputEvent({ type: 'keyUp', keyCode: code, modifiers: mods })
+    },
+    [keyCode, modifiers] as const,
+  )
+}
+
+const PRIMARY_MOD: Mod[] = [isMac ? 'meta' : 'control']
+const shortcutRow = (page: Page, actionId: string) => page.getByTestId(`setting-shortcut-${actionId}`)
+const keysOf = async () => (await state(orbit.app)).settings.shortcuts
+const prioritiesOf = async () => (await state(orbit.app)).settings.shortcutPriority
+
+test('[ST-08][KS-01][KS-12] Shortcut Settings opens the list; search finds an action, and clicking its key then pressing new keys remaps it everywhere', async () => {
+  const { app, shell } = orbit
+  await action(app, 'settings.shortcuts')
+  const page = await pageOfView(app, 'settings')
+  await expect(page.getByTestId('settings-tab-shortcuts')).toHaveAttribute('aria-selected', 'true')
+  await page.getByTestId('shortcuts-search').fill('sidebar tog')
+  const row = shortcutRow(page, 'sidebar.toggle')
+  await expect(row).toBeVisible()
+  await expect(shortcutRow(page, 'tab.new')).toHaveCount(0)
+  const keys = row.getByTestId('shortcut-binding')
+  await expect(keys).toHaveText([isMac ? '⌘S' : 'Ctrl+S'])
+  await keys.first().click()
+  await expect(keys.first()).toHaveText('Type shortcut')
+  await pressInSettings('B', [...PRIMARY_MOD, 'shift'])
+  await expect(keys).toHaveText([SHIFT_B])
+  expect(await keysOf()).toEqual({ 'sidebar.toggle': [`${PRIMARY}+Shift+B`] })
+  await expect(shell.getByTestId('toggle-sidebar')).toHaveAttribute('title', `Hide sidebar (${SHIFT_B})`)
+  await onlyShiftBToggles()
+
+  // Another binding: a key without a modifier is refused and Settings keeps listening; F-keys may stand alone.
+  await row.getByTestId('shortcut-add').click()
+  await pressInSettings('B')
+  await expect(row.getByTestId('shortcut-problem')).toContainText('A shortcut starts with')
+  await pressInSettings('F7')
+  await expect(keys).toHaveText([SHIFT_B, 'F7'])
+  // Esc leaves a binding as it was; ⌫ removes it.
+  await keys.nth(1).click()
+  await pressInSettings('Escape')
+  await expect(keys).toHaveText([SHIFT_B, 'F7'])
+  await keys.nth(1).click()
+  await pressInSettings('Backspace')
+  await expect(keys).toHaveText([SHIFT_B])
+  expect(await keysOf()).toEqual({ 'sidebar.toggle': [`${PRIMARY}+Shift+B`] })
+})
+
+test('[ST-08][KS-01] keys another action has: Settings warns and offers Swap or Remove, and while it listens the keys run nothing', async () => {
+  const { app } = orbit
+  const page = await openSettings(app, { section: 'shortcuts' })
+  const sidebar = shortcutRow(page, 'sidebar.toggle')
+  const dialog = page.getByTestId('shortcut-conflict')
+  // Close Tab's keys would close the Settings window: here they only ask.
+  await sidebar.getByTestId('shortcut-binding').click()
+  await pressInSettings('W', PRIMARY_MOD)
+  await expect(dialog).toContainText('is used by “Close Tab”')
+  expect(await osWindows(app, 'settings')).toHaveLength(1)
+  await dialog.getByTestId('shortcut-conflict-cancel').click()
+  await expect(dialog).toHaveCount(0)
+  expect(await keysOf()).toBeUndefined()
+
+  // Swap: Toggle Sidebar takes New Tab's keys and New Tab gets Toggle Sidebar's.
+  await sidebar.getByTestId('shortcut-binding').click()
+  await pressInSettings('T', PRIMARY_MOD)
+  await dialog.getByTestId('shortcut-conflict-swap').click()
+  await expect.poll(keysOf).toEqual({ 'sidebar.toggle': [`${PRIMARY}+T`], 'tab.new': [`${PRIMARY}+S`] })
+  await expect(shortcutRow(page, 'tab.new').getByTestId('shortcut-binding')).toHaveText([isMac ? '⌘S' : 'Ctrl+S'])
+
+  // Remove: Duplicate Tab, which has no keys, takes New Window's, which is left with none.
+  await shortcutRow(page, 'tab.duplicate').getByTestId('shortcut-record').click()
+  await pressInSettings('N', PRIMARY_MOD)
+  await expect(dialog.getByTestId('shortcut-conflict-swap')).toHaveCount(0)
+  await dialog.getByTestId('shortcut-conflict-clear').click()
+  await expect.poll(keysOf).toMatchObject({ 'tab.duplicate': [`${PRIMARY}+N`], 'window.new': [] })
+  await expect(shortcutRow(page, 'window.new').getByTestId('shortcut-record')).toBeVisible()
+})
+
+test('[ST-08][KS-02][TB-04] right-click an action to prefer websites or Orbit and to reset it; Reset All asks first; the Go to Tab options', async () => {
+  const { app } = orbit
+  expect(await run(app, 'keys.bind', { actionId: 'sidebar.toggle', accel: 'F7' })).toEqual({ ok: true })
+  const page = await openSettings(app, { section: 'shortcuts' })
+  const row = shortcutRow(page, 'sidebar.toggle')
+  const menu = page.getByTestId('shortcut-menu')
+  await expect(row).toContainText('Websites first')
+  await row.click({ button: 'right' })
+  await expect(menu.getByTestId('shortcut-menu-websites')).toHaveAttribute('aria-checked', 'true')
+  await menu.getByTestId('shortcut-menu-orbit').click()
+  await expect.poll(prioritiesOf).toEqual({ 'sidebar.toggle': 'orbit' })
+  await expect(row).not.toContainText('Websites first')
+  await row.click({ button: 'right' })
+  await menu.getByTestId('shortcut-menu-reset').click()
+  await expect.poll(keysOf).toBeUndefined()
+  expect(await prioritiesOf()).toBeUndefined()
+  await expect(row.getByTestId('shortcut-binding')).toHaveText([isMac ? '⌘S' : 'Ctrl+S'])
+  await expect(row).toContainText('Websites first')
+  // At its defaults there is nothing to reset; Esc closes the menu.
+  await row.click({ button: 'right' })
+  await expect(menu.getByTestId('shortcut-menu-reset')).toBeDisabled()
+  await page.keyboard.press('Escape')
+  await expect(menu).toHaveCount(0)
+
+  await run(app, 'keys.bind', { actionId: 'tab.duplicate', accel: 'F7' })
+  await run(app, 'keys.setPriority', { actionId: 'tab.new', priority: 'websites' })
+  await page.getByTestId('shortcuts-reset-all').click()
+  await page.getByTestId('shortcuts-reset-all-confirm').click()
+  await expect.poll(keysOf).toBeUndefined()
+  expect(await prioritiesOf()).toBeUndefined()
+  await expect(page.getByTestId('shortcuts-reset-all')).toBeDisabled()
+
+  // Go to Tab: Favorites counted first or not, and the last item or the ninth for ⌘9.
+  await page.getByTestId('shortcut-count-favorites').click()
+  await expect.poll(async () => (await state(app)).settings.countFavoritesInShortcuts).toBe(false)
+  await page.getByTestId('shortcut-last-tab').selectOption('ninth')
+  await expect.poll(async () => (await state(app)).settings.lastTabOnCmd9).toBe(false)
+  await expect(shortcutRow(page, 'tab.goto.9')).toContainText('Go to Tab 9')
+})
+
+test('[ST-08][KS-03][ST-02] keys the system keeps are marked until the action gets others; Settings search finds shortcuts by name', async () => {
+  const { app } = orbit
+  // The Space 1 keys, as macOS's Mission Control or a Linux desktop may keep them.
+  const accel = isMac ? 'Ctrl+1' : 'Alt+1'
+  await app.evaluate(
+    (_electron, list) =>
+      (
+        globalThis as unknown as { __orbitKeys: { setSystemClashes: (l: unknown) => void } }
+      ).__orbitKeys.setSystemClashes(list),
+    [{ accel, owner: 'Switch to Desktop 1' }],
+  )
+  const page = await openSettings(app, { section: 'shortcuts' })
+  const row = shortcutRow(page, 'space.goto.1')
+  await expect(page.getByTestId('shortcuts-system-notice')).toBeVisible()
+  await expect(row.getByTestId('shortcut-clash')).toContainText('your system uses it for Switch to Desktop 1')
+  await row.getByTestId('shortcut-binding').click()
+  await pressInSettings('F9')
+  await expect(row.getByTestId('shortcut-binding')).toHaveText(['F9'])
+  await expect(row.getByTestId('shortcut-clash')).toHaveCount(0)
+  await expect(page.getByTestId('shortcuts-system-notice')).toHaveCount(0)
+
+  await page.getByTestId('settings-search').fill('switch to space 1')
+  const results = page.getByTestId('settings-results')
+  await expect(results.getByTestId('setting-shortcut-space.goto.1')).toBeVisible()
+  await expect(results.getByTestId('setting-shortcut-space.goto.2')).toBeHidden()
+  await expect(results.getByTestId('shortcuts-search')).toBeHidden()
+})
diff --git a/tests/unit/keymap-settings.test.ts b/tests/unit/keymap-settings.test.ts
new file mode 100644
index 00000000..82033b5e
--- /dev/null
+++ b/tests/unit/keymap-settings.test.ts
@@ -0,0 +1,84 @@
+import { afterEach, describe, expect, it } from 'vitest'
+import {
+  CATEGORY_ORDER,
+  clashesOf,
+  entryMatches,
+  formatModifiers,
+  searchWords,
+  shortcutEntry,
+  shortcutGroups,
+} from '../../src/renderer/src/keys/shortcut-list'
+import { ACTIONS, ACTIONS_BY_ID } from '../../src/shared/actions'
+import { setCustomBindings } from '../../src/shared/keymap'
+
+/** What Settings → Shortcuts lists and how its search filters it (ST-08). */
+
+afterEach(() => setCustomBindings(undefined))
+
+const entry = (id: string, platform: string, options = { lastTabOnCmd9: true }) => {
+  const action = ACTIONS_BY_ID[id]
+  if (!action) throw new Error(`no action ${id}`)
+  return shortcutEntry(action, platform, options)
+}
+
+describe('[ST-08] the list of shortcuts', () => {
+  it('lists every action once, in its group, groups in a fixed order', () => {
+    const groups = shortcutGroups('linux', { lastTabOnCmd9: true })
+    expect(groups.map((g) => g.category)).toEqual(CATEGORY_ORDER.filter((c) => groups.some((g) => g.category === c)))
+    const ids = groups.flatMap((g) => g.entries.map((e) => e.action.id))
+    expect(ids).toHaveLength(ACTIONS.length)
+    expect(new Set(ids).size).toBe(ACTIONS.length)
+  })
+
+  it('shows each action with its keys now and says when they or its priority differ from the defaults', () => {
+    expect(entry('sidebar.toggle', 'darwin')).toMatchObject({
+      title: 'Toggle Sidebar',
+      bindings: ['Cmd+S'],
+      priority: 'websites',
+      isDefault: true,
+    })
+    setCustomBindings({ 'sidebar.toggle': ['Cmd+Shift+B'] })
+    expect(entry('sidebar.toggle', 'darwin')).toMatchObject({ bindings: ['Cmd+Shift+B'], isDefault: false })
+    setCustomBindings(undefined)
+    const action = ACTIONS_BY_ID['sidebar.toggle']
+    if (!action) throw new Error('no action')
+    const chosen = shortcutEntry(action, 'linux', { lastTabOnCmd9: true, priorities: { 'sidebar.toggle': 'orbit' } })
+    expect(chosen).toMatchObject({ bindings: ['Ctrl+S'], priority: 'orbit', isDefault: false })
+  })
+
+  it('names ⌘9 after what it does', () => {
+    expect(entry('tab.goto.9', 'darwin').title).toBe('Go to Last Tab')
+    expect(entry('tab.goto.9', 'darwin', { lastTabOnCmd9: false }).title).toBe('Go to Tab 9')
+  })
+})
+
+describe('[ST-08] search', () => {
+  it('finds an action by every word typed: its name, search words or keys as this platform shows them', () => {
+    const sidebar = entry('sidebar.toggle', 'darwin')
+    expect(entryMatches(sidebar, searchWords('Sidebar tog'), 'darwin')).toBe(true)
+    expect(entryMatches(sidebar, searchWords('⌘S'), 'darwin')).toBe(true)
+    expect(entryMatches(sidebar, searchWords('sidebar exit'), 'darwin')).toBe(false)
+    const linux = entry('sidebar.toggle', 'linux')
+    expect(entryMatches(linux, searchWords('ctrl+s'), 'linux')).toBe(true)
+    expect(entryMatches(entry('tab.toggleMute', 'linux'), searchWords('audio'), 'linux')).toBe(true)
+    expect(entryMatches(linux, [], 'linux')).toBe(true)
+  })
+})
+
+describe('[ST-08] recording and system keys', () => {
+  it('shows the modifiers held as this platform writes them', () => {
+    expect(formatModifiers('Cmd+Shift', 'darwin')).toBe('⇧⌘')
+    expect(formatModifiers('Ctrl+Alt+Shift+Cmd', 'darwin')).toBe('⌃⌥⇧⌘')
+    expect(formatModifiers('Ctrl+Shift', 'linux')).toBe('Ctrl+Shift+')
+    expect(formatModifiers('', 'linux')).toBe('')
+  })
+
+  it('marks the keys of an action that the system keeps (KS-03)', () => {
+    const space = entry('space.goto.1', 'darwin')
+    const clash = { accel: 'Ctrl+1', owner: 'Mission Control: Switch to Desktop 1' }
+    expect(clashesOf(space, [clash, { accel: 'Ctrl+2', owner: 'Mission Control: Switch to Desktop 2' }])).toEqual([
+      clash,
+    ])
+    expect(clashesOf(space, undefined)).toEqual([])
+  })
+})

From 3f93ca4bb0f5ec03d9b3e5e0dbd6473591f067c9 Mon Sep 17 00:00:00 2001
From: Siya <57148521+siyabendoezdemir@users.noreply.github.com>
Date: Sat, 10 Oct 2026 17:08:54 +0000
Subject: [PATCH 07/11] =?UTF-8?q?feat(keys):=20shortcut=20hints=20in=20rig?=
 =?UTF-8?q?ht-click=20menus;=20Help=20=E2=86=92=20Keyboard=20Shortcuts=20s?=
 =?UTF-8?q?heet=20(KS-18,=20OB-12)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

KS-18: the tab menu, a multi-selection's menu, the page menu and a split
pane's menu show an item's key when the item does what the key does,
read from the live keymap each time the menu opens. Items that only look
alike get no hint (Copy Page URL copies the raw address; the Markdown
copy key copies one link).

OB-12: Help → Keyboard Shortcuts (macOS Help menu, the command bar
everywhere, assignable) opens a sheet over the window with the essential
keys as they are now, grouped Everyday, Navigation, Spaces and Split
View. Esc, the close button, a click outside, Close Tab's keys or asking
again close it; its link opens Settings → Shortcuts. From Settings or a
Mini Window it opens over the browser window behind.

Tests: menu hints, the sheet's content and the macOS menu template
(KS-15 roles, live keys, Help → Keyboard Shortcuts) as unit tests; two
e2e tests in keys.spec. Status: KS-01, KS-18, OB-12, OB-13 built,
KS-12 partial.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 FEATURES.md                             |  16 +-
 docs/feature-status.json                |   8 +-
 src/main/keys/index.ts                  |  10 +-
 src/main/keys/menu-hints.ts             |  98 ++++++++++++
 src/main/keys/sheet.ts                  |  41 +++++
 src/main/menu.ts                        |   2 +
 src/main/split/index.ts                 |   4 +-
 src/main/tabs/commands.ts               |   5 +-
 src/main/tabs/context-menu.ts           |   7 +-
 src/renderer/src/keys/ShortcutSheet.tsx |  94 ++++++++++++
 src/renderer/src/keys/sheet.css         | 194 ++++++++++++++++++++++++
 src/renderer/src/keys/sheet.ts          | 100 ++++++++++++
 src/renderer/src/overlay/OverlayApp.tsx |   5 +
 src/shared/actions.ts                   |   7 +
 src/shared/commands/keys.ts             |   3 +
 tests/e2e/keys.spec.ts                  |  85 +++++++++++
 tests/unit/keymap-menu-hints.test.ts    | 103 +++++++++++++
 tests/unit/keymap-menu.test.ts          |  95 ++++++++++++
 tests/unit/keymap-sheet.test.ts         |  42 +++++
 19 files changed, 902 insertions(+), 17 deletions(-)
 create mode 100644 src/main/keys/menu-hints.ts
 create mode 100644 src/main/keys/sheet.ts
 create mode 100644 src/renderer/src/keys/ShortcutSheet.tsx
 create mode 100644 src/renderer/src/keys/sheet.css
 create mode 100644 src/renderer/src/keys/sheet.ts
 create mode 100644 tests/unit/keymap-menu-hints.test.ts
 create mode 100644 tests/unit/keymap-menu.test.ts
 create mode 100644 tests/unit/keymap-sheet.test.ts

diff --git a/FEATURES.md b/FEATURES.md
index 08eab06a..e05e63ad 100644
--- a/FEATURES.md
+++ b/FEATURES.md
@@ -4,12 +4,12 @@
 
 Every row is one behaviour from the clean-room spec. Status per ID: **spec’d** (every row) → **built** → **tested** (a unit or e2e test names the ID) → **feels right** (lead sign-off after a hands-on review against `feel.md`).
 
-**Totals:** 475 spec’d · 205 built (76 partial) · 291 tested · 0 feel right. 10 more are out of scope and not counted.
+**Totals:** 475 spec’d · 209 built (74 partial) · 292 tested · 0 feel right. 10 more are out of scope and not counted.
 
 | Priority | Spec’d | Built | Tested |
 |---|---|---|---|
-| P0 | 174 | 135 | 164 |
-| P1 | 221 | 61 | 116 |
+| P0 | 174 | 136 | 164 |
+| P1 | 221 | 64 | 117 |
 | P2 | 80 | 9 | 11 |
 
 P0 = milestone-1 core experience, P1 = parity, P2 = later.
@@ -346,7 +346,7 @@ Spec: `spec/shortcuts.md`
 
 | ID | Feature | P | Built | Tested | Feels right | Notes |
 |---|---|---|---|---|---|---|
-| KS-01 | One keymap, remapping and persistence | P0 | 🟡 partial | ✅ e2e+unit | – | one keymap keyed by action id (src/shared/actions.ts + src/shared/keymap.ts): the key router, macOS menu bar (rebuilt on a remap), tooltips and command-bar rows read the live bindings; remap, several bindings per action (up to 5), none (command bar and menus still run it), a modifier required except F1-F12, system keys refused, conflicts reported (clear or swap), reset; stored per device in settings.shortcuts, cleaned on load, kept across a restart (Space keys too); Settings → Shortcuts (ST-08) lists every action with a search, records new keys on a click and resets on right-click; the shortcut sheet (OB-12) to come |
+| KS-01 | One keymap, remapping and persistence | P0 | ✅ | ✅ e2e+unit | – | one keymap keyed by action id (src/shared/actions.ts + src/shared/keymap.ts): the key router, macOS menu bar (rebuilt on a remap), tooltips and command-bar rows read the live bindings; remap, several bindings per action (up to 5), none (command bar and menus still run it), a modifier required except F1-F12, system keys refused, conflicts reported (clear or swap), reset; stored per device in settings.shortcuts, cleaned on load, kept across a restart (Space keys too); Settings → Shortcuts (ST-08) lists every action with a search, records new keys on a click and resets on right-click; Help → Keyboard Shortcuts (OB-12) shows the essential keys as they are now |
 | KS-02 | Conflicts with web pages ("prefer websites" vs "prefer Orbit") | P0 | 🟡 partial | ✅ e2e+unit | – | who gets a key first, per action: Toggle Sidebar (Cmd+S / Ctrl+S, SB-11) prefers websites on every platform, Copy URL (Ctrl+Shift+C, NV-17) on Windows/Linux, every other action prefers Orbit (the page never sees the key); with prefer websites the page's main frame gets the first press: left alone, the action runs; used (preventDefault), a toast offers the action and a second press within a second runs it; a held key's repeats stay the page's; a press into a frame Orbit can't see into counts as used; while a page's main frame loads, Orbit takes the keys at once (Electron runs no isolated-world script in a loading page, so the page can't say in time what it did); Settings → Shortcuts sets it per action (right-click → Prefer Websites / Prefer Orbit; a “Websites first” tag on the row); Esc leaving page full screen keeps Chromium's rule and nothing holds Cmd+E yet |
 | KS-03 | Platform mapping rules | P0 | 🟡 partial | ✅ e2e+unit | – | every default checked against the spec tables on macOS, Windows and Linux (unit test): ⌘ → Ctrl, ⌥ → Alt, ⌃ keys (⌃Tab, the split keys) stay Ctrl; the Windows/Linux exceptions Alt+1–9 for Spaces, Ctrl+H, Alt+←/→, Alt+D, F5, F3, Ctrl+F4 and F1; Alt+F4 and Alt+F are kept for the system; a Ctrl+Alt key that typed an AltGr character acts only outside text fields; letters and symbols follow the layout; F11 / Alt+Shift+F come with full screen (KS-08); keys the system keeps (macOS Mission Control “Switch to Desktop N” ⌃1–⌃9 when turned on, GNOME’s workspace keys) are marked in Settings → Shortcuts, which says where to turn them off; no first-run suggestion |
 | KS-04 | Command bar and address | P0 | ✅ | ✅ e2e+unit | – | ⌘T/⌘L/Alt+D, Esc, ⌘T/⌘L again, ↑/↓ (⌃N/⌃P), Enter, Tab, ⌫, ⇧Enter (option), ⌘⌥⌫ / Shift+Delete, ⌘⌥V |
@@ -357,13 +357,13 @@ Spec: `spec/shortcuts.md`
 | KS-09 | Split view | P0 | ✅ | ✅ e2e+unit | – | ⌃⇧= adds a pane the command bar fills, ⌃⇧− closes the focused pane, ⌃⇧1–4 focus a pane, ⌃⇧] / ⌃⇧[ the next / previous pane (Ctrl+Shift on Windows/Linux), ⌘L / Ctrl+L changes the focused pane's address (SV-15), Add Right/Left/Above/Below Split from the command bar; tested from a page |
 | KS-10 | Peek and Mini Window | P1 | – | ✅ unit | – |  |
 | KS-11 | Media | P1 | 🟡 partial | ✅ e2e+unit | – | Space and arrows in the focused player, Cmd/Ctrl+scroll and pinch zoom (tested), hardware media keys via Chromium (untested), Mute Tab action assignable; the calendar meeting shortcut (P2) belongs to TB-21/FV-09 |
-| KS-12 | Library, history, downloads, settings, extensions, help | P1 | – | ✅ e2e+unit | – |  |
+| KS-12 | Library, history, downloads, settings, extensions, help | P1 | 🟡 partial | ✅ e2e+unit | – | ⌘Y / Ctrl+H View History (AR-10); ⌘⇧L Open Library on macOS, the command bar elsewhere; View Archive with no key, assignable; ⌘, / Ctrl+, Settings, which cannot be remapped, and again brings the same Settings window to the front; ⌘⇧⌫ / Ctrl+Shift+Delete Clear Browsing Data…; Shortcut Settings (command bar, assignable); the shortcut sheet from Help → Keyboard Shortcuts (macOS) and the command bar (OB-12); Alt+F stays free for the Windows/Linux app menu (SB-03, SB-26, not built). Not built: Open Downloads (DL-14, downloads lane), Open a local file (⌘O / Ctrl+O when no Peek or Mini Window has focus), pinned extensions (EX-06) |
 | KS-13 | Developer tools | P1 | – | ✅ unit | – |  |
 | KS-14 | Canvases, notes, capture and Tweaks | P2 | – | – | – |  |
 | KS-15 | Standard app and window keys | P1 | – | ✅ unit | – |  |
 | KS-16 | Text-editing keys keep their meaning | P0 | ✅ | ✅ e2e+unit | – | typed keys never go astray: a page or Orbit view that loads (a slow page, a background tab, a reload) no longer takes the keyboard from the command bar, a sidebar field or the page in front (focus-on-navigation off for every web contents Orbit makes); ⌘←/⌘→ act outside text fields only; ⌘[ / ⌘] (Alt+←/→) from a page's text field go back or forward only when the page leaves them alone (a press into a frame Orbit can't see into stays the page's); ⌘Z in a page field is the page's undo (tabs lane, tested here); no shortcut on a plain key runs while an input method composes (unit test: e2e can't drive a composition through the key router) |
 | KS-17 | Mouse, trackpad and modifier-click bindings | P0 | – | – | – |  |
-| KS-18 | Shortcut hints everywhere | P1 | 🟡 partial | ✅ e2e | – | button tooltips (address, copy link, site controls, sidebar toggle, back/forward/reload, find, zoom, Library, Clear, Space dots, Peek, Mini Window Open in…), the empty-window hint, command-bar rows and macOS menu items follow a remap without a restart; context menus and the shortcut sheet (OB-12) to come |
+| KS-18 | Shortcut hints everywhere | P1 | ✅ | ✅ e2e+unit | – | button tooltips (address, copy link, site controls, sidebar toggle, back/forward/reload, find, zoom, Library, Clear, Space dots, Peek, Mini Window Open in…), the empty-window hint, command-bar rows, macOS menu items, the shortcut sheet (OB-12) and the right-click menus of a tab, a multi-selection, the page and a split pane (an item that does what a key does shows that key’s first binding) follow a remap without a restart; a menu shows it the next time it opens. Windows and Linux have no app menu yet (SB-03, SB-26), so there is no menu bar there to label |
 | KS-19 | Keys inside overlays | P0 | 🟡 partial | ✅ e2e | – | the open overlay takes its keys first: command bar (⌘T/⌘L/⌘W/Esc), find bar (Enter/⇧Enter/Esc, NV-05), Peek (Esc, ⌘O, ⌘W, PK-09; Esc closes the Peek and the tab under it keeps loading), the recent-tab switcher (Tab/⇧Tab/`, W, letting go of ⌃), permission prompt and site controls (Esc), the sidebar with keyboard focus (arrows, Enter, Esc back to the page, SB-22); Esc then stops a loading page, as before, even one that uses Esc itself: Electron runs no isolated-world script in a page while it loads, so Orbit can't learn in time whether the page used the key (needs a lead decision: a script in the page's own world or a preload channel, D40) |
 | KS-20 | Shortcuts in special windows | P1 | – | – | – |  |
 
@@ -598,8 +598,8 @@ Spec: `spec/onboarding.md`
 | OB-09 | Done screen and the first browser window | P1 | 🟡 partial | ✅ e2e | – | Done screen sums up colours, Favorites, default browser and import; Start browsing (Back to browsing after a reset) opens the first window centred at about 86% of the screen with the colours and Favorites picked, command bar closed. No Orbit basics folder or local welcome tab (no local guide pages yet), no import counts |
 | OB-10 | Getting-started guide | P1 | – | – | – |  |
 | OB-11 | Contextual tips and one-time hints | P1 | – | – | – |  |
-| OB-12 | Essential keyboard shortcuts sheet | P1 | – | – | – |  |
-| OB-13 | Help and feedback entry points | P1 | 🟡 partial | ✅ e2e+unit | – | command-bar Help, Report a Bug, What's New and Copy Build Info; macOS Help menu (Orbit Help, Report a Bug…, Release Notes, Troubleshooting → Copy Build Info). Help opens the project README; Report a Bug opens a new issue on the public tracker with the build info filled in. The shortcut sheet entry comes with OB-12 (keys lane) |
+| OB-12 | Essential keyboard shortcuts sheet | P1 | ✅ | ✅ e2e+unit | – | Help → Keyboard Shortcuts (macOS Help menu; the command bar’s Keyboard Shortcuts everywhere; a key can be assigned) opens a sheet over the window with the essential keys as they are now (KS-18), grouped Everyday, Navigation, Spaces and Split View, “None” for an action with no key; Esc, ✕, a click outside, Close Tab’s keys or asking again close it; the link at the bottom opens Settings → Shortcuts. Asked from Settings or a Mini Window, it opens over the browser window behind (a new one if there is none) |
+| OB-13 | Help and feedback entry points | P1 | ✅ | ✅ e2e+unit | – | command-bar Help, Report a Bug, What's New and Copy Build Info; macOS Help menu (Orbit Help, Report a Bug…, Release Notes, Troubleshooting → Copy Build Info). Help opens the project README; Report a Bug opens a new issue on the public tracker with the build info filled in. Help → Keyboard Shortcuts (macOS) and the command bar’s Keyboard Shortcuts open the shortcut sheet (OB-12, keys lane) |
 | OB-14 | Skip, resume and reset onboarding | P2 | ✅ | ✅ e2e+unit | – | Skip setup on every step but the last gives the spec's default first window: the theme step's colours and mode are undone and no Favorites are added (D44). The step and the picks so far are saved, so a quit part-way resumes there with them; Reset Onboarding (command bar only) runs the flow again over the open windows and deletes nothing |
 | OB-15 | AI features opt-in step | OOS | ⛔ out of scope | – | – | the spec leaves it out |
 | OB-16 | Personal welcome card | P2 | – | – | – |  |
diff --git a/docs/feature-status.json b/docs/feature-status.json
index 42eb15f8..b4133b18 100644
--- a/docs/feature-status.json
+++ b/docs/feature-status.json
@@ -137,9 +137,9 @@
   "KS-07": {"built": "yes", "note": "Space shortcuts wired through the action table"},
   "KS-19": {"built": "partial", "note": "the open overlay takes its keys first: command bar (⌘T/⌘L/⌘W/Esc), find bar (Enter/⇧Enter/Esc, NV-05), Peek (Esc, ⌘O, ⌘W, PK-09; Esc closes the Peek and the tab under it keeps loading), the recent-tab switcher (Tab/⇧Tab/`, W, letting go of ⌃), permission prompt and site controls (Esc), the sidebar with keyboard focus (arrows, Enter, Esc back to the page, SB-22); Esc then stops a loading page, as before, even one that uses Esc itself: Electron runs no isolated-world script in a page while it loads, so Orbit can't learn in time whether the page used the key (needs a lead decision: a script in the page's own world or a preload channel, D40)"},
   "KS-16": {"built": "yes", "note": "typed keys never go astray: a page or Orbit view that loads (a slow page, a background tab, a reload) no longer takes the keyboard from the command bar, a sidebar field or the page in front (focus-on-navigation off for every web contents Orbit makes); ⌘←/⌘→ act outside text fields only; ⌘[ / ⌘] (Alt+←/→) from a page's text field go back or forward only when the page leaves them alone (a press into a frame Orbit can't see into stays the page's); ⌘Z in a page field is the page's undo (tabs lane, tested here); no shortcut on a plain key runs while an input method composes (unit test: e2e can't drive a composition through the key router)"},
-  "KS-01": {"built": "partial", "note": "one keymap keyed by action id (src/shared/actions.ts + src/shared/keymap.ts): the key router, macOS menu bar (rebuilt on a remap), tooltips and command-bar rows read the live bindings; remap, several bindings per action (up to 5), none (command bar and menus still run it), a modifier required except F1-F12, system keys refused, conflicts reported (clear or swap), reset; stored per device in settings.shortcuts, cleaned on load, kept across a restart (Space keys too); Settings → Shortcuts (ST-08) lists every action with a search, records new keys on a click and resets on right-click; the shortcut sheet (OB-12) to come"},
+  "KS-01": {"built": "yes", "note": "one keymap keyed by action id (src/shared/actions.ts + src/shared/keymap.ts): the key router, macOS menu bar (rebuilt on a remap), tooltips and command-bar rows read the live bindings; remap, several bindings per action (up to 5), none (command bar and menus still run it), a modifier required except F1-F12, system keys refused, conflicts reported (clear or swap), reset; stored per device in settings.shortcuts, cleaned on load, kept across a restart (Space keys too); Settings → Shortcuts (ST-08) lists every action with a search, records new keys on a click and resets on right-click; Help → Keyboard Shortcuts (OB-12) shows the essential keys as they are now"},
   "KS-02": {"built": "partial", "note": "who gets a key first, per action: Toggle Sidebar (Cmd+S / Ctrl+S, SB-11) prefers websites on every platform, Copy URL (Ctrl+Shift+C, NV-17) on Windows/Linux, every other action prefers Orbit (the page never sees the key); with prefer websites the page's main frame gets the first press: left alone, the action runs; used (preventDefault), a toast offers the action and a second press within a second runs it; a held key's repeats stay the page's; a press into a frame Orbit can't see into counts as used; while a page's main frame loads, Orbit takes the keys at once (Electron runs no isolated-world script in a loading page, so the page can't say in time what it did); Settings → Shortcuts sets it per action (right-click → Prefer Websites / Prefer Orbit; a “Websites first” tag on the row); Esc leaving page full screen keeps Chromium's rule and nothing holds Cmd+E yet"},
-  "KS-18": {"built": "partial", "note": "button tooltips (address, copy link, site controls, sidebar toggle, back/forward/reload, find, zoom, Library, Clear, Space dots, Peek, Mini Window Open in…), the empty-window hint, command-bar rows and macOS menu items follow a remap without a restart; context menus and the shortcut sheet (OB-12) to come"},
+  "KS-18": {"built": "yes", "note": "button tooltips (address, copy link, site controls, sidebar toggle, back/forward/reload, find, zoom, Library, Clear, Space dots, Peek, Mini Window Open in…), the empty-window hint, command-bar rows, macOS menu items, the shortcut sheet (OB-12) and the right-click menus of a tab, a multi-selection, the page and a split pane (an item that does what a key does shows that key’s first binding) follow a remap without a restart; a menu shows it the next time it opens. Windows and Linux have no app menu yet (SB-03, SB-26), so there is no menu bar there to label"},
   "KS-03": {"built": "partial", "note": "every default checked against the spec tables on macOS, Windows and Linux (unit test): ⌘ → Ctrl, ⌥ → Alt, ⌃ keys (⌃Tab, the split keys) stay Ctrl; the Windows/Linux exceptions Alt+1–9 for Spaces, Ctrl+H, Alt+←/→, Alt+D, F5, F3, Ctrl+F4 and F1; Alt+F4 and Alt+F are kept for the system; a Ctrl+Alt key that typed an AltGr character acts only outside text fields; letters and symbols follow the layout; F11 / Alt+Shift+F come with full screen (KS-08); keys the system keeps (macOS Mission Control “Switch to Desktop N” ⌃1–⌃9 when turned on, GNOME’s workspace keys) are marked in Settings → Shortcuts, which says where to turn them off; no first-run suggestion"},
   "KS-05": {"built": "partial", "note": "⌘N, ⌘⇧N, ⌘⌥N, ⌘W / Ctrl+W / Ctrl+F4, ⌘⇧W / Ctrl+Shift+W (closes the window, or the Mini Window, Settings or onboarding window that has focus; Alt+F4 is the system's), ⌘⇧T (a closed tab comes back in its place), ⌘D (pins; again, back to the top of Today), ⌘⇧C, ⌘⇧⌥C, ⌘S, ⌘⇧K, ⌘⇧E, F6 (keyboard between the sidebar and the page), tested from a page; Duplicate Tab, Reset Tab, Rename Tab (shows a hidden sidebar to edit the name), Archive Tab, Move Tab to Space… (the command bar on its Move to rows) and Favorite This Tab have no keys until the user gives them some; ⌘Z (sidebar undo) is not remappable yet; the blank window (⌃⌘N, TB-17) and the top toolbar (⌘⇧D, SB-17) are not built"},
   "KS-06": {"built": "yes", "note": "⌘1–⌘8 / Ctrl+1–8 (Favorites counted first unless turned off), ⌘9 / Ctrl+9 the last item or, set so, the ninth, ⌘⌥↓/↑ / Ctrl+Alt+↓/↑ and the ⌘⇧] / ⌘⇧[ (Ctrl+PgDn / Ctrl+PgUp) aliases, all tested from a page; while ⌃ is held, Tab and ⇧Tab (⌃` on macOS) step through recent tabs, W closes the highlighted tab (the next one in the switcher takes its place) and letting go settles; the switcher has no on-screen list yet (TB-05)"},
@@ -221,6 +221,7 @@
   "MD-16": {"built": "partial", "note": "enter: the video shrinks from its place in the page to the corner (~300 ms, standard curve); Back to tab/double-click: the tab is selected at once and a still of the last frame flies back into the page; release glides to the corner; Back to PiP grows from the controller; tray slides with the snappy spring; with reduced motion (FL-28) the player appears and goes without motion and a release settles with a 120 ms ease-out; no haptic tick on macOS"},
   "FL-32": {"built": "yes", "note": "corner resize follows the pointer, resists past its limits (rubber band) and springs back on release; a fling heads for the corner in its direction and settles with the spring; tray slides up with the snappy timing; Back to tab flies to the video's place; pinch zooms (MD-06) rather than resizes"},
   "KS-11": {"built": "partial", "note": "Space and arrows in the focused player, Cmd/Ctrl+scroll and pinch zoom (tested), hardware media keys via Chromium (untested), Mute Tab action assignable; the calendar meeting shortcut (P2) belongs to TB-21/FV-09"},
+  "KS-12": {"built": "partial", "note": "⌘Y / Ctrl+H View History (AR-10); ⌘⇧L Open Library on macOS, the command bar elsewhere; View Archive with no key, assignable; ⌘, / Ctrl+, Settings, which cannot be remapped, and again brings the same Settings window to the front; ⌘⇧⌫ / Ctrl+Shift+Delete Clear Browsing Data…; Shortcut Settings (command bar, assignable); the shortcut sheet from Help → Keyboard Shortcuts (macOS) and the command bar (OB-12); Alt+F stays free for the Windows/Linux app menu (SB-03, SB-26, not built). Not built: Open Downloads (DL-14, downloads lane), Open a local file (⌘O / Ctrl+O when no Peek or Mini Window has focus), pinned extensions (EX-06)"},
   "SB-10": {"built": "partial", "note": "media tray and call controls (media lane), above the bottom bar, pushing the list up; download progress and the update banner belong to other lanes"},
   "PK-01": {"built": "yes", "note": "floating card over the source tab; one Peek per window; links inside navigate it"},
   "PK-02": {"built": "yes", "note": "other-site (eTLD+1) link clicks, Enter on a focused link, and target=_blank in pinned tabs/Favorites; same-site navigates. Only a navigation to the clicked link counts, so form posts, script navigations and auto-posted sign-ins stay in the tab"},
@@ -278,7 +279,8 @@
   "OB-14": {"built": "yes", "note": "Skip setup on every step but the last gives the spec's default first window: the theme step's colours and mode are undone and no Favorites are added (D44). The step and the picks so far are saved, so a quit part-way resumes there with them; Reset Onboarding (command bar only) runs the flow again over the open windows and deletes nothing"},
   "ST-11": {"built": "partial", "note": "Theme mode: Light / Dark / Match system (AP-01). Not built: window material (AP-10, Windows), app icon (AP-09), page defaults (P2)"},
   "ST-17": {"built": "yes", "note": "Settings → About: logo, version (a click copies it), build date, Chromium and Electron versions, system, Check for updates, release notes, Copy build info. Licence and Open-source credits open credits.html, built with the app (D43): Orbit's and Electron's licences, a link to the LICENSES.chromium.html Electron ships, and the licence of each npm package whose code ships. Release notes and help need access to the private repository for now"},
-  "OB-13": {"built": "partial", "note": "command-bar Help, Report a Bug, What's New and Copy Build Info; macOS Help menu (Orbit Help, Report a Bug…, Release Notes, Troubleshooting → Copy Build Info). Help opens the project README; Report a Bug opens a new issue on the public tracker with the build info filled in. The shortcut sheet entry comes with OB-12 (keys lane)"},
+  "OB-12": {"built": "yes", "note": "Help → Keyboard Shortcuts (macOS Help menu; the command bar’s Keyboard Shortcuts everywhere; a key can be assigned) opens a sheet over the window with the essential keys as they are now (KS-18), grouped Everyday, Navigation, Spaces and Split View, “None” for an action with no key; Esc, ✕, a click outside, Close Tab’s keys or asking again close it; the link at the bottom opens Settings → Shortcuts. Asked from Settings or a Mini Window, it opens over the browser window behind (a new one if there is none)"},
+  "OB-13": {"built": "yes", "note": "command-bar Help, Report a Bug, What's New and Copy Build Info; macOS Help menu (Orbit Help, Report a Bug…, Release Notes, Troubleshooting → Copy Build Info). Help opens the project README; Report a Bug opens a new issue on the public tracker with the build info filled in. Help → Keyboard Shortcuts (macOS) and the command bar’s Keyboard Shortcuts open the shortcut sheet (OB-12, keys lane)"},
   "UP-01": {"built": "partial", "note": "checks a release feed at launch (after 30 s) and about every 4 h ± 30 min, after wake if overdue; silent, failures retried at the next check; a private in-memory session that sends only Orbit's version, system and processor type (no cookies). Nothing is checked until a feed is set in Settings → General (empty by default; test and dev builds accept only a feed on this computer). Not built: background download (builds are unsigned, so UP-10's stub)"},
   "UP-02": {"built": "partial", "note": "sidebar banner above the Space switcher, in the Space's colours: a pill that opens on hover with a gradient button; ✕ hides it for 24 h or until the next launch. UP-10 form: \"New version available\" opens the release page in a tab; no relaunch until signed builds"},
   "UP-03": {"built": "partial", "note": "command bar and macOS app menu \"Check for Updates…\" open Settings → About (not a separate window) and check: Checking…, up to date, available, or the failure; Download opens the release page (UP-10); a click on the version copies it. Not built: download progress and Relaunch, the Turn on offer (UP-04), a ☰ entry on Windows/Linux"},
diff --git a/src/main/keys/index.ts b/src/main/keys/index.ts
index 1108ed0a..2261594d 100644
--- a/src/main/keys/index.ts
+++ b/src/main/keys/index.ts
@@ -4,7 +4,9 @@ import { onKeymapChange, setCustomBindings } from '../../shared/keymap'
 import type { MainContext } from '../context'
 import { installMenu } from '../menu'
 import { bind, reset, setPriority, unbind } from './bindings'
+import { lastMenuHints } from './menu-hints'
 import { keyRouter } from './router'
+import { registerShortcutSheet } from './sheet'
 import { setSystemClashesForTest, systemClashes } from './system'
 import { registerTabKeys } from './tab-keys'
 import { registerWindowKeys } from './window-keys'
@@ -78,10 +80,14 @@ export function registerKeys(ctx: MainContext): void {
   commands.register('keys.systemClashes', () => systemClashes())
   registerWindowKeys(ctx)
   registerTabKeys(ctx)
+  registerShortcutSheet(ctx)
   keyRouter.init(ctx)
   commands.register('keys.record', ({ on }, c) => keyRouter.setRecording(on ? c.windowId : undefined))
-  // Tests say which keys the system keeps instead of asking it.
+  // Tests say which keys the system keeps instead of asking it, and read the keys a menu showed.
   if (ctx.e2e) {
-    ;(globalThis as unknown as { __orbitKeys: unknown }).__orbitKeys = { setSystemClashes: setSystemClashesForTest }
+    ;(globalThis as unknown as { __orbitKeys: unknown }).__orbitKeys = {
+      setSystemClashes: setSystemClashesForTest,
+      lastMenuHints,
+    }
   }
 }
diff --git a/src/main/keys/menu-hints.ts b/src/main/keys/menu-hints.ts
new file mode 100644
index 00000000..3791bdfa
--- /dev/null
+++ b/src/main/keys/menu-hints.ts
@@ -0,0 +1,98 @@
+import type { MenuItemConstructorOptions } from 'electron'
+import { ACTIONS_BY_ID, shortcutsFor, toElectronAccelerator } from '../../shared/actions'
+
+/**
+ * Shortcut hints in Orbit's right-click menus (KS-18). An item that does what an action does shows
+ * the action's first key, read from the live keymap each time the menu is built, so a remap shows
+ * the next time the menu opens. The hint is only shown: Orbit's key router runs the keys, so the
+ * item never registers them.
+ */
+
+/** Items, by label, and the action whose keys do the same. */
+export type KeyHints = readonly (readonly [label: string | RegExp, actionId: string])[]
+
+/**
+ * The tab menu and the menu of a multi-selection (src/main/tabs/menus.ts). Only items that do what
+ * the key does: ⌘W and ⌘⇧C act on every selected tab, as Close 3 Tabs and Copy Links do, but the
+ * Markdown copy key copies one link.
+ */
+export const TAB_MENU_KEYS: KeyHints = [
+  ['Pin Tab', 'tab.togglePin'],
+  ['Unpin Tab', 'tab.togglePin'],
+  ['Add to Favorites', 'tab.favorite'],
+  ['Reset to Pinned URL', 'tab.resetToPinned'],
+  ['Rename…', 'tab.rename'],
+  ['Copy Link', 'tab.copyUrl'],
+  ['Copy Links', 'tab.copyUrl'],
+  ['Copy Link as Markdown', 'tab.copyUrlMarkdown'],
+  ['Duplicate', 'tab.duplicate'],
+  ['Mute Tab', 'tab.toggleMute'],
+  ['Unmute Tab', 'tab.toggleMute'],
+  ['Close Tab', 'tab.close'],
+  [/^Close \d+ Tabs$/, 'tab.close'],
+]
+
+/**
+ * The page menu (src/main/tabs/context-menu.ts, src/main/nav/page-menu.ts). Copy Page URL copies
+ * the address as it is, and the Copy URL key copies it without tracking parameters, so it gets no hint.
+ */
+export const PAGE_MENU_KEYS: KeyHints = [
+  ['Back', 'nav.back'],
+  ['Forward', 'nav.forward'],
+  ['Reload', 'nav.reload'],
+  ['Print…', 'page.print'],
+  ['View Page Source', 'page.viewSource'],
+]
+
+/** A split pane's menu (src/main/split/index.ts): its items do to that pane what the keys do to the focused one. */
+export const SPLIT_PANE_MENU_KEYS: KeyHints = [
+  ['Add Split Right', 'split.addRight'],
+  ['Add Split Left', 'split.addLeft'],
+  ['Add Split Above', 'split.addAbove'],
+  ['Add Split Below', 'split.addBelow'],
+  ['Flip Orientation', 'split.flip'],
+  ['Equalize Sizes', 'split.equalize'],
+  ['Separate Tabs', 'split.separate'],
+  ['Close Pane', 'split.close'],
+]
+
+/** The hints of the menu built last, as "Label=Accelerator" (tests). */
+let lastHints: string[] = []
+
+/** The action an item's label names in `hints`, if any. */
+function actionOf(label: string, hints: KeyHints): string | undefined {
+  return hints.find(([match]) => (typeof match === 'string' ? match === label : match.test(label)))?.[1]
+}
+
+/**
+ * The menu with each item that `hints` names showing its action's first key now. An item with a
+ * role or an accelerator of its own keeps it; submenus are looked through too.
+ */
+export function withKeyHints(
+  items: MenuItemConstructorOptions[],
+  hints: KeyHints,
+  platform: string = process.platform,
+): MenuItemConstructorOptions[] {
+  const shown: string[] = []
+  const walk = (list: MenuItemConstructorOptions[]): MenuItemConstructorOptions[] =>
+    list.map((item) => {
+      const submenu = Array.isArray(item.submenu) ? walk(item.submenu) : item.submenu
+      const actionId =
+        item.label && !item.role && item.accelerator === undefined ? actionOf(item.label, hints) : undefined
+      const action = actionId ? ACTIONS_BY_ID[actionId] : undefined
+      const key = action ? shortcutsFor(action, platform)[0] : undefined
+      const next = submenu === item.submenu ? item : { ...item, submenu }
+      if (!key) return next
+      const accelerator = toElectronAccelerator(key)
+      shown.push(`${item.label}=${accelerator}`)
+      return { ...next, accelerator, registerAccelerator: false }
+    })
+  const out = walk(items)
+  lastHints = shown
+  return out
+}
+
+/** The hints of the menu built last (tests). */
+export function lastMenuHints(): string[] {
+  return lastHints
+}
diff --git a/src/main/keys/sheet.ts b/src/main/keys/sheet.ts
new file mode 100644
index 00000000..d55d91e4
--- /dev/null
+++ b/src/main/keys/sheet.ts
@@ -0,0 +1,41 @@
+import { SHORTCUT_SHEET } from '../../shared/commands/keys'
+import type { WindowId } from '../../shared/state'
+import type { MainContext } from '../context'
+
+/**
+ * Help → Keyboard Shortcuts (OB-12): the sheet of essential shortcuts shows in a browser window's
+ * overlay (src/renderer/src/keys/ShortcutSheet.tsx). From Settings or a Mini Window it shows in
+ * the browser window they belong to, or the last one used; with none open, in a new one.
+ */
+export function registerShortcutSheet(ctx: MainContext): void {
+  const { store, windows, commands, actions } = ctx
+  const sheetOpen = (windowId: WindowId | undefined): boolean => {
+    const overlay = windowId ? store.state.windows[windowId]?.overlay : undefined
+    return overlay?.kind === 'panel' && overlay.panel === SHORTCUT_SHEET
+  }
+  const close = (windowId: WindowId) => void commands.run('overlay.close', {}, { windowId })
+  const browserWindow = (id: WindowId | undefined): id is WindowId =>
+    !!id && !!windows.get(id) && !!store.state.windows[id] && store.state.windows[id]?.kind !== 'mini'
+
+  actions.register('help.shortcuts', (c) => {
+    const from = c.windowId ?? windows.focusedWindowId()
+    const windowId = browserWindow(from) ? from : (windows.ids().filter(browserWindow).at(-1) ?? windows.open())
+    // Asked again while it is up: it closes, as the command bar does.
+    if (sheetOpen(windowId)) {
+      close(windowId)
+      return
+    }
+    const win = windows.get(windowId)
+    if (win && !win.isDestroyed() && !win.isFocused()) win.focus()
+    void commands.run('overlay.open', { overlay: { kind: 'panel', panel: SHORTCUT_SHEET } }, { windowId })
+  })
+
+  // KS-19: while the sheet is up, Close Tab's keys close the sheet rather than the tab under it.
+  actions.intercept((id, c) => {
+    if (id !== 'tab.close') return false
+    const windowId = c.windowId ?? windows.focusedWindowId()
+    if (!windowId || !sheetOpen(windowId)) return false
+    close(windowId)
+    return true
+  })
+}
diff --git a/src/main/menu.ts b/src/main/menu.ts
index ed7be71b..e241efc9 100644
--- a/src/main/menu.ts
+++ b/src/main/menu.ts
@@ -161,6 +161,8 @@ export function installMenu(ctx: MainContext): void {
       // Help and feedback (OB-13), release notes (UP-06), Restore Data… (AR-11) and build info (UP-07).
       submenu: [
         item('help.open', 'Orbit Help'),
+        // The essential shortcuts (OB-12).
+        item('help.shortcuts'),
         item('help.reportBug', 'Report a Bug…'),
         item('help.releaseNotes', 'Release Notes'),
         { type: 'separator' },
diff --git a/src/main/split/index.ts b/src/main/split/index.ts
index 6a37e4c9..ed6d2bbc 100644
--- a/src/main/split/index.ts
+++ b/src/main/split/index.ts
@@ -22,6 +22,7 @@ import type { ContainerRef, OrbitState, SplitId, SplitLayout, TabId, WindowId }
 import { paletteFor } from '../../shared/theme'
 import { insertItem, locate, sectionOf, splitOfTab } from '../../shared/tree'
 import type { MainContext } from '../context'
+import { SPLIT_PANE_MENU_KEYS, withKeyHints } from '../keys/menu-hints'
 import type { CallContext } from '../registry'
 import { makeTab } from '../tabs/model'
 import { activeTabOf } from '../windows'
@@ -616,7 +617,8 @@ export function registerSplit(ctx: MainContext): void {
 
   commands.register('split.paneMenu', ({ tabId }, c) => {
     const windowId = windowOf(c)
-    const items = paneControls(tabId, windowId)
+    // Keys lane: an item that a key also does shows the key (KS-18).
+    const items = withKeyHints(paneControls(tabId, windowId), SPLIT_PANE_MENU_KEYS)
     const win = windowId ? windows.get(windowId) : undefined
     if (items.length > 0) Menu.buildFromTemplate(items).popup(win ? { window: win } : {})
   })
diff --git a/src/main/tabs/commands.ts b/src/main/tabs/commands.ts
index 903e74ef..d48b2b56 100644
--- a/src/main/tabs/commands.ts
+++ b/src/main/tabs/commands.ts
@@ -25,6 +25,7 @@ import {
 import { engineForWindow, parseInput } from '../../shared/url'
 import type { MainContext } from '../context'
 import { KEEP_KEYBOARD } from '../keys/focus'
+import { TAB_MENU_KEYS, withKeyHints } from '../keys/menu-hints'
 import type { CallContext } from '../registry'
 import { tabSplitMenuItems } from '../split/menu'
 import { TabMaintenance } from './maintenance'
@@ -373,7 +374,9 @@ export function registerTabs(ctx: MainContext): { ops: TabOps; maintenance: TabM
     const windowId = windowOf(c)
     const state = store.state
     const mo = menuOps(windowId)
-    const all = isFolderId(id) ? folderMenu(state, id, mo) : isTabId(id) ? tabMenu(state, id, selection, mo) : []
+    // Keys lane: an item that a key also does shows the key (KS-18).
+    const forTab = (tabId: TabId) => withKeyHints(tabMenu(state, tabId, selection, mo), TAB_MENU_KEYS)
+    const all = isFolderId(id) ? folderMenu(state, id, mo) : isTabId(id) ? forTab(id) : []
     // Private windows have no pinned tabs, Favorites, folders or other Spaces (NV-11, SB-25).
     const items = isTabId(id) && isPrivateTab(state, id) ? privateTabMenu(all) : all
     if (items.length === 0) return
diff --git a/src/main/tabs/context-menu.ts b/src/main/tabs/context-menu.ts
index c5410caf..195acb7e 100644
--- a/src/main/tabs/context-menu.ts
+++ b/src/main/tabs/context-menu.ts
@@ -3,6 +3,7 @@ import { pageMayOpen } from '../../shared/link-routing'
 import type { TabId } from '../../shared/state'
 import { engineFor, searchUrl } from '../../shared/url'
 import type { MainContext } from '../context'
+import { PAGE_MENU_KEYS, withKeyHints } from '../keys/menu-hints'
 import {
   dictionaryItems,
   keepPageMenu,
@@ -134,6 +135,8 @@ export function showPageContextMenu(ctx: MainContext, tabId: TabId, contents: We
     )
   }
   items.push({ label: 'Inspect', click: () => contents.inspectElement(params.x, params.y) })
-  if (keepPageMenu(ctx, tabId, items)) return
-  Menu.buildFromTemplate(items).popup()
+  // Keys lane: shortcut hints (KS-18).
+  const hinted = withKeyHints(items, PAGE_MENU_KEYS)
+  if (keepPageMenu(ctx, tabId, hinted)) return
+  Menu.buildFromTemplate(hinted).popup()
 }
diff --git a/src/renderer/src/keys/ShortcutSheet.tsx b/src/renderer/src/keys/ShortcutSheet.tsx
new file mode 100644
index 00000000..80c62a68
--- /dev/null
+++ b/src/renderer/src/keys/ShortcutSheet.tsx
@@ -0,0 +1,94 @@
+import { X } from 'lucide-react'
+import { useEffect, useRef } from 'react'
+import { invoke } from '../api'
+import { useOrbit } from '../store'
+import { useKeymap } from './live'
+import { sheetGroups } from './sheet'
+import './sheet.css'
+
+const close = () => invoke('overlay.close', {})
+
+/**
+ * Help → Keyboard Shortcuts (OB-12): a compact sheet of the essential shortcuts over the window,
+ * in the overlay, with the keys they have now (KS-18). Esc, ✕ or a click outside closes it; the
+ * link at the bottom opens Settings → Shortcuts for the full, editable list.
+ */
+export function ShortcutSheet({ dark = false }: { dark?: boolean }) {
+  useKeymap()
+  const lastTabOnCmd9 = useOrbit((s) => s.settings.lastTabOnCmd9)
+  const groups = sheetGroups(window.orbit.platform, { lastTabOnCmd9 })
+  const sheet = useRef<HTMLDivElement>(null)
+
+  // The overlay has the keyboard while the sheet is up (KS-19): Esc closes it wherever focus is.
+  useEffect(() => {
+    sheet.current?.focus()
+    const onKey = (e: KeyboardEvent) => {
+      if (e.key !== 'Escape' || e.defaultPrevented) return
+      e.preventDefault()
+      void close()
+    }
+    window.addEventListener('keydown', onKey)
+    return () => window.removeEventListener('keydown', onKey)
+  }, [])
+
+  return (
+    <div className="ks-sheet-layer">
+      <div
+        ref={sheet}
+        className={`ks-sheet${dark ? ' ks-sheet--dark' : ''}`}
+        role="dialog"
+        aria-modal="true"
+        aria-labelledby="ks-sheet-title"
+        tabIndex={-1}
+        data-testid="shortcut-sheet"
+      >
+        <header className="ks-sheet__head">
+          <h2 id="ks-sheet-title">Keyboard Shortcuts</h2>
+          <button
+            type="button"
+            className="ks-sheet__close"
+            aria-label="Close"
+            data-testid="shortcut-sheet-close"
+            onClick={() => void close()}
+          >
+            <X size={14} />
+          </button>
+        </header>
+        <div className="ks-sheet__groups">
+          {groups.map((group) => (
+            <section key={group.title} className="ks-sheet__group" data-testid="shortcut-sheet-group">
+              <h3>{group.title}</h3>
+              <dl>
+                {group.rows.map((row) => (
+                  <div key={row.title} className="ks-sheet__row" data-testid="shortcut-sheet-row">
+                    <dt>{row.title}</dt>
+                    <dd>
+                      {row.keys ? (
+                        <kbd data-testid="shortcut-sheet-keys">{row.keys}</kbd>
+                      ) : (
+                        <span className="ks-sheet__none">None</span>
+                      )}
+                    </dd>
+                  </div>
+                ))}
+              </dl>
+            </section>
+          ))}
+        </div>
+        <footer className="ks-sheet__foot">
+          <button
+            type="button"
+            className="ks-sheet__link"
+            data-testid="shortcut-sheet-settings"
+            onClick={() => {
+              void invoke('settings.open', { section: 'shortcuts' })
+              void close()
+            }}
+          >
+            All shortcuts, and changing them: Settings → Shortcuts
+          </button>
+        </footer>
+      </div>
+    </div>
+  )
+}
diff --git a/src/renderer/src/keys/sheet.css b/src/renderer/src/keys/sheet.css
new file mode 100644
index 00000000..fc72990e
--- /dev/null
+++ b/src/renderer/src/keys/sheet.css
@@ -0,0 +1,194 @@
+/*
+ * The keyboard shortcut sheet (OB-12) in the overlay: a card centred over the window, in the
+ * Space's colours, that opens with the popover timing (a fade and 0.97 → 1).
+ */
+
+.ks-sheet-layer {
+  position: absolute;
+  inset: 0;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  padding: 16px;
+  background: rgba(10, 10, 14, 0.12);
+  pointer-events: none;
+}
+
+.ks-sheet {
+  --sheet-bg: color-mix(in srgb, var(--frame-top, #fff) 14%, rgba(255, 255, 255, 0.98));
+  --sheet-text: #1c1c1f;
+  --sheet-muted: rgba(28, 28, 31, 0.55);
+  --sheet-line: rgba(0, 0, 0, 0.07);
+  --sheet-kbd: rgba(0, 0, 0, 0.055);
+  box-sizing: border-box;
+  display: flex;
+  flex-direction: column;
+  width: min(720px, 100%);
+  max-height: 100%;
+  border-radius: 13px;
+  background: var(--sheet-bg);
+  color: var(--sheet-text);
+  box-shadow:
+    0 0 0 0.5px rgba(0, 0, 0, 0.16),
+    0 22px 56px rgba(0, 0, 0, 0.24),
+    0 4px 14px rgba(0, 0, 0, 0.1);
+  font-size: 13px;
+  line-height: 1.35;
+  outline: none;
+  user-select: none;
+  pointer-events: auto;
+  animation: ks-sheet-in 150ms var(--ease-out, ease-out);
+}
+
+.ks-sheet--dark {
+  --sheet-bg: color-mix(in srgb, var(--frame-top, #000) 26%, rgba(30, 30, 34, 0.98));
+  --sheet-text: #f2f2f4;
+  --sheet-muted: rgba(242, 242, 244, 0.55);
+  --sheet-line: rgba(255, 255, 255, 0.08);
+  --sheet-kbd: rgba(255, 255, 255, 0.09);
+  box-shadow:
+    0 0 0 0.5px rgba(255, 255, 255, 0.12),
+    0 22px 56px rgba(0, 0, 0, 0.5),
+    0 4px 14px rgba(0, 0, 0, 0.3);
+}
+
+@keyframes ks-sheet-in {
+  from {
+    opacity: 0;
+    transform: scale(0.97);
+  }
+}
+
+@media (prefers-reduced-motion: reduce) {
+  .ks-sheet {
+    animation: none;
+  }
+}
+
+.ks-sheet__head {
+  position: relative;
+  padding: 14px 44px 12px 18px;
+  border-bottom: 1px solid var(--sheet-line);
+}
+
+.ks-sheet__head h2 {
+  margin: 0;
+  font-size: 15px;
+  font-weight: 650;
+}
+
+.ks-sheet__close {
+  position: absolute;
+  top: 10px;
+  right: 10px;
+  display: grid;
+  place-items: center;
+  width: 26px;
+  height: 26px;
+  border: 0;
+  border-radius: 7px;
+  background: transparent;
+  color: var(--sheet-muted);
+}
+
+.ks-sheet__close:hover {
+  background: var(--sheet-kbd);
+  color: var(--sheet-text);
+}
+
+.ks-sheet__groups {
+  display: grid;
+  grid-template-columns: repeat(2, minmax(0, 1fr));
+  gap: 6px 28px;
+  padding: 12px 18px 14px;
+  overflow: auto;
+  scrollbar-width: thin;
+}
+
+@media (max-width: 560px) {
+  .ks-sheet__groups {
+    grid-template-columns: minmax(0, 1fr);
+  }
+}
+
+.ks-sheet__group h3 {
+  margin: 6px 0 4px;
+  color: var(--sheet-muted);
+  font-size: 11px;
+  font-weight: 600;
+  letter-spacing: 0.03em;
+  text-transform: uppercase;
+}
+
+.ks-sheet__group dl {
+  margin: 0;
+}
+
+.ks-sheet__row {
+  box-sizing: border-box;
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 12px;
+  min-height: 26px;
+  padding: 2px 0;
+  border-bottom: 1px solid var(--sheet-line);
+}
+
+.ks-sheet__row:last-child {
+  border-bottom: 0;
+}
+
+/* A long title wraps rather than hiding words; the keys keep their width up to 70% of the row. */
+.ks-sheet__row dt {
+  min-width: 0;
+  overflow-wrap: anywhere;
+}
+
+.ks-sheet__row dd {
+  flex: none;
+  max-width: 70%;
+  margin: 0;
+  text-align: right;
+}
+
+.ks-sheet__row kbd {
+  display: inline-block;
+  padding: 1px 6px;
+  border-radius: 5px;
+  background: var(--sheet-kbd);
+  color: var(--sheet-text);
+  font: inherit;
+  font-size: 12px;
+  font-variant-numeric: tabular-nums;
+}
+
+.ks-sheet__none {
+  color: var(--sheet-muted);
+  font-size: 12px;
+}
+
+.ks-sheet__foot {
+  padding: 10px 18px 14px;
+  border-top: 1px solid var(--sheet-line);
+}
+
+.ks-sheet__link {
+  padding: 0;
+  border: 0;
+  background: none;
+  color: var(--accent, #5865d8);
+  font: inherit;
+  font-weight: 550;
+  cursor: pointer;
+}
+
+.ks-sheet__link:hover {
+  text-decoration: underline;
+}
+
+.ks-sheet__link:focus-visible,
+.ks-sheet__close:focus-visible {
+  outline: 2px solid var(--accent, #5865d8);
+  outline-offset: 2px;
+}
diff --git a/src/renderer/src/keys/sheet.ts b/src/renderer/src/keys/sheet.ts
new file mode 100644
index 00000000..7f1b4f4d
--- /dev/null
+++ b/src/renderer/src/keys/sheet.ts
@@ -0,0 +1,100 @@
+import { ACTIONS_BY_ID, formatAccelerator, shortcutsFor } from '../../../shared/actions'
+
+/**
+ * The keyboard shortcut sheet (OB-12): the essential shortcuts, grouped as Everyday, Navigation,
+ * Spaces and Split View, with the keys they have now (KS-18). Pure, so it is unit-tested; the
+ * full, editable list is Settings → Shortcuts (ST-08).
+ */
+
+/** One line of the sheet: one action, a pair ("Next / Previous Space") or a numbered run ("Go to Tab 1–8"). */
+type Line =
+  | { title?: string; action: string }
+  | { title: string; pair: readonly [string, string] }
+  | { title: string; run: readonly [string, string] }
+
+const SHEET: readonly { title: string; lines: readonly Line[] }[] = [
+  {
+    title: 'Everyday',
+    lines: [
+      { title: 'New Tab or Search', action: 'tab.new' },
+      { action: 'tab.close' },
+      { action: 'tab.reopenClosed' },
+      { action: 'sidebar.toggle' },
+      { action: 'tab.togglePin' },
+      { action: 'tab.copyUrl' },
+      { action: 'page.find' },
+      { action: 'window.new' },
+      { action: 'window.newMini' },
+      { action: 'app.settings' },
+    ],
+  },
+  {
+    title: 'Navigation',
+    lines: [
+      { action: 'url.edit' },
+      { title: 'Back / Forward', pair: ['nav.back', 'nav.forward'] },
+      { action: 'nav.reload' },
+      { action: 'tab.recent' },
+      { title: 'Next / Previous Tab', pair: ['tab.next', 'tab.previous'] },
+      { title: 'Go to Tab 1–8', run: ['tab.goto.1', 'tab.goto.8'] },
+      { action: 'tab.goto.9' },
+    ],
+  },
+  {
+    title: 'Spaces',
+    lines: [
+      { title: 'Next / Previous Space', pair: ['space.next', 'space.previous'] },
+      { title: 'Switch to Space 1–9', run: ['space.goto.1', 'space.goto.9'] },
+    ],
+  },
+  {
+    title: 'Split View',
+    lines: [
+      { action: 'split.add' },
+      { action: 'split.close' },
+      { title: 'Next / Previous Pane', pair: ['split.focusNext', 'split.focusPrevious'] },
+      { title: 'Focus Pane 1–4', run: ['split.focus.1', 'split.focus.4'] },
+    ],
+  },
+]
+
+export interface SheetRow {
+  title: string
+  /** The keys as this platform shows them ("⌘T", "⌘1–⌘8", "⌘⌥→ / ⌘⌥←"); '' when there are none. */
+  keys: string
+}
+
+export interface SheetGroup {
+  title: string
+  rows: SheetRow[]
+}
+
+export interface SheetOptions {
+  /** ⌘9 goes to the last item (Go to Last Tab) or the ninth (Go to Tab 9) (TB-04). */
+  lastTabOnCmd9: boolean
+}
+
+/** The sheet as it is now: each line's title and the first key of each of its actions. */
+export function sheetGroups(platform: string, options: SheetOptions): SheetGroup[] {
+  const key = (id: string) => {
+    const action = ACTIONS_BY_ID[id]
+    const accel = action ? shortcutsFor(action, platform)[0] : undefined
+    return accel ? formatAccelerator(accel, platform) : ''
+  }
+  const row = (line: Line): SheetRow => {
+    if ('action' in line) {
+      const title =
+        line.action === 'tab.goto.9' && !options.lastTabOnCmd9
+          ? 'Go to Tab 9'
+          : (line.title ?? ACTIONS_BY_ID[line.action]?.title ?? line.action)
+      return { title, keys: key(line.action) }
+    }
+    if ('pair' in line) {
+      const keys = line.pair.map(key)
+      return { title: line.title, keys: keys.some(Boolean) ? keys.map((k) => k || '—').join(' / ') : '' }
+    }
+    const [first, last] = line.run.map(key)
+    return { title: line.title, keys: first && last ? `${first}–${last}` : '' }
+  }
+  return SHEET.map((group) => ({ title: group.title, rows: group.lines.map(row) }))
+}
diff --git a/src/renderer/src/overlay/OverlayApp.tsx b/src/renderer/src/overlay/OverlayApp.tsx
index 456de586..64db37be 100644
--- a/src/renderer/src/overlay/OverlayApp.tsx
+++ b/src/renderer/src/overlay/OverlayApp.tsx
@@ -1,6 +1,8 @@
 import { AnimatePresence, domAnimation, LazyMotion, MotionConfig } from 'motion/react'
 import { type CSSProperties, useEffect, useState } from 'react'
+import { SHORTCUT_SHEET } from '../../../shared/commands/keys'
 import { invoke } from '../api'
+import { ShortcutSheet } from '../keys/ShortcutSheet'
 import { isSpacePanel, SpacePanels } from '../shell/spaces/SpacePanels'
 import { useWindow } from '../store'
 import { paletteVars, usePalette } from '../theme'
@@ -59,6 +61,9 @@ export function OverlayApp() {
           {overlay?.kind === 'panel' && overlay.panel === 'site-controls' && (
             <SiteControls key={overlay.nonce} overlay={overlay} dark={palette?.dark} />
           )}
+          {overlay?.kind === 'panel' && overlay.panel === SHORTCUT_SHEET && (
+            <ShortcutSheet key={overlay.nonce} dark={palette?.dark} />
+          )}
           {overlay?.kind === 'peek' && <PeekLayer key={overlay.nonce} overlay={overlay} />}
         </div>
       </MotionConfig>
diff --git a/src/shared/actions.ts b/src/shared/actions.ts
index af60142a..5f3d920f 100644
--- a/src/shared/actions.ts
+++ b/src/shared/actions.ts
@@ -392,6 +392,13 @@ export const ACTIONS: ActionDef[] = [
     category: 'App',
     keywords: ['clear archive', 'delete archived tabs', 'empty archive'],
   },
+  // Help → Keyboard Shortcuts: the essential shortcuts (OB-12); the full list is Settings → Shortcuts.
+  {
+    id: 'help.shortcuts',
+    title: 'Keyboard Shortcuts',
+    category: 'App',
+    keywords: ['shortcut sheet', 'cheat sheet', 'essential shortcuts', 'keys', 'hotkeys', 'help'],
+  },
 
   // Spaces
   { id: 'space.new', title: 'New Space', category: 'Spaces', keywords: ['create space'] },
diff --git a/src/shared/commands/keys.ts b/src/shared/commands/keys.ts
index 9ad0bb44..632433aa 100644
--- a/src/shared/commands/keys.ts
+++ b/src/shared/commands/keys.ts
@@ -49,6 +49,9 @@ export interface SystemClash {
   owner: string
 }
 
+/** The overlay panel of Help → Keyboard Shortcuts (OB-12): `{ kind: 'panel', panel: SHORTCUT_SHEET }`. */
+export const SHORTCUT_SHEET = 'shortcuts'
+
 /** The Go to Tab options (TB-04, FV-10, ST-08). */
 export interface TabNumberOptions {
   /** ⌘1–⌘8 count Favorites first. */
diff --git a/tests/e2e/keys.spec.ts b/tests/e2e/keys.spec.ts
index f7424f08..844bd464 100644
--- a/tests/e2e/keys.spec.ts
+++ b/tests/e2e/keys.spec.ts
@@ -837,3 +837,88 @@ test('[ST-08][KS-03][ST-02] keys the system keeps are marked until the action ge
   await expect(results.getByTestId('setting-shortcut-space.goto.2')).toBeHidden()
   await expect(results.getByTestId('shortcuts-search')).toBeHidden()
 })
+
+// ---------- Shortcut hints in right-click menus (KS-18) ----------
+
+/** The keys the right-click menu built last showed, as "Label=Accelerator". */
+const menuHints = () =>
+  orbit.app.evaluate(() =>
+    (globalThis as unknown as { __orbitKeys: { lastMenuHints: () => string[] } }).__orbitKeys.lastMenuHints(),
+  )
+
+/** A binding as a menu writes it. */
+const menuKey = (key: string) => `${isMac ? 'Command' : 'Control'}+${key}`
+
+test('[KS-18] remap Pin to ⌘⇧P: the command bar’s row and the tab’s right-click menu show it; the page menu shows the keys it has as it opens', async () => {
+  const { app } = orbit
+  const pin = `${PRIMARY}+Shift+P`
+  expect(await run(app, 'keys.bind', { actionId: 'tab.togglePin', accel: pin, replace: `${PRIMARY}+D` })).toEqual({
+    ok: true,
+  })
+  const id = await openTab(app, fx.url('/page/Hints'))
+  const { overlay, top } = await actionRow('pin tab', 'Pin / Unpin Tab')
+  await expect(top.getByTestId('command-shortcut')).toHaveText(isMac ? '⇧⌘P' : 'Ctrl+Shift+P')
+  await overlay.keyboard.press('Escape')
+  await cmd(app, 'tabs.contextMenu', { id })
+  expect(await menuHints()).toEqual(
+    expect.arrayContaining([`Pin Tab=${menuKey('Shift+P')}`, `Close Tab=${menuKey('W')}`]),
+  )
+
+  // The page's own menu: Reload shows its keys, and another key once remapped.
+  const page = await tabPage(app, '/page/Hints')
+  await page.mouse.click(12, 12, { button: 'right' })
+  await expect.poll(menuHints).toContain(`Reload=${menuKey('R')}`)
+  expect(await run(app, 'keys.bind', { actionId: 'nav.reload', accel: 'F9', replace: `${PRIMARY}+R` })).toEqual({
+    ok: true,
+  })
+  await page.mouse.click(12, 12, { button: 'right' })
+  await expect.poll(menuHints).toContain('Reload=F9')
+})
+
+// ---------- Help → Keyboard Shortcuts (OB-12) ----------
+
+test('[OB-12][KS-18][KS-12] Help → Keyboard Shortcuts shows the essential keys as they are now; Esc or Close Tab’s keys close it; its link opens Settings → Shortcuts', async () => {
+  const { app } = orbit
+  expect(await run(app, 'keys.bind', { actionId: 'sidebar.toggle', accel: `${PRIMARY}+Shift+B` })).toEqual({ ok: true })
+  await run(app, 'keys.unbind', { actionId: 'sidebar.toggle', accel: `${PRIMARY}+S` })
+  const tab = await openTab(app, fx.url('/page/Sheet'))
+  if (isMac) {
+    const help = await app.evaluate(({ Menu }) =>
+      Menu.getApplicationMenu()
+        ?.items.find((i) => i.role === 'help')
+        ?.submenu?.items.map((i) => i.label),
+    )
+    expect(help).toContain('Keyboard Shortcuts')
+  }
+  await action(app, 'help.shortcuts')
+  const overlay = await viewPage(app, 'overlay')
+  const sheet = overlay.getByTestId('shortcut-sheet')
+  await expect(sheet.getByTestId('shortcut-sheet-group').locator('h3')).toHaveText([
+    'Everyday',
+    'Navigation',
+    'Spaces',
+    'Split View',
+  ])
+  const row = (title: string) => sheet.getByTestId('shortcut-sheet-row').filter({ hasText: title })
+  await expect(row('Toggle Sidebar').getByTestId('shortcut-sheet-keys')).toHaveText(SHIFT_B)
+  await expect(row('Go to Tab 1–8')).toContainText(isMac ? '⌘1–⌘8' : 'Ctrl+1–Ctrl+8')
+  await expect(sheet).toBeFocused()
+  await pressAnywhere('Escape')
+  await expect(sheet).toHaveCount(0)
+  await expect.poll(async () => Object.values((await state(app)).windows)[0]?.overlay.kind).toBe('none')
+
+  // From the command bar too; Close Tab's keys close the sheet, and the tab under it stays.
+  const { top } = await actionRow('keyboard shortcuts', 'Keyboard Shortcuts')
+  await top.click()
+  await expect(sheet).toBeVisible()
+  await pressAnywhere('W', PRIMARY_MOD)
+  await expect(sheet).toHaveCount(0)
+  expect((await state(app)).tabs[tab]).toBeDefined()
+
+  // The link at the bottom: the full, editable list.
+  await action(app, 'help.shortcuts')
+  await sheet.getByTestId('shortcut-sheet-settings').click()
+  const settings = await pageOfView(app, 'settings')
+  await expect(settings.getByTestId('settings-tab-shortcuts')).toHaveAttribute('aria-selected', 'true')
+  await expect.poll(async () => Object.values((await state(app)).windows)[0]?.overlay.kind).toBe('none')
+})
diff --git a/tests/unit/keymap-menu-hints.test.ts b/tests/unit/keymap-menu-hints.test.ts
new file mode 100644
index 00000000..b7fd525b
--- /dev/null
+++ b/tests/unit/keymap-menu-hints.test.ts
@@ -0,0 +1,103 @@
+import type { MenuItemConstructorOptions } from 'electron'
+import { afterEach, describe, expect, it } from 'vitest'
+import { PAGE_MENU_KEYS, SPLIT_PANE_MENU_KEYS, TAB_MENU_KEYS, withKeyHints } from '../../src/main/keys/menu-hints'
+import { type MenuOps, tabMenu } from '../../src/main/tabs/menus'
+import { makeTab } from '../../src/main/tabs/model'
+import { createInitialState, DEFAULT_PROFILE_ID } from '../../src/shared/defaults'
+import { setCustomBindings } from '../../src/shared/keymap'
+
+/** Shortcut hints in right-click menus (KS-18). */
+
+afterEach(() => setCustomBindings(undefined))
+
+const ops = new Proxy({}, { get: () => () => {} }) as MenuOps
+
+function setup() {
+  const state = createInitialState(0)
+  const spaceId = state.spaceOrder[0] as string
+  const add = (where: 'today' | 'pinned', fields: { muted?: boolean } = {}) => {
+    const tab = makeTab({ spaceId, profileId: DEFAULT_PROFILE_ID, url: 'https://x.test/', ...fields })
+    state.tabs[tab.id] = tab
+    state.spaces[spaceId]?.[where].push(tab.id)
+    return tab.id
+  }
+  return { state, add }
+}
+
+/** "Label=Accelerator" for each item showing a key, submenus included. */
+function hints(items: MenuItemConstructorOptions[]): string[] {
+  return items.flatMap((i) => [
+    ...(i.accelerator ? [`${i.label}=${i.accelerator}`] : []),
+    ...(Array.isArray(i.submenu) ? hints(i.submenu) : []),
+  ])
+}
+
+describe('[KS-18] keys in the tab menu', () => {
+  it('shows the keys of what each item does, as they are now', () => {
+    const { state, add } = setup()
+    const id = add('today')
+    const menu = withKeyHints(tabMenu(state, id, [], ops), TAB_MENU_KEYS, 'darwin')
+    expect(hints(menu)).toEqual([
+      'Pin Tab=Command+D',
+      'Copy Link=Command+Shift+C',
+      'Copy Link as Markdown=Command+Alt+Shift+C',
+      'Close Tab=Command+W',
+    ])
+    expect(menu.find((i) => i.label === 'Pin Tab')?.registerAccelerator).toBe(false)
+    setCustomBindings({ 'tab.togglePin': ['Cmd+Shift+P'], 'tab.duplicate': ['F7'] })
+    const after = hints(withKeyHints(tabMenu(state, id, [], ops), TAB_MENU_KEYS, 'darwin'))
+    expect(after).toContain('Pin Tab=Command+Shift+P')
+    expect(after).toContain('Duplicate=F7')
+    const linux = hints(withKeyHints(tabMenu(state, id, [], ops), TAB_MENU_KEYS, 'linux'))
+    expect(linux).toContain('Close Tab=Control+W')
+  })
+
+  it('names items the tab menus have: pinned, muted and several selected tabs', () => {
+    const { state, add } = setup()
+    const labels = (items: MenuItemConstructorOptions[]) => items.map((i) => i.label ?? '')
+    const today = add('today', { muted: true })
+    const pinned = add('pinned')
+    const other = add('today')
+    const all = new Set([
+      ...labels(tabMenu(state, today, [], ops)),
+      ...labels(tabMenu(state, pinned, [], ops)),
+      ...labels(tabMenu(state, other, [today, other], ops)),
+    ])
+    for (const [label] of TAB_MENU_KEYS) {
+      if (typeof label === 'string') expect(all, label).toContain(label)
+      else
+        expect(
+          [...all].some((l) => label.test(l)),
+          String(label),
+        ).toBe(true)
+    }
+    const several = hints(withKeyHints(tabMenu(state, other, [today, other], ops), TAB_MENU_KEYS, 'linux'))
+    expect(several).toEqual(['Copy Links=Control+Shift+C', 'Close 2 Tabs=Control+W'])
+  })
+})
+
+describe('[KS-18] keys in other menus', () => {
+  it('leaves items with a role or keys of their own, and looks into submenus', () => {
+    const menu = withKeyHints(
+      [
+        { role: 'copy' },
+        { label: 'Reload', accelerator: 'F5' },
+        { label: 'More', submenu: [{ label: 'Back' }, { label: 'Print…' }] },
+        { label: 'Unknown' },
+      ],
+      PAGE_MENU_KEYS,
+      'linux',
+    )
+    expect(hints(menu)).toEqual(['Reload=F5', 'Back=Alt+Left', 'Print…=Control+P'])
+    expect(menu[0]).toEqual({ role: 'copy' })
+    expect(menu[3]).toEqual({ label: 'Unknown' })
+  })
+
+  it("a split pane's menu shows the split keys, those given later too", () => {
+    const pane = () =>
+      withKeyHints([{ label: 'Flip Orientation' }, { label: 'Close Pane' }], SPLIT_PANE_MENU_KEYS, 'darwin')
+    expect(hints(pane())).toEqual(['Close Pane=Control+Shift+-'])
+    setCustomBindings({ 'split.flip': ['Ctrl+Shift+F'] })
+    expect(hints(pane())).toEqual(['Flip Orientation=Control+Shift+F', 'Close Pane=Control+Shift+-'])
+  })
+})
diff --git a/tests/unit/keymap-menu.test.ts b/tests/unit/keymap-menu.test.ts
new file mode 100644
index 00000000..7ace9096
--- /dev/null
+++ b/tests/unit/keymap-menu.test.ts
@@ -0,0 +1,95 @@
+import type { MenuItemConstructorOptions } from 'electron'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+
+/**
+ * The macOS menu bar as installMenu builds it, on any platform: Electron's Menu is replaced by one
+ * that keeps the template, and the Archive's own items by stand-ins.
+ */
+const menu = vi.hoisted(() => ({ template: [] as MenuItemConstructorOptions[] }))
+vi.mock('electron', () => ({
+  app: { name: 'Orbit' },
+  Menu: {
+    buildFromTemplate: (template: MenuItemConstructorOptions[]) => {
+      menu.template = template
+      return template
+    },
+    setApplicationMenu: () => {},
+  },
+}))
+vi.mock('../../src/main/archive/menus', () => ({ keepForMenu: () => ({ label: 'Keep Archived Tabs For' }) }))
+vi.mock('../../src/main/archive/recently-closed', () => ({ recentlyClosedItems: () => [] }))
+vi.mock('../../src/main/keys/router', () => ({ keyRouter: { menuRuns: () => true } }))
+
+import type { MainContext } from '../../src/main/context'
+import { installMenu } from '../../src/main/menu'
+import { ACTIONS_BY_ID } from '../../src/shared/actions'
+import { bindingProblem, setCustomBindings } from '../../src/shared/keymap'
+
+const platform = Object.getOwnPropertyDescriptor(process, 'platform') as PropertyDescriptor
+const ctx = { windows: { focusedWindowId: () => undefined } } as unknown as MainContext
+
+beforeEach(() => Object.defineProperty(process, 'platform', { ...platform, value: 'darwin' }))
+afterEach(() => {
+  Object.defineProperty(process, 'platform', platform)
+  setCustomBindings(undefined)
+})
+
+/** The menu built now: each top-level menu by its label or role. */
+function build(): Record<string, MenuItemConstructorOptions[]> {
+  installMenu(ctx)
+  return Object.fromEntries(
+    menu.template.map((m) => [m.label ?? m.role ?? '?', Array.isArray(m.submenu) ? m.submenu : []]),
+  )
+}
+
+const find = (items: MenuItemConstructorOptions[], label: string) => items.find((i) => i.label === label)
+
+describe('the macOS menu bar', () => {
+  it('[KS-15] keeps the system’s keys: Hide, Hide Others and Quit, the Window menu (⌘M, ⌘`) and the Help menu (⌘? search)', () => {
+    const menus = build()
+    expect(menus.Orbit?.filter((i) => i.role).map((i) => i.role)).toEqual([
+      'services',
+      'hide',
+      'hideOthers',
+      'unhide',
+      'quit',
+    ])
+    expect(menu.template.map((m) => m.role).filter(Boolean)).toEqual(['windowMenu', 'help'])
+    // No action may take them, so they always do what the system says.
+    const mac = { 'Cmd+Q': 'Quit Orbit', 'Cmd+H': 'Hide Orbit', 'Cmd+Alt+H': 'Hide Others', 'Cmd+M': 'Minimize' }
+    for (const [key, what] of Object.entries(mac)) expect(bindingProblem(key, 'darwin')).toContain(what)
+    expect(bindingProblem('Cmd+`', 'darwin')).toContain('switching between Orbit windows')
+    expect(bindingProblem('Cmd+Shift+/', 'darwin')).toContain('Help menu search')
+    for (const p of ['linux', 'win32']) {
+      expect(bindingProblem('Alt+F4', p)).toContain('closing the window')
+      expect(bindingProblem('Alt+Tab', p)).toContain('switching apps')
+    }
+    // Windows and Linux have no Help menu: F1 opens Help (OB-13).
+    expect(ACTIONS_BY_ID['help.open']?.other).toEqual(['F1'])
+  })
+
+  it('[KS-01][KS-18] shows each item’s keys as they are now, and none for an action without keys', () => {
+    let view = build().View ?? []
+    expect(find(view, 'Toggle Sidebar')?.accelerator).toBe('Command+S')
+    setCustomBindings({ 'sidebar.toggle': ['Cmd+Shift+B'], 'tab.togglePin': [] })
+    const menus = build()
+    view = menus.View ?? []
+    expect(find(view, 'Toggle Sidebar')?.accelerator).toBe('Command+Shift+B')
+    const pin = find(menus.Tabs ?? [], 'Pin / Unpin Tab')
+    expect(pin).toBeDefined()
+    expect(pin?.accelerator).toBeUndefined()
+  })
+
+  it('[KS-16] a key that edits text is only shown, so the menu never takes it from a text field', () => {
+    setCustomBindings({ 'tab.togglePin': ['Cmd+A'] })
+    const pin = find(build().Tabs ?? [], 'Pin / Unpin Tab')
+    expect(pin?.accelerator).toBe('Command+A')
+    expect(pin?.registerAccelerator).toBe(false)
+    expect(find(build().View ?? [], 'Toggle Sidebar')?.registerAccelerator).toBeUndefined()
+  })
+
+  it('[OB-12][OB-13] Help → Keyboard Shortcuts comes after Orbit Help', () => {
+    const help = build().help
+    expect(help?.map((i) => i.label).slice(0, 3)).toEqual(['Orbit Help', 'Keyboard Shortcuts', 'Report a Bug…'])
+  })
+})
diff --git a/tests/unit/keymap-sheet.test.ts b/tests/unit/keymap-sheet.test.ts
new file mode 100644
index 00000000..a442c552
--- /dev/null
+++ b/tests/unit/keymap-sheet.test.ts
@@ -0,0 +1,42 @@
+import { afterEach, describe, expect, it } from 'vitest'
+import { type SheetGroup, sheetGroups } from '../../src/renderer/src/keys/sheet'
+import { ACTIONS_BY_ID } from '../../src/shared/actions'
+import { setCustomBindings } from '../../src/shared/keymap'
+
+/** Help → Keyboard Shortcuts (OB-12): the essential shortcuts with the keys they have now (KS-18). */
+
+afterEach(() => setCustomBindings(undefined))
+
+const keysOf = (groups: SheetGroup[], title: string) =>
+  groups.flatMap((g) => g.rows).find((r) => r.title === title)?.keys
+
+describe('[OB-12] the shortcut sheet', () => {
+  it('groups the essential shortcuts as Everyday, Navigation, Spaces and Split View', () => {
+    const groups = sheetGroups('darwin', { lastTabOnCmd9: true })
+    expect(groups.map((g) => g.title)).toEqual(['Everyday', 'Navigation', 'Spaces', 'Split View'])
+    expect(groups.every((g) => g.rows.length > 0)).toBe(true)
+    expect(keysOf(groups, 'New Tab or Search')).toBe('⌘T')
+    expect(keysOf(groups, 'Back / Forward')).toBe('⌘[ / ⌘]')
+    expect(keysOf(groups, 'Go to Tab 1–8')).toBe('⌘1–⌘8')
+    expect(keysOf(groups, 'Switch to Space 1–9')).toBe('⌃1–⌃9')
+    expect(keysOf(groups, 'Focus Pane 1–4')).toBe('⌃⇧1–⌃⇧4')
+    const linux = sheetGroups('linux', { lastTabOnCmd9: true })
+    expect(keysOf(linux, 'Switch to Space 1–9')).toBe('Alt+1–Alt+9')
+    expect(keysOf(linux, 'Back / Forward')).toBe('Alt+← / Alt+→')
+  })
+
+  it('names only actions Orbit has', () => {
+    const ids = ['tab.new', 'tab.close', 'nav.back', 'space.goto.9', 'split.focus.4', 'help.shortcuts']
+    for (const id of ids) expect(ACTIONS_BY_ID[id], id).toBeDefined()
+  })
+
+  it('shows the keys after a remap, and says when an action has none', () => {
+    setCustomBindings({ 'tab.new': ['Cmd+Shift+Y'], 'nav.back': [], 'tab.reopenClosed': [] })
+    const groups = sheetGroups('darwin', { lastTabOnCmd9: false })
+    expect(keysOf(groups, 'New Tab or Search')).toBe('⇧⌘Y')
+    expect(keysOf(groups, 'Back / Forward')).toBe('— / ⌘]')
+    expect(keysOf(groups, 'Reopen Closed Tab')).toBe('')
+    // ⌘9 is named after what it does (TB-04).
+    expect(keysOf(groups, 'Go to Tab 9')).toBe('⌘9')
+  })
+})

From e2ffa0c0f417bb8b79f258b089ca5af7b775d139 Mon Sep 17 00:00:00 2001
From: Siya <57148521+siyabendoezdemir@users.noreply.github.com>
Date: Sat, 10 Oct 2026 17:33:25 +0000
Subject: [PATCH 08/11] feat(keys): keys in private windows, Mini Windows and
 full screen (KS-20, KS-10)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- A private window has no Spaces, pinned tabs, Favorites or folders: the
  actions that need them (⌘D, ⌃1–9 / Alt+1–9, ⌘⌥← / ⌘⌥→, ⌘⇧K Clear, every
  Space action) do nothing there, from a key, a menu or the command bar, and a
  toast says "Not available in a private window". Before, ⌘⇧K archived every
  private tab. Tab keys still work.
- Mini Window: ⌘L now moves the keyboard into the address field, so what is
  typed next lands there (it stayed with the page). Help → Keyboard Shortcuts
  from a Mini Window opens over the browser window (it was swallowed).
  Both are small edits in src/main/miniwindow/index.ts.
- Tests: private-window keys, Mini Window keys (⌘S, ⌃2, zoom, ⌘R, ⌘⌥O, ⌘L,
  the sheet, ⌘W) and full screen with the sidebar hidden (⌘1–9, ⌘⌥↑/↓).
- The browser window an action from Settings or a Mini Window acts in is
  shared (keys/browser-window.ts) for the sheet and Open File.
- Status: KS-10 yes, KS-20 partial (Mini Window ⌘F, the blank window and
  extension keys are not built).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 FEATURES.md                               |   8 +-
 docs/feature-status.json                  |   2 +
 src/main/keys/browser-window.ts           |  14 ++
 src/main/keys/index.ts                    |   2 +
 src/main/keys/sheet.ts                    |   6 +-
 src/main/keys/special-windows.ts          |  39 +++++
 src/main/miniwindow/index.ts              |  12 +-
 tests/e2e/keys.spec.ts                    | 185 +++++++++++++++++++++-
 tests/unit/keymap-special-windows.test.ts |  63 ++++++++
 9 files changed, 321 insertions(+), 10 deletions(-)
 create mode 100644 src/main/keys/browser-window.ts
 create mode 100644 src/main/keys/special-windows.ts
 create mode 100644 tests/unit/keymap-special-windows.test.ts

diff --git a/FEATURES.md b/FEATURES.md
index 801a1ac7..f7d1a672 100644
--- a/FEATURES.md
+++ b/FEATURES.md
@@ -4,12 +4,12 @@
 
 Every row is one behaviour from the clean-room spec. Status per ID: **spec’d** (every row) → **built** → **tested** (a unit or e2e test names the ID) → **feels right** (lead sign-off after a hands-on review against `feel.md`).
 
-**Totals:** 472 spec’d · 209 built (74 partial) · 292 tested · 0 feel right. 13 more are out of scope and not counted.
+**Totals:** 472 spec’d · 210 built (75 partial) · 293 tested · 0 feel right. 13 more are out of scope and not counted.
 
 | Priority | Spec’d | Built | Tested |
 |---|---|---|---|
 | P0 | 174 | 136 | 164 |
-| P1 | 219 | 64 | 117 |
+| P1 | 219 | 65 | 118 |
 | P2 | 79 | 9 | 11 |
 
 P0 = milestone-1 core experience, P1 = parity, P2 = later.
@@ -355,7 +355,7 @@ Spec: `spec/shortcuts.md`
 | KS-07 | Spaces | P0 | ✅ | ✅ e2e+unit | – | Space shortcuts wired through the action table |
 | KS-08 | Page navigation and page tools | P0 | 🟡 partial | ✅ e2e+unit | – | Back, Forward, Reload, hard reload, Stop, find (Cmd+F, Cmd+G, Shift+Cmd+G, F3, Ctrl+G), Cmd+J and zoom keys done; print, save page, reader mode and the rest come with their NV items |
 | KS-09 | Split view | P0 | ✅ | ✅ e2e+unit | – | ⌃⇧= adds a pane the command bar fills, ⌃⇧− closes the focused pane, ⌃⇧1–4 focus a pane, ⌃⇧] / ⌃⇧[ the next / previous pane (Ctrl+Shift on Windows/Linux), ⌘L / Ctrl+L changes the focused pane's address (SV-15), Add Right/Left/Above/Below Split from the command bar; tested from a page |
-| KS-10 | Peek and Mini Window | P1 | – | ✅ unit | – |  |
+| KS-10 | Peek and Mini Window | P1 | ✅ | ✅ e2e+unit | – | ⌘O / Ctrl+O expands a Peek into a selected Today tab (PK-07); Esc and ⌘W / Ctrl+W close it (PK-09, Esc fixed); ⌘⇧T and ⌘Z reopen it (PK-10); ⌘⌥N / Ctrl+Alt+N opens a Mini Window (MW-06); in a Mini Window ⌘O moves its page into the most recent Space (MW-05), ⌘⌥O (also ⌘⇧O) / Ctrl+Alt+O offers the Spaces, ⌘W closes it (MW-09). All from the one keymap and remappable but Esc; the tests press the keys (peek, mini-window and keys specs) |
 | KS-11 | Media | P1 | 🟡 partial | ✅ e2e+unit | – | Space and arrows in the focused player, Cmd/Ctrl+scroll and pinch zoom (tested), hardware media keys via Chromium (untested), Mute Tab action assignable; the calendar meeting shortcut (P2) belongs to TB-21/FV-09 |
 | KS-12 | Library, history, downloads, settings, extensions, help | P1 | 🟡 partial | ✅ e2e+unit | – | ⌘Y / Ctrl+H View History (AR-10); ⌘⇧L Open Library on macOS, the command bar elsewhere; View Archive with no key, assignable; ⌘, / Ctrl+, Settings, which cannot be remapped, and again brings the same Settings window to the front; ⌘⇧⌫ / Ctrl+Shift+Delete Clear Browsing Data…; Shortcut Settings (command bar, assignable); the shortcut sheet from Help → Keyboard Shortcuts (macOS) and the command bar (OB-12); Alt+F stays free for the Windows/Linux app menu (SB-03, SB-26, not built). Not built: Open Downloads (DL-14, downloads lane), Open a local file (⌘O / Ctrl+O when no Peek or Mini Window has focus), pinned extensions (EX-06) |
 | KS-13 | Developer tools | P1 | – | ✅ unit | – |  |
@@ -365,7 +365,7 @@ Spec: `spec/shortcuts.md`
 | KS-17 | Mouse, trackpad and modifier-click bindings | P0 | – | – | – |  |
 | KS-18 | Shortcut hints everywhere | P1 | ✅ | ✅ e2e+unit | – | button tooltips (address, copy link, site controls, sidebar toggle, back/forward/reload, find, zoom, Library, Clear, Space dots, Peek, Mini Window Open in…), the empty-window hint, command-bar rows, macOS menu items, the shortcut sheet (OB-12) and the right-click menus of a tab, a multi-selection, the page and a split pane (an item that does what a key does shows that key’s first binding) follow a remap without a restart; a menu shows it the next time it opens. Windows and Linux have no app menu yet (SB-03, SB-26), so there is no menu bar there to label |
 | KS-19 | Keys inside overlays | P0 | 🟡 partial | ✅ e2e | – | the open overlay takes its keys first: command bar (⌘T/⌘L/⌘W/Esc), find bar (Enter/⇧Enter/Esc, NV-05), Peek (Esc, ⌘O, ⌘W, PK-09; Esc closes the Peek and the tab under it keeps loading), the recent-tab switcher (Tab/⇧Tab/`, W, letting go of ⌃), permission prompt and site controls (Esc), the sidebar with keyboard focus (arrows, Enter, Esc back to the page, SB-22); Esc then stops a loading page, as before, even one that uses Esc itself: Electron runs no isolated-world script in a page while it loads, so Orbit can't learn in time whether the page used the key (needs a lead decision: a script in the page's own world or a preload channel, D40) |
-| KS-20 | Shortcuts in special windows | P1 | – | – | – |  |
+| KS-20 | Shortcuts in special windows | P1 | 🟡 partial | ✅ e2e+unit | – | private window: the same keys, but the actions that need Spaces, pinned tabs, Favorites or folders (⌘D, ⌃1–9 / Alt+1–9, ⌘⌥← / ⌘⌥→, ⌘⇧K Clear, Favorite, New Folder, every Space action) do nothing there, from a key, a menu or the command bar, and a toast says “Not available in a private window”; tab keys work. Mini Window: ⌘W closes it, ⌘O / ⌘⌥O move or offer to move its page (KS-10), ⌘L edits its address with the keyboard in the field, ⌘R, zoom and print act on its page, sidebar and Space keys do nothing, Help → Keyboard Shortcuts opens over the browser window. Full screen: every key works with the sidebar hidden; ⌘1–9 and ⌘⌥↑ / ⌘⌥↓ switch tabs without bringing it out. Not built: ⌘F in a Mini Window (it has no find bar, Mini Window lane), the blank window (TB-17), extension keys in private windows (EX-06, EX-10) |
 
 ## Interaction feel and motion targets (prefix FL)
 
diff --git a/docs/feature-status.json b/docs/feature-status.json
index 8994ce17..0085fca3 100644
--- a/docs/feature-status.json
+++ b/docs/feature-status.json
@@ -225,6 +225,8 @@
   "FL-32": {"built": "yes", "note": "corner resize follows the pointer, resists past its limits (rubber band) and springs back on release; a fling heads for the corner in its direction and settles with the spring; tray slides up with the snappy timing; Back to tab flies to the video's place; pinch zooms (MD-06) rather than resizes"},
   "KS-11": {"built": "partial", "note": "Space and arrows in the focused player, Cmd/Ctrl+scroll and pinch zoom (tested), hardware media keys via Chromium (untested), Mute Tab action assignable; the calendar meeting shortcut (P2) belongs to TB-21/FV-09"},
   "KS-12": {"built": "partial", "note": "⌘Y / Ctrl+H View History (AR-10); ⌘⇧L Open Library on macOS, the command bar elsewhere; View Archive with no key, assignable; ⌘, / Ctrl+, Settings, which cannot be remapped, and again brings the same Settings window to the front; ⌘⇧⌫ / Ctrl+Shift+Delete Clear Browsing Data…; Shortcut Settings (command bar, assignable); the shortcut sheet from Help → Keyboard Shortcuts (macOS) and the command bar (OB-12); Alt+F stays free for the Windows/Linux app menu (SB-03, SB-26, not built). Not built: Open Downloads (DL-14, downloads lane), Open a local file (⌘O / Ctrl+O when no Peek or Mini Window has focus), pinned extensions (EX-06)"},
+  "KS-10": {"built": "yes", "note": "⌘O / Ctrl+O expands a Peek into a selected Today tab (PK-07); Esc and ⌘W / Ctrl+W close it (PK-09, Esc fixed); ⌘⇧T and ⌘Z reopen it (PK-10); ⌘⌥N / Ctrl+Alt+N opens a Mini Window (MW-06); in a Mini Window ⌘O moves its page into the most recent Space (MW-05), ⌘⌥O (also ⌘⇧O) / Ctrl+Alt+O offers the Spaces, ⌘W closes it (MW-09). All from the one keymap and remappable but Esc; the tests press the keys (peek, mini-window and keys specs)"},
+  "KS-20": {"built": "partial", "note": "private window: the same keys, but the actions that need Spaces, pinned tabs, Favorites or folders (⌘D, ⌃1–9 / Alt+1–9, ⌘⌥← / ⌘⌥→, ⌘⇧K Clear, Favorite, New Folder, every Space action) do nothing there, from a key, a menu or the command bar, and a toast says “Not available in a private window”; tab keys work. Mini Window: ⌘W closes it, ⌘O / ⌘⌥O move or offer to move its page (KS-10), ⌘L edits its address with the keyboard in the field, ⌘R, zoom and print act on its page, sidebar and Space keys do nothing, Help → Keyboard Shortcuts opens over the browser window. Full screen: every key works with the sidebar hidden; ⌘1–9 and ⌘⌥↑ / ⌘⌥↓ switch tabs without bringing it out. Not built: ⌘F in a Mini Window (it has no find bar, Mini Window lane), the blank window (TB-17), extension keys in private windows (EX-06, EX-10)"},
   "SB-10": {"built": "partial", "note": "media tray and call controls (media lane), above the bottom bar, pushing the list up; download progress and the update banner belong to other lanes"},
   "PK-01": {"built": "yes", "note": "floating card over the source tab; one Peek per window; links inside navigate it"},
   "PK-02": {"built": "yes", "note": "other-site (eTLD+1) link clicks, Enter on a focused link, and target=_blank in pinned tabs/Favorites; same-site navigates. Only a navigation to the clicked link counts, so form posts, script navigations and auto-posted sign-ins stay in the tab"},
diff --git a/src/main/keys/browser-window.ts b/src/main/keys/browser-window.ts
new file mode 100644
index 00000000..05c421bc
--- /dev/null
+++ b/src/main/keys/browser-window.ts
@@ -0,0 +1,14 @@
+import type { WindowId } from '../../shared/state'
+import type { MainContext } from '../context'
+
+/**
+ * The browser window an action asked from `from` acts in (OB-12, KS-12): that window, or for
+ * Settings or a Mini Window the browser window they belong to or the last one used; with none
+ * open, a new one.
+ */
+export function browserWindowFor(ctx: MainContext, from: WindowId | undefined): WindowId {
+  const { store, windows } = ctx
+  const isBrowser = (id: WindowId | undefined): id is WindowId =>
+    !!id && !!windows.get(id) && !!store.state.windows[id] && store.state.windows[id]?.kind !== 'mini'
+  return isBrowser(from) ? from : (windows.ids().filter(isBrowser).at(-1) ?? windows.open())
+}
diff --git a/src/main/keys/index.ts b/src/main/keys/index.ts
index 2261594d..e69ff400 100644
--- a/src/main/keys/index.ts
+++ b/src/main/keys/index.ts
@@ -7,6 +7,7 @@ import { bind, reset, setPriority, unbind } from './bindings'
 import { lastMenuHints } from './menu-hints'
 import { keyRouter } from './router'
 import { registerShortcutSheet } from './sheet'
+import { registerSpecialWindows } from './special-windows'
 import { setSystemClashesForTest, systemClashes } from './system'
 import { registerTabKeys } from './tab-keys'
 import { registerWindowKeys } from './window-keys'
@@ -81,6 +82,7 @@ export function registerKeys(ctx: MainContext): void {
   registerWindowKeys(ctx)
   registerTabKeys(ctx)
   registerShortcutSheet(ctx)
+  registerSpecialWindows(ctx)
   keyRouter.init(ctx)
   commands.register('keys.record', ({ on }, c) => keyRouter.setRecording(on ? c.windowId : undefined))
   // Tests say which keys the system keeps instead of asking it, and read the keys a menu showed.
diff --git a/src/main/keys/sheet.ts b/src/main/keys/sheet.ts
index d55d91e4..4597eae6 100644
--- a/src/main/keys/sheet.ts
+++ b/src/main/keys/sheet.ts
@@ -1,6 +1,7 @@
 import { SHORTCUT_SHEET } from '../../shared/commands/keys'
 import type { WindowId } from '../../shared/state'
 import type { MainContext } from '../context'
+import { browserWindowFor } from './browser-window'
 
 /**
  * Help → Keyboard Shortcuts (OB-12): the sheet of essential shortcuts shows in a browser window's
@@ -14,12 +15,9 @@ export function registerShortcutSheet(ctx: MainContext): void {
     return overlay?.kind === 'panel' && overlay.panel === SHORTCUT_SHEET
   }
   const close = (windowId: WindowId) => void commands.run('overlay.close', {}, { windowId })
-  const browserWindow = (id: WindowId | undefined): id is WindowId =>
-    !!id && !!windows.get(id) && !!store.state.windows[id] && store.state.windows[id]?.kind !== 'mini'
 
   actions.register('help.shortcuts', (c) => {
-    const from = c.windowId ?? windows.focusedWindowId()
-    const windowId = browserWindow(from) ? from : (windows.ids().filter(browserWindow).at(-1) ?? windows.open())
+    const windowId = browserWindowFor(ctx, c.windowId ?? windows.focusedWindowId())
     // Asked again while it is up: it closes, as the command bar does.
     if (sheetOpen(windowId)) {
       close(windowId)
diff --git a/src/main/keys/special-windows.ts b/src/main/keys/special-windows.ts
new file mode 100644
index 00000000..ff818605
--- /dev/null
+++ b/src/main/keys/special-windows.ts
@@ -0,0 +1,39 @@
+import { isPrivateWindow } from '../../shared/private'
+import type { MainContext } from '../context'
+
+/**
+ * Keys in special windows (KS-20). A private window has no Spaces, pinned tabs, Favorites or
+ * folders (NV-11, SB-25), so the actions that need them do nothing there, whether a key, a menu or
+ * the command bar asks, and a short hint says why rather than leaving the press unanswered. Mini
+ * Windows route their keys themselves (src/main/miniwindow/index.ts).
+ */
+
+/** What the hint says. */
+export const PRIVATE_WINDOW_HINT = 'Not available in a private window'
+
+/** Actions on pinned tabs, Favorites, folders and Today's Clear (⌘D, ⌘⇧K…); every Space action is one too. */
+const NEEDS_SPACES = new Set([
+  'tab.togglePin',
+  'tab.favorite',
+  'tab.resetToPinned',
+  'tab.pickSpace',
+  'pinned.toggleCollapsed',
+  'folder.new',
+  'tabs.clearToday',
+])
+
+/** Whether an action needs the Spaces, pinned tabs, Favorites or folders a private window doesn't have. */
+export function needsSpaces(actionId: string): boolean {
+  return NEEDS_SPACES.has(actionId) || actionId.startsWith('space.')
+}
+
+export function registerSpecialWindows(ctx: MainContext): void {
+  const { store, windows, actions } = ctx
+  actions.intercept((id, c) => {
+    if (!needsSpaces(id)) return false
+    const windowId = c.windowId ?? windows.focusedWindowId()
+    if (!windowId || !isPrivateWindow(store.state, windowId)) return false
+    ctx.toast(windowId, PRIVATE_WINDOW_HINT)
+    return true
+  })
+}
diff --git a/src/main/miniwindow/index.ts b/src/main/miniwindow/index.ts
index 4fcb7d92..e8f6c699 100644
--- a/src/main/miniwindow/index.ts
+++ b/src/main/miniwindow/index.ts
@@ -690,7 +690,15 @@ export function registerMiniWindow(ctx: MainContext): void {
   actions.register('mini.toggleAll', toggleAll)
 
   // In a Mini Window, keys act on its page; sidebar, Space and tab-list keys do nothing (KS-20).
-  const APP_ACTIONS = new Set(['window.new', 'window.newMini', 'window.newPrivate', 'app.settings', 'app.archive'])
+  // Help → Keyboard Shortcuts opens over the browser window behind (OB-12, keys lane).
+  const APP_ACTIONS = new Set([
+    'window.new',
+    'window.newMini',
+    'window.newPrivate',
+    'app.settings',
+    'app.archive',
+    'help.shortcuts',
+  ])
   actions.intercept((id, c) => {
     const mini = miniOf(c)
     if (!mini) return false
@@ -706,6 +714,8 @@ export function registerMiniWindow(ctx: MainContext): void {
         if (mini.tabId) send(mini, 'mini:choose-space')
         return true
       case 'url.edit':
+        // The keyboard goes to the address field too: the page had it (KS-20, keys lane).
+        if (!mini.win.isDestroyed()) mini.win.webContents.focus()
         send(mini, 'mini:edit-url')
         return true
       case 'tab.new': {
diff --git a/tests/e2e/keys.spec.ts b/tests/e2e/keys.spec.ts
index 844bd464..347bf32a 100644
--- a/tests/e2e/keys.spec.ts
+++ b/tests/e2e/keys.spec.ts
@@ -1,6 +1,19 @@
 import { expect, type Page, test } from '@playwright/test'
 import { action, isMac, launchOrbit, MOD, type Orbit, run, state, tabPage, viewPage } from './helpers'
-import { cmd, type NavFixtures, openTab, pressInPage, startNavFixtures, visit } from './nav-support'
+import {
+  cmd,
+  cmdIn,
+  type NavFixtures,
+  openTab,
+  pressInPage,
+  setNativeFullScreen,
+  startNavFixtures,
+  uiPageOf,
+  visit,
+  windowList,
+  windowState,
+  zoomOf,
+} from './nav-support'
 import { openSettings, osWindows, pageOfView } from './settings-support'
 import { activeSpace, createSpace } from './spaces-support'
 
@@ -922,3 +935,173 @@ test('[OB-12][KS-18][KS-12] Help → Keyboard Shortcuts shows the essential keys
   await expect(settings.getByTestId('settings-tab-shortcuts')).toHaveAttribute('aria-selected', 'true')
   await expect.poll(async () => Object.values((await state(app)).windows)[0]?.overlay.kind).toBe('none')
 })
+
+// ---------- Keys in special windows (KS-20) ----------
+
+type ActionHook = { __orbit: { action: (id: string, windowId?: string) => Promise<void> } }
+
+/** Runs an action as if from this window (its menu, its command bar). */
+function actionIn(windowId: string, id: string): Promise<void> {
+  return orbit.app.evaluate(async (_e, [w, a]) => (globalThis as unknown as ActionHook).__orbit.action(a, w), [
+    windowId,
+    id,
+  ] as const)
+}
+
+/** Counts the hints main shows from now on, by message. */
+async function countHints(): Promise<() => Promise<Record<string, number>>> {
+  await orbit.app.evaluate(() => {
+    const g = globalThis as unknown as {
+      __orbit: { ctx: { toast: (w: string | undefined, m: string) => void } }
+      __hints?: Record<string, number>
+    }
+    const seen: Record<string, number> = {}
+    g.__hints = seen
+    const show = g.__orbit.ctx.toast.bind(g.__orbit.ctx)
+    g.__orbit.ctx.toast = (w, m) => {
+      seen[m] = (seen[m] ?? 0) + 1
+      show(w, m)
+    }
+  })
+  return () => orbit.app.evaluate(() => ({ ...(globalThis as unknown as { __hints: Record<string, number> }).__hints }))
+}
+
+test('[KS-20][SB-25] in a private window the keys for pinning, Spaces and Clear do nothing and say so; tab keys still work', async () => {
+  const { app, shell } = orbit
+  await createSpace(app, { name: 'Other', activate: false })
+  await openTab(app, fx.url('/page/Normal'))
+  await shell.keyboard.press(`${MOD}+Shift+N`)
+  await expect.poll(async () => (await windowList(app)).map((w) => w.kind)).toEqual(['main', 'private'])
+  const [main, priv] = await windowList(app)
+  if (!main || !priv) throw new Error('no private window')
+  await cmdIn(app, priv.id, 'overlay.close')
+  const first = await cmdIn<string>(app, priv.id, 'tabs.create', { url: fx.url('/page/PrivOne') })
+  const second = await cmdIn<string>(app, priv.id, 'tabs.create', { url: fx.url('/page/PrivTwo') })
+  await expect.poll(() => fx.hits('/page/PrivTwo')).toBe(1)
+  await expect.poll(async () => (await state(app)).tabs[second]?.loading).toBe(false)
+  const where = async () => {
+    const s = await state(app)
+    const space = s.spaces[priv.spaceId]
+    return {
+      privateSpace: s.windows[priv.id]?.spaceId,
+      mainSpace: s.windows[main.id]?.spaceId,
+      pinned: space?.pinned.length,
+      today: space?.today.length,
+      spaces: s.spaceOrder.length,
+    }
+  }
+  const before = await where()
+  expect(before).toMatchObject({ privateSpace: priv.spaceId, mainSpace: main.spaceId, pinned: 0, today: 2 })
+  const hints = await countHints()
+  const HINT = 'Not available in a private window'
+  const keys: [name: string, key: string, mods: Mod[]][] = [
+    ['Pin', 'D', PRIMARY_MOD],
+    ['Space 2', '2', isMac ? ['control'] : ['alt']],
+    ['Next Space', 'Right', isMac ? ['meta', 'alt'] : ['control', 'alt']],
+    ['Clear Today', 'K', [...PRIMARY_MOD, 'shift']],
+  ]
+  for (const [i, [name, key, mods]] of keys.entries()) {
+    await pressInPage(app, '/page/PrivTwo', key, mods)
+    await expect.poll(async () => (await hints())[HINT], name).toBe(i + 1)
+    expect(await where(), name).toEqual(before)
+  }
+  // The hint shows in the private window.
+  const sidebar = await uiPageOf(app, 'shell', priv.id)
+  await expect(sidebar.getByTestId('toast').filter({ hasText: HINT }).first()).toBeVisible()
+  // The same from its menus and command bar.
+  await actionIn(priv.id, 'space.new')
+  await expect.poll(async () => (await hints())[HINT]).toBe(keys.length + 1)
+  expect(await where()).toEqual(before)
+  // Keys for its own tabs work: ⌘2 selects the second, the one opened first.
+  expect((await state(app)).spaces[priv.spaceId]?.today).toEqual([second, first])
+  await pressInPage(app, '/page/PrivTwo', '2', PRIMARY_MOD)
+  await expect.poll(async () => (await state(app)).windows[priv.id]?.activeTab[priv.spaceId]).toBe(first)
+})
+
+test('[KS-20][KS-10][OB-12] in a Mini Window keys act on its page: ⌘L edits its address, ⌘R and zoom work, sidebar and Space keys do nothing, ⌘⌥O offers the Spaces and ⌘W closes it', async () => {
+  const { app } = orbit
+  await createSpace(app, { name: 'Elsewhere', activate: false })
+  const main = Object.values((await state(app)).windows)[0]
+  if (!main) throw new Error('no window')
+  const path = '/page/InMini'
+  await app.evaluate(({ app: a }, u) => a.emit('open-url', { preventDefault() {} }, u), fx.url(path))
+  const miniOf = async () => Object.values((await state(app)).windows).find((w) => w.kind === 'mini')
+  await expect.poll(async () => (await miniOf())?.id).toBeTruthy()
+  const mini = (await miniOf()) as NonNullable<Awaited<ReturnType<typeof miniOf>>>
+  await expect.poll(() => fx.hits(path)).toBe(1)
+  await expect.poll(async () => (await state(app)).tabs[mini.activeTab[mini.spaceId] ?? '']?.loading).toBe(false)
+  // Native menus are recorded rather than shown.
+  await app.evaluate(({ Menu }) => {
+    const g = globalThis as unknown as { __popups: string[][] }
+    g.__popups = []
+    Menu.prototype.popup = function (this: Electron.Menu) {
+      g.__popups.push(this.items.map((i) => i.label))
+    }
+  })
+  const popups = () => app.evaluate(() => (globalThis as unknown as { __popups: string[][] }).__popups)
+
+  // Sidebar and Space keys do nothing; the zoom after them shows they were taken in order.
+  await pressInPage(app, path, 'S', PRIMARY_MOD)
+  await pressInPage(app, path, '2', isMac ? ['control'] : ['alt'])
+  await pressInPage(app, path, '=', PRIMARY_MOD)
+  await expect.poll(() => zoomOf(app, path)).toBeCloseTo(1.1, 3)
+  const s = await state(app)
+  expect(s.windows[main.id]?.sidebar.visible).toBe(main.sidebar.visible)
+  expect(s.windows[main.id]?.spaceId).toBe(main.spaceId)
+  // ⌘R reloads its page.
+  await pressInPage(app, path, 'R', PRIMARY_MOD)
+  await expect.poll(() => fx.hits(path)).toBe(2)
+  // ⌘⌥O offers the Spaces to move the page into (MW-05).
+  await pressInPage(app, path, 'O', [...PRIMARY_MOD, 'alt'])
+  await expect.poll(popups).toEqual([expect.arrayContaining([expect.stringContaining('Elsewhere')])])
+  // ⌘L edits its address, and the keyboard goes with it: what is typed next goes into the field.
+  await pressInPage(app, path, 'L', PRIMARY_MOD)
+  const ui = app.windows().find((p) => p.url().includes('view=mini'))
+  if (!ui) throw new Error('no Mini Window UI')
+  const address = ui.getByTestId('mini-address-input')
+  await expect(address).toBeFocused()
+  await expect.poll(focusedUrl).toContain('view=mini')
+  expect(await typeAnywhere(['q'])).toEqual([expect.stringContaining('view=mini')])
+  await expect(address).toHaveValue('q')
+  await ui.keyboard.press('Escape')
+  await expect(address).toHaveCount(0)
+  // Help → Keyboard Shortcuts asked with the Mini Window in front opens over the browser window.
+  await actionIn(mini.id, 'help.shortcuts')
+  await expect
+    .poll(async () => (await state(app)).windows[main.id]?.overlay)
+    .toMatchObject({ kind: 'panel', panel: 'shortcuts' })
+  expect((await state(app)).windows[mini.id]).toBeDefined()
+  await cmdIn(app, main.id, 'overlay.close')
+  // ⌘W closes it, and only it.
+  await pressInPage(app, path, 'W', PRIMARY_MOD)
+  await expect.poll(miniOf).toBeUndefined()
+  expect((await state(app)).windows[main.id]).toBeDefined()
+})
+
+test('[KS-20][KS-06] in full screen with the sidebar hidden, ⌘1–9 and ⌘⌥↑ / ⌘⌥↓ switch tabs without it', async () => {
+  const { app } = orbit
+  const spaceId = await activeSpace(app)
+  const c = await openTab(app, fx.url('/page/FsThird'))
+  const b = await openTab(app, fx.url('/page/FsSecond'))
+  const a = await openTab(app, fx.url('/page/FsFirst'))
+  expect((await state(app)).spaces[spaceId]?.today).toEqual([a, b, c])
+  await setNativeFullScreen(app, true)
+  await action(app, 'sidebar.toggle')
+  await expect.poll(async () => (await windowState(app)).sidebar.visible).toBe(false)
+  await selectPage(a, fx.url('/page/FsFirst'))
+  const mod: Mod = isMac ? 'meta' : 'control'
+  await pressMod('3')
+  await expect.poll(activeTab).toBe(c)
+  await expect.poll(focusedUrl).toBe(fx.url('/page/FsThird'))
+  await pressAnywhere('Up', [mod, 'alt'])
+  await expect.poll(activeTab).toBe(b)
+  await expect.poll(focusedUrl).toBe(fx.url('/page/FsSecond'))
+  await pressAnywhere('Down', [mod, 'alt'])
+  await expect.poll(activeTab).toBe(c)
+  await expect.poll(focusedUrl).toBe(fx.url('/page/FsThird'))
+  await pressMod('1')
+  await expect.poll(activeTab).toBe(a)
+  const win = await windowState(app)
+  expect(win.fullscreen).toBe(true)
+  expect(win.sidebar.visible).toBe(false)
+})
diff --git a/tests/unit/keymap-special-windows.test.ts b/tests/unit/keymap-special-windows.test.ts
new file mode 100644
index 00000000..70e80a07
--- /dev/null
+++ b/tests/unit/keymap-special-windows.test.ts
@@ -0,0 +1,63 @@
+import { describe, expect, it, vi } from 'vitest'
+import type { MainContext } from '../../src/main/context'
+import { needsSpaces, PRIVATE_WINDOW_HINT, registerSpecialWindows } from '../../src/main/keys/special-windows'
+import { ActionRegistry } from '../../src/main/registry'
+import { Store } from '../../src/main/store'
+import { ACTIONS, defaultShortcutsFor } from '../../src/shared/actions'
+import { createInitialState, createProfile, createSpace, createWindowState } from '../../src/shared/defaults'
+import { canonicalAccelerator } from '../../src/shared/keymap'
+
+/** Keys in special windows (KS-20): a private window has no Spaces, pinned tabs, Favorites or folders. */
+
+describe('[KS-20] keys in a private window', () => {
+  it('the actions behind ⌘D, ⌃1–9, ⌘⌥← / ⌘⌥→ and ⌘⇧K need Spaces, pinned tabs or Favorites; tab keys don’t', () => {
+    const keys = ['Cmd+D', 'Ctrl+1', 'Ctrl+5', 'Ctrl+9', 'Cmd+Alt+Left', 'Cmd+Alt+Right', 'Cmd+Shift+K']
+    for (const key of keys) {
+      const action = ACTIONS.find((a) =>
+        defaultShortcutsFor(a, 'darwin').some((k) => canonicalAccelerator(k) === canonicalAccelerator(key)),
+      )
+      expect(action, key).toBeDefined()
+      expect(needsSpaces(action?.id ?? ''), `${key}: ${action?.id}`).toBe(true)
+    }
+    for (const id of ['tab.goto.1', 'tab.next', 'tab.close', 'tab.new', 'nav.reload', 'sidebar.toggle', 'page.find']) {
+      expect(needsSpaces(id), id).toBe(false)
+    }
+  })
+
+  it('they do nothing there and say so; elsewhere they run', async () => {
+    const state = createInitialState(0)
+    const priv = { ...createProfile('Private', 'private-1'), partition: 'orbit-private-1' }
+    const privateSpace = createSpace('Private', priv.id)
+    state.profiles[priv.id] = priv
+    state.spaces[privateSpace.id] = privateSpace
+    const normal = createWindowState(state.spaceOrder[0] as string)
+    const privateWindow = createWindowState(privateSpace.id, 'private')
+    state.windows[normal.id] = normal
+    state.windows[privateWindow.id] = privateWindow
+    const actions = new ActionRegistry()
+    const toast = vi.fn()
+    const ctx = {
+      store: new Store(state),
+      actions,
+      windows: { focusedWindowId: () => privateWindow.id },
+      toast,
+    } as unknown as MainContext
+    registerSpecialWindows(ctx)
+    const ran: string[] = []
+    for (const id of ['tabs.clearToday', 'space.goto.2', 'tab.goto.1']) {
+      actions.register(id, (c) => void ran.push(`${id}@${c.windowId}`))
+    }
+
+    await actions.run('tabs.clearToday', { windowId: privateWindow.id })
+    await actions.run('space.goto.2', {})
+    expect(ran).toEqual([])
+    expect(toast.mock.calls).toEqual([
+      [privateWindow.id, PRIVATE_WINDOW_HINT],
+      [privateWindow.id, PRIVATE_WINDOW_HINT],
+    ])
+    await actions.run('tab.goto.1', { windowId: privateWindow.id })
+    await actions.run('tabs.clearToday', { windowId: normal.id })
+    expect(ran).toEqual([`tab.goto.1@${privateWindow.id}`, `tabs.clearToday@${normal.id}`])
+    expect(toast).toHaveBeenCalledTimes(2)
+  })
+})

From fc46c78940eeed9e470e99371036d469f587f0d9 Mon Sep 17 00:00:00 2001
From: Siya <57148521+siyabendoezdemir@users.noreply.github.com>
Date: Sat, 10 Oct 2026 17:42:07 +0000
Subject: [PATCH 09/11] =?UTF-8?q?feat(keys):=20Open=20File=E2=80=A6=20on?=
 =?UTF-8?q?=20=E2=8C=98O=20/=20Ctrl+O=20outside=20a=20Peek;=20F1=20stays?=
 =?UTF-8?q?=20Help=20on=20Windows=20and=20Linux=20(KS-12,=20KS-15)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- Open File… (macOS File menu, the command bar): the files chosen open in
  new tabs of the window, the last one selected. ⌘O / Ctrl+O are Open Peek
  as Tab's keys; where no Peek or Mini Window is open, the key router runs
  Open File on them instead (BORROWED_KEYS, keys/open-file.ts). The menu
  shows the key without registering it, and Settings → Shortcuts says it
  under Open File…, which can get keys of its own. From a Mini Window or
  Settings the files open in the browser window behind, which comes forward.
- windows.ts: one line asks keyRouter.actionIn for the action before it runs.
  miniwindow/index.ts: file.open passes through like help.shortcuts.
- `fixed` can be 'other' (Windows and Linux only), read through isFixed:
  F1 for Help can't be changed or taken there; on macOS Help has no keys
  and can be given some.
- Tests: ⌘O with no Peek (two files, cancel), Open File from a Mini Window,
  the Settings note and the locked F1, menu and keymap unit tests.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 FEATURES.md                             |   8 +-
 docs/feature-status.json                |   3 +-
 src/main/keys/bindings.ts               |  17 ++--
 src/main/keys/index.ts                  |   2 +
 src/main/keys/open-file.ts              |  44 +++++++++
 src/main/keys/router.ts                 |  10 ++
 src/main/menu.ts                        |  12 ++-
 src/main/miniwindow/index.ts            |   3 +-
 src/main/windows.ts                     |   6 +-
 src/renderer/src/keys/ShortcutsPage.tsx |  27 ++++-
 src/shared/actions.ts                   |  55 +++++++++--
 src/shared/commands/settings.ts         |   3 +-
 tests/e2e/keys.spec.ts                  |  89 +++++++++++++++++
 tests/unit/keymap-menu.test.ts          |  19 +++-
 tests/unit/keymap-open-file.test.ts     | 126 ++++++++++++++++++++++++
 tests/unit/keymap-remap.test.ts         |  25 ++++-
 16 files changed, 414 insertions(+), 35 deletions(-)
 create mode 100644 src/main/keys/open-file.ts
 create mode 100644 tests/unit/keymap-open-file.test.ts

diff --git a/FEATURES.md b/FEATURES.md
index f7d1a672..87b12bf0 100644
--- a/FEATURES.md
+++ b/FEATURES.md
@@ -4,12 +4,12 @@
 
 Every row is one behaviour from the clean-room spec. Status per ID: **spec’d** (every row) → **built** → **tested** (a unit or e2e test names the ID) → **feels right** (lead sign-off after a hands-on review against `feel.md`).
 
-**Totals:** 472 spec’d · 210 built (75 partial) · 293 tested · 0 feel right. 13 more are out of scope and not counted.
+**Totals:** 472 spec’d · 211 built (75 partial) · 293 tested · 0 feel right. 13 more are out of scope and not counted.
 
 | Priority | Spec’d | Built | Tested |
 |---|---|---|---|
 | P0 | 174 | 136 | 164 |
-| P1 | 219 | 65 | 118 |
+| P1 | 219 | 66 | 118 |
 | P2 | 79 | 9 | 11 |
 
 P0 = milestone-1 core experience, P1 = parity, P2 = later.
@@ -357,10 +357,10 @@ Spec: `spec/shortcuts.md`
 | KS-09 | Split view | P0 | ✅ | ✅ e2e+unit | – | ⌃⇧= adds a pane the command bar fills, ⌃⇧− closes the focused pane, ⌃⇧1–4 focus a pane, ⌃⇧] / ⌃⇧[ the next / previous pane (Ctrl+Shift on Windows/Linux), ⌘L / Ctrl+L changes the focused pane's address (SV-15), Add Right/Left/Above/Below Split from the command bar; tested from a page |
 | KS-10 | Peek and Mini Window | P1 | ✅ | ✅ e2e+unit | – | ⌘O / Ctrl+O expands a Peek into a selected Today tab (PK-07); Esc and ⌘W / Ctrl+W close it (PK-09, Esc fixed); ⌘⇧T and ⌘Z reopen it (PK-10); ⌘⌥N / Ctrl+Alt+N opens a Mini Window (MW-06); in a Mini Window ⌘O moves its page into the most recent Space (MW-05), ⌘⌥O (also ⌘⇧O) / Ctrl+Alt+O offers the Spaces, ⌘W closes it (MW-09). All from the one keymap and remappable but Esc; the tests press the keys (peek, mini-window and keys specs) |
 | KS-11 | Media | P1 | 🟡 partial | ✅ e2e+unit | – | Space and arrows in the focused player, Cmd/Ctrl+scroll and pinch zoom (tested), hardware media keys via Chromium (untested), Mute Tab action assignable; the calendar meeting shortcut (P2) belongs to TB-21/FV-09 |
-| KS-12 | Library, history, downloads, settings, extensions, help | P1 | 🟡 partial | ✅ e2e+unit | – | ⌘Y / Ctrl+H View History (AR-10); ⌘⇧L Open Library on macOS, the command bar elsewhere; View Archive with no key, assignable; ⌘, / Ctrl+, Settings, which cannot be remapped, and again brings the same Settings window to the front; ⌘⇧⌫ / Ctrl+Shift+Delete Clear Browsing Data…; Shortcut Settings (command bar, assignable); the shortcut sheet from Help → Keyboard Shortcuts (macOS) and the command bar (OB-12); Alt+F stays free for the Windows/Linux app menu (SB-03, SB-26, not built). Not built: Open Downloads (DL-14, downloads lane), Open a local file (⌘O / Ctrl+O when no Peek or Mini Window has focus), pinned extensions (EX-06) |
+| KS-12 | Library, history, downloads, settings, extensions, help | P1 | 🟡 partial | ✅ e2e+unit | – | ⌘Y / Ctrl+H View History (AR-10); ⌘⇧L Open Library on macOS, the command bar elsewhere; View Archive with no key, assignable; ⌘, / Ctrl+, Settings, which cannot be remapped, and again brings the same Settings window to the front; ⌘⇧⌫ / Ctrl+Shift+Delete Clear Browsing Data…; Shortcut Settings (command bar, assignable); the shortcut sheet from Help → Keyboard Shortcuts (macOS) and the command bar (OB-12); Open File… (macOS File menu, the command bar) and ⌘O / Ctrl+O wherever no Peek or Mini Window is open: the files chosen open in new tabs, the last one selected (Settings → Shortcuts says so under Open File…, which can also get keys of its own); Alt+F stays free for the Windows/Linux app menu (SB-03, SB-26, not built). Not built: Open Downloads (DL-14, downloads lane), pinned extensions (EX-06) |
 | KS-13 | Developer tools | P1 | – | ✅ unit | – |  |
 | KS-14 | Canvases, notes, capture and Tweaks | P2 | – | – | – |  |
-| KS-15 | Standard app and window keys | P1 | – | ✅ unit | – |  |
+| KS-15 | Standard app and window keys | P1 | ✅ | ✅ e2e+unit | – | macOS: the menu bar keeps the system’s items and keys: Hide Orbit ⌘H, Hide Others ⌥⌘H and Quit ⌘Q in the Orbit menu, the Window menu (Minimize ⌘M, ⌘` between Orbit windows) and the Help menu with its search (⌘?). No action can take these keys, nor Alt+F4, Alt+Tab or Alt+F on Windows and Linux, and Settings → Shortcuts says what keeps them (KS-03). Windows and Linux: Alt+F4 closes the window and, on the last one, quits; F1 opens Help (OB-13) and can’t be changed there. An Exit item comes with the Windows/Linux app menu (SB-26, not built). The menu template and keymap are unit-tested; not run on a Mac |
 | KS-16 | Text-editing keys keep their meaning | P0 | ✅ | ✅ e2e+unit | – | typed keys never go astray: a page or Orbit view that loads (a slow page, a background tab, a reload) no longer takes the keyboard from the command bar, a sidebar field or the page in front (focus-on-navigation off for every web contents Orbit makes); ⌘←/⌘→ act outside text fields only; ⌘[ / ⌘] (Alt+←/→) from a page's text field go back or forward only when the page leaves them alone (a press into a frame Orbit can't see into stays the page's); ⌘Z in a page field is the page's undo (tabs lane, tested here); no shortcut on a plain key runs while an input method composes (unit test: e2e can't drive a composition through the key router) |
 | KS-17 | Mouse, trackpad and modifier-click bindings | P0 | – | – | – |  |
 | KS-18 | Shortcut hints everywhere | P1 | ✅ | ✅ e2e+unit | – | button tooltips (address, copy link, site controls, sidebar toggle, back/forward/reload, find, zoom, Library, Clear, Space dots, Peek, Mini Window Open in…), the empty-window hint, command-bar rows, macOS menu items, the shortcut sheet (OB-12) and the right-click menus of a tab, a multi-selection, the page and a split pane (an item that does what a key does shows that key’s first binding) follow a remap without a restart; a menu shows it the next time it opens. Windows and Linux have no app menu yet (SB-03, SB-26), so there is no menu bar there to label |
diff --git a/docs/feature-status.json b/docs/feature-status.json
index 0085fca3..d105d2d8 100644
--- a/docs/feature-status.json
+++ b/docs/feature-status.json
@@ -224,8 +224,9 @@
   "MD-16": {"built": "partial", "note": "enter: the video shrinks from its place in the page to the corner (~300 ms, standard curve); Back to tab/double-click: the tab is selected at once and a still of the last frame flies back into the page; release glides to the corner; Back to PiP grows from the controller; tray slides with the snappy spring; with reduced motion (FL-28) the player appears and goes without motion and a release settles with a 120 ms ease-out; no haptic tick on macOS"},
   "FL-32": {"built": "yes", "note": "corner resize follows the pointer, resists past its limits (rubber band) and springs back on release; a fling heads for the corner in its direction and settles with the spring; tray slides up with the snappy timing; Back to tab flies to the video's place; pinch zooms (MD-06) rather than resizes"},
   "KS-11": {"built": "partial", "note": "Space and arrows in the focused player, Cmd/Ctrl+scroll and pinch zoom (tested), hardware media keys via Chromium (untested), Mute Tab action assignable; the calendar meeting shortcut (P2) belongs to TB-21/FV-09"},
-  "KS-12": {"built": "partial", "note": "⌘Y / Ctrl+H View History (AR-10); ⌘⇧L Open Library on macOS, the command bar elsewhere; View Archive with no key, assignable; ⌘, / Ctrl+, Settings, which cannot be remapped, and again brings the same Settings window to the front; ⌘⇧⌫ / Ctrl+Shift+Delete Clear Browsing Data…; Shortcut Settings (command bar, assignable); the shortcut sheet from Help → Keyboard Shortcuts (macOS) and the command bar (OB-12); Alt+F stays free for the Windows/Linux app menu (SB-03, SB-26, not built). Not built: Open Downloads (DL-14, downloads lane), Open a local file (⌘O / Ctrl+O when no Peek or Mini Window has focus), pinned extensions (EX-06)"},
+  "KS-12": {"built": "partial", "note": "⌘Y / Ctrl+H View History (AR-10); ⌘⇧L Open Library on macOS, the command bar elsewhere; View Archive with no key, assignable; ⌘, / Ctrl+, Settings, which cannot be remapped, and again brings the same Settings window to the front; ⌘⇧⌫ / Ctrl+Shift+Delete Clear Browsing Data…; Shortcut Settings (command bar, assignable); the shortcut sheet from Help → Keyboard Shortcuts (macOS) and the command bar (OB-12); Open File… (macOS File menu, the command bar) and ⌘O / Ctrl+O wherever no Peek or Mini Window is open: the files chosen open in new tabs, the last one selected (Settings → Shortcuts says so under Open File…, which can also get keys of its own); Alt+F stays free for the Windows/Linux app menu (SB-03, SB-26, not built). Not built: Open Downloads (DL-14, downloads lane), pinned extensions (EX-06)"},
   "KS-10": {"built": "yes", "note": "⌘O / Ctrl+O expands a Peek into a selected Today tab (PK-07); Esc and ⌘W / Ctrl+W close it (PK-09, Esc fixed); ⌘⇧T and ⌘Z reopen it (PK-10); ⌘⌥N / Ctrl+Alt+N opens a Mini Window (MW-06); in a Mini Window ⌘O moves its page into the most recent Space (MW-05), ⌘⌥O (also ⌘⇧O) / Ctrl+Alt+O offers the Spaces, ⌘W closes it (MW-09). All from the one keymap and remappable but Esc; the tests press the keys (peek, mini-window and keys specs)"},
+  "KS-15": {"built": "yes", "note": "macOS: the menu bar keeps the system’s items and keys: Hide Orbit ⌘H, Hide Others ⌥⌘H and Quit ⌘Q in the Orbit menu, the Window menu (Minimize ⌘M, ⌘` between Orbit windows) and the Help menu with its search (⌘?). No action can take these keys, nor Alt+F4, Alt+Tab or Alt+F on Windows and Linux, and Settings → Shortcuts says what keeps them (KS-03). Windows and Linux: Alt+F4 closes the window and, on the last one, quits; F1 opens Help (OB-13) and can’t be changed there. An Exit item comes with the Windows/Linux app menu (SB-26, not built). The menu template and keymap are unit-tested; not run on a Mac"},
   "KS-20": {"built": "partial", "note": "private window: the same keys, but the actions that need Spaces, pinned tabs, Favorites or folders (⌘D, ⌃1–9 / Alt+1–9, ⌘⌥← / ⌘⌥→, ⌘⇧K Clear, Favorite, New Folder, every Space action) do nothing there, from a key, a menu or the command bar, and a toast says “Not available in a private window”; tab keys work. Mini Window: ⌘W closes it, ⌘O / ⌘⌥O move or offer to move its page (KS-10), ⌘L edits its address with the keyboard in the field, ⌘R, zoom and print act on its page, sidebar and Space keys do nothing, Help → Keyboard Shortcuts opens over the browser window. Full screen: every key works with the sidebar hidden; ⌘1–9 and ⌘⌥↑ / ⌘⌥↓ switch tabs without bringing it out. Not built: ⌘F in a Mini Window (it has no find bar, Mini Window lane), the blank window (TB-17), extension keys in private windows (EX-06, EX-10)"},
   "SB-10": {"built": "partial", "note": "media tray and call controls (media lane), above the bottom bar, pushing the list up; download progress and the update banner belong to other lanes"},
   "PK-01": {"built": "yes", "note": "floating card over the source tab; one Peek per window; links inside navigate it"},
diff --git a/src/main/keys/bindings.ts b/src/main/keys/bindings.ts
index 094eeb93..83ee7cdf 100644
--- a/src/main/keys/bindings.ts
+++ b/src/main/keys/bindings.ts
@@ -5,6 +5,7 @@ import {
   buildKeymap,
   defaultPriorityFor,
   defaultShortcutsFor,
+  isFixed,
 } from '../../shared/actions'
 import type { BindRequest, BindResult, ShortcutPriority } from '../../shared/commands/keys'
 import {
@@ -53,10 +54,10 @@ export function normalizeShortcuts(value: unknown, platform: string): Bindings |
   const out: Bindings = {}
   const taken = new Set<string>()
   for (const action of ACTIONS)
-    if (action.fixed) for (const key of canon(defaultShortcutsFor(action, platform))) taken.add(key)
+    if (isFixed(action, platform)) for (const key of canon(defaultShortcutsFor(action, platform))) taken.add(key)
   for (const action of ACTIONS) {
     const raw = value[action.id]
-    if (action.fixed || !Array.isArray(raw)) continue
+    if (isFixed(action, platform) || !Array.isArray(raw)) continue
     const list: string[] = []
     for (const accel of raw) {
       if (typeof accel !== 'string' || bindingProblem(accel, platform) !== undefined) continue
@@ -76,7 +77,7 @@ export function normalizePriorities(value: unknown, platform: string): Record<st
   const out: Record<string, ShortcutPriority> = {}
   for (const [id, priority] of Object.entries(value)) {
     const action = ACTIONS_BY_ID[id]
-    if (!action || action.fixed || (priority !== 'websites' && priority !== 'orbit')) continue
+    if (!action || isFixed(action, platform) || (priority !== 'websites' && priority !== 'orbit')) continue
     if (priority !== defaultPriorityFor(action, platform)) out[id] = priority
   }
   return Object.keys(out).length > 0 ? out : undefined
@@ -96,7 +97,7 @@ export function bind(
   const custom = copy(stored)
   const action = ACTIONS_BY_ID[req.actionId]
   if (!action) return fail(custom, 'That action no longer exists.')
-  if (action.fixed) return fail(custom, `${action.title} keeps its shortcut.`)
+  if (isFixed(action, platform)) return fail(custom, `${action.title} keeps its shortcut.`)
   const problem = bindingProblem(req.accel, platform)
   if (problem) return fail(custom, problem)
   const accel = canonicalAccelerator(req.accel) as string
@@ -105,7 +106,7 @@ export function bind(
   const mine = canon(keymap.lists.get(action.id) ?? [])
   const owner = keymap.direct.get(accel) ?? keymap.outsideText.get(accel)
   if (owner && owner.id !== action.id) {
-    if (owner.fixed) {
+    if (isFixed(owner, platform)) {
       return fail(custom, `${formatAccelerator(accel, platform)} is kept for ${owner.title}.`)
     }
     if (!req.onConflict) {
@@ -138,7 +139,7 @@ export function unbind(
   const custom = copy(stored)
   const action = ACTIONS_BY_ID[actionId]
   const key = canonicalAccelerator(accel)
-  if (!action || action.fixed || !key) return custom
+  if (!action || isFixed(action, platform) || !key) return custom
   const list = canon(buildKeymap(custom, platform).lists.get(actionId) ?? [])
   if (list.includes(key))
     settle(
@@ -154,7 +155,7 @@ export function unbind(
 export function reset(stored: CustomBindings | undefined, actionId: string, platform: string): Bindings {
   const custom = copy(stored)
   const action = ACTIONS_BY_ID[actionId]
-  if (!action || action.fixed) return custom
+  if (!action || isFixed(action, platform)) return custom
   delete custom[actionId]
   const defaults = new Set(canon(defaultShortcutsFor(action, platform)))
   for (const [id, list] of Object.entries(custom)) {
@@ -175,7 +176,7 @@ export function setPriority(
 ): Record<string, ShortcutPriority> {
   const out = { ...(stored ?? {}) }
   const action = ACTIONS_BY_ID[actionId]
-  if (!action || action.fixed || (priority !== 'websites' && priority !== 'orbit')) return out
+  if (!action || isFixed(action, platform) || (priority !== 'websites' && priority !== 'orbit')) return out
   if (priority === defaultPriorityFor(action, platform)) delete out[actionId]
   else out[actionId] = priority
   return out
diff --git a/src/main/keys/index.ts b/src/main/keys/index.ts
index e69ff400..7e691c4c 100644
--- a/src/main/keys/index.ts
+++ b/src/main/keys/index.ts
@@ -5,6 +5,7 @@ import type { MainContext } from '../context'
 import { installMenu } from '../menu'
 import { bind, reset, setPriority, unbind } from './bindings'
 import { lastMenuHints } from './menu-hints'
+import { registerOpenFile } from './open-file'
 import { keyRouter } from './router'
 import { registerShortcutSheet } from './sheet'
 import { registerSpecialWindows } from './special-windows'
@@ -82,6 +83,7 @@ export function registerKeys(ctx: MainContext): void {
   registerWindowKeys(ctx)
   registerTabKeys(ctx)
   registerShortcutSheet(ctx)
+  registerOpenFile(ctx)
   registerSpecialWindows(ctx)
   keyRouter.init(ctx)
   commands.register('keys.record', ({ on }, c) => keyRouter.setRecording(on ? c.windowId : undefined))
diff --git a/src/main/keys/open-file.ts b/src/main/keys/open-file.ts
new file mode 100644
index 00000000..6c685d10
--- /dev/null
+++ b/src/main/keys/open-file.ts
@@ -0,0 +1,44 @@
+import { pathToFileURL } from 'node:url'
+import { dialog, type OpenDialogOptions } from 'electron'
+import { ACTIONS_BY_ID, type ActionDef, BORROWED_KEYS } from '../../shared/actions'
+import type { OrbitState, WindowId } from '../../shared/state'
+import type { MainContext } from '../context'
+import { browserWindowFor } from './browser-window'
+
+/**
+ * Open File… (KS-12): files from the disk open in new tabs of the window it was asked from, the
+ * last one chosen selected. ⌘O / Ctrl+O first serve an open Peek (PK-07) and a Mini Window
+ * (MW-05), whose action owns those keys; anywhere else the same keys open a file.
+ */
+
+const OPEN_FILE = 'file.open'
+
+/**
+ * The action a key press runs in the window `windowOf` names (asked only for Open Peek as Tab's
+ * keys): they open a file where there is no Peek or Mini Window.
+ */
+export function actionInWindow(action: ActionDef, state: OrbitState, windowOf: () => WindowId | undefined): ActionDef {
+  if (BORROWED_KEYS[OPEN_FILE]?.from !== action.id) return action
+  const windowId = windowOf()
+  const win = windowId ? state.windows[windowId] : undefined
+  if (win?.kind === 'mini' || win?.overlay.kind === 'peek') return action
+  return ACTIONS_BY_ID[OPEN_FILE] ?? action
+}
+
+export function registerOpenFile(ctx: MainContext): void {
+  const { windows, commands, actions } = ctx
+  actions.register(OPEN_FILE, async (c) => {
+    const windowId = browserWindowFor(ctx, c.windowId ?? windows.focusedWindowId())
+    const win = windows.get(windowId)
+    // Asked from Settings, a Mini Window or a page's pop-up: the window the files open in comes forward.
+    if (win && !win.isDestroyed() && !win.isFocused()) win.focus()
+    const options: OpenDialogOptions = { title: 'Open File', properties: ['openFile', 'multiSelections'] }
+    const { canceled, filePaths } =
+      win && !win.isDestroyed() ? await dialog.showOpenDialog(win, options) : await dialog.showOpenDialog(options)
+    if (canceled) return
+    for (const [i, path] of filePaths.entries()) {
+      const url = pathToFileURL(path).href
+      await commands.run('tabs.create', { url, activate: i === filePaths.length - 1 }, { windowId })
+    }
+  })
+}
diff --git a/src/main/keys/router.ts b/src/main/keys/router.ts
index 24c661be..4fd606f8 100644
--- a/src/main/keys/router.ts
+++ b/src/main/keys/router.ts
@@ -4,6 +4,7 @@ import type { RecordedKey } from '../../shared/commands/keys'
 import { acceleratorFromInput, modifiersOf } from '../../shared/keymap'
 import type { WindowId } from '../../shared/state'
 import type { MainContext } from '../context'
+import { actionInWindow } from './open-file'
 import { pageCanAnswer, pageVerdict, watchPageKeys } from './page-keys'
 
 /** A second press of the same keys within this long after the page took the first runs the action (KS-02). */
@@ -110,6 +111,15 @@ export class KeyRouter {
     return true
   }
 
+  /**
+   * The action a key press runs where it was pressed: Open Peek as Tab's keys open a file in a
+   * window with no Peek or Mini Window (KS-12).
+   */
+  actionIn(action: ActionDef | undefined, windowOf: () => WindowId | undefined): ActionDef | undefined {
+    if (!action || !this.ctx) return action
+    return actionInWindow(action, this.ctx.store.state, windowOf)
+  }
+
   /**
    * Keys a web page may use (KS-02, KS-16). Returns true when the press goes to the page: the
    * caller lets it through and runs nothing now. Applies to a tab's page and:
diff --git a/src/main/menu.ts b/src/main/menu.ts
index e241efc9..46b59cd9 100644
--- a/src/main/menu.ts
+++ b/src/main/menu.ts
@@ -1,5 +1,5 @@
 import { app, Menu, type MenuItemConstructorOptions } from 'electron'
-import { ACTIONS_BY_ID, shortcutsFor, toElectronAccelerator } from '../shared/actions'
+import { ACTIONS_BY_ID, borrowedShortcutsFor, shortcutsFor, toElectronAccelerator } from '../shared/actions'
 import { editsText } from '../shared/keymap'
 import { keepForMenu } from './archive/menus'
 import { recentlyClosedItems } from './archive/recently-closed'
@@ -20,13 +20,16 @@ export function installMenu(ctx: MainContext): void {
   }
   const item = (id: string, label?: string): MenuItemConstructorOptions => {
     const action = ACTIONS_BY_ID[id]
-    const accel = action ? shortcutsFor(action, 'darwin')[0] : undefined
+    const own = action ? shortcutsFor(action, 'darwin')[0] : undefined
+    // Keys lent by another action (⌘O for Open File where there is no Peek, KS-12) are shown too.
+    const lent = own || !action ? undefined : borrowedShortcutsFor(action, 'darwin')?.keys[0]
+    const accel = own ?? lent
     return {
       label: label ?? action?.title ?? id,
       accelerator: accel ? toElectronAccelerator(accel) : undefined,
       // A binding that types or edits text (KS-16) is only shown: the router runs it outside text
-      // fields, and the menu must not take it from one.
-      ...(accel && editsText(accel, 'darwin') ? { registerAccelerator: false } : {}),
+      // fields, and the menu must not take it from one. So are lent keys: the router picks the action.
+      ...(accel && (lent || editsText(accel, 'darwin')) ? { registerAccelerator: false } : {}),
       click: () => {
         // A key let through to a page that left it alone reaches the menu too: it runs once (KS-02).
         if (!keyRouter.menuRuns(id)) return
@@ -64,6 +67,7 @@ export function installMenu(ctx: MainContext): void {
         item('window.new'),
         item('window.newMini'),
         item('window.newPrivate'),
+        item('file.open'),
         { type: 'separator' },
         item('tab.close'),
         item('window.close'),
diff --git a/src/main/miniwindow/index.ts b/src/main/miniwindow/index.ts
index e8f6c699..67cc1042 100644
--- a/src/main/miniwindow/index.ts
+++ b/src/main/miniwindow/index.ts
@@ -690,7 +690,7 @@ export function registerMiniWindow(ctx: MainContext): void {
   actions.register('mini.toggleAll', toggleAll)
 
   // In a Mini Window, keys act on its page; sidebar, Space and tab-list keys do nothing (KS-20).
-  // Help → Keyboard Shortcuts opens over the browser window behind (OB-12, keys lane).
+  // Help → Keyboard Shortcuts and File → Open File… act in the browser window behind (OB-12, KS-12, keys lane).
   const APP_ACTIONS = new Set([
     'window.new',
     'window.newMini',
@@ -698,6 +698,7 @@ export function registerMiniWindow(ctx: MainContext): void {
     'app.settings',
     'app.archive',
     'help.shortcuts',
+    'file.open',
   ])
   actions.intercept((id, c) => {
     const mini = miniOf(c)
diff --git a/src/main/windows.ts b/src/main/windows.ts
index 04769f8b..92e02dc8 100644
--- a/src/main/windows.ts
+++ b/src/main/windows.ts
@@ -1067,7 +1067,11 @@ export class WindowManager {
         event.preventDefault()
         return
       }
-      const action = actionForInput(input, process.platform)
+      // Where the key was pressed may decide the action (keys lane: ⌘O opens a file outside a Peek, KS-12).
+      const action = keyRouter.actionIn(
+        actionForInput(input, process.platform),
+        () => this.windowIdFor(contents) ?? this.focusedWindowId(),
+      )
       if (!action || !this.ctx.actions.has(action.id)) {
         this.runOutsideText(contents, input)
         return
diff --git a/src/renderer/src/keys/ShortcutsPage.tsx b/src/renderer/src/keys/ShortcutsPage.tsx
index 8dac789e..04e5d111 100644
--- a/src/renderer/src/keys/ShortcutsPage.tsx
+++ b/src/renderer/src/keys/ShortcutsPage.tsx
@@ -10,7 +10,15 @@ import {
   useRef,
   useState,
 } from 'react'
-import { ACTIONS, ACTIONS_BY_ID, formatAccelerator, shortcutsFor } from '../../../shared/actions'
+import {
+  ACTIONS,
+  ACTIONS_BY_ID,
+  type ActionDef,
+  borrowedShortcutsFor,
+  formatAccelerator,
+  isFixed,
+  shortcutsFor,
+} from '../../../shared/actions'
 import type { BindingConflict, BindResult, RecordedKey, ShortcutPriority } from '../../../shared/commands/keys'
 import { acceleratorFromInput, MAX_BINDINGS, modifiersOf } from '../../../shared/keymap'
 import { invoke } from '../api'
@@ -185,6 +193,13 @@ function useRecorder() {
   return { recording, problem, conflict, start, stop, resolve, dismiss: () => setConflict(undefined) }
 }
 
+/** Keys another action lends this one, said under its row (⌘O for Open File where there is no Peek, KS-12). */
+function lentKeysNote(action: ActionDef): string | undefined {
+  const lent = borrowedShortcutsFor(action, platform)
+  if (!lent) return undefined
+  return `Also ${lent.keys.map(keys).join(' or ')} (the keys of ${lent.from.title}), ${lent.where}.`
+}
+
 /** The first binding of an action as this platform shows it, or ''. */
 function firstKeys(actionId: string): string {
   const action = ACTIONS_BY_ID[actionId]
@@ -246,7 +261,7 @@ export function ShortcutsPage() {
     const row = target.closest('[data-setting]')
     const actionId = row?.querySelector<HTMLElement>('[data-shortcut-action]')?.dataset.shortcutAction
     const entry = actionId ? entries.get(actionId) : undefined
-    if (!entry || entry.action.fixed) return
+    if (!entry || isFixed(entry.action, platform)) return
     e.preventDefault()
     stop()
     // From the keyboard (⇧F10, the menu key) the menu opens at the row's keys.
@@ -338,7 +353,8 @@ export function ShortcutsPage() {
                 actionId={id}
                 title={entry.title}
                 bindings={entry.bindings.join(' ')}
-                fixed={!!entry.action.fixed}
+                fixed={isFixed(entry.action, platform)}
+                note={lentKeysNote(entry.action)}
                 websites={entry.priority === 'websites'}
                 recording={mine ? (mine.replace ?? '') : undefined}
                 held={mine?.held ?? ''}
@@ -417,6 +433,7 @@ const ShortcutRow = memo(function ShortcutRow({
   title,
   bindings,
   fixed,
+  note,
   websites,
   recording,
   held,
@@ -430,6 +447,8 @@ const ShortcutRow = memo(function ShortcutRow({
   /** Its bindings, space-separated. */
   bindings: string
   fixed: boolean
+  /** Said under the row when there is nothing more pressing. */
+  note?: string
   websites: boolean
   /** Recording: '' for a new binding, else the binding being changed. */
   recording: string | undefined
@@ -462,6 +481,8 @@ const ShortcutRow = memo(function ShortcutRow({
     )
   } else if (fixed) {
     description = 'This shortcut can’t be changed.'
+  } else if (note) {
+    description = <span data-testid="shortcut-note">{note}</span>
   }
   const toggle = (replace?: string) => {
     if (recording === (replace ?? '')) stop()
diff --git a/src/shared/actions.ts b/src/shared/actions.ts
index 5f3d920f..4e16ce19 100644
--- a/src/shared/actions.ts
+++ b/src/shared/actions.ts
@@ -55,9 +55,10 @@ export interface ActionDef {
   /**
    * The shortcuts can't be changed (KS-01 "fixed": OS conventions such as ⌘, for Settings, and keys
    * that belong to an overlay such as the recent-tab switcher's). Settings → Shortcuts shows them
-   * without a way to record new ones.
+   * without a way to record new ones. 'other': on Windows and Linux only (F1 for Help, KS-15).
+   * Read it through `isFixed`.
    */
-  fixed?: boolean
+  fixed?: boolean | 'other'
   /**
    * KS-02 "prefer websites": when a page also handles one of the action's keys, the page gets the
    * first press, and pressing again within about a second runs the action. `true` on every
@@ -187,7 +188,8 @@ export const ACTIONS: ActionDef[] = [
   },
   { id: 'tab.toggleMute', title: 'Mute / Unmute Tab', category: 'Tabs', keywords: ['audio', 'sound'] },
   {
-    // In a Mini Window the same keys move its page into the most recent Space (MW-05).
+    // In a Mini Window the same keys move its page into the most recent Space (MW-05); in a
+    // window with no Peek they open a file (KS-12, BORROWED_KEYS).
     id: 'peek.expand',
     title: 'Open Peek as Tab',
     category: 'Tabs',
@@ -195,6 +197,14 @@ export const ACTIONS: ActionDef[] = [
     other: ['Ctrl+O'],
     keywords: ['expand', 'preview', 'mini window', 'move to space'],
   },
+  // Files from the disk in new tabs (KS-12): on Open Peek as Tab's keys where there is no Peek or
+  // Mini Window, and keys of its own if given some.
+  {
+    id: 'file.open',
+    title: 'Open File…',
+    category: 'App',
+    keywords: ['open file', 'local file', 'file from disk', 'browse files', 'html', 'pdf'],
+  },
   {
     id: 'tabs.clearToday',
     title: 'Clear Today Tabs',
@@ -496,6 +506,15 @@ export const ACTIONS: ActionDef[] = [
 
 export const ACTIONS_BY_ID: Record<string, ActionDef> = Object.fromEntries(ACTIONS.map((a) => [a.id, a]))
 
+/**
+ * Actions that also run on another action's keys where that one has nothing to act on (KS-12):
+ * Open File on Open Peek as Tab's ⌘O / Ctrl+O in a window with no Peek or Mini Window. The key
+ * router picks between them (src/main/keys/open-file.ts); menus and Settings show the keys.
+ */
+export const BORROWED_KEYS: Readonly<Record<string, { from: string; where: string }>> = {
+  'file.open': { from: 'peek.expand', where: 'where no Peek or Mini Window is open' },
+}
+
 /** The action's shortcuts as Orbit ships them (KS-03): `mac` on macOS, `other` elsewhere. */
 export function defaultShortcutsFor(action: ActionDef, platform: string): string[] {
   const mac = platform === 'darwin'
@@ -505,6 +524,11 @@ export function defaultShortcutsFor(action: ActionDef, platform: string): string
   ]
 }
 
+/** Whether the action's shortcuts can't be changed on this platform (KS-01, KS-15). */
+export function isFixed(action: ActionDef, platform: string): boolean {
+  return action.fixed === true || (action.fixed === 'other' && platform !== 'darwin')
+}
+
 /** Who gets the action's keys first by default when a page also handles them (KS-02). */
 export function defaultPriorityFor(action: ActionDef, platform: string): ShortcutPriority {
   const prefer = action.preferWebsites
@@ -517,7 +541,7 @@ export function priorityFor(
   platform: string,
   chosen?: Readonly<Record<string, ShortcutPriority>>,
 ): ShortcutPriority {
-  return (!action.fixed && chosen?.[action.id]) || defaultPriorityFor(action, platform)
+  return (!isFixed(action, platform) && chosen?.[action.id]) || defaultPriorityFor(action, platform)
 }
 
 /** A keymap: which action each binding runs, and each action's bindings (KS-01). */
@@ -531,7 +555,8 @@ export interface Keymap {
 }
 
 /** Whether the user's list for an action applies: fixed actions keep their defaults. */
-const ownsList = (action: ActionDef, custom: CustomBindings) => !action.fixed && custom[action.id] !== undefined
+const ownsList = (action: ActionDef, custom: CustomBindings, platform: string) =>
+  !isFixed(action, platform) && custom[action.id] !== undefined
 
 /**
  * The keymap for a platform with the user's bindings `custom`: theirs where they changed an
@@ -552,10 +577,12 @@ export function buildKeymap(custom: CustomBindings, platform: string): Keymap {
     }
     lists.set(action.id, list)
   }
-  for (const action of ACTIONS) if (action.fixed) claim(action, defaultShortcutsFor(action, platform))
-  for (const action of ACTIONS) if (ownsList(action, custom)) claim(action, custom[action.id] ?? [])
+  for (const action of ACTIONS) if (isFixed(action, platform)) claim(action, defaultShortcutsFor(action, platform))
+  for (const action of ACTIONS) if (ownsList(action, custom, platform)) claim(action, custom[action.id] ?? [])
   for (const action of ACTIONS) {
-    if (!action.fixed && !ownsList(action, custom)) claim(action, defaultShortcutsFor(action, platform))
+    if (!isFixed(action, platform) && !ownsList(action, custom, platform)) {
+      claim(action, defaultShortcutsFor(action, platform))
+    }
   }
   const direct = new Map<string, ActionDef>()
   const outsideText = new Map<string, ActionDef>()
@@ -582,6 +609,18 @@ export function shortcutsFor(action: ActionDef, platform: string): string[] {
   return liveIndex(platform).lists.get(action.id) ?? []
 }
 
+/** The keys another action lends this one (BORROWED_KEYS) as they are now, and that action. */
+export function borrowedShortcutsFor(
+  action: ActionDef,
+  platform: string,
+): { keys: string[]; from: ActionDef; where: string } | undefined {
+  const lent = BORROWED_KEYS[action.id]
+  const from = lent ? ACTIONS_BY_ID[lent.from] : undefined
+  if (!lent || !from) return undefined
+  const keys = shortcutsFor(from, platform)
+  return keys.length > 0 ? { keys, from, where: lent.where } : undefined
+}
+
 /** The action that owns a binding now, if any (Settings → Shortcuts' conflict check). */
 export function actionForAccelerator(accel: string, platform: string): ActionDef | undefined {
   const key = canonicalAccelerator(accel)
diff --git a/src/shared/commands/settings.ts b/src/shared/commands/settings.ts
index a90e0a5e..38079634 100644
--- a/src/shared/commands/settings.ts
+++ b/src/shared/commands/settings.ts
@@ -150,8 +150,9 @@ export const SETTINGS_LANE_ACTIONS: ActionDef[] = [
     id: 'help.open',
     title: 'Help',
     category: 'App',
-    // Windows and Linux: F1 (KS-15); macOS has ⌘? for the Help menu.
+    // Windows and Linux: F1, which can't be changed (KS-15); macOS has ⌘? for the Help menu.
     other: ['F1'],
+    fixed: 'other',
     keywords: ['documentation', 'user guide', 'support', 'readme'],
   },
   {
diff --git a/tests/e2e/keys.spec.ts b/tests/e2e/keys.spec.ts
index 347bf32a..3120af62 100644
--- a/tests/e2e/keys.spec.ts
+++ b/tests/e2e/keys.spec.ts
@@ -1,3 +1,7 @@
+import { mkdtempSync, writeFileSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { pathToFileURL } from 'node:url'
 import { expect, type Page, test } from '@playwright/test'
 import { action, isMac, launchOrbit, MOD, type Orbit, run, state, tabPage, viewPage } from './helpers'
 import {
@@ -1105,3 +1109,88 @@ test('[KS-20][KS-06] in full screen with the sidebar hidden, ⌘1–9 and ⌘⌥
   expect(win.fullscreen).toBe(true)
   expect(win.sidebar.visible).toBe(false)
 })
+
+// ---------- Open File (KS-12) and F1 (KS-15) ----------
+
+/** The next Open dialogs answer with these files (none: cancelled); returns how often one was asked. */
+async function answerOpenDialog(files: string[]): Promise<() => Promise<number>> {
+  await orbit.app.evaluate(({ dialog }, list) => {
+    const g = globalThis as unknown as { __openAsked: number }
+    g.__openAsked = 0
+    dialog.showOpenDialog = (async () => {
+      g.__openAsked++
+      return { canceled: list.length === 0, filePaths: list }
+    }) as typeof dialog.showOpenDialog
+  }, files)
+  return () => orbit.app.evaluate(() => (globalThis as unknown as { __openAsked: number }).__openAsked)
+}
+
+test('[KS-12] ⌘O / Ctrl+O with no Peek open, and Open File… from a Mini Window, open files from the disk in new tabs, the last one selected', async () => {
+  const { app } = orbit
+  const dir = mkdtempSync(join(tmpdir(), 'orbit-open-'))
+  const one = join(dir, 'one.html')
+  const two = join(dir, 'two file.html')
+  writeFileSync(one, '<title>First File</title><p>one</p>')
+  writeFileSync(two, '<title>Second File</title><p>two</p>')
+  const spaceId = await activeSpace(app)
+  const start = await openTab(app, fx.url('/page/Start'))
+  await selectPage(start, fx.url('/page/Start'))
+  const tabWith = async (file: string) =>
+    Object.values((await state(app)).tabs).find((t) => t.url === pathToFileURL(file).href)
+  let asked = await answerOpenDialog([one, two])
+  await pressMod('O')
+  await expect.poll(async () => (await tabWith(two))?.title).toBe('Second File')
+  // The first one opened behind it.
+  expect(await tabWith(one)).toBeDefined()
+  expect(await asked()).toBe(1)
+  await expect.poll(activeTab).toBe((await tabWith(two))?.id)
+  expect((await state(app)).spaces[spaceId]?.today).toHaveLength(3)
+
+  // Cancelled: nothing opens.
+  asked = await answerOpenDialog([])
+  await selectPage(start, fx.url('/page/Start'))
+  await pressMod('O')
+  await expect.poll(asked).toBe(1)
+  expect((await state(app)).spaces[spaceId]?.today).toHaveLength(3)
+  await expect.poll(activeTab).toBe(start)
+
+  // File → Open File… with a Mini Window in front: the file opens in the browser window.
+  const main = Object.values((await state(app)).windows).find((w) => w.kind === 'main')
+  await app.evaluate(({ app: a }, u) => a.emit('open-url', { preventDefault() {} }, u), fx.url('/page/InMini'))
+  const miniOf = async () => Object.values((await state(app)).windows).find((w) => w.kind === 'mini')
+  await expect.poll(async () => (await miniOf())?.id).toBeTruthy()
+  const mini = (await miniOf()) as NonNullable<Awaited<ReturnType<typeof miniOf>>>
+  const three = join(dir, 'three.html')
+  writeFileSync(three, '<title>Third File</title>')
+  asked = await answerOpenDialog([three])
+  await actionIn(mini.id, 'file.open')
+  await expect.poll(async () => (await tabWith(three))?.title).toBe('Third File')
+  const s = await state(app)
+  expect(s.spaces[spaceId]?.today).toContain((await tabWith(three))?.id)
+  expect(s.windows[main?.id ?? '']?.activeTab[spaceId]).toBe((await tabWith(three))?.id)
+  expect(s.windows[mini.id]).toBeDefined()
+})
+
+test('[KS-12][KS-15][ST-08] Settings → Shortcuts: Open File… shows the ⌘O it has where no Peek is open; F1 for Help can’t be changed on Windows and Linux', async () => {
+  const { app } = orbit
+  const page = await openSettings(app, { section: 'shortcuts' })
+  const open = shortcutRow(page, 'file.open')
+  await expect(open.getByTestId('shortcut-note')).toHaveText(
+    `Also ${isMac ? '⌘O' : 'Ctrl+O'} (the keys of Open Peek as Tab), where no Peek or Mini Window is open.`,
+  )
+  await expect(open.getByTestId('shortcut-record')).toBeVisible()
+  // The note follows Open Peek as Tab's keys.
+  expect(
+    await run(app, 'keys.bind', { actionId: 'peek.expand', accel: `${PRIMARY}+Shift+E`, onConflict: 'clear' }),
+  ).toEqual({ ok: true })
+  await run(app, 'keys.unbind', { actionId: 'peek.expand', accel: `${PRIMARY}+O` })
+  await expect(open.getByTestId('shortcut-note')).toContainText(isMac ? 'Also ⇧⌘E (' : 'Also Ctrl+Shift+E (')
+  const help = shortcutRow(page, 'help.open')
+  if (isMac) {
+    await expect(help.getByTestId('shortcut-record')).toBeVisible()
+  } else {
+    await expect(help.getByTestId('shortcut-binding')).toHaveText(['F1'])
+    await expect(help).toContainText('This shortcut can’t be changed.')
+    await expect(help.getByTestId('shortcut-record')).toHaveCount(0)
+  }
+})
diff --git a/tests/unit/keymap-menu.test.ts b/tests/unit/keymap-menu.test.ts
index 7ace9096..fb4238a1 100644
--- a/tests/unit/keymap-menu.test.ts
+++ b/tests/unit/keymap-menu.test.ts
@@ -22,7 +22,7 @@ vi.mock('../../src/main/keys/router', () => ({ keyRouter: { menuRuns: () => true
 
 import type { MainContext } from '../../src/main/context'
 import { installMenu } from '../../src/main/menu'
-import { ACTIONS_BY_ID } from '../../src/shared/actions'
+import { ACTIONS_BY_ID, type ActionDef, isFixed } from '../../src/shared/actions'
 import { bindingProblem, setCustomBindings } from '../../src/shared/keymap'
 
 const platform = Object.getOwnPropertyDescriptor(process, 'platform') as PropertyDescriptor
@@ -64,8 +64,10 @@ describe('the macOS menu bar', () => {
       expect(bindingProblem('Alt+F4', p)).toContain('closing the window')
       expect(bindingProblem('Alt+Tab', p)).toContain('switching apps')
     }
-    // Windows and Linux have no Help menu: F1 opens Help (OB-13).
-    expect(ACTIONS_BY_ID['help.open']?.other).toEqual(['F1'])
+    // Windows and Linux have no Help menu: F1 opens Help (OB-13) and can't be changed there.
+    const help = ACTIONS_BY_ID['help.open'] as ActionDef
+    expect(help.other).toEqual(['F1'])
+    expect([isFixed(help, 'linux'), isFixed(help, 'win32'), isFixed(help, 'darwin')]).toEqual([true, true, false])
   })
 
   it('[KS-01][KS-18] shows each item’s keys as they are now, and none for an action without keys', () => {
@@ -88,6 +90,17 @@ describe('the macOS menu bar', () => {
     expect(find(build().View ?? [], 'Toggle Sidebar')?.registerAccelerator).toBeUndefined()
   })
 
+  it('[KS-12] File → Open File… shows Open Peek as Tab’s ⌘O, which opens a file where there is no Peek; keys of its own replace it', () => {
+    const open = find(build().File ?? [], 'Open File…')
+    expect(open?.accelerator).toBe('Command+O')
+    // The key router decides what ⌘O does: the menu only shows it.
+    expect(open?.registerAccelerator).toBe(false)
+    setCustomBindings({ 'file.open': ['Cmd+Shift+F2'] })
+    const own = find(build().File ?? [], 'Open File…')
+    expect(own?.accelerator).toBe('Command+Shift+F2')
+    expect(own?.registerAccelerator).toBeUndefined()
+  })
+
   it('[OB-12][OB-13] Help → Keyboard Shortcuts comes after Orbit Help', () => {
     const help = build().help
     expect(help?.map((i) => i.label).slice(0, 3)).toEqual(['Orbit Help', 'Keyboard Shortcuts', 'Report a Bug…'])
diff --git a/tests/unit/keymap-open-file.test.ts b/tests/unit/keymap-open-file.test.ts
new file mode 100644
index 00000000..4db256d8
--- /dev/null
+++ b/tests/unit/keymap-open-file.test.ts
@@ -0,0 +1,126 @@
+import { afterEach, describe, expect, it, vi } from 'vitest'
+
+/** Open File… (KS-12): the dialog is a stand-in that returns what the test chose. */
+const dialog = vi.hoisted(() => ({
+  result: { canceled: false, filePaths: [] as string[] },
+  asked: [] as unknown[][],
+}))
+vi.mock('electron', () => ({
+  dialog: {
+    showOpenDialog: async (...args: unknown[]) => {
+      dialog.asked.push(args)
+      return dialog.result
+    },
+  },
+}))
+
+import type { MainContext } from '../../src/main/context'
+import { actionInWindow, registerOpenFile } from '../../src/main/keys/open-file'
+import { ActionRegistry } from '../../src/main/registry'
+import { ACTIONS_BY_ID, type ActionDef, borrowedShortcutsFor } from '../../src/shared/actions'
+import { createInitialState, createWindowState } from '../../src/shared/defaults'
+import { setCustomBindings } from '../../src/shared/keymap'
+import type { OrbitState } from '../../src/shared/state'
+
+const peekExpand = ACTIONS_BY_ID['peek.expand'] as ActionDef
+const openFile = ACTIONS_BY_ID['file.open'] as ActionDef
+
+/** A state with a browser window and a Mini Window. */
+function windowsState(): { state: OrbitState; main: string; mini: string } {
+  const state = createInitialState(0)
+  const spaceId = state.spaceOrder[0] as string
+  const main = createWindowState(spaceId)
+  const mini = { ...createWindowState(spaceId), kind: 'mini' as const }
+  state.windows[main.id] = main
+  state.windows[mini.id] = mini
+  return { state, main: main.id, mini: mini.id }
+}
+
+afterEach(() => {
+  setCustomBindings(undefined)
+  dialog.asked = []
+})
+
+describe('[KS-12] ⌘O / Ctrl+O', () => {
+  it('opens a file in a window with no Peek, and in a page’s pop-up; a Peek or a Mini Window keeps them', () => {
+    const { state, main, mini } = windowsState()
+    expect(actionInWindow(peekExpand, state, () => main).id).toBe('file.open')
+    expect(actionInWindow(peekExpand, state, () => undefined).id).toBe('file.open')
+    expect(actionInWindow(peekExpand, state, () => mini).id).toBe('peek.expand')
+    const win = state.windows[main]
+    if (!win) throw new Error('no window')
+    win.overlay = { kind: 'peek' } as unknown as typeof win.overlay
+    expect(actionInWindow(peekExpand, state, () => main).id).toBe('peek.expand')
+    // Other keys are never changed.
+    const reload = ACTIONS_BY_ID['nav.reload'] as ActionDef
+    expect(actionInWindow(reload, state, () => main)).toBe(reload)
+  })
+
+  it('are Open Peek as Tab’s keys, lent to Open File as they are now', () => {
+    expect(borrowedShortcutsFor(openFile, 'darwin')?.keys).toEqual(['Cmd+O'])
+    expect(borrowedShortcutsFor(openFile, 'linux')?.keys).toEqual(['Ctrl+O'])
+    expect(borrowedShortcutsFor(openFile, 'darwin')?.from.id).toBe('peek.expand')
+    setCustomBindings({ 'peek.expand': ['Cmd+E'] })
+    expect(borrowedShortcutsFor(openFile, 'darwin')?.keys).toEqual(['Cmd+E'])
+    setCustomBindings({ 'peek.expand': [] })
+    expect(borrowedShortcutsFor(openFile, 'darwin')).toBeUndefined()
+    expect(borrowedShortcutsFor(peekExpand, 'darwin')).toBeUndefined()
+  })
+})
+
+describe('[KS-12] Open File…', () => {
+  function setup() {
+    const { state, main, mini } = windowsState()
+    const created: { url: string; activate: boolean; windowId: string | undefined }[] = []
+    const focused: string[] = []
+    const fakeWindow = (id: string) => ({
+      isDestroyed: () => false,
+      isFocused: () => false,
+      focus: () => void focused.push(id),
+    })
+    const actions = new ActionRegistry()
+    const ctx = {
+      store: { state },
+      actions,
+      windows: {
+        focusedWindowId: () => main,
+        get: (id: string) => (id === main ? fakeWindow(id) : undefined),
+        ids: () => [main],
+        open: () => main,
+      },
+      commands: {
+        run: async (name: string, args: { url: string; activate: boolean }, c: { windowId?: string }) => {
+          if (name === 'tabs.create') created.push({ url: args.url, activate: args.activate, windowId: c.windowId })
+        },
+      },
+    } as unknown as MainContext
+    registerOpenFile(ctx)
+    return { actions, main, mini, created, focused }
+  }
+
+  it('opens each file chosen in a new tab of the window, the last one selected', async () => {
+    const { actions, main, created } = setup()
+    dialog.result = { canceled: false, filePaths: ['/tmp/a b.html', '/tmp/c.pdf'] }
+    await actions.run('file.open', { windowId: main })
+    expect(dialog.asked).toHaveLength(1)
+    expect(created).toEqual([
+      { url: 'file:///tmp/a%20b.html', activate: false, windowId: main },
+      { url: 'file:///tmp/c.pdf', activate: true, windowId: main },
+    ])
+  })
+
+  it('opens nothing when the dialog is cancelled', async () => {
+    const { actions, main, created } = setup()
+    dialog.result = { canceled: true, filePaths: [] }
+    await actions.run('file.open', { windowId: main })
+    expect(created).toEqual([])
+  })
+
+  it('asked from a Mini Window, opens the files in the browser window, which comes forward', async () => {
+    const { actions, main, mini, created, focused } = setup()
+    dialog.result = { canceled: false, filePaths: ['/tmp/d.txt'] }
+    await actions.run('file.open', { windowId: mini })
+    expect(focused).toEqual([main])
+    expect(created).toEqual([{ url: 'file:///tmp/d.txt', activate: true, windowId: main }])
+  })
+})
diff --git a/tests/unit/keymap-remap.test.ts b/tests/unit/keymap-remap.test.ts
index e754ab85..b23fb2da 100644
--- a/tests/unit/keymap-remap.test.ts
+++ b/tests/unit/keymap-remap.test.ts
@@ -12,6 +12,7 @@ import {
 import {
   ACTIONS,
   ACTIONS_BY_ID,
+  type ActionDef,
   actionForAccelerator,
   actionForInput,
   buildKeymap,
@@ -155,6 +156,28 @@ describe('[KS-01][ST-08] changing bindings', () => {
     expect(bind(undefined, { actionId: 'sidebar.toggle', accel: 'F7' }, 'linux').result).toEqual({ ok: true })
   })
 
+  it('[KS-15] F1 stays Help on Windows and Linux; on macOS Help has no keys and can be given some', () => {
+    for (const platform of ['linux', 'win32']) {
+      expect(bind(undefined, { actionId: 'sidebar.toggle', accel: 'F1' }, platform).result).toEqual({
+        ok: false,
+        problem: 'F1 is kept for Help.',
+      })
+      expect(bind(undefined, { actionId: 'help.open', accel: 'F9' }, platform).result).toEqual({
+        ok: false,
+        problem: 'Help keeps its shortcut.',
+      })
+      // Whatever is stored, F1 is Help's.
+      const keymap = buildKeymap({ 'help.open': [], 'sidebar.toggle': ['F1'] }, platform)
+      expect(keymap.direct.get('F1')?.id).toBe('help.open')
+      expect(normalizeShortcuts({ 'help.open': ['F9'], 'tab.new': ['F1', 'F2'] }, platform)).toEqual({
+        'tab.new': ['F2'],
+      })
+    }
+    expect(shortcutsFor(ACTIONS_BY_ID['help.open'] as ActionDef, 'darwin')).toEqual([])
+    expect(bind(undefined, { actionId: 'help.open', accel: 'F9' }, 'darwin').result).toEqual({ ok: true })
+    expect(bind(undefined, { actionId: 'sidebar.toggle', accel: 'F1' }, 'darwin').result).toEqual({ ok: true })
+  })
+
   it(`keeps at most ${MAX_BINDINGS} bindings on an action`, () => {
     let custom = {}
     for (const n of [1, 2, 3, 4]) custom = bind(custom, { actionId: 'tab.new', accel: `F${n}` }, 'darwin').custom
@@ -200,7 +223,7 @@ describe('[KS-01] stored bindings survive a restart only as Orbit can use them',
   })
 
   it('keeps no more than the most bindings an action can have', () => {
-    const many = ['F1', 'F2', 'F3', 'F4', 'F5', 'F6', 'F7']
+    const many = ['F2', 'F3', 'F4', 'F5', 'F6', 'F7', 'F8']
     expect(normalizeShortcuts({ 'tab.new': many }, 'linux')).toEqual({ 'tab.new': many.slice(0, MAX_BINDINGS) })
   })
 

From adfa7ac542709e71277c025c39494e46779d8b67 Mon Sep 17 00:00:00 2001
From: Siya <57148521+siyabendoezdemir@users.noreply.github.com>
Date: Sat, 10 Oct 2026 20:22:21 +0000
Subject: [PATCH 10/11] fix(keys): a frame with the keyboard judges its own
 keys; Esc on a loading page goes to the page first; D60 priorities (PR #23
 review)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- M1: main mirrors where the keyboard is in each tab's page
  (src/main/keys/page-focus.ts). The main frame, and the frame inside it
  that has the keyboard (contents.focusedFrame), say where focus is as it
  moves. So ⌘[ / Alt+← outside text fields goes back at once, in a frame
  too, and a press in a frame is judged by that frame's fields and handlers.
- M2: Esc in a Mini Window's address field gives the keyboard back to its
  page (mini.focusPage).
- M3: a private window's sidebar has no Clear button.
- D59: the page preload sends one bit after a trusted Esc in a tab's main
  frame: whether the page used it. While the tab loads, main waits for it
  250 ms at most and stops the load only if the page left Esc alone
  (src/main/keys/escape.ts).
- D60: ⌘S prefers Orbit on macOS (Ctrl+S prefers websites on Windows and
  Linux); a page's answer is waited for 250 ms at most, no answer counting
  as left alone; ⌃` steps back in the recent-tab switcher on every
  platform, only while it is up; macOS Settings refuses ⌃ with a lone
  letter.
- F4: ⌘Y / Ctrl+H and the Library's keys from a Mini Window act in the
  browser window behind it.
- F5: View Archive in a private window shows the "Not available" hint.
- F6: on macOS the menu takes ⌘O itself while no Orbit window is shown; it
  is built again as windows show, hide, minimize, restore and close.
- KS-13: DevTools rows in the default-keymap table, and remap tests.
  KS-17: e2e for ⌘-click / middle-click on Forward and a double-click on
  the empty sidebar.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 src/main/keys/escape.ts                       |  81 ++++
 src/main/keys/index.ts                        |  26 +-
 src/main/keys/page-focus.ts                   | 309 ++++++++++++++
 src/main/keys/page-keys.ts                    |  51 ++-
 src/main/keys/router.ts                       |  50 ++-
 src/main/keys/special-windows.ts              |   6 +-
 src/main/menu.ts                              |  46 +-
 src/main/miniwindow/index.ts                  |  11 +-
 src/main/nav/index.ts                         |  17 +-
 src/preload/page.ts                           |  23 +
 src/renderer/src/mini/MiniApp.tsx             |   3 +
 .../src/shell/sidebar/SidebarItems.tsx        |  11 +-
 src/shared/actions.ts                         |  13 +-
 src/shared/commands/peek.ts                   |   2 +
 src/shared/keymap.ts                          |   5 +
 src/shared/site.ts                            |   6 +
 tests/e2e/keys.spec.ts                        | 401 +++++++++++++++++-
 tests/e2e/nav-support.ts                      |  17 +-
 tests/unit/keymap-defaults.test.ts            |  19 +-
 tests/unit/keymap-menu.test.ts                |  61 ++-
 tests/unit/keymap-remap.test.ts               |  72 +++-
 tests/unit/keymap-settings.test.ts            |   6 +
 tests/unit/keymap-special-windows.test.ts     |   2 +
 tests/unit/keys-escape.test.ts                | 159 +++++++
 24 files changed, 1316 insertions(+), 81 deletions(-)
 create mode 100644 src/main/keys/escape.ts
 create mode 100644 src/main/keys/page-focus.ts
 create mode 100644 tests/unit/keys-escape.test.ts

diff --git a/src/main/keys/escape.ts b/src/main/keys/escape.ts
new file mode 100644
index 00000000..0596f6bc
--- /dev/null
+++ b/src/main/keys/escape.ts
@@ -0,0 +1,81 @@
+import { type IpcMainEvent, ipcMain, type WebContents } from 'electron'
+import { PAGE_CHANNEL } from '../../shared/site'
+
+/**
+ * Esc on a loading page (KS-19, NV-04, D59). As in Chromium, the page gets Esc first, and Orbit
+ * stops the load only if the page didn't use it. Electron runs no isolated-world script while a
+ * main frame loads, so the page preload (src/preload/page.ts) says what the page did: one bit per
+ * trusted Esc in the main frame, sent once every handler of the page has run.
+ *
+ * Main reads the bit only while it waits after an Esc pressed in a loading tab, at most
+ * ESCAPE_WAIT_MS; no answer counts as not used (D60). A bit counts only from the main frame of a
+ * tab's page (D40), and only for an Esc pressed there: one sent with no press waiting does nothing.
+ */
+
+/** How long main waits for the page's answer: KS-02's verdict wait (D59, D60). */
+export const ESCAPE_WAIT_MS = 250
+
+/** One Esc pressed while a tab loaded, as main saw it: whether the page used it, and whether the load stopped. */
+export interface EscapeRecord {
+  url: string
+  used: boolean
+  stopped: boolean
+}
+
+/** The presses still waiting for the page's answer, oldest first, by tab contents. */
+const waiting = new WeakMap<WebContents, ((used: boolean) => void)[]>()
+
+/** The last few presses, for the e2e harness. */
+const log: EscapeRecord[] = []
+const LOG_SIZE = 10
+
+let listening = false
+
+/**
+ * Takes the pages' answers. `isTab` says whether a web contents is a tab's (Peek and Mini Window
+ * pages are tabs too). Called once.
+ */
+export function listenForEscapes(isTab: (contents: WebContents) => boolean): void {
+  if (listening) return
+  listening = true
+  ipcMain.on(PAGE_CHANNEL.escape, (event: IpcMainEvent, used: unknown) => {
+    if (typeof used !== 'boolean') return
+    const contents = event.sender
+    const frame = event.senderFrame
+    try {
+      if (!frame || contents.isDestroyed() || !isTab(contents)) return
+      if (frame.frameTreeNodeId !== contents.mainFrame.frameTreeNodeId) return
+    } catch {
+      // A frame or page that went away while the message was on its way.
+      return
+    }
+    waiting.get(contents)?.shift()?.(used)
+  })
+}
+
+/**
+ * Esc was pressed in `contents` while its tab loads and no overlay is open: waits for the page's
+ * answer, then calls `stop` unless the page used the key or the load ended meanwhile.
+ */
+export function escapeThenStop(contents: WebContents, stillLoading: () => boolean, stop: () => void): void {
+  const url = contents.getURL()
+  const queue = waiting.get(contents) ?? []
+  waiting.set(contents, queue)
+  let timer: NodeJS.Timeout | undefined
+  const settle = (used: boolean) => {
+    clearTimeout(timer)
+    const at = queue.indexOf(settle)
+    if (at >= 0) queue.splice(at, 1)
+    const stopped = !used && !contents.isDestroyed() && stillLoading()
+    if (stopped) stop()
+    log.push({ url, used, stopped })
+    if (log.length > LOG_SIZE) log.shift()
+  }
+  queue.push(settle)
+  timer = setTimeout(() => settle(false), ESCAPE_WAIT_MS)
+}
+
+/** The last presses Orbit waited on, oldest first (e2e). */
+export function escapeLog(): EscapeRecord[] {
+  return log.map((r) => ({ ...r }))
+}
diff --git a/src/main/keys/index.ts b/src/main/keys/index.ts
index 7e691c4c..fda3ca89 100644
--- a/src/main/keys/index.ts
+++ b/src/main/keys/index.ts
@@ -1,11 +1,14 @@
+import { webContents } from 'electron'
 import { ACTIONS } from '../../shared/actions'
 import type { BindResult, ShortcutPriority } from '../../shared/commands/keys'
 import { onKeymapChange, setCustomBindings } from '../../shared/keymap'
 import type { MainContext } from '../context'
-import { installMenu } from '../menu'
+import { installMenu, watchWindowsForMenu } from '../menu'
 import { bind, reset, setPriority, unbind } from './bindings'
+import { escapeLog, listenForEscapes } from './escape'
 import { lastMenuHints } from './menu-hints'
 import { registerOpenFile } from './open-file'
+import { pageFocus } from './page-focus'
 import { keyRouter } from './router'
 import { registerShortcutSheet } from './sheet'
 import { registerSpecialWindows } from './special-windows'
@@ -26,8 +29,9 @@ export function registerKeys(ctx: MainContext): void {
   store.subscribe((next, prev) => {
     if (next.settings.shortcuts !== prev.settings.shortcuts) setCustomBindings(next.settings.shortcuts)
   })
-  // The macOS menu bar shows each item's binding (KS-18).
+  // The macOS menu bar shows each item's binding (KS-18), and with no window up takes ⌘O (KS-12).
   onKeymapChange(() => installMenu(ctx))
+  watchWindowsForMenu(ctx)
 
   const saveBindings = (custom: Record<string, string[]>) =>
     store.update((d) => {
@@ -86,12 +90,28 @@ export function registerKeys(ctx: MainContext): void {
   registerOpenFile(ctx)
   registerSpecialWindows(ctx)
   keyRouter.init(ctx)
+  // Whether a page used an Esc pressed while it loads, from its preload (D59).
+  listenForEscapes((contents) => !!ctx.tabs.tabIdFor(contents))
   commands.register('keys.record', ({ on }, c) => keyRouter.setRecording(on ? c.windowId : undefined))
-  // Tests say which keys the system keeps instead of asking it, and read the keys a menu showed.
+  // Tests say which keys the system keeps instead of asking it, and read the keys a menu showed,
+  // where Orbit knows the keyboard is in a page, and what became of Esc on loading pages.
   if (ctx.e2e) {
     ;(globalThis as unknown as { __orbitKeys: unknown }).__orbitKeys = {
       setSystemClashes: setSystemClashesForTest,
       lastMenuHints,
+      focusIn: (urlPart: string) => {
+        const contents = webContents
+          .getAllWebContents()
+          .find((w) => !w.isDestroyed() && !!ctx.tabs.tabIdFor(w) && w.getURL().includes(urlPart))
+        const now = contents ? pageFocus(contents) : undefined
+        if (!now) return null
+        try {
+          return { frame: now.inFrame ? now.frame.url : 'main', where: now.where ?? null }
+        } catch {
+          return null
+        }
+      },
+      escapes: escapeLog,
     }
   }
 }
diff --git a/src/main/keys/page-focus.ts b/src/main/keys/page-focus.ts
new file mode 100644
index 00000000..1b33f46a
--- /dev/null
+++ b/src/main/keys/page-focus.ts
@@ -0,0 +1,309 @@
+import type { WebContents, WebFrameMain } from 'electron'
+import { ANSWER_WAIT_MS, EDITABLE, type PageVerdict, pageVerdict, signature } from './page-keys'
+
+/**
+ * Where the keyboard is in a tab's page, known in main before a key arrives (KS-16, D60), so Back
+ * and Forward can run at once outside text fields without asking a page that may be busy, and a
+ * press with focus in a frame is judged by that frame.
+ *
+ * Each frame watched says, in its own world, where the keyboard is in it, and says it again when
+ * that changes: a script that answers when focus moves (`FOCUS`), sent again after each answer.
+ * The page's main frame is watched for as long as its document lives. The frame inside it that has
+ * the keyboard (`contents.focusedFrame`) is followed too, and also notes the presses Orbit may ask
+ * about, since the main frame's watcher (page-keys.ts) never sees keys pressed in a frame.
+ *
+ * What a frame says about itself is that page's word: a page that says the wrong thing only
+ * changes what its own keys do. Answers are checked before they are used.
+ */
+
+/**
+ * Where the keyboard is in one frame:
+ * - 'field': on one of its text fields;
+ * - 'page': elsewhere in it;
+ * - 'frame': in a frame inside it;
+ * - 'away': not in it.
+ */
+export type FrameWhere = 'field' | 'page' | 'frame' | 'away'
+
+const WHERE: ReadonlySet<string> = new Set<FrameWhere>(['field', 'page', 'frame', 'away'])
+
+/** A key press a followed frame noted: as the main frame's watcher notes them (page-keys.ts). */
+interface KeyRecord {
+  sig: string
+  at: number
+  inField: boolean
+  prevented: boolean
+}
+
+/**
+ * The script a watched frame runs: answers `{ where }` once where the keyboard is differs from
+ * `known` or focus moves, and, with `keys`, `{ where, key }` once a key Orbit may ask about has
+ * been through every handler of the frame (keys with ⌘, Ctrl or Alt, and F1–F24). Leaves nothing
+ * behind in the page.
+ */
+const FOCUS = (known: FrameWhere | null, keys: boolean) => `new Promise((resolve) => {
+  const editable = ${EDITABLE}
+  const where = () => {
+    if (!document.hasFocus()) return 'away'
+    const el = document.activeElement
+    if (el && /^(IFRAME|FRAME|OBJECT|EMBED|FENCEDFRAME)$/.test(el.tagName)) return 'frame'
+    return editable(el) ? 'field' : 'page'
+  }
+  const FOCUS_EVENTS = ['focusin', 'focusout', 'focus', 'blur']
+  let done = false
+  const finish = (answer) => {
+    if (done) return
+    done = true
+    for (const type of FOCUS_EVENTS) removeEventListener(type, moved, true)
+    removeEventListener('keydown', pressed, true)
+    resolve(answer)
+  }
+  const moved = () => setTimeout(() => finish({ where: where() }), 0)
+  const pressed = (e) => {
+    if (!e.isTrusted || ['Control', 'Meta', 'Alt', 'Shift', 'AltGraph'].includes(e.key)) return
+    if (!e.metaKey && !e.ctrlKey && !e.altKey && !/^F\\d{1,2}$/.test(e.key)) return
+    const key = {
+      sig: [e.metaKey, e.ctrlKey, e.altKey, e.shiftKey, e.code].join(','),
+      at: Date.now(),
+      inField: editable(document.activeElement),
+    }
+    // After the whole dispatch: the frame's handlers have all had the event.
+    setTimeout(() => finish({ where: where(), key: { ...key, prevented: e.defaultPrevented } }), 0)
+  }
+  for (const type of FOCUS_EVENTS) addEventListener(type, moved, true)
+  if (${keys}) addEventListener('keydown', pressed, true)
+  if (where() !== ${JSON.stringify(known)}) finish({ where: where() })
+})`
+
+/** A frame's answer, if it is one. */
+function readAnswer(value: unknown): { where: FrameWhere; key?: KeyRecord } | undefined {
+  if (!value || typeof value !== 'object') return undefined
+  const { where, key } = value as { where?: unknown; key?: unknown }
+  if (typeof where !== 'string' || !WHERE.has(where)) return undefined
+  if (key === undefined) return { where: where as FrameWhere }
+  if (!key || typeof key !== 'object') return undefined
+  const { sig, at, inField, prevented } = key as Record<string, unknown>
+  if (typeof sig !== 'string' || sig.length > 64 || typeof at !== 'number' || !Number.isFinite(at)) return undefined
+  if (typeof inField !== 'boolean' || typeof prevented !== 'boolean') return undefined
+  return { where: where as FrameWhere, key: { sig, at, inField, prevented } }
+}
+
+/** Reads a frame's property; undefined once the frame is gone. */
+function read<T>(get: () => T): T | undefined {
+  try {
+    return get()
+  } catch {
+    return undefined
+  }
+}
+
+const sameFrame = (a: WebFrameMain, b: WebFrameMain): boolean =>
+  a === b ||
+  read(() => a.frameTreeNodeId === b.frameTreeNodeId && a.processId === b.processId && a.routingId === b.routingId) ===
+    true
+
+/** One watched frame. */
+interface Watch {
+  frame: WebFrameMain
+  /** What it said last; undefined until it answers. */
+  where: FrameWhere | undefined
+  /** Whether it notes key presses (a followed frame inside the page). */
+  keys: boolean
+  /** Its last key presses, oldest first. */
+  records: KeyRecord[]
+  /** Verdicts waiting for a press to show up in `records`. */
+  wake: Set<() => void>
+  /** When it answered lately: a frame that keeps answering is asked less often. */
+  answers: number[]
+}
+
+/** Where the keyboard is in a page now, and how to learn what the page did with a press there. */
+export interface FocusNow {
+  /** The frame with the keyboard. */
+  frame: WebFrameMain
+  /** Whether that is a frame inside the page rather than the page itself. */
+  inFrame: boolean
+  /** Where in it, as far as Orbit knows. */
+  where: FrameWhere | undefined
+  /** What that frame did with the press `input`, pressed at `pressedAt` (main's clock). */
+  verdict(input: Electron.Input, pressedAt: number): Promise<PageVerdict>
+}
+
+/** Answers this many times a second, at most, before a frame is asked again only after a pause. */
+const ANSWERS_PER_SECOND = 30
+const PAUSE_MS = 200
+
+class PageFocus {
+  private main: Watch | undefined
+  private child: Watch | undefined
+  private retry: NodeJS.Timeout | undefined
+
+  constructor(private readonly contents: WebContents) {}
+
+  /** Watches the main frame's document: each time one commits. */
+  start(): void {
+    const frame = this.frameOf(() => this.contents.mainFrame)
+    this.child = undefined
+    this.main = frame ? this.watch(frame, false) : undefined
+  }
+
+  stop(): void {
+    this.main = undefined
+    this.child = undefined
+    clearTimeout(this.retry)
+  }
+
+  /** A frame inside the page loaded a new document: the followed one is watched again in it. */
+  frameNavigated(processId: number, routingId: number): void {
+    const child = this.child
+    if (!child || read(() => child.frame.processId === processId && child.frame.routingId === routingId) !== true)
+      return
+    this.child = this.watch(child.frame, true)
+  }
+
+  /** Follows the frame inside the page that has the keyboard, if one does. */
+  sync(): void {
+    const main = this.main
+    const focused = this.frameOf(() => this.contents.focusedFrame)
+    if (!main || !focused || sameFrame(focused, main.frame)) {
+      this.child = undefined
+      return
+    }
+    if (this.child && sameFrame(this.child.frame, focused)) return
+    this.child = this.watch(focused, true)
+  }
+
+  now(): FocusNow | undefined {
+    this.sync()
+    const child = this.child
+    if (child) {
+      return {
+        frame: child.frame,
+        inFrame: true,
+        where: child.where,
+        verdict: (input, pressedAt) => this.frameVerdict(child, input, pressedAt),
+      }
+    }
+    const main = this.main
+    if (!main) return undefined
+    return {
+      frame: main.frame,
+      inFrame: false,
+      where: main.where,
+      verdict: (input, pressedAt) => pageVerdict(this.contents, input, pressedAt),
+    }
+  }
+
+  private frameOf(get: () => WebFrameMain | null): WebFrameMain | undefined {
+    if (this.contents.isDestroyed()) return undefined
+    return read(get) ?? undefined
+  }
+
+  private watch(frame: WebFrameMain, keys: boolean): Watch {
+    const watch: Watch = { frame, where: undefined, keys, records: [], wake: new Set(), answers: [] }
+    this.ask(watch)
+    return watch
+  }
+
+  private current(watch: Watch): boolean {
+    return watch === this.main || watch === this.child
+  }
+
+  private ask(watch: Watch): void {
+    let asked: Promise<unknown>
+    try {
+      asked = watch.frame.executeJavaScript(FOCUS(watch.where ?? null, watch.keys))
+    } catch {
+      return
+    }
+    asked.then(
+      (value) => {
+        if (!this.current(watch)) return
+        const answer = readAnswer(value)
+        // A frame that answers something else isn't asked again; its next document is.
+        if (!answer) return
+        watch.where = answer.where
+        if (answer.key) {
+          watch.records.push(answer.key)
+          if (watch.records.length > 16) watch.records.shift()
+          for (const wake of [...watch.wake]) wake()
+        }
+        const now = Date.now()
+        watch.answers = watch.answers.filter((t) => now - t < 1000)
+        watch.answers.push(now)
+        if (watch.answers.length > ANSWERS_PER_SECOND) {
+          setTimeout(() => {
+            if (this.current(watch)) this.ask(watch)
+          }, PAUSE_MS)
+        } else {
+          this.ask(watch)
+        }
+        if (watch === this.main) this.follow(answer.where)
+      },
+      // The frame's document went away: the next one is watched when it commits.
+      () => {},
+    )
+  }
+
+  /**
+   * The main frame says the keyboard went into a frame inside it: follows that frame. Chromium may
+   * say which frame has focus a moment after the page does, so this looks again a few times.
+   */
+  private follow(where: FrameWhere, tries = 5): void {
+    clearTimeout(this.retry)
+    this.sync()
+    if (where !== 'frame' || this.child || tries <= 0) return
+    this.retry = setTimeout(() => {
+      if (this.main?.where === 'frame') this.follow('frame', tries - 1)
+    }, 20)
+  }
+
+  /** What a followed frame did with a press: from what it noted, waiting for it at most ANSWER_WAIT_MS. */
+  private frameVerdict(watch: Watch, input: Electron.Input, pressedAt: number): Promise<PageVerdict> {
+    const sig = signature(input)
+    const since = pressedAt - 10
+    const find = () => watch.records.find((r) => r.sig === sig && r.at >= since)
+    const verdict = (r: KeyRecord): PageVerdict => ({ seen: true, prevented: r.prevented, inField: r.inField })
+    const found = find()
+    if (found) return Promise.resolve(verdict(found))
+    return new Promise((resolve) => {
+      const done = (answer: PageVerdict) => {
+        clearTimeout(timer)
+        watch.wake.delete(wake)
+        resolve(answer)
+      }
+      const wake = () => {
+        const r = find()
+        if (r) done(verdict(r))
+      }
+      // No answer: the frame left the key alone (D60).
+      const timer = setTimeout(() => done(undefined), ANSWER_WAIT_MS)
+      watch.wake.add(wake)
+    })
+  }
+}
+
+const watched = new WeakMap<WebContents, PageFocus>()
+
+/** Watches where the keyboard is in a tab's page, from its first document on (KS-16, D60). */
+export function watchPageFocus(contents: WebContents): void {
+  if (watched.has(contents)) return
+  const focus = new PageFocus(contents)
+  watched.set(contents, focus)
+  contents.on('did-navigate', () => focus.start())
+  contents.on('did-frame-navigate', (_event, _url, _code, _status, isMainFrame, processId, routingId) => {
+    if (!isMainFrame) focus.frameNavigated(processId, routingId)
+  })
+  // A key typed into a frame the page moved the keyboard to, which the page doesn't say.
+  contents.on('before-input-event', (_event, input) => {
+    if (input.type === 'keyDown') focus.sync()
+  })
+  contents.once('destroyed', () => focus.stop())
+  focus.start()
+}
+
+/** Where the keyboard is in a tab's page now; undefined for a page Orbit doesn't watch. */
+export function pageFocus(contents: WebContents): FocusNow | undefined {
+  if (contents.isDestroyed()) return undefined
+  return watched.get(contents)?.now()
+}
diff --git a/src/main/keys/page-keys.ts b/src/main/keys/page-keys.ts
index fca33688..4f881282 100644
--- a/src/main/keys/page-keys.ts
+++ b/src/main/keys/page-keys.ts
@@ -3,6 +3,25 @@ import type { WebContents } from 'electron'
 /** Isolated world for the keys lane's page script (KS-02, KS-16): the page can't see or change it. */
 export const KEYS_WORLD = 1020
 
+/**
+ * Whether an element is a text field: one that types or edits text (page script source, shared by
+ * the watcher here and the focus mirror in page-focus.ts).
+ */
+export const EDITABLE = `(el) => {
+  if (!el || el === document.body || el === document.documentElement) return false
+  if (el.isContentEditable) return true
+  const tag = el.tagName
+  if (tag === 'TEXTAREA' || tag === 'SELECT') return true
+  if (tag !== 'INPUT') return false
+  const type = (el.getAttribute('type') || 'text').toLowerCase()
+  return !['button', 'checkbox', 'color', 'file', 'hidden', 'image', 'radio', 'range', 'reset', 'submit'].includes(type)
+}`
+
+/** A key press as the page scripts note it: its modifiers and physical key. */
+export function signature(input: Pick<Electron.Input, 'meta' | 'control' | 'alt' | 'shift' | 'code'>): string {
+  return [input.meta, input.control, input.alt, input.shift, input.code].join(',')
+}
+
 /**
  * Notes, for each trusted key press in the page's main frame, whether the page called
  * preventDefault on it once every one of its own handlers has run, and whether keyboard focus was
@@ -13,21 +32,12 @@ const WATCH = `(() => {
   if (window.__orbitKeys) return true
   const seen = []
   let waiters = []
-  const editable = () => {
-    const el = document.activeElement
-    if (!el || el === document.body || el === document.documentElement) return false
-    if (el.isContentEditable) return true
-    const tag = el.tagName
-    if (tag === 'TEXTAREA' || tag === 'SELECT') return true
-    if (tag !== 'INPUT') return false
-    const type = (el.getAttribute('type') || 'text').toLowerCase()
-    return !['button', 'checkbox', 'color', 'file', 'hidden', 'image', 'radio', 'range', 'reset', 'submit'].includes(type)
-  }
+  const editable = ${EDITABLE}
   addEventListener('keydown', (e) => {
     if (!e.isTrusted) return
     const sig = [e.metaKey, e.ctrlKey, e.altKey, e.shiftKey, e.code].join(',')
     const at = Date.now()
-    const inField = editable()
+    const inField = editable(document.activeElement)
     // After the whole dispatch: the page's handlers have all had the event.
     setTimeout(() => {
       seen.push({ sig, at, inField, prevented: e.defaultPrevented })
@@ -75,18 +85,21 @@ export function watchPageKeys(contents: WebContents): void {
 
 /** What the page did with a key press. */
 export type PageVerdict =
-  /** The press reached the page's main frame: whether it called preventDefault, and whether focus was in a text field. */
+  /** The press reached the frame with the keyboard: whether it called preventDefault, and whether focus was in a text field. */
   | { seen: true; prevented: boolean; inField: boolean }
-  /** Not within the wait: the page stopped it before any handler, or focus is in a frame. */
+  /** The main frame's watcher didn't see the press within the wait: a handler of the page that ran first stopped it. */
   | { seen: false }
-  /** The page has no watcher (still loading, or a page Orbit can't script). */
+  /** No answer: the page has no watcher (loading, or a page Orbit can't script), or answered too late. */
   | undefined
 
-/** How long to wait for the page's answer before taking it that the page kept the key. */
-export const VERDICT_WAIT_MS = 250
+/** How long the page's watcher waits for the press to reach it (a little less than ANSWER_WAIT_MS). */
+export const VERDICT_WAIT_MS = 200
 
-/** How long main waits for an answer at all: a page whose renderer is busy or hung answers late. */
-const ANSWER_WAIT_MS = 1000
+/**
+ * How long main waits for the page's answer at all; a page whose renderer is busy or hung answers
+ * late, and no answer counts as the page leaving the key alone (D60).
+ */
+export const ANSWER_WAIT_MS = 250
 
 /**
  * Whether the page can say at once what it did with a key press. Electron runs no isolated-world
@@ -107,7 +120,7 @@ export async function pageVerdict(
   pressedAt: number,
 ): Promise<PageVerdict> {
   if (!pageCanAnswer(contents)) return undefined
-  const sig = [input.meta, input.control, input.alt, input.shift, input.code].join(',')
+  const sig = signature(input)
   const code = `window.__orbitKeys ? window.__orbitKeys.verdict(${JSON.stringify(sig)}, ${pressedAt - 10}, ${VERDICT_WAIT_MS}) : null`
   let timer: NodeJS.Timeout | undefined
   try {
diff --git a/src/main/keys/router.ts b/src/main/keys/router.ts
index 4fd606f8..a279a2d1 100644
--- a/src/main/keys/router.ts
+++ b/src/main/keys/router.ts
@@ -5,6 +5,7 @@ import { acceleratorFromInput, modifiersOf } from '../../shared/keymap'
 import type { WindowId } from '../../shared/state'
 import type { MainContext } from '../context'
 import { actionInWindow } from './open-file'
+import { pageFocus, watchPageFocus } from './page-focus'
 import { pageCanAnswer, pageVerdict, watchPageKeys } from './page-keys'
 
 /** A second press of the same keys within this long after the page took the first runs the action (KS-02). */
@@ -40,7 +41,10 @@ export class KeyRouter {
 
   init(ctx: MainContext): void {
     this.ctx = ctx
-    ctx.hooks.tabCreated.push((_tabId, contents) => watchPageKeys(contents))
+    ctx.hooks.tabCreated.push((_tabId, contents) => {
+      watchPageKeys(contents)
+      watchPageFocus(contents)
+    })
     // An action run some other way after a page took its keys (the toast's button, the command
     // bar): the next press of the keys is a first press again. Watches only; never handles.
     ctx.actions.intercept((id) => {
@@ -97,17 +101,23 @@ export class KeyRouter {
   }
 
   /**
-   * W, with Control still held, while switching to a recent tab (⌃Tab) closes the highlighted tab
-   * (KS-06, TB-05); a held W closes one. Returns true when the press was the switcher's: the
-   * caller keeps it from the page and every shortcut (Ctrl+W, Ctrl+Shift+W).
+   * Keys of the recent-tab switcher while it is up (⌃Tab held, KS-06, TB-05), with Control still
+   * held:
+   * - W closes the highlighted tab; a held W closes one.
+   * - ` steps back, on every platform (D60). The rest of the time ⌃` is the page's.
+   * Returns true when the press was the switcher's: the caller keeps it from the page and every
+   * shortcut (Ctrl+W, Ctrl+Shift+W).
    */
   switcherKey(input: Electron.Input, windowOf: () => WindowId | undefined): boolean {
     if (input.type !== 'keyDown' || !input.control || input.meta || input.alt) return false
-    if (input.code !== 'KeyW' && input.key.toLowerCase() !== 'w') return false
+    const close = input.code === 'KeyW' || input.key.toLowerCase() === 'w'
+    const back = !input.shift && (input.code === 'Backquote' || input.key === '`')
+    if (!close && !back) return false
     const windowId = windowOf()
     const recent = this.ctx?.tabs.recentSwitch
     if (!windowId || !recent?.active(windowId)) return false
-    if (!input.isAutoRepeat) recent.closeHighlighted(windowId)
+    if (back) void this.ctx?.actions.run('tab.recentBack', { windowId })
+    else if (!input.isAutoRepeat) recent.closeHighlighted(windowId)
     return true
   }
 
@@ -128,10 +138,13 @@ export class KeyRouter {
    *   about a second runs it: for that press this returns false, and the caller runs the action
    *   at once and keeps the key from the page. A held key's repeats stay the page's.
    * - an action that prefers Orbit but leaves its keys to text fields (Back and Forward's ⌘[ ⌘]):
-   *   the action runs unless focus was in a text field and the page used the press, or the press
-   *   went into a frame Orbit can't see into.
-   * A page whose main frame is loading can't say what it did with a press in time: Orbit takes
-   * the keys at once then.
+   *   outside a text field it runs at once and the page never sees the key, however busy the
+   *   page is (D60). In a text field the page gets the key first, and the action runs unless the
+   *   page used it.
+   * With the keyboard in a frame inside the page, that frame's fields and handlers decide (D60).
+   * No answer from the page within ANSWER_WAIT_MS counts as the page leaving the key alone. A
+   * page whose main frame is loading can't say what it did with a press in time: Orbit takes the
+   * keys at once then.
    */
   leaveToPage(
     contents: WebContents,
@@ -145,16 +158,24 @@ export class KeyRouter {
     if (priority === 'orbit' && !action.pageFirstInFields) return false
     // A page that is loading can't say in time what it did with the key: Orbit takes it at once.
     if (!pageCanAnswer(contents)) return false
+    // Where the keyboard is, known before the press: the page itself or a frame inside it.
+    const focus = pageFocus(contents)
+    const verdict = (pressedAt: number) =>
+      focus ? focus.verdict(input, pressedAt) : pageVerdict(contents, input, pressedAt)
     const key = `${contents.id} ${acceleratorFromInput(input) ?? ''}`
     const windowId = windowOf()
     // Until the page's answer is in, the macOS menu may run the action instead (`menuRuns`).
     const first: FirstPress = { actionId: action.id, until: Number.POSITIVE_INFINITY }
     if (priority === 'orbit') {
+      // Outside a text field the action runs at once (D60); so it does in a frame not known to
+      // have a text field focused.
+      if (focus && (focus.where === 'page' || (focus.inFrame && focus.where !== 'field'))) return false
       this.firstPresses.set(key, first)
-      void pageVerdict(contents, input, Date.now()).then((verdict) => {
+      void verdict(Date.now()).then((answer) => {
         if (this.firstPresses.get(key) === first) this.firstPresses.delete(key)
         if (first.menuRan || contents.isDestroyed()) return
-        if (verdict && (!verdict.seen || (verdict.prevented && verdict.inField))) return
+        // Only a text field whose page used the key keeps it (KS-16).
+        if (answer?.seen && answer.prevented && answer.inField) return
         this.ran(action, windowId)
       })
       return true
@@ -168,14 +189,15 @@ export class KeyRouter {
     if (input.isAutoRepeat) return true
     // Until the page's answer is in, another press counts as the second one.
     this.firstPresses.set(key, first)
-    void pageVerdict(contents, input, Date.now()).then((verdict) => {
+    void verdict(Date.now()).then((answer) => {
       // Whether a second press came (and ran the action) before the answer.
       const waiting = this.firstPresses.get(key) === first
       if (first.menuRan || contents.isDestroyed()) {
         if (waiting) this.firstPresses.delete(key)
         return
       }
-      if (!verdict || (verdict.seen && !verdict.prevented)) {
+      // No answer, or the page saw the press and left it alone.
+      if (!answer || (answer.seen && !answer.prevented)) {
         // The page left the key alone: the press is the action's, besides any second press's.
         if (waiting) this.firstPresses.delete(key)
         this.ran(action, windowId)
diff --git a/src/main/keys/special-windows.ts b/src/main/keys/special-windows.ts
index ff818605..884ea052 100644
--- a/src/main/keys/special-windows.ts
+++ b/src/main/keys/special-windows.ts
@@ -11,7 +11,10 @@ import type { MainContext } from '../context'
 /** What the hint says. */
 export const PRIVATE_WINDOW_HINT = 'Not available in a private window'
 
-/** Actions on pinned tabs, Favorites, folders and Today's Clear (⌘D, ⌘⇧K…); every Space action is one too. */
+/**
+ * Actions on pinned tabs, Favorites, folders, Today's Clear and the Archive (⌘D, ⌘⇧K…); every Space
+ * action is one too. A private window keeps nothing in the Archive (SB-25).
+ */
 const NEEDS_SPACES = new Set([
   'tab.togglePin',
   'tab.favorite',
@@ -20,6 +23,7 @@ const NEEDS_SPACES = new Set([
   'pinned.toggleCollapsed',
   'folder.new',
   'tabs.clearToday',
+  'app.archive',
 ])
 
 /** Whether an action needs the Spaces, pinned tabs, Favorites or folders a private window doesn't have. */
diff --git a/src/main/menu.ts b/src/main/menu.ts
index 40e683e2..0001fc36 100644
--- a/src/main/menu.ts
+++ b/src/main/menu.ts
@@ -1,4 +1,4 @@
-import { app, Menu, type MenuItemConstructorOptions } from 'electron'
+import { app, BrowserWindow, Menu, type MenuItemConstructorOptions } from 'electron'
 import { ACTIONS_BY_ID, borrowedShortcutsFor, shortcutsFor, toElectronAccelerator } from '../shared/actions'
 import { editsText } from '../shared/keymap'
 import { keepForMenu } from './archive/menus'
@@ -18,6 +18,7 @@ export function installMenu(ctx: MainContext): void {
     Menu.setApplicationMenu(null)
     return
   }
+  const windowShown = anyWindowShown()
   const item = (id: string, label?: string): MenuItemConstructorOptions => {
     const action = ACTIONS_BY_ID[id]
     const own = action ? shortcutsFor(action, 'darwin')[0] : undefined
@@ -28,8 +29,9 @@ export function installMenu(ctx: MainContext): void {
       label: label ?? action?.title ?? id,
       accelerator: accel ? toElectronAccelerator(accel) : undefined,
       // A binding that types or edits text (KS-16) is only shown: the router runs it outside text
-      // fields, and the menu must not take it from one. So are lent keys: the router picks the action.
-      ...(accel && (lent || editsText(accel, 'darwin')) ? { registerAccelerator: false } : {}),
+      // fields, and the menu must not take it from one. So are lent keys while a window is shown:
+      // the router picks the action. With none, the menu is all there is, and ⌘O opens a file (KS-12).
+      ...(accel && ((lent && windowShown) || editsText(accel, 'darwin')) ? { registerAccelerator: false } : {}),
       click: () => {
         // A key let through to a page that left it alone reaches the menu too: it runs once (KS-02).
         if (!keyRouter.menuRuns(id)) return
@@ -186,3 +188,41 @@ export function installMenu(ctx: MainContext): void {
   ]
   Menu.setApplicationMenu(Menu.buildFromTemplate(template))
 }
+
+/**
+ * Whether an Orbit window is on screen. Key presses in one go through the key router
+ * (src/main/windows.ts `attachShortcuts`); with none, only the menu bar sees them (KS-12).
+ */
+function anyWindowShown(): boolean {
+  return BrowserWindow.getAllWindows().some((w) => !w.isDestroyed() && w.isVisible() && !w.isMinimized())
+}
+
+let watching = false
+
+/**
+ * macOS: builds the menu bar again when the last Orbit window leaves the screen, and when one comes
+ * back, so that the keys the menu only shows while a window is up (⌘O for Open File…) work from the
+ * menu with none (KS-12).
+ */
+export function watchWindowsForMenu(ctx: MainContext): void {
+  if (process.platform !== 'darwin' || watching) return
+  watching = true
+  let shown = anyWindowShown()
+  const check = () => {
+    // Once Electron has the window's new state.
+    setImmediate(() => {
+      const now = anyWindowShown()
+      if (now === shown) return
+      shown = now
+      installMenu(ctx)
+    })
+  }
+  app.on('browser-window-created', (_event, win) => {
+    win.on('show', check)
+    win.on('hide', check)
+    win.on('minimize', check)
+    win.on('restore', check)
+    win.on('closed', check)
+    check()
+  })
+}
diff --git a/src/main/miniwindow/index.ts b/src/main/miniwindow/index.ts
index 9fa8d082..15f70c75 100644
--- a/src/main/miniwindow/index.ts
+++ b/src/main/miniwindow/index.ts
@@ -665,6 +665,12 @@ export function registerMiniWindow(ctx: MainContext): void {
     if (items.length === 0) return
     Menu.buildFromTemplate(items).popup({ window: mini.win, x: Math.round(x), y: Math.round(y) })
   })
+  // Esc in the address field: the keyboard goes back to the page, which had it before ⌘L (KS-16, KS-20).
+  commands.register('mini.focusPage', (_args, c) => {
+    const mini = miniOf(c)
+    const contents = mini?.tabId ? tabs.contents(mini.tabId) : undefined
+    if (contents && !contents.isDestroyed()) contents.focus()
+  })
   commands.register('mini.control', ({ op }, c) => {
     const mini = miniOf(c)
     if (!mini || mini.win.isDestroyed()) return
@@ -690,13 +696,16 @@ export function registerMiniWindow(ctx: MainContext): void {
   actions.register('mini.toggleAll', toggleAll)
 
   // In a Mini Window, keys act on its page; sidebar, Space and tab-list keys do nothing (KS-20).
-  // Help → Keyboard Shortcuts and File → Open File… act in the browser window behind (OB-12, KS-12, keys lane).
+  // Help → Keyboard Shortcuts, File → Open File… and the Library's keys (⌘Y / Ctrl+H for History,
+  // ⌘⇧L) act in the browser window behind (OB-12, KS-12, AR-10, keys lane).
   const APP_ACTIONS = new Set([
     'window.new',
     'window.newMini',
     'window.newPrivate',
     'app.settings',
     'app.archive',
+    'app.history',
+    'app.library',
     'help.shortcuts',
     'file.open',
   ])
diff --git a/src/main/nav/index.ts b/src/main/nav/index.ts
index e46c88ba..dd302ddf 100644
--- a/src/main/nav/index.ts
+++ b/src/main/nav/index.ts
@@ -6,6 +6,7 @@ import { historyEntryLabel, historyMenuIndexes, shownTabId } from '../../shared/
 import { isPrivateTab, isPrivateWindow } from '../../shared/private'
 import type { TabId, WindowId } from '../../shared/state'
 import type { MainContext } from '../context'
+import { escapeThenStop } from '../keys/escape'
 import type { CallContext } from '../registry'
 import type { TabOps, TabPage } from '../tabs/ops'
 import { type LinkPillInfo, registerLinkPill } from './link-pill'
@@ -344,16 +345,24 @@ export function registerNav(ctx: MainContext, ops: TabOps): void {
   registerPageBridge(ctx, permissions)
 
   ctx.hooks.tabCreated.push((tabId, contents) => {
-    // Esc stops a loading page (NV-04). The page still gets the key; an open overlay (command bar,
-    // find bar, Peek) holds keyboard focus and takes Esc before the page could see it (KS-19).
+    // Esc stops a loading page (NV-04), unless the page uses it: the page gets the key first, and
+    // Orbit stops the load once the page's preload says no handler took it (D59, keys lane). An
+    // open overlay (command bar, find bar, Peek) holds keyboard focus and takes Esc before the page
+    // could see it (KS-19).
     contents.on('before-input-event', (_event, input) => {
       if (input.type !== 'keyDown' || input.key !== 'Escape') return
       if (input.meta || input.control || input.alt || input.shift) return
       if (!store.state.tabs[tabId]?.loading) return
       const windowId = windows.windowOfTab(tabId)
       if (windowId && store.state.windows[windowId]?.overlay.kind !== 'none') return
-      pending.markStopped(tabId)
-      contents.stop()
+      escapeThenStop(
+        contents,
+        () => !!store.state.tabs[tabId]?.loading,
+        () => {
+          pending.markStopped(tabId)
+          contents.stop()
+        },
+      )
     })
     // The mouse's back/forward buttons over a page need nothing here: the page itself goes back or
     // forward one entry on release (Chromium), unless it handles the buttons (NV-01). Over the
diff --git a/src/preload/page.ts b/src/preload/page.ts
index d5edec99..d833c20d 100644
--- a/src/preload/page.ts
+++ b/src/preload/page.ts
@@ -12,6 +12,8 @@
  * Orbit's internal pages (`orbit://<page>/`, DT-13) are Orbit's UI in a tab, not web pages: in the
  * main frame of one, and only there, this gives the bridge Orbit's UI has (D53), and patches
  * nothing. See `exposeInternalPage`.
+ *
+ * In every page's main frame, it also tells main whether the page used an Esc (D59, `watchEscape`).
  */
 import { contextBridge, ipcRenderer } from 'electron'
 import type { OrbitBridge, StatePatch } from '../shared/rpc'
@@ -190,6 +192,27 @@ function exposeInternalPage(windowId: string): void {
   contextBridge.exposeInMainWorld('orbit', bridge)
 }
 
+/**
+ * Esc on a loading page (KS-19, D59): once every handler of the page has had a trusted Esc, main
+ * learns one bit, whether the page used it (preventDefault). Main stops the load only if it didn't.
+ * Runs in this preload's own world: nothing is added to the page, and nothing else is sent.
+ */
+function watchEscape(): void {
+  if (window.top !== window) return
+  window.addEventListener(
+    'keydown',
+    (event) => {
+      if (!event.isTrusted || event.key !== 'Escape') return
+      if (event.metaKey || event.ctrlKey || event.altKey || event.shiftKey) return
+      // After the whole dispatch: the page's handlers have all run.
+      setTimeout(() => ipcRenderer.send(PAGE_CHANNEL.escape, event.defaultPrevented === true), 0)
+    },
+    true,
+  )
+}
+
+watchEscape()
+
 if (location.protocol === 'orbit:') {
   // An internal page. Main says no (null) to anything but a tab's main frame showing one.
   if (window.top === window) {
diff --git a/src/renderer/src/mini/MiniApp.tsx b/src/renderer/src/mini/MiniApp.tsx
index 3ec37aa0..7c4cdea1 100644
--- a/src/renderer/src/mini/MiniApp.tsx
+++ b/src/renderer/src/mini/MiniApp.tsx
@@ -157,8 +157,11 @@ function AddressField({ url, onDone }: { url: string; onDone: () => void }) {
         onChange={(e) => setText(e.target.value)}
         onBlur={onDone}
         onKeyDown={(e) => {
+          // Esc gives the keyboard back to the page (KS-16). Not on blur: a click on the page has
+          // already moved it there.
           if (e.key === 'Escape') {
             e.preventDefault()
+            void invoke('mini.focusPage', {})
             onDone()
           }
         }}
diff --git a/src/renderer/src/shell/sidebar/SidebarItems.tsx b/src/renderer/src/shell/sidebar/SidebarItems.tsx
index cda630bd..efab220f 100644
--- a/src/renderer/src/shell/sidebar/SidebarItems.tsx
+++ b/src/renderer/src/shell/sidebar/SidebarItems.tsx
@@ -107,7 +107,7 @@ export const SidebarItems = memo(function SidebarItems({
         >
           {simple ? header : <SpaceHeader space={space}>{header}</SpaceHeader>}
           {!simple && <PinnedSection space={space} />}
-          <TodayBlock space={space} />
+          <TodayBlock space={space} clear={!simple} />
           <ItemList
             key={`today:${space.id}`}
             containerKey={`today:${space.id}`}
@@ -221,10 +221,13 @@ const PinnedSection = memo(function PinnedSection({ space }: { space: Space }) {
   )
 })
 
-/** Divider with Clear (TD-04) and the "+ New Tab" row (SB-07): one drop slot between pinned and Today. */
-function TodayBlock({ space }: { space: Space }) {
+/**
+ * Divider with Clear (TD-04) and the "+ New Tab" row (SB-07): one drop slot between pinned and Today.
+ * A private window's list has no Clear: its tabs have no Archive to go to (SB-25, KS-20).
+ */
+function TodayBlock({ space, clear }: { space: Space; clear: boolean }) {
   const y = useRowShift('divider')
-  const hasToday = space.today.length > 0
+  const hasToday = clear && space.today.length > 0
   // The button's tooltip follows a remapped shortcut (KS-18).
   const clearShortcut = useShortcutLabel('tabs.clearToday')
   return (
diff --git a/src/shared/actions.ts b/src/shared/actions.ts
index b9707d88..c8a5ef24 100644
--- a/src/shared/actions.ts
+++ b/src/shared/actions.ts
@@ -68,7 +68,9 @@ export interface ActionDef {
   preferWebsites?: boolean | 'other'
   /**
    * With "prefer Orbit", the keys still go first to a page whose text field has focus, and the
-   * action runs only when the page leaves them alone (Back and Forward's ⌘[ and ⌘], KS-16).
+   * action runs unless that page uses them (Back and Forward's ⌘[ and ⌘], KS-16). Anywhere else
+   * the action runs at once and the page never sees the key, however busy the page is. With
+   * keyboard focus in a frame, the frame's own text field and handlers decide (D60).
    */
   pageFirstInFields?: boolean
 }
@@ -127,7 +129,9 @@ export const ACTIONS: ActionDef[] = [
     id: 'tab.recentBack',
     title: 'Switch to Recent Tab (Back)',
     category: 'Tabs',
-    mac: ['Ctrl+Shift+Tab', 'Ctrl+`'],
+    // ⌃` steps back too, on every platform, but only while the switcher is up: the key router's
+    // (src/main/keys/router.ts `switcherKey`), so a page gets it the rest of the time (D60, TB-05).
+    mac: ['Ctrl+Shift+Tab'],
     other: ['Ctrl+Shift+Tab'],
     hidden: true,
     fixed: true,
@@ -334,8 +338,9 @@ export const ACTIONS: ActionDef[] = [
     category: 'Sidebar',
     mac: ['Cmd+S'],
     other: ['Ctrl+S'],
-    // SB-11: a web editor's ⌘S / Ctrl+S gets the first press (KS-02).
-    preferWebsites: true,
+    // SB-11: a web editor's Ctrl+S gets the first press on Windows and Linux (KS-02). On macOS ⌘S
+    // prefers Orbit, as every other action does there; people can change it per action (D60).
+    preferWebsites: 'other',
   },
   { id: 'window.new', title: 'New Window', category: 'Window', mac: ['Cmd+N'], other: ['Ctrl+N'] },
   // Alt+F4 closes the window too, as the system's key (KS-05).
diff --git a/src/shared/commands/peek.ts b/src/shared/commands/peek.ts
index 76d03944..9cd7a503 100644
--- a/src/shared/commands/peek.ts
+++ b/src/shared/commands/peek.ts
@@ -39,6 +39,8 @@ export interface PeekCommands {
   'mini.menu': { args: { menu: 'open-in' | 'profile'; x: number; y: number }; result: void }
   /** Window buttons of a Mini Window (its page is archived on close, MW-09). */
   'mini.control': { args: { op: 'close' | 'minimize' | 'maximize' }; result: void }
+  /** Gives the keyboard back to the Mini Window's page: Esc in its address field (KS-16, KS-20). */
+  'mini.focusPage': { args: Record<string, never>; result: void }
 }
 
 export interface PeekEvents {
diff --git a/src/shared/keymap.ts b/src/shared/keymap.ts
index b25117cd..874f0981 100644
--- a/src/shared/keymap.ts
+++ b/src/shared/keymap.ts
@@ -297,6 +297,11 @@ export function bindingProblem(accel: string, platform: string): string | undefi
   }
   const taken = RESERVED[mac ? 'mac' : 'other'][canonical]
   if (taken) return `${formatAccelerator(canonical, platform)} is kept for ${taken}.`
+  // macOS text fields move the caret with ⌃A, ⌃E, ⌃N, ⌃P and the rest, and the command bar moves
+  // its highlight with ⌃N and ⌃P: a binding would take them (D60).
+  if (mac && a.ctrl && !a.cmd && !a.alt && !a.shift && /^[A-Z]$/.test(a.key)) {
+    return `${formatAccelerator(canonical, platform)} is kept for text fields: on macOS, ⌃ with a letter moves the caret.`
+  }
   return undefined
 }
 
diff --git a/src/shared/site.ts b/src/shared/site.ts
index 9fc0d355..8ed55ef1 100644
--- a/src/shared/site.ts
+++ b/src/shared/site.ts
@@ -192,6 +192,12 @@ export const PAGE_CHANNEL = {
   internalInvoke: 'orbit-page:internal-invoke',
   /** Main → page: (channel, ...args) of a state change or broadcast Orbit's UI gets. */
   internalEvent: 'orbit-page:internal-event',
+  /**
+   * send(used): a trusted Esc reached the page's main frame and every handler of the page has had
+   * it: whether one called preventDefault (KS-19, D59). Main reads it only while it waits after an
+   * Esc in a loading tab, and only from that tab's main frame (src/main/keys/escape.ts).
+   */
+  escape: 'orbit-page:escape',
 } as const
 
 /** A tab comes forward for its notifications' clicks at most this often (a flood can't stall the shell). */
diff --git a/tests/e2e/keys.spec.ts b/tests/e2e/keys.spec.ts
index 3120af62..3ba15926 100644
--- a/tests/e2e/keys.spec.ts
+++ b/tests/e2e/keys.spec.ts
@@ -8,12 +8,14 @@ import {
   cmd,
   cmdIn,
   type NavFixtures,
+  NEW_TAB_CLICK,
   openTab,
   pressInPage,
   setNativeFullScreen,
   startNavFixtures,
   uiPageOf,
   visit,
+  waitLoaded,
   windowList,
   windowState,
   zoomOf,
@@ -25,7 +27,7 @@ let fx: NavFixtures
 let orbit: Orbit
 
 test.beforeAll(async () => {
-  fx = await startNavFixtures()
+  fx = await startNavFixtures(3370, 3389)
 })
 test.afterAll(async () => {
   await fx.close()
@@ -322,8 +324,14 @@ function presses(page: Page): Promise<number> {
   return page.evaluate(() => (window as unknown as { presses: number }).presses)
 }
 
-test('[KS-02][SB-11] a page that uses ⌘S / Ctrl+S gets the first press and a toast offers Toggle Sidebar; a second press within a second runs it', async () => {
+/** Toggle Sidebar set to prefer websites: its default on Windows and Linux; macOS prefers Orbit (D60). */
+async function sidebarPrefersWebsites(): Promise<void> {
+  if (isMac) await run(orbit.app, 'keys.setPriority', { actionId: 'sidebar.toggle', priority: 'websites' })
+}
+
+test('[KS-02][SB-11] preferring websites, a page that uses ⌘S / Ctrl+S gets the first press and a toast offers Toggle Sidebar; a second press within a second runs it', async () => {
   const { app, shell } = orbit
+  await sidebarPrefersWebsites()
   const page = await pageWithKeys('Editor', { code: 'KeyS', use: true })
   await pressMod('s')
   await expect.poll(() => presses(page)).toBe(1)
@@ -348,7 +356,8 @@ test('[KS-02][SB-11] a page that uses ⌘S / Ctrl+S gets the first press and a t
   expect(await presses(page)).toBe(2)
 })
 
-test('[KS-02][SB-11] a page that leaves ⌘S / Ctrl+S alone sees each press, and each press toggles the sidebar', async () => {
+test('[KS-02][SB-11] preferring websites, a page that leaves ⌘S / Ctrl+S alone sees each press, and each press toggles the sidebar', async () => {
+  await sidebarPrefersWebsites()
   const page = await pageWithKeys('Reader', { code: 'KeyS', use: false })
   await pressMod('s')
   await expect.poll(sidebarVisible).toBe(false)
@@ -358,17 +367,18 @@ test('[KS-02][SB-11] a page that leaves ⌘S / Ctrl+S alone sees each press, and
   expect(await presses(page)).toBe(2)
 })
 
-test('[KS-02][ST-08] set to prefer Orbit, ⌘S / Ctrl+S toggles the sidebar at once and the page never sees it', async () => {
+test('[KS-02][ST-08] ⌘S prefers Orbit on macOS (D60) and Ctrl+S websites on Windows and Linux; preferring Orbit, the sidebar toggles at once and the page never sees the key', async () => {
   const { app } = orbit
-  await run(app, 'keys.setPriority', { actionId: 'sidebar.toggle', priority: 'orbit' })
-  expect((await state(app)).settings.shortcutPriority).toEqual({ 'sidebar.toggle': 'orbit' })
+  // Prefer Orbit: macOS's default; on Windows and Linux a choice that is stored.
+  if (!isMac) await run(app, 'keys.setPriority', { actionId: 'sidebar.toggle', priority: 'orbit' })
+  expect((await state(app)).settings.shortcutPriority).toEqual(isMac ? undefined : { 'sidebar.toggle': 'orbit' })
   const page = await pageWithKeys('Editor', { code: 'KeyS', use: true })
   await pressMod('s')
   await expect.poll(sidebarVisible).toBe(false)
   expect(await presses(page)).toBe(0)
-  // Back to the default: the page has the first press again.
+  // Prefer websites (back to the default on Windows and Linux): the page has the first press.
   await run(app, 'keys.setPriority', { actionId: 'sidebar.toggle', priority: 'websites' })
-  expect((await state(app)).settings.shortcutPriority).toBeUndefined()
+  expect((await state(app)).settings.shortcutPriority).toEqual(isMac ? { 'sidebar.toggle': 'websites' } : undefined)
   await pressMod('s')
   await expect.poll(() => presses(page)).toBe(1)
   expect(await sidebarVisible()).toBe(false)
@@ -409,6 +419,7 @@ test('[KS-16][NV-01] in a page text field, ⌘[ / Alt+← goes back only when th
     })
   })
   await c.focus('#box')
+  await focusKnown('/page/FieldC', 'main', 'field')
   await pressInPage(app, '/page/FieldC', key, [...mods])
   await expect
     .poll(() => c.evaluate(() => (window as unknown as { __keys: string[] }).__keys))
@@ -427,6 +438,7 @@ test('[KS-16][NV-01] in a page text field, ⌘[ / Alt+← goes back only when th
 
 test('[KS-02][KS-16] while a page is on its way, Orbit takes its keys at once: ⌘S / Ctrl+S toggles the sidebar, and ⌘[ / Alt+← in a text field goes back', async () => {
   const { app } = orbit
+  await sidebarPrefersWebsites()
   const [key, mods] = isMac ? (['[', ['meta']] as const) : (['Left', ['alt']] as const)
   const id = await openTab(app, fx.url('/page/WayA'))
   await visit(app, id, fx.url('/page/WayB'))
@@ -475,6 +487,216 @@ test('[KS-16][TB-18] ⌘Z / Ctrl+Z in a page text field undoes the typing, not t
   await expect.poll(async () => (await urls()).sort()).toEqual([fx.url('/page/Typing'), fx.url('/page/UndoB')].sort())
 })
 
+// ---------- Keyboard focus in a frame, and pages that are busy (KS-16, KS-02, D60) ----------
+
+type KeysHooks = {
+  __orbitKeys: {
+    focusIn: (urlPart: string) => { frame: string; where: string | null } | null
+    escapes: () => { url: string; used: boolean; stopped: boolean }[]
+  }
+}
+
+/**
+ * Waits until Orbit knows where the keyboard is in the page at `urlPart`: in `frame` ('main' for
+ * the page itself, else the frame's address), on a text field or elsewhere on it ('page').
+ */
+async function focusKnown(urlPart: string, frame: string, where: 'field' | 'page'): Promise<void> {
+  await expect
+    .poll(() =>
+      orbit.app.evaluate((_e, part) => (globalThis as unknown as KeysHooks).__orbitKeys.focusIn(part), urlPart),
+    )
+    .toEqual({ frame, where })
+}
+
+const [BACK_KEY, BACK_MODS] = isMac ? (['[', ['meta']] as const) : (['Left', ['alt']] as const)
+
+/** Runs a script in a frame of the page at `urlPart`, in the frame's own world. */
+function inFrame<T>(urlPart: string, frameUrl: string, code: string): Promise<T> {
+  return orbit.app.evaluate(
+    async ({ webContents }, [part, url, js]) => {
+      const page = webContents.getAllWebContents().find((w) => w.getURL().includes(part))
+      const frame = page?.mainFrame.framesInSubtree.find((f) => f.url === url)
+      if (!frame) throw new Error(`no frame ${url} in ${part}`)
+      return await frame.executeJavaScript(js)
+    },
+    [urlPart, frameUrl, code] as const,
+  ) as Promise<T>
+}
+
+/**
+ * Puts a frame at the top of the page at `urlPart`, showing `/page/<inner>` from the page's own
+ * origin or another one, with a plain button (#plain) in it; returns the frame's address.
+ */
+async function addFrame(urlPart: string, inner: string, crossOrigin: boolean): Promise<string> {
+  const src = crossOrigin ? fx.urlOn('127.0.0.1', `/page/${inner}`) : fx.url(`/page/${inner}`)
+  const page = await tabPage(orbit.app, urlPart)
+  await page.evaluate(
+    (url) =>
+      new Promise<void>((resolve) => {
+        const frame = document.createElement('iframe')
+        frame.style.cssText = 'display:block;width:520px;height:320px;border:0'
+        frame.addEventListener('load', () => resolve(), { once: true })
+        frame.src = url
+        document.body.prepend(frame)
+      }),
+    src,
+  )
+  await inFrame(urlPart, src, `document.body.insertAdjacentHTML('afterbegin', '<button id="plain">Plain</button>')`)
+  return src
+}
+
+/** Clicks an element in a frame as the mouse does, which gives it the keyboard. */
+async function clickInFrame(urlPart: string, frameUrl: string, selector: '#plain' | '#box'): Promise<void> {
+  const page = await tabPage(orbit.app, urlPart)
+  const frame = await page.locator(`iframe[src="${frameUrl}"]`).boundingBox()
+  const at = await inFrame<{ x: number; y: number }>(
+    urlPart,
+    frameUrl,
+    `(() => { const r = document.querySelector('${selector}').getBoundingClientRect(); return { x: r.x + r.width / 2, y: r.y + r.height / 2 } })()`,
+  )
+  if (!frame) throw new Error('no frame')
+  await page.mouse.click(frame.x + at.x, frame.y + at.y)
+  await expect
+    .poll(() =>
+      inFrame(urlPart, frameUrl, 'document.hasFocus() && document.activeElement && document.activeElement.id'),
+    )
+    .toBe(selector.slice(1))
+}
+
+/** A tab at `<title>-C` that came from `<title>-A` and `<title>-B`, with the keyboard, and a frame in it. */
+async function framedTab(title: string, crossOrigin: boolean): Promise<{ id: string; at: string; frame: string }> {
+  const { app } = orbit
+  const id = await openTab(app, fx.url(`/page/${title}-A`))
+  await visit(app, id, fx.url(`/page/${title}-B`))
+  await visit(app, id, fx.url(`/page/${title}-C`))
+  await cmd(app, 'tabs.focusPage', {})
+  await expect.poll(focusedUrl).toBe(fx.url(`/page/${title}-C`))
+  const frame = await addFrame(`/page/${title}-C`, `${title}-Inner`, crossOrigin)
+  return { id, at: `/page/${title}-C`, frame }
+}
+
+const urlOf = async (tabId: string) => (await state(orbit.app)).tabs[tabId]?.url
+
+for (const crossOrigin of [false, true]) {
+  const kind = crossOrigin ? 'cross-origin' : 'same-origin'
+  const tag = crossOrigin ? 'X' : 'S'
+
+  test(`[KS-16][NV-01] keyboard on a button in a ${kind} frame: ⌘[ / Alt+← goes back, at once`, async () => {
+    const { app } = orbit
+    const { id, at, frame } = await framedTab(`FrameButton${tag}`, crossOrigin)
+    await clickInFrame(at, frame, '#plain')
+    await focusKnown(at, frame, 'page')
+    await pressInPage(app, at, BACK_KEY, [...BACK_MODS])
+    await expect.poll(() => urlOf(id)).toBe(fx.url(`/page/FrameButton${tag}-B`))
+  })
+
+  test(`[KS-16][NV-01] keyboard in a text field of a ${kind} frame that leaves ⌘[ / Alt+← alone: it goes back`, async () => {
+    const { app } = orbit
+    const { id, at, frame } = await framedTab(`FrameField${tag}`, crossOrigin)
+    await clickInFrame(at, frame, '#box')
+    await focusKnown(at, frame, 'field')
+    await pressInPage(app, at, BACK_KEY, [...BACK_MODS])
+    await expect.poll(() => urlOf(id)).toBe(fx.url(`/page/FrameField${tag}-B`))
+  })
+}
+
+test('[KS-16][NV-01] a text field in a frame whose page uses ⌘[ / Alt+← keeps it; on the frame’s button the key goes back one page', async () => {
+  const { app } = orbit
+  const { id, at, frame } = await framedTab('FrameEditor', false)
+  // An editor in the frame that outdents with the key while its field has focus.
+  await inFrame(
+    at,
+    frame,
+    `addEventListener('keydown', (e) => {
+      if (document.activeElement?.id === 'box' && (e.code === 'BracketLeft' || e.code === 'ArrowLeft')) e.preventDefault()
+    })`,
+  )
+  await clickInFrame(at, frame, '#box')
+  await focusKnown(at, frame, 'field')
+  await pressInPage(app, at, BACK_KEY, [...BACK_MODS])
+  await expect.poll(() => inFrame<string[]>(at, frame, 'window.__keys')).toContain(isMac ? '[' : 'ArrowLeft')
+  // On the frame's button the key goes back: one page. Had the first press gone back too, this
+  // would land on A.
+  await clickInFrame(at, frame, '#plain')
+  await focusKnown(at, frame, 'page')
+  await pressInPage(app, at, BACK_KEY, [...BACK_MODS])
+  await expect.poll(() => urlOf(id)).toBe(fx.url('/page/FrameEditor-B'))
+})
+
+test('[KS-02][SB-11] keyboard in a frame: Toggle Sidebar, preferring websites, toggles on the first press when the frame leaves ⌘S / Ctrl+S alone; a frame that uses it gets it first', async () => {
+  const { app, shell } = orbit
+  await sidebarPrefersWebsites()
+  const { at, frame } = await framedTab('FrameSave', false)
+  await clickInFrame(at, frame, '#box')
+  await focusKnown(at, frame, 'field')
+  await pressInPage(app, at, 'S', PRIMARY_MOD)
+  await expect.poll(sidebarVisible).toBe(false)
+  expect(await inFrame<string[]>(at, frame, 'window.__keys')).toContain('s')
+  // A frame that saves with the key: the first press is the frame's, and the toast says so.
+  await inFrame(at, frame, `addEventListener('keydown', (e) => { if (e.code === 'KeyS') e.preventDefault() })`)
+  await pressInPage(app, at, 'S', PRIMARY_MOD)
+  const toast = shell.getByTestId('toast').filter({ hasText: `The page used ${SAVE}` })
+  await expect(toast).toHaveCount(1)
+  expect(await sidebarVisible()).toBe(false)
+  await pressInPage(app, at, 'S', PRIMARY_MOD)
+  await expect.poll(sidebarVisible).toBe(true)
+})
+
+/**
+ * Keeps the renderer of the page at `urlPart` busy for 1.5 s, presses a key there once it is, and
+ * returns how long after the press Orbit `acted`: started a navigation, or toggled the sidebar.
+ */
+function busyPress(
+  urlPart: string,
+  key: string,
+  mods: readonly Mod[],
+  acted: 'navigation' | 'sidebar',
+): Promise<number> {
+  return orbit.app.evaluate(
+    async ({ webContents }, [part, keyCode, modifiers, what]) => {
+      const page = webContents.getAllWebContents().find((w) => w.getURL().includes(part))
+      if (!page) throw new Error(`no page ${part}`)
+      type Windows = Record<string, { sidebar: { visible: boolean } }>
+      const hooks = (globalThis as unknown as { __orbit: { state: () => { windows: Windows } } }).__orbit
+      const sidebar = () => Object.values(hooks.state().windows)[0]?.sidebar.visible
+      // The page says it is busy just before it is.
+      const busy = new Promise((resolve) => page.once('page-title-updated', resolve))
+      void page.executeJavaScript(
+        `document.title = 'Busy'; { const end = Date.now() + 1500; while (Date.now() < end); }`,
+      )
+      await busy
+      const before = sidebar()
+      const navigated = new Promise<void>((resolve) => page.once('did-start-navigation', () => resolve()))
+      const start = performance.now()
+      page.sendInputEvent({ type: 'keyDown', keyCode, modifiers: [...modifiers] })
+      page.sendInputEvent({ type: 'keyUp', keyCode, modifiers: [...modifiers] })
+      if (what === 'navigation') await navigated
+      else while (sidebar() === before) await new Promise((r) => setTimeout(r, 2))
+      return performance.now() - start
+    },
+    [urlPart, key, mods, acted] as const,
+  )
+}
+
+test('[KS-16][NV-01] on a busy page, ⌘[ / Alt+← outside a text field goes back at once: Orbit does not wait for the page (D60)', async () => {
+  const { app } = orbit
+  const id = await openTab(app, fx.url('/page/BusyBackA'))
+  await visit(app, id, fx.url('/page/BusyBackB'))
+  await cmd(app, 'tabs.focusPage', {})
+  await expect.poll(focusedUrl).toBe(fx.url('/page/BusyBackB'))
+  await focusKnown('/page/BusyBackB', 'main', 'page')
+  expect(await busyPress('/page/BusyBackB', BACK_KEY, BACK_MODS, 'navigation')).toBeLessThan(200)
+  await expect.poll(() => urlOf(id)).toBe(fx.url('/page/BusyBackA'))
+})
+
+test('[KS-02][SB-11] on a busy page, a key that prefers websites waits at most 250 ms for the page, then Orbit acts (D60)', async () => {
+  await sidebarPrefersWebsites()
+  await pageWithKeys('BusySave', { code: 'KeyS', use: false })
+  await focusKnown('/page/BusySave', 'main', 'page')
+  expect(await busyPress('/page/BusySave', 'S', PRIMARY_MOD, 'sidebar')).toBeLessThan(600)
+  expect(await sidebarVisible()).toBe(false)
+})
+
 // ---------- Tab, window, split and overlay keys (KS-05, KS-06, KS-09, KS-19) ----------
 
 type Mod = 'shift' | 'control' | 'alt' | 'meta'
@@ -616,6 +838,40 @@ test('[KS-06][TB-05] holding ⌃: Tab and ⇧Tab step through recent tabs, W clo
   expect(Object.keys((await state(app)).tabs).sort()).toEqual([b, c, d].sort())
 })
 
+test('[KS-06][TB-05] ⌃` steps back in the recent-tab switcher on every platform, and only while it is up (D60)', async () => {
+  const a = await openTab(orbit.app, fx.url('/page/TickA'))
+  const b = await openTab(orbit.app, fx.url('/page/TickB'))
+  const c = await openTab(orbit.app, fx.url('/page/TickC'))
+  // Most recent first: C, B, A.
+  await selectPage(a, fx.url('/page/TickA'))
+  await selectPage(b, fx.url('/page/TickB'))
+  await selectPage(c, fx.url('/page/TickC'))
+  const ctrl: Mod[] = ['control']
+  const tick: [type: 'keyDown' | 'keyUp', keyCode: string, modifiers: Mod[]][] = [
+    ['keyDown', '`', ctrl],
+    ['keyUp', '`', ctrl],
+  ]
+  // With no switcher up, the key is the page's.
+  const page = await tabPage(orbit.app, '/page/TickC')
+  await keyEvents(tick)
+  await expect.poll(() => page.evaluate(() => (window as unknown as { __keys: string[] }).__keys)).toContain('`')
+  expect(await activeTab()).toBe(c)
+  // ⌃Tab ⌃Tab highlights A; ⌃` steps back to B, and letting go settles there.
+  await keyEvents([
+    ['keyDown', 'Control', ctrl],
+    ['keyDown', 'Tab', ctrl],
+    ['keyUp', 'Tab', ctrl],
+    ['keyDown', 'Tab', ctrl],
+    ['keyUp', 'Tab', ctrl],
+  ])
+  await expect.poll(activeTab).toBe(a)
+  await keyEvents(tick)
+  await expect.poll(activeTab).toBe(b)
+  await keyEvents([['keyUp', 'Control', []]])
+  await expect.poll(focusedUrl).toBe(fx.url('/page/TickB'))
+  expect(await activeTab()).toBe(b)
+})
+
 test('[KS-09][SV-02][SV-16] from a page: ⌃⇧= then Enter on a result shows two panes, ⌃⇧1 focuses the left pane, ⌃⇧] and ⌃⇧[ step, and ⌃⇧− closes the focused pane', async () => {
   const { app, shell } = orbit
   const left = await openTab(app, fx.url('/page/LeftPane'))
@@ -656,6 +912,70 @@ test('[KS-19][PK-09][NV-04] with a Peek open, Esc closes the Peek and the tab un
   await finishLoad(id, '/slow/UnderNext')
 })
 
+/** Esc pressed on pages that were loading, as main saw it: whether the page used it, and whether the load stopped. */
+function escapes(): Promise<{ url: string; used: boolean; stopped: boolean }[]> {
+  return orbit.app.evaluate(() => (globalThis as unknown as KeysHooks).__orbitKeys.escapes())
+}
+
+/** A tab with the keyboard whose page has run its scripts and is still loading: it waits for an image from `/slow/<title>`. */
+async function stillLoading(title: string): Promise<{ id: string; path: string; image: string }> {
+  const { app } = orbit
+  const image = `/slow/${title}Image`
+  const path = `/page/${title}?wait=${encodeURIComponent(image)}`
+  const id = await cmd<string>(app, 'tabs.create', { url: fx.url(path) })
+  await expect.poll(() => fx.hits(image)).toBe(1)
+  await cmd(app, 'tabs.focusPage', {})
+  await expect.poll(focusedUrl).toBe(fx.url(path))
+  expect((await state(app)).tabs[id]?.loading).toBe(true)
+  return { id, path, image }
+}
+
+test('[KS-19][NV-04] Esc on a loading page that uses Esc itself goes to the page, and the load goes on (D59)', async () => {
+  const { app } = orbit
+  const { id, path, image } = await stillLoading('EscUsed')
+  const page = await tabPage(app, `/page/EscUsed`)
+  await page.evaluate(() => {
+    const w = window as unknown as { escapes: number }
+    w.escapes = 0
+    addEventListener('keydown', (e) => {
+      if (e.key !== 'Escape') return
+      w.escapes++
+      e.preventDefault()
+    })
+  })
+  await pressInPage(app, path, 'Escape')
+  await expect.poll(escapes).toEqual([{ url: fx.url(path), used: true, stopped: false }])
+  expect(await page.evaluate(() => (window as unknown as { escapes: number }).escapes)).toBe(1)
+  expect((await state(app)).tabs[id]?.loading).toBe(true)
+  fx.release(image)
+  await expect.poll(async () => (await state(app)).tabs[id]?.loading).toBe(false)
+})
+
+test('[KS-19][NV-04] Esc on a loading page that leaves Esc alone stops the load (D59)', async () => {
+  const { app } = orbit
+  const { id, path } = await stillLoading('EscLeft')
+  await pressInPage(app, path, 'Escape')
+  await expect.poll(async () => (await state(app)).tabs[id]?.loading).toBe(false)
+  expect(await escapes()).toEqual([{ url: fx.url(path), used: false, stopped: true }])
+})
+
+test('[KS-19][NV-04] what a page tells main about Esc counts only for an Esc pressed there: one sent without a press does nothing (D59)', async () => {
+  const { app } = orbit
+  const { id, path } = await stillLoading('EscStray')
+  // Sent as the page's preload sends it, from the tab's main frame, with no Esc pressed.
+  await app.evaluate(({ ipcMain, webContents }, part) => {
+    const page = webContents.getAllWebContents().find((w) => w.getURL().includes(part))
+    if (!page) throw new Error('no page')
+    ipcMain.emit('orbit-page:escape', { sender: page, senderFrame: page.mainFrame }, true)
+  }, path)
+  expect(await escapes()).toEqual([])
+  expect((await state(app)).tabs[id]?.loading).toBe(true)
+  // The next Esc, left alone by the page, stops the load: the bit sent before it didn't count for it.
+  await pressInPage(app, path, 'Escape')
+  await expect.poll(async () => (await state(app)).tabs[id]?.loading).toBe(false)
+  expect(await escapes()).toEqual([{ url: fx.url(path), used: false, stopped: true }])
+})
+
 test('[KS-05][TB-12][TB-11] Rename Tab, Move Tab to Space… and Archive Tab have no keys until given some, then work from a page', async () => {
   const { app, shell } = orbit
   const spaceId = await activeSpace(app)
@@ -699,6 +1019,37 @@ test('[KS-05][TB-12][TB-11] Rename Tab, Move Tab to Space… and Archive Tab hav
   expect((await state(app)).archive.at(-1)?.url).toBe(fx.url('/page/Named'))
 })
 
+// ---------- Pointer bindings (KS-17): the rows no other test covered ----------
+
+test('[KS-17][NV-01][SB-03] ⌘-click or middle-click on Forward opens the next page in a new tab; the tab stays', async () => {
+  const { app, shell } = orbit
+  const id = await openTab(app, fx.url('/page/AheadA'))
+  await visit(app, id, fx.url('/page/AheadB'))
+  await action(app, 'nav.back')
+  await waitLoaded(app, id, fx.url('/page/AheadA'))
+  await expect.poll(async () => (await state(app)).tabs[id]?.canGoForward).toBe(true)
+  const others = async () => Object.keys((await state(app)).tabs).filter((t) => t !== id)
+  const forward = shell.getByTestId('nav-forward')
+  await forward.click({ modifiers: [NEW_TAB_CLICK] })
+  await expect.poll(async () => (await others()).length).toBe(1)
+  const [first] = await others()
+  await waitLoaded(app, first as string, fx.url('/page/AheadB'))
+  await forward.click({ button: 'middle' })
+  await expect.poll(async () => (await others()).length).toBe(2)
+  const second = (await others()).find((t) => t !== first)
+  await waitLoaded(app, second as string, fx.url('/page/AheadB'))
+  // The tab clicked from keeps its page and stays selected.
+  expect(await activeTab()).toBe(id)
+  expect(await urlOf(id)).toBe(fx.url('/page/AheadA'))
+})
+
+test('[KS-17][SB-08][CB-02] double-clicking the empty part of the sidebar opens the command bar for a new tab', async () => {
+  const { app, shell } = orbit
+  await shell.getByTestId('sidebar-empty-area').dblclick()
+  await expect.poll(async () => (await windowState(app)).overlay).toMatchObject({ kind: 'commandbar', mode: 'new-tab' })
+  await expect((await viewPage(app, 'overlay')).getByTestId('command-input')).toBeFocused()
+})
+
 // ---------- Settings → Shortcuts (ST-08) ----------
 
 /**
@@ -793,18 +1144,22 @@ test('[ST-08][KS-02][TB-04] right-click an action to prefer websites or Orbit an
   const page = await openSettings(app, { section: 'shortcuts' })
   const row = shortcutRow(page, 'sidebar.toggle')
   const menu = page.getByTestId('shortcut-menu')
-  await expect(row).toContainText('Websites first')
+  // Toggle Sidebar prefers websites on Windows and Linux, Orbit on macOS (D60).
+  const [byDefault, other] = isMac ? (['orbit', 'websites'] as const) : (['websites', 'orbit'] as const)
+  const websitesFirst = (on: boolean) =>
+    on ? expect(row).toContainText('Websites first') : expect(row).not.toContainText('Websites first')
+  await websitesFirst(byDefault === 'websites')
   await row.click({ button: 'right' })
-  await expect(menu.getByTestId('shortcut-menu-websites')).toHaveAttribute('aria-checked', 'true')
-  await menu.getByTestId('shortcut-menu-orbit').click()
-  await expect.poll(prioritiesOf).toEqual({ 'sidebar.toggle': 'orbit' })
-  await expect(row).not.toContainText('Websites first')
+  await expect(menu.getByTestId(`shortcut-menu-${byDefault}`)).toHaveAttribute('aria-checked', 'true')
+  await menu.getByTestId(`shortcut-menu-${other}`).click()
+  await expect.poll(prioritiesOf).toEqual({ 'sidebar.toggle': other })
+  await websitesFirst(other === 'websites')
   await row.click({ button: 'right' })
   await menu.getByTestId('shortcut-menu-reset').click()
   await expect.poll(keysOf).toBeUndefined()
   expect(await prioritiesOf()).toBeUndefined()
   await expect(row.getByTestId('shortcut-binding')).toHaveText([isMac ? '⌘S' : 'Ctrl+S'])
-  await expect(row).toContainText('Websites first')
+  await websitesFirst(byDefault === 'websites')
   // At its defaults there is nothing to reset; Esc closes the menu.
   await row.click({ button: 'right' })
   await expect(menu.getByTestId('shortcut-menu-reset')).toBeDisabled()
@@ -1012,10 +1367,16 @@ test('[KS-20][SB-25] in a private window the keys for pinning, Spaces and Clear
   // The hint shows in the private window.
   const sidebar = await uiPageOf(app, 'shell', priv.id)
   await expect(sidebar.getByTestId('toast').filter({ hasText: HINT }).first()).toBeVisible()
-  // The same from its menus and command bar.
+  // The same from its menus and command bar, the Archive's included.
   await actionIn(priv.id, 'space.new')
   await expect.poll(async () => (await hints())[HINT]).toBe(keys.length + 1)
+  await actionIn(priv.id, 'app.archive')
+  await expect.poll(async () => (await hints())[HINT]).toBe(keys.length + 2)
   expect(await where()).toEqual(before)
+  // Its sidebar has no Clear button next to Today: nothing there archives its tabs.
+  await expect(sidebar.getByTestId('today-divider')).toBeVisible()
+  await expect(sidebar.getByTestId('new-tab-button')).toBeVisible()
+  await expect(sidebar.getByTestId('clear-today')).toHaveCount(0)
   // Keys for its own tabs work: ⌘2 selects the second, the one opened first.
   expect((await state(app)).spaces[priv.spaceId]?.today).toEqual([second, first])
   await pressInPage(app, '/page/PrivTwo', '2', PRIMARY_MOD)
@@ -1067,8 +1428,18 @@ test('[KS-20][KS-10][OB-12] in a Mini Window keys act on its page: ⌘L edits it
   await expect.poll(focusedUrl).toContain('view=mini')
   expect(await typeAnywhere(['q'])).toEqual([expect.stringContaining('view=mini')])
   await expect(address).toHaveValue('q')
+  // Esc closes the field and gives the keyboard back to the page: what is typed next goes there.
   await ui.keyboard.press('Escape')
   await expect(address).toHaveCount(0)
+  await expect.poll(focusedUrl).toBe(fx.url(path))
+  expect(await typeAnywhere(['z'])).toEqual([fx.url(path)])
+  const inMini = await tabPage(app, path)
+  await expect.poll(() => inMini.evaluate(() => (window as unknown as { __keys: string[] }).__keys)).toContain('z')
+  // ⌘Y / Ctrl+H shows History in the browser window behind.
+  await pressInPage(app, path, isMac ? 'Y' : 'H', PRIMARY_MOD)
+  await expect.poll(() => cmdIn(app, main.id, 'library.status')).toMatchObject({ open: true, section: 'history' })
+  await cmdIn(app, main.id, 'library.close')
+  await expect.poll(() => cmdIn(app, main.id, 'library.status')).toMatchObject({ open: false })
   // Help → Keyboard Shortcuts asked with the Mini Window in front opens over the browser window.
   await actionIn(mini.id, 'help.shortcuts')
   await expect
diff --git a/tests/e2e/nav-support.ts b/tests/e2e/nav-support.ts
index 797d75f9..c111495a 100644
--- a/tests/e2e/nav-support.ts
+++ b/tests/e2e/nav-support.ts
@@ -64,9 +64,10 @@ const escapeHtml = (text: string) => text.replace(/[&<>"]/g, (c) => `&#${c.charC
  * again (#closepopup).
  * `background` is its CSS background; `text` goes in a paragraph (#text); `open` is a page it
  * opens in a pop-up as soon as it loads, without a click; `away` is the address of one more link
- * (#away).
+ * (#away); `wait` is the address of an image (#wait) the page waits for: a `/slow/` one keeps the
+ * page loading after its scripts have run.
  */
-function page(title: string, background = '#f2fbf5', text = '', open = '', away = ''): string {
+function page(title: string, background = '#f2fbf5', text = '', open = '', away = '', wait = ''): string {
   const name = encodeURIComponent(title)
   return `<!doctype html>
 <html><head><meta charset="utf-8"><title>${title}</title><link rel="icon" href="${ICON}">
@@ -80,6 +81,7 @@ ${away ? `<p><a id="away" href="${escapeHtml(away)}">Away</a></p>` : ''}
 <p><a id="download" href="/download/${name}.txt" target="_blank">Download</a>
 <button id="popup" onclick="window.__popup = window.open('/page/Popup-${name}', 'pop', 'width=420,height=360')">Pop-up</button>
 <button id="closepopup" onclick="window.__popup && window.__popup.close()">Close pop-up</button></p>
+${wait ? `<img id="wait" alt="" src="${escapeHtml(wait)}">` : ''}
 <div style="height:2000px"></div>
 <script>
 window.__keys = []
@@ -162,12 +164,13 @@ function tone(seconds: number): Buffer {
  * - `/slow-reload/<title>`: the page at once on the first request, then slowly (30 s) on reloads.
  * - `/page/<title>?open=<path>`: the page, opening `<path>` in a pop-up as it loads (no click).
  * - `/page/<title>?away=<url>`: the page with a link (#away) to `<url>`.
+ * - `/page/<title>?wait=<path>`: the page with an image from `<path>`, which it waits for.
  * - `/download/<name>`: a small text file sent as a download (Content-Disposition: attachment).
  * - `/cookies`: a page that sets two cookies for its host, `strict=1` (SameSite=Strict) and
  *   `lax=1` (SameSite=Lax).
  * - `/media/<title>`: a page with a video and a tone (see `mediaPage()`); `/tone.wav`: the tone.
  */
-export async function startNavFixtures(): Promise<NavFixtures> {
+export async function startNavFixtures(portBase = NAV_PORT_BASE, portLast = 3399): Promise<NavFixtures> {
   const hits = new Map<string, number>()
   const cacheControl = new Map<string, string | undefined>()
   const sentFrom = new Map<string, SentFrom[]>()
@@ -199,6 +202,7 @@ export async function startNavFixtures(): Promise<NavFixtures> {
           u.searchParams.get('text') ?? '',
           u.searchParams.get('open') ?? '',
           u.searchParams.get('away') ?? '',
+          u.searchParams.get('wait') ?? '',
         ),
       )
     }
@@ -253,12 +257,13 @@ export async function startNavFixtures(): Promise<NavFixtures> {
     sockets.add(socket)
     socket.on('close', () => sockets.delete(socket))
   })
-  // Everything the tests run stays within 3300–3399: the first free port from this suite's base.
-  const base = NAV_PORT_BASE + (Number(process.env.TEST_PARALLEL_INDEX ?? 0) % 10)
+  // Everything the tests run stays within 3300–3399 (or the range a suite asks for): the first free
+  // port from this suite's base.
+  const base = portBase + (Number(process.env.TEST_PARALLEL_INDEX ?? 0) % 10)
   await new Promise<void>((resolveListen, reject) => {
     let port = base
     server.on('error', (err: NodeJS.ErrnoException) => {
-      if (err.code === 'EADDRINUSE' && port < 3399) server.listen(++port, '127.0.0.1')
+      if (err.code === 'EADDRINUSE' && port < portLast) server.listen(++port, '127.0.0.1')
       else reject(err)
     })
     server.listen(port, '127.0.0.1', () => resolveListen())
diff --git a/tests/unit/keymap-defaults.test.ts b/tests/unit/keymap-defaults.test.ts
index c8ff81a4..02c325a0 100644
--- a/tests/unit/keymap-defaults.test.ts
+++ b/tests/unit/keymap-defaults.test.ts
@@ -42,7 +42,8 @@ const TABLE: [id: string, mac: string[], other: string[]][] = [
   ['tab.next', ['Cmd+Alt+Down', 'Cmd+Shift+]'], ['Ctrl+Alt+Down', 'Ctrl+PageDown']],
   ['tab.previous', ['Cmd+Alt+Up', 'Cmd+Shift+['], ['Ctrl+Alt+Up', 'Ctrl+PageUp']],
   ['tab.recent', ['Ctrl+Tab'], ['Ctrl+Tab']],
-  ['tab.recentBack', ['Ctrl+Shift+Tab', 'Ctrl+`'], ['Ctrl+Shift+Tab']],
+  // ⌃` steps back too, on every platform, but only while the switcher is up (D60): the router's.
+  ['tab.recentBack', ['Ctrl+Shift+Tab'], ['Ctrl+Shift+Tab']],
   // KS-07: ⌃1–9 on macOS, Alt+1–9 elsewhere (Ctrl+1–9 is tabs).
   ...[1, 2, 3, 4, 5, 6, 7, 8, 9].map((n): [string, string[], string[]] => [
     `space.goto.${n}`,
@@ -91,8 +92,11 @@ const TABLE: [id: string, mac: string[], other: string[]][] = [
   ['app.archive', [], []],
   ['app.settings', ['Cmd+,'], ['Ctrl+,']],
   ['settings.clearBrowsingData', ['Cmd+Shift+Backspace'], ['Ctrl+Shift+Delete']],
-  // KS-13
+  // KS-13 (View Source and hard reload are under KS-08; the device toolbar's ⇧⌘M / Ctrl+Shift+M
+  // is DevTools' own key, below; developer mode and the task manager aren't built)
   ['devtools.toggle', ['Cmd+Alt+I', 'F12'], ['Ctrl+Shift+I', 'F12']],
+  ['devtools.console', ['Cmd+Alt+J'], ['Ctrl+Shift+J']],
+  ['devtools.inspect', ['Cmd+Alt+C'], []],
   // KS-15: F1 opens help on Windows and Linux; macOS's ⌘? is the system's Help menu search.
   ['help.open', [], ['F1']],
 ]
@@ -109,6 +113,17 @@ describe('[KS-03] the default keymap follows the spec tables on each platform',
     expect(canonical(defaultShortcutsFor(action, 'win32'))).toEqual(canonical(other))
   })
 
+  it('[KS-13] leaves DevTools’ own keys to DevTools: no action has ⇧⌘M / Ctrl+Shift+M (device toolbar)', () => {
+    for (const [platform, accel] of [
+      ['darwin', 'Cmd+Shift+M'],
+      ['linux', 'Ctrl+Shift+M'],
+      ['win32', 'Ctrl+Shift+M'],
+    ] as const) {
+      const owner = ACTIONS.find((a) => defaultShortcutsFor(a, platform).some((k) => canonicalAccelerator(k) === accel))
+      expect(owner?.id, platform).toBeUndefined()
+    }
+  })
+
   it('binds each key once per platform, each a binding Orbit accepts', () => {
     for (const platform of ['darwin', 'linux', 'win32']) {
       const seen = new Map<string, string>()
diff --git a/tests/unit/keymap-menu.test.ts b/tests/unit/keymap-menu.test.ts
index fb4238a1..402f23b9 100644
--- a/tests/unit/keymap-menu.test.ts
+++ b/tests/unit/keymap-menu.test.ts
@@ -5,9 +5,26 @@ import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
  * The macOS menu bar as installMenu builds it, on any platform: Electron's Menu is replaced by one
  * that keeps the template, and the Archive's own items by stand-ins.
  */
-const menu = vi.hoisted(() => ({ template: [] as MenuItemConstructorOptions[] }))
+const menu = vi.hoisted(() => {
+  type Shown = { isDestroyed: () => boolean; isVisible: () => boolean; isMinimized: () => boolean }
+  const shown: Shown = { isDestroyed: () => false, isVisible: () => true, isMinimized: () => false }
+  return {
+    template: [] as MenuItemConstructorOptions[],
+    /** The windows Electron has; one shown unless a test says otherwise. */
+    shown,
+    windows: [shown] as Shown[],
+    /** Electron's `browser-window-created` listener, once one is added. */
+    created: undefined as ((event: unknown, win: unknown) => void) | undefined,
+  }
+})
 vi.mock('electron', () => ({
-  app: { name: 'Orbit' },
+  app: {
+    name: 'Orbit',
+    on: (event: string, listener: (event: unknown, win: unknown) => void) => {
+      if (event === 'browser-window-created') menu.created = listener
+    },
+  },
+  BrowserWindow: { getAllWindows: () => menu.windows },
   Menu: {
     buildFromTemplate: (template: MenuItemConstructorOptions[]) => {
       menu.template = template
@@ -21,7 +38,7 @@ vi.mock('../../src/main/archive/recently-closed', () => ({ recentlyClosedItems:
 vi.mock('../../src/main/keys/router', () => ({ keyRouter: { menuRuns: () => true } }))
 
 import type { MainContext } from '../../src/main/context'
-import { installMenu } from '../../src/main/menu'
+import { installMenu, watchWindowsForMenu } from '../../src/main/menu'
 import { ACTIONS_BY_ID, type ActionDef, isFixed } from '../../src/shared/actions'
 import { bindingProblem, setCustomBindings } from '../../src/shared/keymap'
 
@@ -32,6 +49,7 @@ beforeEach(() => Object.defineProperty(process, 'platform', { ...platform, value
 afterEach(() => {
   Object.defineProperty(process, 'platform', platform)
   setCustomBindings(undefined)
+  menu.windows = [menu.shown]
 })
 
 /** The menu built now: each top-level menu by its label or role. */
@@ -44,6 +62,12 @@ function build(): Record<string, MenuItemConstructorOptions[]> {
 
 const find = (items: MenuItemConstructorOptions[], label: string) => items.find((i) => i.label === label)
 
+/** The File menu of the menu last built, without building it again. */
+function fileMenu(): MenuItemConstructorOptions[] {
+  const file = menu.template.find((m) => m.label === 'File')
+  return Array.isArray(file?.submenu) ? file.submenu : []
+}
+
 describe('the macOS menu bar', () => {
   it('[KS-15] keeps the system’s keys: Hide, Hide Others and Quit, the Window menu (⌘M, ⌘`) and the Help menu (⌘? search)', () => {
     const menus = build()
@@ -101,6 +125,37 @@ describe('the macOS menu bar', () => {
     expect(own?.registerAccelerator).toBeUndefined()
   })
 
+  it('[KS-12] with no Orbit window shown, ⌘O is the menu’s own: Open File… takes it (F6)', () => {
+    menu.windows = []
+    const open = find(build().File ?? [], 'Open File…')
+    expect(open?.accelerator).toBe('Command+O')
+    expect(open?.registerAccelerator).toBeUndefined()
+    // A minimized or hidden window has no keys to give the router either.
+    menu.windows = [
+      { ...menu.shown, isMinimized: () => true },
+      { ...menu.shown, isVisible: () => false },
+    ]
+    expect(find(build().File ?? [], 'Open File…')?.registerAccelerator).toBeUndefined()
+    menu.windows = [menu.shown]
+    expect(find(build().File ?? [], 'Open File…')?.registerAccelerator).toBe(false)
+  })
+
+  it('[KS-12] builds the menu again when the last window goes and when one shows again', async () => {
+    build()
+    watchWindowsForMenu(ctx)
+    const listeners = new Map<string, () => void>()
+    menu.created?.({}, { on: (event: string, listener: () => void) => listeners.set(event, listener) })
+    const settled = () => new Promise((resolve) => setImmediate(resolve))
+    menu.windows = []
+    listeners.get('closed')?.()
+    await settled()
+    expect(find(fileMenu(), 'Open File…')?.registerAccelerator).toBeUndefined()
+    menu.windows = [menu.shown]
+    listeners.get('show')?.()
+    await settled()
+    expect(find(fileMenu(), 'Open File…')?.registerAccelerator).toBe(false)
+  })
+
   it('[OB-12][OB-13] Help → Keyboard Shortcuts comes after Orbit Help', () => {
     const help = build().help
     expect(help?.map((i) => i.label).slice(0, 3)).toEqual(['Orbit Help', 'Keyboard Shortcuts', 'Report a Bug…'])
diff --git a/tests/unit/keymap-remap.test.ts b/tests/unit/keymap-remap.test.ts
index b23fb2da..80c10e8c 100644
--- a/tests/unit/keymap-remap.test.ts
+++ b/tests/unit/keymap-remap.test.ts
@@ -1,4 +1,5 @@
 import { afterEach, describe, expect, it, vi } from 'vitest'
+import { frontendKeys } from '../../src/main/devtools/control'
 import {
   bind,
   MAX_BINDINGS,
@@ -16,10 +17,11 @@ import {
   actionForAccelerator,
   actionForInput,
   buildKeymap,
+  isFixed,
   priorityFor,
   shortcutsFor,
 } from '../../src/shared/actions'
-import { keymapVersion, onKeymapChange, setCustomBindings } from '../../src/shared/keymap'
+import { type KeyInput, keymapVersion, onKeymapChange, setCustomBindings } from '../../src/shared/keymap'
 import type { Settings } from '../../src/shared/state'
 
 const action = (id: string) => {
@@ -156,6 +158,26 @@ describe('[KS-01][ST-08] changing bindings', () => {
     expect(bind(undefined, { actionId: 'sidebar.toggle', accel: 'F7' }, 'linux').result).toEqual({ ok: true })
   })
 
+  it('[D60] macOS refuses a plain ⌃-letter binding: text fields move the caret with them', () => {
+    for (const accel of ['Ctrl+A', 'Ctrl+E', 'Ctrl+N', 'Ctrl+P', 'ctrl+k']) {
+      expect(bind(undefined, { actionId: 'sidebar.toggle', accel }, 'darwin').result, accel).toEqual({
+        ok: false,
+        problem: `⌃${accel.slice(-1).toUpperCase()} is kept for text fields: on macOS, ⌃ with a letter moves the caret.`,
+      })
+    }
+    // ⌃ with another modifier, a digit or an F key is a binding like any other (⌃7 is Space 7's, so
+    // it asks first); so is Ctrl+letter elsewhere.
+    for (const accel of ['Ctrl+Shift+N', 'Ctrl+Alt+N', 'Ctrl+Cmd+N', 'Ctrl+7', 'Ctrl+F7']) {
+      const { result } = bind(undefined, { actionId: 'sidebar.toggle', accel }, 'darwin')
+      expect('problem' in result ? result.problem : undefined, accel).toBeUndefined()
+    }
+    expect(bind(undefined, { actionId: 'sidebar.toggle', accel: 'Ctrl+K' }, 'linux').result).toEqual({ ok: true })
+    // One stored before is dropped when the settings load.
+    expect(normalizeShortcuts({ 'sidebar.toggle': ['Ctrl+N', 'Cmd+Shift+B'] }, 'darwin')).toEqual({
+      'sidebar.toggle': ['Cmd+Shift+B'],
+    })
+  })
+
   it('[KS-15] F1 stays Help on Windows and Linux; on macOS Help has no keys and can be given some', () => {
     for (const platform of ['linux', 'win32']) {
       expect(bind(undefined, { actionId: 'sidebar.toggle', accel: 'F1' }, platform).result).toEqual({
@@ -240,8 +262,10 @@ describe('[KS-01] stored bindings survive a restart only as Orbit can use them',
 
 describe('[KS-02] who gets an action’s keys first', () => {
   it('has defaults per action and platform', () => {
-    expect(priorityFor(action('sidebar.toggle'), 'darwin')).toBe('websites')
+    // ⌘S prefers Orbit on macOS, Ctrl+S websites on Windows and Linux (D60).
+    expect(priorityFor(action('sidebar.toggle'), 'darwin')).toBe('orbit')
     expect(priorityFor(action('sidebar.toggle'), 'linux')).toBe('websites')
+    expect(priorityFor(action('sidebar.toggle'), 'win32')).toBe('websites')
     expect(priorityFor(action('tab.copyUrl'), 'darwin')).toBe('orbit')
     expect(priorityFor(action('tab.copyUrl'), 'win32')).toBe('websites')
     expect(priorityFor(action('tab.new'), 'linux')).toBe('orbit')
@@ -266,3 +290,47 @@ describe('[KS-16] keys a page’s text field may use', () => {
     expect(priorityFor(action('nav.forward'), 'linux')).toBe('orbit')
   })
 })
+
+describe('[KS-13] the DevTools keys can be remapped', () => {
+  const press = (key: string, code: string, mods: Partial<KeyInput> = {}): KeyInput => ({
+    key,
+    code,
+    meta: false,
+    control: false,
+    alt: false,
+    shift: false,
+    ...mods,
+  })
+
+  it('open, console, element picker, view source and hard reload: none is fixed', () => {
+    for (const id of ['devtools.toggle', 'devtools.console', 'devtools.inspect', 'page.viewSource', 'nav.hardReload']) {
+      for (const platform of ['darwin', 'linux', 'win32'])
+        expect(isFixed(action(id), platform), `${id} ${platform}`).toBe(false)
+    }
+  })
+
+  it('a remapped open key moves in the router and in the DevTools page itself', () => {
+    const { custom, result } = bind(undefined, { actionId: 'devtools.toggle', accel: 'F9', replace: 'F12' }, 'linux')
+    expect(result).toEqual({ ok: true })
+    setCustomBindings(custom)
+    expect(actionForInput(press('F9', 'F9'), 'linux')?.id).toBe('devtools.toggle')
+    expect(actionForInput(press('F12', 'F12'), 'linux')).toBeUndefined()
+    expect(frontendKeys('linux').toggle.map((k) => k.key)).toEqual(['I', 'F9'])
+  })
+
+  it('the element picker can take ⇧⌘C from Copy URL, as DT-02 says users may', () => {
+    const { custom, result } = bind(
+      undefined,
+      { actionId: 'devtools.inspect', accel: 'Cmd+Shift+C', onConflict: 'clear' },
+      'darwin',
+    )
+    expect(result).toEqual({ ok: true })
+    expect(custom).toEqual({ 'devtools.inspect': ['Cmd+Alt+C', 'Cmd+Shift+C'], 'tab.copyUrl': [] })
+    setCustomBindings(custom)
+    expect(actionForInput(press('C', 'KeyC', { meta: true, shift: true }), 'darwin')?.id).toBe('devtools.inspect')
+    expect(frontendKeys('darwin').inspect).toEqual([
+      { cmd: true, ctrl: false, alt: true, shift: false, key: 'C' },
+      { cmd: true, ctrl: false, alt: false, shift: true, key: 'C' },
+    ])
+  })
+})
diff --git a/tests/unit/keymap-settings.test.ts b/tests/unit/keymap-settings.test.ts
index 82033b5e..a392a54b 100644
--- a/tests/unit/keymap-settings.test.ts
+++ b/tests/unit/keymap-settings.test.ts
@@ -34,6 +34,12 @@ describe('[ST-08] the list of shortcuts', () => {
     expect(entry('sidebar.toggle', 'darwin')).toMatchObject({
       title: 'Toggle Sidebar',
       bindings: ['Cmd+S'],
+      // ⌘S prefers Orbit on macOS (D60); Ctrl+S websites elsewhere.
+      priority: 'orbit',
+      isDefault: true,
+    })
+    expect(entry('sidebar.toggle', 'linux')).toMatchObject({
+      bindings: ['Ctrl+S'],
       priority: 'websites',
       isDefault: true,
     })
diff --git a/tests/unit/keymap-special-windows.test.ts b/tests/unit/keymap-special-windows.test.ts
index 70e80a07..87df2324 100644
--- a/tests/unit/keymap-special-windows.test.ts
+++ b/tests/unit/keymap-special-windows.test.ts
@@ -22,6 +22,8 @@ describe('[KS-20] keys in a private window', () => {
     for (const id of ['tab.goto.1', 'tab.next', 'tab.close', 'tab.new', 'nav.reload', 'sidebar.toggle', 'page.find']) {
       expect(needsSpaces(id), id).toBe(false)
     }
+    // Nor has it an Archive (SB-25): View Archive says so too.
+    expect(needsSpaces('app.archive')).toBe(true)
   })
 
   it('they do nothing there and say so; elsewhere they run', async () => {
diff --git a/tests/unit/keys-escape.test.ts b/tests/unit/keys-escape.test.ts
new file mode 100644
index 00000000..b93fb919
--- /dev/null
+++ b/tests/unit/keys-escape.test.ts
@@ -0,0 +1,159 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+
+type Listener = (event: unknown, ...args: unknown[]) => void
+const ipc = vi.hoisted(() => ({ listeners: new Map<string, Listener>() }))
+vi.mock('electron', () => ({
+  ipcMain: {
+    on: (channel: string, listener: Listener) => {
+      ipc.listeners.set(channel, listener)
+    },
+  },
+}))
+
+import type { WebContents } from 'electron'
+import { ESCAPE_WAIT_MS, escapeLog, escapeThenStop, listenForEscapes } from '../../src/main/keys/escape'
+import { PAGE_CHANNEL } from '../../src/shared/site'
+
+const tabs = new Set<WebContents>()
+listenForEscapes((contents) => tabs.has(contents))
+
+/** A tab's web contents, as far as the Esc answer reads it. */
+function page(url: string, tab = true) {
+  const mainFrame = { frameTreeNodeId: 1 }
+  const contents = { isDestroyed: () => false, getURL: () => url, mainFrame } as unknown as WebContents
+  if (tab) tabs.add(contents)
+  return { contents, mainFrame, child: { frameTreeNodeId: 2 } }
+}
+
+/** What a page's preload sends after an Esc: the bit, from the frame it runs in. */
+function answer(contents: WebContents, frame: unknown, used: unknown): void {
+  ipc.listeners.get(PAGE_CHANNEL.escape)?.({ sender: contents, senderFrame: frame }, used)
+}
+
+beforeEach(() => {
+  vi.useFakeTimers()
+})
+
+afterEach(() => {
+  vi.runOnlyPendingTimers()
+  vi.useRealTimers()
+  tabs.clear()
+})
+
+describe('[KS-19][NV-04] Esc on a loading page: the page first, then Stop (D59)', () => {
+  it('listens on the preload’s own channel', () => {
+    expect(PAGE_CHANNEL.escape).toBe('orbit-page:escape')
+    expect(ipc.listeners.has(PAGE_CHANNEL.escape)).toBe(true)
+  })
+
+  it('the page used Esc: the load goes on', () => {
+    const { contents, mainFrame } = page('https://a.test/used')
+    const stop = vi.fn()
+    escapeThenStop(contents, () => true, stop)
+    answer(contents, mainFrame, true)
+    vi.advanceTimersByTime(ESCAPE_WAIT_MS)
+    expect(stop).not.toHaveBeenCalled()
+    expect(escapeLog().at(-1)).toEqual({ url: 'https://a.test/used', used: true, stopped: false })
+  })
+
+  it('the page left Esc alone: Orbit stops the load at once', () => {
+    const { contents, mainFrame } = page('https://a.test/left')
+    const stop = vi.fn()
+    escapeThenStop(contents, () => true, stop)
+    answer(contents, mainFrame, false)
+    expect(stop).toHaveBeenCalledTimes(1)
+    vi.advanceTimersByTime(ESCAPE_WAIT_MS)
+    expect(stop).toHaveBeenCalledTimes(1)
+    expect(escapeLog().at(-1)).toEqual({ url: 'https://a.test/left', used: false, stopped: true })
+  })
+
+  it('no answer within 250 ms counts as left alone (D60)', () => {
+    expect(ESCAPE_WAIT_MS).toBe(250)
+    const { contents } = page('https://a.test/silent')
+    const stop = vi.fn()
+    escapeThenStop(contents, () => true, stop)
+    vi.advanceTimersByTime(ESCAPE_WAIT_MS - 1)
+    expect(stop).not.toHaveBeenCalled()
+    vi.advanceTimersByTime(1)
+    expect(stop).toHaveBeenCalledTimes(1)
+    // A late answer changes nothing.
+    answer(contents, contents.mainFrame, true)
+    expect(escapeLog().at(-1)).toEqual({ url: 'https://a.test/silent', used: false, stopped: true })
+  })
+
+  it('a bit sent with no Esc pressed does nothing, and doesn’t count for the next press', () => {
+    const { contents, mainFrame } = page('https://a.test/stray')
+    const before = escapeLog().length
+    answer(contents, mainFrame, true)
+    expect(escapeLog()).toHaveLength(before)
+    const stop = vi.fn()
+    escapeThenStop(contents, () => true, stop)
+    vi.advanceTimersByTime(ESCAPE_WAIT_MS)
+    expect(stop).toHaveBeenCalledTimes(1)
+  })
+
+  it('only the main frame of a tab’s page answers (D40)', () => {
+    const { contents, child } = page('https://a.test/frames')
+    const stop = vi.fn()
+    escapeThenStop(contents, () => true, stop)
+    answer(contents, child, true)
+    answer(contents, null, true)
+    expect(stop).not.toHaveBeenCalled()
+    vi.advanceTimersByTime(ESCAPE_WAIT_MS)
+    expect(stop).toHaveBeenCalledTimes(1)
+    // Web contents that aren't a tab's are never asked, and can't answer for one.
+    const other = page('https://b.test/', false)
+    answer(other.contents, other.mainFrame, true)
+    expect(escapeLog().at(-1)?.url).toBe('https://a.test/frames')
+  })
+
+  it('an answer that isn’t one bit is no answer', () => {
+    const { contents, mainFrame } = page('https://a.test/odd')
+    const stop = vi.fn()
+    escapeThenStop(contents, () => true, stop)
+    for (const odd of ['true', 1, {}, undefined]) answer(contents, mainFrame, odd)
+    expect(stop).not.toHaveBeenCalled()
+    answer(contents, mainFrame, true)
+    vi.advanceTimersByTime(ESCAPE_WAIT_MS)
+    expect(stop).not.toHaveBeenCalled()
+  })
+
+  it('two presses: each answer goes to the oldest press still waiting', () => {
+    const { contents, mainFrame } = page('https://a.test/twice')
+    const stop = vi.fn()
+    escapeThenStop(contents, () => true, stop)
+    escapeThenStop(contents, () => true, stop)
+    answer(contents, mainFrame, true)
+    expect(stop).not.toHaveBeenCalled()
+    answer(contents, mainFrame, false)
+    expect(stop).toHaveBeenCalledTimes(1)
+    expect(escapeLog().slice(-2)).toEqual([
+      { url: 'https://a.test/twice', used: true, stopped: false },
+      { url: 'https://a.test/twice', used: false, stopped: true },
+    ])
+  })
+
+  it('a load that ended while Orbit waited is not stopped', () => {
+    const { contents, mainFrame } = page('https://a.test/done')
+    const stop = vi.fn()
+    let loading = true
+    escapeThenStop(contents, () => loading, stop)
+    loading = false
+    answer(contents, mainFrame, false)
+    expect(stop).not.toHaveBeenCalled()
+    expect(escapeLog().at(-1)).toEqual({ url: 'https://a.test/done', used: false, stopped: false })
+  })
+
+  it('keeps only the last few records', () => {
+    const { contents, mainFrame } = page('https://a.test/many')
+    for (let i = 0; i < 30; i++) {
+      escapeThenStop(
+        contents,
+        () => true,
+        () => {},
+      )
+      answer(contents, mainFrame, false)
+    }
+    expect(escapeLog().length).toBeLessThanOrEqual(10)
+  })
+})

From d7425221591a6d5deb4227be0f46b2687d826289 Mon Sep 17 00:00:00 2001
From: Siya <57148521+siyabendoezdemir@users.noreply.github.com>
Date: Sat, 10 Oct 2026 20:22:26 +0000
Subject: [PATCH 11/11] docs(keys): the keys section in ARCHITECTURE (F9);
 KS-02, KS-06, KS-12, KS-13, KS-16, KS-17, KS-19, KS-20, SB-11, TB-05, ST-08
 and NV-04 notes; regenerate FEATURES.md

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 FEATURES.md              | 34 +++++++++++++++++-----------------
 docs/ARCHITECTURE.md     | 23 +++++++++++++++++++++++
 docs/feature-status.json | 22 ++++++++++++----------
 3 files changed, 52 insertions(+), 27 deletions(-)

diff --git a/FEATURES.md b/FEATURES.md
index 7c20d863..b163fb6a 100644
--- a/FEATURES.md
+++ b/FEATURES.md
@@ -4,12 +4,12 @@
 
 Every row is one behaviour from the clean-room spec. Status per ID: **spec’d** (every row) → **built** → **tested** (a unit or e2e test names the ID) → **feels right** (lead sign-off after a hands-on review against `feel.md`).
 
-**Totals:** 472 spec’d · 228 built (79 partial) · 314 tested · 0 feel right. 13 more are out of scope and not counted.
+**Totals:** 472 spec’d · 228 built (81 partial) · 316 tested · 0 feel right. 13 more are out of scope and not counted.
 
 | Priority | Spec’d | Built | Tested |
 |---|---|---|---|
-| P0 | 174 | 140 | 167 |
-| P1 | 219 | 76 | 133 |
+| P0 | 174 | 140 | 168 |
+| P1 | 219 | 76 | 134 |
 | P2 | 79 | 12 | 14 |
 
 P0 = milestone-1 core experience, P1 = parity, P2 = later.
@@ -27,10 +27,10 @@ Spec: `spec/sidebar.md`
 | SB-05 | Favorites grid placement | P0 | ✅ | ✅ e2e | – | Favorites between the address and the title row, outside the scrolling list; same grid, same place across Spaces of one profile |
 | SB-06 | Space title row placement | P0 | ✅ | ✅ e2e | – | title row: inline rename, hover profile badge and … menu (pinned caret is PN-09) |
 | SB-07 | "+ New Tab" row | P0 | ✅ | ✅ e2e | – | + New Tab row with press animation opens the command bar |
-| SB-08 | Empty sidebar area: double-click, drag, right-click | P1 | – | – | – |  |
+| SB-08 | Empty sidebar area: double-click, drag, right-click | P1 | – | ✅ e2e | – |  |
 | SB-09 | Bottom bar: Library, Space switcher, "+" menu | P0 | ✅ | ✅ e2e | – | the Library button (a click opens the Library; a 300 ms hover shows the recent files, downloads and screenshots, which open on a click and drag out as the file; right-click chooses Downloads or Screenshots), the Space switcher and the + menu; the Library and + buttons are 28×28. New Note and New Canvas join the + menu with the notes and canvases lanes |
 | SB-10 | Transient trays above the bottom bar | P1 | 🟡 partial | ✅ e2e | – | media tray and call controls (media lane), above the bottom bar, pushing the list up; download progress and the update banner belong to other lanes |
-| SB-11 | Show / hide the sidebar | P0 | ✅ | ✅ e2e | – | Cmd+S / Ctrl+S, toggle button, View menu and command bar; the sidebar slides out as the card widens (one curve, reversible mid-way); the page views, which can't move in step, keep out of its way while it slides (where they end as it shows, where they were as it hides; the page colour fills the rest); back at the same width, scroll and selected tab; per window, persisted; new windows show it; a page that uses Cmd+S / Ctrl+S itself gets the first press, and a second press within a second or the toast's button toggles the sidebar (KS-02) |
+| SB-11 | Show / hide the sidebar | P0 | ✅ | ✅ e2e | – | Cmd+S / Ctrl+S, toggle button, View menu and command bar; the sidebar slides out as the card widens (one curve, reversible mid-way); the page views, which can't move in step, keep out of its way while it slides (where they end as it shows, where they were as it hides; the page colour fills the rest); back at the same width, scroll and selected tab; per window, persisted; new windows show it; on Windows and Linux a page that uses Ctrl+S itself gets the first press, and a second press within a second or the toast's button toggles the sidebar; on macOS ⌘S toggles at once, as every action there prefers Orbit (D60; Settings → Shortcuts can change either, KS-02) |
 | SB-12 | Hover to reveal the hidden sidebar | P0 | ✅ | ✅ e2e | – | left 6 px edge brings a floating card in its own view over the page, which never moves; main decides whether the pointer moved (not from where it was when the sidebar hid, so Cmd+S at the edge doesn't) and reads it for 300 ms after it leaves a page or the shell, so a flick to the edge (or onto the Linux resize border) brings the card; 0 ms dwell; stays while hovered (16 px band), while a field in it is edited, the command bar is open or a native menu is up in the window (one Chromium refuses counts as closed); goes 400 ms after the pointer moves on, at once on a click into the page (the click reaches the page); not over full-screen video; stays out while the pointer is on another window over it, until it comes back (review A-F1) |
 | SB-13 | Feedback when things happen while the sidebar is hidden | P1 | – | – | – |  |
 | SB-14 | Resize the sidebar width | P0 | ✅ | ✅ e2e | – | drag the edge 1:1 with a live width, clamped 180-420 with no drift; double-click resets to 248; 40 px past the minimum hides (width kept); saved per window |
@@ -44,7 +44,7 @@ Spec: `spec/sidebar.md`
 | SB-22 | Keyboard focus and navigation inside the sidebar | P2 | ✅ | ✅ e2e | – | Cmd/Ctrl+Shift+E focuses the sidebar; arrows, Enter, Escape, F2 |
 | SB-23 | Scrolling, auto-reveal of the active tab and overflow indicator | P1 | ✅ | ✅ e2e | – | selected tab scrolled into view (smooth, then settles); pill points to it while it is out of view; rows use content-visibility |
 | SB-24 | Sidebar colouring follows the Space theme | P0 | 🟡 partial | ✅ e2e+unit | – | theme gradient + grain on sidebar and frame, tinted selection; the neutral theme is a solid soft grey/near-black, not a translucent material yet |
-| SB-25 | Incognito window sidebar | P1 | ✅ | ✅ e2e | – | private window sidebar: top bar and address, a Private label with icon and a plain note, then only its own tabs; no Spaces, Favorites or pinned tabs (and their actions do nothing); + and Cmd/Ctrl+T open the command bar, which a new private window starts with |
+| SB-25 | Incognito window sidebar | P1 | ✅ | ✅ e2e+unit | – | private window sidebar: top bar and address, a Private label with icon and a plain note, then only its own tabs; no Spaces, Favorites or pinned tabs (and their actions do nothing); + and Cmd/Ctrl+T open the command bar, which a new private window starts with |
 | SB-26 | Platform notes (Windows / Linux) | P2 | – | – | – |  |
 | SB-27 | Link status pill | P1 | ✅ | ✅ e2e+unit | – | hovering (or focusing) a link shows a theme-styled pill with where it goes (no scheme) at the bottom-left of that page card, in its own small view; the full URL after 1.5 s on the link, kept for the next links while it stays up; moves to the other corner when the pointer comes within 24 px, out of the way if near both; goes 120 ms after the link is left; not on Peek pages |
 | SB-28 | Page loading indicator | P1 | ✅ | ✅ e2e | – | loading indicator at the top centre of the shown page card (the focused pane; Mini Windows too), in its own view over the page, after 150 ms; it leaves the window when hidden; shows in native full screen, not over a page in HTML full screen (back when that ends if still loading); tab rows keep their favicon loading ring |
@@ -59,7 +59,7 @@ Spec: `spec/tabs.md`
 | TB-02 | Create a new tab | P0 | ✅ | ✅ e2e | – | Cmd+T / + New Tab / link drop (a local file address dropped opens nothing, D49) / Cmd+Alt+V paste; background link tabs gesture-gated |
 | TB-03 | Where new tabs are inserted | P0 | ✅ | ✅ e2e+unit | – | single rule todayInsertIndex(): top of Today |
 | TB-04 | Switching between tabs (pointer and keyboard) | P0 | ✅ | ✅ e2e+unit | – | click, Cmd+1-9 (Favorites setting, Cmd+9 last), Cmd+Alt+Up/Down skip collapsed rows |
-| TB-05 | Recent-tab switcher (Ctrl+Tab) | P1 | 🟡 partial | ✅ e2e | – | Ctrl+Tab / Ctrl+Shift+Tab step through the 5 most recent tabs while Ctrl is held (keyboard only); W with Ctrl held closes the highlighted tab (keys lane, KS-06); no overlay list yet |
+| TB-05 | Recent-tab switcher (Ctrl+Tab) | P1 | 🟡 partial | ✅ e2e | – | Ctrl+Tab / Ctrl+Shift+Tab step through the 5 most recent tabs while Ctrl is held (keyboard only); Ctrl+` steps back too, on every platform, while the switcher is up (D60); W with Ctrl held closes the highlighted tab (keys lane, KS-06); no overlay list yet |
 | TB-06 | Closing a tab | P0 | ✅ | ✅ e2e+unit | – | Today -> Archive, pinned/Favorites unload; next selection below/above/MRU; middle-click; Cmd+W closes window when empty |
 | TB-07 | Reopen the last closed tab | P0 | ✅ | ✅ e2e | – | Cmd+Shift+T stack with full history; Cmd+Z reopens too |
 | TB-08 | Reorder tabs by drag and drop | P0 | ✅ | ✅ e2e+unit | – | pointer drag, 4px threshold, rows spring apart, ghost lift/settle, auto-scroll, Escape cancel, undo; no haptics |
@@ -231,7 +231,7 @@ Spec: `spec/navigation.md`
 | NV-01 | Back and forward | P0 | ✅ | ✅ e2e+unit | – | buttons and keys (Cmd+Left/Right only outside text fields), history menu with favicons that closes on tab switch, Cmd/middle-click opens the entry in a background tab with its history; mouse side buttons are Chromium's; Backspace inert |
 | NV-02 | Trackpad two-finger swipe back/forward | P1 | – | – | – |  |
 | NV-03 | Reload and hard reload | P0 | ✅ | ✅ e2e+unit | – | Cmd/Ctrl+R, F5; hard reload Cmd+Shift+R, Ctrl+Shift+R, Shift+F5, Ctrl+F5; Cmd/middle-click Reload duplicates with history; keyboard focus goes to the page |
-| NV-04 | Stop loading | P1 | ✅ | ✅ e2e+unit | – | Esc in the page while loading (overlays take it first), Cmd+. on macOS, double-click Reload, Stop (x) state; a typed address, Back/Forward or Reload shows where it is going at once and stays when stopped; the loading indicator goes |
+| NV-04 | Stop loading | P1 | ✅ | ✅ e2e+unit | – | Esc in the page while loading (overlays take it first; a page that uses Esc keeps it and goes on loading, D59), Cmd+. on macOS, double-click Reload, Stop (x) state; a typed address, Back/Forward or Reload shows where it is going at once and stays when stopped; the loading indicator goes |
 | NV-05 | Find in page | P0 | ✅ | ✅ e2e+unit | – | floating bar over the active page's top-right corner; finds as you type, n/m count, No matches; Enter/Cmd+G/F3 next, Shift+Enter/Shift+Cmd+G/Shift+F3 previous, buttons; Esc closes and keeps the match selected; per tab (hidden on switch, back with text and place); starts from the selection, else the last search; IME commits; keys typed for the bar before it has the keyboard (a new window's first moments, a busy bar) wait up to 5 s and then go into it in order, text as text (any character); it takes the keyboard when it shows, even later than that; shortcuts and IME composition are not held; Cmd+J jumps to the selection (macOS); Edit > Find menu; does nothing while a Peek is open, so the keyboard stays in it (finding in a Peek is PK-11) |
 | NV-06 | Page zoom | P0 | ✅ | ✅ e2e+unit | – | Chromium steps 25-500% on Cmd+=/Cmd+-/Cmd+0 and Ctrl+wheel (Win/Linux), in a Peek (with a toast) and a Mini Window (no indicator there) too; per host in each profile (all its tabs), remembered across launches (written on quit), dropped with a deleted profile; indicator with Reset over the page for 1.5 s (longer while hovered); pinch is visual zoom and Cmd+0 undoes it too |
 | NV-07 | Print | P1 | – | – | – |  |
@@ -347,25 +347,25 @@ Spec: `spec/shortcuts.md`
 | ID | Feature | P | Built | Tested | Feels right | Notes |
 |---|---|---|---|---|---|---|
 | KS-01 | One keymap, remapping and persistence | P0 | ✅ | ✅ e2e+unit | – | one keymap keyed by action id (src/shared/actions.ts + src/shared/keymap.ts): the key router, macOS menu bar (rebuilt on a remap), tooltips and command-bar rows read the live bindings; remap, several bindings per action (up to 5), none (command bar and menus still run it), a modifier required except F1-F12, system keys refused, conflicts reported (clear or swap), reset; stored per device in settings.shortcuts, cleaned on load, kept across a restart (Space keys too); Settings → Shortcuts (ST-08) lists every action with a search, records new keys on a click and resets on right-click; Help → Keyboard Shortcuts (OB-12) shows the essential keys as they are now |
-| KS-02 | Conflicts with web pages ("prefer websites" vs "prefer Orbit") | P0 | 🟡 partial | ✅ e2e+unit | – | who gets a key first, per action: Toggle Sidebar (Cmd+S / Ctrl+S, SB-11) prefers websites on every platform, Copy URL (Ctrl+Shift+C, NV-17) on Windows/Linux, every other action prefers Orbit (the page never sees the key); with prefer websites the page's main frame gets the first press: left alone, the action runs; used (preventDefault), a toast offers the action and a second press within a second runs it; a held key's repeats stay the page's; a press into a frame Orbit can't see into counts as used; while a page's main frame loads, Orbit takes the keys at once (Electron runs no isolated-world script in a loading page, so the page can't say in time what it did); Settings → Shortcuts sets it per action (right-click → Prefer Websites / Prefer Orbit; a “Websites first” tag on the row); Esc leaving page full screen keeps Chromium's rule and nothing holds Cmd+E yet |
+| KS-02 | Conflicts with web pages ("prefer websites" vs "prefer Orbit") | P0 | 🟡 partial | ✅ e2e+unit | – | who gets a key first, per action: on Windows and Linux Toggle Sidebar (Ctrl+S, SB-11) and Copy URL (Ctrl+Shift+C, NV-17) prefer websites; every other action, and on macOS every action, ⌘S included (D60), prefers Orbit (the page never sees the key); with prefer websites the page gets the first press: left alone, the action runs; used (preventDefault), a toast offers the action and a second press within a second runs it; a held key's repeats stay the page's; with the keyboard in a frame, that frame says what it did; no answer within 250 ms counts as left alone (D60), so a busy page holds a key a quarter of a second at most; while a page's main frame loads, Orbit takes the keys at once (Electron runs no isolated-world script in a loading page); Settings → Shortcuts sets it per action (right-click → Prefer Websites / Prefer Orbit; a “Websites first” tag on the row); Esc leaving page full screen keeps Chromium's rule and nothing holds Cmd+E yet |
 | KS-03 | Platform mapping rules | P0 | 🟡 partial | ✅ e2e+unit | – | every default checked against the spec tables on macOS, Windows and Linux (unit test): ⌘ → Ctrl, ⌥ → Alt, ⌃ keys (⌃Tab, the split keys) stay Ctrl; the Windows/Linux exceptions Alt+1–9 for Spaces, Ctrl+H, Alt+←/→, Alt+D, F5, F3, Ctrl+F4 and F1; Alt+F4 and Alt+F are kept for the system; a Ctrl+Alt key that typed an AltGr character acts only outside text fields; letters and symbols follow the layout; F11 / Alt+Shift+F come with full screen (KS-08); keys the system keeps (macOS Mission Control “Switch to Desktop N” ⌃1–⌃9 when turned on, GNOME’s workspace keys) are marked in Settings → Shortcuts, which says where to turn them off; no first-run suggestion |
 | KS-04 | Command bar and address | P0 | ✅ | ✅ e2e+unit | – | ⌘T/⌘L/Alt+D, Esc, ⌘T/⌘L again, ↑/↓ (⌃N/⌃P), Enter, Tab, ⌫, ⇧Enter (option), ⌘⌥⌫ / Shift+Delete, ⌘⌥V |
 | KS-05 | Tabs and windows | P0 | 🟡 partial | ✅ e2e+unit | – | ⌘N, ⌘⇧N, ⌘⌥N, ⌘W / Ctrl+W / Ctrl+F4, ⌘⇧W / Ctrl+Shift+W (closes the window, or the Mini Window, Settings or onboarding window that has focus; Alt+F4 is the system's), ⌘⇧T (a closed tab comes back in its place), ⌘D (pins; again, back to the top of Today), ⌘⇧C, ⌘⇧⌥C, ⌘S, ⌘⇧K, ⌘⇧E, F6 (keyboard between the sidebar and the page), tested from a page; Duplicate Tab, Reset Tab, Rename Tab (shows a hidden sidebar to edit the name), Archive Tab, Move Tab to Space… (the command bar on its Move to rows) and Favorite This Tab have no keys until the user gives them some; ⌘Z (sidebar undo) is not remappable yet; the blank window (⌃⌘N, TB-17) and the top toolbar (⌘⇧D, SB-17) are not built |
-| KS-06 | Switching tabs | P0 | ✅ | ✅ e2e+unit | – | ⌘1–⌘8 / Ctrl+1–8 (Favorites counted first unless turned off), ⌘9 / Ctrl+9 the last item or, set so, the ninth, ⌘⌥↓/↑ / Ctrl+Alt+↓/↑ and the ⌘⇧] / ⌘⇧[ (Ctrl+PgDn / Ctrl+PgUp) aliases, all tested from a page; while ⌃ is held, Tab and ⇧Tab (⌃` on macOS) step through recent tabs, W closes the highlighted tab (the next one in the switcher takes its place) and letting go settles; the switcher has no on-screen list yet (TB-05) |
+| KS-06 | Switching tabs | P0 | ✅ | ✅ e2e+unit | – | ⌘1–⌘8 / Ctrl+1–8 (Favorites counted first unless turned off), ⌘9 / Ctrl+9 the last item or, set so, the ninth, ⌘⌥↓/↑ / Ctrl+Alt+↓/↑ and the ⌘⇧] / ⌘⇧[ (Ctrl+PgDn / Ctrl+PgUp) aliases, all tested from a page; while ⌃ is held, Tab and ⇧Tab step through recent tabs and ` steps back too, on every platform and only while the switcher is up (D60), W closes the highlighted tab (the next one in the switcher takes its place) and letting go settles; the switcher has no on-screen list yet (TB-05) |
 | KS-07 | Spaces | P0 | ✅ | ✅ e2e+unit | – | Space shortcuts wired through the action table |
 | KS-08 | Page navigation and page tools | P0 | 🟡 partial | ✅ e2e+unit | – | Back, Forward, Reload, hard reload, Stop, find (Cmd+F, Cmd+G, Shift+Cmd+G, F3, Ctrl+G), Cmd+J and zoom keys done; print, save page, reader mode and the rest come with their NV items |
 | KS-09 | Split view | P0 | ✅ | ✅ e2e+unit | – | ⌃⇧= adds a pane the command bar fills, ⌃⇧− closes the focused pane, ⌃⇧1–4 focus a pane, ⌃⇧] / ⌃⇧[ the next / previous pane (Ctrl+Shift on Windows/Linux), ⌘L / Ctrl+L changes the focused pane's address (SV-15), Add Right/Left/Above/Below Split from the command bar; tested from a page |
 | KS-10 | Peek and Mini Window | P1 | ✅ | ✅ e2e+unit | – | ⌘O / Ctrl+O expands a Peek into a selected Today tab (PK-07); Esc and ⌘W / Ctrl+W close it (PK-09, Esc fixed); ⌘⇧T and ⌘Z reopen it (PK-10); ⌘⌥N / Ctrl+Alt+N opens a Mini Window (MW-06); in a Mini Window ⌘O moves its page into the most recent Space (MW-05), ⌘⌥O (also ⌘⇧O) / Ctrl+Alt+O offers the Spaces, ⌘W closes it (MW-09). All from the one keymap and remappable but Esc; the tests press the keys (peek, mini-window and keys specs) |
 | KS-11 | Media | P1 | 🟡 partial | ✅ e2e+unit | – | Space and arrows in the focused player, Cmd/Ctrl+scroll and pinch zoom (tested), hardware media keys via Chromium (untested), Mute Tab action assignable; the calendar meeting shortcut (P2) belongs to TB-21/FV-09 |
-| KS-12 | Library, history, downloads, settings, extensions, help | P1 | 🟡 partial | ✅ e2e+unit | – | ⌘Y / Ctrl+H View History (AR-10); ⌘⇧L Open Library on macOS, the command bar elsewhere; View Archive with no key, assignable; ⌘, / Ctrl+, Settings, which cannot be remapped, and again brings the same Settings window to the front; ⌘⇧⌫ / Ctrl+Shift+Delete Clear Browsing Data…; Shortcut Settings (command bar, assignable); the shortcut sheet from Help → Keyboard Shortcuts (macOS) and the command bar (OB-12); Open File… (macOS File menu, the command bar) and ⌘O / Ctrl+O wherever no Peek or Mini Window is open: the files chosen open in new tabs, the last one selected (Settings → Shortcuts says so under Open File…, which can also get keys of its own); Alt+F stays free for the Windows/Linux app menu (SB-03, SB-26, not built). Not built: Open Downloads (DL-14, downloads lane), pinned extensions (EX-06) |
-| KS-13 | Developer tools | P1 | – | ✅ e2e+unit | – |  |
+| KS-12 | Library, history, downloads, settings, extensions, help | P1 | 🟡 partial | ✅ e2e+unit | – | ⌘Y / Ctrl+H View History (AR-10); ⌘⇧L Open Library on macOS, the command bar elsewhere; View Archive with no key, assignable; ⌘, / Ctrl+, Settings, which cannot be remapped, and again brings the same Settings window to the front; ⌘⇧⌫ / Ctrl+Shift+Delete Clear Browsing Data…; Shortcut Settings (command bar, assignable); the shortcut sheet from Help → Keyboard Shortcuts (macOS) and the command bar (OB-12); Open File… (macOS File menu, the command bar) and ⌘O / Ctrl+O wherever no Peek or Mini Window is open: the files chosen open in new tabs, the last one selected (Settings → Shortcuts says so under Open File…, which can also get keys of its own); with no Orbit window shown, the macOS menu bar takes ⌘O itself, so Open File… still opens (F6); Alt+F stays free for the Windows/Linux app menu (SB-03, SB-26, not built). Not built: Open Downloads (DL-14, downloads lane), pinned extensions (EX-06) |
+| KS-13 | Developer tools | P1 | 🟡 partial | ✅ e2e+unit | – | ⌥⌘I / F12 (Ctrl+Shift+I / F12) open or close DevTools (DT-01, F12 in e2e), ⌥⌘J (Ctrl+Shift+J) the console, ⌥⌘C the element picker (no default on Windows/Linux, where Ctrl+Shift+C is Copy URL), ⌥⌘U (Ctrl+U) View Source, ⌘⇧R (Ctrl+Shift+R) hard reload: each checked against the spec table per platform, and none fixed; a remapped DevTools key moves in the router and in DevTools' own page, and the picker can take ⇧⌘C from Copy URL (unit tests); ⇧⌘M / Ctrl+Shift+M stays DevTools' device toolbar key (no action has it). A remap reaches DevTools already open only once they open again (devtools lane). Not built: developer mode for a site (DT-06; its ⌃D is a plain ⌃-letter, which macOS keeps for the caret, D60) and the task manager (DT-11, Shift+Esc) |
 | KS-14 | Canvases, notes, capture and Tweaks | P2 | – | – | – |  |
 | KS-15 | Standard app and window keys | P1 | ✅ | ✅ e2e+unit | – | macOS: the menu bar keeps the system’s items and keys: Hide Orbit ⌘H, Hide Others ⌥⌘H and Quit ⌘Q in the Orbit menu, the Window menu (Minimize ⌘M, ⌘` between Orbit windows) and the Help menu with its search (⌘?). No action can take these keys, nor Alt+F4, Alt+Tab or Alt+F on Windows and Linux, and Settings → Shortcuts says what keeps them (KS-03). Windows and Linux: Alt+F4 closes the window and, on the last one, quits; F1 opens Help (OB-13) and can’t be changed there. An Exit item comes with the Windows/Linux app menu (SB-26, not built). The menu template and keymap are unit-tested; not run on a Mac |
-| KS-16 | Text-editing keys keep their meaning | P0 | ✅ | ✅ e2e+unit | – | typed keys never go astray: a page or Orbit view that loads (a slow page, a background tab, a reload) no longer takes the keyboard from the command bar, a sidebar field or the page in front (focus-on-navigation off for every web contents Orbit makes); ⌘←/⌘→ act outside text fields only; ⌘[ / ⌘] (Alt+←/→) from a page's text field go back or forward only when the page leaves them alone (a press into a frame Orbit can't see into stays the page's); ⌘Z in a page field is the page's undo (tabs lane, tested here); no shortcut on a plain key runs while an input method composes (unit test: e2e can't drive a composition through the key router) |
-| KS-17 | Mouse, trackpad and modifier-click bindings | P0 | – | – | – |  |
+| KS-16 | Text-editing keys keep their meaning | P0 | ✅ | ✅ e2e+unit | – | typed keys never go astray: a page or Orbit view that loads (a slow page, a background tab, a reload) no longer takes the keyboard from the command bar, a sidebar field or the page in front (focus-on-navigation off for every web contents Orbit makes); ⌘←/⌘→ act outside text fields only; ⌘[ / ⌘] (Alt+←/→) outside text fields go back or forward at once and the page never sees them, however busy it is (Orbit knows where the keyboard is before the press, D60); from a text field they go only when its page leaves them alone (no answer within 250 ms counts as left alone); with the keyboard in a frame, the frame's own fields and handlers decide (e2e with same-site frames; cross-site frames take the same path, but e2e keys can't reach their process); Esc in a Mini Window's address field gives the keyboard back to its page; ⌘Z in a page field is the page's undo (tabs lane, tested here); no shortcut on a plain key runs while an input method composes (unit test: e2e can't drive a composition through the key router) |
+| KS-17 | Mouse, trackpad and modifier-click bindings | P0 | 🟡 partial | ✅ e2e | – | each pointer binding checked against its feature's tests: ⌘-click or middle-click, ⇧⌘-, ⇧- (Peek), ⌥- (split view) and ⌘⌥-click (Mini Window) on links; ⌘-click or middle-click on Back, Forward (keys e2e) or Reload for a new tab; long-press or right-click Back / Forward for history; double-click Reload to stop; ⌘-click a pinned tab's favicon (PN-04); ⌘- / ⇧-click rows (TB-13); double-click the empty sidebar (keys e2e), a tab row (TB-12) or a Favorite (FV-06); swipe over the sidebar (SP-08); pinch / ⌘-scroll (NV-06); mouse buttons 4/5; right-click twice on a video (MD-02). Not built: ⌘-hover + New Tab to paste and go (CB-12), swipe over the page (NV-02), ⌥-click Capture full page (DT-09) |
 | KS-18 | Shortcut hints everywhere | P1 | ✅ | ✅ e2e+unit | – | button tooltips (address, copy link, site controls, sidebar toggle, back/forward/reload, find, zoom, Library, Clear, Space dots, Peek, Mini Window Open in…), the empty-window hint, command-bar rows, macOS menu items, the shortcut sheet (OB-12) and the right-click menus of a tab, a multi-selection, the page and a split pane (an item that does what a key does shows that key’s first binding) follow a remap without a restart; a menu shows it the next time it opens. Windows and Linux have no app menu yet (SB-03, SB-26), so there is no menu bar there to label |
-| KS-19 | Keys inside overlays | P0 | 🟡 partial | ✅ e2e | – | the open overlay takes its keys first: command bar (⌘T/⌘L/⌘W/Esc), find bar (Enter/⇧Enter/Esc, NV-05), Peek (Esc, ⌘O, ⌘W, PK-09; Esc closes the Peek and the tab under it keeps loading), the recent-tab switcher (Tab/⇧Tab/`, W, letting go of ⌃), permission prompt and site controls (Esc), the sidebar with keyboard focus (arrows, Enter, Esc back to the page, SB-22); Esc then stops a loading page, as before, even one that uses Esc itself: Electron runs no isolated-world script in a page while it loads, so Orbit can't learn in time whether the page used the key (needs a lead decision: a script in the page's own world or a preload channel, D40) |
-| KS-20 | Shortcuts in special windows | P1 | 🟡 partial | ✅ e2e+unit | – | private window: the same keys, but the actions that need Spaces, pinned tabs, Favorites or folders (⌘D, ⌃1–9 / Alt+1–9, ⌘⌥← / ⌘⌥→, ⌘⇧K Clear, Favorite, New Folder, every Space action) do nothing there, from a key, a menu or the command bar, and a toast says “Not available in a private window”; tab keys work. Mini Window: ⌘W closes it, ⌘O / ⌘⌥O move or offer to move its page (KS-10), ⌘L edits its address with the keyboard in the field, ⌘R, zoom and print act on its page, sidebar and Space keys do nothing, Help → Keyboard Shortcuts opens over the browser window. Full screen: every key works with the sidebar hidden; ⌘1–9 and ⌘⌥↑ / ⌘⌥↓ switch tabs without bringing it out. Not built: ⌘F in a Mini Window (it has no find bar, Mini Window lane), the blank window (TB-17), extension keys in private windows (EX-06, EX-10) |
+| KS-19 | Keys inside overlays | P0 | 🟡 partial | ✅ e2e+unit | – | the open overlay takes its keys first: command bar (⌘T/⌘L/⌘W/Esc), find bar (Enter/⇧Enter/Esc, NV-05), Peek (Esc, ⌘O, ⌘W, PK-09; Esc closes the Peek and the tab under it keeps loading), the recent-tab switcher (Tab/⇧Tab/`, W, letting go of ⌃), permission prompt and site controls (Esc), the sidebar with keyboard focus (arrows, Enter, Esc back to the page, SB-22); then Esc on a loading page goes to the page first: the page's preload tells main whether the page used it, and Orbit stops the load only if it didn't, waiting 250 ms at most (no answer counts as left alone; D59, D60); only the main frame of a tab's page answers, and only for an Esc pressed there. Not built: leaving full screen with Esc held or pressed twice (NV-20), the print dialog (NV-07) |
+| KS-20 | Shortcuts in special windows | P1 | 🟡 partial | ✅ e2e+unit | – | private window: the same keys, but the actions that need Spaces, pinned tabs, Favorites, folders or the Archive (⌘D, ⌃1–9 / Alt+1–9, ⌘⌥← / ⌘⌥→, ⌘⇧K Clear, Favorite, New Folder, View Archive, every Space action) do nothing there, from a key, a menu or the command bar, and a toast says “Not available in a private window”; its sidebar has no Clear button; tab keys work. Mini Window: ⌘W closes it, ⌘O / ⌘⌥O move or offer to move its page (KS-10), ⌘L edits its address with the keyboard in the field and Esc gives the keyboard back to its page, ⌘R, zoom and print act on its page, sidebar and Space keys do nothing; ⌘Y / Ctrl+H History, the Library and Help → Keyboard Shortcuts open in the browser window behind it. Full screen: every key works with the sidebar hidden; ⌘1–9 and ⌘⌥↑ / ⌘⌥↓ switch tabs without bringing it out. Not built: ⌘F in a Mini Window (it has no find bar, Mini Window lane), the blank window (TB-17), extension keys in private windows (EX-06, EX-10) |
 
 ## Interaction feel and motion targets (prefix FL)
 
@@ -542,7 +542,7 @@ Spec: `spec/settings.md`
 | ST-05 | Per-profile: auto-archive timing | P1 | ✅ | ✅ e2e+unit | – | 12 hours (default), 24 hours, 7 days, 30 days per profile; no Never; other profiles follow Default until set |
 | ST-06 | Per-profile: default search engine and custom engines | P0 | ✅ | ✅ e2e+unit | – | per-profile default engine (8 built-ins), custom engines with keyword and %s URL, Make default from the row menu; no extension override in Electron, so that row does not exist |
 | ST-07 | Per-profile: download location, new-document app, data shortcuts | P1 | – | – | – |  |
-| ST-08 | Shortcuts section (remapping) | P1 | 🟡 partial | ✅ e2e+unit | – | Settings → Shortcuts: every action Orbit has (the action table, as main registers it) in groups with a search by name, search words or keys; click a key, press the new one (a modifier first except F1–F12; system and reserved keys refused, with the reason); + adds another (up to 5), ⌫ while listening removes one, Esc cancels; a key another action has asks: Swap (when replacing) or Remove from the other; right-click: Reset to Default, Remove Shortcut, Prefer Websites / Prefer Orbit (KS-02); Reset All asks first; Go to Tab: Include Favorites in ordering and ⌘9 last or ninth item; actions with no keys (Duplicate Tab…) show Record Shortcut; keys the system keeps are marked (KS-03); Settings search finds rows; stored per device. Not built: the Esc → exit full screen row, which comes when full screen (NV-20) registers that as an action |
+| ST-08 | Shortcuts section (remapping) | P1 | 🟡 partial | ✅ e2e+unit | – | Settings → Shortcuts: every action Orbit has (the action table, as main registers it) in groups with a search by name, search words or keys; click a key, press the new one (a modifier first except F1–F12; system and reserved keys refused, with the reason, and on macOS ⌃ with a lone letter, which moves the caret in text fields, D60); + adds another (up to 5), ⌫ while listening removes one, Esc cancels; a key another action has asks: Swap (when replacing) or Remove from the other; right-click: Reset to Default, Remove Shortcut, Prefer Websites / Prefer Orbit (KS-02); Reset All asks first; Go to Tab: Include Favorites in ordering and ⌘9 last or ninth item; actions with no keys (Duplicate Tab…) show Record Shortcut; keys the system keeps are marked (KS-03); Settings search finds rows; stored per device. Not built: the Esc → exit full screen row, which comes when full screen (NV-20) registers that as an action |
 | ST-09 | Links section | P1 | ✅ | ✅ e2e+unit | – | links from other apps open in a Mini Window (default), the most recent Space or one Space; routing rules (address contains / is exactly → a Space; first match wins; add, edit, reorder, remove); Peek options |
 | ST-10 | Advanced section | P1 | 🟡 partial | ✅ e2e+unit | – | tab sleep timer (TB-16), picture in picture, graphics acceleration; no site customizations, full-URL toggle, sounds or haptics, or edge-drag settings because those features don't exist yet |
 | ST-11 | Appearance section | P1 | 🟡 partial | ✅ e2e | – | Theme mode: Light / Dark / Match system (AP-01). Not built: window material (AP-10, Windows), app icon (AP-09), page defaults (P2) |
diff --git a/docs/ARCHITECTURE.md b/docs/ARCHITECTURE.md
index b4a356ab..456183bc 100644
--- a/docs/ARCHITECTURE.md
+++ b/docs/ARCHITECTURE.md
@@ -38,6 +38,25 @@ BrowserWindow (frameless; hiddenInset traffic lights on macOS)
 - **Keyboard shortcuts** are matched in main via `before-input-event` on every Orbit-owned web contents **and** every tab, so they work whatever has focus. The renderer has a fallback (`src/renderer/src/shortcuts.ts`). The final shortcut set follows `spec/shortcuts.md` (KS-*). Remapping (ST-08) layers user overrides over the defaults.
 - **Hooks** (`MainContext.hooks`) let features plug into tab creation, navigation and `window.open` without editing core files (Peek and Mini Window take over link opens this way).
 
+### Keys: routing, pages and the keyboard (`src/main/keys/`)
+
+- **Router order.** `WindowManager.attachShortcuts` (`src/main/windows.ts`) asks the keys lane's `keyRouter` (`src/main/keys/router.ts`) about each key press, in this order:
+  1. `record`: while Settings → Shortcuts listens for a new binding in that window, the press is reported (`keys.recorded`) and runs nothing (ST-08).
+  2. `switcherKey`: while the recent-tab switcher is up (⌃Tab held), ⌃W closes the highlighted tab and ⌃` steps back (KS-06, TB-05, D60).
+  3. `actionForInput`, then `actionIn`: the action the binding runs where it was pressed (⌘O opens a file outside a Peek or Mini Window, KS-12).
+  4. No action, or none registered: `runOutsideText` (on macOS ⌘← and ⌘→ go back and forward only outside text fields, KS-16).
+  5. `leaveToPage`: keys a page may use go to it first (below).
+  6. Otherwise the key is kept from the page (`preventDefault`) and the action runs, with `repeat` for a held key. Interceptors (private and Mini Windows, the shortcut sheet, DevTools) may answer it there instead.
+- **Pages first** (KS-02, KS-16). An action that prefers websites, and Back and Forward in a text field, go to the page first. The **page watcher** (`page-keys.ts`) is a script in isolated world 1020 of each tab's main frame, installed at `dom-ready`. For each trusted key-down it notes, once every handler of the page has run, whether one called `preventDefault` and whether a text field had focus. Its answers mean:
+  - `{ seen: true, prevented, inField }`: what the page did;
+  - `{ seen: false }`: the press didn't reach it within 200 ms, so a handler of the page that ran first stopped it;
+  - nothing within 250 ms (`ANSWER_WAIT_MS`: a busy renderer, or a page Orbit can't script): the page left the key alone, and the action runs (D60).
+
+  Electron runs no isolated-world script while a main frame loads, so a page on its way can't answer; Orbit takes the keys at once then.
+- **Focus mirror** (`page-focus.ts`, D60). Main knows before a press where the keyboard is in each tab's page: a script in the page's own world says whether a text field, the page, a frame inside it, or nothing there has it, and says it again when focus moves. The frame inside the page that has the keyboard (`contents.focusedFrame`) is followed too, and notes the presses Orbit may ask about. So Back and Forward run at once outside text fields, however busy the page, and a press in a frame is judged by that frame.
+- **Esc on a loading page** (KS-19, D59, `escape.ts`): the page gets Esc first. The page preload says whether a handler used it, and Orbit stops the load only if none did.
+- **No web contents takes the keyboard on navigation** (`KEEP_KEYBOARD`, `focus.ts`, KS-16). Electron focuses a web contents each time its page commits a navigation unless `focusOnNavigation` is off, even a page behind another tab. Every web contents Orbit makes for its windows spreads `KEEP_KEYBOARD` into its `webPreferences`: tab views, Orbit's own views, and pop-ups through `overrideBrowserWindowOptions`. Orbit gives a page the keyboard itself when the user selects, opens or clicks it. A lane that makes or shows a page does the same.
+
 ## 4. Tabs: lifecycle, sleeping, layout
 
 - A tab exists in state whether or not it is **awake**. `TabRuntime.ensure(tabId)` creates its `WebContentsView` lazily (sandboxed, per-profile session) and restores saved navigation history if the tab slept. `sleep(tabId)` saves history and closes the renderer process. That's how memory per idle tab stays low (TB-16). Sleeping is driven by `settings.sleepAfterMs`. Favorites stay warm (FV-08) and audible/visible tabs never sleep.
@@ -80,6 +99,7 @@ src/main/            main process
   media/             PiP, mini player                               lane: peek-mini (media)
   tweaks/ extensions/                                               lane: tweaks-extensions
   history/           browsing-history store (per-profile JSONL + index) lane: commandbar (query API used by archive)
+  keys/              keymap, key router, page watcher, focus mirror  lane: keys
   archive/                                                          lane: archive-persistence
   settings/ import/ downloads/ updates/                             lane: settings-import
 src/shared/          types and pure logic shared by main+renderer (state, tree, url, theme, actions, commands/<area>.ts per lane)
@@ -124,6 +144,9 @@ Sandboxed, context-isolated renderers everywhere. No Node in pages. Pages get on
 - `orbit-page:permission` (NV-15): a synchronous read of how a permission reads for the sending frame's own origin and profile ("prompt" while the user hasn't decided). Read-only.
 - `orbit-page:notification-click` (NV-15): a trusted click on one of the page's notifications. Main brings the tab forward only for a site allowed to show notifications, and at most once per `NOTIFICATION_CLICK_GAP_MS` per tab.
 - `orbit-page:internal-*` (DT-13, D53): Orbit's internal pages only. In the main frame of an `orbit:` page, which is Orbit's own UI, the preload patches nothing and gives `window.orbit`: the store's state and changes, and the commands listed for that page (`INTERNAL_PAGE_COMMANDS`), with no events. Main answers only a tab's main frame showing an `orbit:` page. In a web page it does nothing.
+- `orbit-page:escape` (KS-19, D59): one bit after a trusted Esc reaches the main frame, sent once every handler of the page has run: whether one called `preventDefault`. The listener is in the preload's own world. Main reads the bit only while it waits after an Esc in a loading tab with no overlay open (at most 250 ms; no answer counts as not used), only from that tab's main frame, and only for a press still waiting: a bit with none waiting does nothing. A page that always uses Esc can keep Esc from stopping its load; the Stop button still stops it.
+
+Main also runs scripts in pages, as media, Peek and nav do: the keys lane's page watcher in isolated world 1020, and its focus mirror in the page's own world (`src/main/keys/page-focus.ts`), which leaves nothing behind in the page. What they say is the page's own word: main checks each answer's shape, and an answer can only change what that page's own keys do.
 
 The UI's `orbit:*` IPC accepts registered Orbit UI senders only. UI renderers can't navigate or open windows. Permission prompts are per origin. Tweak JS (user-authored, per site) is injected only through `webFrame.executeJavaScript` in an isolated world, never with Node. Extensions use Electron's built-in extension support plus Orbit's own (MIT) API shims (D3: no GPL dependency).
 
diff --git a/docs/feature-status.json b/docs/feature-status.json
index 9d051295..1a9d2b9e 100644
--- a/docs/feature-status.json
+++ b/docs/feature-status.json
@@ -7,7 +7,7 @@
   "SB-06": {"built": "yes", "note": "title row: inline rename, hover profile badge and … menu (pinned caret is PN-09)"},
   "SB-07": {"built": "yes", "note": "+ New Tab row with press animation opens the command bar"},
   "SB-09": {"built": "yes", "note": "the Library button (a click opens the Library; a 300 ms hover shows the recent files, downloads and screenshots, which open on a click and drag out as the file; right-click chooses Downloads or Screenshots), the Space switcher and the + menu; the Library and + buttons are 28×28. New Note and New Canvas join the + menu with the notes and canvases lanes"},
-  "SB-11": {"built": "yes", "note": "Cmd+S / Ctrl+S, toggle button, View menu and command bar; the sidebar slides out as the card widens (one curve, reversible mid-way); the page views, which can't move in step, keep out of its way while it slides (where they end as it shows, where they were as it hides; the page colour fills the rest); back at the same width, scroll and selected tab; per window, persisted; new windows show it; a page that uses Cmd+S / Ctrl+S itself gets the first press, and a second press within a second or the toast's button toggles the sidebar (KS-02)"},
+  "SB-11": {"built": "yes", "note": "Cmd+S / Ctrl+S, toggle button, View menu and command bar; the sidebar slides out as the card widens (one curve, reversible mid-way); the page views, which can't move in step, keep out of its way while it slides (where they end as it shows, where they were as it hides; the page colour fills the rest); back at the same width, scroll and selected tab; per window, persisted; new windows show it; on Windows and Linux a page that uses Ctrl+S itself gets the first press, and a second press within a second or the toast's button toggles the sidebar; on macOS ⌘S toggles at once, as every action there prefers Orbit (D60; Settings → Shortcuts can change either, KS-02)"},
   "SB-12": {"built": "yes", "note": "left 6 px edge brings a floating card in its own view over the page, which never moves; main decides whether the pointer moved (not from where it was when the sidebar hid, so Cmd+S at the edge doesn't) and reads it for 300 ms after it leaves a page or the shell, so a flick to the edge (or onto the Linux resize border) brings the card; 0 ms dwell; stays while hovered (16 px band), while a field in it is edited, the command bar is open or a native menu is up in the window (one Chromium refuses counts as closed); goes 400 ms after the pointer moves on, at once on a click into the page (the click reaches the page); not over full-screen video; stays out while the pointer is on another window over it, until it comes back (review A-F1)"},
   "SB-14": {"built": "yes", "note": "drag the edge 1:1 with a live width, clamped 180-420 with no drift; double-click resets to 248; 40 px past the minimum hides (width kept); saved per window"},
   "SB-19": {"built": "yes", "note": "8 px margins (6 px with the sidebar hidden), 10 px corners on every page and pane while loading, hidden or floating; fine edge and shadow; native and video full screen drop the frame; the card and the page view take the page background colour so resizes show no white"},
@@ -23,7 +23,7 @@
   "TB-02": {"built": "yes", "note": "Cmd+T / + New Tab / link drop (a local file address dropped opens nothing, D49) / Cmd+Alt+V paste; background link tabs gesture-gated"},
   "TB-03": {"built": "yes", "note": "single rule todayInsertIndex(): top of Today"},
   "TB-04": {"built": "yes", "note": "click, Cmd+1-9 (Favorites setting, Cmd+9 last), Cmd+Alt+Up/Down skip collapsed rows"},
-  "TB-05": {"built": "partial", "note": "Ctrl+Tab / Ctrl+Shift+Tab step through the 5 most recent tabs while Ctrl is held (keyboard only); W with Ctrl held closes the highlighted tab (keys lane, KS-06); no overlay list yet"},
+  "TB-05": {"built": "partial", "note": "Ctrl+Tab / Ctrl+Shift+Tab step through the 5 most recent tabs while Ctrl is held (keyboard only); Ctrl+` steps back too, on every platform, while the switcher is up (D60); W with Ctrl held closes the highlighted tab (keys lane, KS-06); no overlay list yet"},
   "TB-06": {"built": "yes", "note": "Today -> Archive, pinned/Favorites unload; next selection below/above/MRU; middle-click; Cmd+W closes window when empty"},
   "TB-07": {"built": "yes", "note": "Cmd+Shift+T stack with full history; Cmd+Z reopens too"},
   "TB-08": {"built": "yes", "note": "pointer drag, 4px threshold, rows spring apart, ghost lift/settle, auto-scroll, Escape cancel, undo; no haptics"},
@@ -138,14 +138,15 @@
   "CB-23": {"built": "partial", "note": "private (non-persistent) profiles: no history/archive rows, and their tabs, folders and Spaces never show in normal windows; ⌘L on an empty Space acts like ⌘T; split-pane and Mini Window variants not done"},
   "KS-04": {"built": "yes", "note": "⌘T/⌘L/Alt+D, Esc, ⌘T/⌘L again, ↑/↓ (⌃N/⌃P), Enter, Tab, ⌫, ⇧Enter (option), ⌘⌥⌫ / Shift+Delete, ⌘⌥V"},
   "KS-07": {"built": "yes", "note": "Space shortcuts wired through the action table"},
-  "KS-19": {"built": "partial", "note": "the open overlay takes its keys first: command bar (⌘T/⌘L/⌘W/Esc), find bar (Enter/⇧Enter/Esc, NV-05), Peek (Esc, ⌘O, ⌘W, PK-09; Esc closes the Peek and the tab under it keeps loading), the recent-tab switcher (Tab/⇧Tab/`, W, letting go of ⌃), permission prompt and site controls (Esc), the sidebar with keyboard focus (arrows, Enter, Esc back to the page, SB-22); Esc then stops a loading page, as before, even one that uses Esc itself: Electron runs no isolated-world script in a page while it loads, so Orbit can't learn in time whether the page used the key (needs a lead decision: a script in the page's own world or a preload channel, D40)"},
-  "KS-16": {"built": "yes", "note": "typed keys never go astray: a page or Orbit view that loads (a slow page, a background tab, a reload) no longer takes the keyboard from the command bar, a sidebar field or the page in front (focus-on-navigation off for every web contents Orbit makes); ⌘←/⌘→ act outside text fields only; ⌘[ / ⌘] (Alt+←/→) from a page's text field go back or forward only when the page leaves them alone (a press into a frame Orbit can't see into stays the page's); ⌘Z in a page field is the page's undo (tabs lane, tested here); no shortcut on a plain key runs while an input method composes (unit test: e2e can't drive a composition through the key router)"},
+  "KS-19": {"built": "partial", "note": "the open overlay takes its keys first: command bar (⌘T/⌘L/⌘W/Esc), find bar (Enter/⇧Enter/Esc, NV-05), Peek (Esc, ⌘O, ⌘W, PK-09; Esc closes the Peek and the tab under it keeps loading), the recent-tab switcher (Tab/⇧Tab/`, W, letting go of ⌃), permission prompt and site controls (Esc), the sidebar with keyboard focus (arrows, Enter, Esc back to the page, SB-22); then Esc on a loading page goes to the page first: the page's preload tells main whether the page used it, and Orbit stops the load only if it didn't, waiting 250 ms at most (no answer counts as left alone; D59, D60); only the main frame of a tab's page answers, and only for an Esc pressed there. Not built: leaving full screen with Esc held or pressed twice (NV-20), the print dialog (NV-07)"},
+  "KS-16": {"built": "yes", "note": "typed keys never go astray: a page or Orbit view that loads (a slow page, a background tab, a reload) no longer takes the keyboard from the command bar, a sidebar field or the page in front (focus-on-navigation off for every web contents Orbit makes); ⌘←/⌘→ act outside text fields only; ⌘[ / ⌘] (Alt+←/→) outside text fields go back or forward at once and the page never sees them, however busy it is (Orbit knows where the keyboard is before the press, D60); from a text field they go only when its page leaves them alone (no answer within 250 ms counts as left alone); with the keyboard in a frame, the frame's own fields and handlers decide (e2e with same-site frames; cross-site frames take the same path, but e2e keys can't reach their process); Esc in a Mini Window's address field gives the keyboard back to its page; ⌘Z in a page field is the page's undo (tabs lane, tested here); no shortcut on a plain key runs while an input method composes (unit test: e2e can't drive a composition through the key router)"},
+  "KS-17": {"built": "partial", "note": "each pointer binding checked against its feature's tests: ⌘-click or middle-click, ⇧⌘-, ⇧- (Peek), ⌥- (split view) and ⌘⌥-click (Mini Window) on links; ⌘-click or middle-click on Back, Forward (keys e2e) or Reload for a new tab; long-press or right-click Back / Forward for history; double-click Reload to stop; ⌘-click a pinned tab's favicon (PN-04); ⌘- / ⇧-click rows (TB-13); double-click the empty sidebar (keys e2e), a tab row (TB-12) or a Favorite (FV-06); swipe over the sidebar (SP-08); pinch / ⌘-scroll (NV-06); mouse buttons 4/5; right-click twice on a video (MD-02). Not built: ⌘-hover + New Tab to paste and go (CB-12), swipe over the page (NV-02), ⌥-click Capture full page (DT-09)"},
   "KS-01": {"built": "yes", "note": "one keymap keyed by action id (src/shared/actions.ts + src/shared/keymap.ts): the key router, macOS menu bar (rebuilt on a remap), tooltips and command-bar rows read the live bindings; remap, several bindings per action (up to 5), none (command bar and menus still run it), a modifier required except F1-F12, system keys refused, conflicts reported (clear or swap), reset; stored per device in settings.shortcuts, cleaned on load, kept across a restart (Space keys too); Settings → Shortcuts (ST-08) lists every action with a search, records new keys on a click and resets on right-click; Help → Keyboard Shortcuts (OB-12) shows the essential keys as they are now"},
-  "KS-02": {"built": "partial", "note": "who gets a key first, per action: Toggle Sidebar (Cmd+S / Ctrl+S, SB-11) prefers websites on every platform, Copy URL (Ctrl+Shift+C, NV-17) on Windows/Linux, every other action prefers Orbit (the page never sees the key); with prefer websites the page's main frame gets the first press: left alone, the action runs; used (preventDefault), a toast offers the action and a second press within a second runs it; a held key's repeats stay the page's; a press into a frame Orbit can't see into counts as used; while a page's main frame loads, Orbit takes the keys at once (Electron runs no isolated-world script in a loading page, so the page can't say in time what it did); Settings → Shortcuts sets it per action (right-click → Prefer Websites / Prefer Orbit; a “Websites first” tag on the row); Esc leaving page full screen keeps Chromium's rule and nothing holds Cmd+E yet"},
+  "KS-02": {"built": "partial", "note": "who gets a key first, per action: on Windows and Linux Toggle Sidebar (Ctrl+S, SB-11) and Copy URL (Ctrl+Shift+C, NV-17) prefer websites; every other action, and on macOS every action, ⌘S included (D60), prefers Orbit (the page never sees the key); with prefer websites the page gets the first press: left alone, the action runs; used (preventDefault), a toast offers the action and a second press within a second runs it; a held key's repeats stay the page's; with the keyboard in a frame, that frame says what it did; no answer within 250 ms counts as left alone (D60), so a busy page holds a key a quarter of a second at most; while a page's main frame loads, Orbit takes the keys at once (Electron runs no isolated-world script in a loading page); Settings → Shortcuts sets it per action (right-click → Prefer Websites / Prefer Orbit; a “Websites first” tag on the row); Esc leaving page full screen keeps Chromium's rule and nothing holds Cmd+E yet"},
   "KS-18": {"built": "yes", "note": "button tooltips (address, copy link, site controls, sidebar toggle, back/forward/reload, find, zoom, Library, Clear, Space dots, Peek, Mini Window Open in…), the empty-window hint, command-bar rows, macOS menu items, the shortcut sheet (OB-12) and the right-click menus of a tab, a multi-selection, the page and a split pane (an item that does what a key does shows that key’s first binding) follow a remap without a restart; a menu shows it the next time it opens. Windows and Linux have no app menu yet (SB-03, SB-26), so there is no menu bar there to label"},
   "KS-03": {"built": "partial", "note": "every default checked against the spec tables on macOS, Windows and Linux (unit test): ⌘ → Ctrl, ⌥ → Alt, ⌃ keys (⌃Tab, the split keys) stay Ctrl; the Windows/Linux exceptions Alt+1–9 for Spaces, Ctrl+H, Alt+←/→, Alt+D, F5, F3, Ctrl+F4 and F1; Alt+F4 and Alt+F are kept for the system; a Ctrl+Alt key that typed an AltGr character acts only outside text fields; letters and symbols follow the layout; F11 / Alt+Shift+F come with full screen (KS-08); keys the system keeps (macOS Mission Control “Switch to Desktop N” ⌃1–⌃9 when turned on, GNOME’s workspace keys) are marked in Settings → Shortcuts, which says where to turn them off; no first-run suggestion"},
   "KS-05": {"built": "partial", "note": "⌘N, ⌘⇧N, ⌘⌥N, ⌘W / Ctrl+W / Ctrl+F4, ⌘⇧W / Ctrl+Shift+W (closes the window, or the Mini Window, Settings or onboarding window that has focus; Alt+F4 is the system's), ⌘⇧T (a closed tab comes back in its place), ⌘D (pins; again, back to the top of Today), ⌘⇧C, ⌘⇧⌥C, ⌘S, ⌘⇧K, ⌘⇧E, F6 (keyboard between the sidebar and the page), tested from a page; Duplicate Tab, Reset Tab, Rename Tab (shows a hidden sidebar to edit the name), Archive Tab, Move Tab to Space… (the command bar on its Move to rows) and Favorite This Tab have no keys until the user gives them some; ⌘Z (sidebar undo) is not remappable yet; the blank window (⌃⌘N, TB-17) and the top toolbar (⌘⇧D, SB-17) are not built"},
-  "KS-06": {"built": "yes", "note": "⌘1–⌘8 / Ctrl+1–8 (Favorites counted first unless turned off), ⌘9 / Ctrl+9 the last item or, set so, the ninth, ⌘⌥↓/↑ / Ctrl+Alt+↓/↑ and the ⌘⇧] / ⌘⇧[ (Ctrl+PgDn / Ctrl+PgUp) aliases, all tested from a page; while ⌃ is held, Tab and ⇧Tab (⌃` on macOS) step through recent tabs, W closes the highlighted tab (the next one in the switcher takes its place) and letting go settles; the switcher has no on-screen list yet (TB-05)"},
+  "KS-06": {"built": "yes", "note": "⌘1–⌘8 / Ctrl+1–8 (Favorites counted first unless turned off), ⌘9 / Ctrl+9 the last item or, set so, the ninth, ⌘⌥↓/↑ / Ctrl+Alt+↓/↑ and the ⌘⇧] / ⌘⇧[ (Ctrl+PgDn / Ctrl+PgUp) aliases, all tested from a page; while ⌃ is held, Tab and ⇧Tab step through recent tabs and ` steps back too, on every platform and only while the switcher is up (D60), W closes the highlighted tab (the next one in the switcher takes its place) and letting go settles; the switcher has no on-screen list yet (TB-05)"},
   "FL-13": {"built": "yes", "note": "strip of pages, 1:1 tracking, commit thresholds, settle/rubber-band springs, one-page slides for clicks and keys, reduced motion cross-fade"},
   "FL-14": {"built": "yes", "note": "theme blends with the gesture/spring in OKLab; 200 ms preset blends; light/dark cross-fade"},
   "FL-16": {"built": "yes", "note": "motion spring (0.97→1, 4 px drop), 100 ms exit (80 ms after choosing a row) while focus returns at once; fade only with reduced motion; centred in the window"},
@@ -188,7 +189,7 @@
   "PR-09": {"built": "partial", "note": "profiles.rename command; the Settings UI is the settings lane's"},
   "NV-01": {"built": "yes", "note": "buttons and keys (Cmd+Left/Right only outside text fields), history menu with favicons that closes on tab switch, Cmd/middle-click opens the entry in a background tab with its history; mouse side buttons are Chromium's; Backspace inert"},
   "NV-03": {"built": "yes", "note": "Cmd/Ctrl+R, F5; hard reload Cmd+Shift+R, Ctrl+Shift+R, Shift+F5, Ctrl+F5; Cmd/middle-click Reload duplicates with history; keyboard focus goes to the page"},
-  "NV-04": {"built": "yes", "note": "Esc in the page while loading (overlays take it first), Cmd+. on macOS, double-click Reload, Stop (x) state; a typed address, Back/Forward or Reload shows where it is going at once and stays when stopped; the loading indicator goes"},
+  "NV-04": {"built": "yes", "note": "Esc in the page while loading (overlays take it first; a page that uses Esc keeps it and goes on loading, D59), Cmd+. on macOS, double-click Reload, Stop (x) state; a typed address, Back/Forward or Reload shows where it is going at once and stays when stopped; the loading indicator goes"},
   "NV-05": {"built": "yes", "note": "floating bar over the active page's top-right corner; finds as you type, n/m count, No matches; Enter/Cmd+G/F3 next, Shift+Enter/Shift+Cmd+G/Shift+F3 previous, buttons; Esc closes and keeps the match selected; per tab (hidden on switch, back with text and place); starts from the selection, else the last search; IME commits; keys typed for the bar before it has the keyboard (a new window's first moments, a busy bar) wait up to 5 s and then go into it in order, text as text (any character); it takes the keyboard when it shows, even later than that; shortcuts and IME composition are not held; Cmd+J jumps to the selection (macOS); Edit > Find menu; does nothing while a Peek is open, so the keyboard stays in it (finding in a Peek is PK-11)"},
   "NV-06": {"built": "yes", "note": "Chromium steps 25-500% on Cmd+=/Cmd+-/Cmd+0 and Ctrl+wheel (Win/Linux), in a Peek (with a toast) and a Mini Window (no indicator there) too; per host in each profile (all its tabs), remembered across launches (written on quit), dropped with a deleted profile; indicator with Reset over the page for 1.5 s (longer while hovered); pinch is visual zoom and Cmd+0 undoes it too"},
   "NV-08": {"built": "partial", "note": "Cmd/middle-click background tab (toast Opened in a new tab while the sidebar is hidden) and Shift+Cmd foreground tab at the top of Today; Shift-click a new window when Peek is off; the page itself opens these (a link click in an isolated world, with the gesture), so they are requested as its click is: Referer, Sec-Fetch-Site, no SameSite=Strict cookie across sites; Option/Alt-click split view instead of the engine download; a local file opens in a new tab, window, Mini Window or split view only for a local file page whose frames are all local too, whatever the engine lets through: Orbit can't tell which frame asked, so a frame of any other origin (a web page's, or an opaque one: sandboxed, data:) refuses Cmd-, Shift- and Cmd+Option-clicks, target=_blank and window.open, and a toast names the file; a plain click without a target still opens it (D49); Cmd+Option-click a Mini Window and Shift-click Peek through the peek lane; hover pill is SB-27; still requested as if typed (Sec-Fetch-Site none, Strict cookies sent), with the page as Referer: the page menu Open Link in New Tab and New Window, Option-click split view, a blocked pop-up Open; without a Referer too: Peek, Mini Window and routing-rule links (peek lane), a pop-up window own links, Open Link in Private Window (on purpose); a link in a frame from another origin is opened from the top page, without a Referer; not built: dragging links"},
@@ -224,10 +225,11 @@
   "MD-16": {"built": "partial", "note": "enter: the video shrinks from its place in the page to the corner (~300 ms, standard curve); Back to tab/double-click: the tab is selected at once and a still of the last frame flies back into the page; release glides to the corner; Back to PiP grows from the controller; tray slides with the snappy spring; with reduced motion (FL-28) the player appears and goes without motion and a release settles with a 120 ms ease-out; no haptic tick on macOS"},
   "FL-32": {"built": "yes", "note": "corner resize follows the pointer, resists past its limits (rubber band) and springs back on release; a fling heads for the corner in its direction and settles with the spring; tray slides up with the snappy timing; Back to tab flies to the video's place; pinch zooms (MD-06) rather than resizes"},
   "KS-11": {"built": "partial", "note": "Space and arrows in the focused player, Cmd/Ctrl+scroll and pinch zoom (tested), hardware media keys via Chromium (untested), Mute Tab action assignable; the calendar meeting shortcut (P2) belongs to TB-21/FV-09"},
-  "KS-12": {"built": "partial", "note": "⌘Y / Ctrl+H View History (AR-10); ⌘⇧L Open Library on macOS, the command bar elsewhere; View Archive with no key, assignable; ⌘, / Ctrl+, Settings, which cannot be remapped, and again brings the same Settings window to the front; ⌘⇧⌫ / Ctrl+Shift+Delete Clear Browsing Data…; Shortcut Settings (command bar, assignable); the shortcut sheet from Help → Keyboard Shortcuts (macOS) and the command bar (OB-12); Open File… (macOS File menu, the command bar) and ⌘O / Ctrl+O wherever no Peek or Mini Window is open: the files chosen open in new tabs, the last one selected (Settings → Shortcuts says so under Open File…, which can also get keys of its own); Alt+F stays free for the Windows/Linux app menu (SB-03, SB-26, not built). Not built: Open Downloads (DL-14, downloads lane), pinned extensions (EX-06)"},
+  "KS-12": {"built": "partial", "note": "⌘Y / Ctrl+H View History (AR-10); ⌘⇧L Open Library on macOS, the command bar elsewhere; View Archive with no key, assignable; ⌘, / Ctrl+, Settings, which cannot be remapped, and again brings the same Settings window to the front; ⌘⇧⌫ / Ctrl+Shift+Delete Clear Browsing Data…; Shortcut Settings (command bar, assignable); the shortcut sheet from Help → Keyboard Shortcuts (macOS) and the command bar (OB-12); Open File… (macOS File menu, the command bar) and ⌘O / Ctrl+O wherever no Peek or Mini Window is open: the files chosen open in new tabs, the last one selected (Settings → Shortcuts says so under Open File…, which can also get keys of its own); with no Orbit window shown, the macOS menu bar takes ⌘O itself, so Open File… still opens (F6); Alt+F stays free for the Windows/Linux app menu (SB-03, SB-26, not built). Not built: Open Downloads (DL-14, downloads lane), pinned extensions (EX-06)"},
+  "KS-13": {"built": "partial", "note": "⌥⌘I / F12 (Ctrl+Shift+I / F12) open or close DevTools (DT-01, F12 in e2e), ⌥⌘J (Ctrl+Shift+J) the console, ⌥⌘C the element picker (no default on Windows/Linux, where Ctrl+Shift+C is Copy URL), ⌥⌘U (Ctrl+U) View Source, ⌘⇧R (Ctrl+Shift+R) hard reload: each checked against the spec table per platform, and none fixed; a remapped DevTools key moves in the router and in DevTools' own page, and the picker can take ⇧⌘C from Copy URL (unit tests); ⇧⌘M / Ctrl+Shift+M stays DevTools' device toolbar key (no action has it). A remap reaches DevTools already open only once they open again (devtools lane). Not built: developer mode for a site (DT-06; its ⌃D is a plain ⌃-letter, which macOS keeps for the caret, D60) and the task manager (DT-11, Shift+Esc)"},
   "KS-10": {"built": "yes", "note": "⌘O / Ctrl+O expands a Peek into a selected Today tab (PK-07); Esc and ⌘W / Ctrl+W close it (PK-09, Esc fixed); ⌘⇧T and ⌘Z reopen it (PK-10); ⌘⌥N / Ctrl+Alt+N opens a Mini Window (MW-06); in a Mini Window ⌘O moves its page into the most recent Space (MW-05), ⌘⌥O (also ⌘⇧O) / Ctrl+Alt+O offers the Spaces, ⌘W closes it (MW-09). All from the one keymap and remappable but Esc; the tests press the keys (peek, mini-window and keys specs)"},
   "KS-15": {"built": "yes", "note": "macOS: the menu bar keeps the system’s items and keys: Hide Orbit ⌘H, Hide Others ⌥⌘H and Quit ⌘Q in the Orbit menu, the Window menu (Minimize ⌘M, ⌘` between Orbit windows) and the Help menu with its search (⌘?). No action can take these keys, nor Alt+F4, Alt+Tab or Alt+F on Windows and Linux, and Settings → Shortcuts says what keeps them (KS-03). Windows and Linux: Alt+F4 closes the window and, on the last one, quits; F1 opens Help (OB-13) and can’t be changed there. An Exit item comes with the Windows/Linux app menu (SB-26, not built). The menu template and keymap are unit-tested; not run on a Mac"},
-  "KS-20": {"built": "partial", "note": "private window: the same keys, but the actions that need Spaces, pinned tabs, Favorites or folders (⌘D, ⌃1–9 / Alt+1–9, ⌘⌥← / ⌘⌥→, ⌘⇧K Clear, Favorite, New Folder, every Space action) do nothing there, from a key, a menu or the command bar, and a toast says “Not available in a private window”; tab keys work. Mini Window: ⌘W closes it, ⌘O / ⌘⌥O move or offer to move its page (KS-10), ⌘L edits its address with the keyboard in the field, ⌘R, zoom and print act on its page, sidebar and Space keys do nothing, Help → Keyboard Shortcuts opens over the browser window. Full screen: every key works with the sidebar hidden; ⌘1–9 and ⌘⌥↑ / ⌘⌥↓ switch tabs without bringing it out. Not built: ⌘F in a Mini Window (it has no find bar, Mini Window lane), the blank window (TB-17), extension keys in private windows (EX-06, EX-10)"},
+  "KS-20": {"built": "partial", "note": "private window: the same keys, but the actions that need Spaces, pinned tabs, Favorites, folders or the Archive (⌘D, ⌃1–9 / Alt+1–9, ⌘⌥← / ⌘⌥→, ⌘⇧K Clear, Favorite, New Folder, View Archive, every Space action) do nothing there, from a key, a menu or the command bar, and a toast says “Not available in a private window”; its sidebar has no Clear button; tab keys work. Mini Window: ⌘W closes it, ⌘O / ⌘⌥O move or offer to move its page (KS-10), ⌘L edits its address with the keyboard in the field and Esc gives the keyboard back to its page, ⌘R, zoom and print act on its page, sidebar and Space keys do nothing; ⌘Y / Ctrl+H History, the Library and Help → Keyboard Shortcuts open in the browser window behind it. Full screen: every key works with the sidebar hidden; ⌘1–9 and ⌘⌥↑ / ⌘⌥↓ switch tabs without bringing it out. Not built: ⌘F in a Mini Window (it has no find bar, Mini Window lane), the blank window (TB-17), extension keys in private windows (EX-06, EX-10)"},
   "SB-10": {"built": "partial", "note": "media tray and call controls (media lane), above the bottom bar, pushing the list up; download progress and the update banner belong to other lanes"},
   "PK-01": {"built": "yes", "note": "floating card over the source tab; one Peek per window; links inside navigate it"},
   "PK-02": {"built": "yes", "note": "other-site (eTLD+1) link clicks, Enter on a focused link, and target=_blank in pinned tabs/Favorites; same-site navigates. Only a navigation to the clicked link counts, so form posts, script navigations and auto-posted sign-ins stay in the tab"},
@@ -291,7 +293,7 @@
   "ST-20": {"built": "partial", "note": "per-profile rows carry the profile's name, the download location (DL-07) too; passwords and site permissions don't exist yet"},
   "AP-01": {"built": "yes", "note": "Light / Dark / Match system in Settings and the Space theme picker; about 200 ms cross-fade, no flash"},
   "OB-02": {"built": "yes", "note": "audit and e2e: no account UI anywhere, onboarding included; a first run sends nothing off the computer, with or without onboarding, except Chromium's spell-check dictionary download (see tests)"},
-  "ST-08": {"built": "partial", "note": "Settings → Shortcuts: every action Orbit has (the action table, as main registers it) in groups with a search by name, search words or keys; click a key, press the new one (a modifier first except F1–F12; system and reserved keys refused, with the reason); + adds another (up to 5), ⌫ while listening removes one, Esc cancels; a key another action has asks: Swap (when replacing) or Remove from the other; right-click: Reset to Default, Remove Shortcut, Prefer Websites / Prefer Orbit (KS-02); Reset All asks first; Go to Tab: Include Favorites in ordering and ⌘9 last or ninth item; actions with no keys (Duplicate Tab…) show Record Shortcut; keys the system keeps are marked (KS-03); Settings search finds rows; stored per device. Not built: the Esc → exit full screen row, which comes when full screen (NV-20) registers that as an action"},
+  "ST-08": {"built": "partial", "note": "Settings → Shortcuts: every action Orbit has (the action table, as main registers it) in groups with a search by name, search words or keys; click a key, press the new one (a modifier first except F1–F12; system and reserved keys refused, with the reason, and on macOS ⌃ with a lone letter, which moves the caret in text fields, D60); + adds another (up to 5), ⌫ while listening removes one, Esc cancels; a key another action has asks: Swap (when replacing) or Remove from the other; right-click: Reset to Default, Remove Shortcut, Prefer Websites / Prefer Orbit (KS-02); Reset All asks first; Go to Tab: Include Favorites in ordering and ⌘9 last or ninth item; actions with no keys (Duplicate Tab…) show Record Shortcut; keys the system keeps are marked (KS-03); Settings search finds rows; stored per device. Not built: the Esc → exit full screen row, which comes when full screen (NV-20) registers that as an action"},
   "ST-09": {"built": "yes", "note": "links from other apps open in a Mini Window (default), the most recent Space or one Space; routing rules (address contains / is exactly → a Space; first match wins; add, edit, reorder, remove); Peek options"},
   "ST-10": {"built": "partial", "note": "tab sleep timer (TB-16), picture in picture, graphics acceleration; no site customizations, full-URL toggle, sounds or haptics, or edge-drag settings because those features don't exist yet"},
   "ST-12": {"built": "partial", "note": "privacy promise (Orbit sends nothing); Clear browsing data per profile (⌘⇧⌫ / Ctrl+Shift+Delete): history by time range; cookies and site data, and the cache, always from all time (Electron has no range), so they start ticked only for All time; Secure DNS (Automatic, Off, Cloudflare, Google, Quad9); graphics acceleration lives in Advanced. No HTTPS-first or Safe Browsing (not in Electron), no per-site clearing here"},