From f324c4ac7cfddbb81c39f58252250ea4036b0a73 Mon Sep 17 00:00:00 2001
From: "Anthony Fu (via agent)" <reg-github-bot@antfu.me>
Date: Fri, 30 Oct 2026 00:23:19 +0000
Subject: [PATCH] feat(hub-ui): pin group members to the dock bar and keep
 recent tools

- Add Pin/Unpin to the dock context menu, and open the menu on group
  popover and group sidebar members. The menu takes focus, supports
  arrow keys, and Escape closes it and returns focus to the trigger.
- A pinned group member now also gets its own dock bar button, so a
  tool such as Nuxt > Components is one click away.
- The float bar keeps up to `docksRecentLimit` (default 3) tools last
  opened from a group popover or the overflow menu, in slots after the
  bar items. Recent group members show even when the bar does not
  overflow. The session store gains `recentDockIds`; `recentDockId` is
  deprecated and still read.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 docs/content/1.guide/16.hub.md                |   9 +
 .../client/components/dock/Dock.stories.ts    |  21 +-
 .../src/client/components/dock/Dock.vue       |  55 ++--
 .../client/components/dock/DockContextMenu.ts |  79 +++++-
 .../components/dock/DockGroupPopover.vue      |  11 +
 .../components/dock/DockGroupSidebar.vue      |  12 +
 .../views-builtin/SettingsAppearance.vue      |  27 ++
 .../hub-ui/src/client/i18n/locales/de.json    |   3 +
 .../hub-ui/src/client/i18n/locales/en.json    |   3 +
 .../hub-ui/src/client/i18n/locales/es.json    |   3 +
 .../hub-ui/src/client/i18n/locales/fr.json    |   3 +
 .../hub-ui/src/client/i18n/locales/ja.json    |   3 +
 .../hub-ui/src/client/i18n/locales/ko.json    |   3 +
 .../hub-ui/src/client/i18n/locales/pt-BR.json |   3 +
 .../hub-ui/src/client/i18n/locales/ru.json    |   3 +
 .../hub-ui/src/client/i18n/locales/zh-CN.json |   3 +
 .../hub-ui/src/client/i18n/locales/zh-TW.json |   3 +
 packages/hub-ui/src/client/state/commands.ts  |   4 +
 packages/hub-ui/src/client/state/context.ts   |   2 +-
 .../src/client/state/dock-settings.test.ts    | 176 ++++++++-----
 .../hub-ui/src/client/state/dock-settings.ts  | 247 ++++++++++--------
 packages/hub-ui/src/client/state/docks.ts     |   2 +-
 .../src/client/state/settings-defaults.ts     |   8 +-
 packages/hub-ui/src/client/types.ts           |   7 +
 packages/hub/src/client/docks.ts              |  19 +-
 .../@devframes/hub/client.snapshot.d.ts       |   1 +
 26 files changed, 501 insertions(+), 209 deletions(-)

diff --git a/docs/content/1.guide/16.hub.md b/docs/content/1.guide/16.hub.md
index 7cd1250dc..a48fcaf92 100644
--- a/docs/content/1.guide/16.hub.md
+++ b/docs/content/1.guide/16.hub.md
@@ -245,6 +245,15 @@ The first time any member of a group opens in a session, the hub also loads the
 
 Declare `defaultChildId` when one member is the natural landing spot; leave it off when the members are peers.
 
+### Pinned and recent tools
+
+The reference hub UI (`@devframes/hub-ui`) lets users reach a group member in one click. A devframe does not need to set anything for this.
+
+- **Pin.** Right-click a dock button (on the bar, in a group popover, or in the group sidebar) and pick **Pin**. Keyboard users press Shift+F10 or the Menu key on a focused button. A pinned entry moves to the front of the bar. A pinned group member also gets its own bar button, and it still leads inside its group. Opening it opens that member, and its group button shows as active. Pins are stored in the `docksPinned` user setting.
+- **Recent.** When a user opens a tool from a group popover or the overflow menu, the float bar keeps it in a slot after the bar items, newest first. The slots are added on top of the bar's capacity, so opening a tool never pushes another button into the overflow. A tool that is already on the bar (for example a pinned member) does not take a slot. The list is kept per browser tab, in the `recentDockIds` field of the session store.
+
+The `docksRecentLimit` user setting sets how many recent slots the bar keeps. The default is `3`. `0` turns the slots off. Users change it under **Settings > Appearance > Recent tools on the dock bar**. The edge-mode toolbar shows pinned entries but no recent slots.
+
 ### The dual role of `category`
 
 `category` (ordered by `DEFAULT_CATEGORIES_ORDER`, default `'default'`) sets an **ungrouped** entry's outer dock-rail bucket. A **grouped** entry takes its outer bucket from the **group's** `category`, and its own `category` becomes an **in-group sub-category**; a member whose `groupId` never resolves renders top-level under its own `category`.
diff --git a/packages/hub-ui/src/client/components/dock/Dock.stories.ts b/packages/hub-ui/src/client/components/dock/Dock.stories.ts
index c07efad5a..529abfe26 100644
--- a/packages/hub-ui/src/client/components/dock/Dock.stories.ts
+++ b/packages/hub-ui/src/client/components/dock/Dock.stories.ts
@@ -92,6 +92,18 @@ export const WithGroups: Story = floatStory(
   { entries: groupedEntries, panel: { position: 'bottom', left: 50, top: 100, inactiveTimeout: -1 } },
 )
 
