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 e7779be2..ff00537e 100644
--- a/packages/hub-ui/src/client/components/dock/Dock.stories.ts
+++ b/packages/hub-ui/src/client/components/dock/Dock.stories.ts
@@ -133,6 +133,22 @@ export const LowerCapacity: Story = {
   args: { maxVisibleItems: 3 },
 }
 
+/**
+ * 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.
+ */
+export const WithRecentDock: Story = {
+  ...floatStory({
+    entries: overflowEntries,
+    selectedId: 'network',
+    session: { recentDockId: 'network' },
+    panel: { position: 'bottom', left: 50, top: 100, inactiveTimeout: -1 },
+  }),
+  args: { maxVisibleItems: 3 },
+}
+
 /** `maxVisibleItems: 9` — a higher capacity absorbs the overflow set inline. */
 export const HigherCapacity: Story = {
   ...floatStory({ entries: overflowEntries, panel: { position: 'bottom', left: 50, top: 100, inactiveTimeout: -1 } }),
diff --git a/packages/hub-ui/src/client/components/dock/Dock.vue b/packages/hub-ui/src/client/components/dock/Dock.vue
index 61d3f9bc..859cc4c8 100644
--- a/packages/hub-ui/src/client/components/dock/Dock.vue
+++ b/packages/hub-ui/src/client/components/dock/Dock.vue
@@ -3,9 +3,10 @@ import type { DocksContext } from '@devframes/hub/client'
 import type { CSSProperties } from 'vue'
 import type { DockLayout } from './dock-layout'
 import { useEventListener, useScreenSafeArea, whenever } from '@vueuse/core'
-import { computed, onMounted, reactive, ref, useTemplateRef } from 'vue'
+import { computed, onMounted, reactive, ref, useTemplateRef, watch } from 'vue'
 import { BUILTIN_ENTRY_CLIENT_AUTH_NOTICE } from '../../constants'
-import { docksSplitGroupsWithCapacity } from '../../state/dock-settings'
+import { docksSplitGroupsWithCapacity, getEntryGroup, resolveNextRecentDockId, resolveRecentDockEntry } from '../../state/dock-settings'
+import { sharedStateToRef } from '../../state/docks'
 import { setDocksOverflowPanel, useDocksGroupPanel } from '../../state/floating-tooltip'
 import { useIsRpcTrusted } from '../../utils/useIsRpcTrusted'
 import BrandMark from '../icons/BrandMark.vue'
@@ -17,6 +18,7 @@ import {
   resolveViewportMargins,
   snapDockPercent,
 } from './dock-layout'
+import DockEntries from './DockEntries.vue'
 import DockEntriesWithCategories from './DockEntriesWithCategories.vue'
 import DockOverflowButton from './DockOverflowButton.vue'
 
@@ -92,14 +94,46 @@ 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 splitEntries = computed(() => {
-  return docksSplitGroupsWithCapacity(groupedEntries.value, layout.value.maxVisibleItems)
+  return docksSplitGroupsWithCapacity(groupedEntries.value, layout.value.maxVisibleItems, recentEntry.value)
 })
 
 const selectedEntry = computed(() => {
   return context.docks.selected
 })
 
+// Remember the 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
+// the command palette, an RPC activation, or the session restore.
+watch(selectedEntry, (entry) => {
+  if (!entry)
+    return
+  context.panel.session.recentDockId = resolveNextRecentDockId({
+    groups: groupedEntries.value,
+    capacity: layout.value.maxVisibleItems,
+    recentEntry: recentEntry.value,
+    selected: entry,
+    selectedIsGroupMember: !!getEntryGroup(context.docks.entries, entry),
+  })
+})
+
 onMounted(async () => {
   windowSize.width = window.innerWidth
   windowSize.height = window.innerHeight
@@ -311,6 +345,14 @@ onMounted(() => {
 
           <template v-if="splitEntries.overflow.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]"
+              :is-vertical="context.panel.isVertical"
+              :selected="selectedEntry"
+              @select="(e) => context.docks.switchEntry(e?.id)"
+            />
             <DockOverflowButton
               :context="context"
               :is-vertical="context.panel.isVertical"
diff --git a/packages/hub-ui/src/client/state/dock-settings.test.ts b/packages/hub-ui/src/client/state/dock-settings.test.ts
new file mode 100644
index 00000000..b42413cf
--- /dev/null
+++ b/packages/hub-ui/src/client/state/dock-settings.test.ts
@@ -0,0 +1,135 @@
+import type { DevframeDockEntriesGrouped, DevframeDockEntry, DevframeViewGroup } from '@devframes/hub'
+import { describe, expect, it } from 'vitest'
+import { docksSplitGroupsWithCapacity, resolveNextRecentDockId, resolveRecentDockEntry } 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
+}
+
+function group(id: string, extra: Partial<DevframeViewGroup> = {}): DevframeDockEntry {
+  return { id, type: 'group', title: id.toUpperCase(), icon: 'ph:folder-duotone', ...extra } as DevframeDockEntry
+}
+
+function ids(groups: DevframeDockEntriesGrouped): string[] {
+  return groups.flatMap(([, items]) => items.map(item => item.id))
+}
+
+// Five top-level docks on a 3-slot bar: [a] [b] [c] | [overflow: d, e]
+const [a, b, c, d, e] = ['a', 'b', 'c', 'd', 'e'].map(id => iframe(id))
+const rail: DevframeDockEntriesGrouped = [['default', [a, b, c, d, e]]]
+
+describe('docksSplitGroupsWithCapacity', () => {
+  it('splits naturally without a recent entry', () => {
+    const split = docksSplitGroupsWithCapacity(rail, 3)
+    expect(ids(split.visible)).toEqual(['a', 'b', 'c'])
+    expect(ids(split.overflow)).toEqual(['d', 'e'])
+    expect(split.recent).toBeNull()
+  })
+
+  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('renders a recent entry inside the natural slice in place, releasing the slot', () => {
+    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()
+  })
+
+  it('raises a grouped member without touching the rail items in 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)
+  })
+
+  it('skips the reservation when there is no overflow', () => {
+    const member = iframe('g:member', { groupId: 'g' })
+    const smallRail: DevframeDockEntriesGrouped = [['default', [a, b, c]]]
+    const split = docksSplitGroupsWithCapacity(smallRail, 3, member)
+    expect(ids(split.visible)).toEqual(['a', 'b', 'c'])
+    expect(split.overflow).toEqual([])
+    expect(split.recent).toBeNull()
+  })
+
+  it('keeps the lone-overflow fold ahead of the reservation', () => {
+    const foldRail: DevframeDockEntriesGrouped = [['default', [a, b, c, d]]]
+    const split = docksSplitGroupsWithCapacity(foldRail, 3, d)
+    expect(ids(split.visible)).toEqual(['a', 'b', 'c', 'd'])
+    expect(split.overflow).toEqual([])
+    expect(split.recent).toBeNull()
+  })
+})
+
+describe('resolveNextRecentDockId', () => {
+  function next(recentEntry: DevframeDockEntry | null, selected: DevframeDockEntry, selectedIsGroupMember = false) {
+    return resolveNextRecentDockId({ groups: rail, capacity: 3, recentEntry, selected, selectedIsGroupMember })
+  }
+
+  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('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 a naturally-visible selection from claiming the slot', () => {
+    expect(next(null, a)).toBeNull()
+  })
+})
+
+describe('resolveRecentDockEntry', () => {
+  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 })
+  }
+
+  it('resolves a top-level rail entry', () => {
+    expect(resolve('d')).toBe(d)
+  })
+
+  it('resolves a grouped member', () => {
+    expect(resolve('g:member')).toBe(member)
+  })
+
+  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('returns null for an entry that is off the rail', () => {
+    const hidden = iframe('hidden')
+    expect(resolveRecentDockEntry({ entries: [...entries, hidden], groups: groupedRail, recentId: 'hidden' })).toBeNull()
+  })
+})
diff --git a/packages/hub-ui/src/client/state/dock-settings.ts b/packages/hub-ui/src/client/state/dock-settings.ts
index 5e7f3d6a..75c70a9c 100644
--- a/packages/hub-ui/src/client/state/dock-settings.ts
+++ b/packages/hub-ui/src/client/state/dock-settings.ts
@@ -44,6 +44,14 @@ function categoryOrder(category: string, overrides?: Record<string, number>): nu
 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).
