Merge remote-tracking branch 'github/master' into xtr/trajectory-inspection-ui

# Conflicts: # packages/client/runtime/src/client/sessions/session.ts # packages/client/ui-conversation/README.i18n.yaml # packages/client/ui-conversation/README.md # packages/client/ui-conversation/README.zh.md
2026-07-29 09:48:24 +08:00
parent 95574a8ec1 1f242753ec
commit c60d3f2aaa
356 changed files with 8801 additions and 1511 deletions
--- a/packages/client/ui-conversation/README.i18n.yaml
+++ b/packages/client/ui-conversation/README.i18n.yaml
@@ -2,5 +2,5 @@
 # side as of the last confirmed-consistent state. Both languages carry equal authority;
 # after editing either side, bring the other along and re-record with:
 #   pnpm run verify-translation-pairing --write packages/client/ui-conversation/README.md
-README.md: b5067a0a4ad98b784439fa16211b6269fc44139d
-README.zh.md: 5a8ba493c25f38d8be366d29462a258d8ba79ee9
+README.md: 7ab9cd3a065d6dd87c47dfc7056738351813a889
+README.zh.md: e38cb9ab837212546dd9680d5f2bf37865cb7e28
--- a/packages/client/ui-conversation/README.md
+++ b/packages/client/ui-conversation/README.md
@@ -16,7 +16,7 @@ The todo surfaces are two registrations over that shape, both plain registrant p

 Per-session UI state for selection and the active view lives in the declared chat store (`stores.ts` `createChatStore`); the InputHub owns the composer state machine and mirrors its draft into that store for persistence. Apply passes one store handle to the strict session subtree, chat view, and details registrations, so each session shares one instance and the framework owns its lifecycle. Components are pure: the framework standard kit supplies `useSession`/`sessionId`, global `useSessions`/`useWorkspaces`, and the input machine's `useInput`/`inputActions`; store faces and inject factories supply the remaining state and callbacks.

-The composer bar declares session-scoped single seats for `'conversation.input.plan'` and `'conversation.input.model'`, plus list slots for overlay, dock, left, and right input extensions. InputBar renders the model seat immediately before its pending indicator and send/stop button. Feature packages own each control and its state; ui-conversation supplies placement, the `locked` owner prop, and the standard slot shares. A pending composer takeover remains mounted when another conversation view is active so the blocked agent can still receive its answer; without a pending interaction, the active-session composer belongs to Chat. The resident no-session shell uses `DisabledInputBar` and therefore dispatches no session-scoped control seats.
+The composer bar declares session-scoped single seats for `'conversation.input.plan'` (right of the local access-mode control) and `'conversation.input.model'` (immediately before the pending indicator and send/stop button), plus list slots for overlay, dock, left, and right input extensions. Feature packages own each control and its state; ui-conversation supplies placement, the `locked` owner prop, and the standard slot shares. While the `plan` projection's effective target is plan mode, InputBar swaps its textarea placeholder to the plan-task wording (a host-folded value read through the standard-kit `useProjection`; owner-supplied placeholders win). A pending composer takeover remains mounted when another conversation view is active so the blocked agent can still receive its answer; without a pending interaction, the active-session composer belongs to Chat. The resident no-session shell uses `DisabledInputBar` and therefore dispatches no session-scoped control seats.

 `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).

--- a/packages/client/ui-conversation/README.zh.md
+++ b/packages/client/ui-conversation/README.zh.md
@@ -16,7 +16,7 @@ todo 两个面就是在该形状上的两个注册项，都是普通注册方插

 逐 Session UI 状态中的选择与活跃视图位于已声明的聊天 store（`stores.ts` `createChatStore`）中；InputHub 拥有输入区状态机，并将草稿镜像到该 store 以便持久化。apply 将同一个 store handle 传给严格限定于会话的子树、聊天视图和详情注册，因此每个会话内共享一个实例，框架拥有其生命周期。组件保持纯粹：框架标准工具包提供 `useSession`／`sessionId`、全局 `useSessions`／`useWorkspaces`，以及输入状态机的 `useInput`／`inputActions`；store 表层与 inject factory 提供其余状态和回调。

-输入栏为 `'conversation.input.plan'` 和 `'conversation.input.model'` 声明会话作用域的单实例 seat，并为 overlay、dock、left 和 right 输入扩展声明列表 slot。InputBar 将模型 seat 渲染在 pending 指示器与发送／停止按钮之前。各功能包拥有相应控件及其状态；ui-conversation 提供放置位置、`locked` owner prop 和标准 slot share。另一个会话视图活跃时，待处理的 composer 接管仍保持挂载，使被阻塞的 agent（智能体）仍能收到回答；没有待处理交互时，活跃会话的 composer 归 Chat 所有。常驻无会话壳使用 `DisabledInputBar`，因此不会分发任何会话作用域的控件 seat。
+输入栏声明两个会话作用域的单实例 seat：`'conversation.input.plan'` 位于本地 access 模式控件右侧，而 `'conversation.input.model'` 紧接在 pending 指示器与发送／停止按钮之前；它还为 overlay、dock、left 和 right 输入扩展声明列表 slot。各功能包拥有相应控件及其状态；ui-conversation 提供放置位置、`locked` owner prop 和标准 slot share。当 `plan` 投影的有效目标为 plan mode 时，InputBar 会将文本框的 placeholder 切换为 plan 任务文案（它通过标准工具包的 `useProjection` 读取由 host 折叠的值；owner 提供的 placeholder 优先）。另一个会话视图活跃时，待处理的 composer 接管仍保持挂载，使被阻塞的 agent（智能体）仍能收到回答；没有待处理交互时，活跃会话的 composer 归 Chat 所有。常驻无会话壳使用 `DisabledInputBar`，因此不会分发任何会话作用域的控件 seat。

 `src/client/` 按未来的包拆分组织：`contract/` 是唯一的跨领域共享表层（`slots.ts` slot 声明 + 组合后的 slot props，包括工具行契约、`views.ts` 共享原语、`tool-call-model.ts`）；`skeleton/`、`chat/` 和 `toolviews/`（示例注册方）领域目录只导入 contract 文件，彼此绝不导入；`apply.ts` 是唯一允许导入全部三个领域的组装点。`/client` 导出表层只包含契约：`apply`／`inject`、两个服务类和 `contract/` 类型家族；实现组件（骨架、聊天行）与 store factory 保持内部状态，只能通过 apply 的 slot 注册到达页面（测试通过 `./src/*` 子路径获取它们）。

--- a/packages/client/ui-conversation/package.json
+++ b/packages/client/ui-conversation/package.json
@@ -49,6 +49,7 @@
  },
  "devDependencies": {
    "@deepseek-ai/dsh-client-runtime": "workspace:^",
+    "@deepseek-ai/dsh-plan-mode": "workspace:^",
    "@deepseek-ai/dsh-session-projection": "workspace:^",
    "@deepseek-ai/dsh-tool-todo": "workspace:^",
    "@deepseek-ai/dsh-client-ui-layout": "workspace:^",
--- a/packages/client/ui-conversation/src/client/apply.ts
+++ b/packages/client/ui-conversation/src/client/apply.ts
@@ -1,7 +1,7 @@
 /** Registers the conversation components, shared store, and service callbacks. */
 import type { Context } from 'cordis'
 import type { BoundActions } from '@deepseek-ai/dsh-client-ui-slots'
