feat(web): add workspace-aware session flow

packages/client/ui-conversation/README.md

@@ -2,13 +2,15 @@
 
 Conversation domain: skeleton (header/tabs/composer/empty state), chat view (grouped step-summary flow, streaming tail isolation, stats line, per-tool row slot with a bash sample registrant), minimal details panel, scope-addressed ConversationService. Contract: api-contracts v3 §7 plus the slot terminal design (store seat / props shares).
 
+The no-session hero renders the frontend Session Intent from the Session list projection, including its frontend Workspace Intent when no real Workspace exists. It declares `conversation.empty.workspace`, where ui-workspace registers the same picker used by the sidebar. WorkspacesService starts and publishes the two intents. The Session object keeps its identity across publication and retains any prompt that still needs connection or delivery; ConversationRoot reads that `pendingPrompt` from `useSession` and edits or retries it through the scoped ConversationService.
+
 The view ring IS a slot: the conversation registration declares the `'conversation.view'` list slot (session scope) in its `children` table, ConversationRoot renders the active entry through its renderSlot share (`only: <active id>`), and view tabs project from the ring ledger's registration options (`id`/`order`/`label`). The chat view is this package's own ring entry; other plugins (ui-trajectory) contribute tabs through plain `ctx.slots.register` — the former package-local view registry (`registerView`/`ViewEntry`/`ConversationViewMap` and the chrome attachment table) is retired, with per-view chrome dissolved into the view components themselves.
 
 Generic tool rows classify the built-in bash, read, search, write, and edit names into dedicated visual variants. The filesystem variants render the edit icon and `Write · <path>` or `Edit · <path>` summary while retaining the shared row-to-details interaction.
 
 Tool rows are slots too — the standalone tool ring (`ToolViewRegistry`/`ctx.toolviews`/outlet) is retired. The chat entry declares the keyed `'conversation.chat.toolview'` hole (session scope; the key space is runtime-open); its render site dispatches per row via `entryKey: toolName` with `GenericToolCard` as the call-site `fallback`. The owner payload is the uniform `ToolRowOwnerProps` (`callId`/`toolName`/`block`/`openDetails`) and `ToolRowProps` pre-composes it with the session standard kit. A registrant is a plain plugin: `ctx.slots.register({ name: 'conversation.chat.toolview', key: '<tool>', inject? }, Row)` with `inject: ['slots', 'conversation']` as the load-order seam (apply mounts ConversationService after the chat registration, so the service being present guarantees the slot is declared); session differentiation happens inside the component (`useSessions` reading `parentId` — the bash sample is the third-party-posture exemplar). Trajectory/waterfall toolview slots share this shape and land with their own render sites (RendersCheck rejects a declaration nobody renders).
 
-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 the conversation, chat-view, and details registrations, so the session slots share one instance per session (selection written by the chat view, 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, tab read face, details/paging callbacks, startSession chain).
+Per-session UI state (selection, ordinary composer draft, active view) lives in the declared chat store (`stores.ts` `createChatStore`): apply constructs one handle and passes it to the conversation, chat-view, and details registrations, so the session slots share one instance per session (selection written by the chat view, read by details) and the framework owns instance lifecycle and draft persistence. The frontend Session Intent comes from the Session list projection; after publication, any retained prompt comes from that Session's conversation snapshot. Components are pure — the framework standard kit (`useSession`/`sessionId` when session-scoped, plus global `useSessions`/`useWorkspaces`) and the store faces (`useStore`/`actions`) arrive automatically from the registration declaration; inject factories contribute plain data and callbacks for runtime Session actions, send/stop, tabs, details, and paging.
 
 `src/client/` is organized for the future package split: `contract/` is the sole inter-domain shared face (`slots.ts` slot declarations + composed slot props including the tool-row contract, `views.ts` shared primitives, `tool-call-model.ts`); the `skeleton/`, `chat/`, and `toolviews/` (sample registrants) 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).
 

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

@@ -16,7 +16,7 @@ import { DetailsPanel } from './skeleton/DetailsPanel.tsx'
 import { EmptyState } from './skeleton/EmptyState.tsx'
 
 /** Services required by the conversation plugin. */
-export const inject = ['slots', 'layout', 'sessions']
+export const inject = ['slots', 'layout', 'sessions', 'workspaces']
 
 /** Resolve the session-scoped conversation service (scope-addressed send/cancel), failing loud. */
 function scopedConversation(sessions: SessionsService, id: SessionId): ConversationService {
@@ -32,6 +32,7 @@ function scopedConversation(sessions: SessionsService, id: SessionId): Conversat
  */
 export function apply(ctx: Context): void {
   const sessions = ctx.sessions
+  const workspaces = ctx.workspaces
   const layout = ctx.layout
   const slots = ctx.slots
 
@@ -86,7 +87,9 @@ export function apply(ctx: Context): void {
             // Stop failure surfaces via snapshot.promptError; nothing to restore.
           })
         },
-        open: (target: SessionId) => { sessions.open(target) },
+        open: (sessionId) => { sessions.open(sessionId) },
+        updateSessionPrompt: (text) => { scoped.updatePendingPrompt(text) },
+        retrySessionPrompt: () => { scoped.retryPendingPrompt() },
       }
     },
   }, ConversationRoot)
@@ -103,13 +106,16 @@ export function apply(ctx: Context): void {
     label: 'Chat',
     children: { 'conversation.chat.toolview': { kind: 'keyed', scope: 'session' } },
     store: chatStore,
-    inject: (sessionId: SessionId, actions: BoundActions<typeof chatStore>): ChatViewInjected => ({
-      openDetails: (target) => {
-        actions.select(target)
-        layout.openDetails()
-      },
-      loadOlder: () => { void sessions.manager.get(sessionId).loadOlder() },
-    }),
+    inject: (sessionId: SessionId, actions: BoundActions<typeof chatStore>): ChatViewInjected => {
+      const scoped = scopedConversation(sessions, sessionId)
+      return {
+        openDetails: (target) => {
+          actions.select(target)
+          layout.openDetails()
+        },
+        loadOlder: () => { void scoped.loadOlder() },
+      }
+    },
   }, ChatView)
 
   // Class-plugin mount (packages/AGENTS.md service form): the service
@@ -133,20 +139,11 @@ export function apply(ctx: Context): void {
 
   slots.register({
     name: 'conversation.empty',
+    children: { 'conversation.empty.workspace': { kind: 'single', scope: 'root' } },
     inject: (): EmptyStateInjected => ({
-      // ctx.get, not ctx.conversation: the service mounts on this plugin's
-      // own child fiber, so it is not in the inject topology the property
-      // proxy enforces; get reads the global store and stays loud on a torn
-      // boot through the optional-chain throw below.
-      startSession: (opts) => {
-        const conversation = ctx.get('conversation')
-        if (conversation === undefined) throw new Error('ui-conversation: conversation service unavailable')
-        return conversation.startSession(opts)
-      },
-      createWorkspaceSession: async (name) => {
-        const id = await sessions.createWorkspace(name)
-        sessions.open(id)
-      },
+      startSession: (workspaceId, prompt) => { workspaces.startSession(workspaceId, prompt) },
+      updateSessionPrompt: (text) => { sessions.updateIntent(text) },
+      sendSession: () => { workspaces.sendSession() },
     }),
   }, EmptyState)
 }

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

@@ -1,6 +1,7 @@
 /** Conversation slot declarations and their composed component props. */
+import type { RefObject } from 'react'
 import type { PropsRenderSlots, PropsRuntime, PropsStore } from '@deepseek-ai/dsh-client-ui-slots'
-import type { PendingInteraction, SessionId, ToolCallBlock } from '@deepseek-ai/dsh-client-runtime/client'
+import type { PendingInteraction, SessionId, ToolCallBlock, WorkspaceId } from '@deepseek-ai/dsh-client-runtime/client'
 import type { createChatStore } from '../stores.ts'
 import type { CallId, SelectionTarget, ViewTab } from './views.ts'
 
@@ -30,6 +31,8 @@ declare module '@deepseek-ai/dsh-client-ui-slots' {
      * zero owner changes.
      */
     'conversation.composer': { kind: 'chain'; scope: 'session'; owner: ComposerChainProps }
+    /** Shared Workspace picker hole used by the page-local Session Intent hero. */
+    'conversation.empty.workspace': { kind: 'single'; scope: 'root'; owner: EmptyWorkspaceOwnerProps }
   }
 }
 