+   */
+  recent: DevframeDockEntry | null
 }
 
 /**
@@ -404,20 +412,11 @@ export function deriveSidebarCapacity(options: SidebarCapacityOptions): number {
   return Math.max(0, fitWithButton)
 }
 
-/**
- * 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.
- */
-export function docksSplitGroupsWithCapacity(
+/** Slice grouped entries at `capacity`, preserving category buckets. */
+function splitGroupsAt(
   groups: DevframeDockEntriesGrouped,
   capacity: number,
-): SplitGroupsResult {
+): { visible: DevframeDockEntriesGrouped, overflow: DevframeDockEntriesGrouped } {
   const visible: DevframeDockEntriesGrouped = []
   const overflow: DevframeDockEntriesGrouped = []
   let left = capacity
@@ -437,8 +436,134 @@ export function docksSplitGroupsWithCapacity(
     }
   }
 
-  if (overflow.reduce((acc, [, items]) => acc + items.length, 0) === 1)
-    return { visible: [...visible, ...overflow], overflow: [] }
-
   return { visible, overflow }
 }
+
+/** Whether any bucket of a grouped split contains the entry id. */
+function groupsHaveEntry(groups: DevframeDockEntriesGrouped, id: string): boolean {
+  return groups.some(([, items]) => items.some(item => item.id === id))
+}
+
+/**
+ * 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.
+ *
+ * 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).
+ */
+export function docksSplitGroupsWithCapacity(
+  groups: DevframeDockEntriesGrouped,
+  capacity: number,
+  recentEntry: DevframeDockEntry | null = null,
+): 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[]])
+    .filter(([, items]) => items.length > 0)
+
+  return { visible: reduced.visible, overflow, recent: recentEntry }
+}
+
+/**
+ * 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
+  const entry = entries.find(e => e.id === recentId)
+  if (!entry || entry.type === 'group')
+    return null
+  const group = getEntryGroup(entries, entry)
+  if (group) {
+    const members = getGroupMembers(entries, group.id, settings, { whenContext })
+    return members.some(member => member.id === entry.id) ? entry : null
+  }
+  return groupsHaveEntry(groups, entry.id) ? entry : null
+}
+
+/**
+ * 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:
+ *
+ * - 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.
+ *
+ * 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.
+ */
+export function resolveNextRecentDockId(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 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))
+    return current
+  if (groupsHaveEntry(split.overflow, selected.id))
+    return selected.id
+  return current
+}
diff --git a/packages/hub-ui/src/client/state/docks.ts b/packages/hub-ui/src/client/state/docks.ts
index d6c998e2..54552961 100644
--- a/packages/hub-ui/src/client/state/docks.ts
+++ b/packages/hub-ui/src/client/state/docks.ts
@@ -29,6 +29,7 @@ export function DEFAULT_DOCK_SESSION_STORE(): DockSessionStorage {
     open: false,
     selectedDockId: null,
     selectedDockRoute: null,
+    recentDockId: null,
   }
 }
 
