refactor(gui): slot system standard — single register, four props shares, framework store seat

The definitive slot model for the web client, replacing the first-generation
define/register two-step, ScopedSlots whitelist faces, and binding handles:

- 'root' is the only a-priori slot (SlotsService built-in); the shell renders
  exactly ctx.slots.renderSlot('root', {}).
- register is the single API: children = slot declaration + render
  authorization + runtime spec in one options object; misconfiguration fails
  loud at load (duplicate declaration, undeclared contribution, one store
  handle under two scopes).
- Component props arrive in four auto-derived shares: PropsRuntime<K>
  (owner params + session/global standard kits via declare-merge),
  PropsRenderSlots<S>, PropsStore<H>, and the inject business face.
  sessionId is framework-supplied; hooks are framework-made only.
- Framework store seat: defineStore factories declare schema/actions/persist;
  read = useStore, write = baked actions only; store scope derives from the
  mounting entry; per-session persist keys and clearPersisted lifecycle.
- inject factories read the apply closure's own ctx (binding handles retired;
  root-ctx back door closed); SessionProvider is self-wired render-prop.
- Rendering sits behind the SlotRenderer install seam; runtime stays
  React-free; ownership ledger keyed to the single entry axis closes the
  stale-authority window (StaleAuthorizationError probes).

Docs: the slot type-chain note is refreshed in place as the slot system
standard RFC (bilingual pair re-recorded); the web client architecture RFC
defers its slot sections there; packages/client/AGENTS.md gains the slot and
props discipline; gui-testing/web-styling notes drop missions/ references.

Tests: suites rewritten to the standard (props fed directly, real store
engines via createXXXStore().create(), no render machinery); load-time
negative samples for declaration/authorization/store conflicts; verified by
real-host playwright run (three columns, empty state, collapse, keyed session
remount, cross-slot selection sharing).

docs(ui-sidebar): point contract reference at the committed slot standard RFC

missions/ is workspace-local and never committed; the README must not cite it.

packages/client/runtime/tests/sessions-service.spec.ts

@@ -1,10 +1,12 @@
 /**
- * SessionsService: list store projection (manager → {ids, byId} with derived
- * titles), scope-tree lifecycle (lazy mint / frozen survival / removed
- * teardown with watch deferral), binding identity, ancestry walk, create.
+ * SessionsService: list store projection (manager → {ids, byId, current}
+ * with derived titles), the migrated current-selection account (open
+ * validation, persisted mask semantics, cell resolution), scope-tree
+ * lifecycle (lazy mint / frozen survival / removed teardown with watch
+ * deferral), binding identity, ancestry walk, create.
  */
 import { Context } from 'cordis'
-import { describe, expect, it } from 'vitest'
+import { afterEach, describe, expect, it, vi } from 'vitest'
 import type { SessionId } from '@deepseek-ai/dsh-client-connection/client'
 import { SessionsService, scopeOf } from '../src/client/sessions/service.ts'
 import { FakeApiClient, ok } from './fake-api.ts'
@@ -112,6 +114,95 @@ describe('scope tree', () => {
   })
 })
 