@@ -94,7 +97,12 @@ export interface ConversationInjected {
   send(text: string, mode: 'queue' | 'steer'): void
   /** Cancel the in-flight turn (failure surfaces via snapshot.promptError). */
   stop(): void
-  open(id: SessionId): void
+  /** Select a real Session through the runtime navigation owner. */
+  open(sessionId: SessionId): void
+  /** Update the scoped Session's retained prompt. */
+  updateSessionPrompt(text: string): void
+  /** Retry the scoped Session's retained prompt. */
+  retrySessionPrompt(): void
 }
 
 /**
@@ -140,16 +148,24 @@ export interface 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. */
-export interface EmptyStateInjected {
-  /** The create → navigate → first-send chain, in one service call. */
-  startSession(opts: { cwd?: string; text: string; mode: 'queue' | 'steer' }): Promise<void>
-  /**
-   * Create a workspace folder under the host cwd, mint a session there, and
-   * open it (Create-new modal success path).
-   */
-  createWorkspaceSession(name: string): Promise<void>
+/** Owner share common to the empty hero's Workspace picker. */
+export interface EmptyWorkspaceOwnerProps {
+  open: boolean
+  anchorRef?: RefObject<HTMLElement>
+  onPick(workspaceId: WorkspaceId): void
+  onClose(): void
 }
 
-/** Full empty-state component props (root slot: no store; cwd options derive from useSessions in-component). */
-export type EmptyStateSlotProps = PropsRuntime<'conversation.empty'> & EmptyStateInjected
+/** Runtime-owned actions injected into the empty-state occupant. */
+export interface EmptyStateInjected {
+  /** Replace the current Session intent, optionally preserving a prompt while retargeting. */
+  startSession(workspaceId?: WorkspaceId, prompt?: string): void
+  /** Update the current Session intent's controlled prompt. */
+  updateSessionPrompt(text: string): void
+  /** Materialize and send the current Session intent. */
+  sendSession(): void
+}
+
+/** Full empty-state component props: runtime projections, picker child slot, and injected actions. */
+export type EmptyStateSlotProps =
+  PropsRuntime<'conversation.empty'> & PropsRenderSlots<'conversation.empty.workspace'> & EmptyStateInjected

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

@@ -15,7 +15,7 @@ export type { ToolCallBlock } from './contract/tool-call-model.ts'
 export type {
   ChatStore, ChatViewInjected, ChatViewSlotProps, ComposerChainProps, ConversationInjected,
   ConversationSlotProps, ConvViewOwnerProps, ConvViewProps, DetailsInjected, DetailsSlotProps,
-  EmptyStateInjected, EmptyStateSlotProps, ToolRowOwnerProps, ToolRowProps,
+  EmptyStateInjected, EmptyStateSlotProps, EmptyWorkspaceOwnerProps, ToolRowOwnerProps, ToolRowProps,
 } from './contract/slots.ts'
 // Export discipline: packages/client/AGENTS.md.
 

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

@@ -1,5 +1,5 @@
 /**
- * Scope-addressed conversation send, cancel, and empty-state session startup.
+ * Scope-addressed conversation send, cancel, history, and retained-prompt orchestration.
  *
  * Scope addressing rides the cordis Service tracker: property access through
  * `ctx.conversation` rebinds `this.ctx` to the caller's context, so methods
@@ -44,37 +44,27 @@ export class ConversationService extends Service {
     if (!result.ok) throw new Error(`conversation.cancel failed: ${result.error.code}: ${result.error.message}`)
   }
 
-  /**
-   * Empty-state first-send chain (root-context method; does not read scope):
-   * create the session, navigate to it, then send through the new scope.
-   * The create → open ordering is safe: the manager merges the new summary
-   * synchronously before create() resolves, so the list store is projected by
-   * the time open() validates against it (manager notification batching is
-   * microtask-based; SessionsService projects on the same flush that create
-   * awaited through the RPC round trip).
-   * @param opts - project directory, prompt text, and send mode.
-   */
-  async startSession(opts: { cwd?: string; text: string; mode: 'queue' | 'steer' }): Promise<void> {
-    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 sessions.open validates against it.
-    await Promise.resolve()
-    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
-    // topology (a scope fiber never injects services), while get reads the
-    // global store and still binds this service to the scoped ctx.
-    const scopedConversation = scoped.get('conversation')
-    if (scopedConversation === undefined) throw new Error('conversation.startSession: conversation service unavailable through the new scope')
-    await scopedConversation.send(opts.text, opts.mode)
+  /** Pull one older history page for the scoped Session. */
+  async loadOlder(): Promise<void> {
+    await this.scopedSession('loadOlder').loadOlder()
+  }
+
+  /** Update the scoped Session's retained pending prompt. */
+  updatePendingPrompt(text: string): void {
+    this.scopedSession('updatePendingPrompt').updatePendingPrompt(text)
+  }
+
+  /** Retry the scoped Session's retained pending prompt. */
+  retryPendingPrompt(): void {
+    this.scopedSession('retryPendingPrompt').retryPendingPrompt()
   }
 
   /** 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)
+    const binding = this.requireSessions().binding(id)
+    if (binding === undefined) throw new Error(`conversation.${op}: session "${id}" resolved no binding`)
+    return binding.session
   }
 
   /** Read the caller's session scope tag via the sessions service; root contexts fail loud. */

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

@@ -15,6 +15,7 @@ import type { SessionId, SessionListState, SessionSummary } from '@deepseek-ai/d
 import type { ConversationSlotProps } from '../contract/slots.ts'
 import { InputBar } from './InputBar.tsx'
 import type { InputBarError } from './InputBar.tsx'
+import { EmptyHero, WorkspaceChip, workspaceLabel } from './EmptyHero.tsx'
 import css from './ConversationRoot.module.css'
 
 /** Full props = the automatic shares & injected share — composed by reference
@@ -37,8 +38,8 @@ function deriveAncestry(list: SessionListState, id: SessionId): readonly Session
 }
 
 export function ConversationRoot({
-  sessionId, useSession, useSessions, useStore, actions, renderSlot, renderSlotChain,
-  views, send, stop, open,
+  sessionId, useSession, useSessions, useWorkspaces, useStore, actions, renderSlot, renderSlotChain,
+  views, send, stop, open, updateSessionPrompt, retrySessionPrompt,
 }: ConversationRootProps) {
   useSyncExternalStore(views.subscribe, views.version)
   const tabs = views.list()
@@ -48,16 +49,60 @@ export function ConversationRoot({
   const active = tabs.find(v => v.id === activeId) ?? tabs[0]
 
   const ancestry = useSessions(s => deriveAncestry(s, sessionId), shallowEqual)
-  const draft = useStore(s => s.draft)
-  const running = useSession(s => s.running)
+  const pendingPrompt = useSession(s => s.pendingPrompt ?? undefined)
+  const storedDraft = useStore(s => s.draft)
+  const draft = pendingPrompt?.text ?? storedDraft
+  const sessionRunning = useSession(s => s.running)
+  const running = sessionRunning || pendingPrompt?.phase === 'sending'
   const removed = useSession(s => s.removed)
   const promptError = useSession(s => s.promptError)
   const turns = useSession(s => countTurns(s))
   const pending = useSession(s => s.pending)
+  const openState = useSession(s => s.openState)
+  const composerPhase = useSession(s => s.composerPhase)
+  const cwd = useSessions(s => s.byId[sessionId]?.cwd)
+  const workspaceTitle = useWorkspaces(state =>
+    state.items.find(workspace => workspace.sessionIds.includes(sessionId))?.title)
+  const error: InputBarError | null = pendingPrompt?.error !== undefined
+    ? {
+        op: pendingPrompt.retry === 'connect' ? 'session' : 'send',
+        message: pendingPrompt.retry === 'connect'
+          ? `Workspace attach failed: ${pendingPrompt.error}`
+          : `Message send failed: ${pendingPrompt.error}`,
+      }
+    : promptError === null
+      ? null
+      : { op: promptError.op, message: `${promptError.error.message} (${promptError.error.code})` }
+  const status = pendingPrompt?.phase === 'sending'
+    ? pendingPrompt.retry === 'connect' ? 'Attaching session to workspace…' : 'Sending message…'
+    : undefined
+  const setDraft = (text: string): void => {
+    if (pendingPrompt === undefined) actions.setDraft(text)
+    else updateSessionPrompt(text)
+  }
+  const submit = (mode: 'queue' | 'steer'): void => {
+    if (pendingPrompt === undefined) send(draft, mode)
+    else retrySessionPrompt()
+  }
 
-  const error: InputBarError | null = promptError === null
-    ? null
-    : { op: promptError.op, message: `${promptError.error.message}（${promptError.error.code}）` }
+  // Blank-session guidance: phase-derived (the runtime snapshot owns the
+  // predicate — see ComposerPhase). Only `blank` renders the hero; `engaging`
+  // and `active` fall through to the conversation view, so an in-flight
+  // first send never bounces back here. Gated on the OPEN window: phase has
+  // no jurisdiction over loading/error frames (ChatView renders those).
+  if (openState === 'open' && composerPhase === 'blank') {
+    return (
+      <EmptyHero
+        workspaceRow={<WorkspaceChip label={workspaceTitle ?? workspaceLabel(cwd ?? '')} locked />}
+        draft={draft}
+        disabled={removed || pendingPrompt?.phase === 'sending'}
+        error={error}
+        {...(status === undefined ? {} : { status })}
+        onDraftChange={setDraft}
+        onSend={submit}
+      />
+    )
+  }
 
   // The default composer doubles as the chain's all-decline fallback: a
   // pending wait with no registered takeover must still leave the input usable.
@@ -67,9 +112,10 @@ export function ConversationRoot({
       running={running}
       disabled={removed}
       error={error}
+      {...(status === undefined ? {} : { status })}
       variant="composer"
-      onDraftChange={actions.setDraft}
-      onSend={(mode) => { send(draft, mode) }}
+      onDraftChange={setDraft}
+      onSend={submit}
       onStop={stop}
     />
   )
@@ -78,7 +124,7 @@ export function ConversationRoot({
     <div className={css.root}>
       <header className={css.header}>
         <div className={css.crumbRow}>
-          <nav className={css.crumbs} aria-label="会话层级">
+          <nav className={css.crumbs} aria-label="Session hierarchy">
             {ancestry.map((s, i) => {
               const last = i === ancestry.length - 1
               return (

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

@@ -0,0 +1,153 @@
+// EmptyHero: the shared NEW SESSION hero (fish headline + glow + workspace
+// row + hero InputBar), extracted from EmptyState so the bound guidance
+// state (a current session with zero messages, ConversationRoot) renders the
+// same layout without the picker wiring. Hosts own the workspace-row content
+// and the send wiring; modals ride `children` after the stack.
+
+import { useId } from 'react'
+import type { ReactNode, RefObject } from 'react'
+import {
+  FishLogo, IconChevronDownOutline14, IconFolderOpen16,
+} from '@deepseek-ai/dsh-client-ui-primitives'
+import { workspaceTitleOf } from '@deepseek-ai/dsh-client-runtime/client'
+import { InputBar } from './InputBar.tsx'
+import type { InputBarError } from './InputBar.tsx'
+import css from './EmptyState.module.css'
+
+/**
+ * Basename label for the workspace chip / menu rows (the shared derivation);
+ * empty → the design's "New Workspace" placeholder copy; separator-only
+ * paths echo the raw cwd.
+ * @param cwd - workspace directory path ('' for none).
+ * @returns chip label.
+ */
+export function workspaceLabel(cwd: string): string {
+  if (cwd === '') return 'New Workspace'
+  const base = workspaceTitleOf(cwd)
+  return base !== '' ? base : cwd
+}
+
+/**
+ * The workspace chip (folder + label + chevron). Locked form (bound guidance
+ * state): no chevron, no menu affordance, clicks disabled — the bound
+ * session's cwd is final.
+ * @param props.label - chip label (see {@link workspaceLabel}).
+ * @param props.locked - read-only echo form.
+ * @param props.menuOpen - menu expansion echo (interactive form only).
+ * @param props.onClick - menu toggle (interactive form only).
+ * @returns the chip button element.
+ */
+export function WorkspaceChip({ buttonRef, label, locked = false, menuOpen = false, onClick }: {
+  buttonRef?: RefObject<HTMLButtonElement>
+  label: string
+  locked?: boolean
+  menuOpen?: boolean
+  onClick?: () => void
+}) {
+  return (
+    <button
+      ref={buttonRef}
+      type="button"
+      className={css.workspace}
+      aria-label={locked ? 'Current workspace' : 'Choose workspace'}
+      {...(locked ? {} : { 'aria-haspopup': 'menu' as const, 'aria-expanded': menuOpen })}
+      disabled={locked}
+      onClick={onClick}
+    >
+      <IconFolderOpen16 className={css.folder} size={16} />
+      <span className={css.workspaceLabel}>{label}</span>
+      {!locked && <IconChevronDownOutline14 className={css.chevron} size={12} />}
+    </button>
+  )
+}
+
+/** Hero-card props: both hosts supply the workspace row and their send wiring. */
+export interface EmptyHeroProps {
+  /** Workspace-row content (Menu-wrapped chip in EmptyState; bare locked chip in guidance). */
+  workspaceRow: ReactNode
+  draft: string
+  disabled: boolean
+  /** Composer placeholder override (EmptyState's pick-a-workspace hint); defaults to the hero copy. */
+  placeholder?: string
+  error: InputBarError | null
+  status?: string
+  onDraftChange: (text: string) => void
+  onSend: (mode: 'queue' | 'steer') => void
+  onAdd?: () => void
+  /** Overlay content after the stack (EmptyState's modals). */
+  children?: ReactNode
+}
+
+/**
+ * Render the hero card.
+ * @param props - see {@link EmptyHeroProps}.
+ * @returns the centered hero element tree.
+ */
+export function EmptyHero({
+  workspaceRow,
+  draft,
+  disabled,
+  placeholder,
+  error,
+  status,
+  onDraftChange,
+  onSend,
+  onAdd,
+  children,
+}: EmptyHeroProps) {
+  // Stable filter id so multiple hero mounts do not collide in the DOM.
+  const glowFilterId = `empty-glow-${useId().replace(/:/g, '')}`
+  return (
+    <div className={css.root}>
+      <div className={css.stack}>
+        <div className={css.headline}>
+          {/* figma 34:10412: fish 34×25 leading the headline, gap 10. */}
+          <FishLogo size={34} className={css.fish} />
+          Let&apos;s start building
+        </div>
+        <div className={css.body}>
+          {/* figma 313:14109: soft ellipse behind workspace + InputBar; width
+              tracks the card (glow asset 1051 vs design card 776) so blur
+              scales in userSpace with it. */}
+          <svg className={css.glow} viewBox="0 0 1051 468" fill="none" aria-hidden="true">
+            <defs>
+              <filter
+                id={glowFilterId}
+                x="0"
+                y="0"
+                width="1051"
+                height="468"
+                filterUnits="userSpaceOnUse"
+                colorInterpolationFilters="sRGB"
+              >
+                <feFlood floodOpacity="0" result="BackgroundImageFix" />
+                <feBlend mode="normal" in="SourceGraphic" in2="BackgroundImageFix" result="shape" />
+                <feGaussianBlur stdDeviation="50" result="effect1_foregroundBlur" />
+              </filter>
+            </defs>
+            <g filter={`url(#${glowFilterId})`}>
+              <ellipse cx="525.5" cy="234" rx="425.5" ry="134" fill="#6187D8" fillOpacity="0.1" />
+            </g>
+          </svg>
+          <div className={css.workspaceRow}>{workspaceRow}</div>
+          <InputBar
+            draft={draft}
+            running={false}
+            disabled={disabled}
+            error={error}
+            {...(status === undefined ? {} : { status })}
+            variant="hero"
+            placeholder={placeholder ?? 'Describe what you want to build'}
+            onDraftChange={onDraftChange}
+            onSend={onSend}
+            {...(onAdd === undefined ? {} : { onAdd })}
+            addLabel="Create workspace"
+            /* v8 ignore next -- structural noop: hero never passes running=true, so stop is unreachable. */
+            onStop={() => {}}
+          />
+        </div>
+      </div>
+      {children}
+    </div>
+  )
+}

packages/client/ui-conversation/src/client/skeleton/EmptyState.module.css

@@ -100,11 +100,17 @@
   cursor: pointer;
 }
 
-.workspace:hover,
+.workspace:not(:disabled):hover,
 .workspace[aria-expanded='true'] {
   background: var(--dsw-alias-interactive-bg-hover);
 }
 
+/* Locked form (bound guidance state): a static echo — no hover feedback, no
+   pointer affordance; label keeps full contrast. */
+.workspace:disabled {
+  cursor: default;
+}
+
 .folder {
   flex: none;
   color: var(--dsw-alias-label-primary);
@@ -121,22 +127,21 @@
   color: var(--dsw-alias-label-caption);
 }
 
-/* Workspace menu width tracks the longest basename in the Figma frame. */
-.workspaceMenu :global([role='menu']) {
-  min-width: 240px;
-}
-
-/* Dialog field (figma 451:18655 Input): h44, r22, px 14, caption placeholder. */
+/* Dialog field: 44 tall on the modal's 332 content column, r22, hairline
+   border, pad 14/7, 14/22 wt400 primary text, caption placeholder. Focus
+   keeps the resting border (design shows no focus ring). */
 .modalInput {
+  box-sizing: border-box;
   width: 100%;
   height: 44px;
-  padding: 0 14px;
+  padding: 7px 14px;
   border: 1px solid var(--dsw-alias-border-l2);
   border-radius: 22px;
   outline: none;
   background: transparent;
   font-size: 14px;
-  line-height: 24px;
+  font-weight: 400;
+  line-height: 22px;
   color: var(--dsw-alias-label-primary);
 }
 
@@ -144,10 +149,6 @@
   color: var(--dsw-alias-label-caption);
 }
 
-.modalInput:focus {
-  border-color: var(--dsw-alias-state-business-primary);
-}
-
 .modalInput:disabled {
   color: var(--dsw-alias-label-dimmed);
 }

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

@@ -1,305 +1,78 @@
-// EmptyState (figma NEW SESSION screen): centered hero — fish + title,
-// workspace picker row (MenuDropdown 122:9481 + New Workspace submenu
-// 419:16920 + Dialog 451:18655), then the SAME InputBar the resident
-// composer uses (empty→content is a position move, never a swap). Project
-// options derive in-component from useSessions; Create new runs
-// createWorkspaceSession (host mkdir + session.create + open).
-
-import { useId, useMemo, useState } from 'react'
-import {
-  Button,
-  FishLogo,
-  IconChevronDownOutline14,
-  IconFolderClose16,
-  IconFolderOpen16,
-  IconPlusOutline16,
-  Menu,
-  Modal,
-  type MenuEntry,
-} from '@deepseek-ai/dsh-client-ui-primitives'
-import type { SessionListState } from '@deepseek-ai/dsh-client-runtime/client'
+/** Page-local Session Intent hero. */
+import { useRef, useState } from 'react'
 import type { EmptyStateSlotProps } from '../contract/slots.ts'
-import { InputBar } from './InputBar.tsx'
 import type { InputBarError } from './InputBar.tsx'
-import css from './EmptyState.module.css'
+import { EmptyHero, WorkspaceChip } from './EmptyHero.tsx'
 
-/** Menu id for "New Workspace" (opens submenu; not a cwd). */
-const NEW_WORKSPACE = '::new-workspace'
-/** Submenu: path modal (figma 451:18655 copy). */
-const USE_EXISTING = '::use-existing'
-/** Submenu: create-workspace modal → mkdir + default session. */
-const CREATE_NEW = '::create-new'
-
-/** Which full-page dialog is open (null = none). */
-type ModalKind = 'path' | 'create' | null
-
-/** Full props composed by reference from the contract (runtime share & injected share; no store). */
+/** Full props composed from runtime projections, injected actions, and the declared picker slot. */
 export type EmptyStateProps = EmptyStateSlotProps
 
