diff --git a/src/renderer/src/components/tab-bar/TabBarCreateEntry.search.test.tsx b/src/renderer/src/components/tab-bar/TabBarCreateEntry.search.test.tsx
index 8a168bcb684..3bc66004a01 100644
--- a/src/renderer/src/components/tab-bar/TabBarCreateEntry.search.test.tsx
+++ b/src/renderer/src/components/tab-bar/TabBarCreateEntry.search.test.tsx
@@ -79,6 +79,18 @@ function press(key: string): void {
   })
 }
 
+function rowTexts(): string[] {
+  return [...container.querySelectorAll('[role="option"]')].map((row) => row.textContent ?? '')
+}
+
+function seedBrowserHistory(url: string, title: string): void {
+  useAppStore.setState({
+    browserUrlHistory: [
+      { url, normalizedUrl: url.replace(/\/$/, ''), title, lastVisitedAt: 1, visitCount: 1 }
+    ]
+  })
+}
+
 beforeEach(() => {
   fileListMock.current = { files: [], loading: false, loadError: null }
   tabSearchMock.calls = []
@@ -134,6 +146,83 @@ describe('TabBarCreateEntry search behavior', () => {
     )
   })
 
+  it.each([false, true])(
+    'keeps a typed host and its pages above unrelated files (visited root: %s)',
+    (visitedRoot) => {
+      fileListMock.current.files = [
+        'mobile/rpc-foundation/goldens/matrix-transport.capability-probe-status.get-1.json',
+        'mobile/rpc-foundation/goldens/matrix-files.terminal-path-tap-files.open-1.json',
+        'mobile/rpc-foundation/goldens/matrix-files.terminal-path-tap-files.resolveterminalpath-1.json'
+      ]
+      const url = visitedRoot ? 'https://linear.app/' : 'https://linear.app/acme/issues'
+      seedBrowserHistory(url, 'Linear')
+      const onOpenEntry = vi.fn().mockResolvedValue(undefined)
+      renderEntry({ onOpenEntry })
+      setQuery('linear.app')
+
+      const rows = rowTexts()
+      const pageIndex = rows.findIndex((row) => row.includes('Open page'))
+      expect(pageIndex).toBeGreaterThanOrEqual(0)
+      expect(rows.findIndex((row) => row.includes('Open file'))).toBeGreaterThan(pageIndex)
+      expect(container.querySelector('[aria-selected="true"]')?.textContent).toContain('linear.app')
+      submit()
+      expect(onOpenEntry).toHaveBeenCalledWith(
+        expect.objectContaining({
+          classification: visitedRoot
+            ? { kind: 'explicit-url', url }
+            : { kind: 'host-url', url: 'https://linear.app/' }
+        })
+      )
+    }
+  )
+
+  it('still opens a visited host above a filename that contains it', () => {
+    fileListMock.current.files = ['config/localhost.ts']
+    seedBrowserHistory('http://localhost/', 'Local')
+    const onOpenEntry = vi.fn().mockResolvedValue(undefined)
+    renderEntry({ onOpenEntry })
+    setQuery('localhost')
+
+    submit()
+    expect(onOpenEntry).toHaveBeenCalledWith(
+      expect.objectContaining({
+        classification: { kind: 'explicit-url', url: 'http://localhost/' }
+      })
+    )
+  })
+
+  // A code-host page title carries the file path, so it matches path queries too.
+  it.each([false, true])(
+    'keeps a matching page below local rows for a path query (typed: %s)',
+    (typed) => {
+      fileListMock.current.files = [
+        'src/renderer/src/components/tab-bar/TabBarCreateEntry.tsx',
+        'src/renderer/src/components/tab-bar/TabBarCreateEntryRow.tsx'
+      ]
+      seedBrowserHistory(
+        'https://github.com/acme/app/blob/main/src/renderer/src/components/tab-bar/TabBarCreateEntry.tsx',
+        'app/src/renderer/src/components/tab-bar/TabBarCreateEntry.tsx at main · acme/app'
+      )
+      const onOpenEntry = vi.fn().mockResolvedValue(undefined)
+      renderEntry({ onOpenEntry })
+      const query = 'components/tab-bar/TabBarCreate'
+      if (typed) {
+        for (let length = 1; length <= query.length; length += 1) {
+          setQuery(query.slice(0, length))
+        }
+      } else {
+        setQuery(query)
+      }
+
+      const rows = rowTexts()
+      const pageIndex = rows.findIndex((row) => row.includes('Open page'))
+      expect(pageIndex).toBeGreaterThan(rows.findLastIndex((row) => row.includes('Open file')))
+      submit()
+      expect(onOpenEntry).toHaveBeenCalledOnce()
+      expect(onOpenEntry.mock.calls[0]?.[0].classification.kind).not.toBe('explicit-url')
+    }
+  )
+
   it.each(['a', 'ab', 'asciinema'])('waits for an exact filename before arming %s', (query) => {
     fileListMock.current = { files: [], loading: true, loadError: null }
     const onOpenEntry = vi.fn().mockResolvedValue(undefined)
diff --git a/src/renderer/src/components/tab-bar/TabBarCreateEntry.tsx b/src/renderer/src/components/tab-bar/TabBarCreateEntry.tsx
index aaf0c74210c..ac80ca0699c 100644
--- a/src/renderer/src/components/tab-bar/TabBarCreateEntry.tsx
+++ b/src/renderer/src/components/tab-bar/TabBarCreateEntry.tsx
@@ -16,7 +16,7 @@ import {
   resultOptionDomId
 } from './TabBarCreateEntryRow'
 import { dropFileEntriesCoveredByTabResults } from './open-tab-entry-dedupe'
-import { insertHistoryRowsBelowFileMatches } from './tab-create-entry-history-placement'
+import { placeHistoryRowsInEntryOptions } from './tab-create-entry-history-placement'
 import { useOmniboxBrowserHistory } from './use-omnibox-browser-history'
 import { useTabEntryMenuReturnFocus } from './use-tab-entry-menu-return-focus'
 import { activateOpenTabSearchResult } from './open-tab-selection-routing'
@@ -167,7 +167,7 @@ function TabBarCreateEntrySession({
       kind: 'agent' as const,
       option
     })),
-    ...insertHistoryRowsBelowFileMatches(options, historyRows)
+    ...placeHistoryRowsInEntryOptions(options, historyRows)
   ]
   const { activeSelectedIndex, selectedActiveOption } = useNetworkSafeTabEntrySelection({
     activeOptions,
diff --git a/src/renderer/src/components/tab-bar/open-tab-entry-dedupe.ts b/src/renderer/src/components/tab-bar/open-tab-entry-dedupe.ts
index 891cb93353c..a6f4a01a165 100644
--- a/src/renderer/src/components/tab-bar/open-tab-entry-dedupe.ts
+++ b/src/renderer/src/components/tab-bar/open-tab-entry-dedupe.ts
@@ -63,10 +63,10 @@ export function dropHistoryRowsCoveredByBrowserPages(
 
 // The history row carries a real page title, so it beats the bare typed-URL row
 // it duplicates — mirroring the address bar's synthetic-row fold.
-export function dropUrlEntriesCoveredByHistoryRows(
-  options: readonly TabEntryOption[],
+export function dropUrlEntriesCoveredByHistoryRows<Option extends TabEntryOption>(
+  options: readonly Option[],
   rows: readonly BrowserHistoryOmniboxRow[]
-): readonly TabEntryOption[] {
+): readonly Option[] {
   if (rows.length === 0) {
     return options
   }
diff --git a/src/renderer/src/components/tab-bar/tab-create-entry-history-placement.test.ts b/src/renderer/src/components/tab-bar/tab-create-entry-history-placement.test.ts
index d0557dfd13a..60ff4c939fc 100644
--- a/src/renderer/src/components/tab-bar/tab-create-entry-history-placement.test.ts
+++ b/src/renderer/src/components/tab-bar/tab-create-entry-history-placement.test.ts
@@ -1,5 +1,5 @@
 import { describe, expect, it } from 'vitest'
-import { insertHistoryRowsBelowFileMatches } from './tab-create-entry-history-placement'
+import { placeHistoryRowsInEntryOptions } from './tab-create-entry-history-placement'
 import type { BrowserHistoryOmniboxRow } from './tab-create-entry-active-option'
 import type { TabEntryOption } from './tab-create-entry-action'
 import type { ExistingFileMatch } from './tab-create-entry-file-matches'
@@ -22,6 +22,14 @@ const newFileOption: TabEntryOption = {
   id: 'new-file:readme',
   classification: { kind: 'new-file', relativePath: 'readme' }
 }
+const readmeHostOption: TabEntryOption = {
+  id: 'host-url:https://readme.io/docs',
+  classification: { kind: 'host-url', url: 'https://readme.io/docs' }
+}
+const exampleHostOption: TabEntryOption = {
+  id: 'host-url:https://example.com',
+  classification: { kind: 'host-url', url: 'https://example.com' }
+}
 
 function historyRow(url: string): BrowserHistoryOmniboxRow {
   return {
@@ -38,7 +46,7 @@ function kinds(options: readonly { kind: string }[]): string[] {
 
 describe('tab create entry history placement', () => {
   it('lands history below every file match and above new-file and search', () => {
-    const placed = insertHistoryRowsBelowFileMatches(
+    const placed = placeHistoryRowsInEntryOptions(
       [
         fileOption('README.md', 'exact-basename'),
         fileOption('docs/readme-notes.md', 'literal-basename'),
@@ -54,20 +62,23 @@ describe('tab create entry history placement', () => {
     expect(placed[3]).toMatchObject({ option: { id: 'new-file:readme' } })
   })
 
-  it.each(['literal-basename', 'fuzzy'] as const)('stays below a lone %s file row', (matchKind) => {
-    const placed = insertHistoryRowsBelowFileMatches(
-      [fileOption('docs/readme-notes.md', matchKind), searchOption],
-      rows
-    )
+  it.each(['exact-path', 'exact-basename', 'literal-basename', 'fuzzy'] as const)(
+    'stays below a lone %s file row',
+    (matchKind) => {
+      const placed = placeHistoryRowsInEntryOptions(
+        [fileOption('docs/readme-notes.md', matchKind), searchOption],
+        rows
+      )
 
-    expect(kinds(placed)).toEqual(['entry', 'history', 'entry'])
-    expect(placed[0]).toMatchObject({ option: { id: 'existing-file:docs/readme-notes.md' } })
-  })
+      expect(kinds(placed)).toEqual(['entry', 'history', 'entry'])
+      expect(placed[0]).toMatchObject({ option: { id: 'existing-file:docs/readme-notes.md' } })
+    }
+  )
 
   // The phrase-query ordering: the classifier puts search first, and history
   // still has to end up under the fuzzy files that follow it.
   it('sinks past fuzzy files the classifier ranked below web search', () => {
-    const placed = insertHistoryRowsBelowFileMatches(
+    const placed = placeHistoryRowsInEntryOptions(
       [searchOption, fileOption('docs/readme-notes.md', 'fuzzy'), newFileOption],
       rows
     )
@@ -77,43 +88,65 @@ describe('tab create entry history placement', () => {
   })
 
   it('leads the entry block when no file or typed url matched at all', () => {
-    const placed = insertHistoryRowsBelowFileMatches([searchOption, newFileOption], rows)
+    const placed = placeHistoryRowsInEntryOptions([searchOption, newFileOption], rows)
 
     expect(kinds(placed)).toEqual(['history', 'entry', 'entry'])
   })
 
   it('drops a typed-url row the history row already covers', () => {
-    const placed = insertHistoryRowsBelowFileMatches(
-      [
-        {
-          id: 'host-url:https://readme.io/docs',
-          classification: { kind: 'host-url', url: 'https://readme.io/docs' }
-        },
-        searchOption
-      ],
-      rows
-    )
+    const placed = placeHistoryRowsInEntryOptions([readmeHostOption, searchOption], rows)
 
     expect(kinds(placed)).toEqual(['history', 'entry'])
     expect(placed[1]).toMatchObject({ option: { id: 'search:readme' } })
   })
 
   it('keeps a typed-url row that points somewhere else, and stays under it', () => {
-    const placed = insertHistoryRowsBelowFileMatches(
-      [
-        {
-          id: 'host-url:https://example.com',
-          classification: { kind: 'host-url', url: 'https://example.com' }
-        }
-      ],
-      rows
-    )
+    const placed = placeHistoryRowsInEntryOptions([exampleHostOption], rows)
 
     expect(kinds(placed)).toEqual(['entry', 'history'])
   })
 
+  // Visiting a site must not change what Enter does on its name.
+  it('takes the slot of a covered typed-url row above the files below it', () => {
+    const placed = placeHistoryRowsInEntryOptions(
+      [readmeHostOption, fileOption('docs/readme-notes.md', 'fuzzy')],
+      rows
+    )
+
+    expect(kinds(placed)).toEqual(['history', 'entry'])
+    expect(placed[1]).toMatchObject({ option: { id: 'existing-file:docs/readme-notes.md' } })
+  })
+
+  it('joins an uncovered typed-url row above the files below it', () => {
+    const placed = placeHistoryRowsInEntryOptions(
+      [exampleHostOption, fileOption('docs/readme-notes.md', 'fuzzy')],
+      rows
+    )
+
+    expect(kinds(placed)).toEqual(['entry', 'history', 'entry'])
+    expect(placed[0]).toMatchObject({ option: { id: 'host-url:https://example.com' } })
+  })
+
+  it.each([
+    { relation: 'replaces', url: readmeHostOption, expected: ['entry', 'history', 'entry'] },
+    { relation: 'joins', url: exampleHostOption, expected: ['entry', 'entry', 'history', 'entry'] }
+  ])('keeps exact files above history that $relation the typed-url row', ({ url, expected }) => {
+    const placed = placeHistoryRowsInEntryOptions(
+      [
+        fileOption('README.md', 'exact-basename'),
+        url,
+        fileOption('docs/readme-notes.md', 'literal-basename')
+      ],
+      rows
+    )
+
+    expect(kinds(placed)).toEqual(expected)
+    expect(placed[0]).toMatchObject({ option: { id: 'existing-file:README.md' } })
+    expect(placed.at(-1)).toMatchObject({ option: { id: 'existing-file:docs/readme-notes.md' } })
+  })
+
   it('skips status rows, which are not actionable options', () => {
-    const placed = insertHistoryRowsBelowFileMatches(
+    const placed = placeHistoryRowsInEntryOptions(
       [{ id: 'loading', classification: { kind: 'blocked', message: 'Loading files...' } }],
       rows
     )
@@ -122,7 +155,7 @@ describe('tab create entry history placement', () => {
   })
 
   it('returns only the mapped entry rows when there is no history to insert', () => {
-    const placed = insertHistoryRowsBelowFileMatches([searchOption], [])
+    const placed = placeHistoryRowsInEntryOptions([searchOption], [])
 
     expect(kinds(placed)).toEqual(['entry'])
   })
diff --git a/src/renderer/src/components/tab-bar/tab-create-entry-history-placement.ts b/src/renderer/src/components/tab-bar/tab-create-entry-history-placement.ts
index e29a04ee72c..2944d533509 100644
--- a/src/renderer/src/components/tab-bar/tab-create-entry-history-placement.ts
+++ b/src/renderer/src/components/tab-bar/tab-create-entry-history-placement.ts
@@ -1,48 +1,63 @@
-// Where the browser-history block lands inside the omnibox entry rows: below
-// every file the query matched and below anything the user typed as a URL,
-// above the new-file and web-search fallbacks.
+// Where the browser-history block lands inside the omnibox entry rows: with the
+// typed URL when the query is a web address, otherwise below every file the
+// query matched and above the new-file and web-search fallbacks.
 
 import { dropUrlEntriesCoveredByHistoryRows } from './open-tab-entry-dedupe'
 import {
   isActiveEntryOption,
+  type ActiveEntryOption,
   type ActiveOption,
   type BrowserHistoryOmniboxRow
 } from './tab-create-entry-active-option'
 import type { TabEntryOption } from './tab-create-entry-action'
 
-// Leaving the workspace is the heavier action, so a local file outranks a
-// remembered page even when the match was fuzzy.
-function isFileOrUrlOption(option: TabEntryOption): boolean {
+function isTypedUrlOption(option: TabEntryOption): boolean {
   const { kind } = option.classification
-  return (
-    kind === 'existing-file' ||
-    kind === 'absolute-file' ||
-    kind === 'explicit-url' ||
-    kind === 'host-url'
-  )
+  return kind === 'explicit-url' || kind === 'host-url'
 }
 
-export function insertHistoryRowsBelowFileMatches(
-  entryOptions: readonly TabEntryOption[],
-  historyRows: readonly BrowserHistoryOmniboxRow[]
-): readonly ActiveOption[] {
-  const options = dropUrlEntriesCoveredByHistoryRows(entryOptions, historyRows)
-    .filter(isActiveEntryOption)
-    .map((option) => ({ kind: 'entry' as const, option }))
-  if (historyRows.length === 0) {
-    return options
+// Leaving the workspace is the heavier action, so a local file outranks a
+// remembered page even when the match was fuzzy.
+function isFileOption(option: TabEntryOption): boolean {
+  const { kind } = option.classification
+  return kind === 'existing-file' || kind === 'absolute-file'
+}
+
+function historyInsertIndex(
+  options: readonly ActiveEntryOption[],
+  keptOptions: readonly ActiveEntryOption[]
+): number {
+  // History sits with the typed URL row (in its slot once it replaced it), so
+  // visiting a site never changes what Enter does on its name.
+  const urlIndex = options.findIndex(isTypedUrlOption)
+  if (urlIndex !== -1) {
+    return keptOptions.includes(options[urlIndex]) ? urlIndex + 1 : urlIndex
   }
   // Scanning for the last one, not the leading run: the classifier promotes web
   // search above fuzzy files for phrase queries, and history belongs under both.
   let insertAt = 0
-  for (const [index, option] of options.entries()) {
-    if (isFileOrUrlOption(option.option)) {
+  for (const [index, option] of keptOptions.entries()) {
+    if (isFileOption(option)) {
       insertAt = index + 1
     }
   }
+  return insertAt
+}
+
+export function placeHistoryRowsInEntryOptions(
+  entryOptions: readonly TabEntryOption[],
+  historyRows: readonly BrowserHistoryOmniboxRow[]
+): readonly ActiveOption[] {
+  const options = entryOptions.filter(isActiveEntryOption)
+  const keptOptions = dropUrlEntriesCoveredByHistoryRows(options, historyRows)
+  const rows = keptOptions.map((option) => ({ kind: 'entry' as const, option }))
+  if (historyRows.length === 0) {
+    return rows
+  }
+  const insertAt = historyInsertIndex(options, keptOptions)
   return [
-    ...options.slice(0, insertAt),
+    ...rows.slice(0, insertAt),
     ...historyRows.map((option) => ({ kind: 'history' as const, option })),
-    ...options.slice(insertAt)
+    ...rows.slice(insertAt)
   ]
 }