+describe('current selection (migrated from ui-layout, arbitrated into the list snapshot)', () => {
+  afterEach(() => { vi.unstubAllGlobals() })
+
+  it('open() writes list.current; unknown ids fail loud', async () => {
+    const b = bench()
+    await feedList(b, [{ id: 's1' }])
+    expect(b.svc.list.getSnapshot().current).toBeUndefined()
+    b.svc.open(sid('s1'))
+    expect(b.svc.list.getSnapshot().current).toBe('s1')
+    expect(() => { b.svc.open(sid('ghost')) }).toThrow(/unknown session ghost/)
+    expect(b.svc.list.getSnapshot().current).toBe('s1') // failed open leaves the selection alone
+  })
+
+  it('masks (not destroys) the selection while its session is off the list', async () => {
+    const b = bench()
+    await feedList(b, [{ id: 's1' }, { id: 's2' }])
+    b.svc.open(sid('s1'))
+    await feedList(b, [{ id: 's2' }]) // s1 removed → current falls to the empty state
+    expect(b.svc.list.getSnapshot().current).toBeUndefined()
+    await feedList(b, [{ id: 's1' }, { id: 's2' }]) // s1 returns → selection resurfaces
+    expect(b.svc.list.getSnapshot().current).toBe('s1')
+  })
+
+  it('persists the selection under dsh.sessions.current and rehydrates it into a fresh service', async () => {
+    const storage = new Map<string, string>()
+    vi.stubGlobal('localStorage', {
+      getItem: (k: string) => storage.get(k) ?? null,
+      setItem: (k: string, v: string) => { storage.set(k, v) },
+    })
+    const first = bench()
+    await feedList(first, [{ id: 's1' }])
+    first.svc.open(sid('s1'))
+    expect(storage.get('dsh.sessions.current')).toContain('s1')
+    // A fresh boot (same storage) recovers the selection once the list holds the session.
+    const second = bench()
+    await feedList(second, [{ id: 's1' }])
+    expect(second.svc.list.getSnapshot().current).toBe('s1')
+  })
+})
+
+describe('cell (render-layer session kit)', () => {
+  it('resolves an identity-stable {sessionId, useSession} pair; unknown ids yield undefined', async () => {
+    const b = bench()
+    await feedList(b, [{ id: 's1' }])
+    const cell = b.svc.cell('s1')
+    expect(cell).toBeDefined()
+    expect(cell?.sessionId).toBe('s1')
+    expect(cell?.useSession).toBe(b.svc.manager.get(sid('s1')).useSelector)
+    expect(b.svc.cell('s1')).toBe(cell)
+    expect(b.svc.cell('ghost')).toBeUndefined()
+  })
+
+  it('moves the watch like binding(): switching cells sweeps a deferred removal', async () => {
+    const b = bench()
+    await feedList(b, [{ id: 's1' }])
+    b.svc.cell('s1') // watched
+    await feedList(b, []) // removed while watched → deferred, scope survives
+    expect(b.svc.scope(sid('s1'))).toBeDefined()
+    await feedList(b, [{ id: 's2' }])
+    b.svc.cell('s2') // watch moves → sweep tears s1 down
+    expect(b.svc.scope(sid('s1'))).toBeUndefined()
+  })
+})
+
+describe('slot-store scope prune hook', () => {
+  it('notifies ctx.slots.pruneStoreScope when a scope dies (both teardown paths)', async () => {
+    const b = bench()
+    const pruneStoreScope = vi.fn()
+    b.ctx.reflect.provide('slots', { pruneStoreScope })
+    await feedList(b, [{ id: 's1' }, { id: 's2' }])
+    b.svc.scope(sid('s1'))
+    b.svc.binding(sid('s2')) // s2 watched
+    await feedList(b, []) // s1 unwatched → immediate drop; s2 watched → deferred
+    expect(pruneStoreScope).toHaveBeenCalledWith('s1')
+    expect(pruneStoreScope).not.toHaveBeenCalledWith('s2')
+    await feedList(b, [{ id: 's3' }])
+    b.svc.binding(sid('s3')) // watch moves → deferred sweep drops s2
+    expect(pruneStoreScope).toHaveBeenCalledWith('s2')
+  })
+
+  it('tolerates a slots-less boot (object-layer benches carry no slot service)', async () => {
+    const b = bench()
+    await feedList(b, [{ id: 's1' }])
+    b.svc.scope(sid('s1'))
+    await feedList(b, []) // teardown without ctx.slots must not throw
+    expect(b.svc.scope(sid('s1'))).toBeUndefined()
+  })
+})
+
 describe('ancestry', () => {
   it('walks parentId links root-first including self; broken links stop the walk', async () => {
     const b = bench()