-/** 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,
+  useWorkspaces,
+  startSession,
+  updateSessionPrompt,
+  sendSession,
+  renderSlot,
+}: EmptyStateProps) {
+  const intent = useSessions(state => state.intent)
+  const workspaceSnapshot = useWorkspaces(state => state)
+  const workspaces = workspaceSnapshot.items
+  const [pickerOpen, setPickerOpen] = useState(false)
+  const pickerAnchor = useRef<HTMLButtonElement>(null)
+  if (intent === undefined) return null
+  const workspaceId = intent.target.kind === 'workspace' ? intent.target.workspaceId : undefined
+  const workspace = workspaceId === undefined
+    ? undefined
+    : workspaces.find(item => item.workspaceId === workspaceId)
+  const workspaceLabel = intent.target.kind === 'workspace-intent'
+    ? workspaceSnapshot.intent?.name ?? 'Workspace unavailable'
+    : workspace?.title ?? 'Workspace unavailable'
+  const workspaceIntent = workspaceSnapshot.intent
+  const busy = intent.phase === 'connecting' || workspaceIntent?.phase === 'creating'
+  const status = workspaceIntent?.phase === 'creating'
+    ? 'Creating workspace…'
+    : intent.phase === 'connecting'
+      ? 'Creating session…'
+      : workspaceSnapshot.phase === 'pending'
+        ? 'Loading workspaces…'
+        : undefined
+  const error: InputBarError | null = workspaceIntent?.error !== undefined
+    ? { op: 'workspace', message: `Workspace creation failed: ${workspaceIntent.error}` }
+    : intent.error === undefined
+      ? null
+      : { op: 'session', message: `Session creation failed: ${intent.error.message}` }
 
-/** Basename for the workspace chip / menu row; empty → the design's "New Workspace" label. */
-function workspaceLabel(cwd: string): string {
-  if (cwd === '') return 'New Workspace'
-  const base = cwd.replace(/[/\\]+$/, '').split(/[/\\]/).pop()
-  return base !== undefined && base !== '' ? base : cwd
-}
-
-export function EmptyState({ useSessions, startSession, createWorkspaceSession }: 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('')
-  const [cwd, setCwd] = useState('')
-  const [menuOpen, setMenuOpen] = useState(false)
-  const [modalKind, setModalKind] = useState<ModalKind>(null)
-  const [pathDraft, setPathDraft] = useState('')
-  const [workspaceName, setWorkspaceName] = useState('New WorkSpace')
-  const [creating, setCreating] = useState(false)
-  const [modalError, setModalError] = useState<string | null>(null)
-  const [sending, setSending] = useState(false)
-  const [error, setError] = useState<InputBarError | null>(null)
-  // Stable filter id so multiple EmptyState mounts do not collide in the DOM.
-  const glowFilterId = `empty-glow-${useId().replace(/:/g, '')}`
-
-  const submit = (mode: 'queue' | 'steer'): void => {
-    const text = draft.trim()
-    /* v8 ignore next -- defensive: InputBar disables send while empty. */
-    if (text === '' || sending) return
-    setSending(true)
-    setError(null)
-    const chosen = cwd.trim()
-    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: the session selection swaps this slot out for the session body.
-  }
-
-  const items: MenuEntry[] = [
-    ...cwds.map(c => ({
-      id: c,
-      label: workspaceLabel(c),
-      icon: <IconFolderClose16 size={16} />,
-    })),
-    ...(cwds.length > 0 ? [{ type: 'separator' as const, id: 'sep-new' }] : []),
-    {
-      id: NEW_WORKSPACE,
-      label: 'New Workspace',
-      icon: <IconPlusOutline16 size={16} />,
-      submenu: [
-        { id: USE_EXISTING, label: 'Use a existing folder' },
-        { id: CREATE_NEW, label: 'Create new' },
-      ],
-    },
-  ]
-
-  const closeModal = (): void => {
-    if (creating) return
-    setModalKind(null)
-    setModalError(null)
-  }
-
-  const openPathModal = (): void => {
-    setPathDraft(cwd)
-    setModalError(null)
-    setModalKind('path')
-  }
-
-  const openCreateModal = (): void => {
-    setWorkspaceName('New WorkSpace')
-    setModalError(null)
-    setModalKind('create')
-  }
-
-  const confirmPath = (): void => {
-    const next = pathDraft.trim()
-    if (next === '') return
-    setCwd(next)
-    setModalKind(null)
-  }
-
-  const confirmCreate = (): void => {
-    if (creating) return
-    setCreating(true)
-    setModalError(null)
-    createWorkspaceSession(workspaceName)
-      .catch((reason: unknown) => {
-        setModalError(reason instanceof Error ? reason.message : String(reason))
-        setCreating(false)
-      })
-    // Success swaps this slot out for the new session body — no local cleanup.
-  }
-
-  const modalBusy = creating
-  const isPath = modalKind === 'path'
-  const isCreate = modalKind === 'create'
+  const workspaceRow = (
+    <>
+      <WorkspaceChip
+        buttonRef={pickerAnchor}
+        label={workspaceLabel}
+        menuOpen={pickerOpen}
+        onClick={() => { setPickerOpen(open => !open) }}
+      />
+      {renderSlot('conversation.empty.workspace', {
+        open: pickerOpen,
+        anchorRef: pickerAnchor,
+        onPick: (workspaceId) => {
+          setPickerOpen(false)
+          startSession(workspaceId, intent.prompt)
+        },
+        onClose: () => { setPickerOpen(false) },
+      })}
+    </>
+  )
 
   return (
-    <div className={css.root}>
-      <div className={css.stack}>
-        <div className={css.headline}>
-          {/* figma 34:10412: fish 34×25 leading the headline, gap 10. */}
-          <FishLogo size={34} className={css.fish} />
-          Let&apos;s start building
-        </div>
-        <div className={css.body}>
-          {/* figma 313:14109: soft ellipse behind workspace + InputBar; width
-              tracks the card (glow asset 1051 vs design card 776) so blur
-              scales in userSpace with it. */}
-          <svg className={css.glow} viewBox="0 0 1051 468" fill="none" aria-hidden="true">
-            <defs>
-              <filter
-                id={glowFilterId}
-                x="0"
-                y="0"
-                width="1051"
-                height="468"
-                filterUnits="userSpaceOnUse"
-                colorInterpolationFilters="sRGB"
-              >
-                <feFlood floodOpacity="0" result="BackgroundImageFix" />
-                <feBlend mode="normal" in="SourceGraphic" in2="BackgroundImageFix" result="shape" />
-                <feGaussianBlur stdDeviation="50" result="effect1_foregroundBlur" />
-              </filter>
-            </defs>
-            <g filter={`url(#${glowFilterId})`}>
-              <ellipse cx="525.5" cy="234" rx="425.5" ry="134" fill="#6187D8" fillOpacity="0.1" />
-            </g>
-          </svg>
-          <div className={css.workspaceRow}>
-            <Menu
-              open={menuOpen}
-              onClose={() => { setMenuOpen(false) }}
-              {...(cwd !== '' ? { selectedId: cwd } : {})}
-              items={items}
-              side="top"
-              className={css.workspaceMenu!}
-              onSelect={(id) => {
-                if (id === USE_EXISTING) {
-                  setMenuOpen(false)
-                  openPathModal()
-                  return
-                }
-                if (id === CREATE_NEW) {
-                  setMenuOpen(false)
-                  openCreateModal()
-                  return
-                }
-                setCwd(id)
-                setMenuOpen(false)
-              }}
-              anchor={(
-                <button
-                  type="button"
-                  className={css.workspace}
-                  aria-label="项目目录"
-                  aria-haspopup="menu"
-                  aria-expanded={menuOpen}
-                  onClick={() => { setMenuOpen(!menuOpen) }}
-                >
-                  <IconFolderOpen16 className={css.folder} size={16} />
-                  <span className={css.workspaceLabel}>{workspaceLabel(cwd)}</span>
-                  <IconChevronDownOutline14 className={css.chevron} size={12} />
-                </button>
-              )}
-            />
-          </div>
-          <InputBar
-            draft={draft}
-            running={false}
-            disabled={sending}
-            error={error}
-            variant="hero"
-            placeholder="Message to run task, plan and build, enter for / commands"
-            onDraftChange={setDraft}
-            onSend={submit}
-            /* v8 ignore next -- structural noop: hero never passes running=true, so stop is unreachable. */
-            onStop={() => {}}
-          />
-        </div>
-      </div>
-      <Modal
-        open={isPath}
-        onClose={closeModal}
-        title="Enter an existing folder path"
-        footer={(
-          <>
-            <Button variant="outline" className={css.modalAction!} onClick={closeModal}>Cancel</Button>
-            <Button
-              variant="primary"
-              className={css.modalAction!}
-              disabled={pathDraft.trim() === ''}
-              onClick={confirmPath}
-            >
-              Open Folder
-            </Button>
-          </>
-        )}
-      >
-        <input
-          className={css.modalInput}
-          value={pathDraft}
-          aria-label="Folder path"
-          autoFocus
-          placeholder="ex. User/Documents/Harness/Space"
-          onChange={(e) => { setPathDraft(e.target.value) }}
-          onKeyDown={(e) => {
-            if (e.key === 'Enter') {
-              e.preventDefault()
-              confirmPath()
-            }
-          }}
-        />
-      </Modal>
-      <Modal
-        open={isCreate}
-        onClose={closeModal}
-        title="Create new workspace"
-        footer={(
-          <>
-            <Button variant="outline" className={css.modalAction!} disabled={modalBusy} onClick={closeModal}>
-              Cancel
-            </Button>
-            <Button
-              variant="primary"
-              className={css.modalAction!}
-              disabled={modalBusy || workspaceName.trim() === ''}
-              onClick={confirmCreate}
-            >
-              Create
-            </Button>
-          </>
-        )}
-      >
-        <input
-          className={css.modalInput}
-          value={workspaceName}
-          aria-label="Workspace name"
-          autoFocus
-          disabled={modalBusy}
-          onChange={(e) => { setWorkspaceName(e.target.value) }}
-          onKeyDown={(e) => {
-            if (e.key === 'Enter') {
-              e.preventDefault()
-              confirmCreate()
-            }
-          }}
-        />
-        {modalError !== null && <div className={css.modalError} role="alert">{modalError}</div>}
-      </Modal>
-    </div>
+    <EmptyHero
+      workspaceRow={workspaceRow}
+      draft={intent.prompt}
+      disabled={busy}
+      {...(status === undefined ? {} : { status })}
+      error={error}
+      onDraftChange={updateSessionPrompt}
+      onSend={() => { sendSession() }}
+      onAdd={() => { setPickerOpen(true) }}
+    />
   )
 }

packages/client/ui-conversation/src/client/skeleton/InputBar.module.css

@@ -19,18 +19,27 @@
   padding: 0;
 }
 