-import type { SessionId, SessionsService } from '@deepseek-ai/dsh-client-runtime/client'
+import type { ISessions, SessionId } from '@deepseek-ai/dsh-client-runtime/client'
 import type {} from '@deepseek-ai/dsh-client-ui-layout/client'
 import type { ViewTab } from './contract/views.ts'
 import type {
@@ -10,6 +10,7 @@ import type {
 import { resolveToolPath } from './contract/tool-call-model.ts'
 import { createChatStore } from './stores.ts'
 import { ConversationService } from './service.ts'
+import type { IConversation } from './service.ts'
 import { InputHub } from './input/hub.ts'
 import { InputBar } from './skeleton/InputBar.tsx'
 import { ChatView } from './chat/ChatView.tsx'
@@ -24,8 +25,8 @@ import { DetailsPanel } from './skeleton/DetailsPanel.tsx'
 /** Services required by the conversation plugin. */
 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 {
+/** Resolve the session-scoped conversation face (scope-addressed send/cancel), failing loud. */
+function scopedConversation(sessions: ISessions, id: SessionId): IConversation {
  const scoped = sessions.scope(id)
  if (scoped === undefined) throw new Error(`ui-conversation: session "${id}" resolved no scope`)
  const conversation = scoped.get('conversation')
@@ -129,8 +130,9 @@ export function apply(ctx: Context): void {
  // verbs ride this inject (package-internal — hub and bar are one plugin).
  slots.register({
    name: 'conversation.composer.bar',
-    // The two named control seats in the bar's tool row (plan left, model
-    // right); empty until their owning plugins register (B ruling).
+    // The two named control seats in the bar's tool row (plan beside the
+    // access control, model right); empty until their owning plugins
+    // register (B ruling).
    children: {
      'conversation.input.plan': { kind: 'single', scope: 'session' },
      'conversation.input.model': { kind: 'single', scope: 'session' },
--- a/packages/client/ui-conversation/src/client/chat/ChatView.tsx
+++ b/packages/client/ui-conversation/src/client/chat/ChatView.tsx
@@ -375,7 +375,9 @@ export function ChatView({ useSession, useSessions, useStore, renderSlot, sessio
              ))}
            </div>
          )}
-          {pending.map(item => <PendingCard key={item.key} item={item} />)}
+          {pending.map(item => item.kind === 'approval'
+            ? <PendingCard key={item.key} item={item} />
+            : null)}
          {/* Turn-level loading signal: rides the whole running turn (first-token
              wait, tool execution, streaming) so it never flickers per step. */}
          {running && <TurnDots />}
--- a/packages/client/ui-conversation/src/client/chat/GenericToolCard.tsx
+++ b/packages/client/ui-conversation/src/client/chat/GenericToolCard.tsx
@@ -6,12 +6,12 @@

 import type { ReactNode } from 'react'
 import {
-  IconApiOutline14, IconBrowseOutline16, IconCodeOutline16, IconEditOutline16, IconSearchOutline16, IconThinkOutline14,
+  IconApiOutline14, IconBrowseOutline16, IconCodeOutline16, IconEditOutline16, IconSearchOutline16, IconSparkle16,
+  IconThinkOutline14,
 } from '@deepseek-ai/dsh-client-ui-primitives'
 import type { ToolRowOwnerProps } from '../contract/slots.ts'
 import { toolRowModel, type ToolRowVariant } from '../contract/tool-call-model.ts'
 import { ToolRow } from './ToolRow.tsx'
-import { IconSparkle16 } from './IconSparkle16.tsx'

 /** Variant leading icons (figma table); all glyphs render at 14 inside the 16px leading box. */
 const VARIANT_ICONS: Record<ToolRowVariant, ReactNode> = {
--- a/packages/client/ui-conversation/src/client/chat/IconSparkle16.tsx
+++ b/packages/client/ui-conversation/src/client/chat/IconSparkle16.tsx
@@ -1,15 +0,0 @@
-// Local sparkle icon for the Others tool-row variant (figma 43:31850 leading
-// glyph is an SF Symbols "sparkles" text glyph — not extractable as vector
-// data, so this is a hand-authored three-star approximation). Lives here
-// rather than ui-primitives until the exact glyph is exported and adopted
-// into the ic_ds_* family.
-
-export function IconSparkle16({ size = 16, className }: { size?: number; className?: string }) {
-  return (
-    <svg width={size} height={size} className={className} viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
-      <path d="M6.1 3.1Q6.6 7.8 11.3 8.3Q6.6 8.8 6.1 13.5Q5.6 8.8 0.9 8.3Q5.6 7.8 6.1 3.1Z" fill="currentColor" />
-      <path d="M11.9 1Q12.2 3.7 14.9 4Q12.2 4.3 11.9 7Q11.6 4.3 8.9 4Q11.6 3.7 11.9 1Z" fill="currentColor" />
-      <path d="M12.5 9.4Q12.7 11.4 14.7 11.6Q12.7 11.8 12.5 13.8Q12.3 11.8 10.3 11.6Q12.3 11.4 12.5 9.4Z" fill="currentColor" />
-    </svg>
-  )
-}
--- a/packages/client/ui-conversation/src/client/chat/PendingCard.tsx
+++ b/packages/client/ui-conversation/src/client/chat/PendingCard.tsx
@@ -1,30 +1,19 @@
-// PendingCard: approval/question placeholder card (visible, not answerable —
-// the composer-takeover approval panel is a P-II item; wire pending semantics
-// already exist so the flow must show them).
+// PendingCard: display-only approval placeholder. Questions render exclusively
+// through the composer takeover so the same pending wait is never shown twice.

 import { memo } from 'react'
-import type { PendingInteraction } from '@deepseek-ai/dsh-client-runtime/client'
-import { JsonBlock } from '@deepseek-ai/dsh-client-ui-primitives'
+import type { PendingWait } from '@deepseek-ai/dsh-client-runtime/client'
 import css from './PendingCard.module.css'

 export interface PendingCardProps {
-  item: PendingInteraction
+  item: PendingWait<'approval'>
 }

 export const PendingCard = memo(function PendingCard({ item }: PendingCardProps) {
  return (
    <div className={css.card}>
-      {item.kind === 'approval' ? (
-        <>
-          <div className={css.title}>等待审批：<span className={css.mono}>{item.payload.toolName}</span></div>
-          {item.payload.reason !== undefined && <div className={css.reason}>{item.payload.reason}</div>}
-        </>
-      ) : (
-        <>
-          <div className={css.title}>等待回答（{item.payload.questions.length} 题）</div>
-          <JsonBlock label="问题内容" payload={item.payload.questions} />
-        </>
-      )}
+      <div className={css.title}>等待审批：<span className={css.mono}>{item.payload.toolName}</span></div>
+      {item.payload.reason !== undefined && <div className={css.reason}>{item.payload.reason}</div>}
      <div className={css.hint}>请在原客户端处理（web 端作答后续里程碑提供）</div>
    </div>
  )
--- a/packages/client/ui-conversation/src/client/contract/slots.ts
+++ b/packages/client/ui-conversation/src/client/contract/slots.ts
@@ -83,9 +83,10 @@ declare module '@deepseek-ai/dsh-client-ui-slots' {
     */
    'conversation.composer.bar': { kind: 'single'; scope: 'session'; owner: ComposerBarOwnerProps }
    /**
-     * The Plan-mode control seat in the composer tool row (left group).
-     * Declared by the composer-bar entry; empty until a plan plugin
-     * registers (B ruling: no placeholder fallback).
+     * The Plan-mode status seat in the composer tool row (left group,
+     * right of the access-mode control). Declared by the composer-bar
+     * entry; empty until a plan plugin registers (B ruling: no placeholder
+     * fallback).
     */
    'conversation.input.plan': { kind: 'single'; scope: 'session'; owner: InputControlOwnerProps }
    /**
--- a/packages/client/ui-conversation/src/client/index.ts
+++ b/packages/client/ui-conversation/src/client/index.ts
@@ -3,10 +3,9 @@
 * between the independently implemented skeleton and chat domains; `apply.ts`
 * owns their slot assembly.
 */
-import type { ConversationService } from './service.ts'
-
 export { apply, inject } from './apply.ts'
 export { ConversationService } from './service.ts'
+export type { IConversation } from './service.ts'

 export type {
  CallId, ChatStoreState, SelectionTarget, ViewTab,
@@ -22,6 +21,7 @@ export type {

 declare module 'cordis' {
  interface Context {
-    conversation: ConversationService
+    /** The outward face only; the concrete service stays inside this plugin. */
+    conversation: import('./service.ts').IConversation
  }
 }
--- a/packages/client/ui-conversation/src/client/input/hub.ts
+++ b/packages/client/ui-conversation/src/client/input/hub.ts
@@ -8,9 +8,8 @@
 * bail events) and owns the default-sink choreography: every session is a
 * real host entity, so the sink is one unconditional prompt path.
 */
-import type { ClientContext, Session, SessionBinding, SessionId, SessionsService } from '@deepseek-ai/dsh-client-runtime/client'
-import type { SlashController, SlashServiceContract } from '@deepseek-ai/dsh-client-ui-slash/client'
-import type {} from '@deepseek-ai/dsh-client-ui-slash/client'
+import type { ClientContext, ISessions, SessionBinding, SessionFace, SessionId } from '@deepseek-ai/dsh-client-runtime/client'
+import type { SlashController } from '@deepseek-ai/dsh-client-ui-slash/client'
 import { queueReadFaceOf } from '../queue/store.ts'
 import type { ComposerKeyboard, InputService, SessionInput } from './contract.ts'
 import type { PopupDismissFace } from './facade.ts'
@@ -113,7 +112,7 @@ export class InputHub implements InputService {
   * exactly one path; a failed first prompt is an ordinary prompt failure
   * (error strip via promptError, draft restored only while untouched).
   */
-  private sink(session: Session, text: string, mode: 'queue' | 'steer'): void {
+  private sink(session: SessionFace, text: string, mode: 'queue' | 'steer'): void {
    if (text === '') return
    const shell = this.shells.get(session.sessionId)
    // Commit, not an editable clear: undo must not resurrect sent content.
@@ -129,7 +128,7 @@ export class InputHub implements InputService {
  }

  private controller(actx: ClientContext): SlashController | undefined {
-    const slash = this.rootCtx.get('slash') as SlashServiceContract | undefined
+    const slash = this.rootCtx.get('slash')
    return slash?.sessionOf(actx)
  }

@@ -138,7 +137,7 @@ export class InputHub implements InputService {
    return command?.popupFor(actx)
  }

-  private sessions(): SessionsService {
+  private sessions(): ISessions {
    const sessions = this.rootCtx.get('sessions')
    if (sessions === undefined) throw new Error('conversation.input: sessions service unavailable')
    return sessions
--- a/packages/client/ui-conversation/src/client/queue/store.ts
+++ b/packages/client/ui-conversation/src/client/queue/store.ts
@@ -5,7 +5,7 @@
 * reference-stable across unrelated snapshot swaps, so this is a pure
 * projection — no second store, no copy.
 */
-import type { ObservableSnapshot, Session } from '@deepseek-ai/dsh-client-runtime/client'
+import type { ObservableSnapshot, SessionFace } from '@deepseek-ai/dsh-client-runtime/client'
 import type { QueuedMessage } from '../input/contract.ts'

 /**
@@ -13,10 +13,10 @@ import type { QueuedMessage } from '../input/contract.ts'
 * The wiring layer (T5) overlays this onto InputState.queue; the runtime
 * QueuedMessage and the input-contract QueuedMessage are structurally the
 * same frozen shape ({key, preview}).
- * @param session - the resident session instance.
+ * @param session - the resident session face.
 * @returns the queue read face (snapshot reference stable while the queue is unchanged).
 */
-export function queueReadFaceOf(session: Session): ObservableSnapshot<readonly QueuedMessage[]> {
+export function queueReadFaceOf(session: SessionFace): ObservableSnapshot<readonly QueuedMessage[]> {
  return {
    getSnapshot: () => session.getSnapshot().queue,
    subscribe: fn => session.subscribe(fn),
--- a/packages/client/ui-conversation/src/client/service.ts
+++ b/packages/client/ui-conversation/src/client/service.ts
@@ -12,24 +12,50 @@ import type { Context } from 'cordis'
 // Type-only imports: a plugin-to-plugin value import is a bundle purity
 // error, so scope resolution goes through the sessions service (scopeOf
 // method) instead of the standalone helper.
-import type { Session, SessionId, SessionsService } from '@deepseek-ai/dsh-client-runtime/client'
-import { InputHub } from './input/hub.ts'
+import type { ISessions, SessionFace, SessionId } from '@deepseek-ai/dsh-client-runtime/client'
+import type { InputService } from './input/contract.ts'
+
+/**
+ * The outward conversation face (`ctx.conversation`): the scope-addressed
+ * verbs and the input registry other plugins may reach — and exactly what a
+ * test fake must supply.
+ */
+export interface IConversation {
+  /** The per-session input machine registry (InputService face). */
+  readonly input: InputService
+  /**
+   * Send a prompt into the caller scope's session.
+   * @param text - prompt text, sent verbatim as one text block.
+   * @param mode - queue after the current turn, or steer into it.
+   * @returns completion; business failures reject (and land in promptError).
+   */
+  send(text: string, mode: 'queue' | 'steer'): Promise<void>
+  /**
+   * Cancel the scoped session's in-flight turn.
+   * @returns completion; failures reject as in send.
+   */
+  cancel(): Promise<void>
+  /**
+   * Pull one older history page for the scoped session.
+   * @returns completion of the page pull.
+   */
+  loadOlder(): Promise<void>
+}

 /** Scope-addressed conversation service (root singleton, provided as `conversation`). */
-export class ConversationService extends Service {
+export class ConversationService extends Service implements IConversation {
  /** The per-session input machine registry (InputService face, design §5.2). */
-  readonly input: InputHub
+  readonly input: InputService

  /**
   * @param ctx - owning root context (the plugin apply context; the service
   * registers itself and follows that fiber's lifetime).
-   * @param config - the shared InputHub constructed by the plugin apply
-   * (shared with the slot inject factories); absent = own instance
-   * (object-layer tests that never touch slots).
+   * @param config - carries the InputService instance constructed by the
+   * plugin apply (the same InputHub the slot inject factories close over).
   */
-  constructor(ctx: Context, config?: { input?: InputHub }) {
+  constructor(ctx: Context, config: { input: InputService }) {
    super(ctx, 'conversation')
-    this.input = config?.input ?? new InputHub(ctx)
+    this.input = config.input
  }

  /**
@@ -57,8 +83,8 @@ export class ConversationService extends Service {
    await this.scopedSession('loadOlder').loadOlder()
  }

-  /** Resolve the caller scope's Session or throw on root contexts. */
-  private scopedSession(op: string): Session {
+  /** Resolve the caller scope's session face or throw on root contexts. */
+  private scopedSession(op: string): SessionFace {
    const id = this.scopeId(op)
    const binding = this.requireSessions().binding(id)
    if (binding === undefined) throw new Error(`conversation.${op}: session "${id}" resolved no binding`)
@@ -74,10 +100,9 @@ export class ConversationService extends Service {
    return id
  }

-  private requireSessions(): SessionsService {
-    // ctx.get instead of ctx.sessions: the typed Context merge is suspended
-    // while the client/host `sessions` declaration collision awaits
-    // arbitration (see the runtime package's Context merge note).
+  private requireSessions(): ISessions {
+    // Strict ctx.get, not the injection proxy: the scope-addressed pattern
+    // reads the service off whatever context the tracker rebound.
    const sessions = this.ctx.get('sessions')
    if (sessions === undefined) throw new Error('conversation: sessions service unavailable')
    return sessions
--- a/packages/client/ui-conversation/src/client/skeleton/InputBar.tsx
+++ b/packages/client/ui-conversation/src/client/skeleton/InputBar.tsx
@@ -10,6 +10,9 @@ import { useEffect, useRef, useState } from 'react'
 import type { ChangeEvent, KeyboardEvent, MouseEvent, ReactNode } from 'react'
 import clsx from 'clsx'
 import { IconPlusOutline16 } from '@deepseek-ai/dsh-client-ui-primitives'
+// Type-only: the `plan` projection key merge (the TodoDock posture — the
+// composer reads a host-computed value; the domain owns the key).
+import type {} from '@deepseek-ai/dsh-plan-mode/client'
 import type { ComposerBarProps } from '../contract/slots.ts'
 import { deriveDecorations } from '../input/decorations.ts'
 import css from './InputBar.module.css'
@@ -28,7 +31,7 @@ const READONLY_OPTIONS: readonly { id: string; label: string }[] = [
 ]

 export function InputBar({
-  useSession, useInput, inputActions, keyboard, stop, renderSlot, useNotices, useLexicon,
+  useSession, useInput, inputActions, keyboard, stop, renderSlot, useNotices, useLexicon, useProjection,
  variant, placeholder, accessory, overlay, leftItems, rightItems, onAdd, addLabel = 'Add attachment',
 }: InputBarProps) {
  const input = useInput(s => s)
@@ -37,6 +40,9 @@ export function InputBar({
  const promptError = useSession(s => s.promptError)
  const running = useSession(s => s.running)
  const disabled = useSession(s => s.removed)
+  // Plan mode swaps the textarea placeholder (the projection is the folded
+  // host value; owner-prop placeholders — hero, session-unavailable — win).
+  const planActive = useProjection('plan', plan => plan !== undefined && (plan.pending ? !plan.active : plan.active))
  // Prompt failures are ordinary failures (no create/attach transaction
  // exists anymore): the strip renders promptError, the draft stays in the
  // machine, and the user resubmits.
@@ -334,7 +340,9 @@ export function InputBar({
            disabled={locked}
            readOnly={machineBusy}
            data-phase={input.phase}
-            placeholder={placeholder ?? (disabled ? 'Session unavailable' : 'Message the agent')}
+            placeholder={placeholder ?? (disabled
+              ? 'Session unavailable'
+              : planActive ? 'describe your task to generate plan' : 'Message the agent')}
            rows={2}
            onChange={onChange}
            onKeyDown={onKeyDown}
@@ -361,15 +369,15 @@ export function InputBar({
              <IconPlusOutline16 size={14} />
            </button>
            <div className={css.modes}>
-              {renderSlot('conversation.input.plan', { locked })}
              {accessSelect}
+              {renderSlot('conversation.input.plan', { locked })}
            </div>
            {leftItems}
          </div>
          <div className={css.trailing}>
            {rightItems}
            {renderSlot('conversation.input.model', { locked })}
-            {machineBusy && <span className={css.pending} data-input-pending aria-label="处理中" />}
+            {/* {machineBusy && <span className={css.pending} data-input-pending aria-label="处理中" />} */}
            <button
              type="button"
              className={css.primary}
--- a/packages/client/ui-conversation/tests/apply-inject.spec.tsx
+++ b/packages/client/ui-conversation/tests/apply-inject.spec.tsx
@@ -1,144 +1,74 @@
 // @vitest-environment jsdom
 // apply inject factories exercised end to end against the terminal thin
-// shape: the conversation surface (views triple, send choreography incl.
-// optimistic clear + failure restore THROUGH the declared store actions,
-// openDetails = select action + layout orchestration, sessions.open
-// 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).
+// shape: the strict session surface (views triple, draft mirror), the
+// provide-channel input face (machine-sink submit choreography incl.
+// optimistic clear + failure restore), the resident surface (selectWorkspace
+// draft carrying), the composer-bar stop face, openDetails = select action +
+// layout orchestration, and the closeDetails details surface. Complements
+// chat-apply.spec.tsx (registration) and selection-survival.spec.tsx (store
+// axis). History opening is NOT an inject concern — the runtime sessions
+// service opens on watch (sessions-service.spec.ts owns that behavior).
+//
+// The inject surfaces are read off the ledger entries deliberately (typed at
+// this spec's own contract): these cases pin factory choreography the UI
+// guards would mask. Rendering-path acceptance lives in
+// chat-toolview-slot.spec.tsx.

-import { Context } from 'cordis'
-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, WorkspaceListState,
-} from '@deepseek-ai/dsh-client-runtime/client'
-import type { SlotRendererHost } from '@deepseek-ai/dsh-client-web-react'
+import { describe, expect, it, vi } from 'vitest'
+import { SlotTestRuntime } from '@deepseek-ai/dsh-client-test-runtime'
+import type { SessionBehaviorOverrides } from '@deepseek-ai/dsh-client-test-runtime'
+import type { ISession, SessionId } from '@deepseek-ai/dsh-client-runtime/client'
 import { apply, inject } from '@deepseek-ai/dsh-client-ui-conversation/client'
 import type {
  ChatViewInjected, ComposerBarInjected, ConversationInjected, ConversationSessionInjected, DetailsInjected,
 } from '@deepseek-ai/dsh-client-ui-conversation/client'
 import type { createChatStore } from '../src/client/stores.ts'

-afterEach(cleanup)
-
 const ROOT = 'root-1' as SessionId

 type ChatInstance = ReturnType<ReturnType<typeof createChatStore>['create']>
 type ChatActions = ChatInstance['actions']

-const SCOPE_TAG: symbol = (() => {
-  const recorded: (string | symbol)[] = []
-  const spy = new Proxy(new Context(), {
-    get(target, prop, receiver) {
-      recorded.push(prop)
-      // Reflect.get is typed any; the probe only records property names.
-      // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-      return Reflect.get(target, prop, receiver)
-    },
-  })
-  void scopeOf(spy)
-  const symbol = recorded.find((p): p is symbol => typeof p === 'symbol')
-  if (symbol === undefined) throw new Error('scopeOf probe recorded no symbol read')
-  return symbol
-})()
+/** ISession verb mocks, typed against the production face (['prompt'] etc. keep vitest mock ergonomics). */
+function sessionFakeFor() {
+  return {
+    open: vi.fn(() => Promise.resolve()),
+    loadOlder: vi.fn<ISession['loadOlder']>(() => Promise.resolve()),
+    loadAllHistory: vi.fn<ISession['loadAllHistory']>(() => Promise.resolve()),
+    prompt: vi.fn<ISession['prompt']>(() => Promise.resolve({ ok: true, value: { accepted: true } })),
+    cancel: vi.fn<ISession['cancel']>(() => Promise.resolve({ ok: true, value: { accepted: true } })),
+  } satisfies SessionBehaviorOverrides
+}

 async function bench() {
-  const ctx = new Context()
-  const slotsFiber = ctx.plugin(SlotsService)
-  await slotsFiber.await()
-  const slots = ctx.get('slots') as SlotsService
-
-  const listStore = createSnapshotStore<SessionListState>({
-    ids: [ROOT],
-    byId: { [ROOT]: { id: ROOT, title: 'R', displayTitle: 'R', cwd: '/proj', running: false, blank: false, updatedAt: 1 } },
-    current: ROOT,
-    phase: 'ready',
+  const runtime = await SlotTestRuntime.create()
+  const sessionFake = sessionFakeFor()
+  await runtime.sessions.add({
+    id: ROOT,
+    summary: { title: 'R', displayTitle: 'R', cwd: '/proj' },
+    session: sessionFake,
  })
-  const sessionFake = {
-    sessionId: ROOT,
-    open: vi.fn(() => Promise.resolve()),
-    loadOlder: vi.fn(() => Promise.resolve()),
-    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 } }>>(
-      () => Promise.resolve({ ok: true, value: { accepted: true } })),
-    // Observable face (the input machine's queue read face rides it).
-    getSnapshot: () => ({ queue: [] }),
-    subscribe: () => () => {},
-  }
-  const scopes = new Map<SessionId, Context>()
-  const mint = (id: SessionId): Context => {
-    let scoped = scopes.get(id)
-    if (scoped === undefined) {
-      scoped = ctx.plugin(() => {}).ctx.extend({ [SCOPE_TAG]: id })
-      scopes.set(id, scoped)
-    }
-    return scoped
-  }
-  type TestProvider = {
-    resolve(binding: { sessionId: SessionId; session: typeof sessionFake; ctx: Context }): {
-      hooks?: Record<string, unknown>
-      props?: Record<string, unknown>
-    }
-  }
-  const providers: TestProvider[] = []
-  const absentInfo = { sessionId: undefined, hooks: {}, props: {} }
-  const sessionsFake = {
-    list: listStore,
-    binding: (id: SessionId) => ({ sessionId: id, session: sessionFake, ctx: mint(id) }),
-    scope: (id: SessionId) => mint(id),
-    provideInfo: () => undefined,
-    currentProvideInfo: { getSnapshot: () => absentInfo, subscribe: () => () => {} },
-    provide: (descriptor: TestProvider) => { providers.push(descriptor); return () => {} },
-    scopeOf,
-    sessionOf: (actx: Context) => (scopeOf(actx) === undefined ? undefined : sessionFake),
-    open: vi.fn(),
-  }
-  ctx.provide('sessions', sessionsFake)
-  const workspaceStore = createSnapshotStore<WorkspaceListState>({
-    items: [], state: 'idle', phase: 'ready', error: null,
-    baselinesReady: true, recentWorkspaceId: undefined,
-  })
-  const workspacesFake = {
-    list: workspaceStore,
-    connectWorkspace: vi.fn(async () => ROOT),
-    openPath: vi.fn(async () => {}),
-  }
-  ctx.provide('workspaces', workspacesFake)
  const layoutFake = { openDetails: vi.fn(), closeDetails: vi.fn() }
-  ctx.provide('layout', layoutFake)
-  ctx.provide('locale', { bind: () => (key: string) => key })
+  runtime.provide('layout', layoutFake)

-  // The AppFrame role: the three conversation-package slots must be declared
-  // by a live entry before apply can contribute into them (the stand-in
-  // consumes renderSlot to satisfy the declare-means-render check).
-  slots.register({
-    name: 'root',
-    children: {
-      'conversation': { kind: 'single', scope: 'session-maybe' },
-      'details': { kind: 'single', scope: 'session' },
-    },
+  // The AppFrame role: the conversation-package slots must be declared by a
+  // live entry before apply can contribute into them.
+  await runtime.root.declare({
+    'conversation': { kind: 'single', scope: 'session-maybe' },
+    'details': { kind: 'single', scope: 'session' },
  }, (_p: { renderSlot?: unknown }) => null)

-  const fiber = ctx.plugin({ inject: [...inject], apply })
-  await fiber.await()
+  const feature = await runtime.mount({ inject: [...inject], apply })

-  // Reach the render-side entry view (inject + store handle) the way the
-  // renderer does: through the host face.
-  let host: SlotRendererHost | undefined
-  slots.install({ renderRoot: (h) => { host = h; return null } })
-  slots.renderSlot('root', {})
-  const hostFace = host!
-  const entryOf = (key: 'conversation' | 'conversation.session' | 'conversation.composer.bar' | 'conversation.view' | 'details') => hostFace.entriesOf(key)[0]!
+  // The host face (store resolution) exists only inside the installed
+  // renderer, so materialize it the way the shell does.
+  runtime.renderRoot()
+  const entryOf = (key: 'conversation' | 'conversation.session' | 'conversation.composer.bar' | 'conversation.view' | 'details') =>
+    runtime.slots.entries(key)[0]!
  /** Resolve store instance + call the inject the way the outlet would. */
  const conversationSurface = (id: SessionId) => {
    const entry = entryOf('conversation.session')
-    const instance = hostFace.storeOf(entry, id) as ChatInstance
+    const instance = runtime.storeOf('conversation.session', id) as ChatInstance
    const injected = (entry.inject as unknown as (sessionId: SessionId, actions: ChatActions) => ConversationSessionInjected)(
      id, instance.actions)
    return { instance, injected }
@@ -154,27 +84,28 @@ async function bench() {
  /** Same resolution for the chat entry riding the view ring. */
  const chatViewSurface = (id: SessionId) => {
    const entry = entryOf('conversation.view')
-    const instance = hostFace.storeOf(entry, id) as ChatInstance
+    const instance = runtime.storeOf('conversation.view', id) as ChatInstance
    const injected = (entry.inject as unknown as (sessionId: SessionId, actions: ChatActions) => ChatViewInjected)(
      id, instance.actions)
    return { instance, injected }
  }
  /** Materialize the input provide contribution the way the runtime does. */
  const inputSurface = (id: SessionId) => {
-    const contribution = providers[0]!.resolve(sessionsFake.binding(id))
-    const state = contribution.hooks!['input'] as {
+    const info = runtime.sessions.provideInfo(id)!
+    const state = info.hooks['input'] as {
      getSnapshot: () => { draft: string }
      subscribe: (fn: () => void) => () => void
    }
-    const actions = contribution.props!['inputActions'] as {
+    const actions = info.props['inputActions'] as {
      setDraft: (text: string) => void
      submit: (mode?: 'queue' | 'steer') => void
    }
    return { state, actions }
  }
  return {
-    ctx, slots, hostFace, entryOf, conversationSurface, residentSurface, composerSurface, chatViewSurface, inputSurface,
-    sessionFake, sessionsFake, workspacesFake, layoutFake, mint,
+    runtime, feature, slots: runtime.slots, entryOf,
+    conversationSurface, residentSurface, composerSurface, chatViewSurface, inputSurface,
+    sessionFake, layoutFake,
  }
 }

@@ -190,6 +121,7 @@ describe('conversation slot inject surface', () => {
    const chatView = b.chatViewSurface(ROOT)
    chatView.injected.loadOlder()
    expect(b.sessionFake.loadOlder).toHaveBeenCalledTimes(1)
+    await b.runtime.dispose()
  })

  it('the provide-channel input face submits through the machine sink: trim, optimistic clear, failure restore without clobber', async () => {
@@ -208,14 +140,14 @@ describe('conversation slot inject surface', () => {
    await Promise.resolve()
    expect(b.sessionFake.prompt).toHaveBeenCalledWith([{ type: 'text', text: 'hello' }], 'queue')
    // Failure: restored (draft still empty when the rejection lands).
-    b.sessionFake.prompt.mockResolvedValueOnce({ ok: false, error: { code: 'agent-busy', message: 'b' } })
+    b.sessionFake.prompt.mockResolvedValueOnce({ ok: false, error: { code: 'agent-busy', message: 'b', details: { reason: 'b' } } })
    actions.setDraft('retry me')
    actions.submit('queue')
    await vi.waitFor(() => {
      expect(state.getSnapshot().draft).toBe('retry me')
    })
    // Failure landing after new typing: no clobber (restore fills empty only).
-    b.sessionFake.prompt.mockResolvedValueOnce({ ok: false, error: { code: 'agent-busy', message: 'b' } })
+    b.sessionFake.prompt.mockResolvedValueOnce({ ok: false, error: { code: 'agent-busy', message: 'b', details: { reason: 'b' } } })
    actions.submit('queue')
    actions.setDraft('typed during flight')
    await new Promise(r => setTimeout(r, 0))
@@ -229,23 +161,25 @@ describe('conversation slot inject surface', () => {
    expect(mirrored).toEqual(['mirrored text'])
    unbind()
    // Stop failure is swallowed (promptError owns the surface).
-    b.sessionFake.cancel.mockResolvedValueOnce({ ok: false, error: { code: 'internal', message: 'x' } })
+    b.sessionFake.cancel.mockResolvedValueOnce({ ok: false, error: { code: 'internal', message: 'x', details: {} } })
    b.composerSurface(ROOT).stop()
    await new Promise(r => setTimeout(r, 0))
    expect(b.sessionFake.cancel).toHaveBeenCalledTimes(1)
+    await b.runtime.dispose()
  })

-  it('inject fails loud when the session resolves no scope or the scope lacks the service', async () => {
+  it('inject fails loud when the session resolves no binding or the scope lacks the service', async () => {
    const b = await bench()
    const entry = b.entryOf('conversation.composer.bar')
    const injectFn = entry.inject as unknown as (sessionId: SessionId) => ComposerBarInjected
-    // Unknown session: sessions.scope answers nothing.
-    ;(b.sessionsFake.scope as unknown) = () => undefined
-    expect(() => { injectFn(ROOT).stop() }).toThrow(/resolved no scope/)
-    // A scope minted outside the service tree: no conversation service on it.
-    const foreign = new Context()
-    ;(b.sessionsFake.scope as unknown) = () => foreign.plugin(() => {}).ctx.extend({})
-    expect(() => { injectFn(ROOT).stop() }).toThrow(/unavailable through the session scope/)
+    // Unknown session: the keyboard face's binding resolution answers nothing.
+    expect(() => { injectFn('ghost' as SessionId).stop() }).toThrow(/resolved no binding/)
+    // A scope whose service tree lost 'conversation' (the feature fiber
+    // unloaded while a retained inject closure re-runs): fails loud too.
+    const stop = injectFn(ROOT).stop
+    await b.feature.dispose()
+    expect(() => { stop() }).toThrow(/unavailable through the session scope/)
+    await b.runtime.dispose()
  })

  it('openDetails (chat view face) writes the selection through the store actions and opens the panel', async () => {
@@ -258,6 +192,7 @@ describe('conversation slot inject surface', () => {
    // writes land where the skeleton and details read.
    const conv = b.conversationSurface(ROOT)
    expect(conv.instance).toBe(instance)
+    await b.runtime.dispose()
  })

  it('openFile (chat view face) resolves against session cwd and calls workspaces.openPath', async () => {
@@ -265,8 +200,9 @@ describe('conversation slot inject surface', () => {
    const { injected } = b.chatViewSurface(ROOT)
    injected.openFile('src/a.ts')
    await vi.waitFor(() => {
-      expect(b.workspacesFake.openPath).toHaveBeenCalledWith('/proj/src/a.ts')
+      expect(b.runtime.workspaces.calls).toContainEqual({ method: 'openPath', args: ['/proj/src/a.ts'] })
    })
+    await b.runtime.dispose()
  })

  it('routes navigation and workspace switching through the runtime owners, carrying the draft', async () => {
@@ -274,23 +210,73 @@ describe('conversation slot inject surface', () => {
    const { injected } = b.conversationSurface(ROOT)
    const resident = b.residentSurface(ROOT)
    injected.open(ROOT)
-    expect(b.sessionsFake.open).toHaveBeenCalledWith(ROOT)
+    expect(b.runtime.sessions.calls).toContainEqual({ method: 'open', args: [ROOT] })
    // Same-session connect (the picked workspace resolves to this session):
    // no draft movement, plain re-open.
+    b.runtime.workspaces.stub('connectWorkspace', () => Promise.resolve(ROOT))
    const { state, actions } = b.inputSurface(ROOT)
    actions.setDraft('carry me')
    void resident.selectWorkspace('workspace-1' as never)
-    await vi.waitFor(() => { expect(b.sessionsFake.open).toHaveBeenCalledTimes(2) })
-    expect(b.workspacesFake.connectWorkspace).toHaveBeenCalledWith('workspace-1')
+    await vi.waitFor(() => {
+      expect(b.runtime.sessions.calls.filter(c => c.method === 'open')).toHaveLength(2)
+    })
+    expect(b.runtime.workspaces.calls).toContainEqual({ method: 'connectWorkspace', args: ['workspace-1'] })
    expect(state.getSnapshot().draft).toBe('carry me')
    // Cross-session connect: the draft MOVES — the old machine empties, the
    // new session's machine receives the text, then navigation lands there.
    const OTHER = 'other-1' as SessionId
-    b.workspacesFake.connectWorkspace.mockResolvedValueOnce(OTHER)
+    await b.runtime.sessions.add({ id: OTHER }, { current: false })
+    b.runtime.workspaces.stub('connectWorkspace', () => Promise.resolve(OTHER))
    void resident.selectWorkspace('workspace-2' as never)
-    await vi.waitFor(() => { expect(b.sessionsFake.open).toHaveBeenCalledWith(OTHER) })
+    await vi.waitFor(() => {
+      expect(b.runtime.sessions.calls).toContainEqual({ method: 'open', args: [OTHER] })
+    })
    expect(state.getSnapshot().draft).toBe('')
    expect(b.inputSurface(OTHER).state.getSnapshot().draft).toBe('carry me')
+    await b.runtime.dispose()
+  })
+
+  it('selectWorkspace edge arms: no-session resident, empty-draft move, connect failure retryable', async () => {
+    const b = await bench()
+    // No-session resident (hero before any session): connect resolves and
+    // navigation proceeds without any draft choreography.
+    const noSession = b.residentSurface(undefined)
+    b.runtime.workspaces.stub('connectWorkspace', () => Promise.resolve(ROOT))
+    void noSession.selectWorkspace('workspace-0' as never)
+    await vi.waitFor(() => {
+      expect(b.runtime.sessions.calls).toContainEqual({ method: 'open', args: [ROOT] })
+    })
+
+    // Cross-session connect with an EMPTY draft: no move, no clearing.
+    const OTHER = 'b9-other' as SessionId
+    await b.runtime.sessions.add({ id: OTHER }, { current: false })
+    const resident = b.residentSurface(ROOT)
+    const { state } = b.inputSurface(ROOT)
+    expect(state.getSnapshot().draft).toBe('')
+    b.runtime.workspaces.stub('connectWorkspace', () => Promise.resolve(OTHER))
+    void resident.selectWorkspace('workspace-3' as never)
+    await vi.waitFor(() => {
+      expect(b.runtime.sessions.calls).toContainEqual({ method: 'open', args: [OTHER] })
+    })
+    expect(b.inputSurface(OTHER).state.getSnapshot().draft).toBe('')
+
+    // Connect failure: the rejection propagates to the caller (the view owns
+    // the rollback) and no further navigation happens.
+    const opens = b.runtime.sessions.calls.filter(c => c.method === 'open').length
+    b.runtime.workspaces.stub('connectWorkspace', () => Promise.reject(new Error('offline')))
+    await expect(resident.selectWorkspace('workspace-4' as never)).rejects.toThrow('offline')
+    expect(b.runtime.sessions.calls.filter(c => c.method === 'open')).toHaveLength(opens)
+    await b.runtime.dispose()
+  })
+
+  it('scopedConversation fails loud when the session resolves no scope', async () => {
+    const b = await bench()
+    // The chat-view inject resolves the scoped conversation service at inject
+    // time: an unlisted session hits the scope() === undefined throw directly.
+    const entry = b.entryOf('conversation.view')
+    const injectFn = entry.inject as unknown as (sessionId: SessionId, actions: unknown) => unknown
+    expect(() => injectFn('never-listed' as SessionId, {})).toThrow(/resolved no scope/)
+    await b.runtime.dispose()
  })

  it('views read face projects the ring ledger (subscribe/version through ctx.slots)', async () => {
@@ -313,6 +299,7 @@ describe('conversation slot inject surface', () => {
    off()
    off2()
    unsub()
+    await b.runtime.dispose()
  })
 })

@@ -325,9 +312,9 @@ describe('details inject surface', () => {
    injected.closeDetails()
    expect(b.layoutFake.closeDetails).toHaveBeenCalledTimes(1)
    // The shared handle: details resolves the SAME instance conversation writes.
-    const conv = b.hostFace.storeOf(b.entryOf('conversation.session'), ROOT)
-    const details = b.hostFace.storeOf(entry, ROOT)
+    const conv = b.runtime.storeOf('conversation.session', ROOT)
+    const details = b.runtime.storeOf('details', ROOT)
    expect(details).toBe(conv)
+    await b.runtime.dispose()
  })
-
 })
--- a/packages/client/ui-conversation/tests/chat-apply.spec.tsx
+++ b/packages/client/ui-conversation/tests/chat-apply.spec.tsx
@@ -1,89 +1,53 @@
 // @vitest-environment jsdom
 // apply wiring: the conversation service provided, the chat view registered
 // as the first 'conversation.view' ring entry declaring the keyed toolview
-// hole, the three slot registrations land against a root entry's children
-// declarations (the AppFrame role), the shared store handle rides all session
-// entries, and the bash sample mounts through the load-order seam as a keyed
-// entry. Full-chain rendering belongs to the machinery spec
-// (chat-toolview-slot.spec.tsx) and the shell e2e; this spec stops at the
-// assembly surface.
+// hole, the slot registrations land against a root entry's children
+// declarations (the AppFrame role), the shared store handle rides all strict
+// session entries, and the bash sample + todo row mount through the
+// load-order seam as keyed entries. Full-chain rendering belongs to the
+// machinery spec (chat-toolview-slot.spec.tsx) and the shell e2e; this spec
+// stops at the assembly surface.

-import { Context } from 'cordis'
 import { describe, expect, it, vi } from 'vitest'
-import { createSnapshotStore } from '@deepseek-ai/dsh-client-runtime/client'
-import { SlotsService } from '@deepseek-ai/dsh-client-runtime/client'
-import type { SessionId, SessionListState } from '@deepseek-ai/dsh-client-runtime/client'
+import { SlotTestRuntime } from '@deepseek-ai/dsh-client-test-runtime'
+import type { SessionId } from '@deepseek-ai/dsh-client-runtime/client'
 import { apply, inject } from '@deepseek-ai/dsh-client-ui-conversation/client'

 const ROOT = 'root-1' as SessionId
 const CHILD = 'child-1' as SessionId

 async function bench() {
-  const ctx = new Context()
-  const slotsFiber = ctx.plugin(SlotsService)
-  await slotsFiber.await()
+  const runtime = await SlotTestRuntime.create()
+  await runtime.sessions.add({ id: ROOT, summary: { title: 'R', displayTitle: 'R' } }, { current: false })
+  await runtime.sessions.add(
+    { id: CHILD, summary: { title: 'C', displayTitle: 'C', parentId: ROOT } }, { current: false })
+  runtime.provide('layout', { openDetails: vi.fn(), closeDetails: vi.fn() })

-  const listStore = createSnapshotStore<SessionListState>({
-    ids: [ROOT, CHILD],
-    byId: {
-      [ROOT]: { id: ROOT, title: 'R', displayTitle: 'R', running: false, blank: false, updatedAt: 1 },
-      [CHILD]: { id: CHILD, title: 'C', displayTitle: 'C', parentId: ROOT, running: false, blank: false, updatedAt: 2 },
-    },
-    current: undefined,
-    phase: 'ready',
-  })
-  const absentInfo = { sessionId: undefined, hooks: {}, props: {} }
-  const sessionsFake = {
-    list: listStore,
-    binding: vi.fn(),
-    scope: () => undefined,
-    provideInfo: () => undefined,
-    currentProvideInfo: { getSnapshot: () => absentInfo, subscribe: () => () => {} },
-    provide: vi.fn(() => () => {}),
-    create: vi.fn(),
-    open: vi.fn(),
-    updateIntent: vi.fn(),
-  }
-  ctx.provide('sessions', sessionsFake)
-  ctx.provide('workspaces', {
-    startSession: vi.fn(),
-    sendSession: vi.fn(),
-    openPath: vi.fn(async () => {}),
-  })
-  ctx.provide('layout', { openDetails: vi.fn(), closeDetails: vi.fn() })
-  ctx.provide('locale', { bind: () => (key: string) => key })
-
-  // Declared by ui-layout's root entry in production; a stand-in root
-  // occupant declares them here so the contributions land (it consumes
-  // renderSlot to satisfy the declare-means-render check).
-  const slots = ctx.get('slots') as SlotsService
-  slots.register({
-    name: 'root',
-    children: {
-      'conversation': { kind: 'single', scope: 'session-maybe' },
-      'details': { kind: 'single', scope: 'session' },
-    },
+  // Declared by ui-layout's root entry in production; the test root declares
+  // them here so the contributions land.
+  await runtime.root.declare({
+    'conversation': { kind: 'single', scope: 'session-maybe' },
+    'details': { kind: 'single', scope: 'session' },
  }, (_p: { renderSlot?: unknown }) => null)

-  const fiber = ctx.plugin({ inject: [...inject], apply })
-  return { ctx, fiber, slots }
+  const feature = await runtime.mount({ inject: [...inject], apply })
+  return { runtime, feature, slots: runtime.slots }
 }

 /** First stored entry for a key (inject/store live directly on StoredEntry). */
-function renderEntryOf(slots: SlotsService, key: 'conversation' | 'conversation.session' | 'conversation.view' | 'details') {
+function renderEntryOf(slots: Awaited<ReturnType<typeof bench>>['slots'], key: 'conversation' | 'conversation.session' | 'conversation.view' | 'details') {
  return slots.entries(key)[0] as undefined | { inject?: unknown; store?: unknown }
 }

 describe('apply wiring', () => {
  it('provides the conversation service', async () => {
    const b = await bench()
-    await b.fiber.await()
-    expect(b.ctx.get('conversation')).toBeDefined()
+    expect(b.runtime.ctx.get('conversation')).toBeDefined()
+    await b.runtime.dispose()
  })

  it('registers the chat view as the first ring entry, declaring the keyed toolview hole', async () => {
    const b = await bench()
-    await b.fiber.await()
    const entries = b.slots.entries('conversation.view')
    expect(entries.map(e => e.options.id)).toEqual(['chat'])
    expect(entries[0]?.options.label).toBe('Chat')
@@ -91,11 +55,11 @@ describe('apply wiring', () => {
    // Declaring is claiming: the chat entry's registration put the hole on
    // the ledger with the contract's kind/scope.
    expect(b.slots.spec('conversation.chat.toolview')).toEqual({ kind: 'keyed', scope: 'session' })
+    await b.runtime.dispose()
  })

  it('occupies the slots + the ring; session entries share one store handle', async () => {
    const b = await bench()
-    await b.fiber.await()
    const conversation = renderEntryOf(b.slots, 'conversation')
    const conversationSession = renderEntryOf(b.slots, 'conversation.session')
    const chatView = renderEntryOf(b.slots, 'conversation.view')
@@ -111,21 +75,21 @@ describe('apply wiring', () => {
    // The hero workspace picker hole rides the conversation entry's children
    // declaration (the empty-state occupant is gone).
    expect(b.slots.spec('conversation.hero.workspace')).toEqual({ kind: 'single', scope: 'root' })
+    await b.runtime.dispose()
  })

  it('mounts the bash sample and the todo row as keyed entries through the load-order seam', async () => {
    const b = await bench()
-    await b.fiber.await()
    // Both registrant plugins' inject: ['slots', 'conversation'] resolved — the
    // service being present implies the chat entry declared the hole first.
    const entries = b.slots.entries('conversation.chat.toolview')
    expect(entries.map(e => e.options.key)).toEqual(['bash', 'todo_write'])
+    await b.runtime.dispose()
  })

  it('plugin fiber disposal collects every registration (unload cascade, ring and hole included)', async () => {
    const b = await bench()
-    await b.fiber.await()
-    await b.fiber.dispose()
+    await b.feature.dispose()
    expect(b.slots.entries('conversation')).toHaveLength(0)
    // The declared ring collapses with its declaring entry, and the chat
    // entry's keyed hole (with the sample's registration) collapses with it.
@@ -133,6 +97,7 @@ describe('apply wiring', () => {
    expect(b.slots.entries('conversation.chat.toolview')).toHaveLength(0)
    expect(b.slots.spec('conversation.chat.toolview')).toBeUndefined()
    expect(b.slots.entries('details')).toHaveLength(0)
-    expect(b.ctx.get('conversation')).toBeUndefined()
+    expect(b.runtime.ctx.get('conversation')).toBeUndefined()
+    await b.runtime.dispose()
  })
 })
--- a/packages/client/ui-conversation/tests/chat-toolview-slot.spec.tsx
+++ b/packages/client/ui-conversation/tests/chat-toolview-slot.spec.tsx
@@ -1,7 +1,7 @@
 // @vitest-environment jsdom
 // The dissolved tool ring's acceptance chain on the REAL machinery stack:
-// cordis Context + SlotsService ledger + the web-react renderer + this
-// package's own apply — no outlet twins. Proves the keyed
+// SlotTestRuntime (cordis Context + SlotsService ledger + the web-react
+// renderer) + this package's own apply — no outlet twins. Proves the keyed
 // 'conversation.chat.toolview' hole end to end: registered rows dispatch by
 // entryKey (the bash sample lands through its plugin), unregistered tools
 // fall back to GenericToolCard at the render site, live registration/unload
@@ -10,23 +10,16 @@
 // inject: ['slots', 'conversation'] load-order seam suspends on real fiber
 // semantics until the service (and with it the hole declaration) is present.

-import { Context } from 'cordis'
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
-import { act, cleanup, fireEvent, render } from '@testing-library/react'
-import { createSnapshotStore, SlotsService } from '@deepseek-ai/dsh-client-runtime/client'
-import type {
-  ConversationSnapshot, SessionId, SessionListState, ToolResultNode, WorkspaceListState,
-} from '@deepseek-ai/dsh-client-runtime/client'
-import { createSlotRenderer } from '@deepseek-ai/dsh-client-web-react'
+import { cleanup, fireEvent } from '@testing-library/react'
+import type { ISession, SessionId, ToolResultNode } from '@deepseek-ai/dsh-client-runtime/client'
 import type { PropsRenderSlots } from '@deepseek-ai/dsh-client-ui-slots'
+import { SlotTestRuntime } from '@deepseek-ai/dsh-client-test-runtime'
 import { apply, inject } from '@deepseek-ai/dsh-client-ui-conversation/client'
 import type { ToolRowProps } from '@deepseek-ai/dsh-client-ui-conversation/client'

 const SID = 's1' as SessionId

-/** Identity-stable no-session bundle (uSES getSnapshot contract). */
-const ABSENT_INFO = { sessionId: undefined, hooks: {}, props: {} }
-
 afterEach(cleanup)
 // The chat store persists under its declared key; clear between cases.
 beforeEach(() => {
@@ -40,117 +33,39 @@ const toolResult = (seq: number, callId: string, name: string, args = '{"command
  content: [], isError: false, callView: null, resultView: null,
 })

-function snapshotWith(nodes: ToolResultNode[]): ConversationSnapshot {
-  return {
-    sessionId: SID, nodes, foldDegraded: false, partial: null, runningCalls: [], codeDispatches: new Map(),
-    pending: [], queue: [], running: false, composerPhase: 'active', removed: false, openState: 'open', openError: null,
-    hasMore: false, loadingOlder: false, promptError: null, blank: false, lastAgentError: null,
-  }
-}
-
 /** Test-owned AppFrame role: declares and renders the resident conversation area. */
 type AppRootProps = PropsRenderSlots<'conversation' | 'details'>
 function AppRoot({ renderSlot }: AppRootProps) {
  return <>{renderSlot('conversation', {})}</>
 }

+const LAYOUT_CHILDREN = {
+  'conversation': { kind: 'single', scope: 'session-maybe' },
+  'details': { kind: 'single', scope: 'session' },
+} as const
+
 /**
- * Real-stack bench: SlotsService plugin, renderer installed, sessions/layout
- * fakes at the service seams only (external boundaries), the package apply on
- * its own fiber, and the test AppFrame occupying 'root'.
+ * Real-stack bench: SlotTestRuntime with the session/layout doubles at the
+ * service seams only (external boundaries), the package apply on its own
+ * fiber, and the test AppFrame occupying 'root'.
 */
 async function bench(nodes: ToolResultNode[]) {
-  const ctx = new Context()
-  const slotsFiber = ctx.plugin(SlotsService)
-  await slotsFiber.await()
-  const slots = ctx.get('slots') as SlotsService
-
-  const session = createSnapshotStore<ConversationSnapshot>(snapshotWith(nodes))
-  const list = createSnapshotStore<SessionListState>({
-    ids: [SID],
-    byId: { [SID]: { id: SID, title: 'S', displayTitle: 'S', running: false, blank: false, updatedAt: 1 } },
-    current: SID,
-    phase: 'ready',
-  })
-  // Identity-stable provide bundle: the renderer caches hooks per source and
-  // inject results per bundle, both by object identity. Registered providers
-  // (the package's input contribution) materialize into it lazily, once.
-  const providers: ((binding: object) => { hooks?: object; props?: object })[] = []
-  let info: { sessionId: SessionId; hooks: object; props: object } | undefined
-  const scoped = { send: vi.fn(async () => {}), cancel: vi.fn(async () => {}) }
+  const runtime = await SlotTestRuntime.create()
  const layout = { openDetails: vi.fn(), closeDetails: vi.fn() }
-  const actxFake = { get: () => scoped, effect: () => {}, on: () => () => {} }
-  const bindingOf = (id: SessionId) => ({
-    sessionId: id,
-    ctx: actxFake,
+  runtime.provide('layout', layout)
+  await runtime.sessions.add({
+    id: SID,
+    summary: { title: 'S', displayTitle: 'S' },
+    snapshot: { nodes },
    session: {
-      sessionId: id,
-      loadOlder: vi.fn(),
-      prompt: vi.fn(async () => ({ ok: true, value: { accepted: true } })),
-      // Observable face for the input machine's queue read face.
-      getSnapshot: () => session.getSnapshot(),
-      subscribe: (fn: () => void) => session.subscribe(fn),
+      loadOlder: vi.fn<ISession['loadOlder']>(),
+      loadAllHistory: vi.fn<ISession['loadAllHistory']>(),
+      prompt: vi.fn<ISession['prompt']>(async () => ({ ok: true, value: { accepted: true } })),
    },
  })
-  const provideInfo = (id: string) => {
-    if (id !== SID) return undefined
-    if (info === undefined) {
-      const hooks: Record<string, unknown> = { session }
-      const props: Record<string, unknown> = {}
-      for (const provider of providers) {
-        const c = provider(bindingOf(SID))
-        Object.assign(hooks, c.hooks ?? {})
-        Object.assign(props, c.props ?? {})
-      }
-      info = { sessionId: SID, hooks, props }
-    }
-    return info
-  }
-  ctx.provide('sessions', {
-    list,
-    binding: bindingOf,
-    scope: () => actxFake,
-    provideInfo,
-    currentProvideInfo: {
-      getSnapshot: () => provideInfo(SID),
-      subscribe: () => () => {},
-    },
-    provide: (d: { resolve: (typeof providers)[number] }) => { providers.push(d.resolve); return () => {} },
-    scopeOf: () => SID,
-    create: vi.fn(),
-    open: vi.fn(),
-    updateIntent: vi.fn(),
-  })
-  const workspaces = {
-    list: createSnapshotStore<WorkspaceListState>({
-      items: [], state: 'idle', phase: 'ready', error: null,
-      baselinesReady: true, recentWorkspaceId: undefined,
-    }),
-    startSession: vi.fn(),
-    sendSession: vi.fn(),
-    openPath: vi.fn(async () => {}),
-  }
-  ctx.provide('workspaces', workspaces)
-  ctx.provide('layout', layout)
-  ctx.provide('locale', { bind: () => (key: string) => key })
-
-  slots.install(createSlotRenderer())
-  slots.register({
-    name: 'root',
-    children: {
-      'conversation': { kind: 'single', scope: 'session-maybe' },
-      'details': { kind: 'single', scope: 'session' },
-    },
-  }, AppRoot)
-
-  const fiber = ctx.plugin({ inject: [...inject], apply })
-  await fiber.await()
-  return { ctx, slots, fiber, session, list, layout, workspaces }
-}
-
-/** Render the whole tree through the ctx-level root seam (the shell's own entry). */
-function mountApp(slots: SlotsService) {
-  return render(<>{slots.renderSlot('root', {})}</>)
+  await runtime.root.declare(LAYOUT_CHILDREN, AppRoot)
+  const feature = await runtime.mount({ inject: [...inject], apply })
+  return { runtime, slots: runtime.slots, feature, layout }
 }

 describe('keyed toolview hole through the real machinery', () => {
@@ -159,7 +74,7 @@ describe('keyed toolview hole through the real machinery', () => {
      toolResult(3, 'c1', 'bash'),
      toolResult(4, 'c2', 'mystery', '{"n":1}'),
    ])
-    const view = mountApp(b.slots)
+    const view = b.runtime.renderRoot()
    // bash: the sample plugin's keyed registration took the row (root
    // session → global arm, decided inside the component off useSessions).
    expect(view.container.querySelector('[data-sample="bash-global"]')).not.toBeNull()
@@ -167,6 +82,7 @@ describe('keyed toolview hole through the real machinery', () => {
    expect(view.getByText('Build')).toBeTruthy()
    // mystery: no registration under that key → render-site fallback.
    expect(view.getByText('Tool call')).toBeTruthy()
+    await b.runtime.dispose()
  })

  it('renders top-level Cordis calls with lifecycle titles over the generic variants', async () => {
@@ -176,7 +92,7 @@ describe('keyed toolview hole through the real machinery', () => {
      toolResult(4, 'cordis-2', 'cordis_mount', JSON.stringify({ code })),
      toolResult(5, 'cordis-3', 'cordis_unmount', '{"id":"dyn-2"}'),
    ])
-    const view = mountApp(b.slots)
+    const view = b.runtime.renderRoot()

    expect(view.container.querySelector('[data-tool="cordis_inspect"]')?.textContent).toContain('Inspect')
    const mounted = view.container.querySelector('[data-variant="code"]')
@@ -186,42 +102,46 @@ describe('keyed toolview hole through the real machinery', () => {

    fireEvent.click(mounted!.querySelector('button[aria-expanded]')!)
    expect(mounted!.querySelector('pre.shiki')?.textContent).toBe(code)
+    await b.runtime.dispose()
  })

  it('file-path clicks travel owner openFile → chat inject → workspaces.openPath', async () => {
    const b = await bench([toolResult(3, 'c1', 'read', '{"path":"src/a.ts"}')])
-    const view = mountApp(b.slots)
+    const view = b.runtime.renderRoot()
    view.getByText('src/a.ts').click()
    expect(b.layout.openDetails).not.toHaveBeenCalled()
    await vi.waitFor(() => {
-      expect(b.workspaces.openPath).toHaveBeenCalledWith('src/a.ts')
+      expect(b.runtime.workspaces.calls).toContainEqual({ method: 'openPath', args: ['src/a.ts'] })
    })
+    await b.runtime.dispose()
  })

  it('bash summary clicks do not open details or host paths', async () => {
    const b = await bench([toolResult(3, 'c1', 'bash')])
-    const view = mountApp(b.slots)
+    const view = b.runtime.renderRoot()
    view.getByText('Build').click()
    expect(b.layout.openDetails).not.toHaveBeenCalled()
-    expect(b.workspaces.openPath).not.toHaveBeenCalled()
+    expect(b.runtime.workspaces.calls.some(c => c.method === 'openPath')).toBe(false)
+    await b.runtime.dispose()
  })

  it('a live keyed registration takes over its tool row and unload reverts to the fallback', async () => {
    const b = await bench([toolResult(3, 'c2', 'mystery', '{"n":1}')])
-    const view = mountApp(b.slots)
+    const view = b.runtime.renderRoot()
    expect(view.getByText('Tool call')).toBeTruthy()
    let dispose = (): void => {}
-    await act(async () => {
-      dispose = b.slots.register(
-        { name: 'conversation.chat.toolview', key: 'mystery' },
-        () => <div data-testid="mystery-row" />)
-    })
+    dispose = b.slots.register(
+      { name: 'conversation.chat.toolview', key: 'mystery' },
+      () => <div data-testid="mystery-row" />)
+    await b.runtime.flush()
    // Per-key version tick: the row flipped without a remount of the view.
    expect(view.getByTestId('mystery-row')).toBeTruthy()
    expect(view.queryByText('Tool call')).toBeNull()
-    await act(async () => { dispose() })
+    dispose()
+    await b.runtime.flush()
    expect(view.queryByTestId('mystery-row')).toBeNull()
    expect(view.getByText('Tool call')).toBeTruthy()
+    await b.runtime.dispose()
  })

  it('a duplicate key registration fails loud at load', async () => {
@@ -230,6 +150,7 @@ describe('keyed toolview hole through the real machinery', () => {
      { name: 'conversation.chat.toolview', key: 'bash' },
      () => null,
    )).toThrow(/key "bash"/)
+    await b.runtime.dispose()
  })

  it('the inject channel feeds (sessionId) => I into the row component', async () => {
@@ -247,66 +168,33 @@ describe('keyed toolview hole through the real machinery', () => {
    }, ({ mark, poke }: ToolRowProps & { mark: string; poke: () => void }) => (
      <button data-testid="probe-row" onClick={poke}>{mark}</button>
    ))
-    const view = mountApp(b.slots)
+    const view = b.runtime.renderRoot()
    const row = view.getByTestId('probe-row')
    expect(row.textContent).toBe(`for:${SID}`)
    row.click()
    expect(poked).toEqual([SID])
+    await b.runtime.dispose()
  })
 })

 describe('registrant load-order seam', () => {
  it("suspends a registrant on inject: ['slots', 'conversation'] until the service (and the hole) exists", async () => {
-    const ctx = new Context()
-    const slotsFiber = ctx.plugin(SlotsService)
-    await slotsFiber.await()
-    const slots = ctx.get('slots') as SlotsService
-    ctx.provide('sessions', {
-      list: createSnapshotStore<SessionListState>({
-        ids: [], byId: {}, current: undefined, phase: 'ready',
-      }),
-      binding: () => undefined,
-      scope: () => undefined,
-      provideInfo: () => undefined,
-      currentProvideInfo: {
-        getSnapshot: () => ABSENT_INFO,
-        subscribe: () => () => {},
-      },
-      provide: () => () => {},
-      create: vi.fn(),
-      open: vi.fn(),
-      updateIntent: vi.fn(),
-    })
-    ctx.provide('workspaces', {
-      list: createSnapshotStore<WorkspaceListState>({
-        items: [], state: 'idle', phase: 'ready', error: null,
-        baselinesReady: true, recentWorkspaceId: undefined,
-      }),
-      startSession: vi.fn(),
-      sendSession: vi.fn(),
-      openPath: vi.fn(async () => {}),
-    })
-    ctx.provide('layout', { openDetails: vi.fn(), closeDetails: vi.fn() })
-    ctx.provide('locale', { bind: () => (key: string) => key })
-    slots.register({
-      name: 'root',
-      children: {
-        'conversation': { kind: 'single', scope: 'session-maybe' },
-        'details': { kind: 'single', scope: 'session' },
-      },
-    }, AppRoot)
+    const runtime = await SlotTestRuntime.create()
+    runtime.provide('layout', { openDetails: vi.fn(), closeDetails: vi.fn() })
+    await runtime.root.declare(LAYOUT_CHILDREN, AppRoot)

    // Third-party posture, mounted BEFORE ui-conversation: real fiber inject
    // semantics hold it — apply must not run while 'conversation' is absent.
-    // (Plain arrow, not vi.fn: mock functions carry a prototype and trip the
-    // fiber's isConstructor branch.)
+    // Uses ctx.plugin directly (the deliberate-suspension escape hatch; mount()
+    // would fail loud on the missing service). (Plain arrow, not vi.fn: mock
+    // functions carry a prototype and trip the fiber's isConstructor branch.)
    let applyRuns = 0
-    const registrantApply = (registrantCtx: Context): void => {
+    const registrantApply = (registrantCtx: typeof runtime.ctx): void => {
      applyRuns += 1
      registrantCtx.slots.register(
        { name: 'conversation.chat.toolview', key: 'late' }, () => null)
    }
-    const late = ctx.plugin({
+    const late = runtime.ctx.plugin({
      name: 'late-registrant',
      inject: ['slots', 'conversation'],
      apply: registrantApply,
@@ -317,11 +205,11 @@ describe('registrant load-order seam', () => {
    // Mounting the package resolves the seam: service present ⟹ the chat
    // entry (and its hole declaration) is already on the ledger, so the
    // suspended registrant lands without an undeclared-slot throw.
-    const fiber = ctx.plugin({ inject: [...inject], apply })
-    await fiber.await()
+    await runtime.mount({ inject: [...inject], apply })
    await late.await()
    expect(applyRuns).toBe(1)
-    expect(slots.entries('conversation.chat.toolview').map(e => e.options.key))
+    expect(runtime.slots.entries('conversation.chat.toolview').map(e => e.options.key))
      .toEqual(expect.arrayContaining(['bash', 'late']))
+    await runtime.dispose()
  })
 })
--- a/packages/client/ui-conversation/tests/coverage-tails.spec.tsx
+++ b/packages/client/ui-conversation/tests/coverage-tails.spec.tsx
@@ -1,6 +1,6 @@
 // @vitest-environment jsdom
 // Branch tails the acceptance specs do not reach: ToolRow stopped-state dot,
-// PendingCard question arm, bash sample state dots, the node-half empty
+// PendingCard approval wait, bash sample state dots, the node-half empty
 // apply, and AssistantMarkdown reasoning/unknown block arms.

 import { afterEach, describe, expect, it, vi } from 'vitest'
@@ -33,11 +33,11 @@ describe('tails', () => {
    expect(view.container.querySelector('[data-state="stopped"]')).not.toBeNull()
  })

-  it('PendingCard renders the question arm with its count', () => {
+  it('PendingCard renders the approval wait with its tool name', () => {
    const view = render(
-      <PendingCard item={new PendingWait('question', RpcId('r1'), 's1' as SessionId, { questions: [{}, {}] } as PendingWait<'question'>['payload'], vi.fn())} />,
+      <PendingCard item={new PendingWait('approval', RpcId('r1'), 's1' as SessionId, { toolName: 'bash' } as PendingWait<'approval'>['payload'], vi.fn())} />,
    )
-    expect(view.getByText(/等待回答（2 题）/)).toBeTruthy()
+    expect(view.getByText(/等待审批/)).toBeTruthy()
  })

  it('AssistantMarkdown renders reasoning as a Think row and unknown blocks as JSON fallback', () => {
--- a/packages/client/ui-conversation/tests/input-bar.spec.tsx
+++ b/packages/client/ui-conversation/tests/input-bar.spec.tsx
@@ -30,6 +30,8 @@ function snapshotOf(overrides: Partial<ConversationSnapshot> = {}): Conversation

 interface BenchOptions {
  planEntry?: React.ReactNode
+  /** The `plan` projection value the standard-kit useProjection serves. */
+  plan?: { active: boolean; pending: boolean }
  modelEntry?: React.ReactNode
  /** Hot text-ref lexicon (injects a minimal slash stub exposing only lexicon()). */
  lexicon?: ReadonlyMap<'/' | '@', readonly string[]>
@@ -88,7 +90,8 @@ function bench(over?: BenchOptions) {
      items: [], state: 'idle', phase: 'ready', error: null,
      baselinesReady: true, recentWorkspaceId: undefined,
    })),
-    useProjection: (() => undefined),
+    useProjection: ((_key: string, selector?: (v: unknown) => unknown) =>
+      (selector ?? (v => v))(over?.plan)),
    useInput: bindSnapshotSelector(shell.state),
    inputActions: shell.actions,
    keyboard: shell,
@@ -230,6 +233,20 @@ describe('running and lock semantics (queue cut 1)', () => {
    const custom = bench({ placeholder: 'Custom placeholder' })
    expect(custom.textarea.placeholder).toBe('Custom placeholder')
  })
+
+  it('the plan projection swaps the placeholder while its effective target is plan mode', () => {
+    const active = bench({ plan: { active: true, pending: false } })
+    expect(active.textarea.placeholder).toBe('describe your task to generate plan')
+    // /plan just ran: pending entry already reads as the plan target.
+    const entering = bench({ plan: { active: false, pending: true } })
+    expect(entering.textarea.placeholder).toBe('describe your task to generate plan')
+    // Pending exit: target is default again.
+    const leaving = bench({ plan: { active: true, pending: true } })
+    expect(leaving.textarea.placeholder).toBe('Message the agent')
+    // Owner placeholder outranks the plan swap.
+    const custom = bench({ plan: { active: true, pending: false }, placeholder: 'Custom placeholder' })
+    expect(custom.textarea.placeholder).toBe('Custom placeholder')
+  })
 })

 describe('machine pending lock', () => {
@@ -250,7 +267,6 @@ describe('machine pending lock', () => {
    expect(shell.snapshot.phase).toBe('submitting')
    const textarea = view.container.querySelector('textarea')!
    expect(textarea.readOnly).toBe(true)
-    expect(view.container.querySelector('[data-input-pending]')).not.toBeNull()
    expect(view.container.querySelector<HTMLButtonElement>('button[aria-label="Send message"]')!.disabled).toBe(true)
  })
 })
--- a/packages/client/ui-conversation/tests/input-matrix.spec.tsx
+++ b/packages/client/ui-conversation/tests/input-matrix.spec.tsx
@@ -124,13 +124,12 @@ describe('matrix row: claimed', () => {
 describe('matrix row: submitting', () => {
  it('locks enter, renders pending + read-only, keeps the claim snapshot on the currency', async () => {
    const submit = vi.fn(() => new Promise<SubmitOutcome>(() => {})) // never settles
-    const { view, textarea, shell, sink, claim } = bench({ submit })
+    const { textarea, shell, sink, claim } = bench({ submit })
    claim()
    fireEvent.keyDown(textarea, { key: 'Enter' })
    expect(shell.snapshot.phase).toBe('submitting')
    expect(shell.snapshot.claim).toBeDefined()
    expect((textarea).readOnly).toBe(true)
-    expect(view.container.querySelector('[data-input-pending]')).not.toBeNull()
    // Enter is dead inside the lock (submit dispatch is microtask-deferred).
    await vi.waitFor(() => { expect(submit).toHaveBeenCalledTimes(1) })
    fireEvent.keyDown(textarea, { key: 'Enter' })
--- a/packages/client/ui-conversation/tests/selection-survival.spec.ts
+++ b/packages/client/ui-conversation/tests/selection-survival.spec.ts
@@ -1,149 +0,0 @@
-// @vitest-environment jsdom
-/**
- * Exercises selection persistence through the real SlotsService store axis;
- * component stubs cannot prove per-session identity or disposal.
- */
-import { Context } from 'cordis'
-import { beforeEach, describe, expect, it } from 'vitest'
-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'
-
-const sid = (s: string): SessionId => s as SessionId
-
-/** Identity-stable no-session bundle (uSES getSnapshot contract). */
-const ABSENT_INFO = { sessionId: undefined, hooks: {}, props: {} }
-
-interface Bench {
-  slots: SlotsService
-  chat: ReturnType<typeof createChatStore>
-}
-
-function bench(): Bench {
-  const ctx = new Context()
-  ctx.provide('sessions', {
-    list: createSnapshotStore<SessionListState>({
-      ids: [], byId: {}, current: undefined, phase: 'ready',
-    }),
-    provideInfo: () => undefined,
-    currentProvideInfo: {
-      getSnapshot: () => ABSENT_INFO,
-      subscribe: () => () => {},
-    },
-    provide: () => () => {},
-  })
-  ctx.provide('workspaces', {
-    list: createSnapshotStore<WorkspaceListState>({
-      items: [], 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()
-  // The apply.ts shape: one shared handle across both session-slot
-  // registrations. 'conversation'/'details' must first exist in the ledger —
-  // register a root occupant declaring them (the AppFrame role; the stand-in
-  // consumes renderSlot to satisfy the declare-means-render check).
-  slots.register({
-    name: 'root',
-    children: {
-      'conversation': { kind: 'single', scope: 'session-maybe' },
-      'conversation.session': { kind: 'single', scope: 'session' },
-      'details': { kind: 'single', scope: 'session' },
-    },
-  }, (_p: { renderSlot?: unknown }) => null)
-  // apply.ts mounts the shared chat handle only under session-scope slots
-  // (the session-maybe 'conversation' shell carries no store).
-  slots.register({ name: 'conversation.session', store: chat }, () => null)
-  slots.register({ name: 'details', store: chat }, () => null)
-  return { slots, chat }
-}
-
-/** Resolve the store instance the renderer would hand a slot's component for a session. */
-function storeFor(b: Bench, slot: 'conversation.session' | 'details', sessionId: SessionId) {
-  const host = renderHost(b)
-  const entry = host.entriesOf(slot)[0]!
-  return host.storeOf(entry, sessionId)! as ReturnType<ReturnType<typeof createChatStore>['create']>
-}
-
-/** The host face is only built at renderSlot time; install a stub renderer once to reach it. */
-function renderHost(b: Bench): import('@deepseek-ai/dsh-client-ui-slots').SlotRendererHost {
-  const captured = (b as unknown as { _host?: import('@deepseek-ai/dsh-client-ui-slots').SlotRendererHost })
-  if (captured._host === undefined) {
-    b.slots.install({
-      renderRoot: (host) => {
-        captured._host = host
-        return null
-      },
-    })
-    b.slots.renderSlot('root', {})
-  }
-  return captured._host!
-}
-
-beforeEach(() => {
-  localStorage.clear()
-})
-
-describe('selection survives on the store seat', () => {
-  it('one session, two slots: conversation writes, details reads the SAME instance', () => {
-    const b = bench()
-
-    const conv = storeFor(b, 'conversation.session', sid('s1'))
-    const details = storeFor(b, 'details', sid('s1'))
-    conv.actions.select({ turnSeq: 3, callId: 'c1' })
-    expect(details.store.getSnapshot().selection).toEqual({ turnSeq: 3, callId: 'c1' })
-    // Identity, not just value: the shared handle resolves one instance per scope key.
-    expect(details).toBe(conv)
-  })
-
-  it('sessions are isolated: s2 selection never bleeds into s1', () => {
-    const b = bench()
-
-    const one = storeFor(b, 'conversation.session', sid('s1'))
-    const two = storeFor(b, 'conversation.session', sid('s2'))
-    expect(two).not.toBe(one)
-    one.actions.select({ turnSeq: 1, callId: 'a' })
-    two.actions.select({ turnSeq: 9, callId: 'z' })
-    expect(one.store.getSnapshot().selection).toEqual({ turnSeq: 1, callId: 'a' })
-    expect(two.store.getSnapshot().selection).toEqual({ turnSeq: 9, callId: 'z' })
-  })
-
-  it('a list-projection update keeps instance identity and the selection value', () => {
-    const b = bench()
-    const id = sid('s1')
-    const projection = createSnapshotStore({ displayTitle: 's1' })
-
-    const store = storeFor(b, 'conversation.session', id)
-    store.actions.select({ turnSeq: 3, callId: 'c1' })
-    store.actions.setDraft('half-typed')
-
-    projection.set({ displayTitle: 'proj-a' })
-    expect(projection.getSnapshot().displayTitle).toBe('proj-a')
-
-    const after = storeFor(b, 'conversation.session', id)
-    expect(after).toBe(store)
-    expect(after.store.getSnapshot().selection).toEqual({ turnSeq: 3, callId: 'c1' })
-    expect(after.store.getSnapshot().draft).toBe('half-typed')
-  })
-
-  it('session death buries the instance and its persisted draft', () => {
-    const b = bench()
-
-    const doomed = storeFor(b, 'conversation.session', sid('s1'))
-    doomed.actions.setDraft('to be buried')
-    doomed.actions.select({ turnSeq: 1 })
-    expect(localStorage.getItem('dsh.conversation.chat.s1')).not.toBeNull()
-
-    // 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.
-    const reborn = storeFor(b, 'conversation.session', sid('s1'))
-    expect(reborn).not.toBe(doomed)
-    expect(reborn.store.getSnapshot()).toEqual({ selection: null, draft: '', view: null })
-  })
-})
--- a/packages/client/ui-conversation/tests/selection-survival.spec.tsx
+++ b/packages/client/ui-conversation/tests/selection-survival.spec.tsx
@@ -0,0 +1,109 @@
+// @vitest-environment jsdom
+/**
+ * Exercises selection persistence through the real SlotsService store axis;
+ * component stubs cannot prove per-session identity or disposal.
+ */
+import { beforeEach, describe, expect, it } from 'vitest'
+import type { SessionId } from '@deepseek-ai/dsh-client-runtime/client'
+import { SlotTestRuntime } from '@deepseek-ai/dsh-client-test-runtime'
+import { createChatStore } from '../src/client/stores.ts'
+
+const sid = (s: string): SessionId => s as SessionId
+
+type ChatInstance = ReturnType<ReturnType<typeof createChatStore>['create']>
+
+async function bench() {
+  const runtime = await SlotTestRuntime.create()
+  const chat = createChatStore()
+  // The apply.ts shape: one shared handle across both strict-session slot
+  // registrations ('conversation.session'/'details'); the session-maybe
+  // 'conversation' shell carries no store by design. The slots must first
+  // exist in the ledger — the test root declares them (the AppFrame role).
+  await runtime.root.declare({
+    'conversation': { kind: 'single', scope: 'session-maybe' },
+    'conversation.session': { kind: 'single', scope: 'session' },
+    'details': { kind: 'single', scope: 'session' },
+  }, (_p: { renderSlot?: unknown }) => null)
+  runtime.slots.register({ name: 'conversation.session', store: chat }, () => null)
+  runtime.slots.register({ name: 'details', store: chat }, () => null)
+  runtime.renderRoot() // materializes the host face storeOf resolves through
+  return { runtime, chat }
+}
+
+/** Resolve the store instance the renderer would hand a slot's component for a session. */
+function storeFor(b: Awaited<ReturnType<typeof bench>>, slot: 'conversation.session' | 'details', sessionId: SessionId) {
+  return b.runtime.storeOf(slot, sessionId) as ChatInstance
+}
+
+beforeEach(() => {
+  localStorage.clear()
+})
+
+describe('selection survives on the store seat', () => {
+  it('one session, two slots: conversation writes, details reads the SAME instance', async () => {
+    const b = await bench()
+
+    const conv = storeFor(b, 'conversation.session', sid('s1'))
+    const details = storeFor(b, 'details', sid('s1'))
+    conv.actions.select({ turnSeq: 3, callId: 'c1' })
+    expect(details.store.getSnapshot().selection).toEqual({ turnSeq: 3, callId: 'c1' })
+    // Identity, not just value: the shared handle resolves one instance per scope key.
+    expect(details).toBe(conv)
+    await b.runtime.dispose()
+  })
+
+  it('sessions are isolated: s2 selection never bleeds into s1', async () => {
+    const b = await bench()
+
+    const one = storeFor(b, 'conversation.session', sid('s1'))
+    const two = storeFor(b, 'conversation.session', sid('s2'))
+    expect(two).not.toBe(one)
+    one.actions.select({ turnSeq: 1, callId: 'a' })
+    two.actions.select({ turnSeq: 9, callId: 'z' })
+    expect(one.store.getSnapshot().selection).toEqual({ turnSeq: 1, callId: 'a' })
+    expect(two.store.getSnapshot().selection).toEqual({ turnSeq: 9, callId: 'z' })
+    await b.runtime.dispose()
+  })
+
+  it('a list-projection update keeps instance identity and the selection value', async () => {
+    const b = await bench()
+    const id = sid('s1')
+
+    const store = storeFor(b, 'conversation.session', id)
+    store.actions.select({ turnSeq: 3, callId: 'c1' })
+    store.actions.setDraft('half-typed')
+
+    // A projection churn elsewhere (list rows re-projected) must not touch
+    // store identity: drive the runtime's own list observable.
+    await b.runtime.sessions.add({ id, summary: { displayTitle: 'proj-a' } })
+    expect(b.runtime.sessions.list.getSnapshot().byId[id]?.displayTitle).toBe('proj-a')
+
+    const after = storeFor(b, 'conversation.session', id)
+    expect(after).toBe(store)
+    expect(after.store.getSnapshot().selection).toEqual({ turnSeq: 3, callId: 'c1' })
+    expect(after.store.getSnapshot().draft).toBe('half-typed')
+    await b.runtime.dispose()
+  })
+
+  it('session death buries the instance and its persisted draft', async () => {
+    const b = await bench()
+    await b.runtime.sessions.add({ id: 's1' })
+
+    const doomed = storeFor(b, 'conversation.session', sid('s1'))
+    doomed.actions.setDraft('to be buried')
+    doomed.actions.select({ turnSeq: 1 })
+    expect(localStorage.getItem('dsh.conversation.chat.s1')).not.toBeNull()
+
+    // TestSessions.remove drives the same public slot lifecycle seam the
+    // production SessionsService calls when the scope dies (pruneStoreScope).
+    await b.runtime.sessions.remove('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.
+    const reborn = storeFor(b, 'conversation.session', sid('s1'))
+    expect(reborn).not.toBe(doomed)
+    expect(reborn.store.getSnapshot()).toEqual({ selection: null, draft: '', view: null })
+    await b.runtime.dispose()
+  })
+})
--- a/packages/client/ui-conversation/tests/service-orchestration.spec.ts
+++ b/packages/client/ui-conversation/tests/service-orchestration.spec.ts
@@ -1,39 +1,32 @@
 // @vitest-environment jsdom
+// ConversationService scope addressing over the runtime's real scope tag:
+// TestSessions mints tagged scopes through the production createScope, so the
+// service's scopeOf/binding path runs against production resolution (no local
+// tag probe).
 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 { SlotTestRuntime } from '@deepseek-ai/dsh-client-test-runtime'
 import { ConversationService } from '@deepseek-ai/dsh-client-ui-conversation/client'
+import { InputHub } from '../src/client/input/hub.ts'

-const sid = (id: string) => id as SessionId
-const SCOPE_TAG: symbol = (() => {
-  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(proxy)
-  return reads.find((value): value is symbol => typeof value === 'symbol')!
-})()
-
-async function bench(withSessions = true) {
-  const ctx = new Context()
+async function bench() {
+  const runtime = await SlotTestRuntime.create()
  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 sessions = {
-    binding: (sessionId: SessionId) => ({
-      sessionId, session: { prompt, cancel, loadOlder },
-    }),
-    scopeOf,
-  } as unknown as SessionsService
-  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 }
+  await runtime.sessions.add({
+    id: 's1',
+    session: { prompt, cancel, loadOlder },
+  })
+  // config.input is required (the apply shares its hub with the inject
+  // factories); the bench passes its own instance explicitly.
+  const fiber = runtime.ctx.plugin(ConversationService, {
+    input: new InputHub(runtime.ctx),
+  })
+  await fiber.await()
+  const root = runtime.ctx.get('conversation') as ConversationService
+  const scoped = runtime.sessions.scope('s1')!.get('conversation') as ConversationService
+  return { runtime, root, scoped, prompt, cancel, loadOlder }
 }

 describe('ConversationService', () => {
@@ -45,6 +38,7 @@ describe('ConversationService', () => {
    expect(b.prompt).toHaveBeenCalledWith([{ type: 'text', text: 'hello' }], 'steer')
    expect(b.cancel).toHaveBeenCalledOnce()
    expect(b.loadOlder).toHaveBeenCalledOnce()
+    await b.runtime.dispose()
  })

  it('folds Session business failures into callback rejections', async () => {
@@ -53,12 +47,21 @@ describe('ConversationService', () => {
    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')
+    await b.runtime.dispose()
  })

-  it('fails loudly from the root scope or without SessionsService', async () => {
+  it('fails loudly from the root scope, on an unbound session, or without SessionsService', async () => {
    const b = await bench()
    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/)
+    await b.runtime.sessions.remove('s1')
+    await expect(b.scoped.send('x', 'queue')).rejects.toThrow(/resolved no binding/)
+    await b.runtime.dispose()
+    // No SessionsService at all: a bare context (the runtime always provides one).
+    const bare = new Context()
+    await bare.plugin(ConversationService, {
+      input: new InputHub(bare),
+    }).await()
+    const orphan = bare.get('conversation') as ConversationService
+    await expect(orphan.send('x', 'queue')).rejects.toThrow(/sessions service unavailable/)
  })
 })
--- a/packages/client/ui-conversation/tsconfig.json
+++ b/packages/client/ui-conversation/tsconfig.json
@@ -26,6 +26,9 @@
    {
      "path": "../../session-projection/session-projection"
    },
+    {
+      "path": "../../plan/plan-mode"
+    },
    {
      "path": "../../todo/tool-todo"
    },