diff --git a/packages/ui/README.md b/packages/ui/README.md
index f53c8e5..931d8e6 100644
--- a/packages/ui/README.md
+++ b/packages/ui/README.md
@@ -24,6 +24,7 @@ if a `node:*` import creeps back onto that path.
 |---|---|
 | `src/app.css` | The design system: tokens and primitives, ported from the comp. Deliberately global — components carry structure, this file carries appearance. |
 | `src/lib/space.ts` | The `Space` type a view is drawn from, and lookups over it. Knows nothing about where records came from. |
+| `src/lib/space-navigation.ts` | The navigation boundary for spaces: URL changes may open a fold, while successful picker choices replace the URL with that fold's neutral route. |
 | `src/lib/session.svelte.ts` | Which space this tab is looking at: opening one, the visibility-aware poll loop, the remembered space list. The only module that touches the network for reads. |
 | `src/lib/auth.svelte.ts`, `write.ts` | The OAuth session, and `runCli()` over a `RepoWriter` built on it. The only two modules that write. |
 | `src/lib/store.ts`, `src/lib/idb.ts` | `RecordStore` and `SyncStateStore` over an in-memory mirror hydrated from IndexedDB. Synchronous reads, background writes, one database per space. |
diff --git a/packages/ui/src/lib/components/SpacePicker.svelte b/packages/ui/src/lib/components/SpacePicker.svelte
index 44ff4b3..425ed9b 100644
--- a/packages/ui/src/lib/components/SpacePicker.svelte
+++ b/packages/ui/src/lib/components/SpacePicker.svelte
@@ -19,10 +19,12 @@
   //
   // "Opened before" is what remains: spaces this browser profile has read without being a member of, and
   // so has no join for. It is a per-profile convenience rather than anything the network knows.
+  import { goto } from '$app/navigation'
   import { account, rememberedIdentities, signIn, signOut } from '$lib/auth.svelte.js'
   import { unknownActor } from '$lib/directory.js'
   import { discoverOwned, forgetOwned, owned } from '$lib/owned.svelte.js'
   import { forget, leave, openFixture, openSpace, session } from '$lib/session.svelte.js'
+  import { selectSpace } from '$lib/space-navigation.js'
   import Disc from './Disc.svelte'
   import Glyph from './Glyph.svelte'
   import NewSpace from './NewSpace.svelte'
@@ -76,8 +78,13 @@
 
   function submitUri(event: SubmitEvent): void {
     event.preventDefault()
-    if (uri.trim()) void openSpace(uri)
+    if (uri.trim()) void chooseSpace(uri.trim())
   }
+
+  // A successful picker choice updates the fold and its shareable URL as one interaction. A failed
+  // open leaves the old space and overlay in place, with `session.error` available for a retry.
+  const chooseSpace = (spaceUri: string): Promise<boolean> =>
+    selectSpace(spaceUri, openSpace, goto, session)
 </script>
 
 <div class="picker" class:overlay>