-.error {
+.error,
+.status {
   width: 100%;
   max-width: 800px;
   margin-bottom: 6px;
   padding: 4px 8px;
   border-radius: 8px;
-  background: var(--dsw-alias-interactive-bg-hover-danger);
-  color: var(--dsw-alias-state-error-primary);
   font-size: 12px;
   line-height: 18px;
 }
 
+.status {
+  background: var(--dsw-alias-interactive-bg-hover);
+  color: var(--dsw-alias-label-secondary);
+}
+
+.error {
+  background: var(--dsw-alias-interactive-bg-hover-danger);
+  color: var(--dsw-alias-state-error-primary);
+}
+
 .card {
   display: flex;
   flex-direction: column;

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

@@ -9,7 +9,7 @@ import css from './InputBar.module.css'
 
 /** Prompt failure surface (mirrors the session snapshot's promptError shape). */
 export interface InputBarError {
-  op: 'send' | 'stop'
+  op: 'workspace' | 'session' | 'send' | 'stop'
   message: string
 }
 
@@ -18,12 +18,17 @@ export interface InputBarProps {
   running: boolean
   disabled: boolean
   error: InputBarError | null
+  /** Observable async phase for browser fixtures and assistive technology. */
+  status?: string
+  /** Hero = empty-state centered card; composer = resident bottom bar. */
   variant: 'hero' | 'composer'
   placeholder?: string
   accessory?: ReactNode
   onDraftChange: (text: string) => void
   onSend: (mode: 'queue' | 'steer') => void
   onStop: () => void
+  onAdd?: () => void
+  addLabel?: string
 }
 
 interface SelectOption {
@@ -47,7 +52,8 @@ const MODEL_OPTIONS: readonly SelectOption[] = [
 ]
 
 export function InputBar({
-  draft, running, disabled, error, variant, placeholder, accessory, onDraftChange, onSend, onStop,
+  draft, running, disabled, error, status, variant, placeholder, accessory,
+  onDraftChange, onSend, onStop, onAdd, addLabel = 'Add attachment',
 }: InputBarProps) {
   const empty = draft.trim() === ''
   const inputRef = useRef<HTMLTextAreaElement | null>(null)
@@ -98,7 +104,7 @@ export function InputBar({
     inputRef.current?.focus()
   }
 
-  const primaryLabel = running ? '停止' : '发送'
+  const primaryLabel = running ? 'Stop generating' : 'Send message'
   const onPrimary = (): void => {
     if (running) {
       onStop()
@@ -129,11 +135,8 @@ export function InputBar({
 
   return (
     <div className={clsx(css.root, variant === 'hero' && css.hero)}>
-      {error !== null && (
-        <div className={css.error}>
-          {error.op === 'stop' ? '停止失败' : '发送失败'}：{error.message}
-        </div>
-      )}
+      {status !== undefined && <div className={css.status} role="status">{status}</div>}
+      {error !== null && <div className={css.error} role="alert">{error.message}</div>}
       <div className={css.card}>
         {accessory !== undefined && <div className={css.accessory}>{accessory}</div>}
         {/* Mirror-div auto-grow: the hidden mirror renders draft+'\n' and stretches the wrapper
@@ -145,7 +148,7 @@ export function InputBar({
             className={css.input}
             value={draft}
             disabled={locked}
-            placeholder={placeholder ?? (disabled ? '会话不可用' : running ? '回复生成中，可停止后再输入' : '输入消息，Enter 发送，Shift+Enter 换行')}
+            placeholder={placeholder ?? (disabled ? 'Session unavailable' : running ? 'Generating a response…' : 'Message the agent')}
             rows={2}
             onChange={(e) => onDraftChange(e.target.value)}
             onKeyDown={onKeyDown}
@@ -159,10 +162,11 @@ export function InputBar({
             <button
               type="button"
               className={css.add}
-              aria-label="添加"
-              title="添加"
+              aria-label={addLabel}
+              title={addLabel}
               disabled={locked}
               onMouseDown={keepFocus}
+              onClick={onAdd}
             >
               <IconPlusOutline16 size={14} />
             </button>
@@ -177,7 +181,7 @@ export function InputBar({
               type="button"
               className={clsx(css.primary, running && css.stopping)}
               aria-label={primaryLabel}
-              title={running ? '停止本轮' : '发送（Enter）'}
+              title={primaryLabel}
               disabled={!running && (empty || disabled)}
               onMouseDown={keepFocus}
               onClick={onPrimary}

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

@@ -3,8 +3,8 @@
 // shape: the conversation surface (views triple, send choreography incl.
 // optimistic clear + failure restore THROUGH the declared store actions,
 // openDetails = select action + layout orchestration, sessions.open
-// navigation), the injectless-but-closeDetails details surface, and the
-// one-callback empty surface. Complements chat-apply.spec.tsx (registration)
+// navigation), and the closeDetails details surface. Complements
+// chat-apply.spec.tsx (registration)
 // and selection-survival.spec.ts (store axis). History opening is NOT an
 // inject concern anymore — the runtime sessions service opens on watch
 // (sessions-service.spec.ts owns that behavior).
@@ -14,9 +14,11 @@ import { afterEach, describe, expect, it, vi } from 'vitest'
 import { cleanup } from '@testing-library/react'
 import { createSnapshotStore } from '@deepseek-ai/dsh-client-runtime/client'
 import { SlotsService, scopeOf } from '@deepseek-ai/dsh-client-runtime/client'
-import type { SessionId, SessionListState } from '@deepseek-ai/dsh-client-runtime/client'
+import type {
+  SessionId, SessionListState, WorkspaceListState,
+} from '@deepseek-ai/dsh-client-runtime/client'
 import type { SlotRendererHost } from '@deepseek-ai/dsh-client-web-react'
-import { ConversationService, apply, inject } from '@deepseek-ai/dsh-client-ui-conversation/client'
+import { apply, inject } from '@deepseek-ai/dsh-client-ui-conversation/client'
 import type {
   ChatViewInjected, ConversationInjected, DetailsInjected, EmptyStateInjected,
 } from '@deepseek-ai/dsh-client-ui-conversation/client'
@@ -53,10 +55,14 @@ async function bench() {
     ids: [ROOT],
     byId: { [ROOT]: { id: ROOT, title: 'R', displayTitle: 'R', cwd: '/proj', running: false, updatedAt: 1 } },
     current: ROOT,
-  } as SessionListState)
+    intent: undefined,
+    phase: 'ready',
+  })
   const sessionFake = {
     open: vi.fn(() => Promise.resolve()),
     loadOlder: vi.fn(() => Promise.resolve()),
+    updatePendingPrompt: vi.fn(),
+    retryPendingPrompt: vi.fn(),
     prompt: vi.fn<() => Promise<{ ok: boolean; value?: object; error?: { code: string; message: string } }>>(
       () => Promise.resolve({ ok: true, value: { accepted: true } })),
     cancel: vi.fn<() => Promise<{ ok: boolean; value?: object; error?: { code: string; message: string } }>>(
@@ -73,15 +79,24 @@ async function bench() {
   }
   const sessionsFake = {
     list: listStore,
-    manager: { get: () => sessionFake },
+    binding: (id: SessionId) => ({ sessionId: id, session: sessionFake, ctx: mint(id) }),
     scope: (id: SessionId) => mint(id),
     cell: () => undefined,
     scopeOf,
-    create: vi.fn(() => Promise.resolve(ROOT)),
-    createWorkspace: vi.fn(() => Promise.resolve(ROOT)),
     open: vi.fn(),
+    updateIntent: vi.fn(),
   }
   ctx.provide('sessions', sessionsFake)
+  const workspaceStore = createSnapshotStore<WorkspaceListState>({
+    items: [], intent: undefined, state: 'idle', phase: 'ready', error: null,
+    baselinesReady: true, recentWorkspaceId: undefined,
+  })
+  const workspacesFake = {
+    list: workspaceStore,
+    startSession: vi.fn(),
+    sendSession: vi.fn(),
+  }
+  ctx.provide('workspaces', workspacesFake)
   const layoutFake = { openDetails: vi.fn(), closeDetails: vi.fn() }
   ctx.provide('layout', layoutFake)
   ctx.provide('i18n', { bind: () => (key: string) => key })
@@ -124,19 +139,25 @@ async function bench() {
       id, instance.actions)
     return { instance, injected }
   }
-  return { ctx, slots, hostFace, entryOf, conversationSurface, chatViewSurface, sessionFake, sessionsFake, layoutFake, mint }
+  const emptySurface = () => {
+    const entry = entryOf('conversation.empty')
+    return (entry.inject as unknown as () => EmptyStateInjected)()
+  }
+  return {
+    ctx, slots, hostFace, entryOf, conversationSurface, chatViewSurface, emptySurface,
+    sessionFake, sessionsFake, workspacesFake, layoutFake, mint,
+  }
 }
 
 describe('conversation slot inject surface', () => {
-  it('assembles the thin surface side-effect-free, navigates via sessions.open', async () => {
+  it('assembles the thin surface side-effect-free', async () => {
     const b = await bench()
     const { injected } = b.conversationSurface(ROOT)
     // Assembly has no session side effects: opening the event window belongs
     // to the runtime watch path, not the inject factory.
     expect(b.sessionFake.open).not.toHaveBeenCalled()
     expect(injected.views.list().map(v => v.id)).toEqual(['chat'])
-    injected.open(ROOT)
-    expect(b.sessionsFake.open).toHaveBeenCalledWith(ROOT)
+
     const chatView = b.chatViewSurface(ROOT)
     chatView.injected.loadOlder()
     expect(b.sessionFake.loadOlder).toHaveBeenCalledTimes(1)
@@ -202,6 +223,17 @@ describe('conversation slot inject surface', () => {
     expect(conv.instance).toBe(instance)
   })
 
+  it('routes navigation through SessionsService and the retained prompt through the scoped Session', async () => {
+    const b = await bench()
+    const { injected } = b.conversationSurface(ROOT)
+    injected.open(ROOT)
+    injected.updateSessionPrompt('revised')
+    injected.retrySessionPrompt()
+    expect(b.sessionsFake.open).toHaveBeenCalledWith(ROOT)
+    expect(b.sessionFake.updatePendingPrompt).toHaveBeenCalledWith('revised')
+    expect(b.sessionFake.retryPendingPrompt).toHaveBeenCalledOnce()
+  })
+
   it('views read face projects the ring ledger (subscribe/version through ctx.slots)', async () => {
     const b = await bench()
     const { injected } = b.conversationSurface(ROOT)
@@ -225,7 +257,7 @@ describe('conversation slot inject surface', () => {
   })
 })
 
-describe('details and empty inject surfaces', () => {
+describe('details inject surface', () => {
   it('details injects the one layout callback; selection rides the shared store instead', async () => {
     const b = await bench()
     const entry = b.entryOf('details')
@@ -239,29 +271,18 @@ describe('details and empty inject surfaces', () => {
     expect(details).toBe(conv)
   })
 
-  it('empty injects startSession and createWorkspaceSession (no store, cwds derive in-component)', async () => {
+  it('empty state injects the runtime intent actions and remains storeless', async () => {
     const b = await bench()
     const entry = b.entryOf('conversation.empty')
     expect(entry.store).toBeUndefined()
-    const injected = (entry.inject as unknown as () => EmptyStateInjected)()
-    expect(Object.keys(injected).sort()).toEqual(['createWorkspaceSession', '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')
-    b.sessionsFake.open.mockClear()
-    await injected.createWorkspaceSession('Fresh')
-    expect(b.sessionsFake.createWorkspace).toHaveBeenCalledWith('Fresh')
-    expect(b.sessionsFake.open).toHaveBeenCalledWith(ROOT)
-  })
-
-  it('startSession fails loud on a torn boot (conversation service fiber gone)', async () => {
-    const b = await bench()
-    const injected = (b.entryOf('conversation.empty').inject as unknown as () => EmptyStateInjected)()
-    // Tear the service's own fiber (registry keyed by the class): the slot
-    // entries survive, so the gesture-time read hits the loud branch.
-    b.ctx.registry.delete(ConversationService)
-    await vi.waitFor(() => { expect(b.ctx.get('conversation')).toBeUndefined() })
-    expect(() => injected.startSession({ text: 'go', mode: 'queue' })).toThrow(/conversation service unavailable/)
+    const injected = b.emptySurface()
+    injected.startSession(undefined, 'fresh')
+    injected.startSession('workspace-1' as never, 'retargeted')
+    injected.updateSessionPrompt('typed')
+    injected.sendSession()
+    expect(b.workspacesFake.startSession).toHaveBeenNthCalledWith(1, undefined, 'fresh')
+    expect(b.workspacesFake.startSession).toHaveBeenNthCalledWith(2, 'workspace-1', 'retargeted')
+    expect(b.sessionsFake.updateIntent).toHaveBeenCalledWith('typed')
+    expect(b.workspacesFake.sendSession).toHaveBeenCalledOnce()
   })
 })

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

@@ -30,16 +30,23 @@ async function bench() {
       [CHILD]: { id: CHILD, title: 'C', displayTitle: 'C', parentId: ROOT, running: false, updatedAt: 2 },
     },
     current: undefined,
+    intent: undefined,
+    phase: 'ready',
   } as SessionListState)
   const sessionsFake = {
     list: listStore,
-    manager: { get: vi.fn() },
+    binding: vi.fn(),
     scope: () => undefined,
     cell: () => undefined,
     create: vi.fn(),
     open: vi.fn(),
+    updateIntent: vi.fn(),
   }
   ctx.provide('sessions', sessionsFake)
+  ctx.provide('workspaces', {
+    startSession: vi.fn(),
+    sendSession: vi.fn(),
+  })
   ctx.provide('layout', { openDetails: vi.fn(), closeDetails: vi.fn() })
   ctx.provide('i18n', { bind: () => (key: string) => key })
 
@@ -84,7 +91,7 @@ describe('apply wiring', () => {
     expect(b.slots.spec('conversation.chat.toolview')).toEqual({ kind: 'keyed', scope: 'session' })
   })
 
-  it('occupies the three slots + the ring; session entries share one store handle, empty declares none', async () => {
+  it('occupies the three slots + the ring; session entries share one store handle, empty injects runtime actions', async () => {
     const b = await bench()
     await b.fiber.await()
     const conversation = renderEntryOf(b.slots, 'conversation')

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

@@ -27,8 +27,8 @@ const assistant = (seq: number, turn: number, usage?: unknown): AssistantMessage
 function snapshotBase(): ConversationSnapshot {
   return {
     sessionId: SID, nodes: [], foldDegraded: false, partial: null, runningCalls: [],
-    pending: [], running: false, removed: false, openState: 'open', openError: null,
-    hasMore: false, loadingOlder: false, promptError: null, lastAgentError: null,
+    pending: [], running: false, composerPhase: 'active', removed: false, openState: 'open', openError: null,
+    hasMore: false, loadingOlder: false, promptError: null, intent: null, pendingPrompt: null, lastAgentError: null,
   }
 }
 
@@ -127,6 +127,8 @@ describe('bash sample row', () => {
         [CHILD]: { id: CHILD, title: 'c', displayTitle: 'c', parentId: ROOT, running: false, updatedAt: 0 },
       },
       current: undefined,
+      intent: undefined,
+      phase: 'ready',
     } as SessionListState)
   }
 

packages/client/ui-conversation/tests/chat-toolview-slot.spec.tsx

@@ -15,7 +15,7 @@ import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
 import { act, cleanup, render } from '@testing-library/react'
 import { createSnapshotStore, SlotsService } from '@deepseek-ai/dsh-client-runtime/client'
 import type {
-  ConversationSnapshot, SessionId, SessionListState, ToolResultNode,
+  ConversationSnapshot, SessionId, SessionListState, ToolResultNode, WorkspaceListState,
 } from '@deepseek-ai/dsh-client-runtime/client'
 import { createSlotRenderer } from '@deepseek-ai/dsh-client-web-react'
 import type { PropsRenderSlots } from '@deepseek-ai/dsh-client-ui-slots'
@@ -40,8 +40,8 @@ const toolResult = (seq: number, callId: string, name: string, args = '{"command
 function snapshotWith(nodes: ToolResultNode[]): ConversationSnapshot {
   return {
     sessionId: SID, nodes, foldDegraded: false, partial: null, runningCalls: [],
-    pending: [], running: false, removed: false, openState: 'open', openError: null,
-    hasMore: false, loadingOlder: false, promptError: null, lastAgentError: null,
+    pending: [], running: false, composerPhase: 'active', removed: false, openState: 'open', openError: null,
+    hasMore: false, loadingOlder: false, promptError: null, intent: null, pendingPrompt: null, lastAgentError: null,
   } as ConversationSnapshot
 }
 
@@ -65,9 +65,11 @@ async function bench(nodes: ToolResultNode[]) {
   const session = createSnapshotStore<ConversationSnapshot>(snapshotWith(nodes))
   const list = createSnapshotStore<SessionListState>({
     ids: [SID],
-    byId: { [SID]: { id: SID, title: 'S', running: false, updatedAt: 1 } },
+    byId: { [SID]: { id: SID, title: 'S', displayTitle: 'S', running: false, updatedAt: 1 } },
     current: SID,
-  } as SessionListState)
+    intent: undefined,
+    phase: 'ready',
+  })
   // Identity-stable cell: the renderer caches hooks per source and inject
   // results per cell, both by object identity.
   const cell = { sessionId: SID, session }
@@ -75,11 +77,20 @@ async function bench(nodes: ToolResultNode[]) {
   const layout = { openDetails: vi.fn(), closeDetails: vi.fn() }
   ctx.provide('sessions', {
     list,
-    manager: { get: () => ({ loadOlder: vi.fn() }) },
+    binding: (id: SessionId) => ({ sessionId: id, session: { loadOlder: vi.fn() } }),
     scope: () => ({ get: () => scoped }),
     cell: (id: string) => (id === SID ? cell : undefined),
     create: vi.fn(),
     open: vi.fn(),
+    updateIntent: vi.fn(),
+  })
+  ctx.provide('workspaces', {
+    list: createSnapshotStore<WorkspaceListState>({
+      items: [], intent: undefined, state: 'idle', phase: 'ready', error: null,
+      baselinesReady: true, recentWorkspaceId: undefined,
+    }),
+    startSession: vi.fn(),
+    sendSession: vi.fn(),
   })
   ctx.provide('layout', layout)
   ctx.provide('i18n', { bind: () => (key: string) => key })
@@ -182,12 +193,23 @@ describe('registrant load-order seam', () => {
     await slotsFiber.await()
     const slots = ctx.get('slots') as SlotsService
     ctx.provide('sessions', {
-      list: createSnapshotStore<SessionListState>({ ids: [], byId: {}, current: undefined } as SessionListState),
-      manager: { get: vi.fn() },
+      list: createSnapshotStore<SessionListState>({
+        ids: [], byId: {}, current: undefined, intent: undefined, phase: 'ready',
+      }),
+      binding: () => undefined,
       scope: () => undefined,
       cell: () => undefined,
       create: vi.fn(),
       open: vi.fn(),
+      updateIntent: vi.fn(),
+    })
+    ctx.provide('workspaces', {
+      list: createSnapshotStore<WorkspaceListState>({
+        items: [], intent: undefined, state: 'idle', phase: 'ready', error: null,
+        baselinesReady: true, recentWorkspaceId: undefined,
+      }),
+      startSession: vi.fn(),
+      sendSession: vi.fn(),
     })
     ctx.provide('layout', { openDetails: vi.fn(), closeDetails: vi.fn() })
     ctx.provide('i18n', { bind: () => (key: string) => key })

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

@@ -7,7 +7,7 @@ import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
 import { Profiler } from 'react'
 import { act, cleanup, fireEvent, render } from '@testing-library/react'
 import type {
-  AssistantMessageNode, ConversationNode, ConversationSnapshot, RunningToolCall, SessionId, SessionListState, ToolResultNode, UserMessageNode,
+  AssistantMessageNode, ConversationNode, ConversationSnapshot, RunningToolCall, SessionId, SessionListState, ToolResultNode, UserMessageNode, WorkspaceListState,
 } from '@deepseek-ai/dsh-client-runtime/client'
 import { bindSnapshotSelector } from '@deepseek-ai/dsh-client-web-react'
 import { createSnapshotStore, PendingWait } from '@deepseek-ai/dsh-client-runtime/client'
@@ -29,8 +29,8 @@ const SID = 's1' as SessionId
 function snapshotBase(): ConversationSnapshot {
   return {
     sessionId: SID, nodes: [], foldDegraded: false, partial: null, runningCalls: [],
-    pending: [], running: false, removed: false, openState: 'open', openError: null,
-    hasMore: false, loadingOlder: false, promptError: null, lastAgentError: null,
+    pending: [], running: false, composerPhase: 'active', removed: false, openState: 'open', openError: null,
+    hasMore: false, loadingOlder: false, promptError: null, intent: null, pendingPrompt: null, lastAgentError: null,
   }
 }
 
@@ -72,7 +72,15 @@ const runningCall = (callId: string, name = 'bash'): RunningToolCall => ({
 /** Empty sessions-list hook for the global standard-kit seat. */
 function emptySessions() {
   const store = createSnapshotStore<SessionListState>(
-    { ids: [], byId: {}, current: undefined } as SessionListState)
+    { ids: [], byId: {}, current: undefined, intent: undefined, phase: 'ready' })
+  return bindSnapshotSelector(store)
+}
+
+function emptyWorkspaces() {
+  const store = createSnapshotStore<WorkspaceListState>({
+    items: [], intent: undefined, state: 'idle', phase: 'ready', error: null,
+    baselinesReady: true, recentWorkspaceId: undefined,
+  })
   return bindSnapshotSelector(store)
 }
 
@@ -95,6 +103,7 @@ function makeHarness(init?: Partial<ConversationSnapshot>) {
     sessionId: SID,
     useSession: bindSnapshotSelector(source),
     useSessions: emptySessions(),
+    useWorkspaces: emptyWorkspaces(),
     useStore: bindSnapshotSelector(chat),
     actions: chat.actions,
     renderSlot,

packages/client/ui-conversation/tests/coverage-tails.spec.tsx

@@ -87,8 +87,10 @@ describe('tails', () => {
     const sid = 'root-1' as SessionId
     const list = createSnapshotStore<SessionListState>({
       ids: [sid],
-      byId: { [sid]: { id: sid, title: 'r', running: false, updatedAt: 0 } },
+      byId: { [sid]: { id: sid, title: 'r', displayTitle: 'r', running: false, updatedAt: 0 } },
       current: undefined,
+      intent: undefined,
+      phase: 'ready',
     } as SessionListState)
     const props = {
       callId: 'c1', toolName: 'bash', block: errorResult, openDetails: vi.fn(),

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

@@ -5,7 +5,7 @@ import { cleanup, render } from '@testing-library/react'
 import { bindSnapshotSelector } from '@deepseek-ai/dsh-client-web-react'
 import { createSnapshotStore } from '@deepseek-ai/dsh-client-runtime/client'
 import type { UseSession } from '@deepseek-ai/dsh-client-web-react'
-import type { ConversationSnapshot, SessionId, SessionListState } from '@deepseek-ai/dsh-client-runtime/client'
+import type { ConversationSnapshot, SessionId, SessionListState, WorkspaceListState } from '@deepseek-ai/dsh-client-runtime/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'
@@ -19,8 +19,8 @@ const SID = 's1' as SessionId
 function snapshotBase(): ConversationSnapshot {
   return {
     sessionId: SID, nodes: [], foldDegraded: false, partial: null, runningCalls: [],
-    pending: [], running: false, removed: false, openState: 'open', openError: null,
-    hasMore: false, loadingOlder: false, promptError: null, lastAgentError: null,
+    pending: [], running: false, composerPhase: 'active', removed: false, openState: 'open', openError: null,
+    hasMore: false, loadingOlder: false, promptError: null, intent: null, pendingPrompt: null, lastAgentError: null,
   } as ConversationSnapshot
 }
 
@@ -65,12 +65,17 @@ describe('render branch tails', () => {
     const chat = createChatStore().create()
     chat.actions.select({ turnSeq: 1, callId: 'ghost' } satisfies SelectionTarget)
     const emptyList = createSnapshotStore<SessionListState>(
-      { ids: [], byId: {}, current: undefined } as SessionListState)
+      { ids: [], byId: {}, current: undefined, intent: undefined, phase: 'ready' })
+    const emptyWorkspaces = createSnapshotStore<WorkspaceListState>({
+      items: [], intent: undefined, state: 'idle', phase: 'ready', error: null,
+      baselinesReady: true, recentWorkspaceId: undefined,
+    })
     const view = render(
       <DetailsPanel
         sessionId={SID}
         useSession={bindSnapshotSelector({ getSnapshot: () => snap, subscribe: () => () => {} }) as unknown as UseSession<ConversationSnapshot>}
         useSessions={bindSnapshotSelector(emptyList)}
+        useWorkspaces={bindSnapshotSelector(emptyWorkspaces)}
         useStore={bindSnapshotSelector(chat)}
         actions={chat.actions}
         closeDetails={vi.fn()}

packages/client/ui-conversation/tests/hook.ts

@@ -1,20 +0,0 @@
-/**
- * Test-local selector binding through the production uSES implementation.
- * Runtime remains React-free, so specs bind observable sources here.
- */
-import { bindSnapshotSelector } from '../../web-react/src/bind.ts'
-
-/** Minimal observable source (engine stores and scripted fakes both satisfy it). */
-export interface HookSource<T> {
-  getSnapshot(): T
-  subscribe(fn: () => void): () => void
-}
-
-/**
- * Bind a selector hook over a snapshot source.
- * @param src - the source.
- * @returns a SnapshotSelectorHook-shaped hook.
- */
-export function hookOf<T>(src: HookSource<T>) {
-  return bindSnapshotSelector<T>(src)
-}

packages/client/ui-conversation/tests/input-bar.spec.tsx

@@ -19,9 +19,9 @@ function setup(over?: Partial<InputBarProps>) {
   }
   const view = render(<InputBar {...props} />)
   const textarea = view.container.querySelector('textarea')!
-  // aria-label (not role name): title also contains 发送/停止 and would double-match.
+  // aria-label (not role name): title carries the same label and would double-match.
   const button = view.container.querySelector<HTMLButtonElement>(
-    `button[aria-label="${over?.running === true ? '停止' : '发送'}"]`,
+    `button[aria-label="${over?.running === true ? 'Stop generating' : 'Send message'}"]`,
   )!
   return { view, textarea, button, props }
 }
@@ -80,7 +80,7 @@ describe('running lock and primary button', () => {
   it('running locks the textarea and turns the primary into stop', () => {
     const { textarea, button, props } = setup({ running: true })
     expect(textarea.disabled).toBe(true)
-    expect(button.getAttribute('aria-label')).toBe('停止')
+    expect(button.getAttribute('aria-label')).toBe('Stop generating')
     fireEvent.click(button)
     expect(props.onStop).toHaveBeenCalledTimes(1)
     expect(props.onSend).not.toHaveBeenCalled()
@@ -100,30 +100,30 @@ describe('running lock and primary button', () => {
     const textarea = view.container.querySelector('textarea')!
     expect(document.activeElement).toBe(textarea)
     textarea.blur()
-    fireEvent.mouseDown(view.container.querySelector('button[aria-label="发送"]')!)
+    fireEvent.mouseDown(view.container.querySelector('button[aria-label="Send message"]')!)
     expect(document.activeElement).toBe(textarea)
   })
 
   it('disabled state shows the unavailable placeholder; typing forwards drafts', () => {
     const { textarea } = setup({ disabled: true, draft: '' })
-    expect(textarea.placeholder).toBe('会话不可用')
+    expect(textarea.placeholder).toBe('Session unavailable')
     const live = setup({ draft: '' })
-    expect(live.textarea.placeholder).toContain('Enter 发送')
+    expect(live.textarea.placeholder).toBe('Message the agent')
     fireEvent.change(live.textarea, { target: { value: 'typed' } })
     expect(live.props.onDraftChange).toHaveBeenCalledWith('typed')
     const runningPh = setup({ running: true, draft: '' })
-    expect(runningPh.textarea.placeholder).toContain('停止')
-    const custom = setup({ placeholder: '自定义' })
-    expect(custom.textarea.placeholder).toBe('自定义')
+    expect(runningPh.textarea.placeholder).toBe('Generating a response…')
+    const custom = setup({ placeholder: 'Custom placeholder' })
+    expect(custom.textarea.placeholder).toBe('Custom placeholder')
   })
 })
 
 describe('error strip and variants', () => {
   it('renders send and stop failure copy', () => {
     const send = setup({ error: { op: 'send', message: 'boom' } })
-    expect(send.view.getByText(/发送失败：boom/)).toBeTruthy()
+    expect(send.view.container.querySelector('[role="alert"]')?.textContent).toBe('boom')
     const stop = setup({ error: { op: 'stop', message: 'halt' } })
-    expect(stop.view.getByText(/停止失败：halt/)).toBeTruthy()
+    expect(stop.view.container.querySelector('[role="alert"]')?.textContent).toBe('halt')
   })
 
   it('hero variant adds the hero class and accessory row renders', () => {
@@ -136,7 +136,7 @@ describe('error strip and variants', () => {
 describe('placeholder chrome', () => {
   it('renders attach / Plan / Read-only / model controls', () => {
     const { view } = setup()
-    expect(view.getByLabelText('添加')).toBeTruthy()
+    expect(view.getByLabelText('Add attachment')).toBeTruthy()
     expect((view.getByLabelText('Plan mode') as HTMLSelectElement).value).toBe('plan')
     expect((view.getByLabelText('Access mode') as HTMLSelectElement).value).toBe('readonly')
     expect((view.getByLabelText('Model') as HTMLSelectElement).value).toBe('v4-pro-high')
@@ -162,7 +162,7 @@ describe('placeholder chrome', () => {
 
   it('running locks the chrome selects and attach control', () => {
     const { view } = setup({ running: true })
-    expect((view.getByLabelText('添加') as HTMLButtonElement).disabled).toBe(true)
+    expect((view.getByLabelText('Add attachment') as HTMLButtonElement).disabled).toBe(true)
     expect((view.getByLabelText('Plan mode') as HTMLSelectElement).disabled).toBe(true)
     expect((view.getByLabelText('Model') as HTMLSelectElement).disabled).toBe(true)
   })

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

@@ -5,27 +5,31 @@
  */
 import { Context } from 'cordis'
 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 { createSnapshotStore, SlotsService } from '@deepseek-ai/dsh-client-runtime/client'
+import type { SessionId, SessionListState, WorkspaceListState } from '@deepseek-ai/dsh-client-runtime/client'
 import { createChatStore } from '../src/client/stores.ts'
 
-// Use the runtime's programmable fake to drive the real session service.
-import { FakeApiClient, ok } from '../../runtime/tests/fake-api.ts'
-
 const sid = (s: string): SessionId => s as SessionId
 
 interface Bench {
-  ctx: Context
-  api: FakeApiClient
-  sessions: SessionsService
   slots: SlotsService
   chat: ReturnType<typeof createChatStore>
 }
 
 function bench(): Bench {
   const ctx = new Context()
-  const api = new FakeApiClient()
-  const sessions = new SessionsService(ctx, api)
+  ctx.provide('sessions', {
+    list: createSnapshotStore<SessionListState>({
+      ids: [], byId: {}, current: undefined, intent: undefined, phase: 'ready',
+    }),
+    cell: () => undefined,
+  })
+  ctx.provide('workspaces', {
+    list: createSnapshotStore<WorkspaceListState>({
+      items: [], intent: undefined, state: 'idle', phase: 'ready', error: null,
+      baselinesReady: true, recentWorkspaceId: undefined,
+    }),
+  })
   // Service self-registers as ctx 'slots' (cordis Service constructor).
   const slots = new SlotsService(ctx)
   const chat = createChatStore()
@@ -42,22 +46,7 @@ function bench(): Bench {
   }, (_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> {
-  // Manager notifier + store batching are microtask-based.
-  await Promise.resolve()
-  await Promise.resolve()
-}
-
-function feed(b: Bench, rows: { id: string; cwd?: string; running?: boolean }[]): void {
-  b.api.onList = () => Promise.resolve(ok({
-    items: rows.map(r => ({
-      sessionId: sid(r.id), updatedAt: 1, running: r.running ?? false,
-      ...(r.cwd !== undefined ? { cwd: r.cwd } : {}),
-    })),
-  }) as never)
+  return { slots, chat }
 }
 
 /** Resolve the store instance the renderer would hand a slot's component for a session. */
@@ -87,11 +76,8 @@ beforeEach(() => {
 })
 
 describe('selection survives on the store seat', () => {
-  it('one session, two slots: conversation writes, details reads the SAME instance', async () => {
+  it('one session, two slots: conversation writes, details reads the SAME instance', () => {
     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'))
@@ -101,11 +87,8 @@ describe('selection survives on the store seat', () => {
     expect(details).toBe(conv)
   })
 
-  it('sessions are isolated: s2 selection never bleeds into s1', async () => {
+  it('sessions are isolated: s2 selection never bleeds into s1', () => {
     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'))
@@ -116,25 +99,17 @@ describe('selection survives on the store seat', () => {
     expect(two.store.getSnapshot().selection).toEqual({ turnSeq: 9, callId: 'z' })
   })
 
-  it('a display-title-upgrading list refresh keeps instance identity and the selection value', async () => {
+  it('a list-projection update keeps instance identity and the selection value', () => {
     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') }))
-    const id = await b.sessions.create({})
-    await flush()
-    expect(b.sessions.list.getSnapshot().byId[id]).toMatchObject({ displayTitle: 's1' })
-    expect(b.sessions.list.getSnapshot().byId[id]?.title).toBeUndefined()
+    const id = sid('s1')
+    const projection = createSnapshotStore({ displayTitle: 's1' })
 
     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 → better fallback label).
-    feed(b, [{ id: 's1', cwd: '/w/proj-a' }])
-    await b.sessions.manager.refreshList()
-    await flush()
-    expect(b.sessions.list.getSnapshot().byId[id]).toMatchObject({ displayTitle: 'proj-a' })
-    expect(b.sessions.list.getSnapshot().byId[id]?.title).toBeUndefined()
+    projection.set({ displayTitle: 'proj-a' })
+    expect(projection.getSnapshot().displayTitle).toBe('proj-a')
 
     const after = storeFor(b, 'conversation', id)
     expect(after).toBe(store)
@@ -142,32 +117,20 @@ describe('selection survives on the store seat', () => {
     expect(after.store.getSnapshot().draft).toBe('half-typed')
   })
 
-  it('session death buries the instance and its persisted draft', async () => {
+  it('session death buries the instance and its persisted draft', () => {
     const b = bench()
-    feed(b, [{ id: 's1' }, { id: 's2' }])
-    await b.sessions.manager.refreshList()
-    await flush()
 
-    // 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()
 
-    // 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()
+    // SessionsService calls this public slot lifecycle seam when the scope dies.
+    b.slots.pruneStoreScope(sid('s1'))
 
     // 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()
     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,154 +1,70 @@
 // @vitest-environment jsdom
-/**
- * ConversationService orchestration half after the store-seat slimming:
- * scope-addressed send/cancel (result folding, root throw), the startSession
- * chain (create → sessions.open → scoped send), 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); the view
- * registry left for the 'conversation.view' slot (views-type-chain.spec.tsx).
- */
 import { Context } from 'cordis'
 import { describe, expect, it, vi } from 'vitest'
 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'
 
-const sid = (s: string): SessionId => s as SessionId
-
-/** Recover the module-private scope tag through the public seam (same probe as apply-inject.spec). */
+const sid = (id: string) => id as SessionId
 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)
+  const reads: (string | symbol)[] = []
+  const proxy = new Proxy(new Context(), {
+    get(target, property, receiver): unknown {
+      reads.push(property)
+      return Reflect.get(target, property, 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
+  void scopeOf(proxy)
+  return reads.find((value): value is symbol => typeof value === 'symbol')!
 })()
 
-interface SessionDouble {
-  prompt: ReturnType<typeof vi.fn>
-  cancel: ReturnType<typeof vi.fn>
-}
-
-async function bench(opts?: { sessions?: boolean }) {
+async function bench(withSessions = true) {
   const ctx = new Context()
-  const sessionDoubles = new Map<SessionId, SessionDouble>()
-  const scopes = new Map<SessionId, Context>()
-  const mint = (id: SessionId): Context => {
-    let scoped = scopes.get(id)
-    if (scoped === undefined) {
-      const fiber = ctx.plugin(() => {})
-      scoped = fiber.ctx.extend({ [SCOPE_TAG]: id })
-      scopes.set(id, scoped)
-    }
-    return scoped
-  }
-  const createMock = vi.fn(() => Promise.resolve(sid('new-1')))
-  const openMock = vi.fn()
-  const sessionsFake = {
-    manager: {
-      get: (id: SessionId) => {
-        let s = sessionDoubles.get(id)
-        if (s === undefined) {
-          s = {
-            prompt: vi.fn(() => Promise.resolve({ ok: true, value: { accepted: true } })),
-            cancel: vi.fn(() => Promise.resolve({ ok: true, value: { accepted: true } })),
-          }
-          sessionDoubles.set(id, s)
-        }
-        return s
-      },
-    },
-    create: createMock,
-    open: openMock,
-    scope: (id: SessionId) => (id === sid('new-1') ? mint(id) : scopes.get(id)),
+  const prompt = vi.fn(() => Promise.resolve({ ok: true as const, value: { accepted: true as const } }))
+  const cancel = vi.fn(() => Promise.resolve({ ok: true as const, value: { accepted: true as const } }))
+  const loadOlder = vi.fn(() => Promise.resolve())
+  const updatePendingPrompt = vi.fn()
+  const retryPendingPrompt = vi.fn()
+  const sessions = {
+    binding: (sessionId: SessionId) => ({
+      sessionId, session: { prompt, cancel, loadOlder, updatePendingPrompt, retryPendingPrompt },
+    }),
     scopeOf,
   } as unknown as SessionsService
-  if (opts?.sessions !== false) ctx.provide('sessions', sessionsFake)
-  // Class-plugin mount — the same form apply.ts uses in production.
-  const fiber = ctx.plugin(ConversationService)
-  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, openMock }
+  if (withSessions) ctx.provide('sessions', sessions)
+  await ctx.plugin(ConversationService).await()
+  const root = ctx.get('conversation') as ConversationService
+  const scoped = ctx.plugin(() => {}).ctx.extend({ [SCOPE_TAG]: sid('s1') }).get('conversation') as ConversationService
+  return { root, scoped, prompt, cancel, loadOlder, updatePendingPrompt, retryPendingPrompt }
 }
 
-describe('send / cancel', () => {
-  it('sends one text block through the scoped session with the mode', async () => {
+describe('ConversationService', () => {
+  it('routes ordinary and retained-prompt operations through the public Session binding', async () => {
     const b = await bench()
-    await b.scopedSvc(sid('s1')).send('hello', 'steer')
-    expect(b.sessionDoubles.get(sid('s1'))!.prompt).toHaveBeenCalledWith(
-      [{ type: 'text', text: 'hello' }], 'steer')
+    await b.scoped.send('hello', 'steer')
+    await b.scoped.cancel()
+    await b.scoped.loadOlder()
+    b.scoped.updatePendingPrompt('revised')
+    b.scoped.retryPendingPrompt()
+    expect(b.prompt).toHaveBeenCalledWith([{ type: 'text', text: 'hello' }], 'steer')
+    expect(b.cancel).toHaveBeenCalledOnce()
+    expect(b.loadOlder).toHaveBeenCalledOnce()
+    expect(b.updatePendingPrompt).toHaveBeenCalledWith('revised')
+    expect(b.retryPendingPrompt).toHaveBeenCalledOnce()
   })
 
-  it('folds business failure into a thrown error carrying code and message', async () => {
+  it('folds Session business failures into callback rejections', async () => {
     const b = await bench()
-    const s = b.scopedSvc(sid('s1'))
-    // Materialize the double first (manager.get is the lazy mint point).
-    b.sessionsFake.manager.get(sid('s1'))
-    const double = b.sessionDoubles.get(sid('s1'))!
-    double.prompt.mockResolvedValue({ ok: false, error: { code: 'agent-busy', message: 'busy' } })
-    await expect(s.send('x', 'queue')).rejects.toThrow(/send failed: agent-busy: busy/)
+    b.prompt.mockResolvedValueOnce({ ok: false, error: { code: 'agent-busy', message: 'busy', details: {} } } as never)
+    await expect(b.scoped.send('x', 'queue')).rejects.toThrow('conversation.send failed: agent-busy: busy')
+    b.cancel.mockResolvedValueOnce({ ok: false, error: { code: 'internal', message: 'nope', details: {} } } as never)
+    await expect(b.scoped.cancel()).rejects.toThrow('conversation.cancel failed: internal: nope')
   })
 
-  it('cancel resolves on ok and throws the folded business error', async () => {
+  it('fails loudly from the root scope or without SessionsService', async () => {
     const b = await bench()
-    const s = b.scopedSvc(sid('s1'))
-    await s.cancel()
-    const double = b.sessionDoubles.get(sid('s1'))!
-    expect(double.cancel).toHaveBeenCalledTimes(1)
-    double.cancel.mockResolvedValue({ ok: false, error: { code: 'internal', message: 'nope' } })
-    await expect(s.cancel()).rejects.toThrow(/cancel failed: internal: nope/)
-  })
-
-  it('root-context send and cancel throw the addressing hint', async () => {
-    const b = await bench()
-    await expect(b.svc.send('x', 'queue')).rejects.toThrow(/requires a session scope/)
-    await expect(b.svc.cancel()).rejects.toThrow(/requires a session scope/)
-  })
-})
-
-describe('startSession chain', () => {
-  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.openMock).toHaveBeenCalledWith(sid('new-1'))
-    expect(b.sessionDoubles.get(sid('new-1'))!.prompt).toHaveBeenCalledWith(
-      [{ type: 'text', text: 'first' }], 'queue')
-  })
-
-  it('omits cwd from create when not chosen', async () => {
-    const b = await bench()
-    await b.svc.startSession({ text: 't', mode: 'steer' })
-    expect(b.createMock).toHaveBeenCalledWith({})
-  })
-
-  it('fails loud when the created session resolves no scope', async () => {
-    const b = await bench()
-    ;(b.sessionsFake.create as ReturnType<typeof vi.fn>).mockResolvedValue(sid('ghost'))
-    await expect(b.svc.startSession({ text: 't', mode: 'queue' })).rejects.toThrow(/resolved no scope/)
-  })
-})
-
-describe('service-unavailable loud failures', () => {
-  it('throws when sessions is missing', async () => {
-    const b = await bench({ sessions: false })
-    await expect(b.svc.startSession({ text: 't', mode: 'queue' })).rejects.toThrow(/sessions 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.
-    const foreign = new Context()
-    const foreignScope = foreign.plugin(() => {}).ctx.extend({})
-    ;(b.sessionsFake.scope as unknown) = () => foreignScope
-    await expect(b.svc.startSession({ text: 't', mode: 'queue' }))
-      .rejects.toThrow(/conversation service unavailable through the new scope/)
+    await expect(b.root.send('x', 'queue')).rejects.toThrow(/requires a session scope/)
+    const missing = await bench(false)
+    await expect(missing.root.send('x', 'queue')).rejects.toThrow(/sessions service unavailable/)
   })
 })

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

@@ -1,318 +0,0 @@
-// @vitest-environment jsdom
-// Skeleton branch tails for the coverage gate (complements skeleton.spec.tsx
-// 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 path-modal confirm with in-component cwd derivation.
-
-import { afterEach, describe, expect, it, vi } from 'vitest'
-import { cleanup, fireEvent, render, waitFor } from '@testing-library/react'
-import { hookOf } from './hook.ts'
-import { createSnapshotStore } from '@deepseek-ai/dsh-client-runtime/client'
-import type { UseSession } from '@deepseek-ai/dsh-client-ui-slots'
-import type { ConversationSnapshot, SessionId, SessionListState } from '@deepseek-ai/dsh-client-runtime/client'
-import type { SelectionTarget, ViewTab } from '@deepseek-ai/dsh-client-ui-conversation/client'
-// Export discipline: packages/client/AGENTS.md.
-import { createChatStore } from '../src/client/stores.ts'
-import { ConversationRoot, type ConversationRootProps } from '../src/client/skeleton/ConversationRoot.tsx'
-import { DetailsPanel } from '../src/client/skeleton/DetailsPanel.tsx'
-import { EmptyState } from '../src/client/skeleton/EmptyState.tsx'
-
-afterEach(cleanup)
-
-const SID = 's1' as SessionId
-/** Fallback-only chain stub (no takeover registered in these benches). */
-const fallbackRenderSlotChain: ConversationRootProps['renderSlotChain'] =
-  (_key, _owner, opts) => opts?.fallback ?? null
-
-function snapshotBase(): ConversationSnapshot {
-  return {
-    sessionId: SID, 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
-}
-
-function sessionSource(over?: Partial<ConversationSnapshot>) {
-  const snap = { ...snapshotBase(), ...over }
-  return {
-    getSnapshot: () => snap,
-    subscribe: () => () => {},
-  }
-}
-
-/** 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: `durable ${r.title}`, displayTitle: 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 hookOf(store)
-}
-
-describe('ConversationRoot branches', () => {
-  const chatTab: ViewTab = { id: 'chat', label: 'Chat' }
-  /** renderSlot stub in the outlet's baked shape (ring key + only filter marker). */
-  const stubRenderSlot = (() => <div data-testid="view-body" />) as unknown as ConversationRootProps['renderSlot']
-  /** SessionProvider seat stub (render-prop pass-through; ConversationRoot never invokes it). */
-  const SessionProviderStub: ConversationRootProps['SessionProvider'] = ({ children }) => <>{children(SID)}</>
-
-  function rootProps(over?: {
-    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={hookOf(sessionSource(over?.snapshot)) as unknown as UseSession<ConversationSnapshot>}
-        useSessions={listHook(over?.rows ?? [])}
-        useStore={hookOf(chat)}
-        actions={chat.actions}
-        renderSlot={stubRenderSlot}
-        renderSlotChain={fallbackRenderSlotChain}
-        SessionProvider={SessionProviderStub}
-        views={{ list: () => [chatTab], subscribe: () => () => {}, version: () => 1 }}
-        send={vi.fn()}
-        stop={vi.fn()}
-        open={open}
-      />,
-    )
-    return { view, open, chat }
-  }
-
-  it('derives the ancestry breadcrumb from the sessions list and navigates on ancestor click', () => {
-    const { view, open } = rootProps({
-      rows: [{ id: 'root-1', title: 'Workspace' }, { id: 's1', title: 'Current', parentId: 'root-1' }],
-    })
-    expect(view.getByText('Workspace')).toBeTruthy()
-    expect(view.getByText('/')).toBeTruthy()
-    fireEvent.click(view.getByText('Workspace'))
-    expect(open).toHaveBeenCalledWith('root-1' as SessionId)
-    // The last crumb is the current session: disabled, no navigation.
-    fireEvent.click(view.getByText('Current'))
-    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] },
-    })
-    expect(view.getByText(SID)).toBeTruthy()
-    expect(view.getByText(/1 turns/)).toBeTruthy()
-  })
-
-  it('surfaces promptError through the composer error strip', () => {
-    const { view } = rootProps({
-      snapshot: { promptError: { op: 'stop', error: { message: 'halt', code: 'internal' } } as never },
-    })
-    expect(view.getByText(/停止失败：halt（internal）/)).toBeTruthy()
-  })
-
-  it('an unknown stored view id falls back to the first registered view', () => {
-    const { chat } = rootProps({})
-    cleanup()
-    chat.actions.setView('gone')
-    const view = render(
-      <ConversationRoot
-        sessionId={SID}
-        useSession={hookOf(sessionSource()) as unknown as UseSession<ConversationSnapshot>}
-        useSessions={listHook([])}
-        useStore={hookOf(chat)}
-        actions={chat.actions}
-        renderSlot={stubRenderSlot}
-        renderSlotChain={fallbackRenderSlotChain}
-        SessionProvider={SessionProviderStub}
-        views={{ list: () => [chatTab], subscribe: () => () => {}, version: () => 1 }}
-        send={vi.fn()}
-        stop={vi.fn()}
-        open={vi.fn()}
-      />,
-    )
-    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={hookOf(sessionSource(snapshot)) as unknown as UseSession<ConversationSnapshot>}
-        useSessions={listHook([])}
-        useStore={hookOf(chat)}
-        actions={chat.actions}
-        closeDetails={vi.fn()}
-      />,
-    )
-  }
-
-  it('shows non-JSON args verbatim (streaming fragment path)', () => {
-    const view = panel({ turnSeq: 1, callId: 'c1', toolName: 'bash' }, {
-      runningCalls: [{ callId: 'c1', name: 'bash', argsRaw: '{"cmd": tru', turn: 1, step: 1, time: 1_000, callView: null }],
-    })
-    expect(view.getByText('{"cmd": tru')).toBeTruthy()
-  })
-
-  it('a selection without callId renders the empty hint (selector null arm)', () => {
-    const view = panel({ turnSeq: 2 })
-    expect(view.getByText(/点击消息流中的工具行查看详情/)).toBeTruthy()
-  })
-
-  it('snapshot updates re-run the material selector through the shallow equality arm', () => {
-    let snap = { ...snapshotBase(), runningCalls: [{ callId: 'c9', name: 'bash', argsRaw: '{"a":1}', turn: 1, step: 1, time: 1_000, callView: null }] } as ConversationSnapshot
-    const subs = new Set<() => void>()
-    const source = {
-      getSnapshot: () => snap,
-      subscribe: (fn: () => void) => {
-        subs.add(fn)
-        return () => subs.delete(fn)
-      },
-    }
-    const chat = createChatStore().create()
-    chat.actions.select({ turnSeq: 1, callId: 'c9' })
-    const view = render(
-      <DetailsPanel
-        sessionId={SID}
-        useSession={hookOf(source) as unknown as UseSession<ConversationSnapshot>}
-        useSessions={listHook([])}
-        useStore={hookOf(chat)}
-        actions={chat.actions}
-        closeDetails={vi.fn()}
-      />,
-    )
-    expect(view.getByText(/"a": 1/)).toBeTruthy()
-    // Top-level swap with identical material members: the eq arm short-circuits.
-    snap = { ...snap }
-    for (const fn of [...subs]) fn()
-    expect(view.getByText(/"a": 1/)).toBeTruthy()
-  })
-
-  it('windowless call material: no name/args fallback to callId, mixed node walk skips non-matches', () => {
-    // A tool-result whose call head fell outside the window (call === null),
-    // preceded by non-matching nodes so the walk exercises both filter arms.
-    const view = panel({ turnSeq: 1, callId: 'c8' }, {
-      nodes: [
-        { kind: 'user', seq: 1, content: [], source: null } as never,
-        { kind: 'tool-result', seq: 2, callId: 'other', call: { name: 'x', argsRaw: '{}' }, content: [], isError: false, callView: null, resultView: null } as never,
-        { kind: 'tool-result', seq: 3, callId: 'c8', call: null, content: [], isError: false, callView: null, resultView: null } as never,
-      ],
-    })
-    expect(view.getByText('c8')).toBeTruthy()
-  })
-
-  it('stringifies non-text result blocks and renders error-only results', () => {
-    const withBlocks = panel({ turnSeq: 1, callId: 'c2' }, {
-      nodes: [{
-        kind: 'tool-result', seq: 3, callId: 'c2', call: { name: 'read', argsRaw: '{}' },
-        content: [{ type: 'image', data: 'x' } as never],
-        isError: false, callView: null, resultView: null,
-      } as never],
-    })
-    expect(withBlocks.getByText(/"type": "image"/)).toBeTruthy()
-    const errorOnly = panel({ turnSeq: 1, callId: 'c3' }, {
-      nodes: [{
-        kind: 'tool-result', seq: 4, callId: 'c3', call: { name: 'bash', argsRaw: '{}' },
-        content: [], isError: true, error: { name: 'ToolError', code: 'timeout' },
-        callView: null, resultView: null,
-      } as never],
-    })
-    expect(errorOnly.getByText(/ToolError: timeout/)).toBeTruthy()
-  })
-})
-
-describe('EmptyState branches', () => {
-  const noopCreate = () => Promise.resolve()
-
-  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
-        useSessions={listHook([{ id: 'a', title: 'a', cwd: '/proj' }])}
-        startSession={startSession}
-        createWorkspaceSession={noopCreate}
-      />,
-    )
-    const textarea = view.container.querySelector('textarea')!
-    fireEvent.change(textarea, { target: { value: 'first task' } })
-    fireEvent.keyDown(textarea, { key: 'Enter' })
-    await waitFor(() => expect(view.getByText(/发送失败：create down/)).toBeTruthy())
-    expect((textarea as HTMLTextAreaElement).value).toBe('first task')
-  })
-
-  it('non-Error rejection reasons stringify into the error strip', async () => {
-    const startSession = vi.fn(() => Promise.reject('plain-string'))
-    const view = render(
-      <EmptyState
-        useSessions={listHook([])}
-        startSession={startSession}
-        createWorkspaceSession={noopCreate}
-      />,
-    )
-    const textarea = view.container.querySelector('textarea')!
-    fireEvent.change(textarea, { target: { value: 'go' } })
-    fireEvent.keyDown(textarea, { key: 'Enter' })
-    await waitFor(() => expect(view.getByText(/发送失败：plain-string/)).toBeTruthy())
-  })
-
-  it('cwd derivation skips blank cwds; menu picks, path modal confirms, submits the typed path', async () => {
-    const startSession = vi.fn(() => Promise.resolve())
-    const view = render(
-      <EmptyState
-        useSessions={listHook([
-          { id: 'a', title: 'a', cwd: '/proj' },
-          { id: 'b', title: 'b' }, // no cwd: filtered from the option set
-        ])}
-        startSession={startSession}
-        createWorkspaceSession={noopCreate}
-      />,
-    )
-    fireEvent.click(view.getByRole('button', { name: '项目目录' }))
-    expect([...view.getByRole('menu').querySelectorAll('[role="menuitem"]')].map(el => el.textContent))
-      .toEqual(['proj', 'New Workspace'])
-    fireEvent.click(view.getByRole('menuitem', { name: 'proj' }))
-    expect(view.getByRole('button', { name: '项目目录' }).textContent).toContain('proj')
-    fireEvent.click(view.getByRole('button', { name: '项目目录' }))
-    fireEvent.mouseEnter(view.getByRole('menuitem', { name: 'New Workspace' }).parentElement as HTMLElement)
-    fireEvent.click(view.getByRole('menuitem', { name: 'Use a existing folder' }))
-    const custom = view.getByLabelText('Folder path')
-    fireEvent.change(custom, { target: { value: '/typed/dir' } })
-    fireEvent.click(view.getByRole('button', { name: 'Open Folder' }))
-    const textarea = view.container.querySelector('textarea')!
-    fireEvent.change(textarea, { target: { value: 'task' } })
-    fireEvent.keyDown(textarea, { key: 'Enter' })
-    await waitFor(() => expect(startSession).toHaveBeenCalledWith({ text: 'task', mode: 'queue', cwd: '/typed/dir' }))
-  })
-
-  it('Create modal surfaces inject failures inline', async () => {
-    const createWorkspaceSession = vi.fn(() => Promise.reject(new Error('mkdir blocked')))
-    const view = render(
-      <EmptyState
-        useSessions={listHook([])}
-        startSession={() => Promise.resolve()}
-        createWorkspaceSession={createWorkspaceSession}
-      />,
-    )
-    fireEvent.click(view.getByRole('button', { name: '项目目录' }))
-    fireEvent.mouseEnter(view.getByRole('menuitem', { name: 'New Workspace' }).parentElement as HTMLElement)
-    fireEvent.click(view.getByRole('menuitem', { name: 'Create new' }))
-    fireEvent.click(view.getByRole('button', { name: 'Create' }))
-    await waitFor(() => expect(view.getByRole('alert').textContent).toContain('mkdir blocked'))
-  })
-})

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

@@ -1,344 +1,203 @@
 // @vitest-environment jsdom
-/**
- * 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, beforeEach, describe, expect, it, vi } from 'vitest'
+import { cleanup, fireEvent, render } from '@testing-library/react'
 import { bindSnapshotSelector } from '@deepseek-ai/dsh-client-web-react'
 import { createSnapshotStore } from '@deepseek-ai/dsh-client-runtime/client'
-import type { UseSession } from '@deepseek-ai/dsh-client-web-react'
-import type { ConversationSnapshot, PendingInteraction, SessionId, SessionListState } from '@deepseek-ai/dsh-client-runtime/client'
-import { PendingWait } from '@deepseek-ai/dsh-client-runtime/client'
-import { RpcId } from '@deepseek-ai/dsh-client-connection/client'
-import type { SelectionTarget, ViewTab } from '@deepseek-ai/dsh-client-ui-conversation/client'
+import type {
+  ConversationSnapshot, SessionId, SessionListState, WorkspaceId, WorkspaceListState, WorkspaceView,
+} from '@deepseek-ai/dsh-client-runtime/client'
+import type { EmptyStateProps } from '../src/client/skeleton/EmptyState.tsx'
 import type { ConversationRootProps } from '../src/client/skeleton/ConversationRoot.tsx'
-// 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'
 
-const sid = (s: string): SessionId => s as SessionId
-
 afterEach(cleanup)
-beforeEach(() => {
-  // jsdom normally provides localStorage; some host Node builds surface it as undefined.
-  globalThis.localStorage?.clear()
+beforeEach(() => { localStorage.clear() })
+
+const sid = (id: string) => id as SessionId
+const wid = (id: string) => id as WorkspaceId
+const SID = sid('s1')
+
+function workspace(id = 'w1'): WorkspaceView {
+  return {
+    workspaceId: wid(id), path: `/projects/${id}`, title: id, sessionIds: [],
+    createdAt: '2026-01-01T00:00:00.000Z', updatedAt: '2026-01-01T00:00:00.000Z',
+  }
+}
+
+type SessionIntent = NonNullable<SessionListState['intent']>
+type WorkspaceIntent = NonNullable<WorkspaceListState['intent']>
+
+const workspaceState = (
+  items: readonly WorkspaceView[], workspaceIntent?: WorkspaceIntent,
+): WorkspaceListState => ({
+  items, intent: workspaceIntent, state: 'idle', phase: 'ready', error: null,
+  baselinesReady: true, recentWorkspaceId: undefined,
 })
+const hook = <T,>(snapshot: T) => <S,>(selector: (state: T) => S): S => selector(snapshot)
 
-/** Minimal conversation snapshot slice the skeleton reads. */
-interface FakeSnapshot {
-  nodes: readonly {
-    kind: string
-    seq?: number
-    time?: number
-    callId?: string
-    call?: { name: string; argsRaw: string } | null
-    callTime?: number | null
-    content?: readonly { type: string; text?: string }[]
-    isError?: boolean
-    callView?: null
-    resultView?: null
-  }[]
-  runningCalls: readonly {
-    callId: string
-    name: string
-    argsRaw: string
-    turn?: number
-    step?: number
-    time?: number
-    callView?: null
-  }[]
-  running: boolean
-  removed: boolean
-  promptError: { op: 'send' | 'stop'; error: { message: string; code: string } } | null
-  pending: readonly PendingInteraction[]
+function mountEmpty(
+  intent: SessionIntent,
+  items: readonly WorkspaceView[] = [],
+  localWorkspace?: WorkspaceIntent,
+) {
+  const updateSessionPrompt = vi.fn()
+  const sendSession = vi.fn()
+  const startSession = vi.fn()
+  let pickerOwner: unknown
+  const sessionState: SessionListState = {
+    ids: [], byId: {}, current: intent.sessionId, intent, phase: 'ready',
+  }
+  const workspaceIntent = intent.target.kind === 'workspace-intent'
+    ? localWorkspace ?? { name: 'workspace', phase: 'ready' as const }
+    : undefined
+  const view = render(
+    <EmptyState
+      useSessions={hook(sessionState)}
+      useWorkspaces={hook(workspaceState(items, workspaceIntent))}
+      updateSessionPrompt={updateSessionPrompt}
+      sendSession={sendSession}
+      startSession={startSession}
+      renderSlot={((_key: string, owner: unknown) => { pickerOwner = owner; return null }) as EmptyStateProps['renderSlot']}
+    />,
+  )
+  return { view, updateSessionPrompt, sendSession, startSession, pickerOwner: () => pickerOwner }
 }
 
-function fakeSession(init: Partial<FakeSnapshot> = {}) {
-  const store = createSnapshotStore<FakeSnapshot>({
-    nodes: [], runningCalls: [], running: false, removed: false, promptError: null, pending: [], ...init,
-  })
-  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: `durable ${r.title}`, displayTitle: 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: bindSnapshotSelector(store) }
-}
-
-/** SessionProvider seat stub (render-prop pass-through; ConversationRoot never invokes it). */
-const SessionProviderStub: ConversationRootProps['SessionProvider'] = ({ children }) => <>{children(sid('s1'))}</>
-
 describe('EmptyState', () => {
-  const noopCreate = () => Promise.resolve()
-
-  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
-        useSessions={useSessions}
-        startSession={startSession}
-        createWorkspaceSession={noopCreate}
-      />,
-    )
-
-    const trigger = screen.getByRole('button', { name: '项目目录' })
-    fireEvent.click(trigger)
-    const menu = screen.getByRole('menu')
-    expect([...menu.querySelectorAll('[role="menuitem"]')].map(el => el.textContent))
-      .toEqual(['app', 'lib', 'New Workspace'])
-    fireEvent.click(screen.getByRole('menuitem', { name: 'app' }))
-    const box = screen.getByPlaceholderText('Message to run task, plan and build, enter for / commands')
-    fireEvent.change(box, { target: { value: '造一个轮子' } })
-    fireEvent.keyDown(box, { key: 'Enter' })
-    expect(startSession).toHaveBeenCalledWith({ text: '造一个轮子', mode: 'queue', cwd: '/w/app' })
-
-    reject(new Error('后端拒收'))
-    expect(await screen.findByText(/后端拒收/)).toBeTruthy()
-    // Draft survives the failure for retry.
-    expect((box as HTMLTextAreaElement).value).toBe('造一个轮子')
+  it('reads the Workspace and Session intents from runtime projections', () => {
+    const b = mountEmpty({
+      sessionId: sid('local-1'), target: { kind: 'workspace-intent' },
+      prompt: 'draft', phase: 'ready',
+    })
+    expect(b.view.getByRole('button', { name: 'Choose workspace' }).textContent).toContain('workspace')
+    fireEvent.change(b.view.getByPlaceholderText('Describe what you want to build'), { target: { value: 'build it' } })
+    expect(b.updateSessionPrompt).toHaveBeenCalledWith('build it')
+    fireEvent.click(b.view.getByRole('button', { name: 'Send message' }))
+    expect(b.sendSession).toHaveBeenCalledOnce()
   })
 
-  it('Use a existing folder opens the path modal and Open Folder sets the chip', () => {
-    const { useSessions } = fakeSessions([])
-    render(
-      <EmptyState
-        useSessions={useSessions}
-        startSession={() => Promise.resolve()}
-        createWorkspaceSession={noopCreate}
-      />,
-    )
-    fireEvent.click(screen.getByRole('button', { name: '项目目录' }))
-    const newWs = screen.getByRole('menuitem', { name: 'New Workspace' })
-    fireEvent.mouseEnter(newWs.parentElement as HTMLElement)
-    fireEvent.click(screen.getByRole('menuitem', { name: 'Use a existing folder' }))
-    expect(screen.getByRole('dialog', { name: 'Enter an existing folder path' })).toBeTruthy()
-    const path = screen.getByLabelText('Folder path') as HTMLInputElement
-    fireEvent.change(path, { target: { value: '/tmp/fresh' } })
-    fireEvent.click(screen.getByRole('button', { name: 'Open Folder' }))
-    expect(screen.queryByRole('dialog')).toBeNull()
-    expect(screen.getByRole('button', { name: '项目目录' }).textContent).toContain('fresh')
+  it('uses useWorkspaces for the selected label and preserves the prompt when retargeting', () => {
+    const first = workspace('first')
+    const b = mountEmpty({
+      sessionId: sid('local-2'), target: { kind: 'workspace', workspaceId: first.workspaceId },
+      prompt: 'keep me', phase: 'ready',
+    }, [first])
+    expect(b.view.getByRole('button', { name: 'Choose workspace' }).textContent).toContain('first')
+    fireEvent.click(b.view.getByRole('button', { name: 'Choose workspace' }))
+    const owner = b.pickerOwner() as { onPick(id: WorkspaceId): void }
+    owner.onPick(wid('second'))
+    expect(b.startSession).toHaveBeenCalledWith(wid('second'), 'keep me')
   })
 
-  it('Create new opens the modal and createWorkspaceSession succeeds', async () => {
-    const { useSessions } = fakeSessions([])
-    const createWorkspaceSession = vi.fn(() => Promise.resolve())
-    render(
-      <EmptyState
-        useSessions={useSessions}
-        startSession={() => Promise.resolve()}
-        createWorkspaceSession={createWorkspaceSession}
-      />,
-    )
-    fireEvent.click(screen.getByRole('button', { name: '项目目录' }))
-    fireEvent.mouseEnter(screen.getByRole('menuitem', { name: 'New Workspace' }).parentElement as HTMLElement)
-    fireEvent.click(screen.getByRole('menuitem', { name: 'Create new' }))
-    expect(screen.getByRole('dialog', { name: 'Create new workspace' })).toBeTruthy()
-    const name = screen.getByLabelText('Workspace name') as HTMLInputElement
-    expect(name.value).toBe('New WorkSpace')
-    fireEvent.change(name, { target: { value: 'My Proj' } })
-    fireEvent.keyDown(name, { key: 'Enter' })
-    await vi.waitFor(() => expect(createWorkspaceSession).toHaveBeenCalledWith('My Proj'))
-  })
-
-  it('Create modal Cancel dismisses without calling createWorkspaceSession', () => {
-    const { useSessions } = fakeSessions([])
-    const createWorkspaceSession = vi.fn(() => Promise.resolve())
-    render(
-      <EmptyState
-        useSessions={useSessions}
-        startSession={() => Promise.resolve()}
-        createWorkspaceSession={createWorkspaceSession}
-      />,
-    )
-    fireEvent.click(screen.getByRole('button', { name: '项目目录' }))
-    fireEvent.mouseEnter(screen.getByRole('menuitem', { name: 'New Workspace' }).parentElement as HTMLElement)
-    fireEvent.click(screen.getByRole('menuitem', { name: 'Create new' }))
-    fireEvent.click(screen.getByRole('button', { name: 'Cancel' }))
-    expect(screen.queryByRole('dialog')).toBeNull()
-    expect(createWorkspaceSession).not.toHaveBeenCalled()
+  it('exposes materialization phase and failure text', () => {
+    const creating = mountEmpty({
+      sessionId: sid('local-3'), target: { kind: 'workspace-intent' },
+      prompt: 'x', phase: 'ready',
+    }, [], { name: 'workspace', phase: 'creating' })
+    expect(creating.view.getByRole('status').textContent).toBe('Creating workspace…')
+    cleanup()
+    const workspaceFailed = mountEmpty({
+      sessionId: sid('local-3'), target: { kind: 'workspace-intent' },
+      prompt: 'x', phase: 'ready',
+    }, [], { name: 'workspace', phase: 'ready', error: 'offline' })
+    expect(workspaceFailed.view.getByRole('alert').textContent).toBe('Workspace creation failed: offline')
+    cleanup()
+    const failed = mountEmpty({
+      sessionId: sid('local-3'), target: { kind: 'workspace', workspaceId: wid('w1') },
+      prompt: 'x', phase: 'ready', error: { step: 'session', message: 'offline' },
+    }, [workspace()])
+    expect(failed.view.getByRole('alert').textContent).toBe('Session creation failed: offline')
   })
 })
 
-describe('ConversationRoot', () => {
-  function bench(
-    tabs: ViewTab[], activeView?: string, init: Partial<FakeSnapshot> = {},
-    renderSlotChain?: ConversationRootProps['renderSlotChain'],
-  ) {
-    const { useSession } = fakeSession({ nodes: [{ kind: 'user' }, { kind: 'user' }], ...init })
-    const { useSessions } = fakeSessions([
-      { id: 'root', title: 'proj' },
-      { id: 's1', title: 'child', parentId: 'root' },
-    ])
-    const chat = createChatStore().create()
-    if (activeView !== undefined) chat.actions.setView(activeView)
-    const send = vi.fn()
-    const stop = vi.fn()
-    const open = vi.fn()
-    // The renderSlot share as the outlet would bake it: renders a marker for
-    // the ring key carrying the active-id filter (a Mock cannot satisfy the
-    // generic method type directly — cast once at the prop seam).
-    const renderSlot = vi.fn((key: string, _owner: object, opts?: { only?: string }) => (
-      <div data-testid={`view-${opts?.only ?? '(all)'}`} data-slot={key} />
-    ))
-    const ui = render(
-      <ConversationRoot
-        sessionId={sid('s1')}
-        useSession={useSession}
-        useSessions={useSessions}
-        useStore={bindSnapshotSelector(chat)}
-        actions={chat.actions}
-        renderSlot={renderSlot as unknown as ConversationRootProps['renderSlot']}
-        renderSlotChain={renderSlotChain ?? ((_key, _owner, opts) => opts?.fallback ?? null)}
-        SessionProvider={SessionProviderStub}
-        views={{
-          list: () => tabs,
-          subscribe: () => () => {},
-          version: () => 1,
-        }}
-        send={send}
-        stop={stop}
-        open={open}
-      />)
-    return { ui, chat, send, stop, open, renderSlot }
+function conversationSnapshot(
+  composerPhase: ConversationSnapshot['composerPhase'],
+  pendingPrompt: ConversationSnapshot['pendingPrompt'] = null,
+): ConversationSnapshot {
+  return {
+    sessionId: SID, nodes: [], foldDegraded: false, partial: null, runningCalls: [],
+    pending: [], running: false, composerPhase, removed: false, openState: 'open', openError: null,
+    hasMore: false, loadingOlder: false, promptError: null, intent: null, pendingPrompt, lastAgentError: null,
   }
+}
 
-  const tab = (id: string, label: string): ViewTab => ({ id, label })
-
-  it('renders breadcrumb chain (useSessions-derived), meta turns, and the default chat view', () => {
-    const { open } = bench([tab('chat', 'Chat'), tab('trajectory', 'Trajectory')])
-    expect(screen.getByText('proj')).toBeTruthy()
-    expect(screen.getByText('child')).toBeTruthy()
-    expect(screen.getByText(/2 turns/)).toBeTruthy()
-    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)
+function mountConversation(pendingPrompt: ConversationSnapshot['pendingPrompt'] = null) {
+  const root = sid('root')
+  const sessions = createSnapshotStore<SessionListState>({
+    ids: [root, SID],
+    byId: {
+      [root]: { id: root, displayTitle: 'Root', running: false, updatedAt: 1 },
+      [SID]: { id: SID, displayTitle: 'Child', parentId: root, cwd: '/projects/one', running: false, updatedAt: 2 },
+    },
+    current: SID,
+    intent: undefined,
+    phase: 'ready',
   })
-
-  it('switches views through the store view field and falls back on unknown ids', () => {
-    const { chat } = bench([tab('chat', 'Chat'), tab('trajectory', 'Trajectory')])
-    fireEvent.click(screen.getByRole('tab', { name: '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([tab('chat', 'Chat'), tab('trajectory', 'Trajectory')], 'ghost-view')
-    expect(screen.getByTestId('view-chat')).toBeTruthy()
-  })
-
-  it('renders the active view through the declared ring slot with the only filter', () => {
-    const { renderSlot } = bench([tab('chat', 'Chat')])
-    // No owner share: views take everything from the standard kit (contract).
-    expect(renderSlot).toHaveBeenCalledWith('conversation.view', {}, { only: 'chat' })
-    expect(screen.getByTestId('view-chat').getAttribute('data-slot')).toBe('conversation.view')
-  })
-
-  it('hides the tab strip with a single view; composer writes the store draft and sends it', () => {
-    const { chat, send } = bench([tab('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('hi', 'queue')
-  })
-
-  it('dispatches the pending list to the composer chain; all-decline falls back to InputBar', () => {
-    const wait = new PendingWait('question', RpcId('rq'), sid('s1'),
-      { questions: [{ id: 'mode', question: 'Choose?', options: [{ label: 'Fast' }] }] } as PendingWait<'question'>['payload'], vi.fn())
-    // A matching entry takes the composer over.
-    const renderSlotChain = vi.fn(() => <div>question takeover</div>) as unknown as ConversationRootProps['renderSlotChain']
-    bench([tab('chat', 'Chat')], undefined, { pending: [wait] }, renderSlotChain)
-    expect(screen.getByText('question takeover')).toBeTruthy()
-    expect(screen.queryByPlaceholderText(/输入消息/)).toBeNull()
-    // The owner dispatches the raw pending list (chain currency); routing
-    // lives in entry selectors, not here.
-    expect(renderSlotChain).toHaveBeenCalledWith(
-      'conversation.composer',
-      expect.objectContaining({
-        interactions: expect.arrayContaining([expect.objectContaining({ key: 'q:rq' })]),
-      }),
-      expect.objectContaining({ fallback: expect.anything() }),
-    )
-    cleanup()
-    // Zero registered entries (default all-decline stub): the fallback IS the
-    // default InputBar — behavior equals the pre-chain composer.
-    bench([tab('chat', 'Chat')], undefined, { pending: [wait] })
-    expect(screen.getByPlaceholderText(/输入消息/)).toBeTruthy()
-  })
-})
-
-describe('DetailsPanel', () => {
-  function benchDetails(snapshot: Partial<FakeSnapshot>, selection: SelectionTarget | null) {
-    const { useSession } = fakeSession(snapshot)
-    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}
-        useSessions={useSessions}
-        useStore={bindSnapshotSelector(chat)}
-        actions={chat.actions}
-        closeDetails={closeDetails}
-      />)
-    return { closeDetails, chat }
+  const workspaces = createSnapshotStore<WorkspaceListState>(workspaceState([{ ...workspace('one'), sessionIds: [SID] }]))
+  const session = createSnapshotStore<ConversationSnapshot>(conversationSnapshot(
+    pendingPrompt === null ? 'active' : 'blank', pendingPrompt,
+  ))
+  const chat = createChatStore().create()
+  chat.actions.setDraft('ordinary draft')
+  const send = vi.fn()
+  const stop = vi.fn()
+  const open = vi.fn()
+  const updateSessionPrompt = vi.fn()
+  const retrySessionPrompt = vi.fn()
+  const renderSlot = ((_key: string, _owner: object, opts?: { only?: string }) => (
+    <div data-testid={`view-${opts?.only ?? 'all'}`} />
+  )) as ConversationRootProps['renderSlot']
+  const renderSlotChain = ((_key, _owner, opts) => opts?.fallback ?? null) as ConversationRootProps['renderSlotChain']
+  const SessionProvider: ConversationRootProps['SessionProvider'] = ({ children }) => <>{children(SID)}</>
+  const props: ConversationRootProps = {
+    sessionId: SID,
+    useSession: bindSnapshotSelector(session),
+    useSessions: bindSnapshotSelector(sessions),
+    useWorkspaces: bindSnapshotSelector(workspaces),
+    useStore: bindSnapshotSelector(chat),
+    actions: chat.actions,
+    renderSlot,
+    renderSlotChain,
+    SessionProvider,
+    views: { list: () => [{ id: 'chat', label: 'Chat' }], subscribe: () => () => {}, version: () => 1 },
+    send,
+    stop,
+    open,
+    updateSessionPrompt,
+    retrySessionPrompt,
   }
+  const view = render(<ConversationRoot {...props} />)
+  return { view, chat, send, open, updateSessionPrompt, retrySessionPrompt }
+}
 
-  it('renders the selected call args and result off the shared store; close fires the injected callback', () => {
-    const { closeDetails } = benchDetails({
-      nodes: [{
-        kind: 'tool-result', seq: 1, time: 1_000, callId: 'c1',
-        call: { name: 'bash', argsRaw: '{"cmd":"ls"}' },
-        callTime: 500,
-        content: [{ type: 'text', text: 'file-a\nfile-b' }],
-        isError: false, callView: null, resultView: null,
-      }],
-    }, { turnSeq: 1, callId: 'c1' })
-    expect(screen.getByText('bash')).toBeTruthy()
-    expect(screen.getByText(/"cmd": "ls"/)).toBeTruthy()
-    expect(screen.getByText(/file-a/)).toBeTruthy()
-    fireEvent.click(screen.getByRole('button', { name: '关闭详情' }))
-    expect(closeDetails).toHaveBeenCalledTimes(1)
+describe('ConversationRoot draft ownership', () => {
+  it('keeps ordinary per-Session composer text in the chat store and selects through runtime actions', () => {
+    const b = mountConversation()
+    const box = b.view.getByRole('textbox')
+    expect((box as HTMLTextAreaElement).value).toBe('ordinary draft')
+    fireEvent.change(box, { target: { value: 'ordinary revised' } })
+    expect(b.chat.store.getSnapshot().draft).toBe('ordinary revised')
+    fireEvent.keyDown(box, { key: 'Enter' })
+    expect(b.send).toHaveBeenCalledWith('ordinary revised', 'queue')
+    fireEvent.click(b.view.getByRole('button', { name: 'Root' }))
+    expect(b.open).toHaveBeenCalledWith(sid('root'))
   })
 
-  it('shows the empty hint without a selection and the running state for open calls', () => {
-    benchDetails({ runningCalls: [{ callId: 'c9', name: 'bash', argsRaw: '{}', turn: 1, step: 1, time: 1_000, callView: null }] }, null)
-    expect(screen.getByText(/点击消息流中的工具行/)).toBeTruthy()
-    cleanup()
-    benchDetails({ runningCalls: [{ callId: 'c9', name: 'bash', argsRaw: '{}', turn: 1, step: 1, time: 1_000, callView: null }] }, { turnSeq: 1, callId: 'c9' })
-    expect(screen.getByText('运行中…')).toBeTruthy()
-  })
-
-  it('reports an out-of-window call distinctly', () => {
-    benchDetails({}, { turnSeq: 1, callId: 'ghost' })
-    expect(screen.getByText(/不在当前窗口内/)).toBeTruthy()
+  it('reads a retained prompt from useSession and edits/retries it through the scoped Session', () => {
+    const b = mountConversation({
+      workspaceId: wid('one'), text: 'retry me', phase: 'failed',
+      retry: 'send', error: 'offline',
+    })
+    const box = b.view.getByRole('textbox')
+    expect((box as HTMLTextAreaElement).value).toBe('retry me')
+    expect(b.view.getByRole('alert').textContent).toBe('Message send failed: offline')
+    fireEvent.change(box, { target: { value: 'revised prompt' } })
+    expect(b.updateSessionPrompt).toHaveBeenCalledWith('revised prompt')
+    expect(b.chat.store.getSnapshot().draft).toBe('ordinary draft')
+    fireEvent.keyDown(box, { key: 'Enter' })
+    expect(b.retrySessionPrompt).toHaveBeenCalledOnce()
+    expect(b.send).not.toHaveBeenCalled()
   })
 })