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/ui-sidebar/tests/apply.spec.tsx

@@ -1,55 +1,53 @@
-// @vitest-environment jsdom
 /**
- * apply wiring on a real cordis Context + SlotsService: tree store built and
- * subscribed, SidebarRoot registered into the layout-owned sidebar slot with
- * the inject surface bound off the root binding ctx, effect teardown
- * unregisters and drops the list subscription. Behavior-level assertions
- * only — the inject factory's cast shape is due to change with the slot
- * type-chain redesign.
+ * apply wiring on a real cordis Context + SlotsService (terminal register
+ * form): SidebarRoot registered into the layout-declared sidebar slot, the
+ * thin inject surface (three plain service callbacks closed over the plugin
+ * ctx — no hooks, no store lines), load-order fail-loud, and fiber-teardown
+ * unregistration. Component behavior is covered props-direct in
+ * sidebar-root.spec.tsx; no renderer machinery here.
  */
 import { Context } from 'cordis'
-import { afterEach, describe, expect, it, vi } from 'vitest'
-import { cleanup, fireEvent, render, screen } from '@testing-library/react'
-import { act } from 'react'
-import { createSnapshotStore } from '@deepseek-ai/dsh-client-web-react'
-import { scopedSlots, RootBindingProvider } from '@deepseek-ai/dsh-client-web-react'
+import { describe, expect, it, vi } from 'vitest'
+import { createSnapshotStore } from '@deepseek-ai/dsh-client-web-react/store'
 import { SlotsService } from '@deepseek-ai/dsh-client-runtime/client'
 import type { SessionId, SessionListState } from '@deepseek-ai/dsh-client-runtime/client'
 import { apply, inject } from '@deepseek-ai/dsh-client-ui-sidebar/client'
+import type { SidebarRootInjected } from '@deepseek-ai/dsh-client-ui-sidebar/client'
 // Type-only: ui-layout's SlotMap merge so the sidebar slot key typechecks.
 import type {} from '@deepseek-ai/dsh-client-ui-layout/client'
 
 const sid = (s: string) => s as SessionId
 
-afterEach(cleanup)
-
 async function bench() {
   const ctx = new Context()
   await ctx.plugin(SlotsService).await()
   const list = createSnapshotStore<SessionListState>({
     ids: [sid('a')],
     byId: { [sid('a')]: { id: sid('a'), title: 'alpha', cwd: '/proj', running: false, updatedAt: 1 } },
+    current: undefined,
   })
-  const sessions = { list, create: vi.fn(async () => sid('minted')) }
-  const layout = {
-    current: createSnapshotStore<{ sessionId?: SessionId }>({}),
-    open: vi.fn(),
-    toggleSidebar: vi.fn(),
-  }
+  const sessions = { list, create: vi.fn(async () => sid('minted')), open: vi.fn() }
+  const layout = { toggleSidebar: vi.fn() }
   ctx.provide('sessions', sessions)
   ctx.provide('layout', layout)
   const slots = ctx.get('slots') as SlotsService
-  slots.define('sidebar', { kind: 'single', scope: 'root' })
+  // Stand-in for ui-layout's root entry: the sidebar slot only exists while
+  // a live entry declares it in children (declaration account: design §2.2).
+  slots.register(
+    { name: 'root', children: { 'sidebar': { kind: 'single', scope: 'root' } } } as never,
+    () => null,
+  )
   return { ctx, slots, sessions, layout }
 }
 
