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-conversation/README.md

@@ -1,8 +1,10 @@
 # @deepseek-ai/dsh-client-ui-conversation
 
-Conversation domain: skeleton (header/tabs/composer/empty state), chat view (grouped step-summary flow, streaming tail isolation), ctx.toolviews named registry with bash samples, minimal details panel, scope-addressed ConversationService. Contract: api-contracts v3 §7.
+Conversation domain: skeleton (header/tabs/composer/empty state), chat view (grouped step-summary flow, streaming tail isolation), ctx.toolviews named registry with bash samples, minimal details panel, scope-addressed ConversationService. Contract: api-contracts v3 §7 plus the slot terminal design (store seat / props shares).
 
-`src/client/` is organized for the future package split: `contract/` is the sole inter-domain shared face (`slots.ts` composed slot props, `views.ts` view ring, `toolview.ts` tool ring, `tool-call-model.ts`); the `skeleton/`, `chat/`, and `toolviews/` domain directories import contract files and never each other; `apply.ts` is the only assembly point allowed to import all three domains. The `/client` export surface is the contract only — `apply`/`inject`, the two service classes, and the `contract/` type families; implementation components (skeleton, chat rows) stay internal and reach the page exclusively through apply's slot registrations (tests take them via the `./src/*` subpath).
+Per-session UI state (selection, composer draft, active view) lives in the declared chat store (`stores.ts` `createChatStore`): apply constructs one handle and passes it to both the conversation and details registrations, so the two session slots share one instance per session (selection written by conversation, read by details) and the framework owns instance lifecycle and draft persistence. Components are pure — the framework standard kit (`useSession`/`sessionId`/`useSessions`) and the store faces (`useStore`/`actions`) arrive automatically from the registration declaration; the inject factories contribute plain data and callbacks only (send/stop choreography, view registry read face, startSession chain).
+
+`src/client/` is organized for the future package split: `contract/` is the sole inter-domain shared face (`slots.ts` composed slot props, `views.ts` view ring, `toolview.ts` tool ring, `tool-call-model.ts`); the `skeleton/`, `chat/`, and `toolviews/` domain directories import contract files and never each other; `apply.ts` is the only assembly point allowed to import all three domains. The `/client` export surface is the contract only — `apply`/`inject`, the two service classes, and the `contract/` type families; implementation components (skeleton, chat rows) and the store factory stay internal and reach the page exclusively through apply's slot registrations (tests take them via the `./src/*` subpath).
 
 ## Model Experience
 

packages/client/ui-conversation/src/client/apply.ts

@@ -2,20 +2,18 @@
  * Client plugin body: provide the conversation service and toolview registry,
  * register the conversation/details slot occupants and the no-session empty
  * state, and mount the chat view with its samples. Assembly only — components
- * receive everything through inject factories; nothing here renders directly.
+ * receive everything through props: the framework standard kit and store
+ * faces arrive automatically from the declarations below; the inject
+ * factories contribute the plain-data-and-callbacks business face (design §5).
  */
-import { createElement, Fragment, type ReactNode } from 'react'
 import type { Context } from 'cordis'
-import type { SessionBinding } from '@deepseek-ai/dsh-client-ui-slots'
-import { scopedSlots, shallowEqual } from '@deepseek-ai/dsh-client-web-react'
-import type { SnapshotSelectorHook, UseSession } from '@deepseek-ai/dsh-client-web-react'
-import type {
-  SessionId, SessionListState, SessionsService, SlotsService,
-} from '@deepseek-ai/dsh-client-runtime/client'
+import type { BoundActions } from '@deepseek-ai/dsh-client-ui-slots'
+import type { SessionId, SessionsService, SlotsService } from '@deepseek-ai/dsh-client-runtime/client'
 import type { LayoutService } from '@deepseek-ai/dsh-client-ui-layout/client'
 import type { I18nService } from '@deepseek-ai/dsh-client-i18n/client'
-import type { ConvViewProps, SelectionTarget, ViewEntry, ViewId } from './contract/views.ts'
+import type { SelectionTarget } from './contract/views.ts'
 import type { ConversationInjected, DetailsInjected, EmptyStateInjected } from './contract/slots.ts'
+import { createChatStore } from './stores.ts'
 import { ConversationService } from './service.ts'
 import { ToolViewRegistry } from './toolviews/registry.ts'
 import { childSessionScope, registerChat } from './chat/register.ts'
@@ -37,20 +35,13 @@ function need<T>(ctx: Context, name: string): T {
   return value
 }
 
