diff --git a/docs/memory/feature-flows/workspace-chat-tabs-and-titles.md b/docs/memory/feature-flows/workspace-chat-tabs-and-titles.md
index acd8de7fb..b5d55be43 100644
--- a/docs/memory/feature-flows/workspace-chat-tabs-and-titles.md
+++ b/docs/memory/feature-flows/workspace-chat-tabs-and-titles.md
@@ -86,7 +86,8 @@ surface rather than only within one owner's share:
 | ⌥⇧↓ / ⌥⇧↑ (Alt+Shift+↓ / ↑) | Next / previous chat with this agent | shell |
 | ⌘. / Ctrl+. | Show or hide the rail | shell |
 | ⌥. (Alt+.) | Next rail tab | shell |
-| ⌘/ / Ctrl+/ | The keyboard-shortcuts list | shell |
+| ⌘/ / Ctrl+/ | Cursor into the sidebar's search field; again from the field, back to the message field | shell |
+| ⌥/ (Alt+/) | The keyboard-shortcuts list | shell |
 | Esc, the call's `M`, the preview's ←/→, tab roving, a dialog's Tab cycle, the composer typeahead's bare arrows | — | the component that owns the overlay |
 | ⌘K / Ctrl+K | nothing — **reserved** for search (ent#577) | nobody |
 
@@ -139,7 +140,7 @@ protocol entry the map declares, not a second dispatcher), armed above `bootstra
 6. `keymapSuppressed`: a nearer owner already claimed the event
    (`defaultPrevented`, which is how the Esc protocol and the typeahead's bare
    arrows win), anything modal (`[aria-modal="true"]`, with a per-action
-   exemption so ⌘/ can close its own dialog and the rail sheet does not count
+   exemption so ⌥/ can close its own dialog and the rail sheet does not count
    as something modal over the rail), the mobile drawer, or a voice call —
    which suppresses the moving and rail keys silently.
 
@@ -164,7 +165,23 @@ inverted here, since the hands that want the next chat are already typing.
   rule's own arms rather than a second rule. Memory is in-memory and
   session-scoped, as the acceptance criteria asked: a reload starts fresh.
 
-**Discoverability.** ⌘/ opens `PortalKeyList` — a `BaseModal` dialog built
+**Search key.** ⌘/ runs `Portal.vue::focusSearch`: at and above `sm` it calls
+the desktop `PortalSidebar`'s exposed `focusSearch()` (focus + select), or —
+when that field already has focus (`searchHasFocus()`) — hands the caret back
+through `focusConversationComposer`; below `sm` it opens the drawer and focuses
+that instance's field on the next tick. The field shows the chord in a
+`PortalKeyCap` while it is empty and unfocused.
+
+**Tips panel.** `PortalKeyTips.vue` is pinned to the bottom of the OPEN rail
+(`PortalRail`'s `keyTips` prop; an icon button at the foot of the collapsed
+strip is the same door; the sheet has neither). Its rows are
+`keyTipRows(platform)` over `KEY_TIPS`, laid out as two rows of two with the
+two controls stacked beside them (`keyHintCompact` packs a chord pair into one
+cap; labels truncate, caps never wrap). Its keyboard button emits `open-keys`, and its
+close emits `dismiss-key-tips`, which the shell persists with
+`saveKeyTipsDismissed` (`localStorage['trinity-workspace-key-tips']`).
+
+**Discoverability.** ⌥/ opens `PortalKeyList` — a `BaseModal` dialog built
 from `keyListRows(WORKSPACE_KEYMAP, platform)`, so a key cannot exist without
 appearing in the list (minus the reserved row). The sidebar footer has a
 "Keyboard shortcuts" button carrying the same chord, and the surfaces a key
diff --git a/docs/memory/requirements/core-agent.md b/docs/memory/requirements/core-agent.md
index ff2f1f67e..3656a5e57 100644
--- a/docs/memory/requirements/core-agent.md
+++ b/docs/memory/requirements/core-agent.md
@@ -1845,7 +1845,8 @@ bounding the table. OSS-core (Workspace rule above). Flow:
 - **AC-1 — the keys**: `⌘J`/`Ctrl+J` new chat with this agent (§5.21,
   unchanged); `⌥↓`/`⌥↑` next / previous **agent**; `⌥⇧↓`/`⌥⇧↑` next /
   previous **chat with this agent**; `⌘.`/`Ctrl+.` show or hide the rail;
-  `⌥.` next rail tab; `⌘/`/`Ctrl+/` the keyboard-shortcuts list.
+  `⌥.` next rail tab; `⌘/`/`Ctrl+/` the cursor into the sidebar's search
+  field (AC-11); `⌥/` the keyboard-shortcuts list.
 - **AC-2 — one declaration**: every chord lives in
   `src/frontend/src/components/portal/portalKeymap.js` (pure — no DOM, no
   store), with its scope, its owner, and its label. `keymapCollisions(map)`
@@ -1873,10 +1874,10 @@ bounding the table. OSS-core (Workspace rule above). Flow:
   through `defaultPrevented` (the Esc protocol, the composer typeahead's bare
   arrows, which claim bare arrows only).
 - **AC-5 — suppression**: anything modal (`[aria-modal="true"]`, with a
-  per-action exemption so `⌘/` can close its own dialog and the rail sheet
+  per-action exemption so `⌥/` can close its own dialog and the rail sheet
   does not count as modal over the rail), the mobile drawer, and a live voice
   call suppress the moving and rail keys **silently**; `⌘J` keeps its own ask
-  during a call, and `⌘/` stays available. A held key does not walk the list
+  during a call, and `⌘/` and `⌥/` stay available. A held key does not walk the list
   (`e.repeat` resolves to nothing) and an IME composition is never a chord.
   The auto-repeat of a press the shell **claimed** is still swallowed
   (`heldKey` + `workspaceChord`), so a held `⌥.` cannot type `≥` into the
@@ -1903,7 +1904,7 @@ bounding the table. OSS-core (Workspace rule above). Flow:
   that agent. An unsent new chat records nothing, so its draft is reached
   through the landing rule's own arms rather than a second rule. Every moving
   key focuses the composer afterwards.
-- **AC-9 — discoverable**: `⌘/` opens a shortcuts dialog built **from the
+- **AC-9 — discoverable**: `⌥/` opens a shortcuts dialog built **from the
   map**, so a key cannot ship without a row (the reserved chord is excluded —
   nothing binds it, and a dead row in a help dialog is worse than an
   undocumented key). The sidebar footer offers the same dialog, and every
@@ -1912,6 +1913,31 @@ bounding the table. OSS-core (Workspace rule above). Flow:
 - **AC-10 — reserved, not bound**: `⌘K`/`Ctrl+K` is declared and
   **unhandled** — no `preventDefault`, no row in the list — so the browser's
   own behaviour stands until the search surface ships.
+- **AC-11 — the search key**: `⌘/`/`Ctrl+/` puts the cursor in the sidebar's
+  "Search agents and chats" field and selects what is in it — the Dashboard's
+  `/` filter key (§ fleet filter), with the modifier a key needs to work from
+  inside a text field. Pressed again while the field has focus it hands the
+  caret back to the message field. Below `sm` the sidebar is the drawer, so the
+  key opens it and focuses that instance's field. The field shows the chord
+  (a key cap while it is empty and unfocused, plus `title` and
+  `aria-keyshortcuts`). It is NOT the reserved `⌘K` surface: it focuses the
+  search that exists and adds none. The shortcuts list moved to `⌥/` to free
+  the chord, keeping the `⌘.` / `⌥.` pairing (the primary key acts, the Option
+  key steps to its neighbour).
+- **AC-12 — the tips panel**: the open rail carries a small panel pinned to its
+  bottom edge listing four headline chords (switch agent, switch chat, search,
+  new chat) and a button that opens the shortcuts dialog. It is **two rows of
+  two** and nothing else — no heading line, no footer: the close and the
+  open-the-list controls stack beside the rows. A pair of chords prints its
+  modifiers once (`⌥↑↓`, `Alt+Shift+↑↓` — `keyHintCompact`), and when the rail
+  is dragged narrow a label shortens (full text on hover) while a key cap never
+  wraps and a row never becomes two. Rows are derived from the map (`KEY_TIPS`
+  → `keyTipRows`), never typed. The collapsed strip carries
+  the same door as one icon button at its foot; the mobile sheet carries
+  neither. The panel is dismissible, and the dismissal is remembered per
+  browser (`localStorage['trinity-workspace-key-tips']`, a per-viewer
+  convenience — nothing is stored server-side); the sidebar footer button stays
+  as the way back to the full list.
 - **Not this slice**: a search/spotlight surface behind `⌘K`; remapping or
   disabling the chords in settings (they are modifier chords; nothing conflicts
   with typing); the mobile drawer's own Esc/focus-trap contract (#1923).
@@ -1924,6 +1950,7 @@ bounding the table. OSS-core (Workspace rule above). Flow:
   `workspaceKeymap.mount.spec.js` (the shell: dispatch, the walk, the memory,
   the bails and suppression), `portalChatCycle.mount.spec.js`,
   `portalKeyList.mount.spec.js`, `portalKeyHints.mount.spec.js`,
+  `portalKeyTips.mount.spec.js` (the tips panel, both rail forms),
   `portalRosterRow.spec.js` (the bound and the handed-down order, mounted).
 - **Flow**: `docs/memory/feature-flows/workspace-chat-tabs-and-titles.md`
   (→ The key map); the landing rule it calls is
diff --git a/docs/user-docs/faq/sharing-access-and-monetization.md b/docs/user-docs/faq/sharing-access-and-monetization.md
index dbcc64e72..603c84439 100644
--- a/docs/user-docs/faq/sharing-access-and-monetization.md
+++ b/docs/user-docs/faq/sharing-access-and-monetization.md
@@ -120,7 +120,7 @@ Most visits to an agent start new work, so opening an agent now starts a new cha
 
 ## Does the Workspace have keyboard shortcuts?
 
-Yes, and they work while you are typing in the message field. **⌘J** / **Ctrl+J** starts a new chat, **⌥↓** / **⌥↑** moves between agents, **⌥⇧↓** / **⌥⇧↑** between chats with the current agent, **⌘.** / **Ctrl+.** shows or hides the rail, **⌥.** steps through the rail's tabs, and **⌘/** / **Ctrl+/** opens the full list (also the **Keyboard shortcuts** button at the bottom of the sidebar). Esc closes the innermost thing first, then stops a running turn. The keys pause while a dialog is open, and during a voice call only ⌘J answers. See [Workspace](../sharing-and-access/workspace.md#keyboard-shortcuts).
+Yes, and they work while you are typing in the message field. **⌘J** / **Ctrl+J** starts a new chat, **⌥↓** / **⌥↑** moves between agents, **⌥⇧↓** / **⌥⇧↑** between chats with the current agent, **⌘.** / **Ctrl+.** shows or hides the rail, **⌥.** steps through the rail's tabs, **⌘/** / **Ctrl+/** jumps to the sidebar search, and **⌥/** / **Alt+/** opens the full list (also the **Keyboard shortcuts** button at the bottom of the sidebar). Esc closes the innermost thing first, then stops a running turn. The keys pause while a dialog is open, and during a voice call only ⌘J answers. See [Workspace](../sharing-and-access/workspace.md#keyboard-shortcuts).
 
 ## How do I reply to one specific message from the agent?
 
diff --git a/docs/user-docs/sharing-and-access/workspace.md b/docs/user-docs/sharing-and-access/workspace.md
index 3a8d10b89..7fc486a06 100644
--- a/docs/user-docs/sharing-and-access/workspace.md
+++ b/docs/user-docs/sharing-and-access/workspace.md
@@ -51,11 +51,11 @@ Top to bottom:
 - **Trinity Workspace** — the wordmark. It links to the Inbox.
 - **Inbox** — a pinned row with two badges: the number of asks agents are waiting on you to answer, and the number of chats with something you haven't read. See [The Inbox](#the-inbox).
 - **New chat** — opens the agent picker.
-- **Search agents and chats…** — two characters or more. Agents filter in place; chat results replace the chat list below, and each half says separately when it matched nothing.
+- **Search agents and chats…** — two characters or more. **⌘/** / **Ctrl+/** puts the cursor there from anywhere; pressed again from the field, it returns you to the message field. Agents filter in place; chat results replace the chat list below, and each half says separately when it matched nothing.
 - **Agents** — your roster, ordered by the agents you worked with most recently, then by name. Five rows show, with **Show all** to expand. A row carries the agent's display name, the title of your newest chat with it (or its slug when the name is a label), when you last heard from it, an availability chip when the agent is stopped or unreachable, and its own ask and unread badges. **Clicking an agent opens a new, empty chat with it**, with the cursor in the message field — or returns you to a chat with that agent where you left unsent text. Your earlier chats are its tabs, one click away.
 - **Starred** — chats you've starred, lifted out of the date groups so each chat appears exactly once.
 - **Today / Yesterday / Previous 7 days / Older** — everything else. A Main you have never used is not listed here; the agent's row is the way into it.
-- **Keyboard shortcuts** — at the bottom, beside sign-out. It opens the list of keys (also **⌘/** / **Ctrl+/**).
+- **Keyboard shortcuts** — at the bottom, beside sign-out. It opens the list of keys (also **⌥/** / **Alt+/**).
 
 ### The Inbox
 
@@ -236,6 +236,8 @@ Inside a room, **+ Add agent** recruits another, and only a person can do that.
 
 ### Keyboard shortcuts
 
+The open rail carries a small **shortcut tips** panel at its foot with the most-used keys; close it with its **×** and this browser remembers. The collapsed rail shows a single keyboard icon instead, which opens the full list.
+
 | Keys | Where | Does |
 |------|-------|------|
 | **⌘J** / **Ctrl+J** | Anywhere in the Workspace | New chat with the agent in front of you (the picker when there is none) |
@@ -243,7 +245,8 @@ Inside a room, **+ Add agent** recruits another, and only a person can do that.
 | **⌥⇧↓** / **⌥⇧↑** (**Alt+Shift+↓** / **↑**) | Anywhere | Next / previous chat with this agent |
 | **⌘.** / **Ctrl+.** | Anywhere | Show or hide the rail |
 | **⌥.** (**Alt+.**) | Anywhere | Next rail tab |
-| **⌘/** / **Ctrl+/** | Anywhere | The keyboard-shortcuts list |
+| **⌘/** / **Ctrl+/** | Anywhere | Cursor to the sidebar search; again, back to the message field. On a narrow screen it opens the sidebar first |
+| **⌥/** (**Alt+/**) | Anywhere | The keyboard-shortcuts list |
 | **Enter** / **Shift+Enter** | Composer | Send / new line |
 | **↓ ↑**, **Enter**, **Tab**, **Esc** | Composer, with the `/` or `@` list open | Move, insert the selected row, insert the top row, dismiss |
 | **Esc** | Composer, with a *Replying to* chip | Drop the reply |
diff --git a/src/frontend/src/components/base/BaseModal.vue b/src/frontend/src/components/base/BaseModal.vue
index cd52d9077..1d428d72b 100644
--- a/src/frontend/src/components/base/BaseModal.vue
+++ b/src/frontend/src/components/base/BaseModal.vue
@@ -67,7 +67,7 @@ import {
 
 // Attributes land on the DIALOG, not on `Teleport`. A consumer that needs the
 // overlay element itself marked — `PortalKeyList`'s `data-ws-key-list`, which
-// the Workspace key dispatcher excludes so `⌘/` can close the list it opened
+// the Workspace key dispatcher excludes so `⌥/` can close the list it opened
 // — must put that attribute on the SAME element as `aria-modal`, because that
 // is the element the `:not(...)` exclusion matches. Without this the attribute
 // is dropped silently and the marker is a comment rather than a selector.
diff --git a/src/frontend/src/components/portal/PortalKeyCap.vue b/src/frontend/src/components/portal/PortalKeyCap.vue
new file mode 100644
index 000000000..d3c46a881
--- /dev/null
+++ b/src/frontend/src/components/portal/PortalKeyCap.vue
@@ -0,0 +1,7 @@
+<template>
+  <!-- `<kbd>` on gray + `font-mono`, the Dashboard's shape: a key cap reads as
+       a key cap without a hue claiming meaning it has not got. ONE recipe for
+       the three places a chord is printed (the key list, the rail's tips, the
+       sidebar search field), so they cannot drift apart. -->
+  <kbd class="shrink-0 whitespace-nowrap rounded border border-gray-200 bg-gray-50 px-1.5 py-0.5 text-[11px] font-mono text-gray-600 dark:border-gray-700 dark:bg-gray-900 dark:text-gray-300"><slot /></kbd>
+</template>
diff --git a/src/frontend/src/components/portal/PortalKeyList.vue b/src/frontend/src/components/portal/PortalKeyList.vue
index 95b9486e2..a8af25d4c 100644
--- a/src/frontend/src/components/portal/PortalKeyList.vue
+++ b/src/frontend/src/components/portal/PortalKeyList.vue
@@ -1,5 +1,5 @@
 <template>
-  <!-- `data-ws-key-list` is how `⌘/` can CLOSE the list it opened: the probe
+  <!-- `data-ws-key-list` is how `⌥/` can CLOSE the list it opened: the probe
        suppresses every shell key under anything `aria-modal`, and the key list
        is one. The marker rides the dialog element itself (the same element that
        carries `aria-modal`), because that is the element the `:not(...)`
@@ -41,9 +41,7 @@
               <span class="block text-sm text-gray-900 dark:text-gray-100">{{ row.label }}</span>
               <span v-if="row.note" class="block text-xs text-gray-500 dark:text-gray-400">{{ row.note }}</span>
             </span>
-            <!-- `<kbd>` on gray + `font-mono`, the Dashboard's shape: a key cap
-                 reads as a key cap without a hue claiming meaning it has not got. -->
-            <kbd class="shrink-0 rounded border border-gray-200 bg-gray-50 px-1.5 py-0.5 text-[11px] font-mono text-gray-600 dark:border-gray-700 dark:bg-gray-900 dark:text-gray-300">{{ row.keys }}</kbd>
+            <PortalKeyCap>{{ row.keys }}</PortalKeyCap>
           </li>
         </ul>
       </section>
@@ -60,7 +58,7 @@
 
 <script setup>
 /**
- * The `⌘/` key list (ent#621).
+ * The `⌥/` key list (ent#621).
  *
  * Every row is rendered from `keyListRows(WORKSPACE_KEYMAP, …)` — the same
  * declaration the dispatcher resolves against. A hand-typed list is a second
@@ -75,6 +73,7 @@
  */
 import { computed } from 'vue'
 import BaseModal from '@/components/base/BaseModal.vue'
+import PortalKeyCap from './PortalKeyCap.vue'
 import { SCOPE_MOVING, SCOPE_DOING, OWNER_PROTOCOL } from './portalKeymap'
 import { isMacLike } from './portalUtils'
 
diff --git a/src/frontend/src/components/portal/PortalKeyTips.vue b/src/frontend/src/components/portal/PortalKeyTips.vue
new file mode 100644
index 000000000..b50c32396
--- /dev/null
+++ b/src/frontend/src/components/portal/PortalKeyTips.vue
@@ -0,0 +1,99 @@
+<template>
+  <!-- The rail's shortcut tips (ent#621 follow-up), in the rail's two desktop
+       forms. COMPACT is the collapsed strip's: 48px holds no panel, so it is
+       one icon that opens the full list. -->
+  <div v-if="compact" class="pb-2 flex justify-center">
+    <button
+      type="button"
+      class="w-9 h-9 rounded-lg flex items-center justify-center text-gray-400 hover:text-gray-700 dark:hover:text-gray-200 hover:bg-gray-100 dark:hover:bg-gray-800 transition"
+      :title="`Keyboard shortcuts (${KEY_LIST_HINT})`"
+      :aria-label="`Keyboard shortcuts (${KEY_LIST_HINT})`"
+      :aria-keyshortcuts="KEY_LIST_SHORTCUTS"
+      data-testid="portal-rail-keys"
+      @click="$emit('open-keys')"
+    >
+      <svg class="w-5 h-5" fill="none" viewBox="0 0 24 24" stroke="currentColor" aria-hidden="true"><path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" :d="KEYBOARD_GLYPH" /></svg>
+    </button>
+  </div>
+
+  <!-- The OPEN column's: a small panel pinned to its bottom edge. A sibling of
+       the rail's scroll area, never a child — so it does not scroll away and
+       never sits over the content.
+
+       TWO ROWS, and nothing above or below them: the four tips flow by column
+       into a 2×2 (agent over chat, search over new chat), and the two controls
+       stack beside them. What gives when the rail is dragged narrow is the
+       LABEL (it shortens with an ellipsis, the full text on hover); a key cap
+       never wraps and a row never becomes two. The columns are `auto`, so
+       each is as wide as its own content asks before either gives anything
+       up — the first is the wider one (`Alt+Shift+↑↓` against `Ctrl+J`), and
+       an even split would shorten its labels with room to spare beside it. -->
+  <section v-else class="shrink-0 p-2" aria-label="Keyboard shortcut tips" data-testid="ws-key-tips">
+    <BaseCard flush class="flex items-center gap-1.5 pl-2 pr-1 py-1.5">
+      <ul class="flex-1 min-w-0 grid grid-flow-col grid-rows-2 grid-cols-[auto_auto] gap-x-2.5 gap-y-1">
+        <li
+          v-for="row in ROWS"
+          :key="row.id"
+          class="min-w-0 flex items-center justify-between gap-1.5"
+          :title="`${row.label} (${row.fullKeys})`"
+          :data-ws-key-tip="row.id"
+        >
+          <span class="min-w-0 truncate text-xs text-gray-600 dark:text-gray-300" data-ws-key-tip-label>{{ row.label }}</span>
+          <PortalKeyCap>{{ row.keys }}</PortalKeyCap>
+        </li>
+      </ul>
+      <div class="shrink-0 flex flex-col items-center gap-0.5">
+        <button
+          type="button"
+          :class="TIP_BTN"
+          title="Hide"
+          aria-label="Hide shortcut tips"
+          data-testid="ws-key-tips-close"
+          @click="$emit('dismiss')"
+        >
+          <svg class="w-4 h-4" fill="none" viewBox="0 0 24 24" stroke="currentColor" aria-hidden="true"><path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M6 18L18 6M6 6l12 12" /></svg>
+        </button>
+        <button
+          type="button"
+          :class="TIP_BTN"
+          :title="`All shortcuts (${KEY_LIST_HINT})`"
+          :aria-label="`All shortcuts (${KEY_LIST_HINT})`"
+          :aria-keyshortcuts="KEY_LIST_SHORTCUTS"
+          data-testid="ws-key-tips-all"
+          @click="$emit('open-keys')"
+        >
+          <svg class="w-4 h-4" fill="none" viewBox="0 0 24 24" stroke="currentColor" aria-hidden="true"><path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" :d="KEYBOARD_GLYPH" /></svg>
+        </button>
+      </div>
+    </BaseCard>
+  </section>
+</template>
+
+<script setup>
+/**
+ * Every chord printed here is read from the one key map (`keyTipRows`,
+ * `keyHint`), so nothing in this file can name a key of its own. Closing the
+ * panel is REPORTED, not remembered: the shell owns that memory, and tells the
+ * rail whether to mount this at all.
+ */
+import BaseCard from '@/components/base/BaseCard.vue'
+import PortalKeyCap from './PortalKeyCap.vue'
+import { keyTipRows, keyHint, keyShortcutsFor, hostPlatform } from './portalKeymap'
+
+const KEY_PLATFORM = hostPlatform()
+const ROWS = keyTipRows(KEY_PLATFORM)
+const KEY_LIST_HINT = keyHint('key-list', KEY_PLATFORM)
+const KEY_LIST_SHORTCUTS = keyShortcutsFor('key-list', KEY_PLATFORM)
+
+// The keyboard the sidebar footer's "Keyboard shortcuts" button draws: the same
+// door, so the same picture — in both forms of this component.
+const KEYBOARD_GLYPH = 'M3 8a2 2 0 012-2h14a2 2 0 012 2v8a2 2 0 01-2 2H5a2 2 0 01-2-2V8zm4 1v.01M11 9v.01M15 9v.01M7 13h10'
+// The panel's two controls, ONE class string: 24px targets stacked beside the
+// two rows, so they add no line of their own.
+const TIP_BTN = 'p-1 rounded text-gray-400 hover:text-gray-700 dark:hover:text-gray-200 hover:bg-gray-100 dark:hover:bg-gray-700 transition'
+
+defineProps({
+  compact: { type: Boolean, default: false },
+})
+defineEmits(['open-keys', 'dismiss'])
+</script>
diff --git a/src/frontend/src/components/portal/PortalRail.vue b/src/frontend/src/components/portal/PortalRail.vue
index 0c585c12a..4ed50ce41 100644
--- a/src/frontend/src/components/portal/PortalRail.vue
+++ b/src/frontend/src/components/portal/PortalRail.vue
@@ -84,6 +84,10 @@
             <span v-if="s.shape" class="absolute top-1 right-1" :class="dotClass(s.shape)" aria-hidden="true"></span>
           </button>
         </div>
+        <!-- ent#621 (follow-up): 48px holds no panel, so the collapsed strip
+             carries the tips as ONE door at its foot — the same list the open
+             rail's panel opens, and gone with it once dismissed. -->
+        <PortalKeyTips v-if="keyTips" compact class="mt-auto" @open-keys="$emit('open-keys')" />
       </template>
 
       <!-- ========================== OPEN / SHEET ========================== -->
@@ -177,6 +181,18 @@
             </div>
           </slot>
         </div>
+
+        <!-- ent#621 (follow-up): the tips panel, pinned to the bottom of the
+             OPEN column. After the body and outside it, so the body keeps its
+             own scroll axis and the panel never covers what it shows; `mt-auto`
+             holds it at the foot even when no tab body is mounted. Not on the
+             sheet: a phone has no keyboard to hint at. -->
+        <PortalKeyTips
+          v-if="keyTips && mode === 'open'"
+          class="mt-auto"
+          @open-keys="$emit('open-keys')"
+          @dismiss="$emit('dismiss-key-tips')"
+        />
       </template>
     </aside>
   </div>
@@ -188,6 +204,7 @@ import OverflowTabs from '../OverflowTabs.vue'
 import BaseButton from '@/components/base/BaseButton.vue'
 import BaseBadge from '@/components/base/BaseBadge.vue'
 import PortalAvatar from './PortalAvatar.vue'
+import PortalKeyTips from './PortalKeyTips.vue'
 import {
   RAIL_SIGNAL_LIVE,
   RAIL_SIGNAL_UPDATED,
@@ -222,9 +239,13 @@ const props = defineProps({
   participants: { type: Array, default: () => [] },
   // The mobile bottom-sheet form. A sheet is always "open".
   sheet: { type: Boolean, default: false },
+  // ent#621 (follow-up): show the shortcut tips — the panel at the foot of the
+  // open column, the icon at the foot of the collapsed strip. The shell turns
+  // it off once the person has closed it; the rail holds no memory of its own.
+  keyTips: { type: Boolean, default: false },
 })
 
-const emit = defineEmits(['update:open', 'update:activeTab', 'close', 'see-hints'])
+const emit = defineEmits(['update:open', 'update:activeTab', 'close', 'see-hints', 'open-keys', 'dismiss-key-tips'])
 
 const mode = computed(() => (props.sheet ? 'sheet' : props.open ? 'open' : 'collapsed'))
 
diff --git a/src/frontend/src/components/portal/PortalSidebar.vue b/src/frontend/src/components/portal/PortalSidebar.vue
index 0588c998b..daebc8420 100644
--- a/src/frontend/src/components/portal/PortalSidebar.vue
+++ b/src/frontend/src/components/portal/PortalSidebar.vue
@@ -42,13 +42,31 @@
       <!-- Search -->
       <div class="relative">
         <svg class="w-4 h-4 text-gray-400 absolute left-3 top-2.5 pointer-events-none" fill="none" viewBox="0 0 24 24" stroke="currentColor"><path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M21 21l-4.35-4.35M17 11a6 6 0 11-12 0 6 6 0 0112 0z" /></svg>
+        <!-- ent#621 (follow-up): `⌘/` lands here (`focusSearch`, exposed for
+             the shell). The chord is shown three ways — `title`,
+             `aria-keyshortcuts`, and the key cap below — all read from the map. -->
         <input
+          ref="searchInput"
           :value="search"
           type="search"
+          :title="`${SEARCH_PLACEHOLDER} (${SEARCH_KEY_HINT})`"
+          :aria-keyshortcuts="SEARCH_KEY_SHORTCUTS"
           :placeholder="SEARCH_PLACEHOLDER"
           class="w-full rounded-xl border border-gray-300 dark:border-gray-700 bg-white dark:bg-gray-900 text-sm pl-9 pr-3 py-2 focus:ring-2 focus:ring-action-primary-500/40 focus:border-action-primary-500 focus:outline-none"
           @input="$emit('update:search', $event.target.value)"
+          @focus="searchFocused = true"
+          @blur="searchFocused = false"
         />
+        <!-- Only while the field is empty and unfocused: it sits where the
+             field's own clear control appears, and a hint over what you are
+             typing is worse than none. Hidden below `sm`, where this sidebar is
+             the phone drawer and there is no keyboard to press it on. -->
+        <PortalKeyCap
+          v-if="!search && !searchFocused"
+          class="hidden sm:block absolute right-2.5 top-2 pointer-events-none"
+          data-testid="portal-sidebar-search-key"
+          aria-hidden="true"
+        >{{ SEARCH_KEY_HINT }}</PortalKeyCap>
       </div>
     </div>
 
@@ -331,7 +349,7 @@
       </div>
       <!-- ent#621: the keys are only discoverable if something shows them, and
            a key chord cannot show itself. Mouse and touch reach the same list
-           the `⌘/` chord opens (the ent#261 `<kbd>` precedent). -->
+           the `⌥/` chord opens (the ent#261 `<kbd>` precedent). -->
       <button
         type="button"
         :class="FOOTER_BTN"
@@ -360,6 +378,7 @@
 import PortalSidebarProjectsLink from './projects/PortalSidebarProjectsLink.vue'
 import { computed, ref, watch } from 'vue'
 import PortalAvatar from './PortalAvatar.vue'
+import PortalKeyCap from './PortalKeyCap.vue'
 import ChatRow from './PortalChatRow.vue'
 import PortalBrand from './PortalBrand.vue'
 import PortalInboxRow from './PortalInboxRow.vue'
@@ -439,6 +458,26 @@ const AGENT_KEY_HINT = keyHint(['agent-prev', 'agent-next'], KEY_PLATFORM)
 const AGENT_KEY_SHORTCUTS = keyShortcutsFor(['agent-prev', 'agent-next'], KEY_PLATFORM)
 const KEY_LIST_HINT = keyHint('key-list', KEY_PLATFORM)
 const KEY_LIST_SHORTCUTS = keyShortcutsFor('key-list', KEY_PLATFORM)
+const SEARCH_KEY_HINT = keyHint('search-focus', KEY_PLATFORM)
+const SEARCH_KEY_SHORTCUTS = keyShortcutsFor('search-focus', KEY_PLATFORM)
+
+// ent#621 (follow-up) — the search key's two questions, answered by the
+// instance that owns the field (the shell has two sidebars and asks the one on
+// screen). `select()` so a second search replaces the first without a
+// backspace; `searchHasFocus` is what lets a repeat press hand the caret back.
+const searchInput = ref(null)
+const searchFocused = ref(false)
+function focusSearch() {
+  const el = searchInput.value
+  if (!el) return false
+  el.focus()
+  el.select?.()
+  return true
+}
+function searchHasFocus() {
+  return !!searchInput.value && typeof document !== 'undefined' && document.activeElement === searchInput.value
+}
+defineExpose({ focusSearch, searchHasFocus })
 
 // #2258: the accessible name of the footer button, per principal kind.
 const signOutLabel = computed(() => signOutLabelFor(props.isPlatformSession))
diff --git a/src/frontend/src/components/portal/portalKeymap.js b/src/frontend/src/components/portal/portalKeymap.js
index fe14c2434..e265df441 100644
--- a/src/frontend/src/components/portal/portalKeymap.js
+++ b/src/frontend/src/components/portal/portalKeymap.js
@@ -78,6 +78,19 @@ export const WORKSPACE_KEYMAP = Object.freeze([
     label: 'Show or hide the rail',
     chord: chord({ key: '.', code: 'Period', primary: true }),
   }),
+  Object.freeze({
+    id: 'search-focus',
+    action: 'search-focus',
+    surface: 'workspace',
+    owner: OWNER_SHELL,
+    scope: SCOPE_DOING,
+    // The Dashboard's `/` filter key, with the modifier a key needs to work
+    // from INSIDE a text field. It focuses the sidebar search that exists —
+    // it is not the reserved `⌘K` surface above, and adds no second search.
+    label: 'Search agents and chats',
+    note: 'Press again to return to the message field.',
+    chord: chord({ key: '/', code: 'Slash', primary: true, shiftOnKey: true }),
+  }),
   Object.freeze({
     id: 'key-list',
     action: 'key-list',
@@ -85,7 +98,9 @@ export const WORKSPACE_KEYMAP = Object.freeze([
     owner: OWNER_SHELL,
     scope: SCOPE_DOING,
     label: 'Keyboard shortcuts',
-    chord: chord({ key: '/', code: 'Slash', primary: true, shiftOnKey: true }),
+    // ⌥/ since `⌘/` went to search: the same pairing as `⌘.` / `⌥.`. On a US
+    // Mac it types `÷`, so the physical `Slash` arm is the one that answers.
+    chord: chord({ key: '/', code: 'Slash', alt: true, shiftOnKey: true }),
   }),
   Object.freeze({
     id: 'agent-next',
@@ -339,11 +354,11 @@ export function keymapCollisions(map = WORKSPACE_KEYMAP) {
  * drawer — suppresses EVERY shell key, ⌘J included (today it remounts the
  * conversation under an open file preview). A voice call suppresses the keys
  * that would change what is on stage, plus the rail toggle; ⌘J keeps its own
- * "leave the call?" ask (ent#534/551) and ⌘/ is allowed, because opening a
+ * "leave the call?" ask (ent#534/551) and ⌥/ is allowed, because opening a
  * dialog leaves nothing.
  *
  * Per-action exemptions are the CALLER's: it passes `hasModalOpen`'s `ignore`
- * so rail keys do not see the rail's own sheet and ⌘/ can close its own list,
+ * so rail keys do not see the rail's own sheet and ⌥/ can close its own list,
  * `railAvailable` for the two entries marked `needsRail`, and `resumed` for the
  * pass that re-runs a parked ⌘J after the leave-call confirm.
  */
@@ -537,7 +552,81 @@ export function keyHint(actions, platform, map = WORKSPACE_KEYMAP) {
   return bindingsFor(actions, map).map((c) => chordLabel(c, platform)).join(' / ')
 }
 
+/**
+ * The same hint, PACKED: chords that share every modifier and differ only in a
+ * one-glyph key print the modifiers once — `⌥↑↓` for `⌥↑ / ⌥↓`,
+ * `Alt+Shift+↑↓` for the Windows pair. For a place too small for the long form
+ * (the rail's two-row tips); anything that cannot be packed without losing
+ * something — different modifiers, a key that is a word — falls back to
+ * `keyHint`, so the packed form is never a guess.
+ */
+export function keyHintCompact(actions, platform, map = WORKSPACE_KEYMAP) {
+  const chords = bindingsFor(actions, map)
+  if (chords.length < 2) return keyHint(actions, platform, map)
+  const [first] = chords
+  const glyphs = chords.map((c) => keyGlyph(c.key))
+  const packable = glyphs.every((g) => g.length === 1) && chords.every((c) =>
+    !!c.alt === !!first.alt && !!c.shift === !!first.shift && !!c.primary === !!first.primary)
+  if (!packable) return keyHint(actions, platform, map)
+  // `chordLabel` owns the modifier spelling and order; hand it the packed key.
+  return chordLabel({ ...first, key: null }, platform) + glyphs.join('')
+}
+
 /** The same binding as `aria-keyshortcuts` — ARIA's spelling, space-separated. */
 export function keyShortcutsFor(actions, platform, map = WORKSPACE_KEYMAP) {
   return ariaKeyshortcuts(bindingsFor(actions, map), platform)
 }
+
+/**
+ * The rail's tips panel — the handful of chords worth learning first.
+ *
+ * Declared as ACTIONS, never as glyphs: `keyTipRows` reads each row's keys
+ * from the map, so a chord that moves there moves on the panel in the same
+ * commit. Four on purpose — the panel is a nudge, and the full list is one
+ * button away.
+ */
+export const KEY_TIPS = Object.freeze([
+  Object.freeze({ id: 'agent', label: 'Switch agent', actions: Object.freeze(['agent-prev', 'agent-next']) }),
+  Object.freeze({ id: 'chat', label: 'Switch chat', actions: Object.freeze(['chat-prev', 'chat-next']) }),
+  Object.freeze({ id: 'search', label: 'Search', actions: Object.freeze(['search-focus']) }),
+  Object.freeze({ id: 'new-chat', label: 'New chat', actions: Object.freeze(['new-chat']) }),
+])
+
+/** The panel's rows. A tip whose actions the map no longer binds is dropped. */
+export function keyTipRows(platform, map = WORKSPACE_KEYMAP, tips = KEY_TIPS) {
+  return (Array.isArray(tips) ? tips : []).filter(Boolean).map((t) => ({
+    id: t.id,
+    label: t.label,
+    // Packed for the key cap (the panel is two rows of two); the long form is
+    // kept for the hover, where there is room to spell it out.
+    keys: keyHintCompact(t.actions, platform, map),
+    fullKeys: keyHint(t.actions, platform, map),
+  })).filter((r) => r.keys)
+}
+
+/**
+ * Whether this browser closed the tips panel. A per-viewer convenience, so it
+ * lives in `localStorage` and nowhere else; a storage that refuses (private
+ * mode, blocked site data) simply shows the panel again next load.
+ */
+export const KEY_TIPS_STORAGE_KEY = 'trinity-workspace-key-tips'
+
+export function loadKeyTipsDismissed(storage) {
+  try {
+    return !!storage && typeof storage.getItem === 'function'
+      && storage.getItem(KEY_TIPS_STORAGE_KEY) === 'dismissed'
+  } catch {
+    return false
+  }
+}
+
+export function saveKeyTipsDismissed(storage, dismissed) {
+  try {
+    if (!storage || typeof storage.setItem !== 'function') return false
+    if (dismissed) storage.setItem(KEY_TIPS_STORAGE_KEY, 'dismissed')
+    else storage.removeItem(KEY_TIPS_STORAGE_KEY)
+    return true
+  } catch {
+    return false
+  }
+}
diff --git a/src/frontend/src/views/Portal.vue b/src/frontend/src/views/Portal.vue
index bee257978..3e731818b 100644
--- a/src/frontend/src/views/Portal.vue
+++ b/src/frontend/src/views/Portal.vue
@@ -123,6 +123,7 @@
       <!-- Sidebar: persistent on desktop, drawer on mobile -->
       <div class="hidden sm:flex shrink-0 min-w-0 overflow-hidden sm:w-[var(--ws-sidebar,18rem)]">
         <PortalSidebar
+          ref="sidebarRef"
           :roster="orderedRoster"
           :active-agent-name="activeAgentName"
           :threads="sidebarThreads"
@@ -171,6 +172,7 @@
         <div class="absolute inset-0 bg-black/40" @click="mobileNav = false"></div>
         <div class="absolute inset-y-0 left-0">
           <PortalSidebar
+            ref="drawerSidebarRef"
             :roster="orderedRoster"
             :active-agent-name="activeAgentName"
             :threads="sidebarThreads"
@@ -720,9 +722,12 @@
         :open="railState.open"
         :signals="railSignals"
         :participants="railParticipants"
+        :key-tips="!keyTipsDismissed"
         @update:open="setRailOpen"
         @update:active-tab="setRailTab"
         @see-hints="seeHints"
+        @open-keys="keyListOpen = true"
+        @dismiss-key-tips="dismissKeyTips"
       >
         <!-- ent#475: the three re-homed tabs dock into the shell's slots. Each
              body READS a shell-owned store (`usePortalRailFeeds`) and never
@@ -851,7 +856,7 @@
          unmount it mid-sentence. -->
     <p class="sr-only" aria-live="polite" data-testid="ws-key-announce">{{ keyAnnouncement }}</p>
 
-    <!-- ent#621: `⌘/`. ALWAYS mounted and v-model driven — a `v-if` toggle
+    <!-- ent#621: `⌥/`. ALWAYS mounted and v-model driven — a `v-if` toggle
          unmounts past `BaseModal`'s close branch and focus never comes back to
          the message field. Rows come from the map, never from this template. -->
     <PortalKeyList
@@ -966,6 +971,7 @@ import {
 import {
   resolveWorkspaceKey, workspaceChord, keymapSuppressed, hasModalOpen, nextAgent, recordLastOpen,
   nextRailTab, keyListRows, hostPlatform, WORKSPACE_KEYMAP,
+  loadKeyTipsDismissed, saveKeyTipsDismissed,
 } from '@/components/portal/portalKeymap'
 // ent#557: the tab title's unread half. The router owns the label; this pushes
 // the count. See `utils/tabTitle.js` for why neither writes `document.title`.
@@ -2485,7 +2491,36 @@ function stepRailTab() {
 
 const railTabLabel = (id) => (railTabs.value.find((t) => t.id === id) || {}).label || 'Rail'
 
-// ⌘/ — the key list. It toggles rather than only opening, because the chord
+// ⌘/ — the cursor into the sidebar's search field (the Dashboard's `/` filter
+// key, with the modifier a key needs to work from inside a text field). The
+// shell has TWO sidebars and asks the one on screen: the column at and above
+// `sm`, the drawer below it — which the key opens first, since a field inside
+// a closed drawer cannot take focus. Pressed again from the field, it hands the
+// caret back to the message field: the chord that took you there is the one
+// your hand is still on.
+const sidebarRef = ref(null)
+const drawerSidebarRef = ref(null)
+function focusSearch() {
+  if (isWideViewport(typeof window !== 'undefined' ? window : null)) {
+    if (sidebarRef.value?.searchHasFocus?.()) { focusConversationComposer(); return }
+    sidebarRef.value?.focusSearch?.()
+    return
+  }
+  mobileNav.value = true
+  nextTick(() => drawerSidebarRef.value?.focusSearch?.())
+}
+
+// The rail's shortcut tips — on until the person closes them, and the close is
+// remembered for this browser (a per-viewer convenience, so `localStorage`; a
+// storage that refuses just shows them again next load). The ref lives here,
+// beside `railState`, so a chat switch never brings a closed panel back.
+const keyTipsDismissed = ref(loadKeyTipsDismissed(safeStorage()))
+function dismissKeyTips() {
+  keyTipsDismissed.value = true
+  saveKeyTipsDismissed(safeStorage(), true)
+}
+
+// ⌥/ — the key list. It toggles rather than only opening, because the chord
 // that showed you the list is the chord your hand is already on; `key-list` is
 // the one action allowed to see through its own dialog (`MODAL_IGNORE`).
 const keyListOpen = ref(false)
@@ -2521,6 +2556,7 @@ const KEY_DISPATCH = Object.freeze({
   'chat-prev': () => stepChat(-1),
   'rail-toggle': toggleRail,
   'rail-tab-next': stepRailTab,
+  'search-focus': focusSearch,
   'key-list': () => { keyListOpen.value = !keyListOpen.value },
 })
 
diff --git a/src/frontend/tests/unit/portalKeyHints.mount.spec.js b/src/frontend/tests/unit/portalKeyHints.mount.spec.js
index 06b359a16..4653b1a95 100644
--- a/src/frontend/tests/unit/portalKeyHints.mount.spec.js
+++ b/src/frontend/tests/unit/portalKeyHints.mount.spec.js
@@ -72,7 +72,7 @@ describe('ent#621 — the sidebar shows the agent keys', () => {
     w.unmount()
   })
 
-  it('has a button for the key list, so a mouse reaches what ⌘/ reaches', async () => {
+  it('has a button for the key list, so a mouse reaches what ⌥/ reaches', async () => {
     const w = mountSidebar()
     const btn = w.find('[data-testid="portal-sidebar-keys"]')
     expect(btn.exists()).toBe(true)
@@ -143,3 +143,55 @@ describe('ent#621 — the chat strip shows the chat keys', () => {
     w.unmount()
   })
 })
+
+describe('ent#621 (follow-up) — the search field shows and answers its key', () => {
+  const mountSidebar = (props = {}) => mount(PortalSidebar, {
+    attachTo: document.body,
+    props: {
+      roster: [{ name: 'scout' }, { name: 'sage' }],
+      activeAgentName: 'scout',
+      threads: [],
+      clientEmail: 'me@example.com',
+      ...props,
+    },
+    global: { plugins: [router] },
+  })
+  const field = (w) => w.find('input[type="search"]')
+  const cap = (w) => w.find('[data-testid="portal-sidebar-search-key"]')
+
+  it('carries the chord in both channels, read from the map', () => {
+    const w = mountSidebar()
+    expect(field(w).attributes('aria-keyshortcuts')).toBe(keyShortcutsFor('search-focus', P))
+    expect(field(w).attributes('title')).toContain(keyHint('search-focus', P))
+    expect(cap(w).exists()).toBe(true)
+    expect(cap(w).text()).toBe(keyHint('search-focus', P))
+    w.unmount()
+  })
+
+  it('the key cap steps aside for text and for focus', async () => {
+    // It sits where the field's own clear control appears, and a hint that
+    // covers what you are typing is worse than none.
+    const typed = mountSidebar({ search: 'sc' })
+    expect(cap(typed).exists()).toBe(false)
+    typed.unmount()
+
+    const w = mountSidebar()
+    await field(w).trigger('focus')
+    expect(cap(w).exists()).toBe(false)
+    await field(w).trigger('blur')
+    expect(cap(w).exists()).toBe(true)
+    w.unmount()
+  })
+
+  it('exposes focusSearch(), which focuses the field and selects what is in it', async () => {
+    const w = mountSidebar({ search: 'scout' })
+    const el = field(w).element
+    expect(w.vm.searchHasFocus()).toBe(false)
+    w.vm.focusSearch()
+    expect(document.activeElement).toBe(el)
+    expect(w.vm.searchHasFocus()).toBe(true)
+    expect(el.selectionStart).toBe(0)
+    expect(el.selectionEnd).toBe('scout'.length)
+    w.unmount()
+  })
+})
diff --git a/src/frontend/tests/unit/portalKeyList.mount.spec.js b/src/frontend/tests/unit/portalKeyList.mount.spec.js
index e2de1f975..e969c7561 100644
--- a/src/frontend/tests/unit/portalKeyList.mount.spec.js
+++ b/src/frontend/tests/unit/portalKeyList.mount.spec.js
@@ -1,6 +1,6 @@
 // @vitest-environment jsdom
 /**
- * ent#621 [C] — the `⌘/` key list, mounted.
+ * ent#621 [C] — the `⌥/` key list, mounted.
  *
  * Two things can only be proven by mounting it. First, that every row comes
  * from the MAP: a hand-typed list passes any test written against the same
@@ -90,7 +90,7 @@ describe('ent#621 — the key list is the map, rendered', () => {
 })
 
 describe('ent#621 — the key list keeps BaseModal\'s keyboard contract', () => {
-  it('is a real modal dialog, marked so ⌘/ can close its own list', async () => {
+  it('is a real modal dialog, marked so ⌥/ can close its own list', async () => {
     const w = open()
     const dialog = document.querySelector('[role="dialog"]')
     expect(dialog.getAttribute('aria-modal')).toBe('true')
@@ -133,7 +133,7 @@ describe('ent#621 — the key list keeps BaseModal\'s keyboard contract', () =>
     w.unmount()
   })
 
-  it('the close button asks the shell to close, so ⌘/ and the X agree', async () => {
+  it('the close button asks the shell to close, so ⌥/ and the X agree', async () => {
     const w = open()
     document.querySelector('[data-testid="ws-key-list-close"]').click()
     await w.vm.$nextTick()
diff --git a/src/frontend/tests/unit/portalKeyTips.mount.spec.js b/src/frontend/tests/unit/portalKeyTips.mount.spec.js
new file mode 100644
index 000000000..ebeafd998
--- /dev/null
+++ b/src/frontend/tests/unit/portalKeyTips.mount.spec.js
@@ -0,0 +1,137 @@
+// @vitest-environment jsdom
+/**
+ * ent#621 (follow-up) — the rail's shortcut tips panel, mounted.
+ *
+ * A small panel pinned to the bottom of the OPEN rail: four headline chords
+ * packed as two rows of two, a button that opens the full shortcuts dialog and
+ * a close — all inside those two rows. The collapsed strip
+ * carries the same door as one icon; the mobile sheet carries neither. It is
+ * dismissible, and the rail only REPORTS the dismissal — the shell owns the
+ * memory (`workspaceKeymap.mount.spec.js`).
+ *
+ * Mounted through `PortalRail`, not alone: where it sits (after the body, in
+ * the open form only) is the rail's decision and half of what is promised.
+ */
+import { describe, it, expect, beforeEach } from 'vitest'
+import { mount } from '@vue/test-utils'
+import { setActivePinia, createPinia } from 'pinia'
+import PortalRail from '@/components/portal/PortalRail.vue'
+import { keyTipRows, keyHint, hostPlatform } from '@/components/portal/portalKeymap'
+
+globalThis.ResizeObserver = globalThis.ResizeObserver || class { observe() {} unobserve() {} disconnect() {} }
+
+const P = hostPlatform()
+const TABS = [
+  { id: 'work', label: 'Work', signal: 'work' },
+  { id: 'info', label: 'Info', signal: 'info' },
+]
+const mountRail = (props = {}) => mount(PortalRail, {
+  attachTo: document.body,
+  props: { tabs: TABS, activeTab: 'work', open: true, keyTips: true, participants: ['scout'], ...props },
+})
+const panel = (w) => w.find('[data-testid="ws-key-tips"]')
+
+beforeEach(() => {
+  setActivePinia(createPinia())
+  document.body.innerHTML = ''
+})
+
+describe('ent#621 (follow-up) — the tips panel in the open rail', () => {
+  it('lists the four headline chords, read from the map', () => {
+    const w = mountRail()
+    expect(panel(w).exists()).toBe(true)
+    const rows = panel(w).findAll('[data-ws-key-tip]')
+    const want = keyTipRows(P)
+    expect(rows.map((r) => r.attributes('data-ws-key-tip'))).toEqual(want.map((r) => r.id))
+    for (const [i, row] of rows.entries()) {
+      expect(row.text()).toContain(want[i].label)
+      expect(row.find('kbd').text()).toBe(want[i].keys)
+    }
+    // The search row is the chord the sidebar field shows, not a second spelling.
+    expect(panel(w).text()).toContain(keyHint('search-focus', P))
+    w.unmount()
+  })
+
+  it('is two rows of two: agent over chat, search over new chat', () => {
+    // jsdom lays nothing out, so this pins the three things the packing rests
+    // on (the real geometry is checked in a browser): the list flows by COLUMN
+    // into two rows, a label may shorten but a key cap never wraps, and a
+    // shortened label is still readable on hover.
+    const w = mountRail()
+    const list = panel(w).find('ul')
+    expect(list.classes()).toEqual(expect.arrayContaining(['grid', 'grid-flow-col', 'grid-rows-2']))
+    const rows = list.findAll('li')
+    expect(rows.map((r) => r.attributes('data-ws-key-tip'))).toEqual(['agent', 'chat', 'search', 'new-chat'])
+    for (const row of rows) {
+      expect(row.find('kbd').classes()).toContain('whitespace-nowrap')
+      const label = row.find('[data-ws-key-tip-label]')
+      expect(label.classes()).toContain('truncate')
+      expect(row.attributes('title')).toContain(label.text())
+    }
+    // Nothing above or below the two rows: no heading line, no footer button.
+    expect(panel(w).find('h3').exists()).toBe(false)
+    w.unmount()
+  })
+
+  it('sits AFTER the body, so it is the bottom of the rail and never over its content', () => {
+    const w = mountRail()
+    const body = w.find('[data-testid="portal-rail-body"]').element
+    const tips = panel(w).element
+    expect(body.compareDocumentPosition(tips) & Node.DOCUMENT_POSITION_FOLLOWING).toBeTruthy()
+    // A sibling of the scroll area, not a child: it does not scroll away.
+    expect(body.contains(tips)).toBe(false)
+    w.unmount()
+  })
+
+  it('its button asks the shell for the full list', async () => {
+    const w = mountRail()
+    const all = panel(w).find('[data-testid="ws-key-tips-all"]')
+    // Icon-only to fit the two rows, so the name has to be in the label.
+    expect(all.attributes('aria-label')).toContain('All shortcuts')
+    expect(all.attributes('title')).toContain(keyHint('key-list', P))
+    await all.trigger('click')
+    expect(w.emitted('open-keys')).toHaveLength(1)
+    w.unmount()
+  })
+
+  it('its close reports the dismissal and names what it does', async () => {
+    const w = mountRail()
+    const close = panel(w).find('[data-testid="ws-key-tips-close"]')
+    expect(close.attributes('aria-label')).toBe('Hide shortcut tips')
+    await close.trigger('click')
+    expect(w.emitted('dismiss-key-tips')).toHaveLength(1)
+    w.unmount()
+  })
+
+  it('is gone once the shell says it was dismissed', () => {
+    const w = mountRail({ keyTips: false })
+    expect(panel(w).exists()).toBe(false)
+    w.unmount()
+  })
+})
+
+describe('ent#621 (follow-up) — the other two rail forms', () => {
+  it('collapsed: one icon at the foot of the strip opens the list', async () => {
+    const w = mountRail({ open: false })
+    expect(panel(w).exists()).toBe(false)          // 48px holds no panel
+    const btn = w.find('[data-testid="portal-rail-keys"]')
+    expect(btn.exists()).toBe(true)
+    expect(btn.attributes('title')).toContain(keyHint('key-list', P))
+    await btn.trigger('click')
+    expect(w.emitted('open-keys')).toHaveLength(1)
+    w.unmount()
+  })
+
+  it('collapsed and dismissed: the icon goes with the panel', () => {
+    const w = mountRail({ open: false, keyTips: false })
+    expect(w.find('[data-testid="portal-rail-keys"]').exists()).toBe(false)
+    w.unmount()
+  })
+
+  it('the mobile sheet shows neither — there is no keyboard to hint at', () => {
+    const w = mountRail({ sheet: true })
+    expect(panel(w).exists()).toBe(false)
+    expect(w.find('[data-testid="portal-rail-keys"]').exists()).toBe(false)
+    w.unmount()
+  })
+})
diff --git a/src/frontend/tests/unit/workspaceKeymap.dom.spec.js b/src/frontend/tests/unit/workspaceKeymap.dom.spec.js
index 98105772b..0266c54d8 100644
--- a/src/frontend/tests/unit/workspaceKeymap.dom.spec.js
+++ b/src/frontend/tests/unit/workspaceKeymap.dom.spec.js
@@ -11,7 +11,7 @@
  * overlay that says it is modal — including ones that do not exist yet, which
  * is why this is a probe and not a registry — and it must NOT see the one the
  * pressed key belongs to: the rail's own sheet for the rail keys, the key list
- * itself for ⌘/. That exemption is per action, which is what keeps `⌥↓` from
+ * itself for ⌥/. That exemption is per action, which is what keeps `⌥↓` from
  * switching agent behind an open sheet.
  */
 import { describe, it, expect, afterEach } from 'vitest'
@@ -58,7 +58,7 @@ describe('hasModalOpen', () => {
     expect(hasModalOpen(document, { ignore: ['[data-ws-rail-sheet]', '[data-ws-key-list]'] })).toBe(false)
   })
 
-  it('lets ⌘/ close its own list while every other key stays suppressed', () => {
+  it('lets ⌥/ close its own list while every other key stays suppressed', () => {
     add('<div role="dialog" aria-modal="true" data-ws-key-list></div>')
     expect(hasModalOpen(document, { ignore: '[data-ws-key-list]' })).toBe(false)
     expect(hasModalOpen(document)).toBe(true)
diff --git a/src/frontend/tests/unit/workspaceKeymap.mount.spec.js b/src/frontend/tests/unit/workspaceKeymap.mount.spec.js
index 6c389b73d..d38b9d0ab 100644
--- a/src/frontend/tests/unit/workspaceKeymap.mount.spec.js
+++ b/src/frontend/tests/unit/workspaceKeymap.mount.spec.js
@@ -114,7 +114,7 @@ function arm(threads = THREADS, roster = ROSTER) {
 // wiring. Unmounted in `afterEach`, which is also what proves the teardown
 // removes the listener.
 let mounted = []
-async function boot(path, { threads = THREADS, roster = ROSTER } = {}) {
+async function boot(path, { threads = THREADS, roster = ROSTER, stubs = {} } = {}) {
   arm(threads, roster)
   const router = makeRouter()
   await router.push(path)
@@ -124,9 +124,9 @@ async function boot(path, { threads = THREADS, roster = ROSTER } = {}) {
     global: {
       plugins: [router],
       // `PortalKeyList` and `BaseModal` under it are NOT stubbed: what the
-      // ⌘/ cases prove is that a REAL `aria-modal` dialog appears, carrying
+      // ⌥/ cases prove is that a REAL `aria-modal` dialog appears, carrying
       // the `data-ws-key-list` marker on the same element — which is what lets
-      // ⌘/ close its own list while every other key is suppressed under it. A
+      // ⌥/ close its own list while every other key is suppressed under it. A
       // stub renders an empty tag and passes all of that with the dialog
       // unplugged and the marker on the wrong element.
       // `teleport: false` as well: `shallowMount` stubs `<Teleport>`, and
@@ -138,6 +138,7 @@ async function boot(path, { threads = THREADS, roster = ROSTER } = {}) {
         PortalKeyList: false,
         BaseModal: false,
         teleport: false,
+        ...stubs,
       },
     },
   })
@@ -678,12 +679,12 @@ describe('ent#621 [C] — ⌥. walks the rail tabs', () => {
   })
 })
 
-describe('ent#621 [C] — ⌘/ opens the key list', () => {
+describe('ent#621 [C] — ⌥/ opens the key list', () => {
   it('opens, lists every key the map declares but the reserved one, and toggles shut', async () => {
     const { w } = await boot('/workspace/c/s-main')
     expect(document.querySelector('[data-testid="ws-key-list"]')).toBe(null)
 
-    await press(w, { key: '/', meta: true })
+    await press(w, { key: '/', alt: true })
     const dialog = document.querySelector('[data-ws-key-list]')
     expect(dialog).not.toBe(null)
     expect(dialog.getAttribute('role')).toBe('dialog')
@@ -704,13 +705,13 @@ describe('ent#621 [C] — ⌘/ opens the key list', () => {
     // The one action allowed to see through its own dialog: the chord that
     // opened the list closes it, rather than being swallowed by the modal
     // suppression the list itself triggers.
-    await press(w, { key: '/', meta: true })
+    await press(w, { key: '/', alt: true })
     expect(document.querySelector('[data-ws-key-list]')).toBe(null)
   })
 
   it('suppresses every other key while it is open', async () => {
     const { w } = await boot('/workspace/c/s-main')
-    await press(w, { key: '/', meta: true })
+    await press(w, { key: '/', alt: true })
     await press(w, { key: 'ArrowDown', alt: true })
     expect(showing(w).agent).toBe('scout')
   })
@@ -719,7 +720,103 @@ describe('ent#621 [C] — ⌘/ opens the key list', () => {
     const { w } = await boot('/workspace/c/s-main')
     w.vm.voiceCall = { active: true, agentName: 'scout', voiceSessionId: 'v1' }
     await w.vm.$nextTick()
+    await press(w, { key: '/', alt: true })
+    expect(document.querySelector('[data-ws-key-list]')).not.toBe(null)
+  })
+})
+
+// The sidebar, stubbed but honest about the two things the shell reaches
+// through its ref for the search key. Passed per-case (`boot(..., { stubs })`)
+// so every other case keeps the auto-stub it was written against.
+function sidebarStub({ focused = false } = {}) {
+  const focusSearch = vi.fn()
+  const stub = defineComponent({
+    name: 'PortalSidebar',
+    props: ['roster', 'activeAgentName', 'threads', 'search'],
+    setup(_, { expose }) {
+      expose({ focusSearch, searchHasFocus: () => focused })
+      return () => h('div')
+    },
+  })
+  return { stub, focusSearch }
+}
+
+describe('ent#621 (follow-up) — ⌘/ puts the cursor in the sidebar search', () => {
+  it('focuses the desktop sidebar\'s search field, and claims the chord', async () => {
+    viewport(true)
+    const { stub, focusSearch } = sidebarStub()
+    const { w } = await boot('/workspace/c/s-main', { stubs: { PortalSidebar: stub } })
+    const e = await press(w, { key: '/', meta: true })
+    expect(focusSearch).toHaveBeenCalledTimes(1)
+    expect(e.defaultPrevented).toBe(true)
+    expect(w.vm.mobileNav).toBe(false)             // the column, not the drawer
+    expect(showing(w).agent).toBe('scout')          // and the stage did not move
+  })
+
+  it('pressed again from the search field, hands the caret back to the message field', async () => {
+    viewport(true)
+    const { stub, focusSearch } = sidebarStub({ focused: true })
+    const { w } = await boot('/workspace/c/s-main', { stubs: { PortalSidebar: stub } })
+    focusComposer.mockClear()
+    await press(w, { key: '/', meta: true })
+    expect(focusComposer).toHaveBeenCalled()
+    expect(focusSearch).not.toHaveBeenCalled()
+  })
+
+  it('below `sm` it opens the drawer and focuses THAT sidebar\'s field', async () => {
+    viewport(false)
+    const { stub, focusSearch } = sidebarStub()
+    const { w } = await boot('/workspace/c/s-main', { stubs: { PortalSidebar: stub } })
+    await press(w, { key: '/', meta: true })
+    expect(w.vm.mobileNav).toBe(true)
+    expect(focusSearch).toHaveBeenCalledTimes(1)
+  })
+
+  it('is suppressed under a dialog, like every other shell key', async () => {
+    viewport(true)
+    const { stub, focusSearch } = sidebarStub()
+    const { w } = await boot('/workspace/c/s-main', { stubs: { PortalSidebar: stub } })
+    await press(w, { key: '/', alt: true })         // the key list — a real modal
+    expect(document.querySelector('[data-ws-key-list]')).not.toBe(null)
+    const e = await press(w, { key: '/', meta: true })
+    expect(focusSearch).not.toHaveBeenCalled()
+    expect(e.defaultPrevented).toBe(false)
+  })
+
+  it('works during a voice call — focusing a field leaves nothing', async () => {
+    viewport(true)
+    const { stub, focusSearch } = sidebarStub()
+    const { w } = await boot('/workspace/c/s-main', { stubs: { PortalSidebar: stub } })
+    w.vm.voiceCall = { active: true, agentName: 'scout', voiceSessionId: 'v1' }
+    await w.vm.$nextTick()
     await press(w, { key: '/', meta: true })
+    expect(focusSearch).toHaveBeenCalledTimes(1)
+  })
+})
+
+describe('ent#621 (follow-up) — the rail\'s shortcut tips', () => {
+  const railOf = (w) => w.findComponent({ name: 'PortalRail' })
+
+  it('are on until dismissed, and a dismissal is remembered across a reload', async () => {
+    viewport(true)
+    const { w } = await boot('/workspace/c/s-main')
+    expect(railOf(w).props('keyTips')).toBe(true)
+
+    railOf(w).vm.$emit('dismiss-key-tips')
+    await w.vm.$nextTick()
+    expect(railOf(w).props('keyTips')).toBe(false)
+
+    // A fresh shell — the reload — reads the same browser's storage.
+    const again = await boot('/workspace/c/s-main')
+    expect(railOf(again.w).props('keyTips')).toBe(false)
+  })
+
+  it('the panel\'s button opens the same list ⌥/ opens', async () => {
+    viewport(true)
+    const { w } = await boot('/workspace/c/s-main')
+    expect(document.querySelector('[data-ws-key-list]')).toBe(null)
+    railOf(w).vm.$emit('open-keys')
+    await flushPromises()
     expect(document.querySelector('[data-ws-key-list]')).not.toBe(null)
   })
 })
diff --git a/src/frontend/tests/unit/workspaceKeymap.spec.js b/src/frontend/tests/unit/workspaceKeymap.spec.js
index 1e5501fcf..c39f350a7 100644
--- a/src/frontend/tests/unit/workspaceKeymap.spec.js
+++ b/src/frontend/tests/unit/workspaceKeymap.spec.js
@@ -26,6 +26,7 @@ import {
   entryChords, findBinding, matchesChord, resolveWorkspaceKey, workspaceChord, keymapCollisions,
   keymapSuppressed, cycleIndex, nextAgent, recordLastOpen, nextRailTab,
   chordLabel, ariaKeyshortcuts, keyListRows,
+  KEY_TIPS, keyTipRows, keyHint, keyHintCompact, KEY_TIPS_STORAGE_KEY, loadKeyTipsDismissed, saveKeyTipsDismissed,
 } from '../../src/components/portal/portalKeymap'
 import { isNewChatHotkey, newChatHotkeyLabel } from '../../src/components/portal/portalUtils'
 
@@ -60,10 +61,10 @@ describe('the map as a declaration', () => {
     }
   })
 
-  it('declares the nine chords the issue names, plus the protocol keys', () => {
+  it('declares the ten shell chords, plus the protocol keys', () => {
     const shell = WORKSPACE_KEYMAP.filter((e) => e.owner === OWNER_SHELL)
     expect(shell.map((e) => e.action)).toEqual([
-      'find-anything', 'new-chat', 'rail-toggle', 'key-list',
+      'find-anything', 'new-chat', 'rail-toggle', 'search-focus', 'key-list',
       'agent-next', 'agent-prev', 'chat-next', 'chat-prev', 'rail-tab-next',
     ])
     expect(shell.filter((e) => e.reserved).map((e) => e.action)).toEqual(['find-anything'])
@@ -95,6 +96,7 @@ describe('the map as a declaration', () => {
 describe('matchesChord', () => {
   const railToggle = chordOf('rail-toggle')
   const keyList = chordOf('key-list')
+  const search = chordOf('search-focus')
   const agentNext = chordOf('agent-next')
   const chatNext = chordOf('chat-next')
   const railTab = chordOf('rail-tab-next')
@@ -134,11 +136,17 @@ describe('matchesChord', () => {
 
   it('accepts Shift on the printed key but never on the physical one (Decision 29)', () => {
     // DE: `/` is Shift+7. FR: `.` is a shifted key. Both must work.
-    expect(matchesChord(ev({ key: '/', code: 'Digit7', metaKey: true, shiftKey: true }), keyList)).toBe(true)
-    expect(matchesChord(ev({ key: '/', code: 'Slash', metaKey: true }), keyList)).toBe(true)
+    expect(matchesChord(ev({ key: '/', code: 'Digit7', metaKey: true, shiftKey: true }), search)).toBe(true)
+    expect(matchesChord(ev({ key: '/', code: 'Slash', metaKey: true }), search)).toBe(true)
     // macOS ⌘? (Help search) is Shift on the Slash POSITION with `key: '?'`:
     // neither arm may claim it.
-    expect(matchesChord(ev({ key: '?', code: 'Slash', metaKey: true, shiftKey: true }), keyList)).toBe(false)
+    expect(matchesChord(ev({ key: '?', code: 'Slash', metaKey: true, shiftKey: true }), search)).toBe(false)
+    // ⌥/ on a US Mac types `÷`: the Slash position is the arm that answers.
+    expect(matchesChord(ev({ key: '÷', code: 'Slash', altKey: true }), keyList)).toBe(true)
+    expect(matchesChord(ev({ key: '/', code: 'Slash', altKey: true }), keyList)).toBe(true)
+    // …and the two `/` chords never answer for each other.
+    expect(matchesChord(ev({ key: '/', code: 'Slash', metaKey: true }), keyList)).toBe(false)
+    expect(matchesChord(ev({ key: '÷', code: 'Slash', altKey: true }), search)).toBe(false)
     // A chord without `shiftOnKey` rejects Shift outright.
     expect(matchesChord(ev({ key: '.', metaKey: true, shiftKey: true }), railToggle)).toBe(false)
   })
@@ -164,7 +172,9 @@ describe('resolveWorkspaceKey', () => {
     expect(resolveWorkspaceKey(ev({ key: 'j', metaKey: true }))).toBe('new-chat')
     expect(resolveWorkspaceKey(ev({ key: 'j', ctrlKey: true }))).toBe('new-chat')
     expect(resolveWorkspaceKey(ev({ key: '.', metaKey: true }))).toBe('rail-toggle')
-    expect(resolveWorkspaceKey(ev({ key: '/', metaKey: true }))).toBe('key-list')
+    expect(resolveWorkspaceKey(ev({ key: '/', metaKey: true }))).toBe('search-focus')
+    expect(resolveWorkspaceKey(ev({ key: '/', ctrlKey: true }))).toBe('search-focus')
+    expect(resolveWorkspaceKey(ev({ key: '÷', code: 'Slash', altKey: true }))).toBe('key-list')
     expect(resolveWorkspaceKey(ev({ key: 'ArrowDown', altKey: true }))).toBe('agent-next')
     expect(resolveWorkspaceKey(ev({ key: 'ArrowUp', altKey: true }))).toBe('agent-prev')
     expect(resolveWorkspaceKey(ev({ key: 'ArrowDown', altKey: true, shiftKey: true }))).toBe('chat-next')
@@ -259,7 +269,7 @@ describe('keymapSuppressed', () => {
     for (const action of ['agent-next', 'agent-prev', 'chat-next', 'chat-prev', 'rail-tab-next', 'rail-toggle']) {
       expect(sup({ action, callActive: true }), action).toBe(true)
     }
-    // ⌘J keeps its own "leave the call?" ask; ⌘/ opens a dialog, which leaves
+    // ⌘J keeps its own "leave the call?" ask; ⌥/ opens a dialog, which leaves
     // nothing.
     expect(sup({ action: 'new-chat', callActive: true })).toBe(false)
     expect(sup({ action: 'key-list', callActive: true })).toBe(false)
@@ -354,7 +364,10 @@ describe('what people and screen readers read', () => {
     expect(chordLabel(chordOf('new-chat'), 'MacIntel')).toBe('⌘J')
     expect(chordLabel(chordOf('new-chat'), 'Win32')).toBe('Ctrl+J')
     expect(chordLabel(chordOf('rail-toggle'), 'MacIntel')).toBe('⌘.')
-    expect(chordLabel(chordOf('key-list'), 'Linux x86_64')).toBe('Ctrl+/')
+    expect(chordLabel(chordOf('key-list'), 'Linux x86_64')).toBe('Alt+/')
+    expect(chordLabel(chordOf('key-list'), 'MacIntel')).toBe('⌥/')
+    expect(chordLabel(chordOf('search-focus'), 'Linux x86_64')).toBe('Ctrl+/')
+    expect(chordLabel(chordOf('search-focus'), 'MacIntel')).toBe('⌘/')
     expect(chordLabel(chordOf('agent-next'), 'MacIntel')).toBe('⌥↓')
     expect(chordLabel(chordOf('agent-prev'), 'Win32')).toBe('Alt+↑')
     expect(chordLabel(chordOf('chat-next'), 'MacIntel')).toBe('⌥⇧↓')
@@ -376,7 +389,8 @@ describe('what people and screen readers read', () => {
     expect(ariaKeyshortcuts(chordOf('rail-tab-next'), 'Win32')).toBe('Alt+.')
     expect(ariaKeyshortcuts(chordOf('rail-toggle'), 'MacIntel')).toBe('Meta+.')
     expect(ariaKeyshortcuts(chordOf('rail-toggle'), 'Win32')).toBe('Control+.')
-    expect(ariaKeyshortcuts(chordOf('key-list'), 'MacIntel')).toBe('Meta+/')
+    expect(ariaKeyshortcuts(chordOf('key-list'), 'MacIntel')).toBe('Alt+/')
+    expect(ariaKeyshortcuts(chordOf('search-focus'), 'MacIntel')).toBe('Meta+/')
     expect(ariaKeyshortcuts(chordOf('new-chat'), 'MacIntel')).toBe('Meta+J')
     // Alternatives are space-separated, which is the attribute's own grammar.
     expect(ariaKeyshortcuts(entryChords(findBinding('tab-roving')), 'Win32'))
@@ -414,3 +428,75 @@ describe('keyListRows', () => {
     expect(rows.find((r) => r.action === 'call-mute').note).toMatch(/voice call/i)
   })
 })
+
+describe('ent#621 — the search key and the tips panel (follow-up)', () => {
+  const sup = (o) => keymapSuppressed({ action: 'search-focus', ...o })
+
+  it('⌘/ is a key you may use during a call, and never under a dialog', () => {
+    // Focusing a field leaves nothing, so a call does not suppress it; anything
+    // modal does, like every other shell key.
+    expect(sup({ callActive: true })).toBe(false)
+    expect(sup({ modalOpen: true })).toBe(true)
+    expect(sup({ drawerOpen: true })).toBe(true)
+    expect(findBinding('search-focus').scope).toBe(SCOPE_DOING)
+  })
+
+  it('the tips are four headline chords, every one read from the map', () => {
+    expect(KEY_TIPS.map((t) => t.id)).toEqual(['agent', 'chat', 'search', 'new-chat'])
+    for (const tip of KEY_TIPS) {
+      // A tip naming an action the map does not declare would render a row
+      // with no key — the dead row the key list already refuses.
+      for (const action of tip.actions) expect(findBinding(action), action).not.toBeNull()
+    }
+    const mac = keyTipRows('MacIntel')
+    // PACKED: the panel is two rows of two, so a pair of chords that differ
+    // only in their last key prints its modifiers once.
+    expect(mac.map((r) => r.keys)).toEqual(['⌥↑↓', '⌥⇧↑↓', '⌘/', '⌘J'])
+    expect(keyTipRows('Win32').map((r) => r.keys)).toEqual(['Alt+↑↓', 'Alt+Shift+↑↓', 'Ctrl+/', 'Ctrl+J'])
+    // DERIVED, not typed: the row is whatever the map says for its actions —
+    // packed for the cap, spelled out in full for the hover.
+    for (const [i, tip] of KEY_TIPS.entries()) {
+      expect(mac[i].keys).toBe(keyHintCompact(tip.actions, 'MacIntel'))
+      expect(mac[i].fullKeys).toBe(keyHint(tip.actions, 'MacIntel'))
+    }
+    expect(mac.every((r) => r.label)).toBe(true)
+  })
+
+  it('packs a pair of chords only when nothing is lost by it', () => {
+    expect(keyHintCompact(['agent-prev', 'agent-next'], 'MacIntel')).toBe('⌥↑↓')
+    expect(keyHintCompact(['chat-prev', 'chat-next'], 'Linux x86_64')).toBe('Alt+Shift+↑↓')
+    // One chord is just that chord.
+    expect(keyHintCompact('search-focus', 'MacIntel')).toBe(keyHint('search-focus', 'MacIntel'))
+    // Different modifiers cannot share a prefix: spelled out, as `keyHint` does.
+    expect(keyHintCompact(['rail-toggle', 'rail-tab-next'], 'MacIntel')).toBe(keyHint(['rail-toggle', 'rail-tab-next'], 'MacIntel'))
+    // …and neither can a key that is a word rather than a glyph.
+    expect(keyHintCompact(['close-top', 'call-mute'], 'MacIntel')).toBe(keyHint(['close-top', 'call-mute'], 'MacIntel'))
+    expect(keyHintCompact(['no-such-action'], 'MacIntel')).toBe('')
+  })
+
+  it('a tip whose actions the map no longer binds is dropped, not shown keyless', () => {
+    const rows = keyTipRows('MacIntel', WORKSPACE_KEYMAP, [{ id: 'gone', label: 'Gone', actions: ['no-such-action'] }, KEY_TIPS[2]])
+    expect(rows.map((r) => r.id)).toEqual(['search'])
+  })
+
+  it('remembers a dismissal per browser, and survives a storage that refuses', () => {
+    const mem = new Map()
+    const storage = {
+      getItem: (k) => (mem.has(k) ? mem.get(k) : null),
+      setItem: (k, v) => mem.set(k, String(v)),
+      removeItem: (k) => mem.delete(k),
+    }
+    expect(loadKeyTipsDismissed(storage)).toBe(false)
+    expect(saveKeyTipsDismissed(storage, true)).toBe(true)
+    expect(mem.has(KEY_TIPS_STORAGE_KEY)).toBe(true)
+    expect(loadKeyTipsDismissed(storage)).toBe(true)
+    saveKeyTipsDismissed(storage, false)
+    expect(loadKeyTipsDismissed(storage)).toBe(false)
+    // Private mode / blocked site data: shown, and the close still works for
+    // this page load (the shell holds the ref) — it just is not remembered.
+    const broken = { getItem() { throw new Error('denied') }, setItem() { throw new Error('denied') }, removeItem() { throw new Error('denied') } }
+    expect(loadKeyTipsDismissed(broken)).toBe(false)
+    expect(saveKeyTipsDismissed(broken, true)).toBe(false)
+    expect(loadKeyTipsDismissed(null)).toBe(false)
+  })
+})