-function mountSlot(ctx: Context, slots: SlotsService) {
-  const surface = scopedSlots(slots.core, 'sidebar')
-  return render(
-    <RootBindingProvider value={{ ctx }}>
-      {surface.renderSlot('sidebar', {})}
-    </RootBindingProvider>,
-  )
+/** The sidebar entry's injected share, read off the stored entry. */
+function injectedOf(slots: SlotsService): SidebarRootInjected {
+  const entries = slots.entries('sidebar')
+  expect(entries).toHaveLength(1)
+  // The typed StoredEntry.inject is declaration-derived ((...args: never[])
+  // shape); the sidebar factory is parameterless, so the call is safe here.
+  const inject = entries[0]!.inject as (() => SidebarRootInjected) | undefined
+  return inject!()
 }
 
 describe('apply', () => {
@@ -58,101 +56,57 @@ describe('apply', () => {
   })
 
   it('fails loud when mounted without the inject declaration', async () => {
-    // ctx.sessions rides the cordis property proxy: reading it from a plugin
+    // ctx.slots rides the cordis property proxy: reading it from a plugin
     // that never declared the dependency throws instead of yielding undefined.
-    // Await the fiber thenable itself, not a second .await() chain: the test
-    // invariant host wraps plugin() with an eager readiness promise, and only
-    // the thenable settles it (a parallel .await() leaves it unhandled).
     const ctx = new Context()
     await ctx.plugin(SlotsService).await()
     await expect(ctx.plugin({ apply })).rejects.toThrow(/without inject/)
   })
 
-  it('registers SidebarRoot which renders from the live list', async () => {
-    const { ctx, slots } = await bench()
-    await ctx.plugin({ inject: [...inject], apply }).await()
-    mountSlot(ctx, slots)
-    expect(screen.getByText('proj')).toBeTruthy()
-    expect(screen.getByText('1 session')).toBeTruthy()
+  it('fails loud when no live entry has declared the sidebar slot', async () => {
+    const ctx = new Context()
+    await ctx.plugin(SlotsService).await()
+    ctx.provide('sessions', {})
+    ctx.provide('layout', {})
+    await expect(ctx.plugin({ inject: [...inject], apply })).rejects.toThrow(/slot "sidebar" is not declared/)
   })
 
-  it('binds actions to layout/sessions off the root binding', async () => {
+  it('registers SidebarRoot with the thin three-callback inject surface', async () => {
+    const { ctx, slots } = await bench()
+    await ctx.plugin({ inject: [...inject], apply }).await()
+    const injected = injectedOf(slots)
+    // The whole business face: three plain callbacks, no hooks, no store lines.
+    expect(Object.keys(injected).sort()).toEqual(['onCreate', 'onOpen', 'onToggleSidebar'])
+  })
+
+  it('routes the callbacks to the layout/sessions services', async () => {
     const { ctx, slots, sessions, layout } = await bench()
     await ctx.plugin({ inject: [...inject], apply }).await()
-    mountSlot(ctx, slots)
+    const injected = injectedOf(slots)
 
-    act(() => { fireEvent.click(screen.getByLabelText('Collapse sidebar')) })
+    injected.onToggleSidebar()
     expect(layout.toggleSidebar).toHaveBeenCalledOnce()
 
-    act(() => { fireEvent.click(screen.getByText('proj')) })
-    act(() => { fireEvent.click(screen.getByText('alpha')) })
-    expect(layout.open).toHaveBeenCalledWith('a')
+    injected.onOpen(sid('a'))
+    expect(sessions.open).toHaveBeenCalledWith('a')
 
-    act(() => { fireEvent.click(screen.getByText('New Session')) })
+    injected.onCreate()
     expect(sessions.create).toHaveBeenCalledWith({})
     // create-then-open lands after the create promise resolves.
-    await act(async () => { await Promise.resolve() })
-    expect(layout.open).toHaveBeenCalledWith('minted')
+    await Promise.resolve()
+    await Promise.resolve()
+    expect(sessions.open).toHaveBeenCalledWith('minted')
 
-    act(() => { fireEvent.click(screen.getAllByLabelText('New session here')[0]!) })
+    injected.onCreate('/proj')
     expect(sessions.create).toHaveBeenCalledWith({ cwd: '/proj' })
   })
 
-  it('throws from the inject factory when binding ctx lacks the services', async () => {
+  it('teardown unregisters the slot entry', async () => {
     const { ctx, slots } = await bench()
-    await ctx.plugin({ inject: [...inject], apply }).await()
-    const bare = new Context()
-    const spy = vi.spyOn(console, 'error').mockImplementation(() => {})
-    try {
-      const surface = scopedSlots(slots.core, 'sidebar')
-      render(
-        <RootBindingProvider value={{ ctx: bare }}>
-          {surface.renderSlot('sidebar', {})}
-        </RootBindingProvider>,
-      )
-      // The slot error boundary absorbs the throw and logs it.
-      expect(document.querySelector('[data-slot-error="sidebar"]')).toBeTruthy()
-    } finally {
-      spy.mockRestore()
-    }
-  })
-
-  it('search input drives the plugin-owned tree store', async () => {
-    const { ctx, slots } = await bench()
-    await ctx.plugin({ inject: [...inject], apply }).await()
-    mountSlot(ctx, slots)
-    act(() => {
-      fireEvent.change(screen.getByPlaceholderText('Search name, keywords...'), { target: { value: 'zzz' } })
-    })
-    expect(screen.getByText('No matches')).toBeTruthy()
-  })
-
-  it('expansion toggles route through the injected tree actions', async () => {
-    const { ctx, slots, sessions } = await bench()
-    sessions.list.update((draft) => {
-      draft.ids.push(sid('kid'))
-      draft.byId[sid('kid')] = {
-        id: sid('kid'), title: 'child', cwd: '/proj', parentId: sid('a'), running: false, updatedAt: 2,
-      }
-    })
-    await ctx.plugin({ inject: [...inject], apply }).await()
-    mountSlot(ctx, slots)
-    act(() => { fireEvent.click(screen.getByText('proj')) })
-    expect(screen.getByText('alpha')).toBeTruthy()
-    act(() => { fireEvent.click(screen.getByLabelText('Expand')) })
-    expect(screen.getByText('child')).toBeTruthy()
-  })
-
-  it('teardown unregisters the slot and drops the list subscription', async () => {
-    const { ctx, slots, sessions } = await bench()
     const fiber = ctx.plugin({ inject: [...inject], apply })
     await fiber.await()
     expect(slots.entries('sidebar')).toHaveLength(1)
     await fiber.dispose()
     expect(slots.entries('sidebar')).toHaveLength(0)
-    // A post-teardown list change must not reach a disposed store.
-    expect(() => {
-      sessions.list.update((draft) => { draft.ids = [] })
-    }).not.toThrow()
   })
 })