diff --git a/src/app/globals.css b/src/app/globals.css
index 78a09c2..87e3464 100644
--- a/src/app/globals.css
+++ b/src/app/globals.css
@@ -3075,3 +3075,642 @@ html {
     grid-template-columns: repeat(2, minmax(0, 1fr));
   }
 }
+
+/* ============================================
+   Keyboard shortcuts: kbd chips, command palette,
+   help sheet, and the settings binding editor.
+   All colors are theme tokens, so light / dark /
+   high-contrast flip for free.
+   ============================================ */
+
+/* --- kbd chips ------------------------------------------------------------ */
+.kbd {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  min-width: 1.5em;
+  height: 1.55em;
+  padding: 0 0.4em;
+  font-family: var(--font-mono);
+  font-size: 0.72rem;
+  line-height: 1;
+  color: var(--text-secondary);
+  background: var(--bg-tertiary);
+  border: 1px solid var(--border-medium);
+  border-bottom-width: 2px;
+  border-radius: 3px;
+  white-space: nowrap;
+}
+
+.kbd-combo,
+.kbd-step,
+.kbd-list {
+  display: inline-flex;
+  align-items: center;
+  gap: 3px;
+}
+
+.kbd-combo {
+  gap: 5px;
+}
+
+.kbd-list {
+  gap: 6px;
+  flex-wrap: wrap;
+  justify-content: flex-end;
+}
+
+.kbd-plus {
+  color: var(--text-tertiary);
+  font-size: 0.68rem;
+}
+
+.kbd-then,
+.kbd-or {
+  font-family: var(--font-serif);
+  font-size: 0.68rem;
+  font-style: italic;
+  color: var(--text-tertiary);
+  padding: 0 1px;
+}
+
+.kbd-unset {
+  font-family: var(--font-serif);
+  font-size: 0.8rem;
+  font-style: italic;
+  color: var(--text-tertiary);
+}
+
+/* --- command palette + help sheet (shared shell) ------------------------- */
+.cmdk-dialog {
+  margin: 8vh auto auto;
+  padding: 0 1rem;
+  border: none;
+  background: transparent;
+  width: 100%;
+  max-width: 640px;
+  max-height: 84vh;
+  overflow: visible;
+  animation: cmdk-slide-up 0.32s cubic-bezier(0.34, 1.56, 0.64, 1);
+}
+
+.cmdk-dialog::backdrop {
+  background: var(--modal-backdrop);
+  backdrop-filter: blur(10px);
+  -webkit-backdrop-filter: blur(10px);
+  animation: cmdk-fade-in 0.25s ease-out;
+}
+
+.cmdk-panel {
+  display: flex;
+  flex-direction: column;
+  max-height: 84vh;
+  overflow: hidden;
+  background: var(--modal-bg);
+  border: 1px solid var(--border-medium);
+  box-shadow: var(--modal-shadow);
+}
+
+.cmdk-search {
+  display: flex;
+  align-items: center;
+  gap: 0.6rem;
+  padding: 0.85rem 1rem;
+  border-bottom: 1px solid var(--border-subtle);
+  background: var(--modal-header-bg);
+}
+
+.cmdk-search-icon {
+  color: var(--text-tertiary);
+  flex-shrink: 0;
+}
+
+.cmdk-input {
+  flex: 1;
+  min-width: 0;
+  background: transparent;
+  border: 0;
+  outline: none;
+  color: var(--text-primary);
+  font-family: var(--font-serif);
+  font-size: 1.02rem;
+}
+
+.cmdk-input::placeholder {
+  color: var(--text-tertiary);
+}
+
+.cmdk-esc {
+  flex-shrink: 0;
+}
+
+.cmdk-list {
+  flex: 1;
+  overflow-y: auto;
+  padding: 0.4rem;
+}
+
+.cmdk-empty {
+  padding: 1.5rem 1rem;
+  text-align: center;
+  color: var(--text-tertiary);
+  font-family: var(--font-serif);
+  font-size: 0.9rem;
+}
+
+.cmdk-group-label {
+  padding: 0.6rem 0.65rem 0.35rem;
+  font-family: var(--font-serif);
+  font-size: 0.68rem;
+  letter-spacing: 0.1em;
+  text-transform: uppercase;
+  color: var(--text-tertiary);
+}
+
+.cmdk-item {
+  display: flex;
+  align-items: center;
+  gap: 0.7rem;
+  width: 100%;
+  padding: 0.55rem 0.65rem;
+  background: transparent;
+  border: 0;
+  border-left: 2px solid transparent;
+  color: var(--text-primary);
+  cursor: pointer;
+  text-align: left;
+  transition: background 0.12s ease, border-color 0.12s ease;
+}
+
+.cmdk-item.is-active {
+  background: var(--bg-tertiary);
+  border-left-color: var(--text-accent);
+}
+
+.cmdk-item-icon {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  width: 1.6rem;
+  color: var(--text-accent);
+  flex-shrink: 0;
+}
+
+.cmdk-item-body {
+  display: flex;
+  flex-direction: column;
+  gap: 1px;
+  min-width: 0;
+  flex: 1;
+}
+
+.cmdk-item-label {
+  font-family: var(--font-serif);
+  font-size: 0.95rem;
+  color: var(--text-primary);
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.cmdk-item-query {
+  font-family: var(--font-mono);
+  color: var(--text-accent);
+}
+
+.cmdk-item-desc {
+  font-size: 0.76rem;
+  color: var(--text-tertiary);
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.cmdk-item-kbd,
+.cmdk-item-enter {
+  flex-shrink: 0;
+  color: var(--text-tertiary);
+}
+
+.cmdk-footer {
+  display: flex;
+  align-items: center;
+  gap: 1rem;
+  padding: 0.55rem 0.9rem;
+  border-top: 1px solid var(--border-subtle);
+  background: var(--modal-header-bg);
+}
+
+.cmdk-hint {
+  display: inline-flex;
+  align-items: center;
+  gap: 0.35rem;
+  font-family: var(--font-serif);
+  font-size: 0.75rem;
+  color: var(--text-tertiary);
+}
+
+.cmdk-hint-button {
+  margin-left: auto;
+  background: transparent;
+  border: 0;
+  cursor: pointer;
+  transition: color 0.15s ease;
+}
+
+.cmdk-hint-button:hover {
+  color: var(--text-accent);
+}
+
+/* --- shortcuts help sheet specifics -------------------------------------- */
+.shortcuts-panel {
+  max-height: 84vh;
+}
+
+.shortcuts-head {
+  display: flex;
+  align-items: flex-start;
+  justify-content: space-between;
+  gap: 1rem;
+  padding: 1.1rem 1.25rem;
+  border-bottom: 1px solid var(--border-subtle);
+  background: var(--modal-header-bg);
+}
+
+.shortcuts-title {
+  margin: 0 0 0.25rem;
+  font-family: var(--font-serif);
+  font-weight: 400;
+  font-size: 1.25rem;
+  letter-spacing: -0.01em;
+  color: var(--text-primary);
+}
+
+.shortcuts-sub {
+  margin: 0;
+  font-size: 0.8rem;
+  color: var(--text-tertiary);
+}
+
+.shortcuts-close {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  padding: 0.5rem;
+  background: var(--modal-pane-bg);
+  border: 1px solid var(--border-subtle);
+  color: var(--text-tertiary);
+  cursor: pointer;
+  flex-shrink: 0;
+  transition: color 0.2s ease, border-color 0.2s ease, background 0.2s ease;
+}
+
+.shortcuts-close:hover {
+  color: var(--text-primary);
+  border-color: var(--border-medium);
+  background: var(--bg-tertiary);
+}
+
+.shortcuts-body {
+  overflow-y: auto;
+  padding: 1rem 1.25rem 1.25rem;
+  display: flex;
+  flex-direction: column;
+  gap: 1.25rem;
+}
+
+.shortcuts-group-label {
+  margin: 0 0 0.5rem;
+  font-family: var(--font-serif);
+  font-size: 0.7rem;
+  letter-spacing: 0.1em;
+  text-transform: uppercase;
+  color: var(--text-tertiary);
+}
+
+.shortcuts-rows {
+  list-style: none;
+  margin: 0;
+  padding: 0;
+  display: flex;
+  flex-direction: column;
+}
+
+.shortcuts-row {
+  display: flex;
+  align-items: center;
+  gap: 0.65rem;
+  padding: 0.5rem 0;
+  border-top: 1px solid var(--border-subtle);
+}
+
+.shortcuts-group .shortcuts-row:first-child {
+  border-top: none;
+}
+
+.shortcuts-row-icon {
+  display: inline-flex;
+  color: var(--text-accent);
+  flex-shrink: 0;
+}
+
+.shortcuts-row-label {
+  flex: 1;
+  min-width: 0;
+  font-family: var(--font-serif);
+  font-size: 0.9rem;
+  color: var(--text-primary);
+}
+
+.shortcuts-row-keys {
+  flex-shrink: 0;
+}
+
+.shortcuts-foot {
+  padding: 0.85rem 1.25rem;
+  border-top: 1px solid var(--border-subtle);
+  background: var(--modal-header-bg);
+}
+
+.shortcuts-customize {
+  display: inline-flex;
+  align-items: center;
+  gap: 0.45rem;
+  color: var(--text-accent);
+  font-family: var(--font-serif);
+  font-size: 0.85rem;
+  text-decoration: none;
+}
+
+.shortcuts-customize:hover {
+  text-decoration: underline;
+}
+
+/* --- live announcer ------------------------------------------------------ */
+.kbd-live-region {
+  position: absolute;
+  width: 1px;
+  height: 1px;
+  padding: 0;
+  margin: -1px;
+  overflow: hidden;
+  clip: rect(0 0 0 0);
+  clip-path: inset(50%);
+  white-space: nowrap;
+  border: 0;
+}
+
+.kbd-toast {
+  position: fixed;
+  left: 50%;
+  bottom: 2rem;
+  transform: translateX(-50%);
+  z-index: 200;
+  padding: 0.55rem 1rem;
+  background: var(--bg-elevated);
+  border: 1px solid var(--border-medium);
+  box-shadow: var(--shadow-overlay);
+  color: var(--text-primary);
+  font-family: var(--font-serif);
+  font-size: 0.85rem;
+  pointer-events: none;
+  animation: cmdk-toast-in 0.25s ease-out;
+}
+
+/* --- settings: binding editor -------------------------------------------- */
+.kb-launchers {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 0.5rem;
+}
+
+.kb-launch-button {
+  display: inline-flex;
+  align-items: center;
+  gap: 0.5rem;
+  padding: 0.5rem 0.85rem;
+  background: var(--bg-tertiary);
+  border: 1px solid var(--border-medium);
+  color: var(--text-secondary);
+  font-family: var(--font-serif);
+  font-size: 0.85rem;
+  cursor: pointer;
+  transition: border-color 0.2s ease, color 0.2s ease;
+}
+
+.kb-launch-button:hover {
+  color: var(--text-primary);
+  border-color: var(--text-accent);
+}
+
+.kb-group + .kb-group {
+  margin-top: 0.5rem;
+}
+
+.kb-group-label {
+  margin: 0 0 0.5rem;
+  font-family: var(--font-serif);
+  font-size: 0.7rem;
+  letter-spacing: 0.1em;
+  text-transform: uppercase;
+  color: var(--text-tertiary);
+}
+
+.kb-rows {
+  list-style: none;
+  margin: 0;
+  padding: 0;
+  border: 1px solid var(--border-subtle);
+}
+
+.kb-row {
+  display: flex;
+  align-items: center;
+  gap: 0.75rem;
+  padding: 0.7rem 0.85rem;
+}
+
+.kb-row + .kb-row {
+  border-top: 1px solid var(--border-subtle);
+}
+
+.kb-row-icon {
+  display: inline-flex;
+  color: var(--text-accent);
+  flex-shrink: 0;
+}
+
+.kb-row-main {
+  display: flex;
+  flex-direction: column;
+  gap: 1px;
+  min-width: 0;
+  flex: 1;
+}
+
+.kb-row-label {
+  font-family: var(--font-serif);
+  font-weight: 500;
+  font-size: 0.9rem;
+  color: var(--text-primary);
+}
+
+.kb-row-note {
+  font-weight: 400;
+  font-style: italic;
+  color: var(--text-tertiary);
+}
+
+.kb-row-desc {
+  font-size: 0.78rem;
+  color: var(--text-tertiary);
+  line-height: 1.4;
+}
+
+.kb-row-conflict {
+  margin-top: 2px;
+  font-size: 0.75rem;
+  color: var(--danger);
+}
+
+.kb-row-keys {
+  flex-shrink: 0;
+  display: flex;
+  justify-content: flex-end;
+  min-width: 0;
+}
+
+.kb-row-actions {
+  display: inline-flex;
+  align-items: center;
+  gap: 0.35rem;
+  flex-shrink: 0;
+}
+
+.kb-edit-button {
+  padding: 0.3rem 0.7rem;
+  background: var(--accent-forest);
+  color: var(--text-on-accent);
+  border: 1px solid var(--text-accent);
+  font-family: var(--font-serif);
+  font-size: 0.78rem;
+  cursor: pointer;
+  transition: opacity 0.2s ease;
+}
+
+.kb-edit-button:disabled {
+  opacity: 0.5;
+  cursor: not-allowed;
+}
+
+.kb-text-button {
+  display: inline-flex;
+  align-items: center;
+  gap: 0.3rem;
+  padding: 0.3rem 0.5rem;
+  background: transparent;
+  border: 0;
+  color: var(--text-tertiary);
+  font-family: var(--font-serif);
+  font-size: 0.78rem;
+  cursor: pointer;
+  transition: color 0.2s ease;
+}
+
+.kb-text-button:hover:not(:disabled) {
+  color: var(--text-accent);
+}
+
+.kb-text-button:disabled {
+  opacity: 0.5;
+  cursor: not-allowed;
+}
+
+.kb-reset-all {
+  display: flex;
+  justify-content: flex-end;
+}
+
+.kb-recorder {
+  display: flex;
+  flex-direction: column;
+  align-items: flex-end;
+  gap: 3px;
+}
+
+.kb-recorder-box {
+  display: inline-flex;
+  align-items: center;
+  min-height: 1.9rem;
+  min-width: 6rem;
+  padding: 0.2rem 0.55rem;
+  background: var(--bg-tertiary);
+  border: 1px dashed var(--text-accent);
+  cursor: text;
+}
+
+.kb-recorder-box:focus-visible {
+  outline: 2px solid var(--text-accent);
+  outline-offset: 1px;
+}
+
+.kb-recorder-hint {
+  font-family: var(--font-serif);
+  font-size: 0.78rem;
+  font-style: italic;
+  color: var(--text-tertiary);
+}
+
+.kb-recorder-help {
+  font-size: 0.68rem;
+  color: var(--text-tertiary);
+}
+
+@keyframes cmdk-fade-in {
+  from {
+    opacity: 0;
+  }
+  to {
+    opacity: 1;
+  }
+}
+
+@keyframes cmdk-slide-up {
+  from {
+    opacity: 0;
+    transform: translateY(-12px);
+  }
+  to {
+    opacity: 1;
+    transform: translateY(0);
+  }
+}
+
+@keyframes cmdk-toast-in {
+  from {
+    opacity: 0;
+    transform: translate(-50%, 8px);
+  }
+  to {
+    opacity: 1;
+    transform: translate(-50%, 0);
+  }
+}
+
+@media (max-width: 560px) {
+  .kb-row {
+    flex-wrap: wrap;
+  }
+  .kb-row-icon {
+    display: none;
+  }
+  .kb-row-keys {
+    order: 3;
+    width: 100%;
+    justify-content: flex-start;
+  }
+  .kb-row-actions {
+    order: 2;
+    margin-left: auto;
+  }
+}
diff --git a/src/app/layout.tsx b/src/app/layout.tsx
index e24d5d1..9b9fcc2 100644
--- a/src/app/layout.tsx
+++ b/src/app/layout.tsx
@@ -2,6 +2,7 @@ import type { Metadata } from "next";
 import { Analytics } from "@vercel/analytics/next";
 import { AtprotoSessionProvider } from "@/components/AtprotoSessionProvider";
 import { PreferencesProvider } from "@/components/PreferencesProvider";
+import { KeyboardShortcutsProvider } from "@/components/KeyboardShortcutsProvider";
 import Footer from "@/components/Footer";
 import PageTransition from "@/components/PageTransition";
 import ThemeSync from "@/components/ThemeSync";
@@ -77,9 +78,11 @@ export default function RootLayout({
         <A11ySync />
         <AtprotoSessionProvider>
           <PreferencesProvider>
-            <PageTransition>
-              <main style={{ position: 'relative', zIndex: 1 }}>{children}</main>
-            </PageTransition>
+            <KeyboardShortcutsProvider>
+              <PageTransition>
+                <main style={{ position: 'relative', zIndex: 1 }}>{children}</main>
+              </PageTransition>
+            </KeyboardShortcutsProvider>
           </PreferencesProvider>
         </AtprotoSessionProvider>
         <Footer />
diff --git a/src/components/CommandPalette.tsx b/src/components/CommandPalette.tsx
new file mode 100644
index 0000000..c124345
--- /dev/null
+++ b/src/components/CommandPalette.tsx
@@ -0,0 +1,283 @@
+'use client';
+
+import {
+  Fragment,
+  useEffect,
+  useMemo,
+  useRef,
+  useState,
+  type KeyboardEvent,
+} from 'react';
+import { CornerDownLeft, Search } from 'lucide-react';
+import { COMMAND_GROUPS, type Platform } from '@/lib/keybindings';
+import { resolveSearchPath } from '@/utils/atproto/searchRouting';
+import Kbd from './Kbd';
+import type { ResolvedCommand } from './KeyboardShortcutsProvider';
+
+type Item =
+  | { kind: 'command'; cmd: ResolvedCommand }
+  | { kind: 'goto'; query: string; path: string };
+
+function scoreCommand(cmd: ResolvedCommand, q: string): number {
+  const label = cmd.meta.label.toLowerCase();
+  if (label === q) return 100;
+  if (label.startsWith(q)) return 80;
+  if (label.includes(q)) return 60;
+  if (cmd.meta.keywords?.some((k) => k.includes(q))) return 40;
+  const groupLabel =
+    COMMAND_GROUPS.find((g) => g.id === cmd.meta.group)?.label.toLowerCase() ?? '';
+  if (groupLabel.includes(q)) return 20;
+  return -1;
+}
+
+/**
+ * The ⌘K command sheet. A native <dialog> (focus trap + Escape for free, like
+ * JsonModal) with a filter input over every available command, plus a
+ * "go to <query>" row that routes free text into the explorer. Arrow keys move
+ * the selection, Enter runs it. Styling lives in globals.css under `.cmdk-*`.
+ */
+export default function CommandPalette({
+  open,
+  onClose,
+  commands,
+  platform,
+  onNavigate,
+  onOpenHelp,
+}: {
+  open: boolean;
+  onClose: () => void;
+  commands: ResolvedCommand[];
+  platform: Platform;
+  onNavigate: (path: string) => void;
+  onOpenHelp: () => void;
+}) {
+  const ref = useRef<HTMLDialogElement>(null);
+  const inputRef = useRef<HTMLInputElement>(null);
+  const listRef = useRef<HTMLDivElement>(null);
+  const [query, setQuery] = useState('');
+  const [highlight, setHighlight] = useState(0);
+
+  // Drive the native modal from the `open` prop.
+  useEffect(() => {
+    const dlg = ref.current;
+    if (!dlg) return;
+    if (open && !dlg.open) dlg.showModal();
+    else if (!open && dlg.open) dlg.close();
+  }, [open]);
+
+  // Reset + focus whenever the palette opens. The state resets live inside the
+  // timer callback (not synchronously in the effect body) to stay clear of the
+  // set-state-in-effect lint rule — the dialog has just been shown, so a
+  // one-tick-later reset is imperceptible.
+  useEffect(() => {
+    if (!open) return;
+    const id = window.setTimeout(() => {
+      setQuery('');
+      setHighlight(0);
+      inputRef.current?.focus();
+    }, 0);
+    return () => window.clearTimeout(id);
+  }, [open]);
+
+  // Mirror native `close` (Escape / dlg.close()) back to the parent.
+  useEffect(() => {
+    const dlg = ref.current;
+    if (!dlg) return;
+    const handleClose = () => onClose();
+    dlg.addEventListener('close', handleClose);
+    return () => dlg.removeEventListener('close', handleClose);
+  }, [onClose]);
+
+  const q = query.trim().toLowerCase();
+  const available = useMemo(() => commands.filter((c) => c.available), [commands]);
+
+  const items = useMemo<Item[]>(() => {
+    if (!q) return available.map((cmd) => ({ kind: 'command', cmd }));
+    const scored = available
+      .map((cmd) => ({ cmd, s: scoreCommand(cmd, q) }))
+      .filter((x) => x.s >= 0)
+      .sort((a, b) => b.s - a.s);
+    const list: Item[] = scored.map((x) => ({ kind: 'command', cmd: x.cmd }));
+    // Offer a "go to <query>" row only when the text reads like an identifier
+    // (has a dot/colon/slash, or an at://-or-did prefix) or when nothing else
+    // matched — so filtering commands like "toggle theme" doesn't sprout a
+    // spurious navigation row.
+    const trimmed = query.trim();
+    const looksLikeTarget =
+      /[.:/]/.test(trimmed) || trimmed.startsWith('at://') || trimmed.startsWith('did:');
+    if (trimmed.length >= 2 && (looksLikeTarget || list.length === 0)) {
+      const path = resolveSearchPath(query);
+      if (path) list.push({ kind: 'goto', query: trimmed, path });
+    }
+    return list;
+  }, [available, q, query]);
+
+  // Keep the highlight in range as the filtered list shrinks/grows.
+  const activeIndex = items.length === 0 ? -1 : Math.min(highlight, items.length - 1);
+
+  // Scroll the active row into view on selection changes.
+  useEffect(() => {
+    if (!open || activeIndex < 0) return;
+    const el = listRef.current?.querySelector<HTMLElement>(`[data-idx="${activeIndex}"]`);
+    el?.scrollIntoView({ block: 'nearest' });
+  }, [open, activeIndex]);
+
+  function runItem(item: Item | undefined) {
+    if (!item) return;
+    onClose();
+    if (item.kind === 'command') item.cmd.run();
+    else onNavigate(item.path);
+  }
+
+  function onKeyDown(e: KeyboardEvent<HTMLInputElement>) {
+    if (e.key === 'ArrowDown') {
+      e.preventDefault();
+      if (items.length === 0) return;
+      setHighlight((i) => (Math.min(i, items.length - 1) + 1) % items.length);
+    } else if (e.key === 'ArrowUp') {
+      e.preventDefault();
+      if (items.length === 0) return;
+      setHighlight((i) => {
+        const cur = Math.min(i, items.length - 1);
+        return cur <= 0 ? items.length - 1 : cur - 1;
+      });
+    } else if (e.key === 'Enter') {
+      e.preventDefault();
+      runItem(items[activeIndex]);
+    } else if (e.key === 'Escape' && query) {
+      // First Escape clears the query; a second closes the palette.
+      e.preventDefault();
+      setQuery('');
+      setHighlight(0);
+    }
+  }
+
+  return (
+    <dialog
+      ref={ref}
+      aria-label="Command palette"
+      className="cmdk-dialog"
+      onClick={(e) => {
+        if (e.target === ref.current) onClose();
+      }}
+    >
+      <div className="cmdk-panel">
+        <div className="cmdk-search">
+          <Search size={16} aria-hidden className="cmdk-search-icon" />
+          <input
+            ref={inputRef}
+            type="text"
+            role="combobox"
+            aria-expanded
+            aria-controls="cmdk-list"
+            aria-activedescendant={activeIndex >= 0 ? `cmdk-item-${activeIndex}` : undefined}
+            autoComplete="off"
+            autoCapitalize="none"
+            spellCheck={false}
+            placeholder="Search commands, or jump to a handle / at:// URI…"
+            value={query}
+            onChange={(e) => {
+              setQuery(e.target.value);
+              setHighlight(0);
+            }}
+            onKeyDown={onKeyDown}
+            className="cmdk-input"
+          />
+          <kbd className="kbd cmdk-esc">Esc</kbd>
+        </div>
+
+        <div className="cmdk-list" id="cmdk-list" role="listbox" ref={listRef}>
+          {items.length === 0 && (
+            <div className="cmdk-empty">No matching commands.</div>
+          )}
+          {items.map((item, i) => {
+            const isActive = i === activeIndex;
+            if (item.kind === 'goto') {
+              return (
+                <button
+                  key="__goto"
+                  type="button"
+                  role="option"
+                  id={`cmdk-item-${i}`}
+                  data-idx={i}
+                  aria-selected={isActive}
+                  className={`cmdk-item ${isActive ? 'is-active' : ''}`}
+                  onMouseMove={() => setHighlight(i)}
+                  onClick={() => runItem(item)}
+                >
+                  <span className="cmdk-item-icon">
+                    <Search size={16} aria-hidden />
+                  </span>
+                  <span className="cmdk-item-body">
+                    <span className="cmdk-item-label">
+                      Go to <span className="cmdk-item-query">{item.query}</span>
+                    </span>
+                    <span className="cmdk-item-desc">Open in the explorer</span>
+                  </span>
+                  <CornerDownLeft size={14} aria-hidden className="cmdk-item-enter" />
+                </button>
+              );
+            }
+            const { cmd } = item;
+            const Icon = cmd.icon;
+            const showHeader =
+              !q && (i === 0 || (items[i - 1]?.kind === 'command' &&
+                (items[i - 1] as { cmd: ResolvedCommand }).cmd.meta.group !== cmd.meta.group));
+            const groupLabel = COMMAND_GROUPS.find((g) => g.id === cmd.meta.group)?.label;
+            return (
+              <Fragment key={cmd.meta.id}>
+                {showHeader && <div className="cmdk-group-label">{groupLabel}</div>}
+                <button
+                  type="button"
+                  role="option"
+                  id={`cmdk-item-${i}`}
+                  data-idx={i}
+                  aria-selected={isActive}
+                  className={`cmdk-item ${isActive ? 'is-active' : ''}`}
+                  onMouseMove={() => setHighlight(i)}
+                  onClick={() => runItem(item)}
+                >
+                  <span className="cmdk-item-icon">
+                    <Icon size={16} aria-hidden />
+                  </span>
+                  <span className="cmdk-item-body">
+                    <span className="cmdk-item-label">{cmd.meta.label}</span>
+                    <span className="cmdk-item-desc">{cmd.meta.description}</span>
+                  </span>
+                  {cmd.bindings[0] && (
+                    <span className="cmdk-item-kbd">
+                      <Kbd binding={cmd.bindings[0]} platform={platform} />
+                    </span>
+                  )}
+                </button>
+              </Fragment>
+            );
+          })}
+        </div>
+
+        <div className="cmdk-footer">
+          <span className="cmdk-hint">
+            <kbd className="kbd">↑</kbd>
+            <kbd className="kbd">↓</kbd>
+            <span>navigate</span>
+          </span>
+          <span className="cmdk-hint">
+            <kbd className="kbd">↵</kbd>
+            <span>run</span>
+          </span>
+          <button
+            type="button"
+            className="cmdk-hint cmdk-hint-button"
+            onClick={() => {
+              onClose();
+              onOpenHelp();
+            }}
+          >
+            <kbd className="kbd">?</kbd>
+            <span>all shortcuts</span>
+          </button>
+        </div>
+      </div>
+    </dialog>
+  );
+}
diff --git a/src/components/Kbd.tsx b/src/components/Kbd.tsx
new file mode 100644
index 0000000..0de29e1
--- /dev/null
+++ b/src/components/Kbd.tsx
@@ -0,0 +1,63 @@
+'use client';
+
+import { Fragment } from 'react';
+import { bindingTokens, type Platform } from '@/lib/keybindings';
+
+/**
+ * Renders a binding string as styled `<kbd>` chips — one chip per key, a thin
+ * `+` between keys in the same step, and the word "then" between the steps of
+ * a chord (`g` then `h`). Styling lives in globals.css under `.kbd` / `.kbd-*`.
+ */
+export default function Kbd({
+  binding,
+  platform,
+}: {
+  binding: string;
+  platform: Platform;
+}) {
+  const steps = bindingTokens(binding, platform);
+  if (steps.length === 0) return null;
+  return (
+    <span className="kbd-combo">
+      {steps.map((tokens, si) => (
+        <Fragment key={si}>
+          {si > 0 && <span className="kbd-then">then</span>}
+          <span className="kbd-step">
+            {tokens.map((tok, ti) => (
+              <Fragment key={ti}>
+                {ti > 0 && <span className="kbd-plus">+</span>}
+                <kbd className="kbd">{tok}</kbd>
+              </Fragment>
+            ))}
+          </span>
+        </Fragment>
+      ))}
+    </span>
+  );
+}
+
+/**
+ * Render every effective binding for a command, separated by "or". Falls back
+ * to a muted "Not set" when the command is unbound.
+ */
+export function KbdList({
+  bindings,
+  platform,
+}: {
+  bindings: string[];
+  platform: Platform;
+}) {
+  if (bindings.length === 0) {
+    return <span className="kbd-unset">Not set</span>;
+  }
+  return (
+    <span className="kbd-list">
+      {bindings.map((b, i) => (
+        <Fragment key={b}>
+          {i > 0 && <span className="kbd-or">or</span>}
+          <Kbd binding={b} platform={platform} />
+        </Fragment>
+      ))}
+    </span>
+  );
+}
diff --git a/src/components/KeyboardShortcutsProvider.tsx b/src/components/KeyboardShortcutsProvider.tsx
new file mode 100644
index 0000000..accf870
--- /dev/null
+++ b/src/components/KeyboardShortcutsProvider.tsx
@@ -0,0 +1,485 @@
+'use client';
+
+import {
+  createContext,
+  useCallback,
+  useContext,
+  useEffect,
+  useMemo,
+  useRef,
+  useState,
+  type ReactNode,
+} from 'react';
+import { useRouter } from 'next/navigation';
+import {
+  BookOpen,
+  Command,
+  Compass,
+  Copy,
+  Download,
+  Home,
+  Keyboard,
+  Settings,
+  SunMoon,
+  Telescope,
+  User,
+  type LucideIcon,
+} from 'lucide-react';
+import { useAtprotoSession } from './AtprotoSessionProvider';
+import { encodeRepo } from '@/utils/atproto/urls';
+import {
+  applyTheme,
+  setStoredTheme,
+  THEME_STORAGE_KEY,
+  type Theme,
+} from '@/lib/theme';
+import {
+  COMMANDS,
+  DEFAULT_KEYBINDINGS_STATE,
+  KEYBINDINGS_STORAGE_KEY,
+  effectiveBindings,
+  eventToStep,
+  getPlatform,
+  normalizeBinding,
+  parseBinding,
+  readKeybindingsState,
+  writeKeybindingsState,
+  type CommandId,
+  type CommandMeta,
+  type KeybindingsState,
+  type Platform,
+} from '@/lib/keybindings';
+import CommandPalette from './CommandPalette';
+import ShortcutsHelp from './ShortcutsHelp';
+
+/** How long a chord waits for its next key before it gives up (ms). */
+const CHORD_TIMEOUT_MS = 1200;
+
+const COMMAND_ICONS: Record<CommandId, LucideIcon> = {
+  'command-palette': Command,
+  'shortcuts-help': Keyboard,
+  'toggle-theme': SunMoon,
+  'copy-link': Copy,
+  'go-home': Home,
+  'go-explore': Telescope,
+  'go-my-repo': User,
+  'go-links': Compass,
+  'go-extension': Download,
+  'go-docs': BookOpen,
+  'go-settings': Settings,
+};
+
+/** A catalog command with its runtime binding, icon, availability, action. */
+export type ResolvedCommand = {
+  meta: CommandMeta;
+  icon: LucideIcon;
+  /** Bindings in effect right now (override or defaults). */
+  bindings: string[];
+  /** False for auth-gated commands when signed out. */
+  available: boolean;
+  run: () => void;
+};
+
+type KeyboardShortcutsValue = {
+  state: KeybindingsState;
+  platform: Platform;
+  commands: ResolvedCommand[];
+  paletteOpen: boolean;
+  helpOpen: boolean;
+  openPalette: () => void;
+  closePalette: () => void;
+  openHelp: () => void;
+  closeHelp: () => void;
+  setBinding: (id: CommandId, binding: string) => void;
+  unbind: (id: CommandId) => void;
+  resetBinding: (id: CommandId) => void;
+  resetAll: () => void;
+  setEnabled: (v: boolean) => void;
+  setChords: (v: boolean) => void;
+  /** Settings pauses the global listener while capturing a new binding. */
+  setCaptureActive: (v: boolean) => void;
+  announce: (message: string) => void;
+};
+
+const Ctx = createContext<KeyboardShortcutsValue | null>(null);
+
+function isEditableTarget(el: EventTarget | null): boolean {
+  if (!el || !(el instanceof HTMLElement)) return false;
+  const tag = el.tagName;
+  if (tag === 'INPUT' || tag === 'TEXTAREA' || tag === 'SELECT') return true;
+  if (el.isContentEditable) return true;
+  const role = el.getAttribute('role');
+  return role === 'textbox' || role === 'searchbox' || role === 'combobox';
+}
+
+function arrEq(a: string[], b: string[]): boolean {
+  if (a.length !== b.length) return false;
+  for (let i = 0; i < a.length; i++) if (a[i] !== b[i]) return false;
+  return true;
+}
+
+/**
+ * Global keyboard-shortcut engine. Owns the browser-local keybinding state,
+ * runs the single window-level keydown listener (with chord buffering), and
+ * renders the command palette, the shortcuts help sheet, and a small live
+ * announcer for hotkey feedback.
+ *
+ * Mounted once in the root layout, inside the session + preferences providers
+ * so commands can navigate and read the signed-in DID.
+ */
+export function KeyboardShortcutsProvider({ children }: { children: ReactNode }) {
+  const router = useRouter();
+  const { did } = useAtprotoSession();
+
+  const [state, setState] = useState<KeybindingsState>(DEFAULT_KEYBINDINGS_STATE);
+  const [platform, setPlatform] = useState<Platform>('other');
+  const [paletteOpen, setPaletteOpen] = useState(false);
+  const [helpOpen, setHelpOpen] = useState(false);
+  const [toast, setToast] = useState<string | null>(null);
+  const toastTimer = useRef<ReturnType<typeof setTimeout> | null>(null);
+
+  // Hydrate browser-local state + platform after mount (SSR renders defaults).
+  // Deferred a tick so the state updates land outside the synchronous effect
+  // body — the shortcuts are on-by-default, so nothing observable waits on it.
+  useEffect(() => {
+    const id = window.setTimeout(() => {
+      setState(readKeybindingsState());
+      setPlatform(getPlatform());
+    }, 0);
+    return () => window.clearTimeout(id);
+  }, []);
+
+  // Cross-tab sync: mirror edits made in another tab.
+  useEffect(() => {
+    function onStorage(e: StorageEvent) {
+      if (e.key === KEYBINDINGS_STORAGE_KEY) setState(readKeybindingsState());
+    }
+    window.addEventListener('storage', onStorage);
+    return () => window.removeEventListener('storage', onStorage);
+  }, []);
+
+  const announce = useCallback((message: string) => {
+    setToast(message);
+    if (toastTimer.current) clearTimeout(toastTimer.current);
+    toastTimer.current = setTimeout(() => setToast(null), 2200);
+  }, []);
+
+  useEffect(() => {
+    return () => {
+      if (toastTimer.current) clearTimeout(toastTimer.current);
+    };
+  }, []);
+
+  const openPalette = useCallback(() => {
+    setHelpOpen(false);
+    setPaletteOpen(true);
+  }, []);
+  const closePalette = useCallback(() => setPaletteOpen(false), []);
+  const openHelp = useCallback(() => {
+    setPaletteOpen(false);
+    setHelpOpen(true);
+  }, []);
+  const closeHelp = useCallback(() => setHelpOpen(false), []);
+
+  // --- state mutators (write-through to localStorage) ----------------------
+  const setBinding = useCallback((id: CommandId, binding: string) => {
+    setState((prev) => {
+      const next: KeybindingsState = {
+        ...prev,
+        overrides: { ...prev.overrides, [id]: normalizeBinding(binding) },
+      };
+      writeKeybindingsState(next);
+      return next;
+    });
+  }, []);
+  const unbind = useCallback((id: CommandId) => {
+    setState((prev) => {
+      const next: KeybindingsState = {
+        ...prev,
+        overrides: { ...prev.overrides, [id]: '' },
+      };
+      writeKeybindingsState(next);
+      return next;
+    });
+  }, []);
+  const resetBinding = useCallback((id: CommandId) => {
+    setState((prev) => {
+      const overrides = { ...prev.overrides };
+      delete overrides[id];
+      const next: KeybindingsState = { ...prev, overrides };
+      writeKeybindingsState(next);
+      return next;
+    });
+  }, []);
+  const resetAll = useCallback(() => {
+    setState((prev) => {
+      const next: KeybindingsState = { ...prev, overrides: {} };
+      writeKeybindingsState(next);
+      return next;
+    });
+  }, []);
+  const setEnabled = useCallback((v: boolean) => {
+    setState((prev) => {
+      const next = { ...prev, enabled: v };
+      writeKeybindingsState(next);
+      return next;
+    });
+  }, []);
+  const setChords = useCallback((v: boolean) => {
+    setState((prev) => {
+      const next = { ...prev, chords: v };
+      writeKeybindingsState(next);
+      return next;
+    });
+  }, []);
+
+  // Settings toggles this off/on around live key capture so the global
+  // listener doesn't swallow the keys being recorded. A ref (not state) —
+  // the listener reads it synchronously and it drives no rendering.
+  const captureActiveRef = useRef(false);
+  const setCaptureActive = useCallback((v: boolean) => {
+    captureActiveRef.current = v;
+  }, []);
+
+  const toggleTheme = useCallback((): Theme => {
+    const current: Theme =
+      document.documentElement.dataset.theme === 'light' ? 'light' : 'dark';
+    const next: Theme = current === 'dark' ? 'light' : 'dark';
+    setStoredTheme(next);
+    applyTheme(next);
+    // Same-tab storage events don't fire; nudge subscribers (ThemeToggle etc).
+    window.dispatchEvent(
+      new StorageEvent('storage', { key: THEME_STORAGE_KEY, newValue: next }),
+    );
+    return next;
+  }, []);
+
+  const copyLink = useCallback(async () => {
+    try {
+      await navigator.clipboard.writeText(window.location.href);
+      announce('Page link copied');
+    } catch {
+      announce('Couldn’t copy link');
+    }
+  }, [announce]);
+
+  const commands = useMemo<ResolvedCommand[]>(() => {
+    const runners: Record<CommandId, () => void> = {
+      'command-palette': () => openPalette(),
+      'shortcuts-help': () => openHelp(),
+      'toggle-theme': () => {
+        const next = toggleTheme();
+        announce(`Switched to ${next} theme`);
+      },
+      'copy-link': () => {
+        void copyLink();
+      },
+      'go-home': () => router.push('/'),
+      'go-explore': () => router.push('/explore'),
+      'go-my-repo': () => {
+        if (did) router.push(`/explore/${encodeRepo(did)}`);
+      },
+      'go-links': () => router.push('/links'),
+      'go-extension': () => router.push('/extension'),
+      'go-docs': () => router.push('/docs'),
+      'go-settings': () => router.push('/account'),
+    };
+    return COMMANDS.map((meta) => ({
+      meta,
+      icon: COMMAND_ICONS[meta.id],
+      bindings: effectiveBindings(state, meta.id),
+      available: meta.requiresAuth ? Boolean(did) : true,
+      run: runners[meta.id],
+    }));
+  }, [state, did, router, openPalette, openHelp, toggleTheme, copyLink, announce]);
+
+  // Live snapshot for the window listener so it never needs re-subscribing.
+  // Updated in a post-render effect (not during render) so the ref write
+  // doesn't race the commit.
+  const liveRef = useRef({ state, commands, paletteOpen, helpOpen });
+  useEffect(() => {
+    liveRef.current = { state, commands, paletteOpen, helpOpen };
+  });
+
+  // The single global keydown listener. Subscribed once; reads everything it
+  // needs from refs.
+  useEffect(() => {
+    const platformNow = getPlatform();
+    let buffer: string[] = [];
+    let timer: ReturnType<typeof setTimeout> | null = null;
+
+    function clearBuffer() {
+      buffer = [];
+      if (timer) {
+        clearTimeout(timer);
+        timer = null;
+      }
+    }
+
+    function fire(id: CommandId) {
+      const cmd = liveRef.current.commands.find((c) => c.meta.id === id);
+      if (cmd && cmd.available) cmd.run();
+    }
+
+    function onKeyDown(e: KeyboardEvent) {
+      const live = liveRef.current;
+      if (!live.state.enabled) return;
+      if (captureActiveRef.current) return; // settings is recording a binding
+      if (live.paletteOpen || live.helpOpen) return; // a modal owns the keyboard
+      if (e.defaultPrevented) return;
+
+      const step = eventToStep(e, platformNow);
+      if (!step) return;
+
+      const editable = isEditableTarget(e.target);
+      const hasAccel = e.metaKey || e.ctrlKey || e.altKey;
+      // While typing in a field, only accelerator-led shortcuts (⌘K etc.) run;
+      // bare letters and chords must not steal the keystroke.
+      if (editable && !hasAccel) {
+        clearBuffer();
+        return;
+      }
+
+      // Build the currently-active (command, steps) entries.
+      const entries: { id: CommandId; steps: string[] }[] = [];
+      for (const cmd of live.commands) {
+        if (!cmd.available) continue;
+        for (const binding of cmd.bindings) {
+          const steps = parseBinding(binding);
+          if (steps.length === 0) continue;
+          if (!live.state.chords && steps.length > 1) continue;
+          entries.push({ id: cmd.meta.id, steps });
+        }
+      }
+
+      const findFull = (buf: string[]) => entries.filter((en) => arrEq(en.steps, buf));
+      const findPrefix = (buf: string[]) =>
+        entries.filter(
+          (en) => en.steps.length > buf.length && arrEq(en.steps.slice(0, buf.length), buf),
+        );
+
+      let next = [...buffer, step];
+      let full = findFull(next);
+      let prefix = findPrefix(next);
+
+      // If extending the buffer leads nowhere, restart from this key alone.
+      if (full.length === 0 && prefix.length === 0) {
+        next = [step];
+        full = findFull(next);
+        prefix = findPrefix(next);
+      }
+
+      // Nothing matches — let the key through untouched.
+      if (full.length === 0 && prefix.length === 0) {
+        clearBuffer();
+        return;
+      }
+
+      e.preventDefault();
+
+      if (prefix.length > 0) {
+        // A longer chord is still possible; wait for the next key. On timeout,
+        // settle for a full match at the current depth if one exists.
+        buffer = next;
+        if (timer) clearTimeout(timer);
+        timer = setTimeout(() => {
+          const settle = findFull(buffer);
+          clearBuffer();
+          if (settle.length > 0) fire(settle[0].id);
+        }, CHORD_TIMEOUT_MS);
+        return;
+      }
+
+      // Unambiguous full match.
+      clearBuffer();
+      fire(full[0].id);
+    }
+
+    window.addEventListener('keydown', onKeyDown);
+    return () => {
+      window.removeEventListener('keydown', onKeyDown);
+      if (timer) clearTimeout(timer);
+    };
+  }, []);
+
+  const value = useMemo<KeyboardShortcutsValue>(
+    () => ({
+      state,
+      platform,
+      commands,
+      paletteOpen,
+      helpOpen,
+      openPalette,
+      closePalette,
+      openHelp,
+      closeHelp,
+      setBinding,
+      unbind,
+      resetBinding,
+      resetAll,
+      setEnabled,
+      setChords,
+      setCaptureActive,
+      announce,
+    }),
+    [
+      state,
+      platform,
+      commands,
+      paletteOpen,
+      helpOpen,
+      openPalette,
+      closePalette,
+      openHelp,
+      closeHelp,
+      setBinding,
+      unbind,
+      resetBinding,
+      resetAll,
+      setEnabled,
+      setChords,
+      setCaptureActive,
+      announce,
+    ],
+  );
+
+  return (
+    <Ctx.Provider value={value}>
+      {children}
+      <CommandPalette
+        open={paletteOpen}
+        onClose={closePalette}
+        commands={commands}
+        platform={platform}
+        onNavigate={(path) => router.push(path)}
+        onOpenHelp={openHelp}
+      />
+      <ShortcutsHelp
+        open={helpOpen}
+        onClose={closeHelp}
+        commands={commands}
+        platform={platform}
+      />
+      {/* Live region for hotkey feedback (copy, theme). Visually a transient
+          pill; always present in the DOM so screen readers announce it. */}
+      <div className="kbd-live-region" role="status" aria-live="polite">
+        {toast}
+      </div>
+      {toast && (
+        <div className="kbd-toast" aria-hidden="true">
+          {toast}
+        </div>
+      )}
+    </Ctx.Provider>
+  );
+}
+
+export function useKeyboardShortcuts(): KeyboardShortcutsValue {
+  const v = useContext(Ctx);
+  if (!v) {
+    throw new Error(
+      'useKeyboardShortcuts must be used inside <KeyboardShortcutsProvider>',
+    );
+  }
+  return v;
+}
diff --git a/src/components/ShortcutsHelp.tsx b/src/components/ShortcutsHelp.tsx
new file mode 100644
index 0000000..7884563
--- /dev/null
+++ b/src/components/ShortcutsHelp.tsx
@@ -0,0 +1,110 @@
+'use client';
+
+import { useEffect, useRef } from 'react';
+import Link from 'next/link';
+import { Settings, X } from 'lucide-react';
+import { COMMAND_GROUPS, type Platform } from '@/lib/keybindings';
+import { KbdList } from './Kbd';
+import type { ResolvedCommand } from './KeyboardShortcutsProvider';
+
+/**
+ * The `?` keyboard-shortcuts cheat sheet — a read-only reference grouped the
+ * same way as the settings tab. Actionable navigation lives in the command
+ * palette; this is purely "what are the keys". Native <dialog> for the focus
+ * trap + Escape, styled via globals.css `.cmdk-*` / `.shortcuts-*`.
+ */
+export default function ShortcutsHelp({
+  open,
+  onClose,
+  commands,
+  platform,
+}: {
+  open: boolean;
+  onClose: () => void;
+  commands: ResolvedCommand[];
+  platform: Platform;
+}) {
+  const ref = useRef<HTMLDialogElement>(null);
+
+  useEffect(() => {
+    const dlg = ref.current;
+    if (!dlg) return;
+    if (open && !dlg.open) dlg.showModal();
+    else if (!open && dlg.open) dlg.close();
+  }, [open]);
+
+  useEffect(() => {
+    const dlg = ref.current;
+    if (!dlg) return;
+    const handleClose = () => onClose();
+    dlg.addEventListener('close', handleClose);
+    return () => dlg.removeEventListener('close', handleClose);
+  }, [onClose]);
+
+  return (
+    <dialog
+      ref={ref}
+      aria-label="Keyboard shortcuts"
+      className="cmdk-dialog"
+      onClick={(e) => {
+        if (e.target === ref.current) onClose();
+      }}
+    >
+      <div className="cmdk-panel shortcuts-panel">
+        <div className="shortcuts-head">
+          <div>
+            <h2 className="shortcuts-title">Keyboard shortcuts</h2>
+            <p className="shortcuts-sub">
+              Press <kbd className="kbd">?</kbd> any time to open this list.
+            </p>
+          </div>
+          <button
+            type="button"
+            onClick={onClose}
+            aria-label="Close keyboard shortcuts"
+            className="shortcuts-close"
+          >
+            <X size={18} aria-hidden />
+          </button>
+        </div>
+
+        <div className="shortcuts-body">
+          {COMMAND_GROUPS.map((group) => {
+            const rows = commands.filter(
+              (c) => c.meta.group === group.id && c.available,
+            );
+            if (rows.length === 0) return null;
+            return (
+              <section key={group.id} className="shortcuts-group">
+                <h3 className="shortcuts-group-label">{group.label}</h3>
+                <ul className="shortcuts-rows">
+                  {rows.map((cmd) => {
+                    const Icon = cmd.icon;
+                    return (
+                      <li key={cmd.meta.id} className="shortcuts-row">
+                        <span className="shortcuts-row-icon">
+                          <Icon size={15} aria-hidden />
+                        </span>
+                        <span className="shortcuts-row-label">{cmd.meta.label}</span>
+                        <span className="shortcuts-row-keys">
+                          <KbdList bindings={cmd.bindings} platform={platform} />
+                        </span>
+                      </li>
+                    );
+                  })}
+                </ul>
+              </section>
+            );
+          })}
+        </div>
+
+        <div className="shortcuts-foot">
+          <Link href="/account#keyboard" className="shortcuts-customize" onClick={onClose}>
+            <Settings size={14} aria-hidden />
+            <span>Customize shortcuts in settings</span>
+          </Link>
+        </div>
+      </div>
+    </dialog>
+  );
+}
diff --git a/src/components/account/SettingsShell.tsx b/src/components/account/SettingsShell.tsx
index 55f4080..2d908c8 100644
--- a/src/components/account/SettingsShell.tsx
+++ b/src/components/account/SettingsShell.tsx
@@ -5,16 +5,25 @@ import { CloudOff } from 'lucide-react';
 import { useAtprotoSession } from '@/components/AtprotoSessionProvider';
 import AccountTab from './tabs/AccountTab';
 import GeneralTab from './tabs/GeneralTab';
+import KeyboardTab from './tabs/KeyboardTab';
 import SectionsTab from './tabs/SectionsTab';
 import WaypointsTab from './tabs/WaypointsTab';
 import CustomTab from './tabs/CustomTab';
 import AboutTab from './tabs/AboutTab';
 
-type TabId = 'account' | 'general' | 'sections' | 'waypoints' | 'custom' | 'about';
+type TabId =
+  | 'account'
+  | 'general'
+  | 'keyboard'
+  | 'sections'
+  | 'waypoints'
+  | 'custom'
+  | 'about';
 
 const TABS: { id: TabId; label: string }[] = [
   { id: 'account', label: 'Account' },
   { id: 'general', label: 'General' },
+  { id: 'keyboard', label: 'Keyboard' },
   { id: 'sections', label: 'Sections' },
   { id: 'waypoints', label: 'Waypoints' },
   { id: 'custom', label: 'Custom' },
@@ -24,6 +33,7 @@ const TABS: { id: TabId; label: string }[] = [
 const HASH_TO_TAB: Record<string, TabId> = {
   account: 'account',
   general: 'general',
+  keyboard: 'keyboard',
   sections: 'sections',
   waypoints: 'waypoints',
   custom: 'custom',
@@ -91,6 +101,7 @@ export default function SettingsShell() {
       <main className="settings-content">
         {tab === 'account' && <AccountTab />}
         {tab === 'general' && <GeneralTab />}
+        {tab === 'keyboard' && <KeyboardTab />}
         {tab === 'sections' && <SectionsTab />}
         {tab === 'waypoints' && <WaypointsTab />}
         {tab === 'custom' && <CustomTab />}
diff --git a/src/components/account/tabs/KeyboardTab.tsx b/src/components/account/tabs/KeyboardTab.tsx
new file mode 100644
index 0000000..31d3054
--- /dev/null
+++ b/src/components/account/tabs/KeyboardTab.tsx
@@ -0,0 +1,390 @@
+'use client';
+
+import { useEffect, useRef, useState, type KeyboardEvent } from 'react';
+import { Command as CommandIcon, Keyboard, RotateCcw } from 'lucide-react';
+import { useKeyboardShortcuts } from '@/components/KeyboardShortcutsProvider';
+import Toggle from '../Toggle';
+import Kbd, { KbdList } from '@/components/Kbd';
+import {
+  COMMAND_GROUPS,
+  bindingConflicts,
+  eventToStep,
+  normalizeBinding,
+  type CommandId,
+  type Platform,
+} from '@/lib/keybindings';
+
+/** Auto-commit a recorded chord after this idle gap (ms). */
+const RECORD_COMMIT_MS = 900;
+
+/**
+ * Keyboard settings — enable/disable shortcuts, toggle navigation chords, and
+ * rebind every command. Bindings are browser-local (not synced to the PDS):
+ * they're a per-device, per-layout choice, so they live in localStorage like
+ * the theme / font-scale / accessibility toggles.
+ */
+export default function KeyboardTab() {
+  const {
+    state,
+    platform,
+    commands,
+    setEnabled,
+    setChords,
+    resetAll,
+    openPalette,
+    openHelp,
+  } = useKeyboardShortcuts();
+
+  const conflicts = bindingConflicts(state);
+  const anyCustomized = Object.keys(state.overrides).length > 0;
+
+  return (
+    <>
+      <section className="settings-card">
+        <div className="settings-card-head">
+          <h2 className="settings-card-title">Keyboard shortcuts</h2>
+          <p className="settings-card-sub">
+            Fast keyboard access for desktop. Press{' '}
+            <kbd className="kbd">?</kbd> anywhere for the cheat sheet, or open the
+            command palette with <Kbd binding="mod+k" platform={platform} />.
+            These bindings are saved in this browser, not synced to your PDS —
+            keyboards and layouts differ per device.
+          </p>
+        </div>
+
+        <div className="kb-launchers">
+          <button type="button" className="kb-launch-button" onClick={openPalette}>
+            <CommandIcon size={15} aria-hidden />
+            <span>Open command palette</span>
+          </button>
+          <button type="button" className="kb-launch-button" onClick={openHelp}>
+            <Keyboard size={15} aria-hidden />
+            <span>Show all shortcuts</span>
+          </button>
+        </div>
+
+        <Toggle
+          id="keyboard-enabled"
+          label="Enable keyboard shortcuts"
+          description="Master switch. When off, no global shortcut fires (the settings below are kept for when you turn it back on)."
+          checked={state.enabled}
+          onChange={setEnabled}
+        />
+        <Toggle
+          id="keyboard-chords"
+          label="Navigation chords"
+          description="Two-key sequences like “g then e” to jump around. Turn off if you'd rather only use single-key and modifier shortcuts."
+          checked={state.chords}
+          onChange={setChords}
+          disabled={!state.enabled}
+        />
+      </section>
+
+      <section
+        className="settings-card"
+        style={state.enabled ? undefined : { opacity: 0.55 }}
+      >
+        <div className="settings-card-head">
+          <h2 className="settings-card-title">Bindings</h2>
+          <p className="settings-card-sub">
+            Click <em>Edit</em> and press the keys you want. Chords are supported
+            — press one key, then another. <kbd className="kbd">Enter</kbd> saves,{' '}
+            <kbd className="kbd">Esc</kbd> cancels, <kbd className="kbd">⌫</kbd>{' '}
+            removes the last key.
+          </p>
+        </div>
+
+        {COMMAND_GROUPS.map((group) => {
+          const rows = commands.filter((c) => c.meta.group === group.id);
+          if (rows.length === 0) return null;
+          return (
+            <div key={group.id} className="kb-group">
+              <h3 className="kb-group-label">{group.label}</h3>
+              <ul className="kb-rows">
+                {rows.map((cmd) => (
+                  <BindingRow
+                    key={cmd.meta.id}
+                    id={cmd.meta.id}
+                    icon={cmd.icon}
+                    label={cmd.meta.label}
+                    description={cmd.meta.description}
+                    bindings={cmd.bindings}
+                    requiresAuth={Boolean(cmd.meta.requiresAuth)}
+                    available={cmd.available}
+                    platform={platform}
+                    chords={state.chords}
+                    customized={state.overrides[cmd.meta.id] !== undefined}
+                    conflictLabels={conflictLabelsFor(cmd.meta.id, cmd.bindings, conflicts, commands)}
+                    disabled={!state.enabled}
+                  />
+                ))}
+              </ul>
+            </div>
+          );
+        })}
+
+        <div className="kb-reset-all">
+          <button
+            type="button"
+            className="kb-text-button"
+            onClick={resetAll}
+            disabled={!anyCustomized}
+          >
+            <RotateCcw size={13} aria-hidden />
+            <span>Reset all to defaults</span>
+          </button>
+        </div>
+      </section>
+    </>
+  );
+}
+
+/** Labels of the *other* commands a binding collides with. */
+function conflictLabelsFor(
+  id: CommandId,
+  bindings: string[],
+  conflicts: Map<string, CommandId[]>,
+  commands: { meta: { id: CommandId; label: string } }[],
+): string[] {
+  const labels = new Set<string>();
+  for (const binding of bindings) {
+    const ids = conflicts.get(binding);
+    if (!ids) continue;
+    for (const other of ids) {
+      if (other === id) continue;
+      const meta = commands.find((c) => c.meta.id === other)?.meta;
+      if (meta) labels.add(meta.label);
+    }
+  }
+  return [...labels];
+}
+
+function BindingRow({
+  id,
+  icon: Icon,
+  label,
+  description,
+  bindings,
+  requiresAuth,
+  available,
+  platform,
+  chords,
+  customized,
+  conflictLabels,
+  disabled,
+}: {
+  id: CommandId;
+  icon: React.ComponentType<{ size?: number; 'aria-hidden'?: boolean }>;
+  label: string;
+  description: string;
+  bindings: string[];
+  requiresAuth: boolean;
+  available: boolean;
+  platform: Platform;
+  chords: boolean;
+  customized: boolean;
+  conflictLabels: string[];
+  disabled: boolean;
+}) {
+  const { setBinding, resetBinding, unbind, setCaptureActive } = useKeyboardShortcuts();
+  const [editing, setEditing] = useState(false);
+
+  function startEditing() {
+    if (disabled) return;
+    setEditing(true);
+  }
+  function stopEditing() {
+    setEditing(false);
+  }
+
+  return (
+    <li className="kb-row">
+      <span className="kb-row-icon" aria-hidden>
+        <Icon size={15} aria-hidden />
+      </span>
+      <span className="kb-row-main">
+        <span className="kb-row-label">
+          {label}
+          {requiresAuth && !available && (
+            <span className="kb-row-note"> · requires sign-in</span>
+          )}
+        </span>
+        <span className="kb-row-desc">{description}</span>
+        {conflictLabels.length > 0 && (
+          <span className="kb-row-conflict">
+            Also bound to {conflictLabels.join(', ')}
+          </span>
+        )}
+      </span>
+
+      <span className="kb-row-keys">
+        {editing ? (
+          <BindingRecorder
+            platform={platform}
+            chords={chords}
+            onStart={() => setCaptureActive(true)}
+            onStop={() => setCaptureActive(false)}
+            onCommit={(binding) => {
+              setBinding(id, binding);
+              stopEditing();
+            }}
+            onCancel={stopEditing}
+          />
+        ) : (
+          <KbdList bindings={bindings} platform={platform} />
+        )}
+      </span>
+
+      <span className="kb-row-actions">
+        {editing ? (
+          <button type="button" className="kb-text-button" onClick={stopEditing}>
+            Cancel
+          </button>
+        ) : (
+          <>
+            <button
+              type="button"
+              className="kb-edit-button"
+              onClick={startEditing}
+              disabled={disabled}
+            >
+              Edit
+            </button>
+            {customized && (
+              <button
+                type="button"
+                className="kb-text-button"
+                onClick={() => resetBinding(id)}
+                disabled={disabled}
+                title="Reset to default"
+              >
+                Reset
+              </button>
+            )}
+            {bindings.length > 0 && (
+              <button
+                type="button"
+                className="kb-text-button"
+                onClick={() => unbind(id)}
+                disabled={disabled}
+                title="Remove binding"
+              >
+                Clear
+              </button>
+            )}
+          </>
+        )}
+      </span>
+    </li>
+  );
+}
+
+/**
+ * Captures a new binding. While mounted it flips the global listener off (via
+ * onStart/onStop) so recorded keys aren't also handled as live shortcuts. Each
+ * accepted key pushes a chord step; a short idle gap (or Enter) commits, Esc
+ * cancels, Backspace drops the last step.
+ */
+function BindingRecorder({
+  platform,
+  chords,
+  onStart,
+  onStop,
+  onCommit,
+  onCancel,
+}: {
+  platform: Platform;
+  chords: boolean;
+  onStart: () => void;
+  onStop: () => void;
+  onCommit: (binding: string) => void;
+  onCancel: () => void;
+}) {
+  const boxRef = useRef<HTMLDivElement>(null);
+  const [steps, setSteps] = useState<string[]>([]);
+  const commitTimer = useRef<ReturnType<typeof setTimeout> | null>(null);
+  // Keep the latest steps reachable from the timer without re-arming effects.
+  const stepsRef = useRef<string[]>([]);
+  stepsRef.current = steps;
+
+  useEffect(() => {
+    onStart();
+    boxRef.current?.focus();
+    return () => {
+      onStop();
+      if (commitTimer.current) clearTimeout(commitTimer.current);
+    };
+    // Run once for the lifetime of the recorder.
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, []);
+
+  function commit(list: string[]) {
+    if (commitTimer.current) {
+      clearTimeout(commitTimer.current);
+      commitTimer.current = null;
+    }
+    const binding = normalizeBinding(list.join(' '));
+    if (binding) onCommit(binding);
+    else onCancel();
+  }
+
+  function armCommit() {
+    if (commitTimer.current) clearTimeout(commitTimer.current);
+    commitTimer.current = setTimeout(() => commit(stepsRef.current), RECORD_COMMIT_MS);
+  }
+
+  function onKeyDown(e: KeyboardEvent<HTMLDivElement>) {
+    e.preventDefault();
+    e.stopPropagation();
+
+    if (e.key === 'Escape') {
+      onCancel();
+      return;
+    }
+    if (e.key === 'Enter') {
+      if (stepsRef.current.length > 0) commit(stepsRef.current);
+      else onCancel();
+      return;
+    }
+    if (e.key === 'Backspace') {
+      if (commitTimer.current) clearTimeout(commitTimer.current);
+      setSteps((prev) => prev.slice(0, -1));
+      return;
+    }
+
+    const step = eventToStep(e.nativeEvent, platform);
+    if (!step) return; // bare modifier — wait for the real key
+
+    if (!chords) {
+      // Single-step mode: the first key is the whole binding.
+      commit([step]);
+      return;
+    }
+    setSteps((prev) => {
+      const next = [...prev, step];
+      return next;
+    });
+    armCommit();
+  }
+
+  return (
+    <div className="kb-recorder">
+      <div
+        ref={boxRef}
+        className="kb-recorder-box"
+        role="textbox"
+        aria-label="Press keys to set the shortcut"
+        tabIndex={0}
+        onKeyDown={onKeyDown}
+        onBlur={onCancel}
+      >
+        {steps.length === 0 ? (
+          <span className="kb-recorder-hint">Press keys…</span>
+        ) : (
+          <Kbd binding={steps.join(' ')} platform={platform} />
+        )}
+      </div>
+      <span className="kb-recorder-help">Enter saves · Esc cancels</span>
+    </div>
+  );
+}
diff --git a/src/lib/keybindings.ts b/src/lib/keybindings.ts
new file mode 100644
index 0000000..e85ceb8
--- /dev/null
+++ b/src/lib/keybindings.ts
@@ -0,0 +1,424 @@
+/**
+ * Keyboard shortcut engine + command catalog.
+ *
+ * Desktop keyboard shortcuts are browser-local (like theme / font-scale /
+ * a11y), not synced to the PDS: a binding that feels right on one keyboard
+ * layout may collide on another, so the customization lives per-device in
+ * localStorage under `aturi.keybindings.v1`.
+ *
+ * A *binding* is a normalized string:
+ *
+ *   - A single step:  `mod+k`, `mod+shift+c`, `?`, `/`, `t`
+ *   - A chord (sequence of steps, GitHub/Linear style):  `g h`, `g e`
+ *
+ * `mod` is the platform-primary accelerator — ⌘ on macOS, Ctrl elsewhere —
+ * so one default works cross-platform. Modifiers are always emitted in the
+ * canonical order `mod ctrl meta alt shift` so a binding produced from a live
+ * KeyboardEvent string-compares equal to a stored one.
+ *
+ * This module is pure (no React, no lucide) so the command catalog and the
+ * matching logic stay unit-testable and SSR-safe; the runtime wiring (actions,
+ * icons, the global listener) lives in KeyboardShortcutsProvider.
+ */
+
+export const KEYBINDINGS_STORAGE_KEY = 'aturi.keybindings.v1';
+
+export type Platform = 'mac' | 'other';
+
+/** Every command the shortcut engine and command palette know about. */
+export type CommandId =
+  | 'command-palette'
+  | 'shortcuts-help'
+  | 'toggle-theme'
+  | 'copy-link'
+  | 'go-home'
+  | 'go-explore'
+  | 'go-links'
+  | 'go-docs'
+  | 'go-extension'
+  | 'go-settings'
+  | 'go-my-repo';
+
+export type CommandGroup = 'general' | 'navigation' | 'page';
+
+export type CommandMeta = {
+  id: CommandId;
+  /** Human label, shown in the palette, help sheet, and settings. */
+  label: string;
+  /** One-line description for the settings row and palette subtitle. */
+  description: string;
+  group: CommandGroup;
+  /**
+   * Zero or more default bindings. All of them fire out of the box; a user
+   * override (see `KeybindingsState.overrides`) replaces the whole set with a
+   * single binding, or the empty string to unbind entirely.
+   */
+  defaultBindings: string[];
+  /** Extra terms the palette fuzzy-search matches against. */
+  keywords?: string[];
+  /** Command only does something for a signed-in user (e.g. "my repo"). */
+  requiresAuth?: boolean;
+};
+
+export const COMMAND_GROUPS: { id: CommandGroup; label: string }[] = [
+  { id: 'general', label: 'General' },
+  { id: 'navigation', label: 'Navigation' },
+  { id: 'page', label: 'Current page' },
+];
+
+/**
+ * The command catalog. Ordering here is the display order within each group
+ * and the tie-break order when two commands share a binding (first wins).
+ */
+export const COMMANDS: CommandMeta[] = [
+  {
+    id: 'command-palette',
+    label: 'Command palette',
+    description: 'Search commands and jump anywhere.',
+    group: 'general',
+    defaultBindings: ['mod+k', '/'],
+    keywords: ['search', 'command', 'palette', 'jump', 'goto', 'find'],
+  },
+  {
+    id: 'shortcuts-help',
+    label: 'Keyboard shortcuts',
+    description: 'Show this list of shortcuts.',
+    group: 'general',
+    defaultBindings: ['?'],
+    keywords: ['help', 'keys', 'cheat sheet', 'shortcuts'],
+  },
+  {
+    id: 'toggle-theme',
+    label: 'Toggle theme',
+    description: 'Switch between dark and light.',
+    group: 'general',
+    defaultBindings: ['t'],
+    keywords: ['dark', 'light', 'appearance', 'theme', 'mode'],
+  },
+  {
+    id: 'go-home',
+    label: 'Go to home',
+    description: 'The aturi.to landing page.',
+    group: 'navigation',
+    defaultBindings: ['g h'],
+    keywords: ['home', 'landing', 'start'],
+  },
+  {
+    id: 'go-explore',
+    label: 'Go to explorer',
+    description: 'Browse any repo, collection, or record.',
+    group: 'navigation',
+    defaultBindings: ['g e'],
+    keywords: ['explore', 'explorer', 'browse', 'repo', 'pds'],
+  },
+  {
+    id: 'go-my-repo',
+    label: 'Go to my repo',
+    description: 'Open your own repo in the explorer.',
+    group: 'navigation',
+    defaultBindings: ['g m'],
+    keywords: ['my', 'repo', 'mine', 'me', 'account data'],
+    requiresAuth: true,
+  },
+  {
+    id: 'go-links',
+    label: 'Go to universal links',
+    description: 'The at:// universal link tools.',
+    group: 'navigation',
+    defaultBindings: ['g l'],
+    keywords: ['links', 'universal', 'share'],
+  },
+  {
+    id: 'go-extension',
+    label: 'Go to browser extension',
+    description: 'Install the client-switcher extension.',
+    group: 'navigation',
+    defaultBindings: ['g x'],
+    keywords: ['extension', 'browser', 'install', 'download'],
+  },
+  {
+    id: 'go-docs',
+    label: 'Go to docs',
+    description: 'Read the documentation.',
+    group: 'navigation',
+    defaultBindings: ['g d'],
+    keywords: ['docs', 'documentation', 'help', 'guide'],
+  },
+  {
+    id: 'go-settings',
+    label: 'Go to settings',
+    description: 'Your account and preferences.',
+    group: 'navigation',
+    defaultBindings: ['g s'],
+    keywords: ['settings', 'preferences', 'account', 'config'],
+  },
+  {
+    id: 'copy-link',
+    // Unbound by default: the obvious "copy" combo (⌘/Ctrl+Shift+C) is the
+    // browser's own inspect-element shortcut, which we can't reliably
+    // preventDefault. It stays in the palette and is fully bindable here — a
+    // good showcase for the customization the settings tab offers.
+    label: 'Copy page link',
+    description: 'Copy the current page URL to the clipboard.',
+    group: 'page',
+    defaultBindings: [],
+    keywords: ['copy', 'link', 'url', 'share', 'clipboard'],
+  },
+];
+
+export const COMMANDS_BY_ID: Record<CommandId, CommandMeta> = COMMANDS.reduce(
+  (acc, c) => {
+    acc[c.id] = c;
+    return acc;
+  },
+  {} as Record<CommandId, CommandMeta>,
+);
+
+// --- Persisted state -------------------------------------------------------
+
+export type KeybindingsState = {
+  /** Master switch. When off, no global shortcut fires. */
+  enabled: boolean;
+  /** Allow multi-step navigation chords (`g` then a letter). */
+  chords: boolean;
+  /**
+   * Per-command overrides. A present key replaces that command's default
+   * bindings with a single binding; the empty string means "unbound".
+   * Absent means "use the defaults".
+   */
+  overrides: Partial<Record<CommandId, string>>;
+};
+
+export const DEFAULT_KEYBINDINGS_STATE: KeybindingsState = {
+  enabled: true,
+  chords: true,
+  overrides: {},
+};
+
+function isCommandId(value: string): value is CommandId {
+  return Object.prototype.hasOwnProperty.call(COMMANDS_BY_ID, value);
+}
+
+/** Coerce an untrusted parsed blob into a valid state, dropping junk. */
+export function mergeKeybindingsState(
+  input: Partial<KeybindingsState> | null | undefined,
+): KeybindingsState {
+  if (!input || typeof input !== 'object') return { ...DEFAULT_KEYBINDINGS_STATE };
+  const overrides: Partial<Record<CommandId, string>> = {};
+  if (input.overrides && typeof input.overrides === 'object') {
+    for (const [id, binding] of Object.entries(input.overrides)) {
+      if (isCommandId(id) && typeof binding === 'string') {
+        overrides[id] = normalizeBinding(binding);
+      }
+    }
+  }
+  return {
+    enabled: typeof input.enabled === 'boolean' ? input.enabled : true,
+    chords: typeof input.chords === 'boolean' ? input.chords : true,
+    overrides,
+  };
+}
+
+export function readKeybindingsState(): KeybindingsState {
+  if (typeof window === 'undefined') return { ...DEFAULT_KEYBINDINGS_STATE };
+  try {
+    const raw = window.localStorage.getItem(KEYBINDINGS_STORAGE_KEY);
+    if (!raw) return { ...DEFAULT_KEYBINDINGS_STATE };
+    return mergeKeybindingsState(JSON.parse(raw) as Partial<KeybindingsState>);
+  } catch {
+    return { ...DEFAULT_KEYBINDINGS_STATE };
+  }
+}
+
+export function writeKeybindingsState(state: KeybindingsState): void {
+  if (typeof window === 'undefined') return;
+  try {
+    window.localStorage.setItem(KEYBINDINGS_STORAGE_KEY, JSON.stringify(state));
+  } catch {
+    // Quota exceeded or storage disabled — non-fatal.
+  }
+}
+
+/**
+ * The bindings actually in effect for a command: the override (as a
+ * one-element list, or empty when unbound) when present, else the defaults.
+ */
+export function effectiveBindings(state: KeybindingsState, id: CommandId): string[] {
+  const override = state.overrides[id];
+  if (override === undefined) return COMMANDS_BY_ID[id]?.defaultBindings ?? [];
+  return override === '' ? [] : [override];
+}
+
+// --- Platform --------------------------------------------------------------
+
+export function getPlatform(): Platform {
+  if (typeof navigator === 'undefined') return 'other';
+  // `userAgentData.platform` is the modern signal; fall back to the legacy
+  // `platform` string. Any Apple desktop/laptop maps to the ⌘ accelerator.
+  const nav = navigator as Navigator & {
+    userAgentData?: { platform?: string };
+  };
+  const raw =
+    nav.userAgentData?.platform || navigator.platform || navigator.userAgent || '';
+  return /mac|iphone|ipad|ipod/i.test(raw) ? 'mac' : 'other';
+}
+
+// --- Event → step ----------------------------------------------------------
+
+const MODIFIER_KEYS = new Set(['Shift', 'Control', 'Alt', 'Meta', 'AltGraph', 'CapsLock']);
+
+/**
+ * The base key for an event, plus whether its shift is "implied" (already
+ * baked into a printable symbol like `?`, so we must not also emit `shift`).
+ * Returns null for a bare modifier press.
+ */
+function baseKeyFromEvent(e: KeyboardEvent): { key: string; impliedShift: boolean } | null {
+  const k = e.key;
+  if (!k || MODIFIER_KEYS.has(k)) return null;
+  if (k === ' ' || k === 'Spacebar') return { key: 'space', impliedShift: false };
+  if (k.length === 1) {
+    // Printable character. Letters normalize to lowercase and let `shift` ride
+    // as a real modifier (so `mod+shift+c` round-trips); symbols keep the
+    // typed glyph, which already reflects the shift state (`?`, `<`, `:`).
+    if (/[a-zA-Z]/.test(k)) return { key: k.toLowerCase(), impliedShift: false };
+    return { key: k, impliedShift: true };
+  }
+  return { key: k.toLowerCase(), impliedShift: false };
+}
+
+/**
+ * Normalize a live KeyboardEvent into a canonical single-step string, or null
+ * when it can't be a shortcut (bare modifier / dead key / IME composition).
+ */
+export function eventToStep(e: KeyboardEvent, platform: Platform): string | null {
+  if (e.isComposing || e.keyCode === 229) return null;
+  const base = baseKeyFromEvent(e);
+  if (!base) return null;
+
+  const mods: string[] = [];
+  const primary = platform === 'mac' ? e.metaKey : e.ctrlKey;
+  if (primary) mods.push('mod');
+  // The non-primary accelerator is rare but valid (Ctrl on mac, ⊞ elsewhere).
+  if (platform === 'mac' && e.ctrlKey) mods.push('ctrl');
+  if (platform !== 'mac' && e.metaKey) mods.push('meta');
+  if (e.altKey) mods.push('alt');
+  if (e.shiftKey && !base.impliedShift) mods.push('shift');
+
+  return [...mods, base.key].join('+');
+}
+
+// --- Binding parse / normalize ---------------------------------------------
+
+const MOD_ORDER = ['mod', 'ctrl', 'meta', 'alt', 'shift'];
+
+/** Canonicalize a single step string (sort modifiers, lowercase letters). */
+function normalizeStep(step: string): string {
+  const parts = step.trim().split('+').filter(Boolean);
+  if (parts.length === 0) return '';
+  const key = parts[parts.length - 1];
+  const mods = parts.slice(0, -1).map((m) => m.toLowerCase());
+  const ordered = MOD_ORDER.filter((m) => mods.includes(m));
+  // A single-letter key normalizes to lowercase; everything else is kept.
+  const normKey = key.length === 1 && /[a-zA-Z]/.test(key) ? key.toLowerCase() : key;
+  return [...ordered, normKey].join('+');
+}
+
+/** Split a binding into its ordered list of canonical step strings. */
+export function parseBinding(binding: string): string[] {
+  return binding
+    .trim()
+    .split(/\s+/)
+    .filter(Boolean)
+    .map(normalizeStep)
+    .filter(Boolean);
+}
+
+/** Canonical string form of a binding (idempotent). */
+export function normalizeBinding(binding: string): string {
+  return parseBinding(binding).join(' ');
+}
+
+/** Whether a binding is a single step (no chord). */
+export function isSingleStep(binding: string): boolean {
+  return parseBinding(binding).length === 1;
+}
+
+// --- Display ---------------------------------------------------------------
+
+const MOD_DISPLAY: Record<string, Record<Platform, string>> = {
+  mod: { mac: '⌘', other: 'Ctrl' },
+  ctrl: { mac: '⌃', other: 'Ctrl' },
+  meta: { mac: '⌘', other: 'Win' },
+  alt: { mac: '⌥', other: 'Alt' },
+  shift: { mac: '⇧', other: 'Shift' },
+};
+
+const KEY_DISPLAY: Record<string, string> = {
+  space: 'Space',
+  enter: 'Enter',
+  escape: 'Esc',
+  arrowup: '↑',
+  arrowdown: '↓',
+  arrowleft: '←',
+  arrowright: '→',
+  backspace: '⌫',
+  delete: 'Del',
+  tab: 'Tab',
+};
+
+/** Human tokens for one step, e.g. `mod+shift+c` → ['⌘','⇧','C']. */
+export function stepTokens(step: string, platform: Platform): string[] {
+  const parts = parseBinding(step)[0]?.split('+') ?? [];
+  if (parts.length === 0) return [];
+  const key = parts[parts.length - 1];
+  const mods = parts.slice(0, -1);
+  const modTokens = mods.map((m) => MOD_DISPLAY[m]?.[platform] ?? m);
+  const keyToken =
+    KEY_DISPLAY[key] ?? (key.length === 1 ? key.toUpperCase() : key);
+  return [...modTokens, keyToken];
+}
+
+/** Human tokens for a whole binding: one token array per step. */
+export function bindingTokens(binding: string, platform: Platform): string[][] {
+  return parseBinding(binding).map((step) => stepTokens(step, platform));
+}
+
+// --- Conflicts -------------------------------------------------------------
+
+/**
+ * Map of binding-string → command ids that currently claim it. A command is
+ * in conflict when its binding appears against more than one id. Only the
+ * first command in catalog order actually fires (see the provider's matcher),
+ * so surfacing the collision lets the user resolve it deliberately.
+ */
+export function bindingConflicts(state: KeybindingsState): Map<string, CommandId[]> {
+  const byBinding = new Map<string, CommandId[]>();
+  for (const cmd of COMMANDS) {
+    for (const binding of effectiveBindings(state, cmd.id)) {
+      const list = byBinding.get(binding) ?? [];
+      list.push(cmd.id);
+      byBinding.set(binding, list);
+    }
+  }
+  const conflicts = new Map<string, CommandId[]>();
+  for (const [binding, ids] of byBinding) {
+    if (ids.length > 1) conflicts.set(binding, ids);
+  }
+  return conflicts;
+}
+
+/** Command ids (other than `self`) whose bindings collide with `binding`. */
+export function conflictingCommands(
+  state: KeybindingsState,
+  self: CommandId,
+  binding: string,
+): CommandId[] {
+  const normalized = normalizeBinding(binding);
+  if (!normalized) return [];
+  const hits: CommandId[] = [];
+  for (const cmd of COMMANDS) {
+    if (cmd.id === self) continue;
+    if (effectiveBindings(state, cmd.id).includes(normalized)) hits.push(cmd.id);
+  }
+  return hits;
+}