+/**
+ * Pinned and recent group members: pinning Nuxt > Components gives it its own
+ * bar button (it also leads inside the Nuxt popover), and Nuxt > Pages, last
+ * opened from the popover, keeps a recent slot after the divider.
+ */
+export const WithPinnedAndRecentMembers: Story = floatStory({
+  entries: groupedEntries,
+  settings: { docksPinned: ['nuxt:components'] },
+  session: { recentDockIds: ['nuxt:pages'] },
+  panel: { position: 'bottom', left: 50, top: 100, inactiveTimeout: -1 },
+})
+
 /** Past capacity: an overflow button appears at the end of the bar. */
 export const WithOverflow: Story = floatStory(
   { entries: overflowEntries, panel: { position: 'bottom', left: 50, top: 100, inactiveTimeout: -1 } },
@@ -137,15 +149,16 @@ export const LowerCapacity: Story = {
 
 /**
  * A recent dock raised out of the overflow: selecting an entry from the
- * overflow popover reserves the slot between the divider and the overflow
- * button for it, and deselecting it (or selecting a visible neighbour) keeps
- * it there instead of folding it straight back into the overflow.
+ * overflow popover gives it its own slot after the divider, and deselecting
+ * it (or selecting a visible neighbour) keeps it there instead of folding it
+ * straight back into the overflow. Up to `docksRecentLimit` (default 3) docks
+ * keep a slot, newest first.
  */
 export const WithRecentDock: Story = {
   ...floatStory({
     entries: overflowEntries,
     selectedId: 'network',
-    session: { recentDockId: 'network' },
+    session: { recentDockIds: ['network'] },
     panel: { position: 'bottom', left: 50, top: 100, inactiveTimeout: -1 },
   }),
   args: { maxVisibleItems: 3 },
diff --git a/packages/hub-ui/src/client/components/dock/Dock.vue b/packages/hub-ui/src/client/components/dock/Dock.vue
index 43453e8a6..0935b1d10 100644
--- a/packages/hub-ui/src/client/components/dock/Dock.vue
+++ b/packages/hub-ui/src/client/components/dock/Dock.vue
@@ -6,9 +6,9 @@ import { useEventListener, useScreenSafeArea, whenever } from '@vueuse/core'
 import { computed, onMounted, reactive, ref, useTemplateRef, watch } from 'vue'
 import { BUILTIN_ENTRY_CLIENT_AUTH_NOTICE } from '../../constants'
 import { t } from '../../i18n'
-import { docksSplitGroupsWithCapacity, getEntryGroup, resolveNextRecentDockId, resolveRecentDockEntry } from '../../state/dock-settings'
-import { sharedStateToRef } from '../../state/docks'
+import { docksSplitGroupsWithCapacity, getEntryGroup, resolveNextRecentDockIds, resolveRecentDockEntries } from '../../state/dock-settings'
 import { setDocksOverflowPanel, useDocksGroupPanel } from '../../state/floating-tooltip'
+import { useSettings } from '../../state/settings-defaults'
 import { useIsRpcTrusted } from '../../utils/useIsRpcTrusted'
 import BrandMark from '../icons/BrandMark.vue'
 import {
@@ -95,30 +95,35 @@ const isRpcTrusted = useIsRpcTrusted(context, (isTrusted) => {
 
 const groupedEntries = computed(() => context.docks.groupedEntries)
 
-const settings = sharedStateToRef(context.docks.settings)
-
-// The recent dock: the entry last selected from beyond the bar (the overflow
-// popover or a group popover), raised into its own slot between the visible
-// items and the overflow button so deselecting it keeps it one click away.
-// Persisted per-tab in the session store; resolved to `null` when the id no
-// longer maps to a raisable entry.
-const recentEntry = computed(() => resolveRecentDockEntry({
-  entries: context.docks.entries,
-  groups: groupedEntries.value,
-  recentId: context.panel.session.recentDockId,
-  settings: settings.value,
-  whenContext: context.when.context,
-}))
+const settings = useSettings(context)
+
+// The recent docks: the entries last selected from beyond the bar (the
+// overflow popover or a group popover), raised into their own slots after the
+// visible items so they stay one click away. Persisted per-tab in the session
+// store (newest first); ids that no longer map to a raisable entry drop out.
+// `recentDockId` is the older single-entry field, read until a tab writes
+// `recentDockIds`.
+const recentEntries = computed(() => {
+  const session = context.panel.session
+  return resolveRecentDockEntries({
+    entries: context.docks.entries,
+    groups: groupedEntries.value,
+    recentIds: session.recentDockIds ?? (session.recentDockId ? [session.recentDockId] : []),
+    limit: settings.value.docksRecentLimit,
+    settings: settings.value,
+    whenContext: context.when.context,
+  })
+})
 
 const splitEntries = computed(() => {
-  return docksSplitGroupsWithCapacity(groupedEntries.value, layout.value.maxVisibleItems, recentEntry.value)
+  return docksSplitGroupsWithCapacity(groupedEntries.value, layout.value.maxVisibleItems, recentEntries.value)
 })
 
 const selectedEntry = computed(() => {
   return context.docks.selected
 })
 
-// Remember the recent dock whenever the selection lands on an entry that has
+// Remember a recent dock whenever the selection lands on an entry that has
 // no slot on the bar as currently rendered (grouped members always; top-level
 // entries when picked from the overflow popover). Observing the selection
 // (rather than the bar's own click handlers) also covers selections made via
@@ -126,13 +131,15 @@ const selectedEntry = computed(() => {
 watch(selectedEntry, (entry) => {
   if (!entry)
     return
-  context.panel.session.recentDockId = resolveNextRecentDockId({
+  context.panel.session.recentDockIds = resolveNextRecentDockIds({
     groups: groupedEntries.value,
     capacity: layout.value.maxVisibleItems,
-    recentEntry: recentEntry.value,
+    recentEntries: recentEntries.value,
     selected: entry,
     selectedIsGroupMember: !!getEntryGroup(context.docks.entries, entry),
+    limit: settings.value.docksRecentLimit,
   })
+  context.panel.session.recentDockId = undefined
 })
 
 onMounted(async () => {
@@ -344,16 +351,18 @@ onMounted(() => {
             @select="(e) => context.docks.switchEntry(e?.id)"
           />
 
-          <template v-if="splitEntries.overflow.length > 0">
+          <template v-if="splitEntries.recent.length > 0">
             <div class="border-base m1 h-20px w-px border-r-1.5" />
             <DockEntries
-              v-if="splitEntries.recent"
               :context="context"
-              :entries="[splitEntries.recent]"
+              :entries="splitEntries.recent"
               :is-vertical="context.panel.isVertical"
               :selected="selectedEntry"
               @select="(e) => context.docks.switchEntry(e?.id)"
             />
+          </template>
+          <template v-if="splitEntries.overflow.length > 0">
+            <div v-if="splitEntries.recent.length === 0" class="border-base m1 h-20px w-px border-r-1.5" />
             <DockOverflowButton
               :context="context"
               :is-vertical="context.panel.isVertical"
diff --git a/packages/hub-ui/src/client/components/dock/DockContextMenu.ts b/packages/hub-ui/src/client/components/dock/DockContextMenu.ts
index fb692cde9..2109325eb 100644
--- a/packages/hub-ui/src/client/components/dock/DockContextMenu.ts
+++ b/packages/hub-ui/src/client/components/dock/DockContextMenu.ts
@@ -1,6 +1,6 @@
 import type { DevframeDockEntry } from '@devframes/hub'
 import type { DocksContext } from '@devframes/hub/client'
-import { h } from 'vue'
+import { defineComponent, h, nextTick, onMounted, ref } from 'vue'
 import { t } from '../../i18n'
 import { setDockContextMenu } from '../../state/floating-tooltip'
 import { isDockPopupSupported, requestDockPopupOpen, useIsDockPopupOpen } from '../../state/popup'
@@ -16,7 +16,8 @@ interface DockMenuItem {
 
 function renderMenuItem(item: DockMenuItem) {
   return h('button', {
-    class: 'flex items-center gap-2 px3 py1.5 rounded hover:bg-active transition text-left',
+    role: 'menuitem',
+    class: 'flex items-center gap-2 px3 py1.5 rounded hover:bg-active focus-visible:bg-active outline-none transition text-left',
     onClick: item.action,
   }, [
     h('div', { class: `${item.icon} text-base op60` }),
@@ -24,6 +25,55 @@ function renderMenuItem(item: DockMenuItem) {
   ])
 }
 
+/**
+ * The menu body. Takes focus on open so a keyboard user (Shift+F10 or the
+ * Menu key fire `contextmenu` on the focused dock button) can pick an item
+ * right away: arrows and Home/End move between items, Escape closes the menu
+ * and hands focus back to the trigger, Tab closes it.
+ */
+const DockContextMenuList = defineComponent({
+  name: 'DockContextMenuList',
+  props: {
+    items: { type: Array as () => DockMenuItem[], required: true },
+    trigger: { type: Object as () => HTMLElement, required: true },
+  },
+  setup(props) {
+    const root = ref<HTMLElement>()
+    const buttons = () => Array.from(root.value?.querySelectorAll<HTMLButtonElement>('[role="menuitem"]') ?? [])
+
+    onMounted(() => nextTick(() => buttons()[0]?.focus({ preventScroll: true })))
+
+    function onKeydown(e: KeyboardEvent) {
+      const list = buttons()
+      const index = list.indexOf(e.target as HTMLButtonElement)
+      const move = (to: number) => {
+        e.preventDefault()
+        list[(to + list.length) % list.length]?.focus()
+      }
+      switch (e.key) {
+        case 'ArrowDown': return move(index + 1)
+        case 'ArrowUp': return move(index - 1)
+        case 'Home': return move(0)
+        case 'End': return move(list.length - 1)
+        case 'Escape':
+          e.preventDefault()
+          setDockContextMenu(null)
+          props.trigger.focus({ preventScroll: true })
+          return
+        case 'Tab':
+          setDockContextMenu(null)
+      }
+    }
+
+    return () => h('div', {
+      ref: root,
+      role: 'menu',
+      class: 'devframes-dock-menu flex flex-col text-sm min-w-36 mx--1',
+      onKeydown,
+    }, props.items.map(renderMenuItem))
+  },
+})
+
 function hideDock(context: DocksContext, entry: DevframeDockEntry) {
   const settingsStore = context.docks.settings
   const id = entry.id
@@ -49,6 +99,22 @@ function refreshDock(context: DocksContext, entry: DevframeDockEntry) {
   setDockContextMenu(null)
 }
 
+function togglePinDock(context: DocksContext, entry: DevframeDockEntry) {
+  const id = entry.id
+  context.docks.settings.mutate((state) => {
+    state.docksPinned = state.docksPinned.includes(id)
+      ? state.docksPinned.filter(item => item !== id)
+      : [...state.docksPinned, id]
+  })
+  setDockContextMenu(null)
+}
+
+function canPin(context: DocksContext, entry: DevframeDockEntry) {
+  if (entry.id.startsWith('~'))
+    return false
+  return context.docks.entries.some(item => item.id === entry.id)
+}
+
 function canHide(context: DocksContext, entry: DevframeDockEntry) {
   if (entry.id === '~settings')
     return false
@@ -67,7 +133,14 @@ export function openDockContextMenu(options: {
 }) {
   const { context, entry, el, gap = 6 } = options
   const isEdgeMode = context.panel.store.mode === 'edge'
+  const isPinned = context.docks.settings.value().docksPinned.includes(entry.id)
   const items: DockMenuItem[] = [
+    {
+      label: isPinned ? t('docks.unpin') : t('docks.pin'),
+      icon: isPinned ? 'i-ph-push-pin-slash-duotone' : 'i-ph-push-pin-duotone',
+      action: () => togglePinDock(context, entry),
+      visible: canPin(context, entry),
+    },
     {
       label: t('common.hide'),
       icon: 'i-ph-eye-slash-duotone',
@@ -131,6 +204,6 @@ export function openDockContextMenu(options: {
   setDockContextMenu({
     el,
     gap,
-    content: () => h('div', { class: 'flex flex-col text-sm min-w-36 mx--1' }, items.map(renderMenuItem)),
+    content: () => h(DockContextMenuList, { items, trigger: el }),
   })
 }
diff --git a/packages/hub-ui/src/client/components/dock/DockGroupPopover.vue b/packages/hub-ui/src/client/components/dock/DockGroupPopover.vue
index 66a75f66b..598a5876f 100644
--- a/packages/hub-ui/src/client/components/dock/DockGroupPopover.vue
+++ b/packages/hub-ui/src/client/components/dock/DockGroupPopover.vue
@@ -4,6 +4,7 @@ import type { DocksContext } from '@devframes/hub/client'
 import { computed } from 'vue'
 import { t } from '../../i18n'
 import { accentVarStyle } from '../../utils/accent-color'
+import { openDockContextMenu } from './DockContextMenu'
 import DockIcon from './DockIcon.vue'
 
 const props = defineProps<{
@@ -19,6 +20,15 @@ const emit = defineEmits<{
 }>()
 
 const isEmpty = computed(() => props.members.every(([, items]) => items.length === 0))
+
+function openContextMenu(e: MouseEvent, member: DevframeDockEntry) {
+  e.preventDefault()
+  openDockContextMenu({
+    context: props.context,
+    entry: member,
+    el: e.currentTarget as HTMLElement,
+  })
+}
 </script>
 
 <template>
@@ -47,6 +57,7 @@ const isEmpty = computed(() => props.members.every(([, items]) => items.length =
         class="flex items-center gap-2 w-full px2 py1.5 rounded text-sm text-left transition"
         :class="selectedId === member.id ? 'text-primary bg-active' : 'op80 hover:op100 hover:bg-active'"
         @click="emit('select', member)"
+        @contextmenu="openContextMenu($event, member)"
       >
         <DockIcon :icon="member.icon" class="w-4.5 h-4.5 flex-none" />
         <span class="truncate flex-1">{{ member.title }}</span>
diff --git a/packages/hub-ui/src/client/components/dock/DockGroupSidebar.vue b/packages/hub-ui/src/client/components/dock/DockGroupSidebar.vue
index e19d2503d..006398ea5 100644
--- a/packages/hub-ui/src/client/components/dock/DockGroupSidebar.vue
+++ b/packages/hub-ui/src/client/components/dock/DockGroupSidebar.vue
@@ -8,6 +8,7 @@ import { deriveSidebarCapacity, docksSplitGroupsWithCapacity, getGroupMembersGro
 import { setDocksSidebarOverflowPanel, setFloatingTooltip, useDocksSidebarOverflowPanel } from '../../state/floating-tooltip'
 import { useSettings } from '../../state/settings-defaults'
 import { accentVarStyle } from '../../utils/accent-color'
+import { openDockContextMenu } from './DockContextMenu'
 import DockGroupPopover from './DockGroupPopover.vue'
 import DockIcon from './DockIcon.vue'
 
@@ -147,6 +148,16 @@ watchDebounced(
   { debounce: 1000 },
 )
 
+function openContextMenu(e: MouseEvent, member: DevframeDockEntry) {
+  e.preventDefault()
+  hideTooltip()
+  openDockContextMenu({
+    context: props.context,
+    entry: member,
+    el: e.currentTarget as HTMLElement,
+  })
+}
+
 // Highlight the button when the hidden selection lives here, or while open.
 const moreButtonActive = computed(() => selectedInOverflow.value || isOverflowPanelVisible.value)
 </script>
@@ -185,6 +196,7 @@ const moreButtonActive = computed(() => selectedInOverflow.value || isOverflowPa
         @pointerleave="hideTooltip"
         @pointerdown="hideTooltip"
         @click="select(member.id)"
+        @contextmenu="openContextMenu($event, member)"
       >
         <DockIcon :icon="member.icon" class="w-5 h-5 flex-none" />
         <div
diff --git a/packages/hub-ui/src/client/components/views-builtin/SettingsAppearance.vue b/packages/hub-ui/src/client/components/views-builtin/SettingsAppearance.vue
index 4fae661cf..4134c4e55 100644
--- a/packages/hub-ui/src/client/components/views-builtin/SettingsAppearance.vue
+++ b/packages/hub-ui/src/client/components/views-builtin/SettingsAppearance.vue
@@ -46,6 +46,18 @@ const localeOptions = computed(() => [
   ...Object.entries(HUB_UI_LOCALES).map(([value, label]) => ({ value, label })),
 ])
 
+// `0` turns the recent slots off; the upper bound keeps the bar short.
+const recentLimitOptions = computed(() => [
+  { value: '0', label: t('appearance.recentDocksOff') },
+  ...[1, 2, 3, 4, 5].map(count => ({ value: String(count), label: String(count) })),
+])
+
+function onRecentLimitChange(value: string | undefined): void {
+  const limit = Number(value)
+  if (Number.isInteger(limit) && limit >= 0)
+    settingsStore.mutate((s) => { s.docksRecentLimit = limit })
+}
+
 function onLocaleChange(value: string | undefined): void {
   setLocalePreference(matchLocale(value) ?? 'auto')
 }
@@ -121,6 +133,21 @@ function setDockMode(mode: string) {
       </div>
     </div>
 
+    <!-- Recent docks on the float bar -->
+    <div class="flex flex-col gap-2">
+      <div class="flex flex-col">
+        <span class="text-sm">{{ t('appearance.recentDocks') }}</span>
+        <span class="text-xs op50">{{ t('appearance.recentDocksHint') }}</span>
+      </div>
+      <FormSelect
+        :model-value="String(settings.docksRecentLimit)"
+        :options="recentLimitOptions"
+        :aria-label="t('appearance.recentDocks')"
+        class="w-fit"
+        @update:model-value="onRecentLimitChange"
+      />
+    </div>
+
     <!-- Show iframe address bar toggle -->
     <label class="flex items-center gap-3 cursor-pointer group">
       <button
diff --git a/packages/hub-ui/src/client/i18n/locales/de.json b/packages/hub-ui/src/client/i18n/locales/de.json
index a6deb6517..85d1706a6 100644
--- a/packages/hub-ui/src/client/i18n/locales/de.json
+++ b/packages/hub-ui/src/client/i18n/locales/de.json
@@ -68,6 +68,9 @@
   "appearance.closeOutsideHint": "Schließt das {productName}-Panel bei einem Klick außerhalb (nur im eingebetteten Modus)",
   "appearance.autoCollapse": "Randleiste automatisch einklappen",
   "appearance.autoCollapseHint": "Verkleinert die am Rand angedockte Leiste zu einem kleinen Griff, wenn sie inaktiv und geschlossen ist (nur im Randmodus)",
+  "appearance.recentDocks": "Zuletzt verwendete Tools in der Dock-Leiste",
+  "appearance.recentDocksHint": "Zuletzt aus einer Gruppe oder dem Überlaufmenü geöffnete Tools in der Dock-Leiste behalten (nur im Float-Modus).",
+  "appearance.recentDocksOff": "Aus",
 
   "docks.intro": "Sichtbarkeit und Reihenfolge der Dock-Einträge verwalten. Ausgeblendete Einträge erscheinen nicht in der Dock-Leiste.",
   "docks.resetOrder": "Eigene Reihenfolge zurücksetzen",
diff --git a/packages/hub-ui/src/client/i18n/locales/en.json b/packages/hub-ui/src/client/i18n/locales/en.json
index 6c9f1ddb6..2eb653816 100644
--- a/packages/hub-ui/src/client/i18n/locales/en.json
+++ b/packages/hub-ui/src/client/i18n/locales/en.json
@@ -68,6 +68,9 @@
   "appearance.closeOutsideHint": "Close the {productName} panel when clicking outside of it (embedded mode only)",
   "appearance.autoCollapse": "Auto-collapse edge toolbar",
   "appearance.autoCollapseHint": "Shrink the edge-docked toolbar to a small handle when idle and closed (edge mode only)",
+  "appearance.recentDocks": "Recent tools on the dock bar",
+  "appearance.recentDocksHint": "Keep the tools you last opened from a group or the overflow menu on the dock bar (float mode only).",
+  "appearance.recentDocksOff": "Off",
 
   "docks.intro": "Manage visibility and order of dock entries. Hidden entries will not appear in the dock bar.",
   "docks.resetOrder": "Reset custom order",
diff --git a/packages/hub-ui/src/client/i18n/locales/es.json b/packages/hub-ui/src/client/i18n/locales/es.json
index d7df124dc..98e451d8d 100644
--- a/packages/hub-ui/src/client/i18n/locales/es.json
+++ b/packages/hub-ui/src/client/i18n/locales/es.json
@@ -68,6 +68,9 @@
   "appearance.closeOutsideHint": "Cierra el panel de {productName} al hacer clic fuera de él (solo en modo integrado)",
   "appearance.autoCollapse": "Contraer automáticamente la barra de borde",
   "appearance.autoCollapseHint": "Reduce la barra anclada al borde a un pequeño asa cuando está inactiva y cerrada (solo en modo de borde)",
+  "appearance.recentDocks": "Herramientas recientes en la barra",
+  "appearance.recentDocksHint": "Mantén en la barra las herramientas que abriste por última vez desde un grupo o el menú de desbordamiento (solo en modo flotante).",
+  "appearance.recentDocksOff": "Desactivado",
 
   "docks.intro": "Gestiona la visibilidad y el orden de los paneles. Los paneles ocultos no aparecerán en la barra.",
   "docks.resetOrder": "Restablecer orden personalizado",
diff --git a/packages/hub-ui/src/client/i18n/locales/fr.json b/packages/hub-ui/src/client/i18n/locales/fr.json
index 59c8369ab..4c57b86de 100644
--- a/packages/hub-ui/src/client/i18n/locales/fr.json
+++ b/packages/hub-ui/src/client/i18n/locales/fr.json
@@ -68,6 +68,9 @@
   "appearance.closeOutsideHint": "Ferme le panneau {productName} lors d'un clic en dehors de celui-ci (mode intégré uniquement)",
   "appearance.autoCollapse": "Réduire automatiquement la barre de bord",
   "appearance.autoCollapseHint": "Réduit la barre ancrée au bord en une petite poignée lorsqu'elle est inactive et fermée (mode bord uniquement)",
+  "appearance.recentDocks": "Outils récents dans la barre",
+  "appearance.recentDocksHint": "Garder dans la barre les derniers outils ouverts depuis un groupe ou le menu de débordement (mode flottant uniquement).",
+  "appearance.recentDocksOff": "Désactivé",
 
   "docks.intro": "Gérez la visibilité et l'ordre des panneaux. Les panneaux masqués n'apparaissent pas dans la barre.",
   "docks.resetOrder": "Réinitialiser l'ordre personnalisé",
diff --git a/packages/hub-ui/src/client/i18n/locales/ja.json b/packages/hub-ui/src/client/i18n/locales/ja.json
index 5d190d419..0cfc91f17 100644
--- a/packages/hub-ui/src/client/i18n/locales/ja.json
+++ b/packages/hub-ui/src/client/i18n/locales/ja.json
@@ -68,6 +68,9 @@
   "appearance.closeOutsideHint": "{productName} パネルの外側をクリックしたときにパネルを閉じます（埋め込みモードのみ）",
   "appearance.autoCollapse": "エッジツールバーを自動的に折りたたむ",
   "appearance.autoCollapseHint": "アイドル状態で閉じているとき、エッジに固定されたツールバーを小さなハンドルに縮めます（エッジモードのみ）",
+  "appearance.recentDocks": "ドックバーの最近使ったツール",
+  "appearance.recentDocksHint": "グループやオーバーフローメニューから最後に開いたツールをドックバーに表示します（フロートモードのみ）。",
+  "appearance.recentDocksOff": "オフ",
 
   "docks.intro": "ドック項目の表示と順序を管理します。非表示の項目はドックバーに表示されません。",
   "docks.resetOrder": "カスタム順序をリセット",
diff --git a/packages/hub-ui/src/client/i18n/locales/ko.json b/packages/hub-ui/src/client/i18n/locales/ko.json
index 1fc763d03..f33faab97 100644
--- a/packages/hub-ui/src/client/i18n/locales/ko.json
+++ b/packages/hub-ui/src/client/i18n/locales/ko.json
@@ -68,6 +68,9 @@
   "appearance.closeOutsideHint": "{productName} 패널 바깥쪽을 클릭하면 패널을 닫습니다 (임베디드 모드 전용)",
   "appearance.autoCollapse": "가장자리 도구 모음 자동 접기",
   "appearance.autoCollapseHint": "유휴 상태로 닫혀 있을 때 가장자리에 도킹된 도구 모음을 작은 핸들로 줄입니다 (가장자리 모드 전용)",
+  "appearance.recentDocks": "도크 바의 최근 도구",
+  "appearance.recentDocksHint": "그룹이나 오버플로 메뉴에서 마지막으로 연 도구를 도크 바에 유지합니다 (플로트 모드 전용).",
+  "appearance.recentDocksOff": "끄기",
 
   "docks.intro": "도크 항목의 표시 여부와 순서를 관리합니다. 숨긴 항목은 도크 바에 나타나지 않습니다.",
   "docks.resetOrder": "사용자 지정 순서 초기화",
diff --git a/packages/hub-ui/src/client/i18n/locales/pt-BR.json b/packages/hub-ui/src/client/i18n/locales/pt-BR.json
index 5b8d23d6d..e98064f17 100644
--- a/packages/hub-ui/src/client/i18n/locales/pt-BR.json
+++ b/packages/hub-ui/src/client/i18n/locales/pt-BR.json
@@ -68,6 +68,9 @@
   "appearance.closeOutsideHint": "Fecha o painel do {productName} ao clicar fora dele (somente no modo incorporado)",
   "appearance.autoCollapse": "Recolher automaticamente a barra de borda",
   "appearance.autoCollapseHint": "Reduz a barra encaixada na borda a uma pequena alça quando inativa e fechada (somente no modo de borda)",
+  "appearance.recentDocks": "Ferramentas recentes na barra",
+  "appearance.recentDocksHint": "Manter na barra as ferramentas abertas por último a partir de um grupo ou do menu de excedentes (somente no modo flutuante).",
+  "appearance.recentDocksOff": "Desativado",
 
   "docks.intro": "Gerencie a visibilidade e a ordem dos painéis. Painéis ocultos não aparecem na barra.",
   "docks.resetOrder": "Redefinir ordem personalizada",
diff --git a/packages/hub-ui/src/client/i18n/locales/ru.json b/packages/hub-ui/src/client/i18n/locales/ru.json
index 1a46a1a17..ee3e28c6e 100644
--- a/packages/hub-ui/src/client/i18n/locales/ru.json
+++ b/packages/hub-ui/src/client/i18n/locales/ru.json
@@ -68,6 +68,9 @@
   "appearance.closeOutsideHint": "Закрывать панель {productName} при клике вне её (только во встроенном режиме)",
   "appearance.autoCollapse": "Автоматически сворачивать панель у края",
   "appearance.autoCollapseHint": "Сворачивать закреплённую у края панель в небольшой ярлык, когда она неактивна и закрыта (только в режиме у края)",
+  "appearance.recentDocks": "Недавние инструменты на панели",
+  "appearance.recentDocksHint": "Оставлять на панели инструменты, недавно открытые из группы или меню переполнения (только в плавающем режиме).",
+  "appearance.recentDocksOff": "Выкл.",
 
   "docks.intro": "Управляйте видимостью и порядком панелей. Скрытые панели не отображаются на панели инструментов.",
   "docks.resetOrder": "Сбросить пользовательский порядок",
diff --git a/packages/hub-ui/src/client/i18n/locales/zh-CN.json b/packages/hub-ui/src/client/i18n/locales/zh-CN.json
index fb0a2046f..0987fd845 100644
--- a/packages/hub-ui/src/client/i18n/locales/zh-CN.json
+++ b/packages/hub-ui/src/client/i18n/locales/zh-CN.json
@@ -68,6 +68,9 @@
   "appearance.closeOutsideHint": "在 {productName} 面板外部点击时将其关闭（仅嵌入模式）",
   "appearance.autoCollapse": "自动收起边缘工具栏",
   "appearance.autoCollapseHint": "空闲且关闭时，将边缘停靠的工具栏收起为一个小把手（仅边缘模式）",
+  "appearance.recentDocks": "停靠栏中的最近工具",
+  "appearance.recentDocksHint": "在停靠栏中保留最近从分组或溢出菜单打开的工具（仅浮动模式）。",
+  "appearance.recentDocksOff": "关闭",
 
   "docks.intro": "管理工具面板条目的可见性和顺序。隐藏的条目不会出现在工具栏中。",
   "docks.resetOrder": "重置自定义顺序",
diff --git a/packages/hub-ui/src/client/i18n/locales/zh-TW.json b/packages/hub-ui/src/client/i18n/locales/zh-TW.json
index e3478f351..9aceffe56 100644
--- a/packages/hub-ui/src/client/i18n/locales/zh-TW.json
+++ b/packages/hub-ui/src/client/i18n/locales/zh-TW.json
@@ -68,6 +68,9 @@
   "appearance.closeOutsideHint": "在 {productName} 面板外部點擊時將其關閉（僅嵌入模式）",
   "appearance.autoCollapse": "自動收合邊緣工具列",
   "appearance.autoCollapseHint": "閒置且關閉時，將邊緣停靠的工具列收合為一個小把手（僅邊緣模式）",
+  "appearance.recentDocks": "停靠列中的最近工具",
+  "appearance.recentDocksHint": "在停靠列中保留最近從群組或溢出選單開啟的工具（僅限浮動模式）。",
+  "appearance.recentDocksOff": "關閉",
 
   "docks.intro": "管理工具面板項目的可見性和順序。隱藏的項目不會出現在工具列中。",
   "docks.resetOrder": "重設自訂順序",
diff --git a/packages/hub-ui/src/client/state/commands.ts b/packages/hub-ui/src/client/state/commands.ts
index 199ff5239..a34d180bb 100644
--- a/packages/hub-ui/src/client/state/commands.ts
+++ b/packages/hub-ui/src/client/state/commands.ts
@@ -153,6 +153,10 @@ function setupShortcutListener(
     // work for elements belonging to the popup window's realm.
     if (e.composedPath().some(target => (target as Element).classList?.contains('shortcut-key-input')))
       return
+    // An open dock context menu owns its keys (Escape closes the menu, not
+    // the panel; arrows move between items).
+    if (e.composedPath().some(target => (target as Element).classList?.contains('devframes-dock-menu')))
+      return
 
     const pressed = normalizeKeyEvent(e)
     if (!pressed || pressed === 'Mod' || pressed === 'Shift' || pressed === 'Alt')
diff --git a/packages/hub-ui/src/client/state/context.ts b/packages/hub-ui/src/client/state/context.ts
index 1592cd424..5410f5d92 100644
--- a/packages/hub-ui/src/client/state/context.ts
+++ b/packages/hub-ui/src/client/state/context.ts
@@ -456,7 +456,7 @@ export async function createDocksContext(
   // delivered once via the connection handshake.
   const categoryOrderOverride = rpc.connectionMeta.configs?.ui?.dockPreferences?.categoryOrder
   const groupedEntries = computed(() => {
-    return docksGroupByCategories(entries.value, settings.value, { whenContext: getWhenContext(), collapseGroups: true, categoryOrderOverride })
+    return docksGroupByCategories(entries.value, settings.value, { whenContext: getWhenContext(), collapseGroups: true, liftPinnedMembers: true, categoryOrderOverride })
   })
 
   // Initialize commands context with reactive when-context
diff --git a/packages/hub-ui/src/client/state/dock-settings.test.ts b/packages/hub-ui/src/client/state/dock-settings.test.ts
index 9bf9fe273..690eeeaa1 100644
--- a/packages/hub-ui/src/client/state/dock-settings.test.ts
+++ b/packages/hub-ui/src/client/state/dock-settings.test.ts
@@ -1,7 +1,8 @@
 import type { DevframeDockEntriesGrouped, DevframeDockEntry, DevframeViewGroup } from '@devframes/hub'
 import type { WhenContext } from 'devframe/utils/when'
+import { DEFAULT_STATE_USER_SETTINGS } from '@devframes/hub/constants'
 import { describe, expect, it } from 'vitest'
-import { docksSplitGroupsBySize, docksSplitGroupsWithCapacity, resolveGroupPreferredChild, resolveNextRecentDockId, resolveRecentDockEntry } from './dock-settings'
+import { docksGroupByCategories, docksSplitGroupsBySize, docksSplitGroupsWithCapacity, getGroupMembersGrouped, resolveGroupPreferredChild, resolveNextRecentDockIds, resolveRecentDockEntries } from './dock-settings'
 
 function iframe(id: string, extra: Partial<DevframeDockEntry> = {}): DevframeDockEntry {
   return { id, type: 'iframe', url: '/', title: id.toUpperCase(), icon: 'ph:cube-duotone', ...extra } as DevframeDockEntry
@@ -71,88 +72,137 @@ describe('docksSplitGroupsBySize', () => {
 })
 
 describe('docksSplitGroupsWithCapacity', () => {
-  it('splits naturally without a recent entry', () => {
+  it('splits naturally without recent entries', () => {
     const split = docksSplitGroupsWithCapacity(rail, 3)
     expect(ids(split.visible)).toEqual(['a', 'b', 'c'])
     expect(ids(split.overflow)).toEqual(['d', 'e'])
-    expect(split.recent).toBeNull()
+    expect(split.recent).toEqual([])
   })
 
-  it('reserves a slot for a recent entry from the overflow', () => {
-    const split = docksSplitGroupsWithCapacity(rail, 3, d)
-    expect(ids(split.visible)).toEqual(['a', 'b'])
-    expect(ids(split.overflow)).toEqual(['c', 'e'])
-    expect(split.recent).toBe(d)
+  it('raises a recent entry out of the overflow without displacing bar items', () => {
+    const split = docksSplitGroupsWithCapacity(rail, 3, [d])
+    // Only `e` is left beyond the bar, so it folds in instead of overflowing.
+    expect(ids(split.visible)).toEqual(['a', 'b', 'c', 'e'])
+    expect(ids(split.overflow)).toEqual([])
+    expect(split.recent).toEqual([d])
+  })
+
+  it('keeps several recent entries newest first', () => {
+    const f = iframe('f')
+    const longRail: DevframeDockEntriesGrouped = [['default', [a, b, c, d, e, f]]]
+    const split = docksSplitGroupsWithCapacity(longRail, 3, [e, d])
+    expect(ids(split.visible)).toEqual(['a', 'b', 'c', 'f'])
+    expect(split.recent).toEqual([e, d])
   })
 
-  it('renders a recent entry inside the natural slice in place, releasing the slot', () => {
-    const split = docksSplitGroupsWithCapacity(rail, 3, c)
+  it('renders a recent entry inside the visible slice in place', () => {
+    const split = docksSplitGroupsWithCapacity(rail, 3, [c])
     expect(ids(split.visible)).toEqual(['a', 'b', 'c'])
     expect(ids(split.overflow)).toEqual(['d', 'e'])
-    expect(split.recent).toBeNull()
+    expect(split.recent).toEqual([])
   })
 
-  it('raises a grouped member without touching the rail items in the overflow', () => {
+  it('raises a grouped member without touching the overflow', () => {
     const g = group('g')
     const member = iframe('g:member', { groupId: 'g' })
     const groupedRail: DevframeDockEntriesGrouped = [['default', [a, b, g, c, d]]]
-    const split = docksSplitGroupsWithCapacity(groupedRail, 3, member)
-    expect(ids(split.visible)).toEqual(['a', 'b'])
-    expect(ids(split.overflow)).toEqual(['g', 'c', 'd'])
-    expect(split.recent).toBe(member)
+    const split = docksSplitGroupsWithCapacity(groupedRail, 3, [member])
+    expect(ids(split.visible)).toEqual(['a', 'b', 'g'])
+    expect(ids(split.overflow)).toEqual(['c', 'd'])
+    expect(split.recent).toEqual([member])
   })
 
-  it('skips the reservation when there is no overflow', () => {
+  it('raises a grouped member when the bar does not overflow', () => {
     const member = iframe('g:member', { groupId: 'g' })
     const smallRail: DevframeDockEntriesGrouped = [['default', [a, b, c]]]
-    const split = docksSplitGroupsWithCapacity(smallRail, 3, member)
+    const split = docksSplitGroupsWithCapacity(smallRail, 3, [member])
     expect(ids(split.visible)).toEqual(['a', 'b', 'c'])
     expect(split.overflow).toEqual([])
-    expect(split.recent).toBeNull()
+    expect(split.recent).toEqual([member])
   })
 
-  it('keeps the lone-overflow fold ahead of the reservation', () => {
+  it('folds a lone overflowing entry, which then renders in place', () => {
     const foldRail: DevframeDockEntriesGrouped = [['default', [a, b, c, d]]]
-    const split = docksSplitGroupsWithCapacity(foldRail, 3, d)
+    const split = docksSplitGroupsWithCapacity(foldRail, 3, [d])
     expect(ids(split.visible)).toEqual(['a', 'b', 'c', 'd'])
     expect(split.overflow).toEqual([])
-    expect(split.recent).toBeNull()
+    expect(split.recent).toEqual([])
   })
 })
 
-describe('resolveNextRecentDockId', () => {
-  function next(recentEntry: DevframeDockEntry | null, selected: DevframeDockEntry, selectedIsGroupMember = false) {
-    return resolveNextRecentDockId({ groups: rail, capacity: 3, recentEntry, selected, selectedIsGroupMember })
+describe('resolveNextRecentDockIds', () => {
+  function next(recentEntries: DevframeDockEntry[], selected: DevframeDockEntry, selectedIsGroupMember = false, limit = 3) {
+    return resolveNextRecentDockIds({ groups: rail, capacity: 3, recentEntries, selected, selectedIsGroupMember, limit })
   }
 
-  it('follows the a–e walkthrough on a 3-slot bar', () => {
-    // [a] [b] [c] | [O]: selecting d from the overflow raises it
-    expect(next(null, d)).toBe('d')
-    // [a] [b] | {d} [O]: selecting visible a/b (or d itself) keeps d raised
-    expect(next(d, a)).toBe('d')
-    expect(next(d, b)).toBe('d')
-    expect(next(d, d)).toBe('d')
-    // [a] [b] | [d] [O]: selecting e from the overflow replaces d
-    expect(next(d, e)).toBe('e')
-    // selecting c (folded out by the reserved slot) becomes recent, and the
-    // split renders it in its natural place, back to [a] [b] {c} | [O]
-    expect(next(d, c)).toBe('c')
-    expect(docksSplitGroupsWithCapacity(rail, 3, c).recent).toBeNull()
-  })
-
-  it('always raises a grouped member', () => {
-    const member = iframe('g:member', { groupId: 'g' })
-    expect(next(null, member, true)).toBe('g:member')
-    expect(next(d, member, true)).toBe('g:member')
+  it('follows the a-e walkthrough on a 3-slot bar', () => {
+    // [a] [b] [c] | [O: d, e]: selecting d from the overflow raises it
+    expect(next([], d)).toEqual(['d'])
+    // [a] [b] [c] [e] | [d]: selecting a bar item or d itself keeps the list
+    expect(next([d], a)).toEqual(['d'])
+    expect(next([d], e)).toEqual(['d'])
+    expect(next([d], d)).toEqual(['d'])
+  })
+
+  it('puts a new grouped member first and drops the oldest past the limit', () => {
+    const [m1, m2, m3] = ['g:1', 'g:2', 'g:3'].map(id => iframe(id, { groupId: 'g' }))
+    expect(next([], m1, true)).toEqual(['g:1'])
+    expect(next([m1], m2, true)).toEqual(['g:2', 'g:1'])
+    expect(next([m2, m1], m3, true, 2)).toEqual(['g:3', 'g:2'])
+  })
+
+  it('keeps the slots in place when a recent member is opened again', () => {
+    const [m1, m2] = ['g:1', 'g:2'].map(id => iframe(id, { groupId: 'g' }))
+    expect(next([m2, m1], m1, true)).toEqual(['g:2', 'g:1'])
+  })
+
+  it('remembers nothing when the limit is 0', () => {
+    expect(next([d], e, false, 0)).toEqual([])
+    expect(next([], iframe('g:1', { groupId: 'g' }), true, 0)).toEqual([])
   })
 
-  it('keeps the recent dock when the selection is off the rail entirely', () => {
-    expect(next(d, iframe('~notice'))).toBe('d')
-    expect(next(null, iframe('~notice'))).toBeNull()
+  it('keeps the list when the selection is off the rail entirely', () => {
+    expect(next([d], iframe('~notice'))).toEqual(['d'])
+    expect(next([], iframe('~notice'))).toEqual([])
   })
 
-  it('keeps a naturally-visible selection from claiming the slot', () => {
-    expect(next(null, a)).toBeNull()
+  it('keeps a visible selection from claiming a slot', () => {
+    expect(next([], a)).toEqual([])
+  })
+})
+
+describe('pinned group members', () => {
+  const g = group('g', { category: 'framework' })
+  const m1 = iframe('g:1', { groupId: 'g' })
+  const m2 = iframe('g:2', { groupId: 'g' })
+  const entries = [a, g, m1, m2]
+  const settings = { ...DEFAULT_STATE_USER_SETTINGS(), docksPinned: ['g:2'] }
+
+  it('lifts a pinned member onto the bar when asked', () => {
+    const groups = docksGroupByCategories(entries, settings, { collapseGroups: true, liftPinnedMembers: true })
+    expect(groups.map(([category, items]) => [category, items.map(item => item.id)])).toEqual([
+      ['~pinned', ['g:2']],
+      ['framework', ['g']],
+      ['default', ['a']],
+    ])
+  })
+
+  it('keeps a pinned member collapsed without liftPinnedMembers', () => {
+    const groups = docksGroupByCategories(entries, settings, { collapseGroups: true })
+    expect(ids(groups)).toEqual(['g', 'a'])
+  })
+
+  it('still leads the pinned member inside its group', () => {
+    const members = getGroupMembersGrouped(entries, 'g', settings)
+    expect(members.map(([category, items]) => [category, items.map(item => item.id)])).toEqual([
+      ['~pinned', ['g:2']],
+      ['default', ['g:1']],
+    ])
+  })
+
+  it('renders a pinned recent member in place instead of in a recent slot', () => {
+    const groups = docksGroupByCategories(entries, settings, { collapseGroups: true, liftPinnedMembers: true })
+    expect(docksSplitGroupsWithCapacity(groups, 5, [m2, m1]).recent).toEqual([m1])
   })
 })
 
@@ -197,32 +247,32 @@ describe('resolveGroupPreferredChild', () => {
   })
 })
 
-describe('resolveRecentDockEntry', () => {
+describe('resolveRecentDockEntries', () => {
   const g = group('g')
   const member = iframe('g:member', { groupId: 'g' })
   const entries = [a, b, c, d, e, g, member]
   const groupedRail: DevframeDockEntriesGrouped = [['default', [a, b, c, d, e, g]]]
 
-  function resolve(recentId: string | null) {
-    return resolveRecentDockEntry({ entries, groups: groupedRail, recentId })
+  function resolve(recentIds: string[] | null, limit = 3) {
+    return resolveRecentDockEntries({ entries, groups: groupedRail, recentIds, limit })
   }
 
-  it('resolves a top-level rail entry', () => {
-    expect(resolve('d')).toBe(d)
+  it('resolves top-level rail entries and grouped members in order', () => {
+    expect(resolve(['g:member', 'd'])).toEqual([member, d])
   })
 
-  it('resolves a grouped member', () => {
-    expect(resolve('g:member')).toBe(member)
+  it('drops unknown ids and group buttons', () => {
+    expect(resolve(null)).toEqual([])
+    expect(resolve(['missing', 'g', 'd'])).toEqual([d])
   })
 
-  it('returns null for no id, an unknown id, or a group button', () => {
-    expect(resolve(null)).toBeNull()
-    expect(resolve('missing')).toBeNull()
-    expect(resolve('g')).toBeNull()
+  it('drops an entry that is off the rail', () => {
+    const hidden = iframe('hidden')
+    expect(resolveRecentDockEntries({ entries: [...entries, hidden], groups: groupedRail, recentIds: ['hidden'], limit: 3 })).toEqual([])
   })
 
-  it('returns null for an entry that is off the rail', () => {
-    const hidden = iframe('hidden')
-    expect(resolveRecentDockEntry({ entries: [...entries, hidden], groups: groupedRail, recentId: 'hidden' })).toBeNull()
+  it('caps the list at the limit', () => {
+    expect(resolve(['d', 'e', 'g:member'], 2)).toEqual([d, e])
+    expect(resolve(['d'], 0)).toEqual([])
   })
 })
diff --git a/packages/hub-ui/src/client/state/dock-settings.ts b/packages/hub-ui/src/client/state/dock-settings.ts
index b2135ad59..d7f0dbcf2 100644
--- a/packages/hub-ui/src/client/state/dock-settings.ts
+++ b/packages/hub-ui/src/client/state/dock-settings.ts
@@ -49,13 +49,13 @@ export interface SplitGroupsResult {
   visible: DevframeDockEntriesGrouped
   overflow: DevframeDockEntriesGrouped
   /**
-   * The recent dock raised out of the overflow into its own slot, rendered
-   * between the visible items and the overflow button. `null` when no slot is
-   * reserved: no recent dock, no overflow at all, or a recent dock that
-   * already sits inside the natural visible slice (it renders in place there
-   * instead of occupying a redundant slot).
+   * The recent docks raised into their own slots, newest first, rendered
+   * after the visible items and before the overflow button. Empty when no
+   * recent dock needs a slot: a recent dock that already sits inside the
+   * visible slice (a top-level entry, or a pinned member) renders in place
+   * there instead.
    */
-  recent: DevframeDockEntry | null
+  recent: DevframeDockEntry[]
 }
 
 /**
@@ -144,7 +144,8 @@ export function getEntryGroup(
  * `'default'`); the group's `category` is the *outer* bucket the whole group
  * lives in, so it never bleeds into the sub-category split here. A pinned member
  * moves to a `~pinned` sub-category (leading the group, via
- * {@link PINNED_CATEGORY_ORDER}). Sub-categories are ordered by the same
+ * {@link PINNED_CATEGORY_ORDER}); the dock bar also shows it on its own (see
+ * `liftPinnedMembers` on {@link docksGroupByCategories}). Sub-categories are ordered by the same
  * {@link DEFAULT_CATEGORIES_ORDER} table as top-level categories, unless the
  * group entry itself sets {@link DevframeViewGroup.categoryOrder}, whose
  * weights take precedence for this group's sub-categories only, leaving every
@@ -295,40 +296,52 @@ function compareEntryOrder(a: DevframeDockEntry, b: DevframeDockEntry, docksCust
   return ib === ia ? getDefaultTitle(b).localeCompare(getDefaultTitle(a)) : ia - ib
 }
 
-// A pinned top-level entry or group button re-buckets into `~pinned`; a grouped
-// member's outer bucket is left alone so pinning never promotes it onto the bar.
+// A pinned top-level entry or group button re-buckets into `~pinned`. A grouped
+// member's outer bucket is its group's category, unless the member is lifted
+// onto the bar (`liftPinnedMembers`), where it joins `~pinned` too.
 function resolveOuterCategory(
   entry: DevframeDockEntry,
   resolvedGroupCategory: string | undefined,
   docksPinned: readonly string[],
+  liftPinnedMembers: boolean,
 ): string {
   const ownCategory = resolvedGroupCategory ?? entry.category ?? 'default'
-  return docksPinned.includes(entry.id) && resolvedGroupCategory === undefined
+  return docksPinned.includes(entry.id) && (resolvedGroupCategory === undefined || liftPinnedMembers)
     ? PINNED_CATEGORY
     : ownCategory
 }
 
+// Collapse grouped members out of the top-level bar (orphans stay visible).
+// A lifted pinned member stays, so it gets its own button on the bar.
+function isCollapsedMember(
+  entry: DevframeDockEntry,
+  resolvedGroupCategory: string | undefined,
+  docksPinned: readonly string[],
+  liftPinnedMembers: boolean,
+): boolean {
+  return resolvedGroupCategory !== undefined && !(liftPinnedMembers && docksPinned.includes(entry.id))
+}
+
 function bucketEntriesByCategory(
   entries: DevframeDockEntry[],
   groupCategories: Map<string, string>,
   settings: Immutable<DevframeDocksUserSettings>,
-  options: { includeHidden: boolean, whenContext: WhenContext | undefined, collapseGroups: boolean, ignoreCategoryHidden: boolean },
+  options: { includeHidden: boolean, whenContext: WhenContext | undefined, collapseGroups: boolean, ignoreCategoryHidden: boolean, liftPinnedMembers: boolean },
 ): Map<string, DevframeDockEntry[]> {
   const { docksCategoriesHidden, docksPinned } = settings
-  const { includeHidden, whenContext, collapseGroups, ignoreCategoryHidden } = options
+  const { includeHidden, whenContext, collapseGroups, ignoreCategoryHidden, liftPinnedMembers } = options
   const map = new Map<string, DevframeDockEntry[]>()
   for (const entry of entries) {
     const resolvedGroupCategory = entry.type !== 'group' && entry.groupId
       ? groupCategories.get(entry.groupId)
       : undefined
 
-    // Collapse grouped members out of the top-level bar (orphans stay visible)
-    if (collapseGroups && resolvedGroupCategory !== undefined)
+    if (collapseGroups && isCollapsedMember(entry, resolvedGroupCategory, docksPinned, liftPinnedMembers))
       continue
     if (!includeHidden && isEntryRenderHidden(entry, settings, whenContext))
       continue
 
-    const category = resolveOuterCategory(entry, resolvedGroupCategory, docksPinned)
+    const category = resolveOuterCategory(entry, resolvedGroupCategory, docksPinned, liftPinnedMembers)
     // `~pinned` is never hideable, so a pinned entry survives its category being hidden.
     if (!includeHidden && !ignoreCategoryHidden && docksCategoriesHidden.includes(category))
       continue
@@ -365,8 +378,12 @@ function bucketEntriesByCategory(
  * entry or group button, or the in-group sub-category for a member (the
  * members-only in-group split has no group entries, so `resolvedGroupCategory`
  * is undefined there and the member's own category slot is the one replaced).
- * A grouped member's outer bucket is never re-pinned, so pinning a member
- * reorders it inside its group rather than promoting it onto the top-level bar.
+ * A grouped member's outer bucket is re-pinned only with `liftPinnedMembers`:
+ * the dock bar sets it, so a pinned member gets its own bar button (opening
+ * it opens that member, and its group button lights up as active) as well as
+ * leading inside its group. Without it (the settings list, which already
+ * shows members under their group) pinning only reorders the member inside
+ * its group.
  * Because the pinned bucket is chosen before the category-hide check and is
  * itself never hideable, a pinned entry stays visible even when its original
  * category is hidden.
@@ -380,13 +397,13 @@ function bucketEntriesByCategory(
 export function docksGroupByCategories(
   entries: DevframeDockEntry[],
   settings: Immutable<DevframeDocksUserSettings>,
-  options?: { includeHidden?: boolean, whenContext?: WhenContext, collapseGroups?: boolean, ignoreCategoryHidden?: boolean, categoryOrderOverride?: Record<string, number> },
+  options?: { includeHidden?: boolean, whenContext?: WhenContext, collapseGroups?: boolean, ignoreCategoryHidden?: boolean, liftPinnedMembers?: boolean, categoryOrderOverride?: Record<string, number> },
 ): DevframeDockEntriesGrouped {
   const { docksCustomOrder } = settings
-  const { includeHidden = false, whenContext, collapseGroups = false, ignoreCategoryHidden = false, categoryOrderOverride } = options ?? {}
+  const { includeHidden = false, whenContext, collapseGroups = false, ignoreCategoryHidden = false, liftPinnedMembers = false, categoryOrderOverride } = options ?? {}
 
   const groupCategories = collectGroupCategories(entries)
-  const map = bucketEntriesByCategory(entries, groupCategories, settings, { includeHidden, whenContext, collapseGroups, ignoreCategoryHidden })
+  const map = bucketEntriesByCategory(entries, groupCategories, settings, { includeHidden, whenContext, collapseGroups, ignoreCategoryHidden, liftPinnedMembers })
 
   const grouped = Array
     .from(map.entries())
@@ -481,50 +498,60 @@ function groupsHaveEntry(groups: DevframeDockEntriesGrouped, id: string): boolea
   return groups.some(([, items]) => items.some(item => item.id === id))
 }
 
+function countItems(groups: DevframeDockEntriesGrouped): number {
+  return groups.reduce((acc, [, items]) => acc + items.length, 0)
+}
+
+/**
+ * Slice at `capacity`, but fold a lone overflowing entry back into `visible`:
+ * a whole overflow affordance (button + badge + popover) just to reveal one
+ * icon costs more chrome than it saves, so that entry takes the slot the
+ * button would have used.
+ */
+function splitGroupsWithFold(
+  groups: DevframeDockEntriesGrouped,
+  capacity: number,
+): { visible: DevframeDockEntriesGrouped, overflow: DevframeDockEntriesGrouped } {
+  if (countItems(groups) <= capacity + 1)
+    return { visible: groups, overflow: [] }
+  return splitGroupsAt(groups, capacity)
+}
+
 /**
  * Split grouped entries into visible and overflow based on capacity.
  *
  * A lone overflowing entry folds back into `visible` instead of staying in
- * `overflow`: a whole overflow affordance (button + badge + popover) just to
- * reveal one icon costs more chrome than it saves, so that one entry renders
- * inline in the slot the affordance would have occupied. Folding only
- * triggers for exactly one overflowing entry; two or more still overflow
- * normally.
+ * `overflow` (see {@link splitGroupsWithFold}). Folding only triggers for
+ * exactly one overflowing entry; two or more still overflow normally.
  *
- * With a `recentEntry` (see {@link DockSessionStorage.recentDockId}; resolve
- * it via {@link resolveRecentDockEntry} first), one slot is reserved for the
- * recent dock: the natural items split at `capacity - 1`, the recent entry is
- * lifted out of the overflow buckets, and it is returned as `recent` for the
- * bar to render between the visible items and the overflow button. Total slot
- * count stays at `capacity`. The reservation is skipped (natural split, no
- * `recent`) when there is no overflow to raise out of, or when the recent
- * entry already sits inside the natural visible slice (it renders in place
- * there). A recent entry that is a grouped member never appears as a rail item
- * of its own, so it is always raised (its group button, if any, stays put).
+ * `recentEntries` (see {@link DockSessionStorage.recentDockIds}; resolve them
+ * via {@link resolveRecentDockEntries} first) are the docks the user last
+ * opened from beyond the bar. Each one that is not already in the visible
+ * slice is lifted out of the overflow and returned in `recent`, for the bar to
+ * render in its own slot after the visible items. Recent slots come on top of
+ * `capacity`, so opening a tool never pushes a bar item into the overflow. A
+ * grouped member has no bar button of its own (unless it is pinned), so a
+ * recent member always gets a slot, even when the bar does not overflow.
  */
 export function docksSplitGroupsWithCapacity(
   groups: DevframeDockEntriesGrouped,
   capacity: number,
-  recentEntry: DevframeDockEntry | null = null,
+  recentEntries: readonly DevframeDockEntry[] = [],
 ): SplitGroupsResult {
-  const natural = splitGroupsAt(groups, capacity)
-
-  if (natural.overflow.reduce((acc, [, items]) => acc + items.length, 0) === 1)
-    return { visible: [...natural.visible, ...natural.overflow], overflow: [], recent: null }
-
-  if (!recentEntry || natural.overflow.length === 0 || groupsHaveEntry(natural.visible, recentEntry.id))
-    return { ...natural, recent: null }
-
-  // Reserve one slot for the recent dock. The lone-overflow fold cannot apply
-  // here: a non-empty natural overflow implies at least two overflowing
-  // entries (a single one already folded above), so the reduced split always
-  // keeps two or more even after the recent entry is lifted out.
-  const reduced = splitGroupsAt(groups, Math.max(capacity - 1, 0))
-  const overflow = reduced.overflow
-    .map(([category, items]) => [category, items.filter(item => item.id !== recentEntry.id)] as [string, DevframeDockEntry[]])
+  const natural = splitGroupsWithFold(groups, capacity)
+  const recent = recentEntries.filter(entry => !groupsHaveEntry(natural.visible, entry.id))
+  if (recent.length === 0)
+    return { ...natural, recent }
+
+  // Raised entries sit beyond the visible slice, so dropping them from the
+  // groups leaves the visible slice as it was (or lets the lone-overflow fold
+  // apply to what remains).
+  const raisedIds = new Set(recent.map(entry => entry.id))
+  const remaining = groups
+    .map(([category, items]) => [category, items.filter(item => !raisedIds.has(item.id))] as [string, DevframeDockEntry[]])
     .filter(([, items]) => items.length > 0)
 
-  return { visible: reduced.visible, overflow, recent: recentEntry }
+  return { ...splitGroupsWithFold(remaining, capacity), recent }
 }
 
 /** Split an edge toolbar's entries using its available main-axis space. */
@@ -539,7 +566,7 @@ export function docksSplitGroupsBySize(
   const separators = Math.max(0, groups.length - 1)
   const fullSize = total * itemSize + separators * separatorSize + Math.max(0, total + separators - 1) * gap
   if (fullSize <= availableSize)
-    return docksSplitGroupsWithCapacity(groups, total)
+    return { visible: groups, overflow: [], recent: [] }
 
   // Reserve the overflow button first. Each visible entry/divider adds its
   // size plus a gap to the button or the next entry.
@@ -556,29 +583,16 @@ export function docksSplitGroupsBySize(
   }
   // Preserve a lone overflow entry: folding it inline can add a category
   // divider that exceeds the measured space.
-  return { ...splitGroupsAt(groups, capacity), recent: null }
+  return { ...splitGroupsAt(groups, capacity), recent: [] }
 }
 
-/**
- * Resolve a persisted recent-dock id (`DockSessionStorage.recentDockId`) to
- * the entry the float bar can raise, or `null` when the id no longer maps to a
- * raisable entry: it was unregistered, it is a group button (only concrete
- * docks occupy the recent slot), it is a grouped member hidden from its group,
- * or it is a top-level entry no longer present on the rail (hidden via user
- * settings, `when`, or `visibility`).
- */
-export function resolveRecentDockEntry(options: {
-  /** The raw dock entries (`context.docks.entries`). */
-  entries: DevframeDockEntry[]
-  /** The grouped rail items (`context.docks.groupedEntries`). */
-  groups: DevframeDockEntriesGrouped
-  recentId: string | null | undefined
-  settings?: Immutable<DevframeDocksUserSettings>
-  whenContext?: WhenContext
-}): DevframeDockEntry | null {
-  const { entries, groups, recentId, settings, whenContext } = options
-  if (!recentId)
-    return null
+function resolveRecentDockEntry(
+  entries: DevframeDockEntry[],
+  groups: DevframeDockEntriesGrouped,
+  recentId: string,
+  settings: Immutable<DevframeDocksUserSettings> | undefined,
+  whenContext: WhenContext | undefined,
+): DevframeDockEntry | null {
   const entry = entries.find(e => e.id === recentId)
   if (!entry || entry.type === 'group')
     return null
@@ -591,48 +605,71 @@ export function resolveRecentDockEntry(options: {
 }
 
 /**
- * Decide which dock id the recent slot should remember after a selection.
- *
- * The recent slot keeps the last dock selected from somewhere *not* on the
- * bar (the overflow popover or a group popover) one click away, so
- * deselecting it doesn't fold it straight back out of reach:
+ * Resolve the persisted recent-dock ids (`DockSessionStorage.recentDockIds`)
+ * to the entries the float bar can raise, newest first and capped at `limit`.
+ * An id is dropped when it no longer maps to a raisable entry: it was
+ * unregistered, it is a group button (only concrete docks occupy a recent
+ * slot), it is a grouped member hidden from its group, or it is a top-level
+ * entry no longer present on the rail (hidden via user settings, `when`, or
+ * `visibility`).
+ */
+export function resolveRecentDockEntries(options: {
+  /** The raw dock entries (`context.docks.entries`). */
+  entries: DevframeDockEntry[]
+  /** The grouped rail items (`context.docks.groupedEntries`). */
+  groups: DevframeDockEntriesGrouped
+  recentIds: readonly string[] | null | undefined
+  /** Maximum number of recent slots ({@link DevframeDocksUserSettings.docksRecentLimit}). */
+  limit: number
+  settings?: Immutable<DevframeDocksUserSettings>
+  whenContext?: WhenContext
+}): DevframeDockEntry[] {
+  const { entries, groups, recentIds, limit, settings, whenContext } = options
+  if (!recentIds || limit <= 0)
+    return []
+  return recentIds
+    .map(id => resolveRecentDockEntry(entries, groups, id, settings, whenContext))
+    .filter((entry): entry is DevframeDockEntry => entry !== null)
+    .slice(0, limit)
+}
+
+/**
+ * Decide which dock ids the recent slots should remember after a selection.
  *
- * - A grouped member always becomes the recent dock: its own entry never has
- *   a rail slot (only its group button does), so raising it is the only way
- *   the concrete selection stays directly toggleable.
- * - A top-level entry becomes the recent dock only when it was selected from
- *   the overflow popover (it is absent from the bar as currently rendered,
- *   including the recent slot itself). Selecting an entry already visible on
- *   the bar leaves the current recent dock in place.
- * - Anything off the rail entirely (e.g. a built-in notice) leaves the recent
- *   dock unchanged.
+ * The recent slots keep the docks last opened from somewhere *not* on the
+ * bar (the overflow popover or a group popover) one click away:
  *
- * Note the split runs against the *current* recent entry, so "visible" means
- * what the user actually saw when clicking. A newly selected entry that sits
- * inside the full-capacity natural slice still becomes the recent dock here;
- * {@link docksSplitGroupsWithCapacity} then renders it in its natural place,
- * releasing the reserved slot back to the bar.
+ * - A selection already reachable from the bar as rendered (a visible item,
+ *   including a pinned member, or a current recent slot) leaves the list
+ *   alone, so the slots never reshuffle under the cursor.
+ * - Otherwise a grouped member, or a top-level entry selected from the
+ *   overflow popover, moves to the front. The oldest id falls off past
+ *   `limit`.
+ * - Anything off the rail entirely (e.g. a built-in notice) leaves the list
+ *   unchanged.
  */
-export function resolveNextRecentDockId(options: {
+export function resolveNextRecentDockIds(options: {
   /** The grouped rail items (`context.docks.groupedEntries`). */
   groups: DevframeDockEntriesGrouped
   /** The bar's inline item capacity ({@link DockLayout.maxVisibleItems}). */
   capacity: number
-  /** The current recent entry, resolved via {@link resolveRecentDockEntry}. */
-  recentEntry: DevframeDockEntry | null
+  /** The current recent entries, resolved via {@link resolveRecentDockEntries}. */
+  recentEntries: readonly DevframeDockEntry[]
   /** The newly selected entry (post group→member resolution). */
   selected: DevframeDockEntry
   /** Whether `selected` is a member of a registered group. */
   selectedIsGroupMember: boolean
-}): string | null {
-  const { groups, capacity, recentEntry, selected, selectedIsGroupMember } = options
-  if (selectedIsGroupMember)
-    return selected.id
-  const current = recentEntry?.id ?? null
-  const split = docksSplitGroupsWithCapacity(groups, capacity, recentEntry)
-  if (split.recent?.id === selected.id || groupsHaveEntry(split.visible, selected.id))
+  /** Maximum number of recent slots; `0` turns the slots off. */
+  limit: number
+}): string[] {
+  const { groups, capacity, recentEntries, selected, selectedIsGroupMember, limit } = options
+  if (limit <= 0)
+    return []
+  const current = recentEntries.map(entry => entry.id).slice(0, limit)
+  const split = docksSplitGroupsWithCapacity(groups, capacity, recentEntries)
+  if (split.recent.some(entry => entry.id === selected.id) || groupsHaveEntry(split.visible, selected.id))
     return current
-  if (groupsHaveEntry(split.overflow, selected.id))
-    return selected.id
+  if (selectedIsGroupMember || groupsHaveEntry(split.overflow, selected.id))
+    return [selected.id, ...current.filter(id => id !== selected.id)].slice(0, limit)
   return current
 }
diff --git a/packages/hub-ui/src/client/state/docks.ts b/packages/hub-ui/src/client/state/docks.ts
index fcddce18b..7c43b18b9 100644
--- a/packages/hub-ui/src/client/state/docks.ts
+++ b/packages/hub-ui/src/client/state/docks.ts
@@ -29,7 +29,7 @@ export function DEFAULT_DOCK_SESSION_STORE(): DockSessionStorage {
     open: false,
     selectedDockId: null,
     selectedDockRoute: null,
-    recentDockId: null,
+    recentDockIds: [],
     groupLastChildIds: {},
   }
 }
diff --git a/packages/hub-ui/src/client/state/settings-defaults.ts b/packages/hub-ui/src/client/state/settings-defaults.ts
index 5dd221702..7ef5b6cf2 100644
--- a/packages/hub-ui/src/client/state/settings-defaults.ts
+++ b/packages/hub-ui/src/client/state/settings-defaults.ts
@@ -9,7 +9,7 @@ import '../types'
 /** The subset of {@link DevframeDocksUserSettings} hub-ui itself contributes. */
 export type HubUiSettings = Pick<
   DevframeDocksUserSettings,
-  'showIframeAddressBar' | 'closeOnOutsideClick' | 'autoCollapseEdgeToolbar' | 'showDevframeInspector'
+  'showIframeAddressBar' | 'closeOnOutsideClick' | 'autoCollapseEdgeToolbar' | 'showDevframeInspector' | 'docksRecentLimit'
 >
 
 /**
@@ -39,6 +39,8 @@ const HUB_UI_SETTINGS_DEFAULTS: Required<HubUiSettings> = Object.freeze({
   autoCollapseEdgeToolbar: true,
   /** The Devframe Inspector dock stays off the bar until opted into. */
   showDevframeInspector: false,
+  /** The float bar keeps the last three docks opened from beyond it. */
+  docksRecentLimit: 3,
 })
 
 /**
@@ -54,7 +56,9 @@ export function hubUiSetting<K extends keyof HubUiSettings>(
   settings: Pick<DevframeDocksUserSettings, K> | undefined,
   key: K,
 ): Required<HubUiSettings>[K] {
-  return settings?.[key] ?? HUB_UI_SETTINGS_DEFAULTS[key]
+  // TS cannot relate the indexed access across a key union that mixes
+  // boolean and number fields, so the result is re-asserted.
+  return (settings?.[key] ?? HUB_UI_SETTINGS_DEFAULTS[key]) as Required<HubUiSettings>[K]
 }
 
 const settingsByContext = new WeakMap<DocksContext, ComputedRef<ResolvedDocksUserSettings>>()
diff --git a/packages/hub-ui/src/client/types.ts b/packages/hub-ui/src/client/types.ts
index 5ddfb72f5..fdfecfc55 100644
--- a/packages/hub-ui/src/client/types.ts
+++ b/packages/hub-ui/src/client/types.ts
@@ -31,6 +31,13 @@ declare module '@devframes/hub/types' {
      * Settings → Advanced.
      */
     showDevframeInspector?: boolean
+    /**
+     * How many recently opened docks the float bar keeps in their own slots
+     * after its visible items. Only docks opened from beyond the bar (the
+     * overflow popover or a group popover) take a slot. `0` turns the slots
+     * off.
+     */
+    docksRecentLimit?: number
   }
 }
 
diff --git a/packages/hub/src/client/docks.ts b/packages/hub/src/client/docks.ts
index 6ef36fcb5..c61965cf9 100644
--- a/packages/hub/src/client/docks.ts
+++ b/packages/hub/src/client/docks.ts
@@ -41,13 +41,18 @@ export interface DockSessionStorage {
    */
   selectedDockRoute: string | null
   /**
-   * The dock entry most recently selected from beyond the float bar's inline
-   * capacity, whether from the overflow popover or from inside a dock group. A hub UI
-   * provider raises this entry into a dedicated slot between the bar's visible
-   * items and the overflow button, so deselecting it (or selecting a visible
-   * neighbour) keeps it one click away instead of folding it straight back
-   * into the overflow. `null` (or absent, for stores persisted before this
-   * field existed) when no entry has been raised.
+   * The dock entries most recently selected from beyond the float bar's
+   * inline capacity, whether from the overflow popover or from inside a dock
+   * group, newest first. A hub UI provider raises these entries into their own
+   * slots after the bar's visible items, so they stay one click away instead
+   * of folding back into the overflow or the group popover. Absent (for stores
+   * persisted before this field existed) or empty when nothing has been raised.
+   */
+  recentDockIds?: string[]
+  /**
+   * @deprecated Superseded by {@link DockSessionStorage.recentDockIds}. Still
+   * read as a one-entry list when `recentDockIds` is absent, so a tab that
+   * persisted the older field keeps its recent dock after an upgrade.
    */
   recentDockId?: string | null
   /**
diff --git a/tests/__snapshots__/tsnapi/@devframes/hub/client.snapshot.d.ts b/tests/__snapshots__/tsnapi/@devframes/hub/client.snapshot.d.ts
index 3b7451f9c..d0473e2c0 100644
--- a/tests/__snapshots__/tsnapi/@devframes/hub/client.snapshot.d.ts
+++ b/tests/__snapshots__/tsnapi/@devframes/hub/client.snapshot.d.ts
@@ -112,6 +112,7 @@ export interface DockSessionStorage {
   open: boolean;
   selectedDockId: string | null;
   selectedDockRoute: string | null;
+  recentDockIds?: string[];
   recentDockId?: string | null;
   groupLastChildIds?: Record<string, string>;
 }