-/** Per-list-state cwd set (deduped, list order) for the empty-state picker. */
-const cwdsCache = new WeakMap<SessionListState, readonly string[]>()
-function cwdsOf(state: SessionListState): readonly string[] {
-  let cached = cwdsCache.get(state)
-  if (cached === undefined) {
-    const seen = new Set<string>()
-    for (const id of state.ids) {
-      const cwd = state.byId[id]?.cwd
-      if (cwd !== undefined && cwd !== '') seen.add(cwd)
-    }
-    cached = [...seen]
-    cwdsCache.set(state, cached)
-  }
-  return cached
+/** Resolve the session-scoped conversation service (scope-addressed send/cancel), failing loud. */
+function scopedConversation(sessions: SessionsService, id: SessionId): ConversationService {
+  const scoped = sessions.scope(id)
+  if (scoped === undefined) throw new Error(`ui-conversation: session "${id}" resolved no scope`)
+  const conversation = scoped.get('conversation')
+  if (conversation === undefined) throw new Error('ui-conversation: conversation service unavailable through the session scope')
+  return conversation
 }
 
 /**
@@ -80,106 +71,64 @@ export function apply(ctx: Context): void {
     () => registerBashSamples(toolviews, childSessionScope(sessions.list)),
     'ui-conversation: bash toolview samples')
 
-  // ConvViewProps.slots is ScopedSlots<never>: a real outlet with an empty
-  // whitelist (uncallable by type, correct runtime shape for future grants).
-  const emptySlots = scopedSlots<never>(slots.core)
+  // Shared store handle, constructed here so its identity lives and dies with
+  // this fiber (a module-level handle would be a de-facto singleton). Both
+  // session-slot registrations declare it; same scope key = same instance, so
+  // conversation writes and details reads meet in one store.
+  const chat = createChatStore()
 
-  /** conversation slot: skeleton surface assembled once per (entry x session). */
-  const conversationInject = (b: SessionBinding): ConversationInjected => {
-    const bctx = b.ctx as Context
-    const scoped = need<ConversationService>(bctx, 'conversation')
-    const id = b.sessionId as SessionId
-    const useSession = b.session.useSelector as UseSession
-    const selectionStore = scoped.selection
-    const draftsStore = scoped.drafts
-    const session = sessions.manager.get(id)
-    // Watch-driven history pull: assembling the surface IS the watch signal
-    // (once per entry x session; open() is idempotent and self-recovers).
-    void session.open()
-
-    const viewProps: Omit<ConvViewProps, 'slots'> = {
-      sessionId: id,
-      useSession,
-      useSelection: selectionStore.useSelector,
-      actions: {
-        openDetails: (target: SelectionTarget) => { scoped.openDetails(target) },
-        loadOlder: () => { void session.loadOlder() },
-      },
-    }
-
-    const injected: ConversationInjected = {
-      useAncestry: () => sessions.list.useSelector(
-        () => sessions.ancestry(id),
-        (a, b) => shallowEqual(a, b)),
-      views: {
-        list: () => conversation.views(),
-        subscribe: fn => conversation.subscribeViews(fn),
-        version: () => conversation.viewsVersion(),
-      },
-      // layout's viewFor value type is its own looser ViewId; the registry is
-      // the runtime validator (unknown ids fall back to the first view).
-      useActiveView: () => layout.current.useSelector(s => s.viewFor[id]) as ViewId | undefined,
-      composer: {
-        useDraft: () => draftsStore.useSelector(s => s),
-        setDraft: (text) => { draftsStore.set(text) },
-        send: (mode) => {
-          const text = draftsStore.getSnapshot().trim()
-          if (text === '') return
+  slots.register({
+    name: 'conversation',
+    store: chat,
+    inject: (sessionId: SessionId, actions: BoundActions<typeof chat>): ConversationInjected => {
+      const session = sessions.manager.get(sessionId)
+      const scoped = scopedConversation(sessions, sessionId)
+      // Watch-driven history pull: assembling the surface IS the watch signal
+      // (once per entry x session; open() is idempotent and self-recovers).
+      void session.open()
+      return {
+        views: {
+          list: () => conversation.views(),
+          subscribe: fn => conversation.subscribeViews(fn),
+          version: () => conversation.viewsVersion(),
+        },
+        send: (text, mode) => {
+          const trimmed = text.trim()
+          if (trimmed === '') return
           // Optimistic clear with failure restore (choreography lives with the
           // sender; the business failure also lands in snapshot.promptError).
-          draftsStore.set('')
-          void scoped.send(text, mode).catch(() => {
-            if (draftsStore.getSnapshot() === '') draftsStore.set(text)
-          })
+          // The store write path stays inside the declared actions set:
+          // restoreDraft itself no-ops once the user typed something new.
+          actions.clearDraft()
+          void scoped.send(trimmed, mode).catch(() => { actions.restoreDraft(trimmed) })
         },
         stop: () => {
           scoped.cancel().catch(() => {
             // Stop failure surfaces via snapshot.promptError; nothing to restore.
           })
         },
-      },
-      actions: {
-        openView: (view: ViewId) => { layout.openView(id, view) },
-        open: (target: SessionId) => { layout.open(target) },
-      },
-      renderView: (entry: ViewEntry): ReactNode => {
-        const children: ReactNode[] = []
-        if (entry.chrome?.header !== undefined) {
-          children.push(createElement(entry.chrome.header, { key: 'header', sessionId: id, useSession }))
-        }
-        children.push(createElement(entry.component, { key: 'view', ...viewProps, slots: emptySlots }))
-        if (entry.chrome?.footer !== undefined) {
-          children.push(createElement(entry.chrome.footer, { key: 'footer', sessionId: id, useSession }))
-        }
-        return createElement(Fragment, null, ...children)
-      },
-    }
-    return injected
-  }
+        openDetails: (target: SelectionTarget) => {
+          actions.select(target)
+          layout.openDetails()
+        },
+        loadOlder: () => { void session.loadOlder() },
+        open: (target: SessionId) => { sessions.open(target) },
+      }
+    },
+  }, ConversationRoot)
 
-  /** details slot: minimal selection-driven panel. */
-  const detailsInject = (b: SessionBinding): DetailsInjected => {
-    const bctx = b.ctx as Context
-    const scoped = need<ConversationService>(bctx, 'conversation')
-    const injected: DetailsInjected = {
-      useSelection: scoped.selection.useSelector,
-      actions: { closeDetails: () => { layout.closeDetails() } },
-    }
-    return injected
-  }
+  slots.register({
+    name: 'details',
+    store: chat,
+    inject: (): DetailsInjected => ({
+      closeDetails: () => { layout.closeDetails() },
+    }),
+  }, DetailsPanel)
 
-  /** conversation.empty root slot: the NEW SESSION hero. */
-  const emptyInject = (): EmptyStateInjected => {
-    const useCwds: SnapshotSelectorHook<readonly string[]> = (sel, eq) =>
-      sessions.list.useSelector(s => sel(cwdsOf(s)), eq)
-    const injected: EmptyStateInjected = {
-      useCwds,
-      actions: { startSession: opts => conversation.startSession(opts) },
-    }
-    return injected
-  }
-
-  slots.register('conversation', ConversationRoot, { inject: conversationInject })
-  slots.register('details', DetailsPanel, { inject: detailsInject })
-  slots.register('conversation.empty', EmptyState, { inject: emptyInject })
+  slots.register({
+    name: 'conversation.empty',
+    inject: (): EmptyStateInjected => ({
+      startSession: opts => conversation.startSession(opts),
+    }),
+  }, EmptyState)
 }

packages/client/ui-conversation/src/client/chat/ChatView.tsx

@@ -122,7 +122,7 @@ function StreamingTail({ useSession, onGrow }: {
 export function createChatView(deps: ChatViewDeps): FC<ConvViewProps> {
   const { toolviews, t } = deps
 
-  return function ChatView({ sessionId, useSession: useSessionWide, useSelection, actions }: ConvViewProps) {
+  return function ChatView({ sessionId, useSession: useSessionWide, useStore, actions }: ConvViewProps) {
     const useSession = useSessionWide as UseConversation
     const nodes = useSession((s) => s.nodes)
     const runningCalls = useSession((s) => s.runningCalls)
@@ -131,7 +131,7 @@ export function createChatView(deps: ChatViewDeps): FC<ConvViewProps> {
     const openErrorMessage = useSession((s) => s.openError === null ? null : `${s.openError.message}（${s.openError.code}）`)
     const hasMore = useSession((s) => s.hasMore)
     const loadingOlder = useSession((s) => s.loadingOlder)
-    const selectedCallId = useSelection((sel) => sel?.callId)
+    const selectedCallId = useStore((s) => s.selection?.callId)
 
     const items = useMemo(() => deriveChatFlow(nodes), [nodes])
 

packages/client/ui-conversation/src/client/chat/ToolViewOutlet.tsx

@@ -1,13 +1,12 @@
 // ToolViewOutlet: resolves the toolview for one call through ctx.toolviews
 // (uSES over the registry version so unload falls back live) and renders it
 // behind a per-row error boundary. GenericToolCard is the render-side
-// fallback for both a registry miss and a crashed custom row. A registrant
-// inject factory is called once per (registration x binding) and cached,
-// mirroring the scoped-slots injection discipline.
+// fallback for both a registry miss and a crashed custom row. Pure props
+// machinery, zero React context: a registrant inject factory receives the
+// sessionId this outlet already holds, is called once per (registration x
+// session) and cached, mirroring the slot injection discipline.
 
-import { Component, useSyncExternalStore, type FC, type ReactNode } from 'react'
-import { useSessionBinding } from '@deepseek-ai/dsh-client-web-react'
-import type { SessionBinding } from '@deepseek-ai/dsh-client-ui-slots'
+import { Component, useSyncExternalStore, type ReactNode } from 'react'
 import type { SessionId } from '@deepseek-ai/dsh-client-runtime/client'
 import type { ToolViewInject, ToolViewProps, ToolViewResolver } from '../contract/toolview.ts'
 import { GenericToolCard } from './GenericToolCard.tsx'
@@ -19,19 +18,21 @@ export interface ToolViewOutletProps {
   viewProps: ToolViewProps
 }
 
-/** Inject cache: per inject-factory (stable per registration) x binding object. */
-const injectCache = new WeakMap<ToolViewInject<object>, WeakMap<object, object>>()
+/** Inject cache: per inject-factory (stable per registration) x session id.
+ *  The inner Map lives and dies with its factory (WeakMap entry), so entries
+ *  are bounded by the session count over the registration's lifetime. */
+const injectCache = new WeakMap<ToolViewInject<object>, Map<SessionId, object>>()
 
-function cachedInject(inject: ToolViewInject<object>, binding: SessionBinding): object {
-  let perBinding = injectCache.get(inject)
-  if (!perBinding) {
-    perBinding = new WeakMap()
-    injectCache.set(inject, perBinding)
+function cachedInject(inject: ToolViewInject<object>, sessionId: SessionId): object {
+  let perSession = injectCache.get(inject)
+  if (!perSession) {
+    perSession = new Map()
+    injectCache.set(inject, perSession)
   }
-  let props = perBinding.get(binding)
+  let props = perSession.get(sessionId)
   if (!props) {
-    props = inject(binding)
-    perBinding.set(binding, props)
+    props = inject(sessionId)
+    perSession.set(sessionId, props)
   }
   return props
 }
@@ -61,16 +62,6 @@ class RowErrorBoundary extends Component<
   }
 }
 
-/** Split component: only inject-carrying registrations need the session
- *  binding hook (keeps injectless rendering free of the Provider requirement). */
-function InjectedRow({ Row, inject, viewProps }: {
-  Row: FC<ToolViewProps & object>; inject: ToolViewInject<object>; viewProps: ToolViewProps
-}) {
-  const binding = useSessionBinding()
-  const injected = cachedInject(inject, binding)
-  return <Row {...{ ...injected, ...viewProps }} />
-}
-
 export function ToolViewOutlet({ registry, sessionId, toolName, viewProps }: ToolViewOutletProps) {
   const version = useSyncExternalStore(
     (fn) => registry.subscribe(fn),
@@ -83,7 +74,7 @@ export function ToolViewOutlet({ registry, sessionId, toolName, viewProps }: Too
     <RowErrorBoundary resetKey={version} fallback={<GenericToolCard {...viewProps} />}>
       {resolved.inject === undefined
         ? <Row {...viewProps} />
-        : <InjectedRow Row={Row} inject={resolved.inject} viewProps={viewProps} />}
+        : <Row {...{ ...cachedInject(resolved.inject, sessionId), ...viewProps }} />}
     </RowErrorBoundary>
   )
 }

packages/client/ui-conversation/src/client/contract/slots.ts

@@ -1,63 +1,67 @@
 /**
  * Slot-ring contract for the conversation package: the composed props shapes
  * its registrants mount into the layout-owned slots (conversation / details /
- * conversation.empty — the SlotMap declarations live with ui-layout, the
- * slot owner). Per the share-ownership rule, the owner share is REFERENCED
- * from ui-layout and each registrant's injected share is declared here, next
- * to the component that receives it; full component props = owner share &
- * standard share & own injected share.
+ * conversation.empty). Terminal slot design (§3): full component props are the
+ * automatic shares — PropsRuntime<K> (framework standard kit) & PropsStore<H>
+ * (declared store's read/write faces) & the injected business face declared
+ * here. No renderSlot share: none of the three registrations declares
+ * children, so the zero-renderSlot inference applies.
  */
-import type { ReactNode } from 'react'
-import type { SessionId, SessionSummary } from '@deepseek-ai/dsh-client-runtime/client'
-import type { SnapshotSelectorHook, UseSession } from '@deepseek-ai/dsh-client-web-react'
-import type { ConvOwnerProps, DetailsOwnerProps, EmptyOwnerProps } from '@deepseek-ai/dsh-client-ui-layout/client'
-import type { SelectionTarget, ViewEntry, ViewId } from './views.ts'
+import type { PropsRuntime, PropsStore } from '@deepseek-ai/dsh-client-ui-slots'
+import type { SessionId } from '@deepseek-ai/dsh-client-runtime/client'
+import type { createChatStore } from '../stores.ts'
+import type { SelectionTarget, ViewEntry } from './views.ts'
 
-/** Injected share of the conversation slot (assembled by apply's inject factory). */
+/** The shared chat store handle type (apply constructs one; conversation and details both declare it). */
+export type ChatStore = ReturnType<typeof createChatStore>
+
+/**
+ * Injected share of the conversation slot: plain data and callbacks only
+ * (design §5 — hooks are framework-made). The store lines that used to ride
+ * here live in the declared {@link ChatStore} now; ancestry derives from the
+ * standard useSessions hook in-component; view rendering moved into the
+ * component, which holds every share a view needs.
+ */
 export interface ConversationInjected {
-  /** Breadcrumb chain (root ancestor first, self last; ancestry(list) feed). */
-  useAncestry: () => readonly SessionSummary[]
   /** View registry read face (uSES triple from the conversation service). */
   views: {
     list(): readonly ViewEntry[]
     subscribe(fn: () => void): () => void
     version(): number
   }
-  /** Active view accessor (layout.viewFor backed; undefined falls to 'chat'). */
-  useActiveView: () => ViewId | undefined
-  /** Composer surface: draft store hook pair + send/stop choreography. */
-  composer: {
-    useDraft: () => string
-    setDraft(text: string): void
-    send(mode: 'queue' | 'steer'): void
-    stop(): void
-  }
-  actions: {
-    openView(view: ViewId): void
-    open(id: SessionId): void
-  }
-  /** Renders the active view's body (the owner closes over ConvViewProps assembly). */
-  renderView: (entry: ViewEntry) => ReactNode
+  /** Send choreography: trims, clears the draft optimistically, restores it on failure. */
+  send(text: string, mode: 'queue' | 'steer'): void
+  /** Cancel the in-flight turn (failure surfaces via snapshot.promptError). */
+  stop(): void
+  /** Selection write + details panel opening in one gesture (store action + layout orchestration). */
+  openDetails(target: SelectionTarget): void
+  /** Pull one older history page. */
+  loadOlder(): void
+  /** Navigate to another session (breadcrumb ancestors). */
+  open(id: SessionId): void
 }
 
-/** Full conversation-slot component props: owner share & standard share & injected share. */
-export type ConversationSlotProps = ConvOwnerProps & { useSession: UseSession } & ConversationInjected
+/** Full conversation-slot component props: runtime share & store share & injected share. */
+export type ConversationSlotProps =
+  PropsRuntime<'conversation'> & PropsStore<ChatStore> & ConversationInjected
 
-/** Injected share of the details slot. */
+/**
+ * Injected share of the details slot: the panel is otherwise a pure reader of
+ * the shared chat store, but its close button is a layout orchestration call.
+ */
 export interface DetailsInjected {
-  useSelection: SnapshotSelectorHook<SelectionTarget | null>
-  actions: { closeDetails(): void }
+  /** Close the details panel (layout geometry stays with ctx.layout). */
+  closeDetails(): void
 }
 
-/** Full details-slot component props. */
-export type DetailsSlotProps = DetailsOwnerProps & { useSession: UseSession } & DetailsInjected
+/** Full details-slot component props: selection arrives through the shared store, call material through useSession. */
+export type DetailsSlotProps = PropsRuntime<'details'> & PropsStore<ChatStore> & DetailsInjected
 
-/** Injected share of the no-session empty-state slot (root slot: no standard share). */
+/** Injected share of the no-session empty-state slot. */
 export interface EmptyStateInjected {
-  /** cwd options derived from sessions.list (deduped; assembled by the inject factory). */
-  useCwds: SnapshotSelectorHook<readonly string[]>
-  actions: { startSession(opts: { cwd?: string; text: string; mode: 'queue' | 'steer' }): Promise<void> }
+  /** The create → navigate → first-send chain, in one service call. */
+  startSession(opts: { cwd?: string; text: string; mode: 'queue' | 'steer' }): Promise<void>
 }
 
-/** Full empty-state component props. */
-export type EmptyStateSlotProps = EmptyOwnerProps & EmptyStateInjected
+/** Full empty-state component props (root slot: no store; cwd options derive from useSessions in-component). */
+export type EmptyStateSlotProps = PropsRuntime<'conversation.empty'> & EmptyStateInjected

packages/client/ui-conversation/src/client/contract/toolview.ts

@@ -6,7 +6,6 @@
  * implementation files import this, never each other.
  */
 import type { FC } from 'react'
-import type { SessionBinding } from '@deepseek-ai/dsh-client-ui-slots'
 import type { UseSession } from '@deepseek-ai/dsh-client-web-react'
 import type { SessionId, ToolCallBlock } from '@deepseek-ai/dsh-client-runtime/client'
 import type { CallId, Translate } from './views.ts'
@@ -28,11 +27,13 @@ export interface ToolViewProps {
 
 /**
  * Toolview inject factory: produces the registrant's private injected share
- * `I`, called once per (registration x session binding) and cached by the
- * render outlet. Session-bound by nature — tool rows always render inside a
- * session subtree.
+ * `I`, called once per (registration x session) and cached by the render
+ * outlet. Mirrors the slot inject shape (parameters derive from the
+ * declaration): toolviews are session-domain by nature, so the factory
+ * receives the session id only — service access goes through the
+ * registrant's own apply-closure ctx (design §5; binding objects retired).
  */
-export type ToolViewInject<I extends object> = (b: SessionBinding) => I
+export type ToolViewInject<I extends object> = (sessionId: SessionId) => I
 
 /** Options accepted by the toolview registry's register; `I` is inferred from the inject factory. */
 export interface ToolViewOptions<I extends object = object> {

packages/client/ui-conversation/src/client/contract/views.ts

@@ -1,11 +1,11 @@
 /**
- * View-ring contract: the typed conversation view table and the props
- * surfaces handed to registered views. Shared face between the skeleton
- * domain (ConversationRoot renders views) and the chat domain (registers the
- * chat view); domain implementation files import this, never each other.
+ * View-ring contract: the typed conversation view table, the chat store state
+ * shared through it, and the props surfaces handed to registered views.
+ * Shared face between the skeleton domain (ConversationRoot renders views)
+ * and the chat domain (registers the chat view); domain implementation files
+ * import this, never each other.
  */
 import type { FC } from 'react'
-import type { ScopedSlots } from '@deepseek-ai/dsh-client-ui-slots'
 import type { SnapshotSelectorHook, UseSession } from '@deepseek-ai/dsh-client-web-react'
 import type { SessionId } from '@deepseek-ai/dsh-client-runtime/client'
 
@@ -57,12 +57,33 @@ export interface ChromeProps { sessionId: SessionId; useSession: UseSession }
 /** Selection target for the details linkage channel (toolcall is the step special case). */
 export interface SelectionTarget { turnSeq: number; stepSeq?: number; callId?: CallId; toolName?: string }
 
-/** Props handed to registered conversation views. */
+/**
+ * Chat store state (slot terminal design §4): the per-session store shared by
+ * the conversation and details registrations. `createChatStore` implements
+ * this shape; views read it through {@link ConvViewProps}'s pass-through hook.
+ * `view` may carry a stale persisted id after a view plugin unloads — the
+ * registry is the runtime validator (unknown ids fall back to the first view).
+ */
+export interface ChatStoreState {
+  /** Details-linkage channel (conversation writes, details reads). */
+  selection: SelectionTarget | null
+  /** Composer draft (persisted; survives session switches and reloads). */
+  draft: string
+  /** Active conversation view id; null falls back to the first registered view. */
+  view: ViewId | null
+}
+
+/**
+ * Props handed to registered conversation views. `useSession` and `useStore`
+ * are the framework hooks ConversationRoot received as a slot registrant,
+ * passed through unchanged (hook transfer is plain props passing; no
+ * business-made subscription exists on this path). No renderSlot share: the
+ * view ring delegates no sub-slots.
+ */
 export interface ConvViewProps {
   sessionId: SessionId
   useSession: UseSession
-  useSelection: SnapshotSelectorHook<SelectionTarget | null>
+  /** Chat store read face (selection is the only slice views consume today). */
+  useStore: SnapshotSelectorHook<ChatStoreState>
   actions: { openDetails(t: SelectionTarget): void; loadOlder(): void }
-  /** Chat has no delegated sub-slots in P-I (toolviews go through the named registry). */
-  slots: ScopedSlots<never>
 }

packages/client/ui-conversation/src/client/index.ts

@@ -14,14 +14,14 @@ export { ConversationService } from './service.ts'
 export { ToolViewRegistry } from './toolviews/registry.ts'
 
 export type {
-  CallId, ChromeProps, ChromePropsOf, ConversationViewMap, ConvViewProps, ConvViewPropsOf,
-  SelectionTarget, Translate, ViewEntry, ViewEntryDef, ViewId,
+  CallId, ChatStoreState, ChromeProps, ChromePropsOf, ConversationViewMap, ConvViewProps,
+  ConvViewPropsOf, SelectionTarget, Translate, ViewEntry, ViewEntryDef, ViewId,
 } from './contract/views.ts'
 export type {
   ResolvedToolView, ToolCallBlock, ToolViewOptions, ToolViewProps, ToolViewResolver,
 } from './contract/toolview.ts'
 export type {
-  ConversationInjected, ConversationSlotProps, DetailsInjected, DetailsSlotProps,
+  ChatStore, ConversationInjected, ConversationSlotProps, DetailsInjected, DetailsSlotProps,
   EmptyStateInjected, EmptyStateSlotProps,
 } from './contract/slots.ts'
 // Export discipline: packages/client/AGENTS.md.

packages/client/ui-conversation/src/client/service.ts

@@ -1,8 +1,10 @@
 /**
- * ConversationService implementation: scope-addressed send/cancel, per-scope
- * selection/draft stores booked on the session scope fiber, view registry
- * with a uSES read face, openDetails orchestration, and the empty-state
- * startSession chain. Contract: api-contracts v3 section 7.
+ * ConversationService implementation: scope-addressed send/cancel, view
+ * registry with a uSES read face, and the empty-state startSession chain.
+ * Contract: api-contracts v3 section 7. Selection/draft state moved to the
+ * declared chat store (slot terminal design §4) — the per-scope store maps,
+ * lazy construction, and prune bookkeeping this service used to carry are
+ * retired; what remains is the send/stop orchestration face.
  *
  * Scope addressing rides the cordis Service tracker: property access through
  * `ctx.conversation` rebinds `this.ctx` to the caller's context, so methods
@@ -20,11 +22,8 @@ import type { Context } from 'cordis'
 // SessionsService tags contexts with — scopeOf then always returns undefined
 // in the browser while unit tests (single-instance path resolution) stay green.
 import { scopeOf } from '@deepseek-ai/dsh-client-runtime/client'
-import type { Session, SessionId, SessionsService } from '@deepseek-ai/dsh-client-runtime/client'
-import { createSnapshotStore } from '@deepseek-ai/dsh-client-web-react'
-import type { SnapshotStore } from '@deepseek-ai/dsh-client-web-react'
-import type { LayoutService } from '@deepseek-ai/dsh-client-ui-layout/client'
-import type { SelectionTarget, ViewEntry, ViewId } from './index.ts'
+import type { Session, SessionsService } from '@deepseek-ai/dsh-client-runtime/client'
+import type { ViewEntry, ViewId } from './index.ts'
 
 /** Mutable view-registry cell (plain object: mutation never crosses the tracker proxy). */
 interface ViewsState {
@@ -37,8 +36,6 @@ interface ViewsState {
 
 /** Scope-addressed conversation service (root singleton, provided as `conversation`). */
 export class ConversationService extends Service {
-  private readonly selections = new Map<SessionId, SnapshotStore<SelectionTarget | null>>()
-  private readonly draftStores = new Map<SessionId, SnapshotStore<string>>()
   private readonly viewsState: ViewsState = {
     entries: new Map(), cache: null, tick: 0, listeners: new Set(),
   }
@@ -71,37 +68,6 @@ export class ConversationService extends Service {
     if (!result.ok) throw new Error(`conversation.cancel failed: ${result.error.code}: ${result.error.message}`)
   }
 
-  /** Per-scope selection channel (details linkage); root access throws. */
-  get selection(): SnapshotStore<SelectionTarget | null> {
-    return this.scopeStore(this.selections, 'selection',
-      () => createSnapshotStore<SelectionTarget | null>(null))
-  }
-
-  /**
-   * Per-scope draft store, persisted per session id; root access throws.
-   * Persistence is hand-rolled (raw string per key): the snapshot-store
-   * engine's persist middleware object-spreads state on save, corrupting
-   * primitive-state stores.
-   */
-  get drafts(): SnapshotStore<string> {
-    return this.scopeStore(this.draftStores, 'drafts', (id) => {
-      const key = `dsh.conversation.draft.${id}`
-      const store = createSnapshotStore<string>(loadDraft(key))
-      store.subscribe(() => { saveDraft(key, store.getSnapshot()) })
-      return store
-    })
-  }
-
-  /**
-   * Write the scoped selection and open the details panel. Orchestration
-   * only — panel geometry stays with ctx.layout.
-   * @param target - selection target.
-   */
-  openDetails(target: SelectionTarget): void {
-    this.selection.set(target)
-    this.requireLayout().openDetails()
-  }
-
   /**
    * Register a conversation view. Duplicate ids throw; the registration is an
    * effect on the caller's fiber (plugin unload collects it).
@@ -170,9 +136,9 @@ export class ConversationService extends Service {
     const sessions = this.requireSessions()
     const id = await sessions.create(opts.cwd === undefined ? {} : { cwd: opts.cwd })
     // The manager notifier flushes per microtask; one await guarantees the
-    // list-store projection landed before layout.open validates against it.
+    // list-store projection landed before sessions.open validates against it.
     await Promise.resolve()
-    this.requireLayout().open(id)
+    sessions.open(id)
     const scoped = sessions.scope(id)
     if (scoped === undefined) throw new Error(`conversation.startSession: created session "${id}" resolved no scope`)
     // ctx.get, not scoped.conversation: property access walks the fiber
@@ -185,34 +151,11 @@ export class ConversationService extends Service {
 
   /** Resolve the caller scope's Session or throw on root contexts. */
   private scopedSession(op: string): Session {
-    const id = this.scopeId(op)
-    return this.requireSessions().manager.get(id)
-  }
-
-  /** Read the caller's session scope tag; root contexts fail loud. */
-  private scopeId(op: string): SessionId {
     const id = scopeOf(this.ctx)
     if (id === undefined) {
       throw new Error(`conversation.${op} requires a session scope — address one via ctx.sessions.scope(id).conversation`)
     }
-    return id
-  }
-
-  /**
-   * Per-scope store account: lazily created, booked on the scope fiber so the
-   * scope teardown (SessionsService prune) collects the entry.
-   */
-  private scopeStore<T>(
-    map: Map<SessionId, SnapshotStore<T>>, op: string,
-    make: (id: SessionId) => SnapshotStore<T>): SnapshotStore<T> {
-    const id = this.scopeId(op)
-    let store = map.get(id)
-    if (store === undefined) {
-      store = make(id)
-      map.set(id, store)
-      this.ctx.effect(() => () => { map.delete(id) }, `conversation.${op} scope account`)
-    }
-    return store
+    return this.requireSessions().manager.get(id)
   }
 
   private requireSessions(): SessionsService {
@@ -223,12 +166,6 @@ export class ConversationService extends Service {
     if (sessions === undefined) throw new Error('conversation: sessions service unavailable')
     return sessions
   }
-
-  private requireLayout(): LayoutService {
-    const layout = this.ctx.get('layout')
-    if (layout === undefined) throw new Error('conversation: layout service unavailable')
-    return layout
-  }
 }
 
 function bumpViews(state: ViewsState): void {
@@ -236,16 +173,3 @@ function bumpViews(state: ViewsState): void {
   state.tick += 1
   for (const fn of [...state.listeners]) fn()
 }
-
-function loadDraft(key: string): string {
-  /* v8 ignore next -- storage-less environment guard (workers/tests without DOM); jsdom always provides localStorage. */
-  if (typeof localStorage === 'undefined') return ''
-  return localStorage.getItem(key) ?? ''
-}
-
-function saveDraft(key: string, text: string): void {
-  /* v8 ignore next -- storage-less environment guard (workers/tests without DOM); jsdom always provides localStorage. */
-  if (typeof localStorage === 'undefined') return
-  if (text === '') localStorage.removeItem(key)
-  else localStorage.setItem(key, text)
-}

packages/client/ui-conversation/src/client/skeleton/ConversationRoot.tsx

@@ -1,43 +1,82 @@
 // ConversationRoot: the conversation slot's skeleton (figma Header 39:27730 +
-// Tab_Group + view area + composer). Zero framework imports — everything
-// arrives via props from the inject factory: breadcrumb feed, view registry
-// read face, per-view render, and the composer's draft/send choreography.
-// The active view id lives in layout.viewFor (shell viewing state), read and
-// written through injected accessors.
+// Tab_Group + view area + composer). Pure component — everything arrives via
+// props: the framework standard kit (useSession/sessionId/useSessions), the
+// declared chat store's useStore/actions, and the injected business face.
+// Breadcrumbs derive from useSessions with a pure parentId walk; the active
+// view id lives in the chat store's `view` field (per-session by store scope).
 
-import { useSyncExternalStore } from 'react'
+import { useMemo, useSyncExternalStore, type ReactNode } from 'react'
 import clsx from 'clsx'
+import type { SessionId, SessionListState, SessionSummary } from '@deepseek-ai/dsh-client-runtime/client'
+import { shallowEqual } from '@deepseek-ai/dsh-client-web-react'
 import type { ConversationSlotProps } from '../contract/slots.ts'
+import type { ConvViewProps, ViewEntry } from '../contract/views.ts'
 import { InputBar } from './InputBar.tsx'
 import type { InputBarError } from './InputBar.tsx'
 import css from './ConversationRoot.module.css'
 
-/**
- * Full props = owner share (sessionId) & standard share (useSession) &
- * injected share — composed by reference from the contract, never re-typed
- * here (share-ownership rule).
- */
+/** Full props = the automatic shares & injected share — composed by reference
+ *  from the contract, never re-typed here (share-ownership rule). */
 export type ConversationRootProps = ConversationSlotProps
 
+/** Breadcrumb chain: walk parentId links (root ancestor first, self last;
+ *  empty when unknown; a broken link stops the walk). Pure twin of the
+ *  sessions service's ancestry — components derive, they don't subscribe. */
+function deriveAncestry(list: SessionListState, id: SessionId): readonly SessionSummary[] {
+  const chain: SessionSummary[] = []
+  let cursor: SessionId | undefined = id
+  while (cursor !== undefined) {
+    const summary: SessionSummary | undefined = list.byId[cursor]
+    if (summary === undefined || chain.includes(summary)) break
+    chain.unshift(summary)
+    cursor = summary.parentId
+  }
+  return chain
+}
+
 export function ConversationRoot({
-  sessionId, useSession, useAncestry, views, useActiveView, composer, actions, renderView,
+  sessionId, useSession, useSessions, useStore, actions,
+  views, send, stop, openDetails, loadOlder, open,
 }: ConversationRootProps) {
   useSyncExternalStore(views.subscribe, views.version)
   const list = views.list()
-  const activeId = useActiveView() ?? 'chat'
+  // The store's persisted view id may be stale (view plugin unloaded); the
+  // registry is the runtime validator — unknown ids fall to the first view.
+  const activeId = useStore(s => s.view) ?? 'chat'
   const active = list.find(v => v.id === activeId) ?? list[0]
 
-  const ancestry = useAncestry()
-  const draft = composer.useDraft()
-  const running = useSession(s => (s as { running: boolean }).running)
-  const removed = useSession(s => (s as { removed: boolean }).removed)
-  const promptError = useSession(s => (s as { promptError: { op: 'send' | 'stop'; error: { message: string; code: string } } | null }).promptError)
-  const turns = useSession(s => countTurns(s as { nodes: readonly { kind: string }[] }))
+  const ancestry = useSessions(s => deriveAncestry(s, sessionId), shallowEqual)
+  const draft = useStore(s => s.draft)
+  const running = useSession(s => s.running)
+  const removed = useSession(s => s.removed)
+  const promptError = useSession(s => s.promptError)
+  const turns = useSession(s => countTurns(s))
 
   const error: InputBarError | null = promptError === null
     ? null
     : { op: promptError.op, message: `${promptError.error.message}（${promptError.error.code}）` }
 
+  // Views receive the shares this component already holds (hook transfer is
+  // plain props passing); the callback slice is referentially stable per
+  // injected identity so memoized view rows hold.
+  const viewProps = useMemo<ConvViewProps>(() => ({
+    sessionId, useSession, useStore,
+    actions: { openDetails, loadOlder },
+  }), [sessionId, useSession, useStore, openDetails, loadOlder])
+
+  const renderView = (entry: ViewEntry): ReactNode => {
+    const Header = entry.chrome?.header
+    const Footer = entry.chrome?.footer
+    const View = entry.component
+    return (
+      <>
+        {Header !== undefined && <Header sessionId={sessionId} useSession={useSession} />}
+        <View {...viewProps} />
+        {Footer !== undefined && <Footer sessionId={sessionId} useSession={useSession} />}
+      </>
+    )
+  }
+
   return (
     <div className={css.root}>
       <header className={css.header}>
@@ -52,7 +91,7 @@ export function ConversationRoot({
                     type="button"
                     className={clsx(css.crumb, last && css.crumbCurrent)}
                     disabled={last}
-                    onClick={() => { actions.open(s.id) }}
+                    onClick={() => { open(s.id) }}
                   >
                     {s.title}
                   </button>
@@ -74,7 +113,7 @@ export function ConversationRoot({
                 role="tab"
                 aria-selected={v.id === active?.id}
                 className={clsx(css.tab, v.id === active?.id && css.tabActive)}
-                onClick={() => { actions.openView(v.id) }}
+                onClick={() => { actions.setView(v.id) }}
               >
                 {v.label}
               </button>
@@ -93,9 +132,9 @@ export function ConversationRoot({
         disabled={removed}
         error={error}
         variant="composer"
-        onDraftChange={composer.setDraft}
-        onSend={composer.send}
-        onStop={composer.stop}
+        onDraftChange={actions.setDraft}
+        onSend={(mode) => { send(draft, mode) }}
+        onStop={stop}
       />
     </div>
   )

packages/client/ui-conversation/src/client/skeleton/DetailsPanel.tsx

@@ -1,14 +1,16 @@
 // DetailsPanel, P-I minimal form: close button + the selected call's args and
 // result rendered raw. The three-段 Switch / Prev-Next stepping / See-in-
-// trajectory are deferred (ledger). Subscribes to the per-scope selection and
-// derives the call material from the session snapshot — no data of its own.
+// trajectory are deferred (ledger). Reads the selection from the shared chat
+// store (conversation writes, this panel reads — the cross-registration
+// share the store seat exists for) and derives the call material from the
+// session snapshot — no data of its own.
 
 import type { ConversationSnapshot, ToolResultNode } from '@deepseek-ai/dsh-client-runtime/client'
 import { shallowEqual } from '@deepseek-ai/dsh-client-web-react'
 import type { DetailsSlotProps } from '../contract/slots.ts'
 import css from './DetailsPanel.module.css'
 
-/** Full props composed by reference from the contract (owner & standard & injected shares). */
+/** Full props composed by reference from the contract (automatic shares & injected share). */
 export type DetailsPanelProps = DetailsSlotProps
 
 /** Selected call material: resolved result node, or the in-flight running call's args. */
@@ -41,13 +43,13 @@ function pretty(raw: string): string {
   }
 }
 
-export function DetailsPanel({ useSession, useSelection, actions }: DetailsPanelProps) {
-  const selection = useSelection(s => s)
+export function DetailsPanel({ useSession, useStore, closeDetails }: DetailsPanelProps) {
+  const selection = useStore(s => s.selection)
   const callId = selection?.callId
   // materialFor builds a fresh wrapper; shallowEqual short-circuits on its
   // stable members (result node reference rides the snapshot's structural sharing).
   const material = useSession(
-    s => (callId === undefined ? null : materialFor(s as ConversationSnapshot, callId)),
+    s => (callId === undefined ? null : materialFor(s, callId)),
     (a, b) => shallowEqual(a, b))
 
   return (
@@ -58,7 +60,7 @@ export function DetailsPanel({ useSession, useSelection, actions }: DetailsPanel
         </div>
         <button
           type="button" className={css.close} aria-label="关闭详情"
-          onClick={() => { actions.closeDetails() }}
+          onClick={() => { closeDetails() }}
         >
           <svg viewBox="0 0 16 16" width="14" height="14" aria-hidden>
             <path d="M4 4l8 8M12 4l-8 8" stroke="currentColor" strokeWidth="1.5" strokeLinecap="round" />

packages/client/ui-conversation/src/client/skeleton/EmptyState.tsx

@@ -1,12 +1,14 @@
 // EmptyState (figma NEW SESSION screen): centered hero card built around the
 // SAME InputBar component the resident composer uses (the empty→content
 // transition is one component changing position, never a swap). Project
-// picker: cwd set derived from sessions.list plus a free-form new-directory
-// input; submit runs the startSession chain (create → open → send) in one
-// service call.
+// picker: cwd set derived in-component from the standard useSessions hook
+// (subscription is the framework's, derivation is a pure function — design
+// §6) plus a free-form new-directory input; submit runs the startSession
+// chain (create → open → send) in one service call.
 
-import { useState } from 'react'
+import { useMemo, useState } from 'react'
 import { FishLogo } from '@deepseek-ai/dsh-client-ui-primitives'
+import type { SessionListState } from '@deepseek-ai/dsh-client-runtime/client'
 import type { EmptyStateSlotProps } from '../contract/slots.ts'
 import { InputBar } from './InputBar.tsx'
 import type { InputBarError } from './InputBar.tsx'
@@ -15,11 +17,22 @@ import css from './EmptyState.module.css'
 /** Select sentinel for the free-form directory entry (impossible as a real path: not absolute). */
 const NEW_DIR = '::new-directory'
 
-/** Full props composed by reference from the contract (owner & injected shares; root slot has no standard share). */
+/** Full props composed by reference from the contract (runtime share & injected share; no store). */
 export type EmptyStateProps = EmptyStateSlotProps
 
-export function EmptyState({ useCwds, actions }: EmptyStateProps) {
-  const cwds = useCwds(s => s)
+/** Deduped cwd set in list order (pure derivation over the sessions list). */
+function deriveCwds(state: SessionListState): readonly string[] {
+  const seen = new Set<string>()
+  for (const id of state.ids) {
+    const cwd = state.byId[id]?.cwd
+    if (cwd !== undefined && cwd !== '') seen.add(cwd)
+  }
+  return [...seen]
+}
+
+export function EmptyState({ useSessions, startSession }: EmptyStateProps) {
+  const list = useSessions(s => s)
+  const cwds = useMemo(() => deriveCwds(list), [list])
   // Local viewing state: the empty state owns no session, so its draft is
   // ephemeral by design (drafts are keyed by session id; there is none yet).
   const [draft, setDraft] = useState('')
@@ -35,14 +48,14 @@ export function EmptyState({ useCwds, actions }: EmptyStateProps) {
     setSending(true)
     setError(null)
     const chosen = cwd.trim()
-    actions.startSession({ text, mode, ...(chosen === '' ? {} : { cwd: chosen }) })
+    startSession({ text, mode, ...(chosen === '' ? {} : { cwd: chosen }) })
       .catch((reason: unknown) => {
         // The empty state survives failure with the draft intact (no session
         // exists to carry promptError; this is the only local error surface).
         setError({ op: 'send', message: reason instanceof Error ? reason.message : String(reason) })
         setSending(false)
       })
-    // Success needs no cleanup: layout.open swaps this slot out for the session body.
+    // Success needs no cleanup: the session selection swaps this slot out for the session body.
   }
 
   const picker = (

packages/client/ui-conversation/src/client/stores.ts

@@ -0,0 +1,40 @@
+/**
+ * Chat store factory (slot terminal design §4): selection + draft + active
+ * view for one session, shared by the conversation and details registrations
+ * (apply constructs one handle and passes it to both). Session-scope
+ * derivation: both mount slots are scope=session, so the framework creates
+ * one instance per session; the persist key is scope-suffixed by the
+ * framework, aligning with the previous per-session draft persistence.
+ *
+ * Module exports the factory only — a module-level handle would pin identity
+ * in the module cache (a de-facto singleton surviving plugin reloads).
+ */
+import { defineStore } from '@deepseek-ai/dsh-client-web-react'
+import type { ChatStoreState, SelectionTarget, ViewId } from './contract/views.ts'
+
+/**
+ * Declare the per-session chat store. `selection` is the details-linkage
+ * channel (conversation writes, details reads); `draft` is the composer text
+ * (persisted so it survives session switches and reloads); `view` is the
+ * active conversation view id (previously layout.viewFor — store seat is the
+ * cross-remount survival channel, null falls back to the first registered view).
+ * @returns the store handle (spec + identity + factory in one value).
+ */
+export function createChatStore() {
+  return defineStore({
+    // Anchored to the contract shape: views consume the store through
+    // ConvViewProps' SnapshotSelectorHook<ChatStoreState>, so init and the
+    // contract cannot drift.
+    init: (): ChatStoreState => ({ selection: null, draft: '', view: null }),
+    persist: 'dsh.conversation.chat',
+    actions: {
+      select: (d, target: SelectionTarget | null) => { d.selection = target },
+      setDraft: (d, text: string) => { d.draft = text },
+      clearDraft: (d) => { d.draft = '' },
+      // Optimistic-send failure restore: only when the user typed nothing new
+      // since the clear (send choreography lives in the inject factory).
+      restoreDraft: (d, text: string) => { if (d.draft === '') d.draft = text },
+      setView: (d, view: ViewId) => { d.view = view },
+    },
+  })
+}

packages/client/ui-conversation/tests/apply-inject.spec.tsx

@@ -1,26 +1,32 @@
 // @vitest-environment jsdom
-// apply inject factories exercised end to end: the conversation slot surface
-// (ancestry feed, views triple, active view, composer choreography incl.
-// optimistic clear + failure restore, renderView chrome assembly, watch-driven
-// open), the details surface, and the empty-state surface (cwd derivation
-// cache). Complements chat-apply.spec.tsx, which stops at registration.
+// apply inject factories exercised end to end against the terminal thin
+// shape: the conversation surface (views triple, send choreography incl.
+// optimistic clear + failure restore THROUGH the declared store actions,
+// openDetails = select action + layout orchestration, watch-driven open,
+// sessions.open navigation), the injectless-but-closeDetails details surface,
+// and the one-callback empty surface. Complements chat-apply.spec.tsx
+// (registration) and selection-survival.spec.ts (store axis).
 
 import { Context } from 'cordis'
 import { afterEach, describe, expect, it, vi } from 'vitest'
-import { act, cleanup, render } from '@testing-library/react'
-import { createElement } from 'react'
-import { createSnapshotStore, bindSnapshotSelector } from '@deepseek-ai/dsh-client-web-react'
+import { cleanup } from '@testing-library/react'
+import { createSnapshotStore } from '@deepseek-ai/dsh-client-web-react/src/store/index.ts'
 import { SlotsService, scopeOf } from '@deepseek-ai/dsh-client-runtime/client'
-import type { ConversationSnapshot, SessionId, SessionListState } from '@deepseek-ai/dsh-client-runtime/client'
+import type { SessionId, SessionListState } from '@deepseek-ai/dsh-client-runtime/client'
+import type { SlotRendererHost } from '@deepseek-ai/dsh-client-web-react'
 import { apply, inject } from '@deepseek-ai/dsh-client-ui-conversation/client'
-import type { ConversationService, ViewEntry } from '@deepseek-ai/dsh-client-ui-conversation/client'
-import type { SessionBinding } from '@deepseek-ai/dsh-client-ui-slots'
-import type {} from '@deepseek-ai/dsh-client-ui-layout/client'
+import type {
+  ConversationInjected, DetailsInjected, EmptyStateInjected,
+} from '@deepseek-ai/dsh-client-ui-conversation/client'
+import type { createChatStore } from '../src/client/stores.ts'
 
 afterEach(cleanup)
 
 const ROOT = 'root-1' as SessionId
 
+type ChatInstance = ReturnType<ReturnType<typeof createChatStore>['create']>
+type ChatActions = ChatInstance['actions']
+
 const SCOPE_TAG: symbol = (() => {
   const recorded: (string | symbol)[] = []
   const spy = new Proxy(new Context(), {
@@ -35,28 +41,18 @@ const SCOPE_TAG: symbol = (() => {
   return symbol
 })()
 
-function snapshotBase(): ConversationSnapshot {
-  return {
-    sessionId: ROOT, nodes: [], foldDegraded: false, partial: null, runningCalls: [],
-    pending: [], running: false, removed: false, openState: 'open', openError: null,
-    hasMore: false, loadingOlder: false, promptError: null, lastAgentError: null,
-  } as ConversationSnapshot
-}
-
 async function bench() {
   const ctx = new Context()
   const slotsFiber = ctx.plugin(SlotsService)
   await slotsFiber.await()
+  const slots = ctx.get('slots') as SlotsService
 
   const listStore = createSnapshotStore<SessionListState>({
     ids: [ROOT],
     byId: { [ROOT]: { id: ROOT, title: 'R', cwd: '/proj', running: false, updatedAt: 1 } },
-  })
-  const snap = snapshotBase()
+    current: ROOT,
+  } as SessionListState)
   const sessionFake = {
-    getSnapshot: () => snap,
-    subscribe: () => () => {},
-    useSelector: undefined as unknown,
     open: vi.fn(() => Promise.resolve()),
     loadOlder: vi.fn(() => Promise.resolve()),
     prompt: vi.fn<() => Promise<{ ok: boolean; value?: object; error?: { code: string; message: string } }>>(
@@ -64,7 +60,6 @@ async function bench() {
     cancel: vi.fn<() => Promise<{ ok: boolean; value?: object; error?: { code: string; message: string } }>>(
       () => Promise.resolve({ ok: true, value: { accepted: true } })),
   }
-  sessionFake.useSelector = bindSnapshotSelector(sessionFake as never)
   const scopes = new Map<SessionId, Context>()
   const mint = (id: SessionId): Context => {
     let scoped = scopes.get(id)
@@ -77,200 +72,143 @@ async function bench() {
   const sessionsFake = {
     list: listStore,
     manager: { get: () => sessionFake },
-    ancestry: (id: SessionId) => {
-      const s = listStore.getSnapshot().byId[id]
-      return s === undefined ? [] : [s]
-    },
     scope: (id: SessionId) => mint(id),
+    cell: () => undefined,
     create: vi.fn(() => Promise.resolve(ROOT)),
+    open: vi.fn(),
   }
   ctx.provide('sessions', sessionsFake)
-  const layoutFake = {
-    current: createSnapshotStore<{ sessionId?: SessionId; viewFor: Record<string, string> }>({ viewFor: {} }),
-    open: vi.fn(), openView: vi.fn(), openDetails: vi.fn(), closeDetails: vi.fn(),
-  }
+  const layoutFake = { openDetails: vi.fn(), closeDetails: vi.fn() }
   ctx.provide('layout', layoutFake)
   ctx.provide('i18n', { bind: () => (key: string) => key })
 
-  const slots = ctx.get('slots') as SlotsService
-  slots.define('conversation', { kind: 'single', scope: 'session' })
-  slots.define('details', { kind: 'single', scope: 'session' })
-  slots.define('conversation.empty', { kind: 'single', scope: 'root' })
+  // The AppFrame role: the three conversation-package slots must be declared
+  // by a live entry before apply can contribute into them (the stand-in
+  // consumes renderSlot to satisfy the declare-means-render check).
+  slots.register({
+    name: 'root',
+    children: {
+      'conversation': { kind: 'single', scope: 'session' },
+      'details': { kind: 'single', scope: 'session' },
+      'conversation.empty': { kind: 'single', scope: 'root' },
+    },
+  }, (_p: { renderSlot?: unknown }) => null)
 
   const fiber = ctx.plugin({ inject: [...inject], apply })
   await fiber.await()
 
-  const binding: SessionBinding = {
-    sessionId: ROOT as never,
-    session: { useSelector: sessionFake.useSelector } as never,
-    ctx: mint(ROOT) as never,
+  // Reach the render-side entry view (inject + store handle) the way the
+  // renderer does: through the host face.
+  let host: SlotRendererHost | undefined
+  slots.install({ renderRoot: (h) => { host = h; return null } })
+  slots.renderSlot('root', {})
+  const hostFace = host!
+  const entryOf = (key: 'conversation' | 'details' | 'conversation.empty') => hostFace.entriesOf(key)[0]!
+  /** Resolve store instance + call the inject the way the outlet would. */
+  const conversationSurface = (id: SessionId) => {
+    const entry = entryOf('conversation')
+    const instance = hostFace.storeOf(entry, id) as ChatInstance
+    const injected = (entry.inject as unknown as (sessionId: SessionId, actions: ChatActions) => ConversationInjected)(
+      id, instance.actions)
+    return { instance, injected }
   }
-  const entryOf = (key: 'conversation' | 'details' | 'conversation.empty') => {
-    const entries = slots.entries(key)
-    return entries[0]! as { options: { inject: (b: unknown) => Record<string, unknown> } }
-  }
-  return { ctx, slots, binding, sessionFake, sessionsFake, layoutFake, mint, entryOf }
+  return { ctx, slots, hostFace, entryOf, conversationSurface, sessionFake, sessionsFake, layoutFake, mint }
 }
 
 describe('conversation slot inject surface', () => {
-  it('assembles the full surface and pulls history through the watch signal', async () => {
+  it('assembles the thin surface, pulls history through the watch signal, navigates via sessions.open', async () => {
     const b = await bench()
-    const injected = b.entryOf('conversation').options.inject(b.binding) as {
-      useAncestry: () => readonly { id: SessionId }[]
-      views: { list(): readonly ViewEntry[]; version(): number; subscribe(fn: () => void): () => void }
-      useActiveView: () => string | undefined
-      composer: { useDraft: () => string; setDraft(t: string): void; send(m: string): void; stop(): void }
-      actions: { openView(v: string): void; open(id: SessionId): void }
-      renderView: (entry: ViewEntry) => unknown
-    }
+    const { injected } = b.conversationSurface(ROOT)
     expect(b.sessionFake.open).toHaveBeenCalledTimes(1)
     expect(injected.views.list().map(v => v.id)).toEqual(['chat'])
-    injected.actions.openView('chat')
-    expect(b.layoutFake.openView).toHaveBeenCalledWith(ROOT, 'chat')
-    injected.actions.open(ROOT)
-    expect(b.layoutFake.open).toHaveBeenCalledWith(ROOT)
+    injected.open(ROOT)
+    expect(b.sessionsFake.open).toHaveBeenCalledWith(ROOT)
+    injected.loadOlder()
+    expect(b.sessionFake.loadOlder).toHaveBeenCalledTimes(1)
   })
 
-  it('composer send trims, optimistically clears, and restores on failure; stop swallows rejection', async () => {
+  it('send trims, optimistically clears through actions, restores on failure without clobbering new typing', async () => {
     const b = await bench()
-    const injected = b.entryOf('conversation').options.inject(b.binding) as {
-      composer: { setDraft(t: string): void; send(m: 'queue'): void; stop(): void }
-    }
-    const scoped = b.mint(ROOT).get('conversation') as ConversationService
-    // Whitespace-only draft: no send.
-    scoped.drafts.set('   ')
-    injected.composer.send('queue')
+    const { instance, injected } = b.conversationSurface(ROOT)
+    // Whitespace-only: no send, and the (whitespace) draft is not cleared.
+    instance.actions.setDraft('   ')
+    injected.send('   ', 'queue')
     expect(b.sessionFake.prompt).not.toHaveBeenCalled()
+    expect(instance.store.getSnapshot().draft).toBe('   ')
     // Success: cleared and stays cleared.
-    injected.composer.setDraft('hello')
-    injected.composer.send('queue')
-    expect(scoped.drafts.getSnapshot()).toBe('')
+    instance.actions.setDraft('hello')
+    injected.send('hello', 'queue')
+    expect(instance.store.getSnapshot().draft).toBe('')
     await Promise.resolve()
     expect(b.sessionFake.prompt).toHaveBeenCalledWith([{ type: 'text', text: 'hello' }], 'queue')
     // Failure: restored (draft still empty when the rejection lands).
     b.sessionFake.prompt.mockResolvedValueOnce({ ok: false, error: { code: 'agent-busy', message: 'b' } })
-    injected.composer.setDraft('retry me')
-    injected.composer.send('queue')
+    instance.actions.setDraft('retry me')
+    injected.send('retry me', 'queue')
     await vi.waitFor(() => {
-      expect(scoped.drafts.getSnapshot()).toBe('retry me')
+      expect(instance.store.getSnapshot().draft).toBe('retry me')
     })
-    // Failure with new typing: no clobber.
+    // Failure landing after new typing: no clobber (restoreDraft fills empty only).
     b.sessionFake.prompt.mockResolvedValueOnce({ ok: false, error: { code: 'agent-busy', message: 'b' } })
-    injected.composer.send('queue')
-    injected.composer.setDraft('typed during flight')
+    injected.send('retry me', 'queue')
+    instance.actions.setDraft('typed during flight')
     await new Promise(r => setTimeout(r, 0))
-    expect(scoped.drafts.getSnapshot()).toBe('typed during flight')
+    expect(instance.store.getSnapshot().draft).toBe('typed during flight')
     // Stop failure is swallowed (promptError owns the surface).
     b.sessionFake.cancel.mockResolvedValueOnce({ ok: false, error: { code: 'internal', message: 'x' } })
-    injected.composer.stop()
+    injected.stop()
     await new Promise(r => setTimeout(r, 0))
+    expect(b.sessionFake.cancel).toHaveBeenCalledTimes(1)
   })
 
-  it('view actions forward: openDetails writes selection through the scoped service, loadOlder hits the session', async () => {
+  it('openDetails writes the selection through the store actions and opens the panel', async () => {
     const b = await bench()
-    const injected = b.entryOf('conversation').options.inject(b.binding) as {
-      // viewProps rides renderView's closure; reach the actions through a rendered entry.
-      renderView: (entry: ViewEntry) => React.ReactNode
-    }
-    let captured: { openDetails(t: { turnSeq: number; callId?: string }): void; loadOlder(): void } | undefined
-    const Probe = (p: { actions: typeof captured }) => {
-      captured = p.actions
-      return null
-    }
-    render(createElement('div', null, injected.renderView({
-      id: 'chat', label: 'Chat', component: Probe,
-    } as unknown as ViewEntry)))
-    captured!.openDetails({ turnSeq: 2, callId: 'c1' })
+    const { instance, injected } = b.conversationSurface(ROOT)
+    injected.openDetails({ turnSeq: 2, callId: 'c1' })
+    expect(instance.store.getSnapshot().selection).toEqual({ turnSeq: 2, callId: 'c1' })
     expect(b.layoutFake.openDetails).toHaveBeenCalledTimes(1)
-    const scoped = b.mint(ROOT).get('conversation') as import('@deepseek-ai/dsh-client-ui-conversation/client').ConversationService
-    expect(scoped.selection.getSnapshot()).toEqual({ turnSeq: 2, callId: 'c1' })
-    captured!.loadOlder()
-    expect(b.sessionFake.loadOlder).toHaveBeenCalledTimes(1)
   })
 
-  it('renderView mounts chrome header/footer around the view body', async () => {
+  it('views read face forwards to the service registry (subscribe/version)', async () => {
     const b = await bench()
-    const injected = b.entryOf('conversation').options.inject(b.binding) as {
-      renderView: (entry: ViewEntry) => React.ReactNode
-    }
-    const entry = {
-      id: 'chat', label: 'Chat',
-      component: () => createElement('div', { 'data-testid': 'body' }),
-      chrome: {
-        header: () => createElement('div', { 'data-testid': 'hd' }),
-        footer: () => createElement('div', { 'data-testid': 'ft' }),
-      },
-    } as unknown as ViewEntry
-    const view = render(createElement('div', null, injected.renderView(entry)))
-    expect(view.getByTestId('hd')).toBeTruthy()
-    expect(view.getByTestId('body')).toBeTruthy()
-    expect(view.getByTestId('ft')).toBeTruthy()
-    // Ancestry and draft/active-view hooks execute inside a component tree.
-    const HookProbe = () => {
-      const injected2 = b.entryOf('conversation').options.inject(b.binding) as {
-        useAncestry: () => readonly { title: string }[]
-        useActiveView: () => string | undefined
-        composer: { useDraft: () => string }
-      }
-      const chain = injected2.useAncestry()
-      const active = injected2.useActiveView()
-      const draft = injected2.composer.useDraft()
-      return createElement('i', { 'data-testid': 'probe' }, `${chain.length}|${active ?? 'none'}|${draft}`)
-    }
-    const probe = render(createElement(HookProbe))
-    // Draft content carries over from the composer case (per-scope store is
-    // process-resident); the probe asserts hook wiring, not draft value.
-    expect(probe.getByTestId('probe').textContent).toMatch(/^1\|none\|/)
-    // A list-store update while mounted drives the ancestry selector's
-    // shallowEqual arm (same derived chain → short-circuit, no re-render churn).
-    await act(async () => {
-      b.sessionsFake.list.update((d: { byId: Record<string, { updatedAt: number }> }) => {
-        d.byId[ROOT]!.updatedAt = 2
-      })
-    })
-    expect(probe.getByTestId('probe').textContent).toMatch(/^1\|none\|/)
-    // The views read-face triple forwards to the service registry.
-    const injected3 = b.entryOf('conversation').options.inject(b.binding) as {
-      views: { list(): readonly { id: string }[]; subscribe(fn: () => void): () => void; version(): number }
-    }
-    expect(injected3.views.list().map(v => v.id)).toEqual(['chat'])
-    const beforeVersion = injected3.views.version()
+    const { injected } = b.conversationSurface(ROOT)
+    const before = injected.views.version()
     const listener = vi.fn()
-    const unsub = injected3.views.subscribe(listener)
-    const conversation = b.ctx.get('conversation') as import('@deepseek-ai/dsh-client-ui-conversation/client').ConversationService
-    const offExtra = conversation.registerView({ id: 'chat2', label: 'X', component: () => null } as never)
+    const unsub = injected.views.subscribe(listener)
+    const conversation = b.ctx.get('conversation') as
+      import('@deepseek-ai/dsh-client-ui-conversation/client').ConversationService
+    const off = conversation.registerView({ id: 'chat2', label: 'X', component: () => null } as never)
     expect(listener).toHaveBeenCalled()
-    expect(injected3.views.version()).toBeGreaterThan(beforeVersion)
-    offExtra()
+    expect(injected.views.version()).toBeGreaterThan(before)
+    expect(injected.views.list().map(v => v.id)).toEqual(['chat', 'chat2'])
+    off()
     unsub()
   })
 })
 
 describe('details and empty inject surfaces', () => {
-  it('details surface wires selection and closeDetails', async () => {
+  it('details injects the one layout callback; selection rides the shared store instead', async () => {
     const b = await bench()
-    const injected = b.entryOf('details').options.inject(b.binding) as {
-      useSelection: unknown
-      actions: { closeDetails(): void }
-    }
-    expect(injected.useSelection).toBeTypeOf('function')
-    injected.actions.closeDetails()
+    const entry = b.entryOf('details')
+    const injected = (entry.inject as unknown as () => DetailsInjected)()
+    expect(Object.keys(injected)).toEqual(['closeDetails'])
+    injected.closeDetails()
     expect(b.layoutFake.closeDetails).toHaveBeenCalledTimes(1)
+    // The shared handle: details resolves the SAME instance conversation writes.
+    const conv = b.hostFace.storeOf(b.entryOf('conversation'), ROOT)
+    const details = b.hostFace.storeOf(entry, ROOT)
+    expect(details).toBe(conv)
   })
 
-  it('empty surface derives the deduped cwd set with a per-state cache and starts sessions', async () => {
+  it('empty injects the startSession chain only (no store, cwds derive in-component)', async () => {
     const b = await bench()
-    const injected = b.entryOf('conversation.empty').options.inject({ ctx: b.ctx }) as {
-      useCwds: (sel: (s: readonly string[]) => unknown, eq?: unknown) => unknown
-      actions: { startSession(opts: { text: string; mode: 'queue' }): Promise<void> }
-    }
-    const CwdsProbe = () => {
-      const cwds = injected.useCwds(s => s) as readonly string[]
-      return createElement('i', { 'data-testid': 'cwds' }, cwds.join(','))
-    }
-    const view = render(createElement(CwdsProbe))
-    expect(view.getByTestId('cwds').textContent).toBe('/proj')
-    await injected.actions.startSession({ text: 'go', mode: 'queue' })
+    const entry = b.entryOf('conversation.empty')
+    expect(entry.store).toBeUndefined()
+    const injected = (entry.inject as unknown as () => EmptyStateInjected)()
+    expect(Object.keys(injected)).toEqual(['startSession'])
+    await injected.startSession({ text: 'go', mode: 'queue' })
     expect(b.sessionsFake.create).toHaveBeenCalled()
+    expect(b.sessionsFake.open).toHaveBeenCalledWith(ROOT)
+    expect(b.sessionFake.prompt).toHaveBeenCalledWith([{ type: 'text', text: 'go' }], 'queue')
   })
 })

packages/client/ui-conversation/tests/chat-apply.spec.tsx

@@ -1,19 +1,18 @@
 // @vitest-environment jsdom
 // apply wiring: services provided, chat view + footer chrome registered, the
-// three slot registrations land against ui-layout-shaped specs, and the bash
-// samples resolve differentially (sub-session default scope). Full-chain
-// rendering belongs to the shell e2e; this spec stops at the assembly surface.
+// three slot registrations land against a root entry's children declarations
+// (the AppFrame role), the shared store handle rides both session slots, and
+// the bash samples resolve differentially (sub-session default scope).
+// Full-chain rendering belongs to the shell e2e; this spec stops at the
+// assembly surface.
 
 import { Context } from 'cordis'
 import { describe, expect, it, vi } from 'vitest'
-import { createSnapshotStore } from '@deepseek-ai/dsh-client-web-react'
+import { createSnapshotStore } from '@deepseek-ai/dsh-client-web-react/src/store/index.ts'
 import { SlotsService } from '@deepseek-ai/dsh-client-runtime/client'
 import type { SessionId, SessionListState } from '@deepseek-ai/dsh-client-runtime/client'
 import { apply, inject, ToolViewRegistry } from '@deepseek-ai/dsh-client-ui-conversation/client'
 import type { ConversationService } from '@deepseek-ai/dsh-client-ui-conversation/client'
-// Type-only: pulls ui-layout's SlotMap declaration merge into this spec's
-// program so the slot keys below typecheck in the client lane.
-import type {} from '@deepseek-ai/dsh-client-ui-layout/client'
 
 const ROOT = 'root-1' as SessionId
 const CHILD = 'child-1' as SessionId
@@ -29,31 +28,42 @@ async function bench() {
       [ROOT]: { id: ROOT, title: 'R', running: false, updatedAt: 1 },
       [CHILD]: { id: CHILD, title: 'C', parentId: ROOT, running: false, updatedAt: 2 },
     },
-  })
+    current: undefined,
+  } as SessionListState)
   const sessionsFake = {
     list: listStore,
     manager: { get: vi.fn() },
-    ancestry: () => [],
     scope: () => undefined,
+    cell: () => undefined,
     create: vi.fn(),
+    open: vi.fn(),
   }
   ctx.provide('sessions', sessionsFake)
-  ctx.provide('layout', {
-    current: createSnapshotStore<{ viewFor: Record<string, string> }>({ viewFor: {} }),
-    open: vi.fn(), openView: vi.fn(), openDetails: vi.fn(), closeDetails: vi.fn(),
-  })
+  ctx.provide('layout', { openDetails: vi.fn(), closeDetails: vi.fn() })
   ctx.provide('i18n', { bind: () => (key: string) => key })
 
-  // Specs owned by ui-layout in production; declared here so registrations land.
+  // Declared by ui-layout's root entry in production; a stand-in root
+  // occupant declares them here so the contributions land (it consumes
+  // renderSlot to satisfy the declare-means-render check).
   const slots = ctx.get('slots') as SlotsService
-  slots.define('conversation', { kind: 'single', scope: 'session' })
-  slots.define('details', { kind: 'single', scope: 'session' })
-  slots.define('conversation.empty', { kind: 'single', scope: 'root' })
+  slots.register({
+    name: 'root',
+    children: {
+      'conversation': { kind: 'single', scope: 'session' },
+      'details': { kind: 'single', scope: 'session' },
+      'conversation.empty': { kind: 'single', scope: 'root' },
+    },
+  }, (_p: { renderSlot?: unknown }) => null)
 
   const fiber = ctx.plugin({ inject: [...inject], apply })
   return { ctx, fiber, slots }
 }
 
+/** First stored entry for a key (inject/store live directly on StoredEntry). */
+function renderEntryOf(slots: SlotsService, key: 'conversation' | 'details' | 'conversation.empty') {
+  return slots.entries(key)[0] as undefined | { inject?: unknown; store?: unknown }
+}
+
 describe('apply wiring', () => {
   it('provides conversation and toolviews services', async () => {
     const b = await bench()
@@ -71,14 +81,20 @@ describe('apply wiring', () => {
     expect(views[0]?.chrome?.footer).toBeDefined()
   })
 
-  it('occupies conversation/details/conversation.empty with inject factories', async () => {
+  it('occupies the three slots; session pair shares one store handle, empty declares none', async () => {
     const b = await bench()
     await b.fiber.await()
-    for (const key of ['conversation', 'details', 'conversation.empty'] as const) {
-      const entries = b.slots.entries(key)
-      expect(entries, key).toHaveLength(1)
-      expect((entries[0]!.options as { inject?: unknown }).inject, key).toBeTypeOf('function')
-    }
+    const conversation = renderEntryOf(b.slots, 'conversation')
+    const details = renderEntryOf(b.slots, 'details')
+    const empty = renderEntryOf(b.slots, 'conversation.empty')
+    expect(conversation?.inject).toBeTypeOf('function')
+    expect(details?.inject).toBeTypeOf('function')
+    expect(empty?.inject).toBeTypeOf('function')
+    // The shared handle: one apply-built store value on BOTH session entries.
+    expect(conversation?.store).toBeDefined()
+    expect(details?.store).toBe(conversation?.store)
+    // The empty slot is storeless (local state + useSessions derivation).
+    expect(empty?.store).toBeUndefined()
   })
 
   it('bash samples resolve differentially: scoped row for sub-sessions, global for roots', async () => {

packages/client/ui-conversation/tests/chat-branch-tails.spec.tsx

@@ -9,8 +9,8 @@ import { cleanup, render } from '@testing-library/react'
 import { act } from '@testing-library/react'
 import type { SessionId, ToolResultNode } from '@deepseek-ai/dsh-client-runtime/client'
 import type { RpcId } from '@deepseek-ai/dsh-client-connection/client'
-import { bindSnapshotSelector, createSessionProvider } from '@deepseek-ai/dsh-client-web-react'
-import type { SessionBinding as ReactSessionBinding, UseSession } from '@deepseek-ai/dsh-client-web-react'
+import { bindSnapshotSelector } from '@deepseek-ai/dsh-client-web-react'
+import type { UseSession } from '@deepseek-ai/dsh-client-web-react'
 import { ToolViewRegistry } from '@deepseek-ai/dsh-client-ui-conversation/client'
 import type { ToolViewProps, Translate } from '@deepseek-ai/dsh-client-ui-conversation/client'
 import { MessageItem } from '../src/client/chat/MessageItem.tsx'
@@ -92,34 +92,33 @@ describe('small branch tails', () => {
 })
 
 describe('ToolViewOutlet dispatch', () => {
-  it('caches the inject factory per (registration x binding) and merges its props', () => {
+  it('caches the inject factory per (registration x session) and merges its props', () => {
     const registry = new ToolViewRegistry()
-    const inject = vi.fn(() => ({ extra: 'injected' }))
+    const inject = vi.fn((sessionId: SessionId) => ({ extra: `injected:${sessionId}` }))
     registry.register('bash',
       (p: ToolViewProps & { extra: string }) => <div data-testid="row">{p.extra}</div>,
       { inject })
-    // InjectedRow reads the session binding from context: mount through the
-    // real SessionProvider so the (factory x binding) cache path executes.
-    const binding: ReactSessionBinding = {
-      sessionId: SID,
-      session: { useSelector: (() => { throw new Error('unused') }) as never },
-      ctx: {},
-    }
-    const Provider = createSessionProvider({
-      useCurrent: () => SID,
-      resolveBinding: () => binding,
-      renderBody: () => (
-        <ToolViewOutlet registry={registry} sessionId={SID} toolName="bash" viewProps={viewProps()} />
-      ),
-    })
-    const view = render(<Provider />)
-    expect(view.getByTestId('row').textContent).toBe('injected')
+    // Pure props machinery: the outlet feeds its own sessionId to the
+    // factory — no provider/context needed (terminal channel form).
+    const view = render(
+      <ToolViewOutlet registry={registry} sessionId={SID} toolName="bash" viewProps={viewProps()} />,
+    )
+    expect(view.getByTestId('row').textContent).toBe(`injected:${SID}`)
     expect(inject).toHaveBeenCalledTimes(1)
-    // Remount against the SAME binding: cache hit, factory not re-run.
+    // Remount under the SAME session: cache hit, factory not re-run.
     view.unmount()
-    const second = render(<Provider />)
-    expect(second.getByTestId('row').textContent).toBe('injected')
+    const second = render(
+      <ToolViewOutlet registry={registry} sessionId={SID} toolName="bash" viewProps={viewProps()} />,
+    )
+    expect(second.getByTestId('row').textContent).toBe(`injected:${SID}`)
     expect(inject).toHaveBeenCalledTimes(1)
+    // A different session is a distinct cache key: factory runs once more.
+    second.unmount()
+    const other = render(
+      <ToolViewOutlet registry={registry} sessionId={'s2' as SessionId} toolName="bash" viewProps={viewProps()} />,
+    )
+    expect(other.getByTestId('row').textContent).toBe('injected:s2')
+    expect(inject).toHaveBeenCalledTimes(2)
   })
 
   it('a crashing custom row falls back to GenericToolCard and retries on re-registration', () => {

packages/client/ui-conversation/tests/chat-stats-bash-sample.spec.tsx

@@ -154,6 +154,7 @@ describe('bash toolview samples', () => {
     const scope = childSessionScope({
       getSnapshot: () => ({
         ids: [root, child],
+        current: undefined,
         byId: {
           [root]: { id: root, title: 'r', running: false, updatedAt: 0 },
           [child]: { id: child, title: 'c', parentId: root, running: false, updatedAt: 0 },

packages/client/ui-conversation/tests/chat-store.spec.ts

@@ -0,0 +1,94 @@
+// @vitest-environment jsdom
+/**
+ * createChatStore unit account (slot terminal design §4): the declared
+ * actions write set, persist round-trip through the scope-suffixed key, and
+ * factory purity (every create() is an independent instance; the factory
+ * itself holds no singleton state).
+ */
+import { beforeEach, describe, expect, it } from 'vitest'
+import { createChatStore } from '../src/client/stores.ts'
+
+const KEY = 'dsh.conversation.chat'
+
+beforeEach(() => {
+  localStorage.clear()
+})
+
+describe('createChatStore', () => {
+  it('init shape: empty selection/draft/view', () => {
+    const store = createChatStore().create()
+    expect(store.store.getSnapshot()).toEqual({ selection: null, draft: '', view: null })
+  })
+
+  it('actions cover the declared write set', () => {
+    const store = createChatStore().create()
+
+    store.actions.select({ turnSeq: 3, callId: 'c1', toolName: 'bash' })
+    expect(store.store.getSnapshot().selection).toEqual({ turnSeq: 3, callId: 'c1', toolName: 'bash' })
+    store.actions.select(null)
+    expect(store.store.getSnapshot().selection).toBeNull()
+
+    store.actions.setDraft('hello')
+    expect(store.store.getSnapshot().draft).toBe('hello')
+    store.actions.clearDraft()
+    expect(store.store.getSnapshot().draft).toBe('')
+
+    store.actions.setView('chat')
+    expect(store.store.getSnapshot().view).toBe('chat')
+  })
+
+  it('restoreDraft only fills an empty draft (optimistic-send rollback contract)', () => {
+    const store = createChatStore().create()
+    // Rollback path: draft was cleared by send, nothing typed since.
+    store.actions.restoreDraft('failed text')
+    expect(store.store.getSnapshot().draft).toBe('failed text')
+    // The user typed something new before the failure landed: keep theirs.
+    store.actions.setDraft('newer input')
+    store.actions.restoreDraft('stale text')
+    expect(store.store.getSnapshot().draft).toBe('newer input')
+  })
+
+  it('persists per scope key and rehydrates a fresh instance', () => {
+    const handle = createChatStore()
+    const s1 = handle.create('sess-1')
+    s1.actions.setDraft('draft for one')
+    s1.actions.select({ turnSeq: 1 })
+
+    // Scope-suffixed key: each session persists separately.
+    expect(localStorage.getItem(`${KEY}.sess-1`)).not.toBeNull()
+    expect(localStorage.getItem(`${KEY}.sess-2`)).toBeNull()
+
+    // A rebuilt instance under the same scope key rehydrates the state.
+    const again = createChatStore().create('sess-1')
+    expect(again.store.getSnapshot().draft).toBe('draft for one')
+    expect(again.store.getSnapshot().selection).toEqual({ turnSeq: 1 })
+
+    // A sibling scope starts clean.
+    const other = createChatStore().create('sess-2')
+    expect(other.store.getSnapshot().draft).toBe('')
+  })
+
+  it('clearPersisted removes the scope entry (session-death cleanup hook)', () => {
+    const store = createChatStore().create('sess-9')
+    store.actions.setDraft('doomed')
+    expect(localStorage.getItem(`${KEY}.sess-9`)).not.toBeNull()
+    store.clearPersisted()
+    expect(localStorage.getItem(`${KEY}.sess-9`)).toBeNull()
+  })
+
+  it('every create() is an independent instance; the factory holds no singleton', () => {
+    const handle = createChatStore()
+    const a = handle.create()
+    const b = handle.create()
+    a.actions.setDraft('only in a')
+    expect(b.store.getSnapshot().draft).toBe('')
+    // Two factory calls likewise share no LIVE state (identity is per handle
+    // VALUE, not per module — the sharing contract lives in the framework's
+    // handle x scope-key resolution, not in module state). Persistence is the
+    // one sanctioned cross-instance channel: clear it so this assertion sees
+    // memory identity, not rehydration (covered by the persist case above).
+    localStorage.clear()
+    const c = createChatStore().create()
+    expect(c.store.getSnapshot().draft).toBe('')
+  })
+})

packages/client/ui-conversation/tests/chat-view.spec.tsx

@@ -3,7 +3,7 @@
 // toolview dispatch and selection handoff — driven through a scripted
 // ObservableSnapshot fake, no wire.
 
-import { afterEach, describe, expect, it, vi } from 'vitest'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
 import { Profiler } from 'react'
 import { act, cleanup, fireEvent, render } from '@testing-library/react'
 import type {
@@ -13,10 +13,16 @@ import { bindSnapshotSelector } from '@deepseek-ai/dsh-client-web-react'
 import type { UseSession } from '@deepseek-ai/dsh-client-web-react'
 import type { ConvViewProps, SelectionTarget } from '@deepseek-ai/dsh-client-ui-conversation/client'
 import { ToolViewRegistry } from '@deepseek-ai/dsh-client-ui-conversation/client'
+import { createChatStore } from '../src/client/stores.ts'
 import { createChatView } from '../src/client/chat/ChatView.tsx'
 import { deriveChatFlow, flowKeys } from '../src/client/chat/chat-flow.ts'
 
 afterEach(cleanup)
+// Keyless create() persists under the bare declared key; clear between cases
+// so one harness's selection cannot rehydrate into the next.
+beforeEach(() => {
+  localStorage.clear()
+})
 
 const SID = 's1' as SessionId
 
@@ -68,33 +74,17 @@ function makeHarness(init?: Partial<ConversationSnapshot>) {
   const ChatView = createChatView({ toolviews: registry, t: (k) => k })
   const openDetails = vi.fn<(t: SelectionTarget) => void>()
   const loadOlder = vi.fn()
-  const selection = makeSelection()
+  // Selection rides the REAL chat store (same construction path as
+  // production; the view reads it through the ConvViewProps useStore share).
+  const chat = createChatStore().create()
   const props: ConvViewProps = {
     sessionId: SID,
     useSession: bindSnapshotSelector(source) as unknown as UseSession,
-    useSelection: bindSnapshotSelector(selection.source),
+    useStore: chat.useSelector,
     actions: { openDetails, loadOlder },
-    slots: { renderSlot: () => null } as never,
-  }
-  return { set, registry, ChatView, props, openDetails, loadOlder, setSelection: selection.set }
-}
-
-function makeSelection() {
-  let sel: SelectionTarget | null = null
-  const subs = new Set<() => void>()
-  return {
-    set(next: SelectionTarget | null) {
-      sel = next
-      for (const fn of [...subs]) fn()
-    },
-    source: {
-      getSnapshot: () => sel,
-      subscribe: (fn: () => void) => {
-        subs.add(fn)
-        return () => subs.delete(fn)
-      },
-    },
   }
+  const setSelection = (next: SelectionTarget | null): void => { chat.actions.select(next) }
+  return { set, registry, ChatView, props, openDetails, loadOlder, setSelection }
 }
 
 describe('chat-flow derivation', () => {

packages/client/ui-conversation/tests/gate-branch-tails.spec.tsx

@@ -1,23 +1,24 @@
 // @vitest-environment jsdom
-// Final branch tails for the coverage gate, post slot-phase-2: apply's need()
-// throw + cwd cache hit/empty-cwd skip, AssistantMarkdown non-final reasoning,
-// StatsLine usage-less node, ChatView tool-group selected passthrough +
-// running-empty guard, DetailsPanel titleless selection, registry disposer
-// after a foreign removal emptied the list.
+// Final branch tails for the coverage gate, terminal slot form: apply's
+// need() throw, AssistantMarkdown non-final reasoning, StatsLine usage-less
+// node, DetailsPanel titleless selection, registry disposer after a foreign
+// removal emptied the list. (The old cwd WeakMap-cache account retired with
+// the mechanism — derivation lives in EmptyState now, covered by the
+// skeleton specs.)
 
 import { afterEach, describe, expect, it, vi } from 'vitest'
 import { cleanup, render } from '@testing-library/react'
 import { Context } from 'cordis'
-import { createSnapshotStore, bindSnapshotSelector } from '@deepseek-ai/dsh-client-web-react'
+import { bindSnapshotSelector } from '@deepseek-ai/dsh-client-web-react'
+import { createSnapshotStore } from '@deepseek-ai/dsh-client-web-react/src/store/index.ts'
 import type { UseSession } from '@deepseek-ai/dsh-client-web-react'
-import { SlotsService } from '@deepseek-ai/dsh-client-runtime/client'
 import type { ConversationSnapshot, SessionId, SessionListState } from '@deepseek-ai/dsh-client-runtime/client'
 import { apply, inject, ToolViewRegistry } from '@deepseek-ai/dsh-client-ui-conversation/client'
 import type { SelectionTarget } from '@deepseek-ai/dsh-client-ui-conversation/client'
+import { createChatStore } from '../src/client/stores.ts'
 import { AssistantMarkdown } from '../src/client/chat/AssistantMarkdown.tsx'
 import { StatsLine } from '../src/client/chat/StatsLine.tsx'
 import { DetailsPanel } from '../src/client/skeleton/DetailsPanel.tsx'
-import type {} from '@deepseek-ai/dsh-client-ui-layout/client'
 
 afterEach(cleanup)
 
@@ -42,40 +43,6 @@ describe('apply need() and cwd cache', () => {
     expect(() => { (apply as (c: Context) => void)(ctx) }).toThrow(/sessions service unavailable/)
   })
 
-  it('cwd derivation caches per list state and skips empty cwd values', async () => {
-    const ctx = new Context()
-    const slotsFiber = ctx.plugin(SlotsService)
-    await slotsFiber.await()
-    const listStore = createSnapshotStore<SessionListState>({
-      ids: [SID, 'x2' as SessionId, 'x3' as SessionId],
-      byId: {
-        [SID]: { id: SID, title: 'a', cwd: '/proj', running: false, updatedAt: 1 },
-        ['x2' as SessionId]: { id: 'x2' as SessionId, title: 'b', cwd: '', running: false, updatedAt: 1 },
-        ['x3' as SessionId]: { id: 'x3' as SessionId, title: 'c', running: false, updatedAt: 1 },
-      },
-    })
-    ctx.provide('sessions', { list: listStore, manager: { get: vi.fn() }, ancestry: () => [], scope: () => undefined, create: vi.fn() })
-    ctx.provide('layout', { current: createSnapshotStore<{ viewFor: Record<string, string> }>({ viewFor: {} }), open: vi.fn(), openView: vi.fn(), openDetails: vi.fn(), closeDetails: vi.fn() })
-    ctx.provide('i18n', { bind: () => (k: string) => k })
-    const slots = ctx.get('slots') as SlotsService
-    slots.define('conversation', { kind: 'single', scope: 'session' })
-    slots.define('details', { kind: 'single', scope: 'session' })
-    slots.define('conversation.empty', { kind: 'single', scope: 'root' })
-    const fiber = ctx.plugin({ inject: [...inject], apply })
-    await fiber.await()
-    const entry = slots.entries('conversation.empty')[0]! as unknown as {
-      options: { inject: (b: unknown) => { useCwds: (sel: (s: readonly string[]) => readonly string[]) => readonly string[] } }
-    }
-    const injected = entry.options.inject({ ctx })
-    const Probe = () => {
-      const cwds = injected.useCwds(s => s)
-      const again = injected.useCwds(s => s)
-      // Cache hit: same state object yields the same derived array reference.
-      return <i data-testid="cwds">{`${cwds.join(',')}|${String(cwds === again)}`}</i>
-    }
-    const view = render(<Probe />)
-    expect(view.getByTestId('cwds').textContent).toBe('/proj|true')
-  })
 })
 
 describe('render branch tails', () => {
@@ -101,7 +68,7 @@ describe('render branch tails', () => {
     }
     const source = { getSnapshot: () => snap, subscribe: () => () => {} }
     const view = render(
-      <StatsLine sessionId={SID} useSession={bindSnapshotSelector(source) as unknown as UseSession} />,
+      <StatsLine sessionId={SID} useSession={bindSnapshotSelector(source) as unknown as UseSession<ConversationSnapshot>} />,
     )
     expect(view.getByText('cache hit 0% · 15 tokens · 2 turns · 3 steps')).toBeTruthy()
   })
@@ -114,13 +81,20 @@ describe('render branch tails', () => {
   })
 
   it('DetailsPanel title falls to 详情 when the selection has no toolName and no material', () => {
-    const SEL: SelectionTarget = { turnSeq: 1, callId: 'ghost' }
+    localStorage.clear()
+    const snap = snapshotBase()
+    const chat = createChatStore().create()
+    chat.actions.select({ turnSeq: 1, callId: 'ghost' } satisfies SelectionTarget)
+    const emptyList = createSnapshotStore<SessionListState>(
+      { ids: [], byId: {}, current: undefined } as SessionListState)
     const view = render(
       <DetailsPanel
         sessionId={SID}
-        useSession={bindSnapshotSelector({ getSnapshot: () => snapshotBase(), subscribe: () => () => {} }) as unknown as UseSession}
-        useSelection={bindSnapshotSelector({ getSnapshot: () => SEL, subscribe: () => () => {} })}
-        actions={{ closeDetails: vi.fn() }}
+        useSession={bindSnapshotSelector({ getSnapshot: () => snap, subscribe: () => () => {} }) as unknown as UseSession<ConversationSnapshot>}
+        useSessions={emptyList.useSelector}
+        useStore={chat.useSelector}
+        actions={chat.actions}
+        closeDetails={vi.fn()}
       />,
     )
     expect(view.getByText('详情')).toBeTruthy()

packages/client/ui-conversation/tests/selection-survival.spec.ts

@@ -1,16 +1,19 @@
 // @vitest-environment jsdom
 /**
- * M1a regression pin: the per-scope selection must survive list refreshes.
- * Drives the REAL SessionsService + ConversationService chain over the
- * programmable wire fake — a late list refresh that upgrades the display
- * title (bare id → cwd basename) and a reconnect-driven refreshList+resync
- * must neither recreate the session scope nor clear the selection account.
+ * Selection survival across the store seat (terminal design §4): the chat
+ * store now carries what the per-scope selection account used to — this pins
+ * the same behavior contract in the new mechanism. Drives the REAL
+ * SlotsService store axis with the shared createChatStore handle (the exact
+ * apply.ts shape: one handle, two session-slot registrations): same session's
+ * two slots resolve one instance (conversation writes, details reads);
+ * sessions are isolated; a session's death buries its instance AND its
+ * persisted draft; a list refresh does not touch instance identity.
  */
 import { Context } from 'cordis'
-import { describe, expect, it } from 'vitest'
-import type { SessionId } from '@deepseek-ai/dsh-client-connection/client'
-import { SessionsService } from '@deepseek-ai/dsh-client-runtime/client'
-import { ConversationService } from '@deepseek-ai/dsh-client-ui-conversation/client'
+import { beforeEach, describe, expect, it } from 'vitest'
+import { SessionsService, SlotsService } from '@deepseek-ai/dsh-client-runtime/client'
+import type { SessionId } from '@deepseek-ai/dsh-client-runtime/client'
+import { createChatStore } from '../src/client/stores.ts'
 
 // The runtime package's programmable fake lives in its tests; import through
 // the src path (same pattern the runtime specs use — test-support material).
@@ -22,15 +25,31 @@ interface Bench {
   ctx: Context
   api: FakeApiClient
   sessions: SessionsService
-  conversation: ConversationService
+  slots: SlotsService
+  chat: ReturnType<typeof createChatStore>
 }
 
 function bench(): Bench {
   const ctx = new Context()
   const api = new FakeApiClient()
   const sessions = new SessionsService(ctx, api)
-  const conversation = new ConversationService(ctx)
-  return { ctx, api, sessions, conversation }
+  // Service self-registers as ctx 'slots' (cordis Service constructor).
+  const slots = new SlotsService(ctx)
+  const chat = createChatStore()
+  // The apply.ts shape: one shared handle across both session-slot
+  // registrations. 'conversation'/'details' must first exist in the ledger —
+  // register a root occupant declaring them (the AppFrame role; the stand-in
+  // consumes renderSlot to satisfy the declare-means-render check).
+  slots.register({
+    name: 'root',
+    children: {
+      'conversation': { kind: 'single', scope: 'session' },
+      'details': { kind: 'single', scope: 'session' },
+    },
+  }, (_p: { renderSlot?: unknown }) => null)
+  slots.register({ name: 'conversation', store: chat }, () => null)
+  slots.register({ name: 'details', store: chat }, () => null)
+  return { ctx, api, sessions, slots, chat }
 }
 
 async function flush(): Promise<void> {
@@ -48,8 +67,63 @@ function feed(b: Bench, rows: { id: string; cwd?: string; running?: boolean }[])
   }) as never)
 }
 
-describe('selection survives list refreshes (M1a)', () => {
-  it('create → select → title-upgrading refresh keeps scope, binding, store and value', async () => {
+/** Resolve the store instance the renderer would hand a slot's component for a session. */
+function storeFor(b: Bench, slot: 'conversation' | 'details', sessionId: SessionId) {
+  const host = renderHost(b)
+  const entry = host.entriesOf(slot)[0]!
+  return host.storeOf(entry, sessionId)! as ReturnType<ReturnType<typeof createChatStore>['create']>
+}
+
+/** The host face is only built at renderSlot time; install a stub renderer once to reach it. */
+function renderHost(b: Bench): import('@deepseek-ai/dsh-client-web-react').SlotRendererHost {
+  const captured = (b as unknown as { _host?: import('@deepseek-ai/dsh-client-web-react').SlotRendererHost })
+  if (captured._host === undefined) {
+    b.slots.install({
+      renderRoot: (host) => {
+        captured._host = host
+        return null
+      },
+    })
+    b.slots.renderSlot('root', {})
+  }
+  return captured._host!
+}
+
+beforeEach(() => {
+  localStorage.clear()
+})
+
+describe('selection survives on the store seat', () => {
+  it('one session, two slots: conversation writes, details reads the SAME instance', async () => {
+    const b = bench()
+    feed(b, [{ id: 's1' }])
+    await b.sessions.manager.refreshList()
+    await flush()
+
+    const conv = storeFor(b, 'conversation', sid('s1'))
+    const details = storeFor(b, 'details', sid('s1'))
+    conv.actions.select({ turnSeq: 3, callId: 'c1' })
+    expect(details.store.getSnapshot().selection).toEqual({ turnSeq: 3, callId: 'c1' })
+    // Identity, not just value: the shared handle resolves one instance per scope key.
+    expect(details).toBe(conv)
+  })
+
+  it('sessions are isolated: s2 selection never bleeds into s1', async () => {
+    const b = bench()
+    feed(b, [{ id: 's1' }, { id: 's2' }])
+    await b.sessions.manager.refreshList()
+    await flush()
+
+    const one = storeFor(b, 'conversation', sid('s1'))
+    const two = storeFor(b, 'conversation', sid('s2'))
+    expect(two).not.toBe(one)
+    one.actions.select({ turnSeq: 1, callId: 'a' })
+    two.actions.select({ turnSeq: 9, callId: 'z' })
+    expect(one.store.getSnapshot().selection).toEqual({ turnSeq: 1, callId: 'a' })
+    expect(two.store.getSnapshot().selection).toEqual({ turnSeq: 9, callId: 'z' })
+  })
+
+  it('a title-upgrading list refresh keeps instance identity and the selection value', async () => {
     const b = bench()
     // First-send shape: client-side create inserts the row without cwd (title = bare id).
     b.api.onCreate = () => Promise.resolve(ok({ sessionId: sid('s1') }))
@@ -57,11 +131,9 @@ describe('selection survives list refreshes (M1a)', () => {
     await flush()
     expect(b.sessions.list.getSnapshot().byId[id]?.title).toBe('s1')
 
-    const binding = b.sessions.binding(id)
-    expect(binding).toBeDefined()
-    const scoped = b.sessions.scope(id)!
-    const store = (scoped.get('conversation') as ConversationService).selection
-    store.set({ turnSeq: 3, callId: 'c1' })
+    const store = storeFor(b, 'conversation', id)
+    store.actions.select({ turnSeq: 3, callId: 'c1' })
+    store.actions.setDraft('half-typed')
 
     // The late list refresh lands (host knows the cwd → formal title).
     feed(b, [{ id: 's1', cwd: '/w/proj-a' }])
@@ -69,53 +141,40 @@ describe('selection survives list refreshes (M1a)', () => {
     await flush()
     expect(b.sessions.list.getSnapshot().byId[id]?.title).toBe('proj-a')
 
-    // Scope, binding and the selection account must all be identity-stable.
-    expect(b.sessions.scope(id)).toBe(scoped)
-    expect(b.sessions.binding(id)).toBe(binding)
-    const after = (b.sessions.scope(id)!.get('conversation') as ConversationService).selection
+    const after = storeFor(b, 'conversation', id)
     expect(after).toBe(store)
-    expect(after.getSnapshot()).toEqual({ turnSeq: 3, callId: 'c1' })
+    expect(after.store.getSnapshot().selection).toEqual({ turnSeq: 3, callId: 'c1' })
+    expect(after.store.getSnapshot().draft).toBe('half-typed')
   })
 
-  it('reconnect (handleConnected: refreshList + resync) keeps the selection account', async () => {
+  it('session death buries the instance and its persisted draft', async () => {
     const b = bench()
-    feed(b, [{ id: 's1' }])
+    feed(b, [{ id: 's1' }, { id: 's2' }])
     await b.sessions.manager.refreshList()
     await flush()
 
-    const scoped = b.sessions.scope(sid('s1'))!
-    const store = (scoped.get('conversation') as ConversationService).selection
-    store.set({ turnSeq: 1, callId: 'c9' })
+    // Mint the scope (store prune rides the scope-teardown axis: no scope,
+    // no teardown — the real page always resolves the binding to render).
+    b.sessions.binding(sid('s1'))
+    const doomed = storeFor(b, 'conversation', sid('s1'))
+    doomed.actions.setDraft('to be buried')
+    doomed.actions.select({ turnSeq: 1 })
+    expect(localStorage.getItem('dsh.conversation.chat.s1')).not.toBeNull()
 
-    // Reconnect generation: title upgrade arrives with the re-pull.
-    feed(b, [{ id: 's1', cwd: '/w/proj-a', running: true }])
-    b.sessions.manager.handleConnected()
-    await flush()
-    await flush()
-
-    expect(b.sessions.scope(sid('s1'))).toBe(scoped)
-    const after = (b.sessions.scope(sid('s1'))!.get('conversation') as ConversationService).selection
-    expect(after).toBe(store)
-    expect(after.getSnapshot()).toEqual({ turnSeq: 1, callId: 'c9' })
-  })
-
-  it('a transiently failing list refresh does not prune live scopes', async () => {
-    const b = bench()
-    feed(b, [{ id: 's1' }])
+    // Watch elsewhere so s1's scope teardown is not deferred, then remove it.
+    b.sessions.binding(sid('s2'))
+    feed(b, [{ id: 's2' }])
     await b.sessions.manager.refreshList()
     await flush()
-    const scoped = b.sessions.scope(sid('s1'))!
-    const store = (scoped.get('conversation') as ConversationService).selection
-    store.set({ turnSeq: 2, callId: 'c2' })
 
-    // Wire hiccup: the reconnect-time list RPC throws (transport error).
-    b.api.onList = () => Promise.reject(new Error('boom'))
-    b.sessions.manager.handleConnected()
+    // Persisted residue is gone with the session...
+    expect(localStorage.getItem('dsh.conversation.chat.s1')).toBeNull()
+    // ...and a re-created same-id session starts from a FRESH instance.
+    feed(b, [{ id: 's1' }, { id: 's2' }])
+    await b.sessions.manager.refreshList()
     await flush()
-    await flush()
-
-    expect(b.sessions.scope(sid('s1'))).toBe(scoped)
-    expect((b.sessions.scope(sid('s1'))!.get('conversation') as ConversationService).selection.getSnapshot())
-      .toEqual({ turnSeq: 2, callId: 'c2' })
+    const reborn = storeFor(b, 'conversation', sid('s1'))
+    expect(reborn).not.toBe(doomed)
+    expect(reborn.store.getSnapshot()).toEqual({ selection: null, draft: '', view: null })
   })
 })

packages/client/ui-conversation/tests/service-orchestration.spec.ts

@@ -1,9 +1,10 @@
 // @vitest-environment jsdom
 /**
- * ConversationService orchestration half: scope-addressed send/cancel (result
- * folding, root throw), openDetails choreography, the startSession chain, and
- * the service-unavailable loud failures. Store semantics live in
- * service-stores.spec.ts.
+ * ConversationService orchestration half after the store-seat slimming:
+ * scope-addressed send/cancel (result folding, root throw), the startSession
+ * chain (create → sessions.open → scoped send), views ordering, and the
+ * service-unavailable loud failures. Selection/draft state left this service
+ * for the declared chat store (chat-store.spec.ts / selection-survival.spec.ts).
  */
 import { Context } from 'cordis'
 import { describe, expect, it, vi } from 'vitest'
@@ -13,7 +14,7 @@ import { ConversationService } from '@deepseek-ai/dsh-client-ui-conversation/cli
 
 const sid = (s: string): SessionId => s as SessionId
 
-/** Recover the module-private scope tag through the public seam (same probe as service-stores.spec). */
+/** Recover the module-private scope tag through the public seam (same probe as apply-inject.spec). */
 const SCOPE_TAG: symbol = (() => {
   const recorded: (string | symbol)[] = []
   const spy = new Proxy(new Context(), {
@@ -33,7 +34,7 @@ interface SessionDouble {
   cancel: ReturnType<typeof vi.fn>
 }
 
-async function bench(opts?: { layout?: boolean; sessions?: boolean }) {
+async function bench(opts?: { sessions?: boolean }) {
   const ctx = new Context()
   const sessionDoubles = new Map<SessionId, SessionDouble>()
   const scopes = new Map<SessionId, Context>()
@@ -47,6 +48,7 @@ async function bench(opts?: { layout?: boolean; sessions?: boolean }) {
     return scoped
   }
   const createMock = vi.fn(() => Promise.resolve(sid('new-1')))
+  const openMock = vi.fn()
   const sessionsFake = {
     manager: {
       get: (id: SessionId) => {
@@ -62,16 +64,15 @@ async function bench(opts?: { layout?: boolean; sessions?: boolean }) {
       },
     },
     create: createMock,
+    open: openMock,
     scope: (id: SessionId) => (id === sid('new-1') ? mint(id) : scopes.get(id)),
   } as unknown as SessionsService
   if (opts?.sessions !== false) ctx.provide('sessions', sessionsFake)
-  const layoutFake = { open: vi.fn(), openDetails: vi.fn() }
-  if (opts?.layout !== false) ctx.provide('layout', layoutFake)
   const fiber = ctx.plugin((pluginCtx) => { void new ConversationService(pluginCtx) })
   await fiber.await()
   const svc = ctx.get('conversation') as ConversationService
   const scopedSvc = (id: SessionId) => mint(id).get('conversation') as ConversationService
-  return { ctx, svc, scopedSvc, mint, sessionDoubles, sessionsFake, createMock, layoutFake }
+  return { ctx, svc, scopedSvc, mint, sessionDoubles, sessionsFake, createMock, openMock }
 }
 
 describe('send / cancel', () => {
@@ -109,22 +110,12 @@ describe('send / cancel', () => {
   })
 })
 
-describe('openDetails', () => {
-  it('writes the scoped selection then opens the layout panel', async () => {
-    const b = await bench()
-    const s = b.scopedSvc(sid('s1'))
-    s.openDetails({ turnSeq: 3, callId: 'c1', toolName: 'bash' })
-    expect(s.selection.getSnapshot()).toEqual({ turnSeq: 3, callId: 'c1', toolName: 'bash' })
-    expect(b.layoutFake.openDetails).toHaveBeenCalledTimes(1)
-  })
-})
-
 describe('startSession chain', () => {
-  it('creates, navigates, then sends through the new scope', async () => {
+  it('creates, navigates through sessions.open, then sends through the new scope', async () => {
     const b = await bench()
     await b.svc.startSession({ cwd: '/proj', text: 'first', mode: 'queue' })
     expect(b.createMock).toHaveBeenCalledWith({ cwd: '/proj' })
-    expect(b.layoutFake.open).toHaveBeenCalledWith(sid('new-1'))
+    expect(b.openMock).toHaveBeenCalledWith(sid('new-1'))
     expect(b.sessionDoubles.get(sid('new-1'))!.prompt).toHaveBeenCalledWith(
       [{ type: 'text', text: 'first' }], 'queue')
   })
@@ -148,12 +139,6 @@ describe('service-unavailable loud failures', () => {
     await expect(b.svc.startSession({ text: 't', mode: 'queue' })).rejects.toThrow(/sessions service unavailable/)
   })
 
-  it('throws when layout is missing', async () => {
-    const b = await bench({ layout: false })
-    const s = b.scopedSvc(sid('s1'))
-    expect(() => { s.openDetails({ turnSeq: 1 }) }).toThrow(/layout service unavailable/)
-  })
-
   it('startSession fails loud when the new scope cannot resolve conversation', async () => {
     const b = await bench()
     // A scope minted outside the service tree: scoped.get('conversation') finds nothing.
@@ -165,7 +150,7 @@ describe('service-unavailable loud failures', () => {
   })
 })
 
-describe('views ordering and draft persistence branches', () => {
+describe('views ordering', () => {
   it('orders by explicit order with undefined treated as zero (both comparator arms)', async () => {
     const b = await bench()
     const entry = (id: string, order?: number) => ({
@@ -177,15 +162,4 @@ describe('views ordering and draft persistence branches', () => {
     b.svc.registerView(entry('first', -1) as never)
     expect(b.svc.views().map(v => v.id)).toEqual(['first', 'default-zero', 'z-late'])
   })
-
-  it('draft store round-trips through localStorage and removes the key when emptied', async () => {
-    const b = await bench()
-    localStorage.setItem('dsh.conversation.draft.s9', 'restored')
-    const s = b.scopedSvc(sid('s9'))
-    expect(s.drafts.getSnapshot()).toBe('restored')
-    s.drafts.set('typed')
-    expect(localStorage.getItem('dsh.conversation.draft.s9')).toBe('typed')
-    s.drafts.set('')
-    expect(localStorage.getItem('dsh.conversation.draft.s9')).toBeNull()
-  })
 })

packages/client/ui-conversation/tests/service-stores.spec.ts

@@ -1,176 +0,0 @@
-// @vitest-environment jsdom
-/**
- * ConversationService store half: scope-addressed selection/drafts accounts
- * (lazy mint, per-scope isolation, root access throws, scope teardown
- * collects), view registry (order, duplicate throw, effect-scoped disposal,
- * uSES read face). Send/cancel/startSession orchestration live in
- * service-orchestration.spec.ts.
- */
-import { Context } from 'cordis'
-import { beforeEach, describe, expect, it, vi } from 'vitest'
-import type { FC } from 'react'
-import { scopeOf } from '@deepseek-ai/dsh-client-runtime/client'
-import type { SessionId, SessionsService } from '@deepseek-ai/dsh-client-runtime/client'
-import { ConversationService } from '@deepseek-ai/dsh-client-ui-conversation/client'
-import type { ConvViewProps, ViewEntry } from '@deepseek-ai/dsh-client-ui-conversation/client'
-
-const sid = (s: string): SessionId => s as SessionId
-
-/**
- * The scope tag symbol is module-private to the runtime package; recover it
- * through the public seam by recording which symbol scopeOf reads off a
- * spying proxy (keeps this bench honest against the real tagging shape
- * without dragging the full SessionsService + wire fake in here).
- */
-const SCOPE_TAG: symbol = (() => {
-  const recorded: (string | symbol)[] = []
-  const spy = new Proxy(new Context(), {
-    get(target, prop, receiver): unknown {
-      recorded.push(prop)
-      return Reflect.get(target, prop, receiver)
-    },
-  })
-  void scopeOf(spy)
-  const symbol = recorded.find((p): p is symbol => typeof p === 'symbol')
-  if (symbol === undefined) throw new Error('scopeOf probe recorded no symbol read')
-  return symbol
-})()
-
-/** Scope bench: real cordis scope fibers tagged like SessionsService.resolve mints them. */
-interface Bench {
-  ctx: Context
-  svc: ConversationService
-  mint: (id: SessionId) => Context
-  dispose: (id: SessionId) => Promise<void>
-}
-
-function bench(): Bench {
-  const ctx = new Context()
-  const fibers = new Map<SessionId, { fiber: ReturnType<Context['plugin']>; ctx: Context }>()
-  const mint = (id: SessionId): Context => {
-    let rec = fibers.get(id)
-    if (rec === undefined) {
-      const fiber = ctx.plugin(() => {})
-      const scoped = fiber.ctx.extend({ [SCOPE_TAG]: id })
-      rec = { fiber, ctx: scoped }
-      fibers.set(id, rec)
-    }
-    return rec.ctx
-  }
-  const dispose = async (id: SessionId): Promise<void> => {
-    const rec = fibers.get(id)
-    if (rec !== undefined) {
-      await rec.fiber.dispose()
-      fibers.delete(id)
-    }
-  }
-  const sessions = { scope: (id: SessionId) => fibers.get(id)?.ctx } as unknown as SessionsService
-  ctx.provide('sessions', sessions)
-  const svc = new ConversationService(ctx)
-  return { ctx, svc, mint, dispose }
-}
-
-/** Scoped service view: ctx.get binds the root singleton to the scoped ctx (scope addressing seam). */
-function convo(scoped: Context): ConversationService {
-  const service = scoped.get('conversation')
-  if (service === undefined) throw new Error('bench: conversation unavailable')
-  return service
-}
-
-const viewComp = (() => null) as unknown as FC<ConvViewProps>
-const entry = (id: string, order?: number): ViewEntry =>
-  ({ id, label: id, component: viewComp, ...(order !== undefined ? { order } : {}) }) as unknown as ViewEntry
-
-beforeEach(() => { localStorage.clear() })
-
-describe('scope addressing of stores', () => {
-  it('root-context selection/drafts access throws with the addressing hint', () => {
-    const b = bench()
-    expect(() => b.svc.selection).toThrow(/requires a session scope/)
-    expect(() => b.svc.drafts).toThrow(/requires a session scope/)
-  })
-
-  it('mints one store per scope and keeps identity per session', () => {
-    const b = bench()
-    const c1 = b.mint(sid('s1'))
-    const c2 = b.mint(sid('s2'))
-    const sel1 = convo(c1).selection
-    const sel2 = convo(c2).selection
-    expect(sel1).not.toBe(sel2)
-    expect(convo(c1).selection).toBe(sel1)
-    sel1.set({ turnSeq: 3 })
-    expect(sel1.getSnapshot()).toEqual({ turnSeq: 3 })
-    expect(sel2.getSnapshot()).toBeNull()
-  })
-
-  it('persists drafts keyed by session id and evolves independently', async () => {
-    const b = bench()
-    const c1 = b.mint(sid('s1'))
-    convo(c1).drafts.set('hello')
-    expect(localStorage.getItem('dsh.conversation.draft.s1')).toBe('hello')
-    const c2 = b.mint(sid('s2'))
-    expect(convo(c2).drafts.getSnapshot()).toBe('')
-    // Re-minting after teardown rehydrates from storage; clearing removes the key.
-    await b.dispose(sid('s1'))
-    expect(convo(b.mint(sid('s1'))).drafts.getSnapshot()).toBe('hello')
-    convo(b.mint(sid('s1'))).drafts.set('')
-    expect(localStorage.getItem('dsh.conversation.draft.s1')).toBeNull()
-  })
-
-  it('scope fiber disposal collects the store account (fresh store on re-mint)', async () => {
-    const b = bench()
-    const c1 = b.mint(sid('s1'))
-    const sel = convo(c1).selection
-    sel.set({ turnSeq: 1 })
-    await b.dispose(sid('s1'))
-    const again = b.mint(sid('s1'))
-    const sel2 = convo(again).selection
-    expect(sel2).not.toBe(sel)
-    expect(sel2.getSnapshot()).toBeNull()
-  })
-})
-
-describe('view registry', () => {
-  it('orders by order (ties keep registration sequence) with a stable cache reference', () => {
-    const b = bench()
-    b.svc.registerView(entry('chat', 0))
-    b.svc.registerView(entry('waterfall', 2))
-    b.svc.registerView(entry('trajectory', 1))
-    const views = b.svc.views()
-    expect(views.map(v => v.id)).toEqual(['chat', 'trajectory', 'waterfall'])
-    expect(b.svc.views()).toBe(views)
-  })
-
-  it('duplicate id throws; disposer removes and bumps the version', () => {
-    const b = bench()
-    const fn = vi.fn()
-    b.svc.subscribeViews(fn)
-    const off = b.svc.registerView(entry('chat'))
-    expect(() => b.svc.registerView(entry('chat'))).toThrow(/already registered/)
-    const v1 = b.svc.viewsVersion()
-    off()
-    expect(b.svc.viewsVersion()).toBeGreaterThan(v1)
-    expect(b.svc.views()).toEqual([])
-    expect(fn).toHaveBeenCalled()
-  })
-
-  it('unsubscribe stops notifications', () => {
-    const b = bench()
-    const fn = vi.fn()
-    const unsub = b.svc.subscribeViews(fn)
-    unsub()
-    b.svc.registerView(entry('chat'))
-    expect(fn).not.toHaveBeenCalled()
-  })
-
-  it('a registering plugin fiber unloading collects its views (effect cascade)', async () => {
-    const b = bench()
-    const fiber = b.ctx.plugin((pluginCtx: Context) => {
-      convo(pluginCtx).registerView(entry('chat'))
-    })
-    await fiber.await()
-    expect(b.svc.views().map(v => v.id)).toEqual(['chat'])
-    await fiber.dispose()
-    expect(b.svc.views()).toEqual([])
-  })
-})

packages/client/ui-conversation/tests/skeleton-branches.spec.tsx

@@ -1,16 +1,19 @@
 // @vitest-environment jsdom
 // Skeleton branch tails for the coverage gate (complements skeleton.spec.tsx
-// acceptance flows): breadcrumb ancestry rendering + error strip in
-// ConversationRoot, DetailsPanel non-JSON args / non-text result blocks /
-// error-only results, EmptyState failure surface and custom-directory swap.
+// acceptance flows), four-share props form: breadcrumb ancestry derivation +
+// error strip in ConversationRoot, DetailsPanel non-JSON args / non-text
+// result blocks / error-only results over the shared store, EmptyState
+// failure surface and custom-directory swap with in-component cwd derivation.
 
 import { afterEach, describe, expect, it, vi } from 'vitest'
 import { cleanup, fireEvent, render, waitFor } from '@testing-library/react'
 import { bindSnapshotSelector } from '@deepseek-ai/dsh-client-web-react'
+import { createSnapshotStore } from '@deepseek-ai/dsh-client-web-react/src/store/index.ts'
 import type { UseSession } from '@deepseek-ai/dsh-client-web-react'
-import type { ConversationSnapshot, SessionId, SessionSummary } from '@deepseek-ai/dsh-client-runtime/client'
+import type { ConversationSnapshot, SessionId, SessionListState } from '@deepseek-ai/dsh-client-runtime/client'
 import type { SelectionTarget, ViewEntry } from '@deepseek-ai/dsh-client-ui-conversation/client'
 // Export discipline: packages/client/AGENTS.md.
+import { createChatStore } from '../src/client/stores.ts'
 import { ConversationRoot } from '../src/client/skeleton/ConversationRoot.tsx'
 import { DetailsPanel } from '../src/client/skeleton/DetailsPanel.tsx'
 import { EmptyState } from '../src/client/skeleton/EmptyState.tsx'
@@ -35,37 +38,52 @@ function sessionSource(over?: Partial<ConversationSnapshot>) {
   }
 }
 
-const summary = (id: string, title: string): SessionSummary =>
-  ({ id: id as SessionId, title, running: false, updatedAt: 1 })
+/** Sessions-list stub over a snapshot store (the standard useSessions hook shape). */
+function listHook(rows: { id: string; title: string; cwd?: string; parentId?: string }[]) {
+  const store = createSnapshotStore<SessionListState>({
+    ids: rows.map(r => r.id as SessionId),
+    byId: Object.fromEntries(rows.map(r => [r.id, {
+      id: r.id as SessionId, title: r.title, running: false, updatedAt: 1,
+      ...(r.cwd !== undefined ? { cwd: r.cwd } : {}),
+      ...(r.parentId !== undefined ? { parentId: r.parentId as SessionId } : {}),
+    }])),
+    current: undefined,
+  } as SessionListState)
+  return store.useSelector
+}
 
 describe('ConversationRoot branches', () => {
   const chatEntry: ViewEntry = {
-    id: 'chat', label: 'Chat', component: () => null,
+    id: 'chat', label: 'Chat', component: () => <div data-testid="view-body" />,
   } as unknown as ViewEntry
 
   function rootProps(over?: {
-    ancestry?: readonly SessionSummary[]
+    rows?: { id: string; title: string; parentId?: string }[]
     snapshot?: Partial<ConversationSnapshot>
   }) {
     const open = vi.fn()
+    const chat = createChatStore().create()
     const view = render(
       <ConversationRoot
         sessionId={SID}
-        useSession={bindSnapshotSelector(sessionSource(over?.snapshot)) as unknown as UseSession}
-        useAncestry={() => over?.ancestry ?? []}
+        useSession={bindSnapshotSelector(sessionSource(over?.snapshot)) as unknown as UseSession<ConversationSnapshot>}
+        useSessions={listHook(over?.rows ?? [])}
+        useStore={chat.useSelector}
+        actions={chat.actions}
         views={{ list: () => [chatEntry], subscribe: () => () => {}, version: () => 1 }}
-        useActiveView={() => undefined}
-        composer={{ useDraft: () => '', setDraft: vi.fn(), send: vi.fn(), stop: vi.fn() }}
-        actions={{ openView: vi.fn(), open }}
-        renderView={() => <div data-testid="view-body" />}
+        send={vi.fn()}
+        stop={vi.fn()}
+        openDetails={vi.fn()}
+        loadOlder={vi.fn()}
+        open={open}
       />,
     )
-    return { view, open }
+    return { view, open, chat }
   }
 
-  it('renders the ancestry breadcrumb with separators and navigates on ancestor click', () => {
+  it('derives the ancestry breadcrumb from the sessions list and navigates on ancestor click', () => {
     const { view, open } = rootProps({
-      ancestry: [summary('root-1', 'Workspace'), summary('s1', 'Current')],
+      rows: [{ id: 'root-1', title: 'Workspace' }, { id: 's1', title: 'Current', parentId: 'root-1' }],
     })
     expect(view.getByText('Workspace')).toBeTruthy()
     expect(view.getByText('/')).toBeTruthy()
@@ -76,6 +94,14 @@ describe('ConversationRoot branches', () => {
     expect(open).toHaveBeenCalledTimes(1)
   })
 
+  it('a broken parent link stops the ancestry walk at the known chain', () => {
+    const { view } = rootProps({
+      rows: [{ id: 's1', title: 'Orphan', parentId: 'vanished' }],
+    })
+    // The walk keeps s1 itself and stops where the parent is unknown.
+    expect(view.getByText('Orphan')).toBeTruthy()
+  })
+
   it('falls back to the raw session id without ancestry and counts user turns', () => {
     const { view } = rootProps({
       snapshot: { nodes: [{ kind: 'user', seq: 1 } as never, { kind: 'assistant', seq: 2 } as never] },
@@ -91,31 +117,41 @@ describe('ConversationRoot branches', () => {
     expect(view.getByText(/停止失败：halt（internal）/)).toBeTruthy()
   })
 
-  it('an unknown active view id falls back to the first registered view', () => {
+  it('an unknown stored view id falls back to the first registered view', () => {
+    const { chat } = rootProps({})
+    cleanup()
+    chat.actions.setView('gone' as never)
     const view = render(
       <ConversationRoot
         sessionId={SID}
-        useSession={bindSnapshotSelector(sessionSource()) as unknown as UseSession}
-        useAncestry={() => []}
+        useSession={bindSnapshotSelector(sessionSource()) as unknown as UseSession<ConversationSnapshot>}
+        useSessions={listHook([])}
+        useStore={chat.useSelector}
+        actions={chat.actions}
         views={{ list: () => [chatEntry], subscribe: () => () => {}, version: () => 1 }}
-        useActiveView={() => 'gone' as never}
-        composer={{ useDraft: () => '', setDraft: vi.fn(), send: vi.fn(), stop: vi.fn() }}
-        actions={{ openView: vi.fn(), open: vi.fn() }}
-        renderView={(entry) => <div data-testid={`body-${entry.id}`} />}
+        send={vi.fn()}
+        stop={vi.fn()}
+        openDetails={vi.fn()}
+        loadOlder={vi.fn()}
+        open={vi.fn()}
       />,
     )
-    expect(view.getByTestId('body-chat')).toBeTruthy()
+    expect(view.getByTestId('view-body')).toBeTruthy()
   })
 })
 
 describe('DetailsPanel branches', () => {
   function panel(selection: SelectionTarget | null, snapshot?: Partial<ConversationSnapshot>) {
+    const chat = createChatStore().create()
+    if (selection !== null) chat.actions.select(selection)
     return render(
       <DetailsPanel
         sessionId={SID}
-        useSession={bindSnapshotSelector(sessionSource(snapshot)) as unknown as UseSession}
-        useSelection={bindSnapshotSelector({ getSnapshot: () => selection, subscribe: () => () => {} })}
-        actions={{ closeDetails: vi.fn() }}
+        useSession={bindSnapshotSelector(sessionSource(snapshot)) as unknown as UseSession<ConversationSnapshot>}
+        useSessions={listHook([])}
+        useStore={chat.useSelector}
+        actions={chat.actions}
+        closeDetails={vi.fn()}
       />,
     )
   }
@@ -142,13 +178,16 @@ describe('DetailsPanel branches', () => {
         return () => subs.delete(fn)
       },
     }
-    const SEL: SelectionTarget = { turnSeq: 1, callId: 'c9' }
+    const chat = createChatStore().create()
+    chat.actions.select({ turnSeq: 1, callId: 'c9' })
     const view = render(
       <DetailsPanel
         sessionId={SID}
-        useSession={bindSnapshotSelector(source) as unknown as UseSession}
-        useSelection={bindSnapshotSelector({ getSnapshot: () => SEL, subscribe: () => () => {} })}
-        actions={{ closeDetails: vi.fn() }}
+        useSession={bindSnapshotSelector(source) as unknown as UseSession<ConversationSnapshot>}
+        useSessions={listHook([])}
+        useStore={chat.useSelector}
+        actions={chat.actions}
+        closeDetails={vi.fn()}
       />,
     )
     expect(view.getByText(/"a": 1/)).toBeTruthy()
@@ -192,18 +231,10 @@ describe('DetailsPanel branches', () => {
 })
 
 describe('EmptyState branches', () => {
-  // getSnapshot must return a stable reference (uSES contract) — a fresh
-  // array per call loops the selector forever.
-  const CWDS: readonly string[] = ['/proj']
-  const NO_CWDS: readonly string[] = []
-
   it('keeps the draft and surfaces a local error strip when startSession rejects', async () => {
     const startSession = vi.fn(() => Promise.reject(new Error('create down')))
     const view = render(
-      <EmptyState
-        useCwds={bindSnapshotSelector({ getSnapshot: () => CWDS, subscribe: () => () => {} })}
-        actions={{ startSession }}
-      />,
+      <EmptyState useSessions={listHook([{ id: 'a', title: 'a', cwd: '/proj' }])} startSession={startSession} />,
     )
     const textarea = view.container.querySelector('textarea')!
     fireEvent.change(textarea, { target: { value: 'first task' } })
@@ -215,10 +246,7 @@ describe('EmptyState branches', () => {
   it('non-Error rejection reasons stringify into the error strip', async () => {
     const startSession = vi.fn(() => Promise.reject('plain-string'))
     const view = render(
-      <EmptyState
-        useCwds={bindSnapshotSelector({ getSnapshot: () => NO_CWDS, subscribe: () => () => {} })}
-        actions={{ startSession }}
-      />,
+      <EmptyState useSessions={listHook([])} startSession={startSession} />,
     )
     const textarea = view.container.querySelector('textarea')!
     fireEvent.change(textarea, { target: { value: 'go' } })
@@ -226,15 +254,20 @@ describe('EmptyState branches', () => {
     await waitFor(() => expect(view.getByText(/发送失败：plain-string/)).toBeTruthy())
   })
 
-  it('cwd select picks an option, swaps to free-form on 新目录, and submits the typed path', async () => {
+  it('cwd derivation skips blank cwds; select picks, swaps to free-form, submits the typed path', async () => {
     const startSession = vi.fn(() => Promise.resolve())
     const view = render(
       <EmptyState
-        useCwds={bindSnapshotSelector({ getSnapshot: () => CWDS, subscribe: () => () => {} })}
-        actions={{ startSession }}
+        useSessions={listHook([
+          { id: 'a', title: 'a', cwd: '/proj' },
+          { id: 'b', title: 'b' }, // no cwd: filtered from the option set
+        ])}
+        startSession={startSession}
       />,
     )
     const select = view.container.querySelector('select')!
+    expect([...(select as HTMLSelectElement).options].map(o => o.value))
+      .toEqual(['', '/proj', '::new-directory'])
     fireEvent.change(select, { target: { value: '/proj' } })
     expect((select as HTMLSelectElement).value).toBe('/proj')
     fireEvent.change(select, { target: { value: '::new-directory' } })

packages/client/ui-conversation/tests/skeleton.spec.tsx

@@ -1,19 +1,23 @@
 // @vitest-environment jsdom
 /**
- * Skeleton acceptance: empty-state transition (same InputBar component in
- * hero position, startSession submit), ConversationRoot view switching over
- * the registry face, DetailsPanel open/close linkage against a layout-shaped
- * fake. Components stay framework-free — everything arrives via props here,
- * exactly as the inject factories will assemble them.
+ * Skeleton acceptance over the four-share props form: empty-state transition
+ * (same InputBar component in hero position, startSession submit, in-component
+ * cwd derivation), ConversationRoot view switching through the store's view
+ * field, DetailsPanel selection through the shared store. Components stay
+ * pure — the framework shares are stubbed (useSession/useSessions), the store
+ * share is a REAL createChatStore().create() instance (same construction path
+ * as production), injected callbacks are spies.
  */
 import { cleanup, fireEvent, render, screen } from '@testing-library/react'
-import { afterEach, describe, expect, it, vi } from 'vitest'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
 import type { FC } from 'react'
-import { bindSnapshotSelector, createSnapshotStore } from '@deepseek-ai/dsh-client-web-react'
+import { bindSnapshotSelector } from '@deepseek-ai/dsh-client-web-react'
+import { createSnapshotStore } from '@deepseek-ai/dsh-client-web-react/src/store/index.ts'
 import type { UseSession } from '@deepseek-ai/dsh-client-web-react'
-import type { SessionId, SessionSummary } from '@deepseek-ai/dsh-client-runtime/client'
-import type { SelectionTarget, ViewEntry, ViewId } from '@deepseek-ai/dsh-client-ui-conversation/client'
+import type { ConversationSnapshot, SessionId, SessionListState } from '@deepseek-ai/dsh-client-runtime/client'
+import type { SelectionTarget, ViewEntry } from '@deepseek-ai/dsh-client-ui-conversation/client'
 // Export discipline: packages/client/AGENTS.md.
+import { createChatStore } from '../src/client/stores.ts'
 import { ConversationRoot } from '../src/client/skeleton/ConversationRoot.tsx'
 import { DetailsPanel } from '../src/client/skeleton/DetailsPanel.tsx'
 import { EmptyState } from '../src/client/skeleton/EmptyState.tsx'
@@ -21,6 +25,9 @@ import { EmptyState } from '../src/client/skeleton/EmptyState.tsx'
 const sid = (s: string): SessionId => s as SessionId
 
 afterEach(cleanup)
+beforeEach(() => {
+  localStorage.clear()
+})
 
 /** Minimal conversation snapshot slice the skeleton reads. */
 interface FakeSnapshot {
@@ -35,17 +42,38 @@ function fakeSession(init: Partial<FakeSnapshot> = {}) {
   const store = createSnapshotStore<FakeSnapshot>({
     nodes: [], runningCalls: [], running: false, removed: false, promptError: null, ...init,
   })
-  return { store, useSession: bindSnapshotSelector(store) as unknown as UseSession }
+  return { store, useSession: bindSnapshotSelector(store) as unknown as UseSession<ConversationSnapshot> }
+}
+
+/** Sessions-list stub: the standard useSessions hook over a snapshot store. */
+function fakeSessions(rows: { id: string; title: string; cwd?: string; parentId?: string }[]) {
+  const store = createSnapshotStore<SessionListState>({
+    ids: rows.map(r => sid(r.id)),
+    byId: Object.fromEntries(rows.map(r => [r.id, {
+      id: sid(r.id), title: r.title, running: false, updatedAt: 1,
+      ...(r.cwd !== undefined ? { cwd: r.cwd } : {}),
+      ...(r.parentId !== undefined ? { parentId: sid(r.parentId) } : {}),
+    }])),
+    current: undefined,
+  } as SessionListState)
+  return { store, useSessions: store.useSelector }
 }
 
 describe('EmptyState', () => {
-  it('submits startSession with the typed text and picked cwd; failure surfaces locally', async () => {
-    const cwds = createSnapshotStore<readonly string[]>(['/w/app', '/w/lib'])
+  it('derives cwd options from the sessions list, submits startSession, failure surfaces locally', async () => {
+    const { useSessions } = fakeSessions([
+      { id: 'a', title: 'a', cwd: '/w/app' },
+      { id: 'b', title: 'b', cwd: '/w/lib' },
+      { id: 'c', title: 'c', cwd: '/w/app' }, // duplicate cwd dedupes
+    ])
     let reject!: (e: Error) => void
     const startSession = vi.fn(() => new Promise<void>((_res, rej) => { reject = rej }))
-    render(<EmptyState useCwds={cwds.useSelector} actions={{ startSession }} />)
+    render(<EmptyState useSessions={useSessions} startSession={startSession} />)
 
-    fireEvent.change(screen.getByRole('combobox', { name: '项目目录' }), { target: { value: '/w/app' } })
+    const select = screen.getByRole('combobox', { name: '项目目录' })
+    expect([...(select as HTMLSelectElement).options].map(o => o.value))
+      .toEqual(['', '/w/app', '/w/lib', '::new-directory'])
+    fireEvent.change(select, { target: { value: '/w/app' } })
     const box = screen.getByPlaceholderText('Message to run task, plan and build')
     fireEvent.change(box, { target: { value: '造一个轮子' } })
     fireEvent.keyDown(box, { key: 'Enter' })
@@ -58,8 +86,8 @@ describe('EmptyState', () => {
   })
 
   it('new-directory option swaps the select for a free-form input', () => {
-    const cwds = createSnapshotStore<readonly string[]>([])
-    render(<EmptyState useCwds={cwds.useSelector} actions={{ startSession: () => Promise.resolve() }} />)
+    const { useSessions } = fakeSessions([])
+    render(<EmptyState useSessions={useSessions} startSession={() => Promise.resolve()} />)
     fireEvent.change(screen.getByRole('combobox'), { target: { value: '::new-directory' } })
     const custom = screen.getByPlaceholderText(/目录路径/)
     fireEvent.change(custom, { target: { value: '/tmp/fresh' } })
@@ -68,90 +96,117 @@ describe('EmptyState', () => {
 })
 
 describe('ConversationRoot', () => {
-  function bench(views: ViewEntry[], active?: string) {
+  function bench(views: ViewEntry[], activeView?: string) {
     const { useSession } = fakeSession({ nodes: [{ kind: 'user' }, { kind: 'user' }] })
-    const activeStore = createSnapshotStore<string | undefined>(active)
-    const openView = vi.fn((v: string) => { activeStore.set(v) })
-    const open = vi.fn()
-    const drafts = createSnapshotStore<string>('')
+    const { useSessions } = fakeSessions([
+      { id: 'root', title: 'proj' },
+      { id: 's1', title: 'child', parentId: 'root' },
+    ])
+    const chat = createChatStore().create()
+    if (activeView !== undefined) chat.actions.setView(activeView as never)
     const send = vi.fn()
     const stop = vi.fn()
-    const ancestry: SessionSummary[] = [
-      { id: sid('root'), title: 'proj', running: false, updatedAt: 1 },
-      { id: sid('s1'), title: 'child', running: false, updatedAt: 1, parentId: sid('root') },
-    ]
-    const rendered: string[] = []
+    const openDetails = vi.fn()
+    const loadOlder = vi.fn()
+    const open = vi.fn()
     const ui = render(
       <ConversationRoot
         sessionId={sid('s1')}
         useSession={useSession}
-        useAncestry={() => ancestry}
+        useSessions={useSessions}
+        useStore={chat.useSelector}
+        actions={chat.actions}
         views={{
           list: () => views,
           subscribe: () => () => {},
           version: () => 1,
         }}
-        useActiveView={() => activeStore.useSelector(s => s) as ViewId | undefined}
-        composer={{
-          useDraft: () => drafts.useSelector(s => s),
-          setDraft: (t) => { drafts.set(t) },
-          send, stop,
-        }}
-        actions={{ openView: openView as (v: never) => void, open }}
-        renderView={(entry) => { rendered.push(entry.id); return <div data-testid={`view-${entry.id}`} /> }}
+        send={send}
+        stop={stop}
+        openDetails={openDetails}
+        loadOlder={loadOlder}
+        open={open}
       />)
-    return { ui, openView, open, rendered, send, drafts }
+    return { ui, chat, send, stop, open }
   }
 
-  const comp = (() => null) as unknown as FC<never>
+  /** View bodies record their mount via testid (renderView is in-component now). */
   const view = (id: string, label: string): ViewEntry =>
-    ({ id, label, component: comp }) as unknown as ViewEntry
+    ({
+      id, label,
+      component: (() => <div data-testid={`view-${id}`} />) as unknown as FC<never>,
+    }) as unknown as ViewEntry
 
-  it('renders breadcrumb chain, meta turns, and the active view (default chat)', () => {
-    const { rendered, open } = bench([view('chat', 'Chat'), view('trajectory', 'Trajectory')])
+  it('renders breadcrumb chain (useSessions-derived), meta turns, and the default chat view', () => {
+    const { open } = bench([view('chat', 'Chat'), view('trajectory', 'Trajectory')])
     expect(screen.getByText('proj')).toBeTruthy()
     expect(screen.getByText('child')).toBeTruthy()
     expect(screen.getByText(/2 turns/)).toBeTruthy()
-    expect(rendered).toEqual(['chat'])
+    expect(screen.getByTestId('view-chat')).toBeTruthy()
     // Ancestor crumb navigates; current crumb is disabled.
     fireEvent.click(screen.getByRole('button', { name: 'proj' }))
     expect(open).toHaveBeenCalledWith('root')
     expect((screen.getByRole('button', { name: 'child' }) as HTMLButtonElement).disabled).toBe(true)
   })
 
-  it('switches views through actions.openView and re-renders the new body', () => {
-    const { openView } = bench([view('chat', 'Chat'), view('trajectory', 'Trajectory')])
+  it('switches views through the store view field and falls back on unknown ids', () => {
+    const { chat } = bench([view('chat', 'Chat'), view('trajectory', 'Trajectory')])
     fireEvent.click(screen.getByRole('tab', { name: 'Trajectory' }))
-    expect(openView).toHaveBeenCalledWith('trajectory')
+    expect(chat.store.getSnapshot().view).toBe('trajectory')
     expect(screen.getByTestId('view-trajectory')).toBeTruthy()
+    cleanup()
+    // A stale persisted id (its view plugin unloaded) falls to the first view.
+    bench([view('chat', 'Chat'), view('trajectory', 'Trajectory')], 'ghost-view')
+    expect(screen.getByTestId('view-chat')).toBeTruthy()
   })
 
-  it('hides the tab strip with a single view and wires the composer send', () => {
-    const { send } = bench([view('chat', 'Chat')])
+  it('mounts chrome header/footer around the view body', () => {
+    const entry = {
+      id: 'chat', label: 'Chat',
+      component: () => <div data-testid="body" />,
+      chrome: {
+        header: () => <div data-testid="hd" />,
+        footer: () => <div data-testid="ft" />,
+      },
+    } as unknown as ViewEntry
+    bench([entry])
+    expect(screen.getByTestId('hd')).toBeTruthy()
+    expect(screen.getByTestId('body')).toBeTruthy()
+    expect(screen.getByTestId('ft')).toBeTruthy()
+  })
+
+  it('hides the tab strip with a single view; composer writes the store draft and sends it', () => {
+    const { chat, send } = bench([view('chat', 'Chat')])
     expect(screen.queryByRole('tablist')).toBeNull()
     const box = screen.getByPlaceholderText(/输入消息/)
     fireEvent.change(box, { target: { value: 'hi' } })
+    // Typing goes through actions.setDraft into the shared store.
+    expect(chat.store.getSnapshot().draft).toBe('hi')
     fireEvent.keyDown(box, { key: 'Enter' })
-    expect(send).toHaveBeenCalledWith('queue')
+    expect(send).toHaveBeenCalledWith('hi', 'queue')
   })
 })
 
 describe('DetailsPanel', () => {
   function benchDetails(snapshot: Partial<FakeSnapshot>, selection: SelectionTarget | null) {
     const { useSession } = fakeSession(snapshot)
-    const selectionStore = createSnapshotStore<SelectionTarget | null>(selection)
+    const { useSessions } = fakeSessions([])
+    const chat = createChatStore().create()
+    if (selection !== null) chat.actions.select(selection)
     const closeDetails = vi.fn()
     render(
       <DetailsPanel
         sessionId={sid('s1')}
         useSession={useSession}
-        useSelection={selectionStore.useSelector}
-        actions={{ closeDetails }}
+        useSessions={useSessions}
+        useStore={chat.useSelector}
+        actions={chat.actions}
+        closeDetails={closeDetails}
       />)
-    return { closeDetails, selectionStore }
+    return { closeDetails, chat }
   }
 
-  it('renders the selected call args and result; close fires the layout-linked action', () => {
+  it('renders the selected call args and result off the shared store; close fires the injected callback', () => {
     const { closeDetails } = benchDetails({
       nodes: [{
         kind: 'tool-result', callId: 'c1',

packages/client/ui-conversation/tests/toolviews-type-chain.spec.ts

@@ -8,7 +8,6 @@
 // pinned here. Follows the slots-ring exemplar's shape.
 import { describe, expect, it } from 'vitest'
 import type { FC, ReactNode } from 'react'
-import type { SessionBinding } from '@deepseek-ai/dsh-client-ui-slots'
 import type { ToolViewOptions, ToolViewProps } from '../src/client/contract/toolview.ts'
 import { ToolViewRegistry } from '../src/client/toolviews/registry.ts'
 import type { SessionId } from '@deepseek-ai/dsh-client-runtime/client'
@@ -66,8 +65,9 @@ describe('tool-ring full chain (positive dual)', () => {
     const registry = new ToolViewRegistry()
     // Registration: I inferred from the factory, component proved ⊇ ToolViewProps & I.
     const disposeGlobal = registry.register('bash', InjectedRow, {
-      inject: (b: SessionBinding): RowInjected => ({
-        useRuns: () => b.sessionId.length,
+      // Terminal channel form: the factory receives the session id only.
+      inject: (sessionId: SessionId): RowInjected => ({
+        useRuns: () => sessionId.length,
         actions2: { rerun: () => {} },
       }),
     })
@@ -81,9 +81,7 @@ describe('tool-ring full chain (positive dual)', () => {
     expect(global?.component).toBe(InjectedRow)
     // Read face: I is erased to object, the factory reference survives; the
     // outlet-side restoration is the budgeted cast (same boundary as slots).
-    const injected = (global?.inject as (b: SessionBinding) => RowInjected)(
-      { sessionId: 'ab', session: { useSelector: undefined }, ctx: undefined },
-    )
+    const injected = (global?.inject as (sessionId: SessionId) => RowInjected)(sid('ab'))
     expect(injected.useRuns()).toBe(2)
     // Unknown tool → undefined (caller falls back to the generic card).
     expect(registry.resolve('ghost-tool', sid('other'))).toBeUndefined()

packages/client/ui-conversation/tests/views-type-chain.spec.tsx

@@ -69,6 +69,17 @@ describe('view-ring type-chain negatives (compile-time; body never runs)', () =>
         chrome: { header: (props: ChromePropsOf<'vt-plain'> & { onlyPlain: true }) => null },
       }
       void mixed
+      // 6. Zero-renderSlot inference: the view ring declares no children, so
+      //    view props carry no delegation face (the old hand-written
+      //    ScopedSlots<never> empty surface is retired, not replaced).
+      const renderless = (props: ConvViewPropsOf<'vt-plain'>): ReactNode => {
+        // @ts-expect-error views receive no renderSlot — no sub-slot delegation
+        void props.renderSlot
+        // @ts-expect-error the legacy slots face is gone from view props
+        void props.slots
+        return null
+      }
+      void renderless
       return null as ReactNode
     }
     expect(negatives).toBeTypeOf('function')