diff --git a/packages/hub/src/client/docks.ts b/packages/hub/src/client/docks.ts
index 5e8b3566..019fae37 100644
--- a/packages/hub/src/client/docks.ts
+++ b/packages/hub/src/client/docks.ts
@@ -40,6 +40,16 @@ export interface DockSessionStorage {
    * reload. `null` when the selected dock has no iframe route to remember.
    */
   selectedDockRoute: string | null
+  /**
+   * The dock entry most recently selected from beyond the float bar's inline
+   * capacity — 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.
+   */
+  recentDockId?: string | null
 }
 
 export type DockClientType = 'embedded' | 'standalone'
diff --git a/tests/__snapshots__/tsnapi/@devframes/hub/client.snapshot.d.ts b/tests/__snapshots__/tsnapi/@devframes/hub/client.snapshot.d.ts
index 2acd6a0e..42fca8c4 100644
--- a/tests/__snapshots__/tsnapi/@devframes/hub/client.snapshot.d.ts
+++ b/tests/__snapshots__/tsnapi/@devframes/hub/client.snapshot.d.ts
@@ -110,6 +110,7 @@ export interface DockSessionStorage {
   open: boolean;
   selectedDockId: string | null;
   selectedDockRoute: string | null;
+  recentDockId?: string | null;
 }
 export interface DocksPanelContext {
   store: DockPanelStorage;