@@ -181,7 +188,7 @@
       <ul class="picker-list">
         {#each owned.spaces as space (space.uri)}
           <li>
-            <button class="picker-item" type="button" disabled={busy} onclick={() => void openSpace(space.uri)}>
+            <button class="picker-item" type="button" disabled={busy} onclick={() => void chooseSpace(space.uri)}>
               <span class="mark"><Glyph name="mark" size={17} /></span>
               <span class="txt">
                 <!-- A joined space's name comes from a record in somebody else's repo. When that cannot
@@ -215,7 +222,7 @@
     <ul class="picker-list">
       {#each alsoOpened as ref (ref.uri)}
         <li>
-          <button class="picker-item" type="button" disabled={busy} onclick={() => void openSpace(ref.uri)}>
+          <button class="picker-item" type="button" disabled={busy} onclick={() => void chooseSpace(ref.uri)}>
             <span class="mark"><Glyph name="mark" size={17} /></span>
             <span class="txt">
               <span class="picker-name">{ref.name}</span>
diff --git a/packages/ui/src/lib/session.svelte.ts b/packages/ui/src/lib/session.svelte.ts
index 473a908..1a9c455 100644
--- a/packages/ui/src/lib/session.svelte.ts
+++ b/packages/ui/src/lib/session.svelte.ts
@@ -132,6 +132,7 @@ interface Live {
 }
 
 let live: Live | undefined
+let openGeneration = 0
 
 export interface OpenOptions {
   /** Injected by tests; the browser gets `FetchRepoTransport` over the cached PDS resolver. */
@@ -149,6 +150,7 @@ export interface OpenOptions {
 export async function openSpace(input: string, options: OpenOptions = {}): Promise<void> {
   const uri = input.trim()
   if (uri === FIXTURE_SENTINEL) return openFixture()
+  const generation = ++openGeneration
   session.status = 'opening'
   session.error = ''
   try {
@@ -157,36 +159,57 @@ export async function openSpace(input: string, options: OpenOptions = {}): Promi
       throw new Error(`That is a ${parts.collection} record. A space URI names a ${COLLECTIONS.space}.`)
     }
   } catch (error) {
-    session.status = session.space ? 'ready' : 'choosing'
-    session.error = message(error)
+    if (generation === openGeneration) {
+      session.status = session.space ? 'ready' : 'choosing'
+      session.error = message(error)
+    }
     return
   }
 
-  stop()
+  stopLive()
   const identities = options.identities ?? new Identities()
+  let current: Live | undefined
   try {
     const stores = await (options.openStores ?? openSpaceStores)(uri)
+    if (generation !== openGeneration) {
+      stores.close()
+      return
+    }
     const transport = options.transport?.(identities) ?? new FetchRepoTransport(identities.pdsResolver)
     const poller = new RepoPoller(transport, stores.records, stores.state)
     const ingestor = new SpaceIngestor(uri, poller, stores.records)
-    live = { uri, stores, ingestor, identities, timer: undefined, syncing: false, stopped: false }
+    current = { uri, stores, ingestor, identities, timer: undefined, syncing: false, stopped: false }
+    live = current
     const index = await ingestor.sync()
+    if (generation !== openGeneration || current.stopped) {
+      abandon(current)
+      return
+    }
     await identities.resolve(index.members.map((member) => member.did))
-    publish(index)
+    if (generation !== openGeneration || current.stopped) {
+      abandon(current)
+      return
+    }
+    publish(index, current)
     session.status = 'ready'
     session.picking = false
     remember(uri, index.space.value.name)
     rememberLast(uri)
     if (options.poll !== false) resume()
   } catch (error) {
-    stop()
-    session.status = 'failed'
-    session.error = message(error)
+    if (generation === openGeneration) {
+      stopLive()
+      session.status = 'failed'
+      session.error = message(error)
+    } else if (current) {
+      abandon(current)
+    }
   }
 }
 
 export function openFixture(): void {
-  stop()
+  openGeneration += 1
+  stopLive()
   session.space = buildFixtureSpace()
   session.status = 'ready'
   session.picking = false
@@ -261,12 +284,12 @@ export function leave(): void {
   storage()?.removeItem(LAST_KEY)
 }
 
-function publish(index: MaterializedIndex): void {
-  const uri = live?.uri ?? index.space.uri
+function publish(index: MaterializedIndex, current = live): void {
+  const uri = current?.uri ?? index.space.uri
   session.space = {
     uri,
     index,
-    directory: buildDirectory(index, live?.identities.handles() ?? {}, live?.identities.avatars() ?? {}),
+    directory: buildDirectory(index, current?.identities.handles() ?? {}, current?.identities.avatars() ?? {}),
     // The instant the view is drawn at. Every "expires in 9 min" and "6m ago" on screen counts
     // against this one value, so a tick that changes nothing else still moves the clocks.
     asOf: new Date().toISOString(),
@@ -391,7 +414,7 @@ export async function settle(): Promise<void> {
   await Promise.all([live.stores.records.settle(), live.stores.state.settle()])
 }
 
-export function stop(): void {
+function stopLive(): void {
   if (!live) return
   pause()
   live.stopped = true
@@ -400,5 +423,19 @@ export function stop(): void {
   session.syncing = false
 }
 
+function abandon(current: Live): void {
+  if (live === current) {
+    stopLive()
+  } else if (!current.stopped) {
+    current.stopped = true
+    current.stores.close()
+  }
+}
+
+export function stop(): void {
+  openGeneration += 1
+  stopLive()
+}
+
 const message = (error: unknown): string =>
   error instanceof Error ? error.message : String(error)
diff --git a/packages/ui/src/lib/session.test.ts b/packages/ui/src/lib/session.test.ts
index 56ca482..8da00ad 100644
--- a/packages/ui/src/lib/session.test.ts
+++ b/packages/ui/src/lib/session.test.ts
@@ -33,6 +33,11 @@ const HANDLES: Record<string, string> = {
 
 const currentVersions = (): StoredRecord[] => latestVersions(fixture.records)
 
+const versionsFor = (spaceUri: string): StoredRecord[] =>
+  currentVersions().map((record) =>
+    JSON.parse(JSON.stringify(record).replaceAll(fixture.spaceUri, spaceUri)) as StoredRecord,
+  )
+
 interface Harness {
   network: FakePds
   database: SpaceDatabase
@@ -67,6 +72,50 @@ afterEach(() => {
 })
 
 describe('opening a live space', () => {
+  it('publishes and remembers the latest distinct space', async () => {
+    const uriB = `${fixture.spaceUri}-b`
+    const spaceA = harness()
+    const spaceB = harness(versionsFor(uriB))
+
+    await openSpace(fixture.spaceUri, options(spaceA))
+    spaceA.network.reset()
+    await openSpace(uriB, options(spaceB))
+
+    expect(session.space?.uri).toBe(uriB)
+    expect(session.status).toBe('ready')
+    expect(session.recents[0]?.uri).toBe(uriB)
+    await sync()
+    expect(spaceA.network.calls).toHaveLength(0)
+  })
+
+  it('does not let a superseded open publish or fail after the latest one', async () => {
+    const uriB = `${fixture.spaceUri}-b`
+    const slow = harness()
+    const latest = harness(versionsFor(uriB))
+    let release: (() => void) | undefined
+    const gate = new Promise<void>((resolve) => (release = resolve))
+    const slowOptions = options(slow)
+    const slowOpenStores = slowOptions.openStores
+    if (!slowOpenStores) throw new Error('missing store opener')
+
+    const openingA = openSpace(fixture.spaceUri, {
+      ...slowOptions,
+      openStores: async (uri) => {
+        await gate
+        return slowOpenStores(uri)
+      },
+    })
+    await openSpace(uriB, options(latest))
+    const published = session.space
+    release?.()
+    await openingA
+
+    expect(session.space).toBe(published)
+    expect(session.space?.uri).toBe(uriB)
+    expect(session.status).toBe('ready')
+    expect(session.error).toBe('')
+  })
+
   it('draws the same views the fixture does, from repos over the wire', async () => {
     const live = harness()
     await open(live)
diff --git a/packages/ui/src/lib/space-navigation.test.ts b/packages/ui/src/lib/space-navigation.test.ts
new file mode 100644
index 0000000..890aab4
--- /dev/null
+++ b/packages/ui/src/lib/space-navigation.test.ts
@@ -0,0 +1,63 @@
+import { describe, expect, it, vi } from 'vitest'
+import { createSpaceNavigationObserver, selectSpace } from './space-navigation.js'
+
+const A = 'at://did:plc:owner/com.disnetdev.radial.space/a'
+const B = 'at://did:plc:owner/com.disnetdev.radial.space/b'
+
+describe('space navigation', () => {
+  it('reacts to a changed URL target, not a session publication', () => {
+    const open = vi.fn()
+    const observe = createSpaceNavigationObserver(open)
+    const oldUrl = new URL(`/p/current?space=${encodeURIComponent(A)}`, 'https://radl.app')
+
+    observe(oldUrl, A)
+    observe(oldUrl, B)
+    expect(open).not.toHaveBeenCalled()
+
+    const linked = new URL(`/p/other?space=${encodeURIComponent(B)}`, 'https://radl.app')
+    observe(linked, A)
+    expect(open).toHaveBeenCalledOnce()
+    expect(open).toHaveBeenCalledWith(linked)
+  })
+
+  it('lands a successful picker switch on one neutral destination parameter', async () => {
+    const state = { status: 'opening' as 'opening' | 'ready', space: { uri: A } }
+    const navigate = vi.fn(async (_href: string, _options: { replaceState: true }) => {})
+    const switched = await selectSpace(
+      B,
+      async () => {
+        state.status = 'ready'
+        state.space = { uri: B }
+      },
+      navigate,
+      state,
+    )
+
+    expect(switched).toBe(true)
+    expect(navigate).toHaveBeenCalledOnce()
+    const call = navigate.mock.calls[0]
+    if (!call) throw new Error('navigation missing')
+    const [href, options] = call
+    const url = new URL(href, 'https://radl.app')
+    expect(url.pathname).toBe('/')
+    expect(url.searchParams.getAll('space')).toEqual([B])
+    expect(options).toEqual({ replaceState: true })
+  })
+
+  it('keeps the picker route in place when opening fails', async () => {
+    const state = { status: 'opening' as 'opening' | 'failed', space: { uri: A } }
+    const navigate = vi.fn(async (_href: string, _options: { replaceState: true }) => {})
+    const switched = await selectSpace(
+      B,
+      async () => {
+        state.status = 'failed'
+      },
+      navigate,
+      state,
+    )
+
+    expect(switched).toBe(false)
+    expect(state.space.uri).toBe(A)
+    expect(navigate).not.toHaveBeenCalled()
+  })
+})
diff --git a/packages/ui/src/lib/space-navigation.ts b/packages/ui/src/lib/space-navigation.ts
new file mode 100644
index 0000000..5f4c0cb
--- /dev/null
+++ b/packages/ui/src/lib/space-navigation.ts
@@ -0,0 +1,35 @@
+import type { SessionStatus } from './session.svelte.js'
+import { withSpace } from './space.js'
+
+interface SessionTarget {
+  status: SessionStatus
+  space: { uri: string } | undefined
+}
+
+/**
+ * URLs choose a space when navigation changes. Session publications are deliberately not inputs:
+ * polling and picker opens rebuild the current space without turning the old URL into a command.
+ */
+export function createSpaceNavigationObserver(open: (url: URL) => void): (url: URL, openUri?: string) => void {
+  let observed = ''
+  return (url, openUri) => {
+    const href = url.href
+    if (href === observed) return
+    observed = href
+    const target = url.searchParams.get('space')
+    if (target && target !== openUri) open(url)
+  }
+}
+
+/** A picker choice owns both halves of a switch: opening the fold, then naming it in the URL. */
+export async function selectSpace(
+  uri: string,
+  open: (uri: string) => Promise<void>,
+  navigate: (href: string, options: { replaceState: true }) => Promise<void>,
+  state: SessionTarget,
+): Promise<boolean> {
+  await open(uri)
+  if (state.status !== 'ready' || state.space?.uri !== uri) return false
+  await navigate(withSpace('/', uri), { replaceState: true })
+  return true
+}
diff --git a/packages/ui/src/routes/+layout.svelte b/packages/ui/src/routes/+layout.svelte
index 9605f37..824b400 100644
--- a/packages/ui/src/routes/+layout.svelte
+++ b/packages/ui/src/routes/+layout.svelte
@@ -1,6 +1,6 @@
 <script lang="ts">
   import '../app.css'
-  import { onMount } from 'svelte'
+  import { onMount, untrack } from 'svelte'
   import { goto } from '$app/navigation'
   import { page } from '$app/state'
   import { initAuth } from '$lib/auth.svelte.js'
@@ -21,6 +21,7 @@
   import SpacePicker from '$lib/components/SpacePicker.svelte'
   import Toast from '$lib/components/Toast.svelte'
   import { bootstrap, session, stop, watchVisibility } from '$lib/session.svelte.js'
+  import { createSpaceNavigationObserver } from '$lib/space-navigation.js'
   import {
     goalByRoute,
     projectByName,
@@ -65,10 +66,14 @@
   const route = $derived(page.route.id ?? '')
 
   // A client-side navigation can carry a link for another space without remounting this layout.
-  // Re-run the same coordinator only when its explicit target differs from the open fold.
+  // The URL is the only reactive input: publishing a picker choice or a polling rebuild must not
+  // reinterpret the URL the human just left behind as another navigation command.
+  const observeSpaceNavigation = createSpaceNavigationObserver((url) => void bootstrap(url))
   $effect(() => {
-    const target = page.url.searchParams.get('space')
-    if (bootstrapped && target && target !== session.space?.uri) void bootstrap(page.url)
+    const href = page.url.href
+    if (bootstrapped) {
+      observeSpaceNavigation(new URL(href), untrack(() => session.space?.uri))
+    }
   })
 
   // A draft belongs to the view that opened it: leaving that view abandons it rather than carrying