Single source of truth for "what keys do what, where, and why."
Outer opentui bindings live in packages/kobe/src/tui/context/keybindings.ts — KobeKeymap is the canonical table for those. Users can override most of them via ~/.kobe/settings/keybindings.yaml (see "User customization" below). Do not hardcode outer-TUI chord strings outside that table. Pane code reaches in via bindByIds({ id: handler }); the help dialog (F1) reads every row, while the status bar reads only rows whose friendly hint has not opted out with status: false. A single edit there is enough to update chord, Help copy, and footer eligibility.
Outer-monitor retirement (2026-06, docs/design/app-retirement.md). The opentui outer monitor (
app.tsx) is gone, and the keymap rows whose only registering surface died with it were removed:palette.open(the command palette itself was deleted),app.copy_or_quit(the Ctrl+C arm-to-quit machinery + its status-bar chip),focus.next/focus.prev(tab pane-cycling — pane focus is tmux's job now), andpane.resize-grow/pane.resize-shrink(the mouseResizableEdgewas the last resize surface). Rows that document live tmux-layer or pane-host behavior (focus.numeric,focus.sidebar, the Workspace chat/question rows, terminal rows) stay. References to those removed rows below in the historical decision log are kept as history.
Direct-tmux handover bindings are the explicit exception: they are real tmux server/window bindings installed by packages/kobe/src/tui/panes/terminal/tmux.ts. Their DEFAULT chords live in packages/kobe/src/tmux/keybindings.ts (TMUX_SINGLE_BINDING_DEFAULTS / TMUX_FOCUS_DEFAULTS, user-overridable via tmux.* ids — see "User customization" below), and the in-session Tasks pane footer (packages/kobe/src/tui/tasks-pane/host.tsx) renders from the same resolved set. Change a handover default in the defaults table, not at the install site.
There are four panes:
| Ordinal | Pane | scope value |
Focus chord |
|---|---|---|---|
| h | Sidebar (TASKS) | "sidebar" |
ctrl+h |
| j | Workspace (chat / files preview) | "workspace" |
ctrl+j |
| k | Files | "files" |
ctrl+k |
| l | Terminal | "terminal" |
ctrl+l |
ctrl+hjkl is global (scope: "global", id focus.numeric). It fires from any pane, including when the chat composer has the
keyboard. ctrl+letter chords map to stable C0 control bytes that every terminal sends without protocol negotiation, so the chord
works without iTerm CSI-u, kitty keyboard, tmux extended-keys, or any per-user setup. The only thing that suppresses it is an
open dialog — binding registrations include enabled: dialog.stack.length === 0 so dialog-internal keys
(esc to dismiss, enter to confirm) win on the dialog stack.
ctrl+q from workspace focus jumps back to the sidebar (focus.sidebar). esc is not a global "back to sidebar" — it
would yank focus out of the chat composer mid-edit. ESC is reserved for: closing the top dialog (DialogProvider) and
interrupting a streaming turn (Chat). Sidebar focus owns plain q (quit confirm) and plain n (new task).
- Global, modifier-prefixed (e.g.
ctrl+1..4,ctrl+,,ctrl+k,f1,ctrl+shift+q). Always-on. Modifier keys never reach the composer textarea, so they can't collide with typing. Default home for cross-pane app verbs. - Pane-scoped, plain letters (e.g. sidebar
n/q/s, files[/], terminalj/k). Single-character chords. Gated at the call site withenabled: focusedPane() === <scope>. Plain letters typed in the composer are LITERAL TEXT — the gate is what keeps them from intercepting input. - Doc-only (no chord registered, but a
KobeKeymaprow exists for help/status display). Used when the chord lives inside a renderable's own keybinding map (textarea'skeyBindingsprop, slash-dropdown'sonKeyDown). Examples:chat.send(enter),chat.newline(shift+enter),chat.steer(ctrl+enter).
Every plain-letter binding MUST be pane-scoped. Every global binding MUST be modifier-prefixed.
Violating this means the chord either steals composer typing (plain letter as global) or never fires (modifier-prefixed but
gated to one pane). When in doubt, look at the scope field on the keymap entry and the enabled predicate at the registration
site — they should agree.
| Chord | Overlap | Resolution |
|---|---|---|
ctrl+hjkl |
focus.numeric (global) — works without any terminal config |
Pane focus uses ctrl+hjkl (vim-style direction keys mapped onto pane ordinals h/j/k/l = sidebar/workspace/files/terminal). Why not ctrl+digit? ctrl+digit needs CSI-u / kitty keyboard support; even with kobe's useKittyKeyboard: {} enabled, iTerm2 has a quirk where ctrl+1 / ctrl+9 / ctrl+0 fall through to a bare digit byte while ctrl+2..8 emit CSI-u correctly. Why not alt+digit? Option+digit on macOS gets eaten by launchers like Raycast before reaching the terminal. ctrl+letter has stable C0 control byte mappings that every terminal sends, no protocol negotiation, no per-key quirks. |
ctrl+k palette vs focus |
palette.open moved to ctrl+p, then the palette was retired with the outer monitor |
ctrl+k was the palette chord, then the "focus files pane" chord (k = ordinal 3). The command palette is gone (2026-06 retirement); ctrl+k keeps its focus.numeric role. |
esc |
dialog dismiss vs chat interrupt | DialogProvider registers a higher-priority escape binding while a dialog is open; dialog pop wins. With no dialog and chat focused while streaming, chat.interrupt cancels the turn. Idle ESC is a no-op so the composer doesn't lose focus mid-edit. |
ctrl+c |
copy selection vs double-tap quit | RETIRED with the outer monitor (app.copy_or_quit + useKobeKeybindings are gone). In pane hosts ctrl+c is host-local (Ops/settings hosts exit); inside a Handover the terminal/tmux own it. |
ctrl+o |
shell flow-control history (^O) / editor-open convention |
Global "open active task in editor." We use a modifier chord because it must work from every pane without stealing composer text. The handler is a no-op when no active task or editor opener is available. |
tab |
pane cycle vs textarea focus actions | RETIRED — focus.next/focus.prev were removed with the outer monitor; tab reaches the focused renderable untouched. |
[ / ] |
sidebar view switch vs files tab cycle | Both pane-scoped (different scopes), so the focused pane wins. |
ctrl+[ / ctrl+] |
outer dialog sub-tab cycle vs tmux ChatTab cycle | In the outer TUI, the New Task dialog owns ctrl+[ / ctrl+] locally to switch its sub-tabs. Inside a Handover, the same chords are tmux no-prefix bindings on the dedicated -L kobe socket: previous / next ChatTab window. The old self-rendered chat-tab handler is stale; ChatTabs are tmux windows now. |
ctrl+w |
readline delete-word vs tmux ChatTab close | Inside a Handover, kobe restores the v0.5 close-tab chord as a tmux no-prefix binding. It closes the current ChatTab window only when another window remains; the final window is protected so ctrl+w cannot accidentally destroy the whole Task tmux Session. |
sidebar letter chords (j/k/g/G/d/a/r/P/m) vs /-search typing |
Letter chords are registered in a sidebar-scoped useBindings block gated enabled: focused() && !searchMode(). When / enters search mode the block de-registers, so subsequent letter keys fall through to the inline search input as literal text. [ / ] view switch lives in a separate always-on block and keeps firing during search. A second search-only block registers up/down (filtered-list nav), enter (commit), and esc (cancel + restore prior selection). |
kobe already enables opentui's kitty / CSI-u keyboard protocol with useKittyKeyboard: {}. That lets supporting terminals send
full modifier information for richer chords like shift+enter, ctrl+enter, ctrl+pageup, and ctrl-modified punctuation or
digits. tmux must be told to preserve those extended key sequences instead of translating them back to legacy bytes.
Recommended tmux config:
# tmux >= 3.2
set -g extended-keys on
set -as terminal-features ',xterm*:extkeys'
set -as terminal-features ',tmux*:extkeys'Outer-terminal requirements still apply:
- iTerm2: enable profile-level "Report keys using CSI u" / CSI-u key reporting. Even then, iTerm2 has a known ctrl+1 / ctrl+9 / ctrl+0 quirk, so kobe does not rely on ctrl+digit for core navigation.
- Kitty, foot, Ghostty, and recent Terminal.app builds generally answer the keyboard-protocol enable sequence without extra kobe config, but local keybindings in the terminal app can still intercept a chord before tmux sees it.
- macOS launchers and terminal application shortcuts can swallow Option/Cmd chords globally. No tmux setting can pass through a shortcut that never reached tmux.
The invariant for kobe-owned shortcuts remains: primary navigation must work without this setup. ctrl+hjkl pane focus is kept as
the direct pane chord because ctrl+letter maps to stable C0 bytes that tmux can pass in legacy mode. Extended-key passthrough is for
the shortcuts where the terminal protocol is the only way to distinguish intent, not a dependency for basic operation.
Normal startup opens directly into the task's tmux session. These keys are installed on kobe's isolated tmux socket, not the user's global tmux config:
| Chord | Scope | Action |
|---|---|---|
ctrl+h/j/k/l |
no-prefix tmux | Move between Tasks / engine / Ops / shell panes directionally. Edge-guarded: each bind is if-shell -F "#{?window_zoomed_flag,1,#{?pane_at_<edge>,,1}}" "select-pane -<dir>", so a press at the window edge is a no-op instead of tmux's default wrap-around (ctrl+h on the leftmost Tasks pane used to teleport to the rightmost pane) — EXCEPT while a pane is zoomed: zoom sets all four pane_at_* flags, so the outer conditional lets a zoomed press fall through to plain select-pane (unzoom + move, the pre-guard behavior). The guard is on the command side, so user-overridden tmux.focus keys keep it. |
ctrl+q |
no-prefix tmux | Two-stage: focus the current window's Tasks pane; press again from the Tasks pane to detach to the launching shell (session keeps running). prefix d / ctrl+b d still detaches in one step. |
ctrl+t |
no-prefix tmux | Create a same-engine ChatTab window for the current task/worktree. |
ctrl+shift+t |
no-prefix tmux, terminal-dependent | Prompt for engine, then create a ChatTab window. |
tmux prefix T |
tmux prefix fallback | Same engine picker as ctrl+shift+t, for terminals that do not forward the shifted control chord. |
ctrl+[ / ctrl+] |
no-prefix tmux | Previous / next ChatTab window. |
ctrl+w |
no-prefix tmux | Close the current ChatTab window if another window remains. |
F2 |
no-prefix tmux | Rename the current ChatTab window. |
tmux prefix s |
tmux prefix | Add a temporary shell split in the middle workspace area. The current ChatTab caps at four middle panes: engine + up to three aux shells. |
tmux prefix x |
tmux prefix | Close the focused workspace aux split, or the most recent aux split when focus is elsewhere. The engine pane is never closed by this binding. |
tmux prefix r |
tmux prefix | Reset the middle workspace area by closing every temporary aux split in the current ChatTab. |
tmux prefix a |
tmux prefix | Hide/restore the Tasks pane by moving it to a background tmux window, preserving the Tasks process. |
tmux prefix o |
tmux prefix | Toggle the file/Ops pane in the current ChatTab. Hiding it closes only the kobe-owned Ops pane; showing it rebuilds that pane against the current engine pane. |
tmux prefix z |
tmux prefix | Hide/restore the terminal pane by moving it to a background tmux window, preserving its shell process and scrollback. |
tmux prefix space |
tmux prefix | Toggle Zen mode — collapses every ChatTab in the session to its engine pane (hides the file/Ops and terminal panes, and the Tasks rail unless Settings → General → "Keep Tasks pane in zen mode" is on). Zen is session-wide and persistent: tabs you switch to stay collapsed, and a newly created ChatTab opens collapsed too. A second press restores exactly the panes zen hid across all tabs. Also reachable via the zen chip above the file list (enter-only, since entering hides that pane). |
tmux prefix f |
tmux prefix | Open the prompt-only quick-task page (asks for just a prompt; repo / engine / base branch default from the current task). |
Inside the Tasks pane itself, plain-letter task actions are pane-local: n new task, s Settings, u update page when an update is available, o open worktree, t toggle task sort (default/manual vs recent), a archive/unarchive, d delete, r title, b branch, v engine, ? collapse/expand the keys legend (KV-persisted; clicking the ── keys ── header does the same), and [ / ] Working session vs Archives. ctrl+p cycles the global project filter (all → each saved project), synced across every task session through the daemon's ui-prefs channel, without restoring repo grouping: PROJECTS rows stay visible as main-session entries, while the TASKS section narrows to the selected repo and still composes with / search. Right (tasks.focusEngine) re-focuses the current window's engine pane — the role-tagged @kobe_role=claude pane via claudePaneIdStrict, the inverse of the ctrl+h jump to the rail — and no-ops outside tmux (no $TMUX_PANE). These host-level letters (and Right) gate on BOTH an empty dialog stack and the sidebar's /-search being inactive — while a query is being typed they fall through as literal text (Right keeps moving the search input's cursor); move-mode is unaffected, since it only owns j/k/enter/esc. Archive/delete also kill the task's cached tmux session when present, because the legacy outer monitor no longer owns that cleanup path.
The Tasks/Ops panes are version-tagged with @kobe_pane_version. After an upgrade, ensureSession respawns stale kobe-owned panes in place while preserving the engine pane and ChatTab windows. Do not use kobe reset as the normal update path; reset is the runtime-recovery fallback for wedged tmux/daemon state.
Users can rebind most chords without touching the code. The config lives in the
hand-authored settings directory (~/.kobe/settings/, distinct from the
machine-written KV blob) and is loaded ONCE per process at TUI boot by
applyUserKeybindings() (src/tui/context/keybindings-user.ts),
which mutates the matching KobeKeymap rows in place. Because every pane
registers through bindByIds and the F1 help dialog / status bar render from
the same table, one mutation re-points every surface — chord, Help copy, and
footer hint follow automatically (overridden rows get their hint.keys
refreshed; an unbound row loses its hint). Restart kobe — or respawn the pane —
to apply edits. Pure parsing/validation logic lives in
src/tui/lib/keymap-overrides.ts
(vitest-covered, no opentui imports, mirroring the keymap-dispatch split).
bindings: # applies on every platform
chat.fork.new: ctrl+g # string = one chord
sidebar.select: [enter] # list = several chords (all fire the action)
files.createPR: null # null / [] = unbind (hint disappears too)
darwin: # platform overlay — wins over `bindings` per id
bindings: # (aliases: macos / mac; also: linux, windows)
palette.open: [cmd+p, ctrl+p]
linux:
bindings:
palette.open: ctrl+pSemantics and guard rails:
-
Ids come from
KobeKeymap— press F1 for the live list, or open Settings → Keybindings (read-only section showing the config path, applied overrides, and every load warning; warnings also go toconsole.warn→ the pane log). -
Chord grammar mirrors
matchKey():mod+...+key, modifier aliases (control/command/meta/option…) are canonicalized toctrl/cmd/alt/shiftin the dispatcher's order.esc→escape,pgup→pageup.left/rightare the arrow keys; left vs right modifier keys cannot be distinguished by terminal protocols, so there is nolctrl/rcmdsyntax. -
The boundary rule is enforced on user input: a bare single character on a
global/workspace/terminal-scope binding is dropped with a warning (it would steal typed input).shift+<letter>chords are rejected (terminals deliver shift+letter as a plain character — see the KOB-74 decision log below). -
Conflicts warn but apply: an override colliding with another binding in an overlapping scope logs "last registration wins; consider a different chord".
-
tmux-layer session keys use the same file via
tmux.*ids resolved bysrc/tmux/keybindings.tsand installed byensureSession(overridden defaults areunbind-key'd first, so a long-lived server doesn't keep both chords):tmux.tab.new(ctrl+t),tmux.tab.chooseEngine(ctrl+shift+t — shift+letter IS allowed here, tmux bindsC-S-…on extended-keys terminals),tmux.tab.prev/tmux.tab.next(ctrl+[ / ctrl+]),tmux.tab.close(ctrl+w),tmux.tab.rename(f2),tmux.detach(ctrl+q two-stage), prefix-scoped layout controls (tmux.layout.workspaceSplit=s,tmux.layout.workspaceClose=x,tmux.layout.workspaceReset=r,tmux.layout.tasksToggle=a,tmux.layout.opsToggle=o,tmux.layout.terminalToggle=z), andtmux.focus— a POSITIONAL group of exactly 4 chords in order left/down/up/right (default ctrl+h/j/k/l). One chord per single id;nullskips installing the binding. Extra guard rails:cmd+chords are rejected (Command never reaches tmux). Bare keys are rejected for no-prefix root ids unless they're F-keys because root bindings live in every pane and would shadow typing; prefix-scoped layout ids may use bare keys. The Tasks-pane footer legend and the tmuxstatus-righthint render from the resolved set, so overrides show their own chords. Overrides apply when a session is (re)built, not to a session that's already running. Theprefix T/prefix frows stay fixed. -
Positional (slot-layout) ids are rebindable via slot dispatch: the direction-multiplexed ids — one id, several chords, the action depends on WHICH chord fired — used to be fixed because their handlers read
evt.name. They now dispatch on the matched chord's slot (its index in the id'skeysarray:bindByIdsassigns it,dispatchKeyEventpasses it to the handler as a second argument), so an override just has to respect the id's positional layout, validated inSLOT_CONTRACTS(src/tui/lib/keymap-overrides.ts) — same idea astmux.focus's exactly-4-chords rule. All current layouts are alternating pairs, so any even chord count works (a wrong count warns and keeps the default;null/[]still unbinds):id slot layout (even slots, odd slots) default keys sidebar.navdown, up j, k, down, upfiles.navdown, up j, k, down, upsidebar.search.navdown, up down, upfiles.hierarchycollapse, expand h, l, left, rightsidebar.viewprevious view, next view [, ]files.tabprevious tab, next tab [, ]bindings: sidebar.nav: [w, s] # 2-chord nav: w=down, s=up files.hierarchy: [left, right] # arrows only files.tab: [ctrl+left, ctrl+right] # pairs can be modifier chords
-
Fixed (not rebindable): listed in
FIXED_BINDING_IDSwith reasons —focus.numeric(positional h/j/k/l → pane set mirroring the tmux-layerctrl+hjklbindings; rebindtmux.focusinstead),sidebar.goto/sidebar.pin/sidebar.localMerge(the handler fires onevt.shift—shift+<letter>chords are inexpressible in the chord grammar, so a rebind could never carry the shifted half), andchat.question.nav/chat.question.pick-number(no live registration site since the legacy Chat pane's question picker was removed — display-only rows; if the picker returns, implement it with slot dispatch before unlocking). Doc-only rows (keys: [], e.g. composer enter/shift+enter) also can't be overridden.
- Decide the flavour (global/modifier vs pane-scoped/letter).
- Add the row to
KobeKeymap. Setid,scope,keys,description, optionalhint, optionalcategory. Usehint.status: falsewhen the chord belongs in Help but not in the always-visible footer. - Wire the handler:
- Global → register inside
useKobeKeybindings(inkeybindings.ts) or as a top-leveluseBindingsblock inapp.tsx. - Pane-scoped → register in the pane's own
useBindings(sidebar uses itscontroller.ts, files haskeys.ts, workspace usesChat.tsx's pane block, app.tsx hosts the sidebar-only ones forn/q/s/ etc). - In every case use
bindByIds({ "<id>": handler })so the chord comes fromKobeKeymap, not a string literal.
- Global → register inside
- Gate appropriately:
- Pane-scoped:
enabled: focusedPane() === "<scope>" && dialog.stack.length === 0. - Global:
enabled: dialog.stack.length === 0is the usual minimum.
- Pane-scoped:
- If the chord lives inside a textarea's
keyBindingsprop or a renderable'sonKeyDown, leave the keymap row'skeys: [](doc-only) so the help dialog still advertises it.
In rough order of likelihood:
- Dialog open? Pretty much every binding gates on
dialog.stack.length === 0. With a dialog on top, only the dialog's own bindings (esc / ctrl+c / inline submit) fire. - Wrong pane focused? Pane-scoped bindings only fire when their pane owns focus. Check
focusedPane()in dev: status bar's left section label —Tasks:/Chat:/Files:/Terminal:— tracks focus exactly. - Plain letter caught by an input? If the binding is plain
qand the composer textarea has focus, the textarea consumes the keystroke as text. Pane-scoped binding rules above prevent this in practice; if it's a global plain letter, it's already the bug — convert to a modifier chord or pane-scope it. - Shadowed by a higher-priority binding?
useBindingscalls register in mount order; later registrations win on the same chord. Look for two registrations with overlapping chords (the docs/JSON doesn't catch this — has to be read). - Terminal byte sequence mismatch? Some terminals deliver
ctrl+shift+qas the same bytes asctrl+q; the keymap layer drops the shift modifier on letter keys (seelib/keymap.tsx's normalizer comment). If you registered both, both fire.
Whenever you discover, debug, or resolve a keybinding-boundary issue. Treat it as the place a future agent / Jackson can grep for "why does ctrl+1 do X here but Y there." The doc is small on purpose — the goal is "every keybinding decision has a one-paragraph explanation findable in this file"; if a section sprawls, the underlying design is probably wrong.
KOB-74 asked for ctrl+shift+t ("new tab" in browsers, restoring a closed tab; semantic
match for forking into a new task). The keymap layer normalizes terminal-delivered keys
and drops the shift+ modifier on letter keys (see lib/keymap-dispatch.ts —
if (evt.shift && name && name.length > 1) mods.push("shift")). Terminals deliver
shift+letter as uppercase, not as a modifier event, so ctrl+shift+t and ctrl+t produce
identical match candidates. ctrl+t is already chat.tab.new (open a sibling chat tab in
the same task), so registering quick-fork on ctrl+shift+t would either collide silently
or steal the existing chord — neither is acceptable.
Candidate chords considered (workspace-scoped, modifier-prefixed, free in the keymap):
ctrl+f— "fork." ctrl+letter has stable C0 byte mappings (0x06) in every terminal, no CSI-u / kitty-keyboard / iTerm quirks. The composer's textarea would normally readctrl+fas emacs-style forward-char, but ouruseBindingslistener fires first and callspreventDefault()so the textarea never sees it.alt+t— keeps the "t" semantics. Option+letter on macOS produces a special character (Option+T → †) at the OS level, which the keymap layer surfaces asalt+tviaevt.option. Reliable in most setups, but Option+digit is a known macOS-launcher hazard (Raycast/Karabiner) and Option+letter sometimes follows; ctrl+letter sidesteps it.ctrl+b— "branch." Free, but less mnemonic for "fork a task" vs "create a branch."
Landed on ctrl+f. The chord is workspace-scoped (only fires when chat owns focus) so it
doesn't shadow the global focus-numeric set. Decision: KOB-74. See context/keybindings.ts
→ chat.fork.new for the registration.
We iterated through three candidates before landing on ctrl+hjkl. Recording the journey here so the next agent (or Jackson) doesn't
re-derive it.
-
ctrl+1..4— first attempt, mirrors VSCode/iTerm pane focus muscle memory.- Conflict 1 (resolved):
chat.tab.pickwas registered on the same chords. In v0.6, self-rendered chat-tab picking is gone; ChatTab navigation lives inside tmux asctrl+]/ctrl+[previous / next window. - Conflict 2 (load-bearing): legacy terminal mode doesn't propagate the ctrl modifier on digit keys — pressing
ctrl+1just sends the byte1. The ctrl-digit chord requires the CSI-u / kitty keyboard protocol, which:- opentui can request via
useKittyKeyboard: {}onrender(). Done. - The terminal must respond to. iTerm2 has a quirk where ctrl+1 / ctrl+9 / ctrl+0 silently fall through to a bare digit byte even with CSI-u enabled — only ctrl+2..8 emit the proper sequence.
- tmux must pass the sequences through with
set -g extended-keys on(tmux ≥ 3.2) +set -as terminal-features 'xterm*:extkeys'.
- opentui can request via
- Verdict: too many config layers; ctrl+1 works for nobody by default.
- Conflict 1 (resolved):
-
alt+1..4— second attempt. Always-works because alt+digit produces a stable two-byteESC<digit>sequence in legacy mode, no protocol negotiation needed.- Conflict: macOS launchers (Raycast, Karabiner, Alfred) commonly intercept Option+digit globally before it reaches the terminal. Many users (including Jackson) have alt/option/cmd entirely committed to other software.
- Verdict: works in theory, doesn't reach kobe in practice on heavily-customized macOS setups.
-
ctrl+hjkl— final landing. ctrl+letter chords have stable C0 control byte mappings:ctrl+h = 0x08(BS)ctrl+j = 0x0a(LF)ctrl+k = 0x0b(VT)ctrl+l = 0x0c(FF)
These bytes are sent by every terminal, every tmux config, every shell — no protocol, no quirks, no setup. The chord conflicts with editor commands (ctrl+h = backspace, ctrl+l = clear screen, etc.) but our
useBindingslistener sees the keypress before the textarea's editor handler, and once the chord switches focus, the textarea isn't focused anymore — so the conflict never manifests in practice.ctrl+kwas previously the command palette chord (palette.open). Freed and reassigned; palette moved toctrl+p/cmd+p(vscode/Cursor convention).Mapping is positional (h/j/k/l = ordinal 1/2/3/4), not directional. The pane title's bold prefix shows the chord letter to make the chord discoverable from a glance.
Lesson for the next chord-design pass: prefer ctrl+letter over ctrl+digit / alt+digit / cmd+digit. Letters Just Work; digits need protocol upgrades; modifiers other than ctrl get hijacked by user-space launchers. Pick a single-modifier ctrl+letter chord and accept that "this conflicts with shell editor commands" is acceptable when the binding's intent is to MOVE focus AWAY from the input that would consume it.