Merge remote-tracking branch 'origin/master' into feat/todo-multi-in-progress

.agents/notes/implemented/architecture/2026-07-25-web-client-session-scope-and-provide-channel.i18n.yaml

@@ -0,0 +1,6 @@
+# Bilingual-pair consistency record (docs/i18n/README.md): the git blob hash of each
+# 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
+2026-07-25-web-client-session-scope-and-provide-channel.md: 063494b56461593015d6de4c2b55a2d1d6a3c676
+2026-07-25-web-client-session-scope-and-provide-channel.zh.md: cd5d29dfbcd9356a9ea15852d5d27a3660084abf

.agents/notes/implemented/architecture/2026-07-25-web-client-session-scope-and-provide-channel.md

@@ -0,0 +1,137 @@
+# Agent Note: Web client Agent-scope parity model and the provisioning channel (agents/scope / blank reuse / provide)
+
+Status: implemented
+
+English | [中文](2026-07-25-web-client-session-scope-and-provide-channel.zh.md)
+
+> Scope: the client Agent scope (actx) and targeted events, the client/host materialization parity model, the blank-session bit and reuse (`connectWorkspace`), the per-session provisioning channel (`sessions.provide`), the read-only queue mirror (`session/queued`), and the host wire smalls that carry these capabilities (the summary `blank` column, the `host/session-added` frame field, and the `host/commands-changed` frame). The input state machine and the slash pipeline live in the [input machine note](2026-07-25-web-input-machine-and-slash-pipeline.md); the command business surfaces live in the [command surfaces note](2026-07-25-web-command-surfaces-and-assembly.md).
+
+## Problem
+
+The web client had a single global session surface: slots all rendered from the root context, so plugins had no notion of "which agent/session is current"; the draft's true copy was buried inside the Session object, leaving any plugin that wanted to participate in input with nowhere to hook in. To support a command/input system, the platform layer first had to answer:
+
+- Who owns session interaction state (menus, popups, drafts, in-flight requests), and how two sessions are structurally isolated;
+- What a "new session" is before the host entity exists — whether the client must forge an independent life for it;
+- How session-scope components fetch their own session data, instead of props passed down layer by layer;
+- What a user-abandoned new session leaves behind on the host side, and who collects it.
+
+Hard constraints: the host is the single source of truth; every registration goes through a `ctx.effect` disposer; the scope mechanism matches the host's Agent scope architecture; model-visible ⟺ already in the session log.
+
+## Decision
+
+### The parity model: client and host share one root state axis
+
+Host-side `session.create(workspaceId)` produces Session + Agent + cwd in one piece (an atomic bundle, never split); the client side is the mirror of that birth — the instant a session row enters the list mirror, the client mints its Agent scope (actx + provide + the full input surface mounted):
+
+- Session identity is the host's true form from birth: the sessionId arrives via the `session.create` response / the `host/session-added` frame, and every client-side address (the scope tag, slot store keys, RPC addressing) uses that same id.
+- The materialization moment = the instant the user picks a Workspace (cwd settled): the client calls `session.create({workspaceId})` on the spot and receives the complete entity.
+- "New Session with no workspace picked" is a **pure view state** (a navigation position) corresponding to no session/scope entity; until the pick, the composer is locked whole (no slash, no plain text).
+- A "blank session" is just an ordinary materialized session whose log is still empty; to every Agent-scope plugin on the host (goal/plan/skill/…) it is indistinguishable from any session, so slash/plan are all naturally live.
+
+### Agent scope: the actx is the sole session carrier in the client-side cordis world
+
+The runtime's `agents/scope.ts` matches the host's `dsh-scope` at the mechanism layer (fiber + tag + filter; no value import: the host package carries the scoped-events `Events` merge, which would collide with the Context merge inside the client program):
+
+- `createScope(ctx, key)`: a no-op plugin fiber plus `extend({[kScope]: key, [Context.filter]: …})` — the filter lives directly on the actx: untagged listeners receive globally, tagged ones receive only their own scope.
+- Dispatch is the cordis primitives with thisArg = the actx itself: `actx.bail(actx, event, req)` / `actx.emit(actx, event, payload)`.
+- `Session.bindScope(actx)`: paired exactly once when resolve mints the scope (rebinding throws; dropScope unbinds), mirroring the host's `Agent.loopCtx` — the Session uses it to dispatch its own scoped events. The reverse actx→Session direction is one hop through `sessions.sessionOf(actx)` (mirroring host plugins' `agent.session` usage).
+
+Three deliberate divergences from the host dsh-scope:
+
+- The filter lives on the actx itself rather than a separate carrier: the host wrapper layer guards the business Agent subject against drifting from the scope key (host events inject the Agent itself as the first argument), while client event payloads carry only an id — there is no subject to protect.
+- Keys compare by branded `SessionId` value rather than object identity: on the host, agent.id === session id (1:1 on the same axis), agent identity directly reuses the `SessionId` brand, and a client scope's identity is its wire id.
+- The client scope is an **Agent identity** scope, not a live-object scope: during a cold session the host Agent object is already disposed while the client actx stays alive (in view) — the identity axis is in strict parity while object hot/cold is deliberately unsynchronized.
+
+id→ctx handoff is allowed in only three kinds of places (business providers never hand off):
+
+- Slot inject factories: the ctx never enters the render layer; the identity the slot framework hands a component is the sessionId, exchanged back into objects/controllers through service maps.
+- Root coordination services self-addressing: from a projection's sessionId back to the actx via `sessions.scope(id)`.
+- Root untagged listeners: looking up their own store by the payload's sessionId.
+
+### Scope lifecycle: anchored to the list mirror — birth is entering view, death is prune
+
+Session instances share the scope's lifecycle; liveness eligibility = host-listed (one criterion, shared by mint and prune):
+
+- Birth = a session row entering client view (the list baseline pull / the local `create()` echo / the `host/session-added` frame); a lazy first resolve mints the scope (resolution is a pure function, render-safe).
+- One prune tears down three things together: the Session instance, the scope fiber (cascading through every consumer hung on the actx), and the session-keyed slot store. The staged session (= `list.current`) is the exception: removed while still on stage, it keeps a frozen read-only view, torn down only once the stage moves away.
+- Reopening = lazily rebuilding the instance + `open()` pulling history (the host session log is the durable truth).
+- Remaining TODO: approval/question frames never enter history and cannot be recovered across a prune (the manager-level pendingBuffers cover only the never-instantiated window).
+
+### The blank bit: the empty session's visible projection, conversion, and reuse
+
+A session "materialized but with no first prompt" is governed by the summary-derived bit `blank` (a derived column, not a header field; SessionHeader stays immutable):
+
+- The host criterion: `session.events.length === 0` (zero log events = no user message yet). A live session reads `summarize()` straight from memory; a cold session is always `false` — the lazy-create contract guarantees a never-appended session never enters `persistence.list()` at all (both the JSONL and SQLite backends are verified truly lazy), so blank never touches disk.
+- The wire carries it in two places: the required `SessionSummary.blank` column, and the required `blank` field on the `host/session-added` frame (always true at creation, letting other tabs enter the same blank-session state into their mirrors).
+- The client mirror only lowers, never raises (monotonic), flipped from three sources, all reusing existing wire signals:
+  - The sender's own tab: the **successful response** to the first `prompt()` flips false (acceptance proves the user/message is already in the host log — this flip is confirmation, not optimism; `onEngaged` synchronously updates the list mirror, converting the current `New Session` row in place to an ordinary title, adding no list row). A rejected first prompt keeps the session blank: aligned with host authority, still shown as `New Session`, keeping its connectWorkspace reuse eligibility.
+  - Other tabs: the `host/session-status (running:true)` frame flips it — a blank session never runs, so the first running necessarily means no longer blank;
+  - Reconnect alignment: `session.list`'s summary.blank is authoritative, so a tab that missed frames aligns naturally on its next pull; a stale blank:true can never mark a converted session back to blank.
+- List discipline: the store retains every row; the Workspace browser's grouping, flat view, search, and counts share one visible projection — every non-blank session shows, while blank sessions show only the one with `session.id === sessions.current`, its title forced to `New Session`. After a Workspace switch, the old blank entity stays in the mirror but is hidden from the list while the target Workspace's current blank shows; the user-visible surface therefore holds at most one blank row globally.
+- The residue ledger takes zero GC: after a refresh, blank sessions come back with the bit intact and are reused on the next same-workspace connect, so the ordinary single-tab path keeps at most one per workspace; after a host restart, blanks leave no disk trace and simply evaporate; the extra empty shells from multi-tab races only become non-current hidden rows, digested by later reuse, with no coordination.
+
+### connectWorkspace: the sole entry point of New Session
+
+`workspaces.connectWorkspace(workspaceId): Promise<SessionId>` (owned by WorkspacesService — it holds both the workspace canonical path and the sessions reference):
+
+- The reuse arm: the list mirror is searched for `blank && cwd == workspace.path` (direct equality on the host realpath canonical form); a hit returns that id directly, creating nothing.
+- The create arm: on a miss, `session.create({workspaceId})` returns the new id.
+- An unknown workspaceId fails loud (never silently creating somewhere else).
+- The resolution guarantee (one contract for both arms): when the promise resolves, the returned id is already in the list store and `sessions.binding(id)` resolves synchronously — `SessionsService.create` projects the list synchronously after RPC success before resolving, so a draft mover can write text into the new scope's machine before open, without waiting for a notifier flush.
+- The caller takes the id and does its own `sessions.open`; sending the first prompt is an ordinary `session.prompt` — the session already exists, a failure is an ordinary prompt failure, the draft text is still in the machine, and a retry is simply sending again.
+- The global New Session button defaults to `recentWorkspaceId`: first comparing each Workspace's newest Session `updatedAt`, falling back to the Workspace `createdAt` when it has no Sessions, and keeping host order on ties; only with no Workspace at all does it `sessions.clear()` into the no-session view. Create actions inside a Workspace group still hit that Workspace explicitly.
+- At startup the runtime subscribes to the first complete baseline: a successfully restored current session is kept in place; otherwise it automatically calls `connectWorkspace(recentWorkspaceId)` and opens the returned blank session. The policy settles only once; a later user-initiated clear is never overridden by auto-selection again, and a connect failure waits for the next baseline projection to retry.
+- Re-picking the Workspace in the blank Hero also goes through `connectWorkspace`; when the target id differs from the current one, the current input machine's non-empty draft moves to the target scope first, then `sessions.open(nextId)`. The old blank entity is not deleted — it merely leaves the list by no longer being current.
+
+### Per-session provisioning: the `sessions.provide` standard-kit channel
+
+The sole provisioning path by which session slot components fetch their own session data. Plugins declare a fixed key map through the static descriptor `sessions.provide({hooks, props, resolve})` (a duplicate key throws at registration); `resolve(binding)` materializes values for a specific session and tears them down with the scope. Web-react's `standardKit` single loop binds the hooks compartment into `use<Name>` selector hooks (`observableHook`→uSES, anti-tearing) and passes the props compartment through as-is.
+
+Slot scope is the closed set `root | session-maybe | session`:
+
+- `root` receives only the global standard kit, with no session identity or provisioning.
+- `session-maybe` follows the current session, but the component instance does not change key when the id appears, disappears, or changes; with no session, `sessionId`, the results of `useSession`/`useInput`, and `inputActions` may all be absent. The unkeyed root `SessionMaybeProvider` drives these updates, while `SessionMaybeProvideInfo` uses the static key map to retain the complete hook/prop shape even with no session.
+- `session` guarantees that `sessionId`, every hook source, and every prop exist; each strict entry's error boundary is keyed by `sessionId`, so switching sessions recreates that entry and its session store.
+
+`conversation` is the resident `session-maybe` shell: `ConversationRoot`, HeroShell, the Workspace picker, the composer stack, and the overlay chain's fallback frame retain their React instances across the no-session → blank-session switch; `conversation.session` carries only the strict-session header/view, while the composer and every input slot also stay strict `session`. With no session, the composer stack places the presentation-only `DisabledInputBar` directly; once a session appears, the input body is swapped for the strictly bound InputBar; the textarea may be rebuilt, while the Hero and the layout skeleton are not. The blank → engaging/active transition stays inside the same strict-session subtree, and the InputBar is never rebuilt on a phase flip.
+
+- The runtime's first built-in entry: the `'session'` hook — `useSession` itself rides the same mechanism, no special-casing.
+- Concurrent discipline: the render plane reads only from the hooks compartment (uSES consistency guarantee); props-compartment callbacks are used only in event-handler space; descriptor resolution is render-safe (idempotent caching, with prune reaping residue from abandoned renders).
+- Third-party components take zero value dependencies; types are a one-line type-only import (declaration merging into `SessionStandardProps` / `SessionMaybeStandardProps`).
+
+### The read-only queue mirror
+
+- The MuxFrame `session/queued`: the Session holds a read-only inbox mirror (previews truncated; steering retired by source match); queue frames never enter history — pure stream state, cleared on reconnect and refilled from the new baseline; the never-instantiated window is buffered and replayed through the manager pendingBuffers.
+- Queue semantics: running does not lock input; ordinary messages queue through `session.prompt {mode:'queue'}`, and commands never queue.
+
+### Host wire smalls
+
+- The summary `blank` column and the `host/session-added` frame's `blank` field (see the blank bit above).
+- The SSE frame `host/commands-changed` (a pure invalidation signal); the client routes it into the typed events `commands/changed` and `connection/reset` (broadcast after each connection generation is established; wire-derived caches uniformly treat prior state as stale).
+- `command.list/execute` and `skill.list` are uniformly single-addressed by `sessionId` (a session always has an Agent; `agentFor`'s resume semantics come ready-made); the command-surface narrative lives in the [command surfaces note](2026-07-25-web-command-surfaces-and-assembly.md).
+- The `session.create` request shape: workspaceId/cwd as either-or, plus an optional caller-preallocated sessionId (a same-id same-cwd retry is idempotent; a different cwd reports `session-conflict`).
+
+## Alternatives considered
+
+| Rejected | One-line reason |
+|---|---|
+| A client-local Intent + materialize (published CAS / the pendingPrompt attach transaction / the before-create chain) | The client is forced to simulate the first half-life the host lacks, breeding a pile of state machinery — published CAS, the attach transaction, partial publication |
+| Host-reserved IDs (a draft Map) | The host merely acknowledges a number; the state machine stays on the client untouched |
+| A host draft Session (a Session without an Agent) | Every host surface that looks up the Agent must fork for drafts; core would need an attachAgent seam plus late-written header cwd |
+| Binding an Agent before cwd (ungrouped) | Overturns the readonly header.cwd "created in" invariant, plus the launch-dir side-effect product trap |
+| Passing session context down through React Context | Plugins should hold one mental model across host and client; the scope mechanism is isomorphic to the host dsh-scope |
+| A `scopeTarget` carrier + fused dispatcher (mirroring the host `agentEvents`) | The host wrapper layer guards the business Agent subject against drifting from the scope key; client events have no subject to guard — the filter on the actx plus cordis primitives covers every need |
+| Sessions not holding a ctx (a cordis-free object layer) | A red line born only so the filtering unit tests avoid importing cordis, at the cost of two-hop contribute callbacks plus mutable public fields; the host Agent already holds loopCtx |
+| Resident Session instances (resident-instance) | The host session log is the durable truth; residency is mere identity convenience, and its misalignment with the scope lifecycle is a source of complexity |
+| Components receiving wiring-callback bundles (two-layer inject→props pass-down) | The standard-kit channel lets components fetch their own; the public surface converges to hooks + stable props |
+| Swapping the no-session Hero view for the entire session Conversation | Even with the outer layout unchanged, the Hero, picker, and composer subtrees would remount together, making the whole UI region jump |
+| Making InputBar itself `session-maybe` | The input state machine, keyboard command surface, and actions would all have to accept absent values; replacing only the disabled input body keeps optionality at the shell boundary |
+| A dedicated conversion frame | `session-status(running:true)` semantically implies conversion (a blank session never runs); adding a frame buys zero information for one more wire type |
+
+## Consequences
+
+- Plugins gain session context isomorphic to the host's: per-session state hangs on the actx and mounts/tears down in one piece with the scope fiber, making leaks structurally impossible; two-session isolation is structurally guaranteed by the scope filter.
+- The client object layer converges to a wire mirror: session identity, lifecycle, and capability adjudication all defer to the host entity — the input system (the next layer) always faces a session with a real Agent, and providers like slash/skill uniformly address by sessionId directly.
+- Blank-session governance takes zero dedicated mechanisms: state rides one derived bit, visibility rides the unified list projection (only the current blank shows, as `New Session`), reclamation rides lazy persistence's existing contract (evaporation on restart), and the ordinary ceiling rides same-Workspace reuse.
+- The cost: the id→ctx handoff discipline and provide's Concurrent discipline are conventions rather than type-enforced, pinned by review and tests; fully disabled input while no workspace is picked is an experience cost the product surface accepts (the price of the single state axis).
+- Known gaps: approval/question recovery across prune (TODO); model selection returns in live-mutation shape (the host `selectModel` trio is ready-made, awaiting its own branch).

.agents/notes/implemented/architecture/2026-07-25-web-client-session-scope-and-provide-channel.zh.md

@@ -0,0 +1,137 @@
+# Agent Note: Web client Agent-scope 对等模型与供数通道（agents/scope / blank 复用 / provide）
+
+Status: implemented
+
+[English](2026-07-25-web-client-session-scope-and-provide-channel.md) | 中文
+
+> 范围：client Agent scope（actx）与定向事件、client/host 实体化对等模型、空会话 blank 位与复用（`connectWorkspace`）、per-session 供数通道（`sessions.provide`）、队列只读镜像（`session/queued`），以及承载这些能力的 host wire 小件（summary `blank` 列、`host/session-added` 帧字段、`host/commands-changed` 帧）。输入状态机与 slash 管线见[输入状态机 note](2026-07-25-web-input-machine-and-slash-pipeline.md)；命令业务面见[命令业务面 note](2026-07-25-web-command-surfaces-and-assembly.md)。
+
+## 问题
+
+web client 只有一张全局会话面：slot 全部从根 context 渲染，插件拿不到「当前是哪个 agent/session」的语境；draft 真身埋在 Session 对象里，任何要参与输入的插件都无处下手。要支撑命令/输入体系，平台层必须先回答：
+
+- 会话交互态（菜单、popup、草稿、在途请求）归谁持有，双会话如何结构性隔离；
+- 「新会话」在 host 实体存在之前是什么——client 要不要为它造一段独立生命；
+- session-scope 组件如何「自己拿会话数据」，而不是层层下传 props；
+- 用户放弃的新会话在 host 侧留下什么，谁来收。
+
+硬约束：host 是唯一真源；一切注册走 `ctx.effect` disposer；scope 机制与 host 的 Agent scope 架构一致；模型可见 ⟺ 已入 session log。
+
+## 决策
+
+### 对等模型：client 与 host 同一根状态轴
+
+host 侧 `session.create(workspaceId)` 一体产出 Session + Agent + cwd（原子大礼包，不拆）；client 侧就是这次出生的镜像——会话行进入 list mirror 的瞬间，client 为它铸 Agent scope（actx + provide + 输入面全套挂上）：
+
+- 会话身份自出生即为 host 真身：sessionId 由 `session.create` 响应 / `host/session-added` 帧带来，client 侧一切寻址（scope tag、slot store 键、RPC 地址）用的都是同一个 id。
+- 实体化时点 = 用户选定 Workspace（cwd 确定）的瞬间：client 当场调 `session.create({workspaceId})`，拿到完整实体。
+- 「New Session 且未选 workspace」是**纯视图态**（一个导航位置），不对应任何 session/scope 实体；选定之前 composer 整体锁死（无 slash、无纯文本）。
+- 「空会话」就是一个日志还空着的普通实体化会话；对 host 上所有 Agent-scope 插件（goal/plan/skill/…）它与任何会话无异，slash/plan 天然全活。
+
+### Agent scope：actx 是 client 侧 cordis 世界的唯一会话载体
+
+runtime `agents/scope.ts` 与 host `dsh-scope` 机制层一致（fiber + tag + filter 过滤；不 value-import：host 包携带 scoped-events 的 `Events` merge，进 client program 撞 Context merge）：
+
+- `createScope(ctx, key)`：no-op plugin fiber + `extend({[kScope]: key, [Context.filter]: …})`——filter 直接住 actx：untagged listener 全局可收，tagged 只收本 scope。
+- 派发就是 cordis 原语，thisArg = actx 本身：`actx.bail(actx, event, req)` / `actx.emit(actx, event, payload)`。
+- `Session.bindScope(actx)`：resolve 铸 scope 时单次配对（重复绑 throw；dropScope unbind），镜像 host `Agent.loopCtx`——Session 用它自行派发 scoped 事件。actx→Session 反向走 `sessions.sessionOf(actx)` 一跳（镜像 host 插件 `agent.session` 用法）。
+
+与 host dsh-scope 的有意分歧三条：
+
+- filter 住 actx 自身而非独立 carrier：host 包装层护的是「业务 Agent subject 与 scope key 不漂移」（host 事件首参注入 Agent 本体），client 事件 payload 只带 id、无 subject 可护。
+- key 用品牌 `SessionId` 值比较而非对象身份：host 里 agent.id === session id（1:1 同轴），agent 身份直接复用 `SessionId` 品牌，client scope 的身份即 wire id。
+- client 是 **Agent 身份** scope 而非活对象 scope：cold 会话期 host Agent 对象已 dispose 而 client actx 存活（视野内）——身份轴严格对等、对象冷热有意不同步。
+
+id→ctx 换乘只许三类位置（业务 provider 永不换乘）：
+
+- slot inject 工厂：ctx 不进渲染层，slot 框架交给组件的身份就是 sessionId，经服务 map 换回对象/controller。
+- root 协调服务自寻址：从投影的 sessionId 经 `sessions.scope(id)` 找回 actx。
+- root untagged listener：按 payload 的 sessionId 查自有 store。
+
+### scope 生命周期：挂靠 list mirror，出生即视野、死亡即 prune
+
+Session 实例与 scope 同生命周期，存活资格 = host listed（一个判据，mint 与 prune 共用）：
+
+- 出生 = 会话行进入 client 视野（list 基线拉取 / `create()` 本地回声 / `host/session-added` 帧），lazy 首次 resolve 铸 scope（resolution 纯函数、渲染安全）。
+- prune 一次同拆三样：Session 实例、scope fiber（级联挂在 actx 上的一切消费者）、session-keyed slot store。staged session（= `list.current`）例外：被移除仍在台上时保留冻结只读视图，stage 移走才拆。
+- 重开 = lazy 重建实例 + `open()` 拉 history（host session log 是持久真相）。
+- 遗留 TODO：approval/question 帧不进 history，跨 prune 不可恢复（manager 级 pendingBuffers 只覆盖「从未实例化」窗口）。
+
+### blank 位：空会话的可见投影、转正与复用
+
+「实体化但无首讯」的会话经 summary 派生位 `blank` 治理（派生列而非 header 字段，SessionHeader 保持不可变）：
+
+- host 判据：`session.events.length === 0`（零日志事件 = 尚无用户消息）。live 会话 `summarize()` 内存直读；cold 会话恒 `false`——lazy-create 契约保证 never-appended 会话根本不进 `persistence.list()`（JSONL/SQLite 两后端均已实证真 lazy），blank 从不落盘。
+- wire 承载两处：`SessionSummary.blank` 必填列；`host/session-added` 帧必填 `blank` 字段（创建时恒 true，供别的 tab 按同一空会话状态入镜像）。
+- client 镜像只降不升（单调），三来源翻转，全部复用既有 wire 信号：
+  - 发送方本地：首次 `prompt()` 的**成功响应**翻 false（受理即证明 user/message 已入 host 日志——此点翻转是确证而非乐观；`onEngaged` 同步更新列表镜像，当前 `New Session` 行原地转为普通标题，不新增列表行）。首讯被拒则会话保持 blank：与 host 权威对齐、继续显示为 `New Session`、保持 connectWorkspace 复用资格。
+  - 其他端：`host/session-status (running:true)` 帧翻转——blank 会话从不 running，首次 running 必然已非 blank；
+  - 重连对齐：`session.list` 的 summary.blank 是权威，错过帧的端下次拉取自然对齐；陈旧的 blank:true 不能把已转正的会话重新标回 blank。
+- 列表纪律：store 保留全部行；Workspace browser 的分组、平铺、搜索和计数共用同一可见投影——所有非 blank 会话都显示，blank 会话只显示 `session.id === sessions.current` 的一条，并强制标题为 `New Session`。切换 Workspace 后，旧 blank 实体仍在镜像中但从列表隐藏，目标 Workspace 的 current blank 显示；因此用户可见面全局至多一条 blank 行。
+- 残留账零 GC：刷新后 blank 会话带位回来，下次同 workspace 复用，普通单端路径使每个 workspace 至多保留一个；host 重启后 blank 无盘痕自然蒸发；多 tab 竞态多出的空壳只会成为非 current 隐藏行，后续复用消化，不做协调。
+
+### connectWorkspace：New Session 的唯一入口
+
+`workspaces.connectWorkspace(workspaceId): Promise<SessionId>`（归属 WorkspacesService——它同时持有 workspace 规范 path 与 sessions 引用）：
+
+- 复用臂：list mirror 中找 `blank && cwd == workspace.path`（host realpath 规范 canon 直等比较），命中直接返回该 id，不新建。
+- 新建臂：未命中则 `session.create({workspaceId})`，返回新 id。
+- 未知 workspaceId fail loud（不静默创建到别处）。
+- 解析保证（两臂同契约）：promise resolve 时返回的 id 已在 list store 且 `sessions.binding(id)` 同步可解析——`SessionsService.create` 在 RPC 成功后同步投影列表再 resolve，使 draft 搬运方可以在 open 之前往新 scope 的 machine 写文本，不等 notifier flush。
+- 调用方拿 id 自行 `sessions.open`；首讯发送就是普通 `session.prompt`——会话本来就在，失败即普通 prompt 失败，draft 文本还在 machine 里，重试即再次发送。
+- 全局 New Session 按钮默认取 `recentWorkspaceId`：先比较各 Workspace 内 Session 的最新 `updatedAt`，无 Session 时回退 Workspace `createdAt`，同值保持 Host 顺序；只有完全没有 Workspace 时才 `sessions.clear()` 进入无 session 视图。Workspace 分组内的创建动作仍显式命中该 Workspace。
+- runtime 启动时订阅首次完整基线：若已有恢复成功的 current session 则保持不动，否则自动 `connectWorkspace(recentWorkspaceId)` 并 open 返回的 blank session。该策略只结算一次；之后用户主动 clear 不会再次被自动选择覆盖，连接失败则等下一次基线投影重试。
+- blank Hero 中改选 Workspace 也走 `connectWorkspace`；若目标 id 与当前 id 不同，先把当前 input machine 的非空 draft 搬到目标 scope，再 `sessions.open(nextId)`。旧 blank 实体不删除，只因不再 current 而从列表隐藏。
+
+### per-session 供数：`sessions.provide` 标准件通道
+
+session slot 组件「自己拿 session 数据」的唯一供数路径。插件以静态描述符 `sessions.provide({hooks, props, resolve})` 声明固定键表（重名 key 注册时 throw），`resolve(binding)` 在确定 session 下物化值并随 scope 拆；web-react `standardKit` 统一循环把 hooks 格绑成 `use<Name>` 选择器 hook（`observableHook`→uSES，防 tearing）、props 格原样透传。
+
+slot scope 是闭集 `root | session-maybe | session`：
+
+- `root` 只拿全局标准件，不接收 session 身份或供数。
+- `session-maybe` 跟随 current session，但组件实例不因 id 有无或切换而换 key；无 session 时 `sessionId`、`useSession`/`useInput` 的选择结果及 `inputActions` 均可缺省。根部无 key 的 `SessionMaybeProvider` 驱动这条更新，`SessionMaybeProvideInfo` 靠静态键表在无 session 时仍保留完整 hook/prop 形状。
+- `session` 保证 `sessionId`、所有 hook source 与 props 均存在；每个严格 entry 的错误边界以 `sessionId` 为 key，切换 session 会重建该 entry 及其 session store。
+
+`conversation` 是 `session-maybe` 的常驻外壳：`ConversationRoot`、HeroShell、Workspace picker、composer stack 与 overlay chain 的 fallback 外框在无 session → blank session 的切换中保持 React 实例；`conversation.session` 只承载严格 session 的 header/view，composer 与各输入 slot 也保持严格 `session`。无 session 时 composer stack 直接放纯展示的 `DisabledInputBar`，session 出现后把输入体换成严格绑定的 InputBar；textarea 允许重建，Hero 与布局骨架不重建。blank → engaging/active 仍在同一严格 session subtree 内，InputBar 不因 phase 翻转而重建。
+
+- runtime 内建第一条：`'session'` hook——`useSession` 本身走同一机制，无特判。
+- Concurrent 纪律：渲染平面只从 hooks 格读（uSES 一致性保证）；props 格回调只在事件 handler 空间用；描述符解析 render-safe（幂等缓存、废弃渲染残留由 prune 收尸）。
+- 第三方组件值零依赖，类型一行 type-only import（declaration merging 进 `SessionStandardProps` / `SessionMaybeStandardProps`）。
+
+### 队列只读镜像
+
+- MuxFrame `session/queued`：Session 持只读 inbox 镜像（预览截断、steering 按 source 匹配退休）；queue 帧不进 history，纯 stream 态——重连清空、新基线重灌；未实例化窗口经 manager pendingBuffers 缓冲重放。
+- 队列语义：running 不锁输入；普通消息经 `session.prompt {mode:'queue'}` 排队，命令永不排队。
+
+### host wire 小件
+
+- summary `blank` 列与 `host/session-added` 帧 `blank` 字段（见上文 blank 位）。
+- SSE 帧 `host/commands-changed`（纯失效信号）；client 路由为类型事件 `commands/changed` 与 `connection/reset`（连接代建立后广播，wire 派生缓存一律视旧态为 stale）。
+- `command.list/execute`、`skill.list` 一律 `sessionId` 单址（会话恒有 Agent，`agentFor` 的 resume 语义现成）；命令面叙述见[命令业务面 note](2026-07-25-web-command-surfaces-and-assembly.md)。
+- `session.create` 请求形状：workspaceId/cwd 二选一 + 可选调用方预分配 sessionId（同 id 同 cwd 重试幂等，异 cwd 报 `session-conflict`）。
+
+## Alternatives considered
+
+| 弃案 | 一行理由 |
+|---|---|
+| client-local Intent + materialize（published CAS / pendingPrompt attach 事务 / before-create 链） | client 被迫模拟 host 缺失的前半段生命，养出 published CAS、attach 事务、部分发布一坨状态机 |
+| host 预留 ID（draft Map） | host 只认了个号，状态机原封留在 client |
+| host draft Session（有 Session 无 Agent） | 每个查 Agent 的 host 面都要为 draft 分叉；core 要开 attachAgent 缝 + header cwd 后写 |
+| 无 cwd 先绑 Agent（ungrouped） | header.cwd readonly "created in" 不变性被推翻 + launch-dir 副作用产品坑 |
+| React Context 层层传会话语境 | 插件在 host/client 两侧应是一个心智模型；scope 机制与 host dsh-scope 同构 |
+| `scopeTarget` carrier + 融合派发器（镜像 host `agentEvents`） | host 包装层护的是「业务 Agent subject 与 scope key 不漂移」，client 事件无 subject 可护；filter 住 actx + cordis 原语覆盖全部需求 |
+| Session 不持 ctx（对象层 cordis-free） | 只为筛选单测不引 cordis 而生的红线，代价是 contribute 两跳回调 + 可变公有字段；host Agent 本就持 loopCtx |
+| Session 实例常驻（resident-instance） | host session log 即持久真相；常驻仅为身份便利，与 scope 生命周期错位是复杂度之源 |
+| 组件收 wiring 回调包（inject→props 两层下传） | 标准件通道让组件自取；公共面收敛为 hooks + 稳定 props |
+| Hero 无 session 视图与 session Conversation 整支互换 | 即使外层 layout 不变，Hero、picker 与 composer 子树仍会一起重建，界面产生整块抖动 |
+| 让 InputBar 自身变成 `session-maybe` | 输入状态机、键盘命令面与动作都被迫接受缺省值；只替换 disabled 输入体能把可选性留在外壳边界 |
+| 专用「转正」帧 | `session-status(running:true)` 语义蕴含转正（blank 会话从不 running），加帧是 wire 多一型换零信息 |
+
+## 后果
+
+- 插件获得与 host 同构的会话语境：per-session 状态挂 actx、随 scope fiber 一次拆装，泄漏结构性不可能；双会话隔离由 scope filter 结构性保证。
+- client 对象层收敛为 wire 镜像：会话身份、生命周期、能力判别全部以 host 实体为准——输入体系（下一层）面对的永远是「有真 Agent 的会话」，slash/skill 等 provider 一律以 sessionId 直接寻址。
+- 空会话治理零专用机制：状态靠一个派生位，可见性靠统一列表投影（仅 current blank 以 `New Session` 展示），回收靠 lazy persistence 的既有契约（重启蒸发），常规上限靠同 Workspace 复用。
+- 代价：id→ctx 换乘纪律、provide 的 Concurrent 纪律都是约定而非类型强制，靠 review 与测试钉住；「未选 workspace」期间输入全禁是产品面接受的体验代价（单一状态轴换来的）。
+- 已知欠账：approval/question 跨 prune 恢复（TODO）；模型选择以 live-mutation 形状回归（host `selectModel` 三件套现成，等独立分支）。

.agents/notes/implemented/architecture/2026-07-25-web-command-surfaces-and-assembly.i18n.yaml

@@ -0,0 +1,6 @@
+# Bilingual-pair consistency record (docs/i18n/README.md): the git blob hash of each
+# 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
+2026-07-25-web-command-surfaces-and-assembly.md: 5188e8c17b31157b1c03203a8d7ba2d8e6a1496b
+2026-07-25-web-command-surfaces-and-assembly.zh.md: 0134cc10cf4f49b7719d6a0dacb239389776d6ed

.agents/notes/implemented/architecture/2026-07-25-web-command-surfaces-and-assembly.md

@@ -0,0 +1,62 @@
+# Agent Note: Web command business surfaces and assembly (ui-command / ui-skill / ui-subagent)
+
+Status: implemented
+
+English | [中文](2026-07-25-web-command-surfaces-and-assembly.zh.md)
+
+> Scope: the command directory cache and three-kind dispatch (ui-command), the popup selection flow, the two skill / subagent reference sources, and fixture command routing plus assembly acceptance (the slash-flow snapshot). The carrying wire lives in the [session scope note](2026-07-25-web-client-session-scope-and-provide-channel.md); triggers, the menu, and the input machine live in the [input machine note](2026-07-25-web-input-machine-and-slash-pipeline.md).
+
+## Problem
+
+The pipeline was ready but command knowledge had no landing spot: host-side `ctx.commands` and `ctx.skills` were complete while the web channel had no command capability. The business layer had to answer:
+
+- Command UI takes more than one shape (execute on the spot, pop a select box, backfill and keep typing arguments) — how do business packages ship with zero skeleton changes;
+- When is the directory fetched: pulling on every menu open is too slow, while a resident cache needs invalidation and reconnect stories;
+- Sessions are always agent-backed (Session + Agent born in the same instant) — by what address does the client command surface honor the host's per-agent effective directory;
+- Assembly-level acceptance: with the layers split apart, how the user-visible main chain is pinned once they come together.
+
+## Decision
+
+### ui-command: a `CommandService` + a session-keyed `CommandDirectory` + a per-session `PopupSelectController`
+
+- The `ClientSessionContext { sessionId }` projection is self-held in the ui-slash contract (types.ts): sessions are always agent-backed, so session identity is the entire projection of command capability; the wire addresses by `{sessionId}` (both `command.list` and `command.execute`; the host resolves the Agent from the session header).
+- The directory is compartmented by `SessionId`, with per-key single-flight + an epoch guard (an old pull never overwrites newer state); `commands/changed` soft-invalidates every key (the old snapshot keeps serving while the repull runs in the background), `connection/reset` hard-invalidates every key and rewarms, Enter strong-waits on the current key, and a failure keeps the draft with no downgrade. Prewarming hangs on the source's `warm` hook — once over the full roster at scope birth, which covers the entire session lifecycle (session capability is constant from birth).
+- `register(contribution)` registers client commands (a descriptor + `available(projection)` + a popupSelect spec); candidate synthesis = the host directory + contribution availability filtering, then the query/position pass, and a host/contribution name clash fails loud.
+- The three command kinds derive from the registration surfaces; developers never declare positions: a host descriptor with `input` = **leadingInput** (backfill `/name ␣` + claim, keep typing arguments, leading position only); a client-registered popupSelect spec = **popupSelect** (the official select-box shell, business ships zero components); neither = **execute** (run on selection, zero UI).
+- The dispatch decision table: the menu can trigger all three kinds; Space recognizes only leadingInput (the misfire defense: irreversible side effects keep explicit entry points only); Enter runs execute / opens the shell only on a bare token, while leadingInput tolerates trailing arguments.
+- The popup from `popupFor(actx)`: search filters locally, select is single-flight, the projection is captured at open, onSelect consumes the token through the consume-token event only on success, a failure is retained for retry, and a session switch merely hides it. The popup shell is a transient layer (never in the state machine): the box holds focus, Enter/↑↓/Escape belong to it, and clicking outside the box dismisses (clicking the textarea also returns focus).
+
+### Reference sources (seeing only projections plus their own apply closures, on the root ctx)
+
+- **ui-skill**: `skill.list({sessionId})` addresses by session (the host resolves the project root from the session header); the directory cache is single-flight keyed by sessionId, prewarmed at birth by the `warm` hook and fully cleared by `connection/reset`. A pick produces a text outcome (the literal `/name ` text, Decision 21); `lexicon` supplies the roster from CatalogFetch's settled snapshot (`undefined` while not warm). No match hook (references never enter command adjudication). Skill references ride ordinary prompts as literal text (outside the command plane; tool-skill unchanged, with the session-prefix directory providing the cooperative association).
+- **ui-subagent**: candidates are zero-RPC (the sessions.list snapshot filtered by parentId/running); a pick produces a text outcome (the literal `@name ` text); `lexicon` derives from the same snapshot (the model-side representation awaits its business workstream).
+
+### Fixture command routing and assembly
+
+- The connection fixture adds command routing (fixture + fake-api): the keyless rig can run the complete command flow (directory, execution, popup selection).
+- The apps/cli assembly mounts all the new packages; the tsconfig path map / reference sets are filled in; catalogs/docs are regenerated with the wire and events.
+
+### Assembly-level acceptance: the slash-flow snapshot
+
+`apps/web/tests/slash-flow.snapshot.ts` pins the user-visible main chain (assembled keyless; package mocks are no substitute for the assembled transcript): the composer disabled with no session → creating a Workspace and entering an already-materialized blank session → picking the `/echo` leadingInput from the `/` menu → the command executes but the blank bit does not flip and the list still shows `New Session` → the first ordinary prompt's successful acceptance converts that same row; the same session-bound textarea holds across blank → active. `workspace-flow.snapshot.ts` separately pins blank-row creation/reuse, first-prompt rejection backfill, and — on a Workspace switch before the first prompt — the draft moving across input machines with the old blank row hidden.
+
+## Alternatives considered
+
+| Rejected | One-line reason |
+|---|---|
+| Inline prompt dispatch (command text riding the message into the host for parsing) | Conflates the command and message planes; command execution being independent of the message queue is existing host semantics |
+| A bridge materializing skills as commands | Skills have their own directory; N registrations would be a detour; the tag form naturally avoids the command plane |
+| A `skill.invoke` RPC | The host has no such operation; skill references are plain text riding prompts |
+| A new ContentBlock reference type | Full-chain cost (adapters/UI/compaction); text-as-truth plus structured occurrence records suffices |
+| Client packages self-reporting command directories | The host is the single source of truth; the client only reads descriptors, with `commands-changed` pushing invalidation |
+| The `requires: 'none' \| 'agent'` discriminant axis (an agentless directory + dual-addressed queries) | With sessions always agent-backed, the amphibious command has no owner; the whole axis reverts to master's shape, to be reopened on real demand |
+| Dedicated commandresult / commandpanel slots | Results go through notices; the popup shell is a skeleton-internal overlay; rich result cards sit in the ledger |
+| An agent-type directory as the `@` source | No type registry exists; the live-session snapshot already covers it |
+| A PickAction/EnterCommand class family (class-inheritance pick products) | Cross-package runtime values break client bundle purity; pure data interfaces plus closure methods are equivalent |
+
+## Consequences
+
+- Shipping a business command = a host registration plus one client `command.register` (popupSelect) or zero registration (execute/leadingInput derive automatically), with zero skeleton changes; the cost is that the three-kind semantics concentrate in ui-command, and a hypothetical fourth kind means changing it.
+- The resident directory cache plus push invalidation buys zero-latency menus and reliable enter adjudication; the cost is three invalidation paths (the change frame, reconnect, the epoch guard) that all need tests pinning them.
+- sessionId addressing puts the host's per-agent effective directory (global + scoped shadows) straight on the wire, with the client presenting it as-is.
+- Known gaps: the popupSelect shell has no shipped business consumer yet (model selection and its kin return with #600's host `selectModel` in live-mutation shape, serving as the onboarding template then); the queue's second cut (per-item Inbox operations), rich result cards, and roster configurability sit in the ledger awaiting their triggers.

.agents/notes/implemented/architecture/2026-07-25-web-command-surfaces-and-assembly.zh.md

@@ -0,0 +1,62 @@
+# Agent Note: Web 命令业务面与装配（ui-command / ui-skill / ui-subagent）
+
+Status: implemented
+
+[English](2026-07-25-web-command-surfaces-and-assembly.md) | 中文
+
+> 范围：命令目录缓存与三型判定（ui-command）、popup 选择流、skill / subagent 两个引用源、fixture 命令路由与装配验收（slash-flow 快照）。承载 wire 见[会话作用域 note](2026-07-25-web-client-session-scope-and-provide-channel.md)；触发/菜单/输入机器见[输入状态机 note](2026-07-25-web-input-machine-and-slash-pipeline.md)。
+
+## 问题
+
+管线就绪但没有命令知识的落点：host 侧 `ctx.commands` 与 `ctx.skills` 完整而 web 通道无命令能力。业务层要回答：
+
+- 命令 UI 不止一种形态（当场执行、弹选择框、回填后继续打参数）——业务包如何零骨架改动上架；
+- 目录何时拉取：每次开菜单现拉太慢，常驻缓存就要有失效与重连故事；
+- 会话恒 agent-backed（Session+Agent 同瞬出生），client 命令面以什么地址兑现 host 的 per-agent 有效目录；
+- 装配级验收：拆开的各层合起来，用户可见主链如何钉住。
+
+## 决策
+
+### ui-command：`CommandService` + session 键控 `CommandDirectory` + per-session `PopupSelectController`
+
+- 投影 `ClientSessionContext { sessionId }` 自持于 ui-slash 契约（types.ts）：会话恒 agent-backed，会话身份即命令能力的全部投影；wire 以 `{sessionId}` 寻址（`command.list` / `command.execute` 均是；host 从会话 header 解析 Agent）。
+- 目录按 `SessionId` 分格，per-key single-flight + epoch guard（旧拉取永不覆盖新态），`commands/changed` 全 key 软失效（旧快照继续服务、后台重拉）、`connection/reset` 全 key 硬失效并预热，Enter 强等当前 key、失败留草稿不降级。预热挂 source 的 `warm` 钩子——scope 出生时对全 roster 一次，即覆盖整个会话生命周期（会话能力自出生恒定）。
+- `register(contribution)` 注册 client 命令（descriptor + `available(projection)` + popupSelect spec）；候选合成 = host 目录 + contribution 可用性过滤，再过 query/position，host/contribution 重名 fail loud。
+- 命令三型按注册面派生，开发者不声明位置：host descriptor 带 `input` = **leadingInput**（回填 `/name ␣` + claim，继续打参数，仅限行首）；client 注册 popupSelect spec = **popupSelect**（官方选择框壳，业务零组件）；两者皆无 = **execute**（选中即执行，零 UI）。
+- 判定决策表：菜单可触发三型；Space 只认 leadingInput（误触发防线：不可逆副作用只留显式入口）；Enter 裸 token 才 execute/开壳、leadingInput 容忍尾随参数。
+- `popupFor(actx)` 的 popup：search 本地过滤、select single-flight、open 时捕获投影、onSelect 成功才经 consume-token 事件消 token、失败保留可重试、session 切换只隐藏。popup 壳是瞬态层（不进状态机）：框持焦点、Enter/↑↓/Escape 归它、点框外即 dismiss（点 textarea 同时归还焦点）。
+
+### 引用源（只见投影 + 自家 apply 闭包的 root ctx）
+
+- **ui-skill**：`skill.list({sessionId})` 按会话寻址（host 从会话 header 解析项目根）；目录缓存按 sessionId 键控 single-flight，`warm` 钩子出生预热、`connection/reset` 全清。pick 产出 text outcome（`/name ` 原文，决策 21）；`lexicon` 从 CatalogFetch 的 settled 快照给名录（未热 `undefined`）。无 match 钩子（引用不进命令裁决）。skill 引用以原文随普通 prompt 走（命令平面之外；tool-skill 不变，session-prefix 目录提供协作关联）。
+- **ui-subagent**：候选零 RPC（sessions.list 快照按 parentId/running 过滤）；pick 产出 text outcome（`@name ` 原文）；`lexicon` 同快照派生（模型侧表示待业务立项）。
+
+### fixture 命令路由与装配
+
+- connection fixture 补命令路由（fixture + fake-api）：keyless 台架可跑完整命令流（目录、执行、popup 选择）。
+- apps/cli 装配挂全部新包；tsconfig path map / reference 集补齐；catalog/docs 随 wire 与事件再生成。
+
+### 装配级验收：slash-flow 快照
+
+`apps/web/tests/slash-flow.snapshot.ts` 钉住用户可见主链（assembled keyless，包 mock 不替代装配转录）：无 session 时 composer 禁用 → 创建 Workspace 并进入已实体化的 blank session → `/` 菜单选 `/echo` leadingInput → 命令执行但 blank 位不翻转、列表仍显示 `New Session` → 首条普通 prompt 成功受理后同一行转正；同一 session-bound textarea 跨 blank → active 保持。`workspace-flow.snapshot.ts` 另钉住 blank 行创建/复用、首讯拒绝回填，以及首讯前切换 Workspace 时 draft 跨 input machine 搬运且旧 blank 行隐藏。
+
+## Alternatives considered
+
+| 弃案 | 一行理由 |
+|---|---|
+| prompt 内联派发（命令文本随消息进 host 解析） | 混淆命令/消息平面；命令执行独立于消息队列是既有 host 语义 |
+| skill 物化为 command 的桥 | skill 自有目录；N 笔注册是绕路；标签形式天然避开命令平面 |
+| `skill.invoke` RPC | host 无此操作；skill 引用是随 prompt 的普通文本 |
+| 新 ContentBlock 引用类型 | 全链路成本（adapter/UI/compaction）；文本即真身 + 结构化 occurrence 记录已足够 |
+| client 各包自报命令目录 | host 是唯一真源；client 只读 descriptor，`commands-changed` 推失效 |
+| `requires: 'none' \| 'agent'` 判别轴（agentless 目录 + 双址查询） | 会话恒 agent-backed 后两栖命令无 owner；整轴回退 master 形状，待真需求重开 |
+| 专用 commandresult / commandpanel 坑位 | 结果走 notice；popup 壳是骨架内浮层；富结果卡入台账 |
+| agent-type 目录做 `@` 源 | 无类型注册表；live-session 快照已覆盖 |
+| PickAction/EnterCommand 类族（类继承 pick 产物） | 跨包运行时值破坏 client bundle 纯度；纯数据接口 + 闭包方法等价 |
+
+## 后果
+
+- 业务命令上架 = host 注册 + client 一笔 `command.register`（popupSelect）或零注册（execute/leadingInput 自动派生），零骨架改动；代价是三型语义集中在 ui-command，假想的第四型意味着改它。
+- 常驻目录缓存 + 推失效换来菜单零延迟与回车裁决可靠；代价是三条失效路径（change 帧、重连、epoch guard）都需测试钉住。
+- sessionId 寻址让 host 的 per-agent 有效目录（全局 + scoped shadows）直接上 wire，client 原样呈现。
+- 已知欠账：popupSelect 壳暂无已上架业务消费者（模型选择等 #600 的 host `selectModel` 以 live-mutation 形态回归，届时作接入样板）；队列第二刀（逐项 Inbox 操作）、富结果卡、roster 可配置性入台账待触发。

.agents/notes/implemented/architecture/2026-07-25-web-input-machine-and-slash-pipeline.i18n.yaml

@@ -0,0 +1,6 @@
+# Bilingual-pair consistency record (docs/i18n/README.md): the git blob hash of each
+# 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
+2026-07-25-web-input-machine-and-slash-pipeline.md: acbd132a5fdb97a4098064aae689dfca604ad4b7
+2026-07-25-web-input-machine-and-slash-pipeline.zh.md: 158650a41b47f98037a1b3e610d9294694c55a8c

.agents/notes/implemented/architecture/2026-07-25-web-input-machine-and-slash-pipeline.md

@@ -0,0 +1,132 @@
+# Agent Note: Web input state machine, composer slots, and the slash pipeline (ui-conversation input / ui-slash)
+
+Status: implemented
+
+English | [中文](2026-07-25-web-input-machine-and-slash-pipeline.zh.md)
+
+> Scope: the input state machine (the occurrence table + claim watch + the submit transaction), the hub/facade and send orchestration, the three scoped bail events for cross-plugin input rewrites, `/` and `@` trigger detection and the menu pipeline (ui-slash), and the slot system around the composer. It depends on the [session scope note](2026-07-25-web-client-session-scope-and-provide-channel.md)'s sctx / provide / session-maybe and blank entity model; command knowledge (the three kinds, the directory, popups) is untouched here — that is the [command surfaces note](2026-07-25-web-command-surfaces-and-assembly.md)'s territory.
+
+## Problem
+
+Two composers, each a law unto itself: hero (EmptyState, the controlled chain writing straight into the Session) and the in-conversation InputBar (a plain controlled textarea) — behavior, draft ownership, and send path all inconsistent. To bring the three trigger families — `/` commands, skill references, `@` references — onto the input surface, these had to be answered:
+
+- How the three trigger families layer, and who holds knowledge of "commands" versus who stays zero-knowledge;
+- How the input box expresses "command mode" — derived from the draft text or explicit state? What do backspace, enter, space, and pasting a whole line each mean;
+- Submission is an asynchronous transaction (an RPC round trip) — how are stale-result backwash, session switching, and React concurrent replay defended;
+- How reference chips are represented on a plain textarea, and who owns undo / clipboard / paste matching / model serialization;
+- How cross-plugin input rewrites (menu backfill, reference insertion, token consumption) achieve dependency inversion;
+- Which React shells must be reused across no session → blank session, and which strict-session input bodies may be replaced.
+
+Hard constraints: components mount through slots only; presentation artifacts never enter the session log; the keyboard path is IME-safe throughout.
+
+## Decision
+
+### The input state machine (`InputMachine`)
+
+A pure state machine, events in / effects out, clock injected. Four phases (plain / adjudicating / claimed / submitting). Command mode is **never derived from the draft**; the pick paths establish it explicitly at discrete moments; the claim is watched by `draft.startsWith(token)`, with a backspace break releasing automatically; the claim shape is `{token, hint?}` (hint feeds ghost text).
+
+The event surface (`dispatch(ev)` is the single write entry; one transaction per event):
+
+- `draft-changed {draft, editRange?}` — the textarea's full draft; editRange narrows the occurrence-shift computation, defaulting to a shared prefix/suffix scan.
+- `newline {selection}` — the Ctrl+Enter line break (not via the browser's execCommand: under self-managed undo a browser write forks two histories).
+- `begin-command {claim, span}` / `insert-ref {reference, span}` / `consume-token {guard}` — the machine side of the three bail events; span CAS = draftRev equality.
+- `set-invalid {invalidIds}` — the style bit for owner-resolution results (not a transaction).
+- `undo` / `redo` — the self-managed transaction log (a ring of 100; single-character typing merges within injected-clock windows; a successful submit clears the log).
+- `paste-begin {text, selection, components?, generation?}` — the paste plus hot-snapshot synchronously matched components in one transaction (one Undo returns to before the paste); opens a PasteMatchAttempt.
+- `paste-upgrade {attemptId, span, reference}` — an asynchronous match upgrade as its own transaction (Undo in two steps); the attempt stays current, and insertedRange shrinks with each upgrade.
+- `invalidate-paste` — attempt-ending gestures observed at the DOM layer (caret/selection operations and the like).
+- `enter {mode}` / `adjudicated` / `adjudication-failed` / `submit-settled` / `release` — the submit-transaction plane: a SubmitAttempt (seq + AbortSignal) blocks backwash; success commits and clears the draft; failure rolls back under the drift guard (the enter-time snapshot is backfilled only while the live draft still equals it; if the user has typed again, only a notice fires).
+
+The effect surface (executed by the shell): `adjudicate` (calls SlashController.adjudicate), `begin-submit` (the claim.submit transaction), `default-sink` (ordinary messages, hub-orchestrated), `notice`.
+
+The occurrence table and the chip's three projections:
+
+- Each reference occupies one `U+FFFC` in the draft; a table entry is `{occurrenceId, source, ref, offset, label, clipboardText, invalid?}`; same-named chips stay independent through occurrenceId.
+- Every edit updates the draft and the table in one transaction: ranges shift; a deletion/replacement intersecting a placeholder acts on the whole chip.
+- The single-character placeholder makes keyboard atomicity mostly hold natively (the caret has no interior position; Backspace / arrow keys / Shift extension natively take the whole chip); a mouse click on a chip goes backdrop hit → whole-chip setSelectionRange.
+- The visual projection = label: the backdrop renders the chip at the placeholder offset (the textarea glyph is invisible), with invalid taking the invalid style.
+- The clipboard/persistence projection = clipboardText: copy/cut expands placeholders inside the selection; the draft-persistence mirror writes the same projection (the chat store always holds plain text; the refresh seed semantics = select-all copy → reopen → paste, with chips degrading to text across a refresh).
+- The model projection = generated per chip at submit through the source's `codec.serialize` (owned by the submit attempt's signal and stale guard; a missing owner / failure / cancel means no send, never a downgrade to `/name`).
+
+### Cross-plugin input rewrites: three scoped bail events
+
+The contract is declared in ui-slash (the bottom of the dependency chain); producers dispatch via `sctx.bail(sctx, ...)`, and the only consuming side is the three listeners the hub hangs on the sctx when building the shell; returning `true` ⟺ the machine passed the phase and CAS guards and actually rewrote (emitting the event ≠ a successful modification; whether Space gets `preventDefault` follows the return value):
+
+- `slash/input-begin-command` `{claim, span}` — backfill of the command claim adjudicated from a menu pick / Space (dispatched by the SlashController).
+- `slash/input-insert-reference` `{reference, span}` — reference chip insertion (dispatched by the SlashController).
+- `slash/input-consume-token` `{guard: span | bare-token}` — consuming the command token after business success (dispatched by the downstream command surfaces).
+
+Calls that stay un-evented (registry registration → explicit call → await): Input's own draft/submit, asynchronous Enter adjudication, the reference serializer, the asynchronous paste matcher. `@mode bail` has entered the JSDoc parser and the cordis catalog gate (scripts/jsdoc.ts).
+
+### The slash pipeline (ui-slash: a root `SlashService` + a per-session `SlashController`)
+
+A trigger/menu/pick pipeline with zero knowledge of "commands":
+
+- The service holds only the source registry (`SlashSource{trigger: '/'|'@', name, candidates, onPick, matchSpace?, matchEnter?}`; (trigger,name) unique, registration order = group order = polling order) and `sessionOf(sctx)`. Implementing a match hook IS the declaration of participation in space/enter adjudication; the pipeline polls in registration order, the first non-undefined answer wins, and no claimant means the default sink. matchSpace is synchronous (space fires mid-keystroke; hot cache only); matchEnter is asynchronous (it may await the source's own warmup, and a warmup failure rejects).
+- The controller holds the single authoritative hit (span included; retained for Space after the menu closes), the per-session menu store, the candidate-fetch generation, keyboard arbitration (combobox mode: focus stays in the textarea, ↑↓/Enter/Escape are intercepted and all pass the IME composition guard, with the single exception Shift+Enter unconditionally going first), and pick orchestration (outcome → self-dispatched bail events); at each session scope's birth it runs `warm(projection)` once over the source roster — within that scope the projection holds only the stable sessionId, with no published/capability transitions; the scope disposer tears down the controller.
+- Trigger-detection word boundaries (`user@host` and URL `/` never trigger) and the guard tiers (plain: `/` everywhere + `@` inline / claimed: `/` suppressed, `@` live / frozen: none) are the frozen pure core.
+
+### hub / facade: the resident shell and the strict-session input body
+
+- The hub (trigger/decoration registries + send orchestration) takes the slash/command services as optional `ctx.get()` dependencies: without ui-slash or the command surfaces, input still sends and receives normally — graceful degradation.
+- Each materialized Session has exactly one `SessionInputShell` (the facade), created and torn down with the session scope; with no session, no input machine is built. `ConversationRoot` is itself the `session-maybe` resident shell, holding HeroShell, the Workspace picker, the composer stack, and the chain-fallback frame.
+- With no session the shell renders the presentation-only `DisabledInputBar`; once `connectWorkspace` returns a blank session, only the input body is swapped for the strict-session InputBar. The textarea may be rebuilt here, while `ConversationRoot`, the Hero, and the layout skeleton hold; blank → engaging/active stays the same session-bound InputBar, with the textarea never rebuilt on a phase flip.
+- ConversationRoot's Hero criterion is `sessionId === undefined || (composerPhase === 'blank' && (openState === 'open' || openState === 'loading'))`. The first submit enters engaging synchronously, and a failure keeps the composer and the error context rather than falling back to the blank Hero; the sidebar's blank bit flips false only after a prompt is successfully accepted.
+- Sending unifies in the hub defaultSink: after an optimistic draft clear it goes only through `session.prompt {mode:'queue'|'steer'}`; backfill happens only when it fails and the live draft is still empty — a user who has kept typing is never overwritten. No Draft materialize or attach transaction exists.
+- When the blank Hero re-picks the Workspace, the shell calls `connectWorkspace`; if the target session differs, the non-empty draft moves from the current shell to the target shell before the new id is opened, and the old blank session survives but is no longer current.
+- The Notifier's two-bit contract: `dirty` (snapshot freshness, clearable by an `ensureFresh` pull) and `notifyPending` (notification debt, cleared only by a flush) are mutually independent — a pull must not swallow a push, and object-layer push subscribers (watchTransaction) depend on this guarantee.
+
+### Plain-text references (Decision 21): text outcomes and lexicon decoration
+
+skill/@subagent references skip the placeholder + occurrence identity chain — a pick inserts the literal `/name ` `@name ` text straight into the draft, with the chip visual purely derived:
+
+- PickOutcome gains a `{text}` arm; the new scoped bail event `slash/input-insert-text` `{text, span}` (the same contract as the other three: draftRev CAS, returning true ⟺ an actual rewrite); facade.insertText goes through setDraft concatenation — zero machine changes.
+- Sources get an optional `lexicon?(session)` hook: a synchronous hot-snapshot name roster, with `undefined` = data not warm — zero decoration, never triggering a fetch (the render path stays synchronous and side-effect-free); the controller aggregates it into the `lexicon()` public surface.
+- `decorations.scanTextRefs`: a word-boundary scan of the draft (`/name`, `@name` at line start / after whitespace; `x/name` never hits) against the roster; a hit gets the `.textRef` mark (a pure range highlight on the backdrop, same as hlToken); an edit breaking the match shape simply disappears on the next scan.
+- Sending is the literal text (no more `<skill>` serialization); on the bubble side MessageItem decorates both shapes (the legacy `<skill>` tag + plain-text tokens).
+- The old occurrence/paste/serialize chain stays on disk in full, undeleted (additive; deletion is a separate future cut). Known limitation kept as-is: with the lexicon not warm at paste / cold start there is no decoration — it lights up only after typing `/` opens the menu once.
+
+### Per-session provide contributions and the private keyboard surface
+
+- ui-conversation (the hub doubling as a contributor) supplies through `sessions.provide` the `'input'` hook (machine state + the queue overlay) plus the `inputActions` prop (`setDraft`/`submit`, stable void callbacks).
+- The public/private boundary: the public provide carries only React-vocabulary members; the keyboard/DOM command surface (track/arbitrate/space/undo/redo/paste/dismissPopup/bindMirror — synchronous return values, disposer semantics) is InputBar-exclusive, passed privately in-package through the InputBar entry's own inject, never leaving the plugin boundary.
+
+### The slot system
+
+`conversation` is itself session-maybe; its session content and the composer input slots are strict session, while the Hero Workspace picker stays root. The child slots are all declared by ui-conversation's conversation registration:
+
+- `conversation.session` (single) — the strict-session header, view ring, and chat store; rebuilt when the session id switches.
+- `conversation.composer.bar` (single) — the slot for the InputBar itself: the InputBar is a true slot entry (self-registered into its own slot) and the content of the composer chain's fallback; it is not a chain entry — the chain's single election would unmount it on a takeover, breaking textarea DOM survival.
+- `conversation.input.overlay` — the floating-overlay anchor inside the input card; registrants' inject resolves each one's own per-session controller by the slot sessionId.
+- `conversation.input.dock` — the stacked strip above the input (QueueDock's read-only queue list lands here), ordered by `order`.
+- `conversation.composer.dock` — the stats band on the composer's top edge.
+- `conversation.input.left` / `conversation.input.right` — the tool-row left and right regions.
+- `conversation.input.plan` / `conversation.input.model` (single) — the tool row's two named control seats; the bar passes only `locked` (owner props), each stays empty until its owning plugin registers, no placeholder fallback.
+- `conversation.hero.workspace` (root scope) — the Workspace picker shared by the no-session and blank Hero; a pick reuses or creates the target blank session through `connectWorkspace`, moving the draft where necessary before switching current.
+
+### Testing discipline
+
+The state machine's entire behavior is covered by pure-JS unit tests (event sequences in, asserting state and effects, zero browser DOM); the interaction matrix is projection-tested row by row. This requirement is precisely what forced the pure-core + service-shell layering.
+
+## Alternatives considered
+
+| Rejected | One-line reason |
+|---|---|
+| An ActiveCommand intermediate state / a registerMode mode registry / deriving command mode from the draft | Claims are established explicitly by the pick paths — no table, no derivation |
+| Direct bindTarget/bindDraft object wiring | Reverse coupling plus root-singleton cross-session mispairing; scoped bail events preserve dependency inversion with structurally correct routing |
+| A unified slash/input-apply, or eventing everything | Three independent payloads cover the cross-plugin rewrites; asynchronous paths stay registry-based explicit calls |
+| contenteditable / a rich-text tree | Poor compatibility; textarea + U+FFFC + the occurrence table covers the full interaction contract |
+| Dual draft persistence {text, occurrences} | The mirror writing the clipboard projection adds zero new concepts; chip degradation across refresh is acceptable |
+| The native textarea undo stack | Unreliable under controlled + programmatic writes; the paste two-step undo semantics can only be self-managed |
+| The InputBar receiving a 16-member wiring-callback bundle | The consumption matrix proved 11 members InputBar-exclusive and 1 a dead member; the standard-kit channel lets components fetch their own, with the keyboard surface passed privately in-package |
+| Space adjudication also claiming execute-kind commands | The misfire defense: after a space the whole line is an ordinary prompt; irreversible side effects keep explicit entry points only |
+| A generic tokenPattern decoration mechanism | Structured occurrence records replace pattern scanning |
+| A placeholder select resident in the tool row | Named seats stay empty until registration; a placeholder clashing with the real implementation is two sources of truth |
+| All references through U+FFFC chips (the pre-Decision-21 line) | Plain text + derived decoration carries zero identity state; the literal text IS the model projection, sparing undo/clipboard any special cases; the chip chain is kept for scenarios needing indivisible atomicity |
+
+## Consequences
+
+- One resident conversation shell carries no-session/blank/active: no session → blank guarantees only the outer frame's React identity, allowing the disabled textarea to be replaced by the strict InputBar; the same blank session → engaging/active keeps the InputBar and the textarea. EmptyState and the controlled intent chain (`sessions.updateIntent`/`updatePendingPrompt`/`workspaces.sendSession`) are deleted along with their last consumer.
+- The input surface's zero knowledge of commands plus optional dependencies: pure input works without the command packages; `@` references and skill references get free reuse of the same menu/pick pipeline. The cost is that space/enter adjudication is a per-source polling protocol whose answer semantics (sync/async, the meaning of undefined) are a frozen contract.
+- Transactionalized submission (attempt seq + the drift guard) makes the three defect classes — stale-result backwash, session switching, concurrent replay — structurally impossible, pinned by the matrix tests.
+- Known gaps: chip fidelity across refresh (paste matching is reusable for it) has no workstream yet; the subagent reference's model representation awaits its business workstream.

.agents/notes/implemented/architecture/2026-07-25-web-input-machine-and-slash-pipeline.zh.md

@@ -0,0 +1,132 @@
+# Agent Note: Web 输入状态机、composer 坑位与 slash 管线（ui-conversation input / ui-slash）
+
+Status: implemented
+
+[English](2026-07-25-web-input-machine-and-slash-pipeline.md) | 中文
+
+> 范围：输入状态机（occurrence 表 + claim 看护 + 提交事务）、hub/facade 与发送编排、跨插件输入改写的三个 scoped bail 事件、`/` 与 `@` 触发检测与菜单管线（ui-slash）、composer 周边坑位体系。依赖[会话作用域 note](2026-07-25-web-client-session-scope-and-provide-channel.md)的 sctx / provide / session-maybe 与 blank 实体模型；命令知识（三型、目录、popup）零涉——那是[命令业务面 note](2026-07-25-web-command-surfaces-and-assembly.md)的领地。
+
+## 问题
+
+两个各自为政的 composer：hero（EmptyState，受控链直写 Session）与会话内 InputBar（普通受控 textarea），行为、draft 所有权、发送路径全不一致。要让 `/` 命令、skill 引用、`@` 引用三类触发进入输入面，必须回答：
+
+- 三类触发如何分层，谁对"命令"有知识、谁零知识；
+- 输入框如何表达"命令态"——从 draft 文本推导还是显式状态？退格、回车、空格、整行粘贴各是什么语义；
+- 提交是异步事务（RPC 往返）——晚到结果回灌、会话切换、React concurrent 重放如何防御；
+- 引用 chip 在纯 textarea 上如何表示，undo/剪贴板/粘贴匹配/模型序列化各归谁；
+- 跨插件的输入改写（菜单回填、引用插入、token 消费）如何做到依赖倒置；
+- 无 session → blank session 时哪些 React 外壳必须复用，哪些严格 session 输入体允许替换。
+
+硬约束：组件一律经 slots 挂载；呈现物不进 session log；键盘路径全程 IME 安全。
+
+## 决策
+
+### 输入状态机（`InputMachine`）
+
+纯状态机，事件进/效果出，注入时钟。四相 phase（plain / adjudicating / claimed / submitting）。命令态**永不从 draft 推导**，由 pick 路径在离散时刻显式建立；claim 由 `draft.startsWith(token)` 看护、退格破坏自动 release；claim 形状 `{token, hint?}`（hint 供 ghost text）。
+
+事件面（`dispatch(ev)` 单写入口，每个事件一个 transaction）：
+
+- `draft-changed {draft, editRange?}`——textarea 全量草稿；editRange 缩小 occurrence 平移计算，缺省前后缀共扫。
+- `newline {selection}`——Ctrl+Enter 换行（不经浏览器 execCommand：自管 undo 下浏览器写入会分叉双历史）。
+- `begin-command {claim, span}` / `insert-ref {reference, span}` / `consume-token {guard}`——三个 bail 事件的机器侧；span CAS = draftRev 相等。
+- `set-invalid {invalidIds}`——owner resolution 结果的样式位（非 transaction）。
+- `undo` / `redo`——自管 transaction log（环形 100；单字符打字按注入时钟窗合并；提交成功清 log）。
+- `paste-begin {text, selection, components?, generation?}`——粘贴 + 热快照同步匹配组件同 transaction（Undo 一次回粘贴前）；打开 PasteMatchAttempt。
+- `paste-upgrade {attemptId, span, reference}`——异步匹配升级为独立 transaction（Undo 两段）；attempt 保持 current，insertedRange 随升级收缩。
+- `invalidate-paste`——DOM 层观察到的 attempt 终结手势（caret/selection 操作等）。
+- `enter {mode}` / `adjudicated` / `adjudication-failed` / `submit-settled` / `release`——提交事务平面：SubmitAttempt（seq + AbortSignal）防回灌，成功 commit 清稿，失败带漂移守卫 rollback（回车时快照仅当 live draft 仍等于它才回填；用户已再输入则只发 notice）。
+
+效果面（shell 执行）：`adjudicate`（调 SlashController.adjudicate）、`begin-submit`（claim.submit 事务）、`default-sink`（普通消息，hub 编排）、`notice`。
+
+occurrence 表与 chip 三投影：
+
+- 每颗引用在 draft 中占一个 `U+FFFC`；表项 `{occurrenceId, source, ref, offset, label, clipboardText, invalid?}`；同名 chip 因 occurrenceId 独立。
+- 一切编辑同 transaction 更新 draft 与表：区间平移；与占位符相交的删除/替换作用于整颗。
+- 单字符占位使键盘原子性大半原生成立（caret 无内部位；Backspace/方向键/Shift 扩选原生即整颗）；鼠标点 chip 由 backdrop 命中 → 整颗 setSelectionRange。
+- 视觉投影 = label：backdrop 在占位符 offset 渲染 chip（textarea 字形不可见），invalid 走失效样式。
+- 剪贴板/持久化投影 = clipboardText：copy/cut 把选区内占位符展开；draft 持久化 mirror 写同一投影（chat store 里永远是普通文本，刷新 seed 语义 = 全选复制→重开→粘贴，chip 跨刷新降级为文本）。
+- 模型投影 = submit 时经 source `codec.serialize` 逐颗生成（归 submit attempt 的 signal 与 stale guard；owner 缺失/失败/取消则不发送，不降级为 `/name`）。
+
+### 跨插件输入改写：三个 scoped bail 事件
+
+契约声明在 ui-slash（依赖最底层），生产者经 `sctx.bail(sctx, ...)` 派发，唯一消费侧是 hub 建 shell 时挂在 sctx 上的三个 listener；返回 `true` ⟺ 机器过 phase + CAS 守卫并实际改写（发出事件 ≠ 修改成功，Space 是否 `preventDefault` 以返回值为准）：
+
+- `slash/input-begin-command` `{claim, span}`——菜单 pick / Space 裁决出的命令 claim 回填（SlashController 派发）。
+- `slash/input-insert-reference` `{reference, span}`——引用 chip 插入（SlashController 派发）。
+- `slash/input-consume-token` `{guard: span | bare-token}`——业务成功后消费命令 token（下游命令面派发）。
+
+不事件化的调用（registry 注册 → 显式调用 → await）：Input 自身的 draft/submit、Enter 异步裁决、reference serializer、异步 paste matcher。`@mode bail` 已入 JSDoc parser 与 cordis catalog 门禁（scripts/jsdoc.ts）。
+
+### slash 管线（ui-slash：root `SlashService` + per-session `SlashController`）
+
+对"命令"零知识的触发/菜单/pick 管线：
+
+- service 只有 source 注册表（`SlashSource{trigger: '/'|'@', name, candidates, onPick, matchSpace?, matchEnter?}`；(trigger,name) 唯一、注册序 = 组序 = 轮询序）与 `sessionOf(sctx)`。实现 match 钩子即参与空格/回车裁决的声明；管线按注册序轮询，首个非 undefined 应答胜出，无人认领落 default sink。matchSpace 同步（空格在击键中触发，只许热缓存）；matchEnter 异步（可 await 源自身预热，预热失败即 reject）。
+- controller 持有唯一权威 hit（含 span；菜单关闭后为 Space 保留）、per-session menu store、候选 fetch generation、键盘仲裁（combobox 模式：焦点始终在 textarea，↑↓/Enter/Escape 拦截且全程过 IME composition 守卫，唯一例外 Shift+Enter 无条件先行）、pick 编排（outcome → 自派 bail 事件）；每个 session scope 出生时对 source roster 做一次 `warm(projection)`，projection 在该 scope 内只有稳定的 sessionId，无 published/能力跃迁；scope disposer 拆除 controller。
+- 触发检测词边界（`user@host`、URL `/` 永不触发）、守卫分档（plain：`/` 到处 + `@` 行内 / claimed：`/` 抑制、`@` 活 / frozen：全无）为冻结纯核。
+
+### hub / facade：常驻外壳与严格 session 输入体
+
+- hub（trigger/decoration 注册表 + 发送编排）对 slash/command 服务是可选 `ctx.get()` 依赖：无 ui-slash/命令面时输入正常收发，优雅降级。
+- 每个实体 Session 只有一个 `SessionInputShell`（facade），随 session scope 创建和拆除；无 session 时不造 input machine。`ConversationRoot` 自身是 `session-maybe` 常驻外壳，持有 HeroShell、Workspace picker、composer stack 与 chain fallback 外框。
+- 无 session 时外壳渲染纯展示的 `DisabledInputBar`；`connectWorkspace` 返回 blank session 后，仅输入体换成严格 session 的 InputBar。这里允许 textarea 重建，`ConversationRoot`、Hero 与布局骨架保持；blank → engaging/active 仍是同一 session-bound InputBar，textarea 不因 phase 翻转而重建。
+- ConversationRoot 的 Hero 判据是 `sessionId === undefined || (composerPhase === 'blank' && (openState === 'open' || openState === 'loading'))`。首次 submit 同步进入 engaging，失败也保留 composer 与错误上下文，不退回 blank Hero；sidebar 的 blank 位只在 prompt 成功受理后翻 false。
+- 发送统一在 hub defaultSink：乐观清稿后只走 `session.prompt {mode:'queue'|'steer'}`；失败且 live draft 仍为空才回填，用户已经继续输入则不覆盖。不存在 Draft materialize 或 attach 事务。
+- blank Hero 改选 Workspace 时，外壳调用 `connectWorkspace`；目标 session 不同时把非空 draft 从当前 shell 搬到目标 shell，再 open 新 id，旧 blank session 留存但不再 current。
+- Notifier 双位契约：`dirty`（快照新鲜度，`ensureFresh` 拉取可清）与 `notifyPending`（通知欠账，只有 flush 清）各自独立——拉取不得吞推送，对象层推订阅者（watchTransaction）依赖这一保证。
+
+### 纯文本引用（决策 21）：text outcome 与 lexicon 装饰
+
+skill/@subagent 引用不走占位符 + occurrence 身份链——pick 直接把 `/name ` `@name ` 原文插进 draft，chip 视觉纯派生：
+
+- PickOutcome 增 `{text}` arm；新 scoped bail 事件 `slash/input-insert-text` `{text, span}`（与另三个同契约：draftRev CAS、返回 true ⟺ 实际改写）；facade.insertText 走 setDraft 拼接，机器零改动。
+- source 可选 `lexicon?(session)` 钩子：同步热快照名录，`undefined` = 数据未热——零装饰、永不触发 fetch（渲染路径保持同步无副作用）；controller 聚合为 `lexicon()` 公面。
+- `decorations.scanTextRefs`：词边界扫描 draft（行首/空白后的 `/name`、`@name`，`x/name` 永不命中）对照名录，命中即 `.textRef` mark（backdrop 纯 range 高亮，同 hlToken）；编辑破坏匹配形状下次扫描自然消失。
+- 发送即原文（不再 `<skill>` 序列化）；气泡侧 MessageItem 双形状装饰（legacy `<skill>` 标签 + 纯文本 token）。
+- 旧 occurrence/paste/serialize 链全部保留在盘未删（additive；删除另成将来一刀）。已知局限维持现状：粘贴/冷启动时 lexicon 未热不装饰，输 `/` 开一次菜单后才亮。
+
+### per-session 供数贡献与键盘私面
+
+- ui-conversation（hub 兼贡献者）经 `sessions.provide` 供 `'input'` hook（机器状态 + queue overlay）+ `inputActions` prop（`setDraft`/`submit`，稳定 void 回调）。
+- 公私分界：公共 provide 只放 React 语汇成员；键盘/DOM 命令面（track/arbitrate/space/undo/redo/paste/dismissPopup/bindMirror——同步返回值、disposer 语义）是 InputBar 独占，走 InputBar entry 自己的 inject 包内私递，不出插件边界。
+
+### 坑位体系
+
+`conversation` 本身是 session-maybe；其会话内容与 composer 输入坑位严格 session，Hero Workspace picker 保持 root。子坑均由 ui-conversation 的 conversation 注册声明：
+
+- `conversation.session`（single）——严格 session 的 header、view ring 与 chat store；session id 切换时重建。
+- `conversation.composer.bar`（single）——InputBar 本体的坑位：InputBar 是真 slot entry（自家坑自注册），composer chain fallback 的内容；不做 chain entry——chain 单选举会在 takeover 时卸载它，破坏 textarea DOM 存活。
+- `conversation.input.overlay`——输入卡内浮层锚点；注册者 inject 按 slot sessionId 解析各自 per-session controller。
+- `conversation.input.dock`——输入上方堆叠条（QueueDock 的队列只读列表落此），order 定序。
+- `conversation.composer.dock`——composer 上沿统计带。
+- `conversation.input.left` / `conversation.input.right`——工具行左右区。
+- `conversation.input.plan` / `conversation.input.model`（single）——工具行两具名控制位；bar 只传 `locked`（owner props），空到 owning 插件注册为止，无占位 fallback。
+- `conversation.hero.workspace`（root scope）——无 session / blank Hero 共用的 Workspace picker；pick 经 `connectWorkspace` 复用或创建目标 blank session，必要时搬运 draft 后切 current。
+
+### 测试纪律
+
+状态机全部行为由纯 JS 单测覆盖（事件序列进、断言状态与效果，零浏览器 DOM）；交互矩阵逐行投影测试。这一要求正是纯核 + 服务壳分层的成因。
+
+## Alternatives considered
+
+| 弃案 | 一行理由 |
+|---|---|
+| ActiveCommand 中间态 / registerMode 模式注册表 / 从 draft 推导命令态 | claim 由 pick 路径显式建立——无表、无推导 |
+| bindTarget/bindDraft 对象直连 | 反向耦合 + root 单例跨会话误配；scoped bail 事件保依赖倒置且路由结构性正确 |
+| 统一 slash/input-apply 或全事件化 | 三个独立 payload 覆盖跨插件改写；异步链路保持 registry 显式调用 |
+| contenteditable / 富文本树 | 兼容性差；textarea + U+FFFC + occurrence 表覆盖全部交互契约 |
+| draft 双持久化 {text, occurrences} | mirror 写剪贴板投影零新概念；chip 跨刷新降级可接受 |
+| 原生 textarea undo 栈 | 受控 + 程序化写入下不可靠；粘贴两段 undo 语义只能自管 |
+| InputBar 收 16 员 wiring 回调包 | 消费矩阵实证 11 员 InputBar 独占、1 员死成员；标准件通道让组件自取，键盘面包内私递 |
+| 空格裁决也认领即执行型命令 | 误触发防线：空格后整行是普通 prompt；不可逆副作用只留显式入口 |
+| 通用 tokenPattern 装饰机制 | 结构化 occurrence 记录取代模式扫描 |
+| 占位 select 常驻工具行 | 具名坑位空到注册为止；占位件与真实现冲突时是双真相源 |
+| 引用一律走 U+FFFC chip（决策 21 前旧线） | 纯文本 + 派生装饰零身份状态；原文即模型投影，undo/剪贴板免特判；chip 链保留给需要不可分原子性的场景 |
+
+## 后果
+
+- 一个常驻 conversation 外壳承接 no-session/blank/active：无 session → blank 只保证大框架 React identity，允许 disabled textarea 替换为严格 InputBar；同一 blank session → engaging/active 保持 InputBar 与 textarea。EmptyState 与受控 intent 链（`sessions.updateIntent`/`updatePendingPrompt`/`workspaces.sendSession`）随最后消费者一并删除。
+- 输入面对命令零知识 + 可选依赖：无命令包时纯输入可用；`@` 引用与 skill 引用免费复用同一菜单/pick 管线。代价是空格/回车裁决是逐 source 轮询协议，其应答语义（同步/异步、undefined 含义）为冻结契约。
+- 提交事务化（attempt seq + 漂移守卫）使晚到结果回灌、会话切换、concurrent 重放三类缺陷结构性不可能，由矩阵测试钉住。
+- 已知欠账：chip 跨刷新保真（可复用粘贴匹配）未立项；subagent 引用的模型表示待业务立项。

.gitignore

@@ -7,8 +7,8 @@ pnpm-debug.log
 .pnpm-store/
 .cache/
 examples/*/*.jsonl
-.sessions/
 .storages/
+.sessions/
 examples/*/.sessions/
 coverage/
 .doc-typecheck-*/

apps/cli/cordis.yml

@@ -145,6 +145,30 @@
 - id: tool-skill
   name: '@deepseek-ai/dsh-tool-skill'
 
+# Host command registry: the single source of truth behind command.list /
+# command.execute; the web '/' menu is a pure projection of this registry.
+- id: commands
+  name: '@deepseek-ai/dsh-commands'
+
+# Plan mode registers /plan (the first real command on the web surface).
+# Section text mirrors examples/tui-agent/cordis.yml (the reference
+# deployment); plan-mode throws at load on an empty section.
+- id: plan-mode
+  name: '@deepseek-ai/dsh-plan-mode'
+  config:
+    section: |
+          You are in plan mode. Stay in plan mode until exit_plan_mode succeeds or the user switches the session mode. Imperative language to implement changes means plan the implementation, not execute it. A user's conversational agreement — including an answer confirming something you asked — approves nothing and does not end plan mode; fold the confirmed decision into the plan and submit it through exit_plan_mode.
+
+          Explore first. Use non-mutating reads, searches, static analysis, and checks to ground the plan in the actual repository. Do not edit or write files, change configuration, run formatters or code generation that rewrites tracked files, commit, or otherwise carry out the plan. Prefer existing functions and patterns over new machinery.
+
+          The tool catalog stays the same across modes for request-cache stability. These plan-mode rules override any later tool description or guidance that suggests using mutation tools; those tools remain listed only to keep the request shape stable. Do not use todo_write to track this planning phase: it tracks implementation after an approved plan, while the plan itself belongs in exit_plan_mode.
+
+          Resolve discoverable facts by inspection. Use ask_user_question only for user-owned choices or material ambiguity that inspection cannot answer. Do not ask the user where code lives or how current behavior works when you can find out.
+
+          Make the plan decision-complete: state the goal and success criteria; group implementation changes by subsystem; identify public API, schema, and data-flow changes; cover edge cases, failure modes, tests, acceptance criteria, and explicit assumptions. Keep it concise enough to review but detailed enough that another engineer can implement it without making design decisions.
+
+          When ready, call exit_plan_mode with the complete plan markdown, starting with a # title. Make exit_plan_mode the only and final tool call in that assistant response: it presents the plan for approval, and implementation begins only in a later step after approval. Do not paste the final plan as a plain reply or ask "should I proceed?" through prose or ask_user_question. If review rejects it, incorporate the feedback and present again. If the review channel is unavailable or aborted, stay in plan mode and ask the user to switch modes manually; do not proceed with implementation.
+
 # token-meter rejects unknown config keys — keep this row bare.
 - id: token-meter
   name: '@deepseek-ai/dsh-token-meter'
@@ -262,6 +286,20 @@
 - id: ui-workspace
   name: '@deepseek-ai/dsh-client-ui-workspace'
 
+# Input triggers: the '/' | '@' pipeline (ui-slash), the command surface over
+# it (ui-command), and the two reference sources (ui-skill / ui-subagent).
+- id: ui-slash
+  name: '@deepseek-ai/dsh-client-ui-slash'
+
+- id: ui-command
+  name: '@deepseek-ai/dsh-client-ui-command'
+
+- id: ui-skill
+  name: '@deepseek-ai/dsh-client-ui-skill'
+
+- id: ui-subagent
+  name: '@deepseek-ai/dsh-client-ui-subagent'
+
 - id: ui-question
   name: '@deepseek-ai/dsh-client-ui-question'
 

apps/cli/package.json

@@ -26,6 +26,7 @@
     "@deepseek-ai/dsh-client-locale": "workspace:^",
     "@deepseek-ai/dsh-client-modules": "workspace:^",
     "@deepseek-ai/dsh-client-runtime": "workspace:^",
+    "@deepseek-ai/dsh-client-ui-command": "workspace:^",
     "@deepseek-ai/dsh-client-ui-conversation": "workspace:^",
     "@deepseek-ai/dsh-client-ui-layout": "workspace:^",
     "@deepseek-ai/dsh-client-ui-models": "workspace:^",
@@ -33,10 +34,14 @@
     "@deepseek-ai/dsh-client-ui-settings": "workspace:^",
     "@deepseek-ai/dsh-client-ui-settings-general": "workspace:^",
     "@deepseek-ai/dsh-client-ui-sidebar": "workspace:^",
+    "@deepseek-ai/dsh-client-ui-skill": "workspace:^",
+    "@deepseek-ai/dsh-client-ui-slash": "workspace:^",
+    "@deepseek-ai/dsh-client-ui-subagent": "workspace:^",
     "@deepseek-ai/dsh-client-ui-theme": "workspace:^",
     "@deepseek-ai/dsh-client-ui-trajectory": "workspace:^",
     "@deepseek-ai/dsh-client-ui-workspace": "workspace:^",
     "@deepseek-ai/dsh-code-runtime-worker": "workspace:^",
+    "@deepseek-ai/dsh-commands": "workspace:^",
     "@deepseek-ai/dsh-compact-basic": "workspace:^",
     "@deepseek-ai/dsh-frontend": "workspace:^",
     "@deepseek-ai/dsh-fs-local": "workspace:^",
@@ -47,6 +52,7 @@
     "@deepseek-ai/dsh-llm-deepseek": "workspace:^",
     "@deepseek-ai/dsh-llm-retry": "workspace:^",
     "@deepseek-ai/dsh-paths": "workspace:^",
+    "@deepseek-ai/dsh-plan-mode": "workspace:^",
     "@deepseek-ai/dsh-session": "workspace:^",
     "@deepseek-ai/dsh-session-persistence-jsonl": "workspace:^",
     "@deepseek-ai/dsh-session-title": "workspace:^",

apps/web/tests/code-mode-round.e2e.ts

@@ -18,7 +18,7 @@ import {
   captureStableAria, compareOrRefreshGolden, fixtureUserPrompts,
   launchWebScaffold, recordFixture, watchConsole, webSnapshotMode, type WebScaffold,
 } from './scaffold.ts'
-import { saveFailureShot } from './support.ts'
+import { connectFreshWorkspace, saveFailureShot } from './support.ts'
 
 const FIXTURE = fileURLToPath(new URL('./snapshots/code-mode-round/session.jsonl', import.meta.url))
 const UI_EXPECTED = fileURLToPath(new URL('./snapshots/code-mode-round/ui.expected.md', import.meta.url))
@@ -48,6 +48,8 @@ describe('web e2e: Code Mode round renders nested sub-calls', () => {
     tripwire = watchConsole(page)
     await page.goto(scaffold.baseUrl, { waitUntil: 'load' })
     await page.waitForSelector('[class*="frame"]', { timeout: 30_000 })
+    // Fresh world: connect a Workspace so the composer scenarios start live.
+    await connectFreshWorkspace(page)
   }, 120_000)
 
   afterAll(async () => {

apps/web/tests/lifecycle-chrome.e2e.ts

@@ -20,7 +20,7 @@ import {
   acknowledgeReloadConnectionLoss, assertFixtureInventory, captureStableAria, compareOrRefreshGolden, fixtureUserPrompts,
   launchWebScaffold, recordFixture, watchConsole, webSnapshotMode, type WebScaffold,
 } from './scaffold.ts'
-import { saveFailureShot } from './support.ts'
+import { connectFreshWorkspace, saveFailureShot } from './support.ts'
 
 const SNAPSHOT_DIR = fileURLToPath(new URL('./snapshots/lifecycle-chrome', import.meta.url))
 const FIXTURE = join(SNAPSHOT_DIR, 'session.jsonl')
@@ -47,6 +47,8 @@ describe('web e2e: lifecycle & chrome (workspace flow / reload / dark mode)', ()
     tripwire = watchConsole(page)
     await page.goto(scaffold.baseUrl, { waitUntil: 'load' })
     await page.waitForSelector('[class*="frame"]', { timeout: 30_000 })
+    // Fresh world: connect a Workspace so the composer scenarios start live.
+    await connectFreshWorkspace(page)
   }, 120_000)
 
   afterAll(async () => {

apps/web/tests/live-interactions.e2e.ts

@@ -23,7 +23,7 @@ import {
   assertFixtureInventory, captureStableAria, compareOrRefreshGolden, fixtureUserPrompts,
   launchWebScaffold, recordFixture, watchConsole, webSnapshotMode, type WebScaffold,
 } from './scaffold.ts'
-import { saveFailureShot } from './support.ts'
+import { connectFreshWorkspace, saveFailureShot } from './support.ts'
 
 const SNAPSHOT_DIR = fileURLToPath(new URL('./snapshots/live-interactions', import.meta.url))
 const FIXTURE = join(SNAPSHOT_DIR, 'session.jsonl')
@@ -94,6 +94,8 @@ describe('web e2e: live-turn interactions (cancel / error / retry)', () => {
     tripwire = watchConsole(page)
     await page.goto(scaffold.baseUrl, { waitUntil: 'load' })
     await page.waitForSelector('[class*="frame"]', { timeout: 30_000 })
+    // Fresh world: connect a Workspace so the composer scenarios start live.
+    await connectFreshWorkspace(page)
   }
 
   /**
@@ -134,9 +136,11 @@ describe('web e2e: live-turn interactions (cancel / error / retry)', () => {
     await page.getByRole('button', { name: 'Stop generating' }).click()
     await settled
     expect(turnEndReasons(sessionEvents).at(-1)).toBe('aborted')
-    // Composer recovered; no streaming node lingers.
+    // Composer recovered; no streaming node lingers. The host settled first
+    // (awaited above), but the abort frame reaches the browser over SSE — the
+    // frozen-partial swap is eventually consistent, so poll rather than count.
     await expect.poll(() => page.locator('textarea').first().isEnabled(), { timeout: 10_000 }).toBe(true)
-    expect(await page.locator('[data-streaming="true"]').count()).toBe(0)
+    await expect.poll(() => page.locator('[data-streaming="true"]').count(), { timeout: 10_000 }).toBe(0)
     // Golden of the aborted end-state: the prompt bubble plus the frozen
     // partial ('partial' is the hang entry's replayed prefix) and no more.
     const snapshot = await captureStableAria(page, '[class*="centerCol"]', scaffold!.workspaceCwd)

apps/web/tests/question-composer.e2e.ts

@@ -18,7 +18,7 @@ import {
   assertFixtureInventory, captureStableAria, compareOrRefreshGolden, fixtureUserPrompts,
   launchWebScaffold, recordFixture, watchConsole, webSnapshotMode, type WebScaffold,
 } from './scaffold.ts'
-import { saveFailureShot } from './support.ts'
+import { connectFreshWorkspace, saveFailureShot } from './support.ts'
 
 const SNAPSHOT_DIR = fileURLToPath(new URL('./snapshots/question-composer', import.meta.url))
 const FIXTURE = join(SNAPSHOT_DIR, 'session.jsonl')
@@ -45,6 +45,8 @@ describe('web e2e: resident question composer round trip', () => {
     tripwire = watchConsole(page)
     await page.goto(scaffold.baseUrl, { waitUntil: 'load' })
     await page.waitForSelector('[class*="frame"]', { timeout: 30_000 })
+    // Fresh world: connect a Workspace so the composer scenarios start live.
+    await connectFreshWorkspace(page)
   }, 120_000)
 
   afterAll(async () => {

apps/web/tests/replay-round-trip.e2e.ts

@@ -18,7 +18,7 @@ import {
   assertFixtureInventory, captureStableAria, compareOrRefreshGolden, fixtureUserPrompts,
   launchWebScaffold, recordFixture, watchConsole, webSnapshotMode, type WebScaffold,
 } from './scaffold.ts'
-import { saveFailureShot } from './support.ts'
+import { connectFreshWorkspace, saveFailureShot } from './support.ts'
 
 const SNAPSHOT_DIR = fileURLToPath(new URL('./snapshots/fresh-round-trip', import.meta.url))
 const FIXTURE = fileURLToPath(new URL('./snapshots/fresh-round-trip/session.jsonl', import.meta.url))
@@ -47,6 +47,8 @@ describe('web e2e: fresh round trip through the real assembly', () => {
     tripwire = watchConsole(page)
     await page.goto(scaffold.baseUrl, { waitUntil: 'load' })
     await page.waitForSelector('[class*="frame"]', { timeout: 30_000 })
+    // Fresh world: connect a Workspace so the composer scenarios start live.
+    await connectFreshWorkspace(page)
   }, 120_000)
 
   afterAll(async () => {

apps/web/tests/slash-flow.snapshot.ts

@@ -0,0 +1,191 @@
+// @vitest-environment jsdom
+// Assembled keyless snapshot of the slash/input/session convergence under the
+// agent-parity model: the New Session view state locks the composer until a
+// Workspace is picked (connectWorkspace materializes the full Session+Agent),
+// the '/' menu serves the session's wire command catalog (sessions are always
+// agent-backed — no draft/materialized split), a leadingInput command claims,
+// submits over the wire, and notices its result, and the SAME composer
+// textarea then carries the first plain send, whose ACCEPTANCE (not attempt)
+// flips blank and surfaces the session in lists. This is the user-visible
+// acceptance anchor — package mocks do not substitute for the assembled
+// application transcript.
+import { readFileSync } from 'node:fs'
+import { join } from 'node:path'
+import { act, cleanup, fireEvent, screen, waitFor, within } from '@testing-library/react'
+import { afterEach, beforeEach, expect, it, vi } from 'vitest'
+import type { WebBootEntry } from '@deepseek-ai/dsh-client-modules/client'
+import { AppWebEntry } from '@deepseek-ai/dsh-client-web'
+
+const PLUGINS: readonly (WebBootEntry & { dir: string })[] = [
+  { id: '@deepseek-ai/dsh-client-connection', dir: 'connection', url: '/plugins/connection.js', rev: 'fx', inject: [], immediately: true },
+  { id: '@deepseek-ai/dsh-client-runtime', dir: 'runtime', url: '/plugins/runtime.js', rev: 'fx', inject: ['@deepseek-ai/dsh-client-connection'], immediately: true },
+  { id: '@deepseek-ai/dsh-client-ui-theme', dir: 'ui-theme', url: '/plugins/ui-theme.js', rev: 'fx', inject: [], immediately: true },
+  { id: '@deepseek-ai/dsh-client-locale', dir: 'locale', url: '/plugins/locale.js', rev: 'fx', inject: [], immediately: true },
+  { id: '@deepseek-ai/dsh-client-ui-layout', dir: 'ui-layout', url: '/plugins/ui-layout.js', rev: 'fx', inject: ['@deepseek-ai/dsh-client-runtime'] },
+  { id: '@deepseek-ai/dsh-client-ui-sidebar', dir: 'ui-sidebar', url: '/plugins/ui-sidebar.js', rev: 'fx', inject: ['@deepseek-ai/dsh-client-ui-layout'] },
+  { id: '@deepseek-ai/dsh-client-ui-slash', dir: 'ui-slash', url: '/plugins/ui-slash.js', rev: 'fx', inject: ['@deepseek-ai/dsh-client-runtime'] },
+  { id: '@deepseek-ai/dsh-client-ui-conversation', dir: 'ui-conversation', url: '/plugins/ui-conversation.js', rev: 'fx', inject: ['@deepseek-ai/dsh-client-ui-layout', '@deepseek-ai/dsh-client-ui-slash'] },
+  { id: '@deepseek-ai/dsh-client-ui-command', dir: 'ui-command', url: '/plugins/ui-command.js', rev: 'fx', inject: ['@deepseek-ai/dsh-client-ui-slash', '@deepseek-ai/dsh-client-ui-conversation'] },
+  { id: '@deepseek-ai/dsh-client-ui-skill', dir: 'ui-skill', url: '/plugins/ui-skill.js', rev: 'fx', inject: ['@deepseek-ai/dsh-client-ui-slash'] },
+  { id: '@deepseek-ai/dsh-client-ui-subagent', dir: 'ui-subagent', url: '/plugins/ui-subagent.js', rev: 'fx', inject: ['@deepseek-ai/dsh-client-ui-slash'] },
+  {
+    id: '@deepseek-ai/dsh-client-ui-workspace',
+    dir: 'ui-workspace',
+    url: '/plugins/ui-workspace.js',
+    rev: 'fx',
+    inject: [
+      '@deepseek-ai/dsh-client-runtime',
+      '@deepseek-ai/dsh-client-ui-conversation',
+      '@deepseek-ai/dsh-client-ui-sidebar',
+    ],
+  },
+]
+
+const bundles = new Map(PLUGINS.map(plugin => [
+  plugin.url,
+  readFileSync(join(process.cwd(), 'packages/client', plugin.dir, 'lib/client.js'), 'utf8'),
+]))
+
+interface FixtureWindow extends Window {
+  __DSH_BOOT__?: { rev: string; entries: WebBootEntry[] }
+  __ModuleLoader__?: unknown
+}
+
+class ResizeObserverStub {
+  observe(): void {}
+  disconnect(): void {}
+  unobserve(): void {}
+}
+
+const win = window as FixtureWindow
+let unmount: (() => void) | undefined
+
+beforeEach(() => {
+  localStorage.clear()
+  document.title = 'DeepSeek Harness'
+  vi.stubGlobal('ResizeObserver', ResizeObserverStub)
+  vi.stubGlobal('requestAnimationFrame', (callback: FrameRequestCallback) =>
+    setTimeout(() => { callback(0) }, 0) as unknown as number)
+  vi.stubGlobal('cancelAnimationFrame', (id: number) => { clearTimeout(id) })
+})
+
+afterEach(() => {
+  act(() => { unmount?.() })
+  unmount = undefined
+  cleanup()
+  delete win.__DSH_BOOT__
+  delete win.__ModuleLoader__
+  delete (globalThis as Record<string, unknown>).__fxTiming
+  document.body.innerHTML = ''
+  document.head.querySelectorAll('style[data-plugin]').forEach((style) => { style.remove() })
+  document.title = ''
+  history.replaceState(null, '', '/')
+  vi.unstubAllGlobals()
+})
+
+/** Boot the complete built client graph against one keyless fixture branch. */
+function boot(search: string): void {
+  history.replaceState(null, '', `/${search}`)
+  const root = document.createElement('div')
+  root.id = 'root'
+  document.body.appendChild(root)
+  win.__DSH_BOOT__ = { rev: 'fx', entries: PLUGINS.map(({ dir: _dir, ...plugin }) => plugin) }
+  act(() => {
+    const entry = new AppWebEntry(root, {
+      fetchBundle: (url) => {
+        const code = bundles.get(url)
+        return code === undefined ? Promise.reject(new Error(`missing built bundle ${url}`)) : Promise.resolve(code)
+      },
+      executeBundle: (code) => { (0, eval)(code) },
+    })
+    void entry.run()
+    unmount = () => { entry.dispose() }
+  })
+}
+
+/** Collapse decorative whitespace while preserving the text a user sees. */
+function visibleText(element: Element): string {
+  return (element.textContent ?? '').replace(/\s+/g, ' ').trim()
+}
+
+/** Type into the machine-driven composer and let the change echo back. */
+async function typeComposer(composer: HTMLTextAreaElement, value: string): Promise<void> {
+  fireEvent.change(composer, { target: { value } })
+  await waitFor(() => { expect(composer.value).toBe(value) })
+}
+
+it('locked view state, connectWorkspace unlock, /echo claim chain, and blank-on-acceptance ride one resident composer', async () => {
+  boot('?fixture=empty')
+
+  // View state: no session entity — the composer renders locked; only the
+  // workspace picker is live.
+  const locked = await screen.findByPlaceholderText<HTMLTextAreaElement>(
+    'Choose a workspace to start', {}, { timeout: 10_000 },
+  )
+  expect(locked.disabled).toBe(true)
+
+  // Pick (create) a Workspace: connectWorkspace materializes the full
+  // Session+Agent and the provider swaps in the live blank-session hero.
+  fireEvent.click(screen.getAllByRole('button', { name: 'Choose workspace' })
+    .find(el => el.getAttribute('aria-haspopup') === 'menu')!)
+  fireEvent.click(await screen.findByRole('menuitem', { name: 'Create workspace' }))
+  fireEvent.click(await screen.findByRole('menuitem', { name: 'Create a new workspace' }))
+  const dialog = await screen.findByRole('dialog', { name: 'Create a new workspace' })
+  fireEvent.change(within(dialog).getByRole('textbox', { name: 'New workspace name' }), {
+    target: { value: 'nova' },
+  })
+  fireEvent.click(within(dialog).getByRole('button', { name: 'Create workspace' }))
+
+  const composer = await screen.findByPlaceholderText<HTMLTextAreaElement>(
+    'Describe what you want to build', {}, { timeout: 10_000 },
+  )
+  expect(composer.disabled).toBe(false)
+
+  // '/' opens the menu with the session's wire command catalog (the session
+  // is agent-backed from birth — the catalog is the single-address list).
+  await typeComposer(composer, '/')
+  const menu = await screen.findByRole('listbox', { name: 'Trigger suggestions' })
+  await waitFor(() => { expect(visibleText(menu)).toContain('echo') })
+  const menuText = visibleText(menu)
+
+  // Pick /echo (leadingInput): the claim token lands in the same textarea.
+  fireEvent.mouseDown(screen.getByRole('option', { name: /echo/ }))
+  await waitFor(() => { expect(composer.value).toBe('/echo ') })
+
+  // Type args and submit: the claim executes over the wire and notices its
+  // result; the token is consumed and the draft returns to plain text.
+  await typeComposer(composer, '/echo hello parser')
+  fireEvent.keyDown(composer, { key: 'Enter' })
+  await screen.findByText('hello parser', {}, { timeout: 10_000 })
+  await waitFor(() => { expect(composer.value).toBe('') })
+
+  // Slash execution does not flip blank: the selected row remains New Session.
+  const tree = screen.getByRole('tree', { name: 'Sessions' })
+  expect(within(tree).getByText('1 session')).toBeDefined()
+  expect(within(tree).getByText('New Session')).toBeDefined()
+
+  // First plain send through the SAME textarea: acceptance logs the user
+  // message and converts the existing sidebar row out of blank.
+  const before = composer
+  await typeComposer(composer, 'build me a parser')
+  fireEvent.keyDown(composer, { key: 'Enter' })
+  await waitFor(() => {
+    expect(screen.queryByText("Let's start building")).toBeNull()
+  }, { timeout: 10_000 })
+  await waitFor(() => { expect(within(tree).getByText('1 session')).toBeDefined() }, { timeout: 10_000 })
+  const after = document.querySelector('textarea')
+
+  expect({
+    menuHadEcho: menuText.includes('echo'),
+    menuHadCompact: menuText.includes('compact'),
+    composerSurvivedConversion: after === before,
+    sessionListed: visibleText(within(tree).getByText('1 session').closest('[role="treeitem"]')!),
+  }).toMatchInlineSnapshot(`
+    {
+      "composerSurvivedConversion": true,
+      "menuHadCompact": true,
+      "menuHadEcho": true,
+      "sessionListed": "nova1 session",
+    }
+  `)
+})

apps/web/tests/smoke-real.e2e.ts

@@ -24,7 +24,7 @@ import { pathToFileURL } from 'node:url'
 import type { Browser, Page } from 'playwright'
 import { chromium } from 'playwright'
 import { afterAll, beforeAll, describe, expect, it, onTestFailed } from 'vitest'
-import { REPO_ROOT, probeFreePort, requireDist, saveFailureShot } from './support.ts'
+import { REPO_ROOT, connectFreshWorkspace, probeFreePort, requireDist, saveFailureShot } from './support.ts'
 
 /** Repo-root .env → process.env (never overrides an already-set variable). */
 function loadRootEnv(): void {
@@ -404,6 +404,8 @@ describe.skipIf(!process.env.DEEPSEEK_API_KEY || notReady.length > 0)('web smoke
 
   it('2+3 empty-state first send completes a real model round', async () => {
     onTestFailed(() => saveFailureShot(page, 'w5-first-round'))
+    // Fresh world: connect a Workspace so the composer starts live.
+    await connectFreshWorkspace(page)
     const input = page.locator('textarea').first()
     await input.waitFor({ timeout: 10_000 })
     await screen(page, '02-empty-state')

apps/web/tests/snapshots/code-mode-round/ui.expected.md

@@ -23,13 +23,7 @@
 - textbox "Message the agent"
 - button "Add attachment":
   - img
-- combobox "Plan mode":
-  - option "Plan" [selected]
-  - option "Agent"
 - combobox "Access mode":
   - option "Read-only" [selected]
   - option "Read-write"
-- combobox "Model":
-  - option "DeepSeek-V4-Pro High" [selected]
-  - option "DeepSeek-V4-Pro"
 - button "Send message" [disabled]

apps/web/tests/snapshots/fresh-round-trip/ui.expected.md

@@ -19,13 +19,7 @@
 - textbox "Message the agent"
 - button "Add attachment":
   - img
-- combobox "Plan mode":
-  - option "Plan" [selected]
-  - option "Agent"
 - combobox "Access mode":
   - option "Read-only" [selected]
   - option "Read-write"
-- combobox "Model":
-  - option "DeepSeek-V4-Pro High" [selected]
-  - option "DeepSeek-V4-Pro"
 - button "Send message" [disabled]

apps/web/tests/snapshots/lifecycle-chrome/hero.expected.md

@@ -11,7 +11,11 @@
 - button "Search sessions":
   - img
 - textbox "Search name, keywords..."
-- tree "Sessions": No sessions yet
+- tree "Sessions":
+  - treeitem "workspace 1 session" [expanded]:
+    - img
+    - text: workspace 1 session
+  - treeitem "New Session now" [selected]
 - button "设置":
   - img
   - text: 设置
@@ -23,13 +27,10 @@
 - textbox "Describe what you want to build"
 - button "Add attachment":
   - img
-- combobox "Plan mode":
-  - option "Plan" [selected]
-  - option "Agent"
 - combobox "Access mode":
   - option "Read-only" [selected]
   - option "Read-write"
-- combobox "Model":
-  - option "DeepSeek-V4-Pro High" [selected]
-  - option "DeepSeek-V4-Pro"
 - button "Send message" [disabled]
+- text: 详情
+- button "关闭详情"
+- text: 点击消息流中的工具行查看详情

apps/web/tests/snapshots/lifecycle-chrome/reloaded.expected.md

@@ -15,13 +15,7 @@
 - textbox "Message the agent"
 - button "Add attachment":
   - img
-- combobox "Plan mode":
-  - option "Plan" [selected]
-  - option "Agent"
 - combobox "Access mode":
   - option "Read-only" [selected]
   - option "Read-write"
-- combobox "Model":
-  - option "DeepSeek-V4-Pro High" [selected]
-  - option "DeepSeek-V4-Pro"
 - button "Send message" [disabled]

apps/web/tests/snapshots/live-interactions/cancel.expected.md

@@ -12,13 +12,7 @@
 - textbox "Message the agent"
 - button "Add attachment":
   - img
-- combobox "Plan mode":
-  - option "Plan" [selected]
-  - option "Agent"
 - combobox "Access mode":
   - option "Read-only" [selected]
   - option "Read-write"
-- combobox "Model":
-  - option "DeepSeek-V4-Pro High" [selected]
-  - option "DeepSeek-V4-Pro"
 - button "Send message" [disabled]

apps/web/tests/snapshots/live-interactions/error-auth.expected.md

@@ -10,13 +10,7 @@
 - textbox "Message the agent"
 - button "Add attachment":
   - img
-- combobox "Plan mode":
-  - option "Plan" [selected]
-  - option "Agent"
 - combobox "Access mode":
   - option "Read-only" [selected]
   - option "Read-write"
-- combobox "Model":
-  - option "DeepSeek-V4-Pro High" [selected]
-  - option "DeepSeek-V4-Pro"
 - button "Send message" [disabled]

apps/web/tests/snapshots/live-interactions/retry.expected.md

@@ -15,13 +15,7 @@
 - textbox "Message the agent"
 - button "Add attachment":
   - img
-- combobox "Plan mode":
-  - option "Plan" [selected]
-  - option "Agent"
 - combobox "Access mode":
   - option "Read-only" [selected]
   - option "Read-write"
-- combobox "Model":
-  - option "DeepSeek-V4-Pro High" [selected]
-  - option "DeepSeek-V4-Pro"
 - button "Send message" [disabled]

apps/web/tests/snapshots/navigation-panes/details-open.expected.md

@@ -1,3 +1,5 @@
 - text: bash
 - button "关闭详情"
-- text: "Input { \"command\": \"echo NAVIGATION_OK\", \"description\": \"Print NAVIGATION_OK\" } Output NAVIGATION_OK"
+- text: Input
+- code: "{ \"command\": \"echo NAVIGATION_OK\", \"description\": \"Print NAVIGATION_OK\" }"
+- text: Output NAVIGATION_OK

apps/web/tests/snapshots/question-composer/answered.expected.md

@@ -21,13 +21,7 @@
 - textbox "Message the agent"
 - button "Add attachment":
   - img
-- combobox "Plan mode":
-  - option "Plan" [selected]
-  - option "Agent"
 - combobox "Access mode":
   - option "Read-only" [selected]
   - option "Read-write"
-- combobox "Model":
-  - option "DeepSeek-V4-Pro High" [selected]
-  - option "DeepSeek-V4-Pro"
 - button "Send message" [disabled]

apps/web/tests/snapshots/seeded-history/ui.expected.md

@@ -24,13 +24,7 @@
 - textbox "Message the agent"
 - button "Add attachment":
   - img
-- combobox "Plan mode":
-  - option "Plan" [selected]
-  - option "Agent"
 - combobox "Access mode":
   - option "Read-only" [selected]
   - option "Read-write"
-- combobox "Model":
-  - option "DeepSeek-V4-Pro High" [selected]
-  - option "DeepSeek-V4-Pro"
 - button "Send message" [disabled]

apps/web/tests/snapshots/steering/settled.expected.md

@@ -21,13 +21,7 @@
 - textbox "Message the agent"
 - button "Add attachment":
   - img
-- combobox "Plan mode":
-  - option "Plan" [selected]
-  - option "Agent"
 - combobox "Access mode":
   - option "Read-only" [selected]
   - option "Read-write"
-- combobox "Model":
-  - option "DeepSeek-V4-Pro High" [selected]
-  - option "DeepSeek-V4-Pro"
 - button "Send message" [disabled]

apps/web/tests/steering.e2e.ts

@@ -23,7 +23,7 @@ import {
   assertFixtureInventory, captureStableAria, compareOrRefreshGolden, fixtureUserPrompts,
   launchWebScaffold, recordFixture, watchConsole, webSnapshotMode, type WebScaffold,
 } from './scaffold.ts'
-import { saveFailureShot } from './support.ts'
+import { connectFreshWorkspace, saveFailureShot } from './support.ts'
 
 const SNAPSHOT_DIR = fileURLToPath(new URL('./snapshots/steering', import.meta.url))
 const FIXTURE = join(SNAPSHOT_DIR, 'session.jsonl')
@@ -71,6 +71,8 @@ describe('web e2e: mid-turn steering lands durably and visibly', () => {
     tripwire = watchConsole(page)
     await page.goto(scaffold.baseUrl, { waitUntil: 'load' })
     await page.waitForSelector('[class*="frame"]', { timeout: 30_000 })
+    // Fresh world: connect a Workspace so the composer scenarios start live.
+    await connectFreshWorkspace(page)
   }, 120_000)
 
   afterAll(async () => {

apps/web/tests/support.ts

@@ -32,6 +32,31 @@ export function probeFreePort(): Promise<number> {
   })
 }
 
+/**
+ * Drive the hero's workspace picker through its create-by-name dialog until
+ * the live composer unlocks. A fresh world has no Workspace, so the boot
+ * lands in the locked view state (startup auto-selection has nothing to
+ * select); every scenario that types into the composer must connect one
+ * first. The default name 'workspace' keeps the session header cwd at
+ * <workspaceRoot>/workspace — the materialization proof several scenarios
+ * assert.
+ * @param page - the page under test.
+ * @param name - workspace name typed into the create dialog.
+ */
+export async function connectFreshWorkspace(page: Page, name = 'workspace'): Promise<void> {
+  await page.getByRole('button', { name: 'Choose workspace' }).click()
+  await page.getByRole('menuitem', { name: 'Create workspace' }).hover()
+  await page.getByRole('menuitem', { name: 'Create a new workspace' }).click()
+  const dialog = page.getByRole('dialog', { name: 'Create a new workspace' })
+  await dialog.waitFor({ timeout: 10_000 })
+  await dialog.getByLabel('New workspace name').fill(name)
+  await dialog.getByRole('button', { name: 'Create workspace' }).click()
+  // The pick connected the workspace: the blank session's live composer
+  // replaces the locked placeholder and enables.
+  await page.locator('textarea:enabled[placeholder="Describe what you want to build"]')
+    .waitFor({ timeout: 15_000 })
+}
+
 /** Failure evidence goes to the gitignored .artifacts/ (repo convention). */
 export async function saveFailureShot(page: Page, name: string): Promise<void> {
   const dir = fileURLToPath(new URL('../../../.artifacts', import.meta.url))

apps/web/tests/workspace-flow.snapshot.ts

@@ -1,4 +1,12 @@
 // @vitest-environment jsdom
+// Assembled keyless snapshots of the New Session flow under the agent-parity
+// model: startup auto-connects the recent Workspace's blank session when one
+// exists; without any Workspace the composer is locked in the pure view
+// state until one is chosen. Picking one materializes the full Session+Agent
+// (reuse-or-create of the workspace's blank session), the first ACCEPTED
+// prompt flips blank and surfaces the session in lists, and failures leave
+// no client-side transaction state: a failed attach keeps the view state
+// locked, a rejected prompt keeps the session blank with the draft restored.
 import { readFileSync } from 'node:fs'
 import { join } from 'node:path'
 import { act, cleanup, fireEvent, screen, waitFor, within } from '@testing-library/react'
@@ -93,25 +101,12 @@ function boot(search: string): void {
   })
 }
 
-/** Recreate the built client graph while preserving browser-persistent state. */
-function refresh(search: string): void {
-  act(() => { unmount?.() })
-  unmount = undefined
-  cleanup()
-  delete win.__DSH_BOOT__
-  delete win.__ModuleLoader__
-  delete (globalThis as Record<string, unknown>).__fxTiming
-  document.body.innerHTML = ''
-  document.head.querySelectorAll('style[data-plugin]').forEach((style) => { style.remove() })
-  boot(search)
-}
-
 /** Collapse decorative whitespace while preserving the text a user sees. */
 function visibleText(element: Element): string {
   return (element.textContent ?? '').replace(/\s+/g, ' ').trim()
 }
 
-/** Identify the interactive Workspace chip by its menu contract. */
+/** Identify the interactive Workspace chip (view state or blank-session hero) by its menu contract. */
 function workspaceChip(): HTMLElement {
   const chip = screen.getAllByRole('button', { name: 'Choose workspace' })
     .find(element => element.getAttribute('aria-haspopup') === 'menu')
@@ -119,210 +114,242 @@ function workspaceChip(): HTMLElement {
   return chip
 }
 
-/** Edit the runtime-owned controlled input and assert the same-tick echo:
- *  a deferred echo makes React roll the textarea back mid-IME-composition,
- *  committing partial keystrokes (e.g. Pinyin "nihao" leaking as "nnini h…"). */
+/** The locked view-state composer (no session yet). */
+async function findLockedComposer(): Promise<HTMLTextAreaElement> {
+  return await screen.findByPlaceholderText(
+    'Choose a workspace to start', {}, { timeout: 10_000 },
+  )
+}
+
+/** The live blank-session hero composer (session materialized). */
+async function findHeroComposer(): Promise<HTMLTextAreaElement> {
+  return await screen.findByPlaceholderText(
+    'Describe what you want to build', {}, { timeout: 10_000 },
+  )
+}
+
+/** Edit the machine-owned controlled input and assert the same-tick echo. */
 function setComposerText(composer: HTMLElement, value: string): void {
   fireEvent.change(composer, { target: { value } })
   expect((composer as HTMLTextAreaElement).value).toBe(value)
 }
 
-it('starts a writable page-local draft without inventing a sidebar Workspace', async () => {
+/** Drive the picker's create flow: chip → Create workspace → name dialog. */
+async function createWorkspaceViaPicker(name: string): Promise<void> {
+  fireEvent.click(workspaceChip())
+  fireEvent.click(await screen.findByRole('menuitem', { name: 'Create workspace' }))
+  fireEvent.click(await screen.findByRole('menuitem', { name: 'Create a new workspace' }))
+  const dialog = await screen.findByRole('dialog', { name: 'Create a new workspace' })
+  fireEvent.change(within(dialog).getByRole('textbox', { name: 'New workspace name' }), {
+    target: { value: name },
+  })
+  fireEvent.click(within(dialog).getByRole('button', { name: 'Create workspace' }))
+}
+
+/** Pick an existing Workspace row from the chip menu. */
+async function pickWorkspace(title: string): Promise<void> {
+  fireEvent.click(workspaceChip())
+  fireEvent.click(await screen.findByRole('menuitem', { name: title }))
+}
+
+it('locks the composer in the New Session view state until a Workspace is chosen', async () => {
   boot('?fixture=empty')
 
-  const composer = await screen.findByPlaceholderText('Describe what you want to build', {}, { timeout: 10_000 })
+  const composer = await findLockedComposer()
   const tree = screen.getByRole('tree', { name: 'Sessions' })
-  setComposerText(composer, 'keep this local')
 
   expect({
     headline: visibleText(screen.getByText("Let's start building")),
-    workspaceDraft: visibleText(workspaceChip()),
+    chip: visibleText(workspaceChip()),
+    composerDisabled: composer.disabled,
+    sendDisabled: screen.getByRole<HTMLButtonElement>('button', { name: 'Send message' }).disabled,
     sidebar: visibleText(tree),
-    composerDisabled: (composer as HTMLTextAreaElement).disabled,
-    prompt: (composer as HTMLTextAreaElement).value,
   }).toMatchInlineSnapshot(`
     {
-      "composerDisabled": false,
+      "chip": "New Workspace",
+      "composerDisabled": true,
       "headline": "Let's start building",
-      "prompt": "keep this local",
+      "sendDisabled": true,
       "sidebar": "No sessions yet",
-      "workspaceDraft": "workspace",
     }
   `)
 })
 
-it('creates a real empty Workspace immediately and focuses its Session draft', async () => {
-  boot('?fixture=empty')
+it('selects the recent Workspace and opens its blank Session on first load', async () => {
+  boot('?fixture')
 
-  await screen.findByPlaceholderText('Describe what you want to build', {}, { timeout: 10_000 })
-  const workspaceSection = screen.getByText('Workspaces').parentElement
-  if (workspaceSection === null) throw new Error('Workspace section missing')
-  fireEvent.click(within(workspaceSection).getByRole('button', { name: 'Create workspace' }))
-  fireEvent.click(await screen.findByRole('menuitem', { name: 'Create workspace' }))
-  fireEvent.click(await screen.findByRole('menuitem', { name: 'Create a new workspace' }))
-
-  const dialog = await screen.findByRole('dialog', { name: 'Create a new workspace' })
-  fireEvent.change(within(dialog).getByRole('textbox', { name: 'New workspace name' }), {
-    target: { value: 'nova' },
-  })
-  fireEvent.click(within(dialog).getByRole('button', { name: 'Create workspace' }))
-
-  const tree = await screen.findByRole('tree', { name: 'Sessions' })
-  await waitFor(() => { expect(within(tree).getByText('1 session')).toBeDefined() })
-  const group = within(tree).getByText('1 session').closest('[role="treeitem"]')
-  const draft = within(tree).getByText('New session').closest('[role="treeitem"]')
-  if (group === null || draft === null) throw new Error('created Workspace projection missing')
+  const composer = await findHeroComposer()
+  const tree = screen.getByRole('tree', { name: 'Sessions' })
+  await waitFor(() => { expect(within(tree).getByText('4 sessions')).toBeDefined() }, { timeout: 10_000 })
 
   expect({
-    workspace: visibleText(group),
-    draft: visibleText(draft),
-    draftSelected: draft.getAttribute('aria-selected'),
-    composerWorkspace: visibleText(workspaceChip()),
+    chip: visibleText(workspaceChip()),
+    composerDisabled: composer.disabled,
+    blankRow: within(tree).getByText('New Session').textContent,
   }).toMatchInlineSnapshot(`
     {
-      "composerWorkspace": "nova",
-      "draft": "New session",
-      "draftSelected": "true",
+      "blankRow": "New Session",
+      "chip": "fixture",
+      "composerDisabled": false,
+    }
+  `)
+})
+
+it('creating a Workspace materializes and lists its selected blank Session', async () => {
+  boot('?fixture=empty')
+
+  await findLockedComposer()
+  await createWorkspaceViaPicker('nova')
+
+  // The pick connected the workspace: full Session+Agent exists, composer live.
+  const composer = await findHeroComposer()
+  const tree = screen.getByRole('tree', { name: 'Sessions' })
+  await waitFor(() => { expect(within(tree).getByText('1 session')).toBeDefined() })
+  expect(within(tree).getByText('New Session')).toBeDefined()
+  const group = within(tree).getByText('1 session').closest('[role="treeitem"]')
+  if (group === null) throw new Error('created Workspace projection missing')
+
+  expect({
+    composerDisabled: composer.disabled,
+    chip: visibleText(workspaceChip()),
+    workspace: visibleText(group),
+  }).toMatchInlineSnapshot(`
+    {
+      "chip": "nova",
+      "composerDisabled": false,
       "workspace": "nova1 session",
     }
   `)
 })
 
-it('drops the page-local draft on refresh while retaining real Workspaces and Sessions', async () => {
-  boot('?fixture')
+it('New Session reuses the Workspace blank session and converts the single visible row', async () => {
+  boot('?fixture=empty')
 
-  const composer = await screen.findByPlaceholderText('Describe what you want to build', {}, { timeout: 10_000 })
+  await findLockedComposer()
+  await createWorkspaceViaPicker('nova')
+  await findHeroComposer()
   const tree = screen.getByRole('tree', { name: 'Sessions' })
-  setComposerText(composer, 'discard this page-local draft')
-  const beforeGroup = within(tree).getByText('4 sessions').closest('[role="treeitem"]')
-  if (beforeGroup === null) throw new Error('fixture Workspace projection missing before refresh')
+  await waitFor(() => { expect(within(tree).getByText('1 session')).toBeDefined() }, { timeout: 10_000 })
 
-  const before = {
-    workspace: visibleText(beforeGroup),
-    draft: visibleText(within(tree).getByText('New session')),
-    prompt: (composer as HTMLTextAreaElement).value,
-  }
+  // New Session resolves through the recent Workspace and reuses its blank
+  // session in place: no locked interlude, no second entity.
+  fireEvent.click(screen.getByRole('button', { name: 'New session' }))
+  const composer = await findHeroComposer()
+  await waitFor(() => { expect(within(tree).getByText('1 session')).toBeDefined() }, { timeout: 10_000 })
 
-  refresh('?fixture')
+  setComposerText(composer, 'first light')
+  fireEvent.keyDown(composer, { key: 'Enter' })
 
-  const refreshedComposer = await screen.findByPlaceholderText('Describe what you want to build', {}, { timeout: 10_000 })
-  const refreshedTree = screen.getByRole('tree', { name: 'Sessions' })
-  const afterGroup = within(refreshedTree).getByText('4 sessions').closest('[role="treeitem"]')
-  if (afterGroup === null) throw new Error('fixture Workspace projection missing after refresh')
+  // Conversion: the accepted prompt flips blank without adding a second row.
+  await screen.findByText('first light', { exact: true }, { timeout: 10_000 })
+  await waitFor(() => { expect(within(tree).getByText('1 session')).toBeDefined() }, { timeout: 10_000 })
+  const group = within(tree).getByText('1 session').closest('[role="treeitem"]')
+  if (group === null) throw new Error('converted Session projection missing')
 
   expect({
-    before,
-    after: {
-      workspace: visibleText(afterGroup),
-      replacementDraft: visibleText(within(refreshedTree).getByText('New session')),
-      prompt: (refreshedComposer as HTMLTextAreaElement).value,
-    },
+    workspace: visibleText(group),
+    promptVisible: screen.getByText('first light', { exact: true }).textContent,
   }).toMatchInlineSnapshot(`
     {
-      "after": {
-        "prompt": "",
-        "replacementDraft": "New session",
-        "workspace": "fixture4 sessions",
-      },
-      "before": {
-        "draft": "New session",
-        "prompt": "discard this page-local draft",
-        "workspace": "fixture4 sessions",
-      },
+      "promptVisible": "first light",
+      "workspace": "nova1 session",
     }
   `)
 })
 
-it('keeps a published Session with only cwd membership evidence in Ungrouped', async () => {
+it('a failed Workspace attach recovers by reusing the published blank session', async () => {
   boot('?fixture&fixtureAttach=fail')
 
-  const composer = await screen.findByPlaceholderText('Describe what you want to build', {}, { timeout: 10_000 })
-  setComposerText(composer, 'keep this cwd-only session')
-  fireEvent.click(screen.getByRole('button', { name: 'Send message' }))
+  // The rejected startup connect surfaces the locked view state first: the
+  // failure leaves no client-side transaction state to unwind.
+  await findLockedComposer()
 
+  // The host published the session before rejecting attachment (blank, with
+  // the workspace cwd), so the next connect — retry or manual pick — reuses
+  // it instead of minting a duplicate, and the hero opens on it.
+  await pickWorkspace('fixture')
+  const composer = await findHeroComposer()
   const tree = screen.getByRole('tree', { name: 'Sessions' })
-  await waitFor(() => { expect(within(tree).getByText('Ungrouped')).toBeDefined() }, { timeout: 10_000 })
-  const workspaceGroup = within(tree).getByText('3 sessions').closest('[role="treeitem"]')
-  const ungroupedGroup = within(tree).getByText('1 session').closest('[role="treeitem"]')
-  const ungroupedSection = ungroupedGroup?.parentElement
-  if (workspaceGroup === null || ungroupedGroup === null || ungroupedSection === null || ungroupedSection === undefined) {
-    throw new Error('Workspace or Ungrouped projection missing')
-  }
-  const session = within(ungroupedSection).getByRole('treeitem', { selected: true })
-  const retained = screen.getByDisplayValue('keep this cwd-only session')
+  const group = within(tree).getByText('3 sessions').closest('[role="treeitem"]')
+  if (group === null) throw new Error('fixture Workspace projection missing')
 
   expect({
-    workspace: visibleText(workspaceGroup),
-    ungrouped: visibleText(ungroupedGroup),
-    session: within(session).getByText('fixture', { exact: true }).textContent,
-    sessionSelected: session.getAttribute('aria-selected'),
-    prompt: (retained as HTMLTextAreaElement).value,
+    headline: visibleText(screen.getByText("Let's start building")),
+    composerDisabled: composer.disabled,
+    chip: visibleText(workspaceChip()),
+    workspace: visibleText(group),
   }).toMatchInlineSnapshot(`
     {
-      "prompt": "keep this cwd-only session",
-      "session": "fixture",
-      "sessionSelected": "true",
-      "ungrouped": "Ungrouped1 session",
+      "chip": "fixture",
+      "composerDisabled": false,
+      "headline": "Let's start building",
       "workspace": "fixture3 sessions",
     }
   `)
 })
 
-it('materializes the automatic Workspace and Session on the first successful send', async () => {
-  boot('?fixture=empty')
-
-  const composer = await screen.findByPlaceholderText('Describe what you want to build', {}, { timeout: 10_000 })
-  setComposerText(composer, 'build a lighthouse')
-  fireEvent.click(screen.getByRole('button', { name: 'Send message' }))
-
-  const tree = screen.getByRole('tree', { name: 'Sessions' })
-  await waitFor(() => { expect(within(tree).getByText('1 session')).toBeDefined() }, { timeout: 10_000 })
-  await screen.findByText('build a lighthouse', { exact: true }, { timeout: 10_000 })
-  const group = within(tree).getByText('1 session').closest('[role="treeitem"]')
-  const session = within(tree).getByRole('treeitem', { selected: true })
-  if (group === null) throw new Error('materialized Workspace projection missing')
-
-  expect({
-    workspace: visibleText(group),
-    session: within(session).getByText('workspace', { exact: true }).textContent,
-    sessionSelected: session.getAttribute('aria-selected'),
-    promptVisible: screen.getByText('build a lighthouse', { exact: true }).textContent,
-  }).toMatchInlineSnapshot(`
-    {
-      "promptVisible": "build a lighthouse",
-      "session": "workspace",
-      "sessionSelected": "true",
-      "workspace": "workspace1 session",
-    }
-  `)
-})
-
-it('keeps the published Workspace, Session, and unsent prompt after rejection', async () => {
+it('a rejected first prompt keeps the session blank and the draft in the machine', async () => {
   boot('?fixture=empty&fixturePrompt=reject')
 
-  const composer = await screen.findByPlaceholderText('Describe what you want to build', {}, { timeout: 10_000 })
+  await findLockedComposer()
+  await createWorkspaceViaPicker('nova')
+  const composer = await findHeroComposer()
+
   setComposerText(composer, 'do not lose this')
   fireEvent.click(screen.getByRole('button', { name: 'Send message' }))
 
   const alert = await screen.findByRole('alert', {}, { timeout: 10_000 })
-  const retained = screen.getByDisplayValue('do not lose this')
+  // Failure restore rides the machine (no pendingPrompt transaction): the
+  // draft returns to the same resident textarea one render later. The
+  // attempt flips the composer out of the hero (engaging = retry chrome),
+  // but acceptance never happened: the session row stays New Session.
+  const retained = await screen.findByDisplayValue('do not lose this')
   const tree = screen.getByRole('tree', { name: 'Sessions' })
-  await waitFor(() => { expect(within(tree).getByText('1 session')).toBeDefined() })
   const group = within(tree).getByText('1 session').closest('[role="treeitem"]')
-  const session = within(tree).getByRole('treeitem', { selected: true })
   if (group === null) throw new Error('rejected-send Workspace projection missing')
 
   expect({
-    workspace: visibleText(group),
-    session: within(session).getByText('workspace', { exact: true }).textContent,
     error: visibleText(alert),
     prompt: (retained as HTMLTextAreaElement).value,
+    blankRow: within(tree).getByText('New Session').textContent,
+    workspace: visibleText(group),
   }).toMatchInlineSnapshot(`
     {
-      "error": "Message send failed: agent-busy: fixture: prompt rejected before acceptance",
+      "blankRow": "New Session",
+      "error": "fixture: prompt rejected before acceptance (agent-busy)",
       "prompt": "do not lose this",
-      "session": "workspace",
-      "workspace": "workspace1 session",
+      "workspace": "nova1 session",
+    }
+  `)
+})
+
+it('switching Workspace before the first message carries the draft to the new blank session', async () => {
+  boot('?fixture')
+
+  const composer = await findHeroComposer()
+  setComposerText(composer, 'carry me')
+
+  // Switch = session switch: the new workspace's blank session takes over,
+  // the typed draft moves machine-to-machine, the old blank stays hidden.
+  await createWorkspaceViaPicker('nova')
+  await waitFor(() => { expect(visibleText(workspaceChip())).toBe('nova') }, { timeout: 10_000 })
+  const carried = await screen.findByDisplayValue('carry me')
+  const tree = screen.getByRole('tree', { name: 'Sessions' })
+  const fixtureGroup = within(tree).getByText('3 sessions').closest('[role="treeitem"]')
+  const novaGroup = within(tree).getByText('1 session').closest('[role="treeitem"]')
+  if (fixtureGroup === null || novaGroup === null) throw new Error('Workspace projections missing after switch')
+
+  expect({
+    chip: visibleText(workspaceChip()),
+    prompt: (carried as HTMLTextAreaElement).value,
+    fixtureWorkspace: visibleText(fixtureGroup),
+    novaWorkspace: visibleText(novaGroup),
+  }).toMatchInlineSnapshot(`
+    {
+      "chip": "nova",
+      "fixtureWorkspace": "fixture3 sessions",
+      "novaWorkspace": "nova1 session",
+      "prompt": "carry me",
     }
   `)
 })

docs/config-catalog.md

@@ -2047,6 +2047,7 @@ These load from a `cordis.yml` entry with no `config:` block; they declare no co
 - `@deepseek-ai/dsh-client-locale` ([`packages/client/locale/src/index.ts`](../packages/client/locale/src/index.ts))
 - `@deepseek-ai/dsh-client-modules` — requires `httpServer` · `loader` ([`packages/client/modules/src/index.ts`](../packages/client/modules/src/index.ts))
 - `@deepseek-ai/dsh-client-runtime` ([`packages/client/runtime/src/index.ts`](../packages/client/runtime/src/index.ts))
+- `@deepseek-ai/dsh-client-ui-command` ([`packages/client/ui-command/src/index.ts`](../packages/client/ui-command/src/index.ts))
 - `@deepseek-ai/dsh-client-ui-conversation` ([`packages/client/ui-conversation/src/index.ts`](../packages/client/ui-conversation/src/index.ts))
 - `@deepseek-ai/dsh-client-ui-layout` ([`packages/client/ui-layout/src/index.ts`](../packages/client/ui-layout/src/index.ts))
 - `@deepseek-ai/dsh-client-ui-models` ([`packages/client/ui-models/src/index.ts`](../packages/client/ui-models/src/index.ts))
@@ -2054,6 +2055,9 @@ These load from a `cordis.yml` entry with no `config:` block; they declare no co
 - `@deepseek-ai/dsh-client-ui-settings` ([`packages/client/ui-settings/src/index.ts`](../packages/client/ui-settings/src/index.ts))
 - `@deepseek-ai/dsh-client-ui-settings-general` ([`packages/client/ui-settings-general/src/index.ts`](../packages/client/ui-settings-general/src/index.ts))
 - `@deepseek-ai/dsh-client-ui-sidebar` ([`packages/client/ui-sidebar/src/index.ts`](../packages/client/ui-sidebar/src/index.ts))
+- `@deepseek-ai/dsh-client-ui-skill` ([`packages/client/ui-skill/src/index.ts`](../packages/client/ui-skill/src/index.ts))
+- `@deepseek-ai/dsh-client-ui-slash` ([`packages/client/ui-slash/src/index.ts`](../packages/client/ui-slash/src/index.ts))
+- `@deepseek-ai/dsh-client-ui-subagent` ([`packages/client/ui-subagent/src/index.ts`](../packages/client/ui-subagent/src/index.ts))
 - `@deepseek-ai/dsh-client-ui-theme` ([`packages/client/ui-theme/src/index.ts`](../packages/client/ui-theme/src/index.ts))
 - `@deepseek-ai/dsh-client-ui-trajectory` ([`packages/client/ui-trajectory/src/index.ts`](../packages/client/ui-trajectory/src/index.ts))
 - `@deepseek-ai/dsh-client-ui-workspace` ([`packages/client/ui-workspace/src/index.ts`](../packages/client/ui-workspace/src/index.ts))

docs/cordis-catalog/events.md

@@ -9,7 +9,7 @@ This file is GENERATED from source (`scripts/gen-cordis-catalog.ts`) and verifie
 
 The **harness tier** below (the `@deepseek-ai/dsh-*` packages) is the vocabulary this repo owns, grouped by scope. The **inherited tier** at the end is the cordis-core + loader/hmr/timer event surface a plugin also sees — pinned vendor source, summarized tersely. The event-dispatch methods themselves are generated in the [Cordis core Events API](core/events.md).
 
-Dispatch modes: **emit** (fire-and-forget), **waterfall** (each listener gets `next()` and may transform or veto — see [waterfall semantics](../cordis-primer.md#cordis-waterfall-semantics)), **parallel** (awaited fan-out; all listeners run), **serial** (awaited in registration order until one returns a bail value — anything other than `null`, `false`, or `undefined`).
+Dispatch modes: **emit** (fire-and-forget), **waterfall** (each listener gets `next()` and may transform or veto — see [waterfall semantics](../cordis-primer.md#cordis-waterfall-semantics)), **parallel** (awaited fan-out; all listeners run), **serial** (awaited in registration order until one returns a bail value — anything other than `null`, `false`, or `undefined`), **bail** (synchronous in-order dispatch until one listener returns a bail value; the scoped input-mutation events use it for an applied/not-applied answer).
 
 ## `agent/*`
 
@@ -708,6 +708,75 @@ Types: [Scoped](../core-data-structures/scope.md) · [Session](../core-data-stru
 
 Source: [`packages/core/session/src/index.ts:111`](../../packages/core/session/src/index.ts)
 
+## `slash/*`
+
+### `slash/input-begin-command` — bail
+
+Applies one command claim to the scoped Input. Dispatched with the session's scope carrier; the owning session's input listener returns `true` only after the phase and span CAS checks pass and the machine actually mutated — producers treat anything else as "not applied".
+
+```ts cordis-catalog
+/**
+ * Applies one command claim to the scoped Input. Dispatched with the
+ * session's scope carrier; the owning session's input listener returns
+ * `true` only after the phase and span CAS checks pass and the machine
+ * actually mutated — producers treat anything else as "not applied".
+ * @param request - Claim and menu-time span CAS.
+ * @mode bail
+ */
+'slash/input-begin-command'(request: BeginCommandRequest): true | undefined
+```
+
+Source: [`packages/client/ui-slash/src/types.ts:220`](../../packages/client/ui-slash/src/types.ts)
+
+### `slash/input-consume-token` — bail
+
+Consumes one command token after business success (popup settle / menu-pick execute). Same carrier routing and applied-truth contract.
+
+```ts cordis-catalog
+/**
+ * Consumes one command token after business success (popup settle /
+ * menu-pick execute). Same carrier routing and applied-truth contract.
+ * @param request - Exact span or bare-token guard.
+ * @mode bail
+ */
+'slash/input-consume-token'(request: ConsumeTokenRequest): true | undefined
+```
+
+Source: [`packages/client/ui-slash/src/types.ts:234`](../../packages/client/ui-slash/src/types.ts)
+
+### `slash/input-insert-reference` — bail
+
+Inserts one reference into the scoped Input (same carrier routing and applied-truth contract as begin-command).
+
+```ts cordis-catalog
+/**
+ * Inserts one reference into the scoped Input (same carrier routing and
+ * applied-truth contract as begin-command).
+ * @param request - Reference and menu-time span CAS.
+ * @mode bail
+ */
+'slash/input-insert-reference'(request: InsertReferenceRequest): true | undefined
+```
+
+Source: [`packages/client/ui-slash/src/types.ts:227`](../../packages/client/ui-slash/src/types.ts)
+
+### `slash/input-insert-text` — bail
+
+Replaces the trigger token span with literal text — the plain-text reference path (decision 21). Same carrier routing and applied-truth contract; the draft gains ordinary characters, no occurrence entry.
+
+```ts cordis-catalog
+/**
+ * Replaces the trigger token span with literal text — the plain-text
+ * reference path (decision 21). Same carrier routing and applied-truth
+ * contract; the draft gains ordinary characters, no occurrence entry.
+ * @param request - Replacement text and menu-time span CAS.
+ * @mode bail
+ */
+'slash/input-insert-text'(request: InsertTextRequest): true | undefined
+```
+
+Source: [`packages/client/ui-slash/src/types.ts:242`](../../packages/client/ui-slash/src/types.ts)
+
 ## `subagent/*`
 
 ### `subagent/end` — emit

docs/event-producer-consumer.md

@@ -12,9 +12,9 @@ This matrix shows which packages dispatch each harness-owned event and which pac
 | `agent/created` | `emit` | [`packages/core/agent/src/types.ts:285`](../packages/core/agent/src/types.ts) | [`agent`](../packages/core/agent) (`events.dispatch`) | [`goal-session`](../packages/goal/goal-session), [`tui`](../packages/ui/tui) |
 | `agent/disposed` | `emit` | [`packages/core/agent/src/types.ts:294`](../packages/core/agent/src/types.ts) | [`agent`](../packages/core/agent) (`events.dispatch`) | [`agent-loop`](../packages/core/agent-loop), [`goal-session`](../packages/goal/goal-session), [`tui`](../packages/ui/tui) |
 | `agent/error` | `emit` | [`packages/core/agent/src/types.ts:498`](../packages/core/agent/src/types.ts) | [`agent-loop`](../packages/core/agent-loop) (`emit`) | `apiproxy`, [`goal-session`](../packages/goal/goal-session), [`tui`](../packages/ui/tui) |
-| `agent/inbox/dequeue` | `emit` | [`packages/core/agent/src/types.ts:326`](../packages/core/agent/src/types.ts) | [`agent-loop`](../packages/core/agent-loop) (`emit`) | [`agent`](../packages/core/agent) |
-| `agent/inbox/discard` | `emit` | [`packages/core/agent/src/types.ts:340`](../packages/core/agent/src/types.ts) | [`agent-loop`](../packages/core/agent-loop) (`emit`) | [`agent`](../packages/core/agent) |
-| `agent/inbox/enqueue` | `emit` | [`packages/core/agent/src/types.ts:316`](../packages/core/agent/src/types.ts) | [`agent-loop`](../packages/core/agent-loop) (`emit`) | [`agent`](../packages/core/agent), [`goal-session`](../packages/goal/goal-session), [`tui`](../packages/ui/tui) |
+| `agent/inbox/dequeue` | `emit` | [`packages/core/agent/src/types.ts:326`](../packages/core/agent/src/types.ts) | [`agent-loop`](../packages/core/agent-loop) (`emit`) | [`agent`](../packages/core/agent), `apiproxy` |
+| `agent/inbox/discard` | `emit` | [`packages/core/agent/src/types.ts:340`](../packages/core/agent/src/types.ts) | [`agent-loop`](../packages/core/agent-loop) (`emit`) | [`agent`](../packages/core/agent), `apiproxy` |
+| `agent/inbox/enqueue` | `emit` | [`packages/core/agent/src/types.ts:316`](../packages/core/agent/src/types.ts) | [`agent-loop`](../packages/core/agent-loop) (`emit`) | [`agent`](../packages/core/agent), `apiproxy`, [`goal-session`](../packages/goal/goal-session), [`tui`](../packages/ui/tui) |
 | `agent/post-step` | `serial` | [`packages/core/agent/src/types.ts:448`](../packages/core/agent/src/types.ts) | [`agent-loop`](../packages/core/agent-loop) (`serial`) | [`compact-basic`](../packages/compact/compact-basic), [`session-checkpoint-policy`](../packages/session-persistence/session-checkpoint-policy) |
 | `agent/pre-step` | `serial` | [`packages/core/agent/src/types.ts:379`](../packages/core/agent/src/types.ts) | [`agent-loop`](../packages/core/agent-loop) (`serial`) | [`time-context`](../packages/context/time-context), [`user-approval`](../packages/ui/user-approval) |
 | `agent/prompt-submit` | `waterfall` | [`packages/core/agent/src/types.ts:395`](../packages/core/agent/src/types.ts) | [`agent-loop`](../packages/core/agent-loop) (`waterfall`) | [`goal-session`](../packages/goal/goal-session), [`hooks-claude`](../packages/hooks/hooks-claude), [`hooks-codex`](../packages/hooks/hooks-codex), [`plan-mode`](../packages/plan/plan-mode), [`repeat-tool-guard`](../packages/guard/repeat-tool-guard) |
@@ -27,7 +27,7 @@ This matrix shows which packages dispatch each harness-owned event and which pac
 | `agent/turn-continuation` | `waterfall` | [`packages/core/agent/src/types.ts:474`](../packages/core/agent/src/types.ts) | [`agent-loop`](../packages/core/agent-loop) (`waterfall`) | [`hooks-claude`](../packages/hooks/hooks-claude), [`hooks-codex`](../packages/hooks/hooks-codex), [`plan-mode`](../packages/plan/plan-mode) |
 | `agent/turn-stop` | `serial` | [`packages/core/agent/src/types.ts:485`](../packages/core/agent/src/types.ts) | [`agent-loop`](../packages/core/agent-loop) (`serial`) | [`subagent-inprocess`](../packages/subagent/subagent-inprocess), [`tool-goal`](../packages/goal/tool-goal) |
 | `approval/request` | `waterfall` | [`packages/ui/user-approval/src/index.ts:30`](../packages/ui/user-approval/src/index.ts) | [`user-approval`](../packages/ui/user-approval) (`waterfall`) | [`acp`](../packages/acp/acp) |
-| `commands/change` | `emit` | [`packages/ui/commands/src/index.ts:103`](../packages/ui/commands/src/index.ts) | [`commands`](../packages/ui/commands) (`events.dispatch`) | [`tui`](../packages/ui/tui) |
+| `commands/change` | `emit` | [`packages/ui/commands/src/index.ts:103`](../packages/ui/commands/src/index.ts) | [`commands`](../packages/ui/commands) (`events.dispatch`) | `apiproxy`, [`tui`](../packages/ui/tui) |
 | `domain/changed` | `emit` | [`packages/storage/storage-domain/src/events.ts:46`](../packages/storage/storage-domain/src/events.ts) | [`storage-domain`](../packages/storage/storage-domain) (`emit`) | `apiproxy`, [`storage-domain`](../packages/storage/storage-domain), [`workspace`](../packages/workspace/workspace) |
 | `fs/edit-intent` | `waterfall` | [`packages/fs/fs/src/index.ts:62`](../packages/fs/fs/src/index.ts) | [`tool-fs`](../packages/fs/tool-fs) (`waterfall`) | [`fs-policy`](../packages/fs/fs-policy) |
 | `fs/observed` | `emit` | [`packages/fs/fs/src/index.ts:71`](../packages/fs/fs/src/index.ts) | [`tool-fs`](../packages/fs/tool-fs) (`emit`) | [`fs-policy`](../packages/fs/fs-policy) |
@@ -38,6 +38,10 @@ This matrix shows which packages dispatch each harness-owned event and which pac
 | `session/disposed` | `emit` | [`packages/core/session/src/index.ts:89`](../packages/core/session/src/index.ts) | [`session`](../packages/core/session) (`events.dispatch`) | [`agent-loop`](../packages/core/agent-loop), `apiproxy`, [`session-persistence`](../packages/session-persistence/session-persistence), [`session-title`](../packages/session-title/session-title) |
 | `session/event` | `emit` | [`packages/core/session/src/index.ts:101`](../packages/core/session/src/index.ts) | [`session`](../packages/core/session) (`events.dispatch`) | [`acp`](../packages/acp/acp), `apiproxy`, [`cli-demo`](../packages/examples/cli-demo), [`compact`](../packages/compact/compact), [`goal`](../packages/goal/goal), [`goal-session`](../packages/goal/goal-session), [`hook-protocol`](../packages/hooks/hook-protocol), [`jsonrpc`](../packages/ui/jsonrpc), [`session`](../packages/core/session), [`session-persistence`](../packages/session-persistence/session-persistence), [`session-title`](../packages/session-title/session-title), [`token-meter`](../packages/llm/token-meter), [`tui`](../packages/ui/tui), [`user-approval`](../packages/ui/user-approval), [`workspace-context`](../packages/context/workspace-context) |
 | `session/flush` | `parallel` | [`packages/core/session/src/index.ts:111`](../packages/core/session/src/index.ts) | [`session`](../packages/core/session) (`events.dispatch`) | [`session-persistence`](../packages/session-persistence/session-persistence) |
+| `slash/input-begin-command` | `bail` | [`packages/client/ui-slash/src/types.ts:220`](../packages/client/ui-slash/src/types.ts) | - | `ui-conversation` |
+| `slash/input-consume-token` | `bail` | [`packages/client/ui-slash/src/types.ts:234`](../packages/client/ui-slash/src/types.ts) | - | `ui-conversation` |
+| `slash/input-insert-reference` | `bail` | [`packages/client/ui-slash/src/types.ts:227`](../packages/client/ui-slash/src/types.ts) | - | `ui-conversation` |
+| `slash/input-insert-text` | `bail` | [`packages/client/ui-slash/src/types.ts:242`](../packages/client/ui-slash/src/types.ts) | - | `ui-conversation` |
 | `subagent/end` | `emit` | [`packages/subagent/subagent/src/index.ts:139`](../packages/subagent/subagent/src/index.ts) | [`subagent`](../packages/subagent/subagent) (`events.dispatch`) | [`hooks-claude`](../packages/hooks/hooks-claude), [`jsonrpc`](../packages/ui/jsonrpc), [`subagent`](../packages/subagent/subagent) |
 | `subagent/provider-added` | `emit` | [`packages/subagent/subagent/src/index.ts:113`](../packages/subagent/subagent/src/index.ts) | [`subagent`](../packages/subagent/subagent) (`emit`) | [`subagent`](../packages/subagent/subagent), [`tool-subagent`](../packages/subagent/tool-subagent) |
 | `subagent/provider-removed` | `emit` | [`packages/subagent/subagent/src/index.ts:119`](../packages/subagent/subagent/src/index.ts) | [`subagent`](../packages/subagent/subagent) (`events.dispatch`) | [`subagent`](../packages/subagent/subagent), [`tool-subagent`](../packages/subagent/tool-subagent) |
@@ -61,6 +65,8 @@ This matrix shows which packages dispatch each harness-owned event and which pac
 
 | Event string | Dispatchers | Listeners |
 | --- | --- | --- |
+| `commands/changed` | `runtime` (`emit`) | - |
+| `connection/reset` | `runtime` (`emit`) | - |
 | `internal/dispatch` | - | [`compact`](../packages/compact/compact), [`fs`](../packages/fs/fs), [`goal`](../packages/goal/goal), [`goal-session`](../packages/goal/goal-session), [`hook-protocol`](../packages/hooks/hook-protocol), [`llm-retry`](../packages/llm/llm-retry), [`permission`](../packages/ui/permission), [`plan-mode`](../packages/plan/plan-mode), [`pty-local`](../packages/pty/pty-local), `runtime`, [`sandbox-policy`](../packages/sandbox/sandbox-policy), [`scope`](../packages/core/scope), [`session`](../packages/core/session), [`subagent`](../packages/subagent/subagent), [`time-context`](../packages/context/time-context), [`tool-todo`](../packages/todo/tool-todo), [`tools`](../packages/core/tools), [`user-approval`](../packages/ui/user-approval), [`workflow`](../packages/workflow/workflow) |
 | `internal/plugin` | - | `hmr`, `modules`, `webserver` |
 | `internal/status` | - | [`agent`](../packages/core/agent) |

docs/module-graph.md

@@ -141,6 +141,7 @@ flowchart TD
     pkg_client_locale["client-locale"]
     pkg_client_modules["client-modules"]
     pkg_client_runtime["client-runtime"]
+    pkg_client_ui_command["client-ui-command"]
     pkg_client_ui_conversation["client-ui-conversation"]
     pkg_client_ui_layout["client-ui-layout"]
     pkg_client_ui_models["client-ui-models"]
@@ -149,7 +150,10 @@ flowchart TD
     pkg_client_ui_settings["client-ui-settings"]
     pkg_client_ui_settings_general["client-ui-settings-general"]
     pkg_client_ui_sidebar["client-ui-sidebar"]
+    pkg_client_ui_skill["client-ui-skill"]
+    pkg_client_ui_slash["client-ui-slash"]
     pkg_client_ui_slots["client-ui-slots"]
+    pkg_client_ui_subagent["client-ui-subagent"]
     pkg_client_ui_theme["client-ui-theme"]
     pkg_client_ui_trajectory["client-ui-trajectory"]
     pkg_client_ui_workspace["client-ui-workspace"]
@@ -256,10 +260,6 @@ flowchart TD
   pkg_client_locale --> pkg_client_ui_primitives
   pkg_client_locale --> pkg_client_ui_slots
   pkg_client_locale --> pkg_invariants
-  pkg_client_ui_conversation --> pkg_client_runtime
-  pkg_client_ui_conversation --> pkg_client_ui_primitives
-  pkg_client_ui_conversation --> pkg_client_ui_slots
-  pkg_client_ui_conversation --> pkg_invariants
   pkg_client_ui_models --> pkg_client_runtime
   pkg_client_ui_models --> pkg_client_ui_slots
   pkg_client_ui_models --> pkg_invariants
@@ -271,6 +271,9 @@ flowchart TD
   pkg_client_ui_sidebar --> pkg_client_ui_primitives
   pkg_client_ui_sidebar --> pkg_client_ui_slots
   pkg_client_ui_sidebar --> pkg_invariants
+  pkg_client_ui_slash --> pkg_client_runtime
+  pkg_client_ui_slash --> pkg_client_ui_slots
+  pkg_client_ui_slash --> pkg_invariants
   pkg_client_ui_workspace --> pkg_client_runtime
   pkg_client_ui_workspace --> pkg_client_ui_primitives
   pkg_client_ui_workspace --> pkg_client_ui_slots
@@ -301,12 +304,26 @@ flowchart TD
   pkg_system_prompt --> pkg_scope
   pkg_web --> pkg_invariants
   pkg_web --> pkg_llm
+  pkg_client_ui_conversation --> pkg_client_runtime
+  pkg_client_ui_conversation --> pkg_client_ui_primitives
+  pkg_client_ui_conversation --> pkg_client_ui_slash
+  pkg_client_ui_conversation --> pkg_client_ui_slots
+  pkg_client_ui_conversation --> pkg_invariants
   pkg_client_ui_settings_general --> pkg_client_locale
   pkg_client_ui_settings_general --> pkg_client_runtime
   pkg_client_ui_settings_general --> pkg_client_ui_primitives
   pkg_client_ui_settings_general --> pkg_client_ui_settings
   pkg_client_ui_settings_general --> pkg_client_ui_slots
   pkg_client_ui_settings_general --> pkg_invariants
+  pkg_client_ui_skill --> pkg_client_connection
+  pkg_client_ui_skill --> pkg_client_runtime
+  pkg_client_ui_skill --> pkg_client_ui_slash
+  pkg_client_ui_skill --> pkg_client_ui_slots
+  pkg_client_ui_skill --> pkg_invariants
+  pkg_client_ui_subagent --> pkg_client_runtime
+  pkg_client_ui_subagent --> pkg_client_ui_slash
+  pkg_client_ui_subagent --> pkg_client_ui_slots
+  pkg_client_ui_subagent --> pkg_invariants
   pkg_client_ui_theme --> pkg_client_locale
   pkg_client_ui_theme --> pkg_client_runtime
   pkg_client_ui_theme --> pkg_client_ui_primitives
@@ -364,6 +381,13 @@ flowchart TD
   pkg_app_boot --> pkg_invariants
   pkg_app_boot --> pkg_paths
   pkg_app_boot --> pkg_system_prompt
+  pkg_client_ui_command --> pkg_client_connection
+  pkg_client_ui_command --> pkg_client_runtime
+  pkg_client_ui_command --> pkg_client_ui_conversation
+  pkg_client_ui_command --> pkg_client_ui_primitives
+  pkg_client_ui_command --> pkg_client_ui_slash
+  pkg_client_ui_command --> pkg_client_ui_slots
+  pkg_client_ui_command --> pkg_invariants
   pkg_client_ui_layout --> pkg_client_runtime
   pkg_client_ui_layout --> pkg_client_ui_slots
   pkg_client_ui_layout --> pkg_client_ui_theme
@@ -855,10 +879,10 @@ flowchart TD
 | [`client-connection`](../packages/client/connection) | `client` | [`host-webserver`](../packages/host/webserver), [`invariants`](../packages/support/invariants) |
 | [`client-hmr`](../packages/client/hmr) | `client` | [`client-modules`](../packages/client/modules), [`host-webserver`](../packages/host/webserver), [`invariants`](../packages/support/invariants) |
 | [`client-locale`](../packages/client/locale) | `client` | [`client-runtime`](../packages/client/runtime), [`client-ui-primitives`](../packages/client/ui-primitives), [`client-ui-slots`](../packages/client/ui-slots), [`invariants`](../packages/support/invariants) |
-| [`client-ui-conversation`](../packages/client/ui-conversation) | `client` | [`client-runtime`](../packages/client/runtime), [`client-ui-primitives`](../packages/client/ui-primitives), [`client-ui-slots`](../packages/client/ui-slots), [`invariants`](../packages/support/invariants) |
 | [`client-ui-models`](../packages/client/ui-models) | `client` | [`client-runtime`](../packages/client/runtime), [`client-ui-slots`](../packages/client/ui-slots), [`invariants`](../packages/support/invariants) |
 | [`client-ui-settings`](../packages/client/ui-settings) | `client` | [`client-runtime`](../packages/client/runtime), [`client-ui-primitives`](../packages/client/ui-primitives), [`client-ui-slots`](../packages/client/ui-slots), [`invariants`](../packages/support/invariants) |
 | [`client-ui-sidebar`](../packages/client/ui-sidebar) | `client` | [`client-runtime`](../packages/client/runtime), [`client-ui-primitives`](../packages/client/ui-primitives), [`client-ui-slots`](../packages/client/ui-slots), [`invariants`](../packages/support/invariants) |
+| [`client-ui-slash`](../packages/client/ui-slash) | `client` | [`client-runtime`](../packages/client/runtime), [`client-ui-slots`](../packages/client/ui-slots), [`invariants`](../packages/support/invariants) |
 | [`client-ui-workspace`](../packages/client/ui-workspace) | `client` | [`client-runtime`](../packages/client/runtime), [`client-ui-primitives`](../packages/client/ui-primitives), [`client-ui-slots`](../packages/client/ui-slots), [`invariants`](../packages/support/invariants) |
 | [`helper`](../packages/sdk/helper) | `sdk` | [`brand`](../packages/util/brand), [`invariants`](../packages/support/invariants) |
 | [`telemetry`](../packages/sdk/telemetry) | `sdk` | [`brand`](../packages/util/brand), [`invariants`](../packages/support/invariants), [`paths`](../packages/util/paths) |
@@ -870,7 +894,10 @@ flowchart TD
 | [`session`](../packages/core/session) | `core` | [`brand`](../packages/util/brand), [`invariants`](../packages/support/invariants), [`llm`](../packages/llm/llm), [`scope`](../packages/core/scope) |
 | [`system-prompt`](../packages/core/system-prompt) | `core` | [`invariants`](../packages/support/invariants), [`llm`](../packages/llm/llm), [`scope`](../packages/core/scope) |
 | [`web`](../packages/web/web) | `web` | [`invariants`](../packages/support/invariants), [`llm`](../packages/llm/llm) |
+| [`client-ui-conversation`](../packages/client/ui-conversation) | `client` | [`client-runtime`](../packages/client/runtime), [`client-ui-primitives`](../packages/client/ui-primitives), [`client-ui-slash`](../packages/client/ui-slash), [`client-ui-slots`](../packages/client/ui-slots), [`invariants`](../packages/support/invariants) |
 | [`client-ui-settings-general`](../packages/client/ui-settings-general) | `client` | [`client-locale`](../packages/client/locale), [`client-runtime`](../packages/client/runtime), [`client-ui-primitives`](../packages/client/ui-primitives), [`client-ui-settings`](../packages/client/ui-settings), [`client-ui-slots`](../packages/client/ui-slots), [`invariants`](../packages/support/invariants) |
+| [`client-ui-skill`](../packages/client/ui-skill) | `client` | [`client-connection`](../packages/client/connection), [`client-runtime`](../packages/client/runtime), [`client-ui-slash`](../packages/client/ui-slash), [`client-ui-slots`](../packages/client/ui-slots), [`invariants`](../packages/support/invariants) |
+| [`client-ui-subagent`](../packages/client/ui-subagent) | `client` | [`client-runtime`](../packages/client/runtime), [`client-ui-slash`](../packages/client/ui-slash), [`client-ui-slots`](../packages/client/ui-slots), [`invariants`](../packages/support/invariants) |
 | [`client-ui-theme`](../packages/client/ui-theme) | `client` | [`client-locale`](../packages/client/locale), [`client-runtime`](../packages/client/runtime), [`client-ui-primitives`](../packages/client/ui-primitives), [`client-ui-slots`](../packages/client/ui-slots), [`invariants`](../packages/support/invariants) |
 | [`lsp`](../packages/lsp/lsp) | `lsp` | [`brand`](../packages/util/brand), [`invariants`](../packages/support/invariants), [`llm`](../packages/llm/llm) |
 | [`sandbox`](../packages/sandbox/sandbox) | `sandbox` | [`invariants`](../packages/support/invariants), [`llm`](../packages/llm/llm) |
@@ -889,6 +916,7 @@ flowchart TD
 | [`session-title`](../packages/session-title/session-title) | `session-title` | [`brand`](../packages/util/brand), [`invariants`](../packages/support/invariants), [`llm`](../packages/llm/llm), [`session`](../packages/core/session) |
 | [`llm-replay`](../packages/support/llm-replay) | `support` | [`invariants`](../packages/support/invariants), [`llm`](../packages/llm/llm), [`session`](../packages/core/session) |
 | [`app-boot`](../packages/ui/app-boot) | `ui` | [`invariants`](../packages/support/invariants), [`paths`](../packages/util/paths), [`system-prompt`](../packages/core/system-prompt) |
+| [`client-ui-command`](../packages/client/ui-command) | `client` | [`client-connection`](../packages/client/connection), [`client-runtime`](../packages/client/runtime), [`client-ui-conversation`](../packages/client/ui-conversation), [`client-ui-primitives`](../packages/client/ui-primitives), [`client-ui-slash`](../packages/client/ui-slash), [`client-ui-slots`](../packages/client/ui-slots), [`invariants`](../packages/support/invariants) |
 | [`client-ui-layout`](../packages/client/ui-layout) | `client` | [`client-runtime`](../packages/client/runtime), [`client-ui-slots`](../packages/client/ui-slots), [`client-ui-theme`](../packages/client/ui-theme), [`invariants`](../packages/support/invariants) |
 | [`code-runtime-worker`](../packages/code-runtime/code-runtime-worker) | `code-runtime` | [`code-runtime`](../packages/code-runtime/code-runtime), [`invariants`](../packages/support/invariants), [`session`](../packages/core/session) |
 | [`lsp-local`](../packages/lsp/lsp-local) | `lsp` | [`brand`](../packages/util/brand), [`invariants`](../packages/support/invariants), [`llm`](../packages/llm/llm), [`lsp`](../packages/lsp/lsp), [`timeout`](../packages/util/timeout) |

packages/client/connection/src/client/api.ts

@@ -9,6 +9,7 @@ export type {
   ApiProxy, SessionsApi, SessionSummary, HostApi, EventsApi, MuxFrame, HostFrame,
   ApprovalResponsePayload, QuestionResponsePayload, HistoryEntry, ToolEventView,
   WorkspaceApi, WorkspaceId, WorkspaceView,
+  CommandsApi, CommandDescriptor, CommandExecuteResult, SkillsApi, SkillEntry,
 } from '@deepseek-ai/dsh-host-apiproxy/api'
 export type { ToolCallView, ToolResultView } from '@deepseek-ai/dsh-tools/presentation'
 export type {

packages/client/connection/src/client/fixture.ts

@@ -347,10 +347,11 @@ class FxInbox<F> implements StreamConn<F> {
  * @returns an ApiProxy backed entirely by in-memory state — no host process, no network.
  */
 export function createFixtureApi(options: FixtureOptions = {}): ApiProxy {
+  // The resident fixture sessions all carry history, so none of them is blank.
   const sessions: SessionSummary[] = options.empty ? [] : [
-    { sessionId: sid('fx-alpha'), updatedAt: Date.now(), running: true, cwd: '/tmp/fixture' },
-    { sessionId: sid('fx-beta'), updatedAt: Date.now() - 60_000, running: false, parentSessionId: sid('fx-alpha'), cwd: '/tmp/fixture' },
-    { sessionId: sid('fx-gamma'), updatedAt: Date.now() - 120_000, running: false, cwd: '/tmp/fixture' },
+    { sessionId: sid('fx-alpha'), updatedAt: Date.now(), running: true, blank: false, cwd: '/tmp/fixture' },
+    { sessionId: sid('fx-beta'), updatedAt: Date.now() - 60_000, running: false, blank: false, parentSessionId: sid('fx-alpha'), cwd: '/tmp/fixture' },
+    { sessionId: sid('fx-gamma'), updatedAt: Date.now() - 120_000, running: false, blank: false, cwd: '/tmp/fixture' },
   ]
   const logs = new Map<SessionId, SessionEvent[]>([[sid('fx-alpha'), buildAlphaLog()]])
   const nextTurn = new Map<SessionId, number>([[sid('fx-alpha'), 60]])
@@ -427,6 +428,16 @@ export function createFixtureApi(options: FixtureOptions = {}): ApiProxy {
   }
 
   const summaryOf = (id: SessionId): SessionSummary | undefined => sessions.find(s => s.sessionId === id)
+  /** Shared session guard for sessionId-addressed catalog routes: the error
+   *  response when the session is unknown, undefined when it exists. */
+  const requireSession = (request: RpcRequest<{ sessionId: SessionId }>): Promise<RpcResponse<never>> | undefined => {
+    if (summaryOf(request.payload.sessionId) !== undefined) return undefined
+    return err<{ sessionId: SessionId }, never>(request, {
+      code: 'session-not-found',
+      message: `no session ${request.payload.sessionId}`,
+      details: { sessionId: request.payload.sessionId },
+    })
+  }
   const setRunning = (id: SessionId, running: boolean): void => {
     const summary = summaryOf(id)
     if (summary === undefined || summary.running === running) return
@@ -582,12 +593,13 @@ export function createFixtureApi(options: FixtureOptions = {}): ApiProxy {
           }
         }
         const created: SessionSummary = {
-          sessionId: requestedId ?? sid(`fx-${nextSession++}`), updatedAt: Date.now(), running: false, cwd,
+          sessionId: requestedId ?? sid(`fx-${nextSession++}`), updatedAt: Date.now(), running: false, blank: true, cwd,
         }
         sessions.push(created)
         attachedSessions += 1
         const emitSession = (): void => {
-          emitHost({ type: 'host/session-added', sessionId: created.sessionId, cwd })
+          // Mirrors the host: the frame fires at creation, so blank is constantly true.
+          emitHost({ type: 'host/session-added', sessionId: created.sessionId, blank: true, cwd })
         }
         if (workspace !== undefined && options.failWorkspaceAttach) {
           emitSession()
@@ -628,6 +640,8 @@ export function createFixtureApi(options: FixtureOptions = {}): ApiProxy {
           })
         }
         summary.updatedAt = Date.now()
+        // First accepted prompt appends events: the summary stops being blank.
+        summary.blank = false
         const userText = content.map(b => (b.type === 'text' ? b.text : '')).join('')
         if (mode === 'steer' && replays.has(id)) {
           // Steering: insert a steering message into the current turn; the replay continues.
@@ -738,6 +752,52 @@ export function createFixtureApi(options: FixtureOptions = {}): ApiProxy {
         return ok(request, { workspace: { ...workspace } })
       },
     },
+    commands: {
+      // The catalog mirrors one session's effective view (every fixture
+      // session has an agent, like the real host).
+      list: (request) => {
+        const missing = requireSession(request)
+        if (missing !== undefined) return missing
+        return ok(request, {
+          commands: [
+            { name: 'compact', description: 'fixture：压缩当前会话上下文' },
+            { name: 'echo', description: 'fixture：回显参数', input: { hint: 'text to echo' } },
+            { name: 'goal-fixture', description: 'fixture：目标样本命令', input: { hint: '<objective>' } },
+          ],
+        })
+      },
+      execute: (request) => {
+        const missing = requireSession(request)
+        if (missing !== undefined) return missing
+        const line = request.payload.line.trim()
+        const match = /^\/(\S+)(?:\s+(.*))?$/.exec(line)
+        const name = match?.[1]
+        if (name === 'compact' || name === 'echo') {
+          return ok(request, {
+            matched: true as const,
+            result: { kind: 'success' as const, text: name === 'echo' ? (match?.[2] ?? '') : 'fixture：已压缩（假动作）' },
+          })
+        }
+        if (name === 'goal-fixture') {
+          return ok(request, {
+            matched: true as const,
+            result: { kind: 'success' as const, text: `fixture：goal 已设置（${request.payload.sessionId}）` },
+          })
+        }
+        return ok(request, { matched: false as const })
+      },
+    },
+    skills: {
+      list: (request) => {
+        const missing = requireSession(request)
+        if (missing !== undefined) return missing
+        return ok(request, {
+          skills: [
+            { name: 'fixture-demo', description: 'fixture 技能样本', whenToUse: '仅供 UI 目录渲染验收' },
+          ],
+        })
+      },
+    },
     events: {
       async *mux(_request, signal) {
         const conn = new FxInbox<MuxFrame>()
@@ -855,6 +915,10 @@ export class FixtureApiClient extends AbstractApiClient {
       case 'workspace.create': return this.api.workspace.create(request)
       case 'workspace.rename': return this.api.workspace.rename(request)
       case 'workspace.insertSessionBefore': return this.api.workspace.insertSessionBefore(request)
+      case 'command.list': return this.api.commands.list(request)
+      // The in-memory execute never blocks, so a never-aborting signal is faithful here.
+      case 'command.execute': return this.api.commands.execute(request, new AbortController().signal)
+      case 'skill.list': return this.api.skills.list(request)
     }
   }
 

packages/client/connection/src/client/index.ts

@@ -14,6 +14,7 @@ export type {
   ApiProxy, SessionsApi, SessionSummary, HostApi, EventsApi, MuxFrame, HostFrame,
   ApprovalResponsePayload, QuestionResponsePayload, HistoryEntry, ToolEventView,
   ToolCallView, ToolResultView, WorkspaceApi, WorkspaceId, WorkspaceView,
+  CommandsApi, CommandDescriptor, CommandExecuteResult, SkillsApi, SkillEntry,
   RpcRequest, RpcResponse, RpcResult, RpcError, RpcErrorCode,
   ClientRequest, ServerResponse, ServerRequest, ClientResponse, RpcMessage, RpcReceipt,
   IApiClient, SessionId, SessionEvent, ContentBlock, StreamChunk,

packages/client/connection/tests/fake-api.ts

@@ -2,7 +2,8 @@
 // data source on a real clock; behavior tests need per-case responses and
 // deferred-controlled timing). Streams are hand pumps: pushMux/pushHost.
 import type {
-  HostFrame, IApiClient, MuxFrame, RpcRequest, RpcResponse, SessionId,
+  CommandDescriptor, CommandExecuteResult, HostFrame, IApiClient, MuxFrame,
+  RpcRequest, RpcResponse, SessionId, SkillEntry,
 } from '../src/client/api.ts'
 import { RpcId } from '../src/client/api.ts'
 
@@ -85,6 +86,24 @@ export class FakeApiClient implements IApiClient {
     }))),
   }
 
+  // Payloads stay `unknown` (lint-lane note above); response rows are the real
+  // wire shapes so cases can program catalogs and skill lists without casts.
+  onCommandList: (payload: unknown) => Promise<RpcResponse<{ commands: CommandDescriptor[] }>>
+    = () => Promise.resolve(ok({ commands: [] }))
+  onCommandExecute: (payload: unknown) => Promise<RpcResponse<{ matched: boolean; result?: CommandExecuteResult }>>
+    = () => Promise.resolve(ok({ matched: false }))
+  onSkillList: (payload: unknown) => Promise<RpcResponse<{ skills: SkillEntry[] }>>
+    = () => Promise.resolve(ok({ skills: [] }))
+
+  readonly commands: IApiClient['commands'] = {
+    list: (payload: unknown) => this.record('command.list', payload, this.onCommandList(payload)),
+    execute: (payload: unknown) => this.record('command.execute', payload, this.onCommandExecute(payload)),
+  }
+
+  readonly skills: IApiClient['skills'] = {
+    list: (payload: unknown) => this.record('skill.list', payload, this.onSkillList(payload)),
+  }
+
   /** When true, streams never fire onOpen (misbehaving-carrier material for the handshake timeout guard). */
   suppressStreamOpen = false
 

packages/client/connection/tests/fixture-commands.spec.ts

@@ -0,0 +1,92 @@
+/**
+ * Fixture commands/skills domains: contract-shape conformance for the two
+ * domains added to ApiProxy — rpcId echo, session-addressed catalogs, execute
+ * parse/dispatch, skill.list session resolution, and the FixtureApiClient
+ * dispatch rows.
+ */
+import { describe, expect, it } from 'vitest'
+import type { SessionId } from '../src/client/api.ts'
+import { RpcId } from '../src/client/api.ts'
+import type { RpcRequest } from '../src/client/api.ts'
+import { FixtureApiClient, createFixtureApi } from '../src/client/fixture.ts'
+
+const sid = (id: string): SessionId => id as SessionId
+let reqCount = 0
+const req = <P>(payload: P): RpcRequest<P> => ({ rpcId: RpcId(`t-${reqCount++}`), payload })
+const signal = new AbortController().signal
+
+describe('createFixtureApi commands/skills', () => {
+  it('serves the addressed session catalog with rpcId echo', async () => {
+    const api = createFixtureApi()
+    const request = req({ sessionId: sid('fx-alpha') })
+    const response = await api.commands.list(request)
+    expect(response.rpcId).toBe(request.rpcId)
+    if (!response.result.ok) throw new Error('list failed')
+    const commands = response.result.value.commands
+    expect(commands.map(c => c.name)).toEqual(['compact', 'echo', 'goal-fixture'])
+    // input hint rides only the commands declaring it.
+    const echo = commands.find(c => c.name === 'echo')
+    expect(echo?.input?.hint).toBeTruthy()
+    expect(commands.find(c => c.name === 'compact')?.input).toBeUndefined()
+  })
+
+  it('rejects a catalog request for an unknown session', async () => {
+    const api = createFixtureApi()
+    const response = await api.commands.list(req({ sessionId: sid('fx-nope') }))
+    expect(response.result).toMatchObject({ ok: false, error: { code: 'session-not-found' } })
+  })
+
+  it('executes a known command line and reports matched with a result', async () => {
+    const api = createFixtureApi()
+    const response = await api.commands.execute(req({ sessionId: sid('fx-alpha'), line: '/echo hello world' }), signal)
+    if (!response.result.ok) throw new Error('execute failed')
+    expect(response.result.value.matched).toBe(true)
+    expect(response.result.value.result).toEqual({ kind: 'success', text: 'hello world' })
+  })
+
+  it('addresses execute to the session (result text carries the id)', async () => {
+    const api = createFixtureApi()
+    const hit = await api.commands.execute(req({ sessionId: sid('fx-alpha'), line: '/goal-fixture ship' }), signal)
+    if (!hit.result.ok) throw new Error('execute failed')
+    expect(hit.result.value.matched).toBe(true)
+    expect(hit.result.value.result?.text).toContain('fx-alpha')
+
+    const missing = await api.commands.execute(req({ sessionId: sid('fx-nope'), line: '/goal-fixture ship' }), signal)
+    expect(missing.result).toMatchObject({ ok: false, error: { code: 'session-not-found' } })
+  })
+
+  it('falls to matched:false on unknown names and non-command lines', async () => {
+    const api = createFixtureApi()
+    for (const line of ['/nope', 'plain text', '/']) {
+      const response = await api.commands.execute(req({ sessionId: sid('fx-alpha'), line }), signal)
+      if (!response.result.ok) throw new Error('execute failed')
+      expect(response.result.value.matched).toBe(false)
+      expect(response.result.value.result).toBeUndefined()
+    }
+  })
+
+  it('serves the skill catalog for the addressed session and rejects unknown sessions', async () => {
+    const api = createFixtureApi()
+    const response = await api.skills.list(req({ sessionId: sid('fx-alpha') }))
+    if (!response.result.ok) throw new Error('skill list failed')
+    expect(response.result.value.skills[0]?.name).toBe('fixture-demo')
+
+    const missingSession = await api.skills.list(req({ sessionId: sid('fx-nope') }))
+    expect(missingSession.result).toMatchObject({ ok: false, error: { code: 'session-not-found' } })
+  })
+})
+
+describe('FixtureApiClient command/skill dispatch', () => {
+  it('routes the three method keys through the in-memory dispatch table', async () => {
+    const client = new FixtureApiClient()
+    const list = await client.commands.list({ sessionId: sid('fx-alpha') })
+    if (!list.result.ok) throw new Error('command.list failed')
+    expect(list.result.value.commands.length).toBeGreaterThan(0)
+    const executed = await client.commands.execute({ sessionId: sid('fx-alpha'), line: '/compact' })
+    if (!executed.result.ok) throw new Error('command.execute failed')
+    expect(executed.result.value.matched).toBe(true)
+    const skills = await client.skills.list({ sessionId: sid('fx-alpha') })
+    if (!skills.result.ok) throw new Error('skill.list failed')
+    expect(skills.result.value.skills.length).toBeGreaterThan(0)
+  })
+})

packages/client/connection/tests/fixture.spec.ts

@@ -87,7 +87,7 @@ describe('createFixtureApi', () => {
     await consuming
     if (!created.result.ok) throw new Error('create failed')
     const createdId = created.result.value.sessionId
-    expect(seen).toEqual([{ type: 'host/session-added', sessionId: createdId, cwd: '/tmp/fixture' }])
+    expect(seen).toEqual([{ type: 'host/session-added', sessionId: createdId, blank: true, cwd: '/tmp/fixture' }])
     const list = await api.sessions.list(req({}))
     if (!list.result.ok) throw new Error('list failed')
     expect(list.result.value.items.some(s => s.sessionId === createdId)).toBe(true)
@@ -384,7 +384,7 @@ describe('createFixtureApi', () => {
     await consuming
     // The session lands with the workspace's path as cwd, and the account
     // write pushes the fresh workspace snapshot after session-added.
-    expect(seen[0]).toEqual({ type: 'host/session-added', sessionId: id, cwd: '/tmp/fixture' })
+    expect(seen[0]).toEqual({ type: 'host/session-added', sessionId: id, blank: true, cwd: '/tmp/fixture' })
     expect(seen[1]).toMatchObject({
       type: 'host/workspace-changed',
       workspace: { workspaceId: 'fx-ws-fixture', sessionIds: [id, 'fx-alpha', 'fx-beta', 'fx-gamma'] },
@@ -413,7 +413,7 @@ describe('createFixtureApi', () => {
     expect(frames[0]).toMatchObject({
       type: 'host/workspace-changed', workspace: { sessionIds: [preallocated] },
     })
-    expect(frames[1]).toEqual({ type: 'host/session-added', sessionId: preallocated, cwd: made.result.value.workspace.path })
+    expect(frames[1]).toEqual({ type: 'host/session-added', sessionId: preallocated, blank: true, cwd: made.result.value.workspace.path })
 
     const retried = await api.sessions.create(req({
       workspaceId: made.result.value.workspace.workspaceId,

packages/client/locale/tests/language-row.spec.tsx

@@ -16,12 +16,12 @@ const OPTIONS = [{ id: 'zh', label: '中文' }, { id: 'en', label: 'English' }]
 /** Empty global standard-kit hooks (the row reads neither). */
 function emptySessions() {
   const store = createSnapshotStore<SessionListState>(
-    { ids: [], byId: {}, current: undefined, intent: undefined, phase: 'ready' })
+    { ids: [], byId: {}, current: undefined, phase: 'ready' })
   return bindSnapshotSelector(store)
 }
 function emptyWorkspaces() {
   const store = createSnapshotStore<WorkspaceListState>({
-    items: [], intent: undefined, state: 'idle', phase: 'ready', error: null,
+    items: [], state: 'idle', phase: 'ready', error: null,
     baselinesReady: true, recentWorkspaceId: undefined,
   })
   return bindSnapshotSelector(store)

packages/client/runtime/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
-README.md: 7776a5c2cf1d0990c9c339c6e5fc66401f935810
-README.zh.md: 8a0b7394c07878b8de958eae43d11203c92b5827
+README.md: 4724ebc75d441252245a0e811a4ae34f8b529a98
+README.zh.md: 6a0076742efccaf946910c77c77a9b74194b9dc5

packages/client/runtime/README.md

@@ -2,7 +2,7 @@
 
 English | [中文](README.zh.md)
 
-Client cordis boot and React-free object services: SlotsService wraps SlotCore and supplies renderer data sources; SessionsService owns Session objects, list/scope/history state, and page-local Session Intent state; WorkspacesService depends on SessionsService and owns Workspace objects, list/actions, page-local Workspace Intent state, default-target derivation, and the cross-object New Session flow. The runtime fans the shared Host stream into both managers. Contract: api-contracts v3 §4.
+Client cordis boot and React-free object services: SlotsService wraps SlotCore and supplies renderer data sources; SessionsService owns Session objects, list/scope/history state; WorkspacesService depends on SessionsService and owns Workspace objects, list/actions, default-target derivation, and the New Session blank-reuse entry (`connectWorkspace`). The runtime fans the shared Host stream into both managers. Client sessions are always Host-born (Session+Agent+cwd in one `session.create`); the client holds no pre-entity session state — a session's Agent scope (the client mirror of host dsh-scope, keyed by the shared agent/session id) is born when its row enters the list mirror and dies with the prune. Contract: api-contracts v3 §4.
 
 ## Workspace and Session lists
 
@@ -10,9 +10,9 @@ Workspace and Session lists have independent monotone `pending` → `ready` base
 
 SlotsService gives the renderer separate bare observables for `useSessions` and `useWorkspaces`; web-react creates the hooks. Workspace business state does not enter `SessionListState` or an entry store.
 
-## Session creation failures
+## New Session and the blank mirror
 
-`SessionsService.create` accepts an optional caller-preallocated SessionId. It throws `SessionCreateError` on failure: `requestedSessionId` remains available after transport uncertainty, while `publishedSessionId` is set when `workspace-attach-failed` proves the Host published a real Session before attachment failed. For the New Session flow, the frontend Session object owns its retained prompt and advances it through attachment and send; a partially published Session keeps the same object and prompt while it appears as Ungrouped.
+`WorkspacesService.connectWorkspace(workspaceId)` resolves the session a New Session flow lands in: it reuses the workspace's existing blank session from the list mirror (`blank && cwd == workspace.path`) or calls `session.create({workspaceId})`, returning the session id for the caller to open. `SessionSummary.blank` mirrors the host's derived empty-log bit and only ever lowers on the client: seeded by `session.list` / the `host/session-added` frame, flipped false by the first ACCEPTED local `prompt()` (on the RPC success response — acceptance proves the user message is in the host log; a rejected first prompt keeps the session blank and reusable) and by any `running: true` status frame, re-aligned by every list re-pull. List surfaces hide blank rows; the store carries every row. `SessionsService.create` accepts an optional caller-preallocated SessionId and throws `SessionCreateError` (carrying `requestedSessionId`) on failure.
 
 ## Code Mode sub-dispatch index
 
@@ -33,5 +33,5 @@ None; this package neither assembles nor sends a provider request.
 ## Known Limitations and Deferred Work
 
 - **`loader.unload` is a stub (throws not-implemented)** — the full chain (fiber dispose → registration cascade → style removal) lands with the HMR project.
-- **Scope teardown is stage-driven, single-occupant today** — the staged session follows `list.current` exactly (staging is the open signal: the event window opens ⟺ the session is on stage); a removed-while-staged session's scope survives frozen until the stage moves on, not until true observer count reaches zero. Resolution (`cell()`/`binding()`/`scope()`) is pure addressing, render-safe. The staged state can widen to a multi-pane list when concurrent panes land.
+- **Scope teardown is stage-driven, single-occupant today** — the staged session follows `list.current` exactly (staging is the open signal: the event window opens ⟺ the session is on stage); a removed-while-staged session's scope survives frozen until the stage moves on, not until true observer count reaches zero. Resolution (`provideInfo()`/`binding()`/`scope()`) is pure addressing, render-safe. The staged state can widen to a multi-pane list when concurrent panes land.
 - **Value imports of this package from plugin bundles must use the `/client` subpath** — the bare package name is not in the loader externals table and inlines a second module instance, whose private scope-tag Symbol never matches (the empty-state P0 postmortem).

packages/client/runtime/README.zh.md

@@ -2,7 +2,7 @@
 
 [English](README.md) | 中文
 
-客户端 cordis 启动与不依赖 React 的对象服务：SlotsService 包装 SlotCore 并提供 renderer 数据源；SessionsService 拥有 Session 对象、列表／scope／history 状态和页面局部 Session Intent 状态；WorkspacesService 依赖 SessionsService，拥有 Workspace 对象、列表／操作、页面局部 Workspace Intent 状态、默认目标派生，以及跨对象 New Session 流程。运行时把共享 Host 流分发给两个 manager。契约：api-contracts v3 §4。
+客户端 cordis 启动与不依赖 React 的对象服务：SlotsService 包装 SlotCore 并提供 renderer 数据源；SessionsService 拥有 Session 对象、列表／scope／history 状态；WorkspacesService 依赖 SessionsService，拥有 Workspace 对象、列表／操作、默认目标派生，以及 New Session 空会话复用入口（`connectWorkspace`）。运行时把共享 Host 流分发给两个 manager。客户端 Session 一律由 Host 出生（一次 `session.create` 同瞬产出 Session+Agent+cwd）；客户端不持有任何实体化之前的会话状态——Agent scope（host dsh-scope 的客户端镜像，以 agent/session 共用 id 为键）在会话行进入列表镜像时出生，随 prune 死亡。契约：api-contracts v3 §4。
 
 ## Workspace 与 Session 列表
 
@@ -10,9 +10,9 @@ Workspace 和 Session 列表各自具有单调的 `pending` → `ready` 基线
 
 SlotsService 分别为 renderer 提供 `useSessions` 与 `useWorkspaces` 的裸 observable；web-react 创建 hook。Workspace 业务状态不会进入 `SessionListState` 或配置项 store。
 
-## Session 创建失败
+## New Session 与 blank 镜像
 
-`SessionsService.create` 接受可选的、由调用方预先分配的 SessionId。失败时抛出 `SessionCreateError`：传输状态不确定后仍可取得 `requestedSessionId`；如果 Host 在附加失败前已经发布真实 Session，则会设置 `publishedSessionId`，此时 `workspace-attach-failed` 提供了证明。在 New Session 流程中，前端 Session 对象拥有其保留的提示词，并推动提示词完成附加与发送；部分发布的 Session 会保留同一对象和提示词，同时显示为 Ungrouped。
+`WorkspacesService.connectWorkspace(workspaceId)` 解析 New Session 流程最终落入的会话：先在列表镜像中复用该 workspace 的既有空会话（`blank && cwd == workspace.path`），未命中则调用 `session.create({workspaceId})`，返回会话 id 由调用方 open。`SessionSummary.blank` 镜像主机派生的空日志位，在客户端只降不升：由 `session.list`／`host/session-added` 帧播种，本地首次**受理成功**的 `prompt()`（RPC 成功响应时——受理即证明用户消息已入主机日志；首讯被拒则会话保持 blank、保持可复用）与任何 `running: true` 状态帧翻为 false，每次列表重拉重新对齐。列表表面隐藏 blank 行；store 保留全部行。`SessionsService.create` 接受可选的、由调用方预先分配的 SessionId，失败时抛出 `SessionCreateError`（携带 `requestedSessionId`）。
 
 ## Code Mode 子调用索引
 
@@ -33,5 +33,5 @@ SlotsService 分别为 renderer 提供 `useSessions` 与 `useWorkspaces` 的裸
 ## 已知限制与暂缓事项
 
 - **`loader.unload` 是 stub（抛出 not-implemented）**：完整链路（fiber 释放 → 注册级联 → 样式移除）随 HMR 项目落地。
-- **scope 拆卸由阶段驱动，目前只能有一个占用者**：已 staged 的 Session 精确跟随 `list.current`（staging 就是打开信号：事件窗口打开 ⟺ Session 位于 stage）；在 staged 状态下被移除的 Session，其 scope 会冻结保留，直到 stage 转向其他 Session，而非直到真实观察者数量降为零。解析（`cell()`／`binding()`／`scope()`）只是纯寻址，可安全用于渲染。并发 pane 落地时，staged 状态可以扩展为多 pane 列表。
+- **scope 拆卸由阶段驱动，目前只能有一个占用者**：已 staged 的 Session 精确跟随 `list.current`（staging 就是打开信号：事件窗口打开 ⟺ Session 位于 stage）；在 staged 状态下被移除的 Session，其 scope 会冻结保留，直到 stage 转向其他 Session，而非直到真实观察者数量降为零。解析（`provideInfo()`／`binding()`／`scope()`）只是纯寻址，可安全用于渲染。并发 pane 落地时，staged 状态可以扩展为多 pane 列表。
 - **插件组合包从该包执行值导入时必须使用 `/client` 子路径**：裸包名不在 loader external 表中，会内联第二个模块实例；其私有 scope-tag Symbol 永远无法匹配（空状态 P0 事故复盘）。

packages/client/runtime/src/client/agents/scope.ts

@@ -0,0 +1,70 @@
+/**
+ * Client Agent-scope primitive: mint a Cordis context tagged with the owning
+ * Agent's identity. The mechanism mirrors the host `dsh-scope` architecture
+ * (no-op plugin fiber + context tag + `Context.filter` routing predicate);
+ * the shape deliberately diverges: the filter lives on the actx itself
+ * instead of a separate carrier object, so scoped dispatch is plain cordis —
+ * `actx.bail(actx, event, payload)` / `actx.emit(actx, ...)` — with no
+ * wrapper. The host needs a detached carrier because its dispatch subject is
+ * the business Agent object; client scope events carry only ids, so the
+ * actx is the natural subject. The second divergence stands: the scope key
+ * is the branded `SessionId` (value compared), not an object identity — the
+ * agent and its session share one id (1:1, same axis; no separate AgentId
+ * brand), and a client scope's identity IS that wire id. Third divergence,
+ * deliberate: the client scopes the Agent IDENTITY, not a live Agent object
+ * — a cold session's host Agent is already disposed while its client actx
+ * stays alive for history viewing.
+ */
+import { Context as CordisContext } from 'cordis'
+import type { Context, Fiber } from 'cordis'
+import type { SessionId } from '@deepseek-ai/dsh-client-connection/client'
+
+/** Context tag written by {@link createScope}. */
+const kScope = Symbol('dsh.client.scope')
+
+/** A minted Agent scope and its disposal boundary. */
+export interface AgentScopeHandle {
+  /**
+   * Tagged context: scope-owned registrations and scoped dispatch both go
+   * through it (passing it as the dispatch subject routes to this agent's
+   * tagged listeners plus every untagged one).
+   */
+  ctx: Context
+  /** Backing fiber (dispose tears down every scope-owned registration). */
+  fiber: Fiber
+}
+
+/** Shared no-op plugin backing each Agent scope fiber. */
+function agentScope(): void {}
+
+/**
+ * Mint an Agent scope under `ctx`: a no-op plugin fiber whose context
+ * carries the agent tag and the dispatch filter — untagged listeners are
+ * admitted globally, tagged listeners only for a matching agent.
+ * Registrations through the returned ctx dispose with the fiber.
+ * @param ctx - client root context the scope fiber mounts under.
+ * @param key - owning agent identity (the routing tag; agent id === session id).
+ * @returns the tagged context and its backing fiber.
+ */
+export function createScope(ctx: Context, key: SessionId): AgentScopeHandle {
+  const fiber = ctx.plugin(agentScope)
+  return {
+    fiber,
+    ctx: fiber.ctx.extend({
+      [kScope]: key,
+      [CordisContext.filter](listenerCtx: Context): boolean {
+        const tag = scopeOf(listenerCtx)
+        return tag === undefined || tag === key
+      },
+    }),
+  }
+}
+
+/**
+ * Read the nearest agent tag inherited by a context.
+ * @param ctx - any client context.
+ * @returns its agent identity (the session id), or undefined for root contexts.
+ */
+export function scopeOf(ctx: Context): SessionId | undefined {
+  return (ctx as Context & { [kScope]?: SessionId })[kScope]
+}

packages/client/runtime/src/client/index.ts

@@ -1,7 +1,7 @@
 /** Browser runtime services for slots, sessions, workspaces, and connection-stream delivery. */
 import type { Context } from 'cordis'
 import type { ConnectionHandle, SessionId } from '@deepseek-ai/dsh-client-connection/client'
-import type { SnapshotSelectorHook } from '@deepseek-ai/dsh-client-ui-slots'
+import type { MaybeSnapshotSelectorHook, SnapshotSelectorHook } from '@deepseek-ai/dsh-client-ui-slots'
 import { SlotsService } from './slots.ts'
 import { SessionsService } from './sessions/service.ts'
 import type { SessionListState } from './sessions/service.ts'
@@ -11,10 +11,14 @@ import type { ConversationSnapshot, RunningToolCall, ToolResultNode } from './se
 export { SlotsService } from './slots.ts'
 export type { RootOwnerProps } from './slots.ts'
 export { SessionCreateError, SessionsService, scopeOf, workspaceTitleOf } from './sessions/service.ts'
+export { createScope } from './agents/scope.ts'
+export type { AgentScopeHandle } from './agents/scope.ts'
 export { WorkspacesService } from './workspaces/service.ts'
 export type { Session } from './sessions/session.ts'
-export type { SessionBinding, SessionListState, SessionSummary } from './sessions/service.ts'
-export type { SessionIntentListSnapshot, SessionListPhase } from './sessions/manager.ts'
+export type {
+  SessionBinding, SessionListState, SessionProvideContribution, SessionProvideDescriptor, SessionSummary,
+} from './sessions/service.ts'
+export type { SessionListPhase } from './sessions/manager.ts'
 export type { WorkspaceListPhase } from './workspaces/manager.ts'
 export type { WorkspaceListState } from './workspaces/service.ts'
 export type { WorkspaceId, WorkspaceView } from '@deepseek-ai/dsh-client-connection/client'
@@ -25,7 +29,7 @@ export type {
 } from './contract/store.ts'
 export type {
   AssistantBlock, AssistantMessageNode, CodeSubCall, ComposerPhase, ContextMessageNode, ConversationNode,
-  ConversationSnapshot, PendingPrompt, RunningToolCall, SessionIntentSnapshot, SessionIntentTarget,
+  ConversationSnapshot, QueuedMessage, RunningToolCall,
   SteeringMessageNode, ToolResultNode, UnknownSurfaceNode, UserMessageNode,
 } from './sessions/conversation.ts'
 export { PendingWait } from './sessions/pending.ts'
@@ -56,6 +60,12 @@ declare module '@deepseek-ai/dsh-client-ui-slots' {
     /** The framework-resolved session id (owners never pass it). */
     sessionId: SessionId
   }
+  /** Standard kit for slots that remain mounted while current session changes. */
+  interface SessionMaybeStandardProps {
+    useSession: MaybeSnapshotSelectorHook<ConversationSnapshot>
+    /** Current session id; absent in the no-session state. */
+    sessionId: SessionId | undefined
+  }
   /** Props injected into every global slot component. */
   interface GlobalStandardProps {
     useSessions: SnapshotSelectorHook<SessionListState>
@@ -72,6 +82,20 @@ declare module 'cordis' {
      * @param key - the mutated SlotMap key.
      */
     'slots/changed'(key: string): void
+    /**
+     * The host command registry changed (host/commands-changed passthrough).
+     * Pure invalidation signal: subscribers refetch `command.list` in the
+     * background rather than diffing.
+     * @mode emit
+     */
+    'commands/changed'(): void
+    /**
+     * A connection generation was (re-)established. Wire-derived caches must
+     * treat their state as stale and repull (commands directory; the queue
+     * mirrors reset themselves through the session resync path).
+     * @mode emit
+     */
+    'connection/reset'(): void
   }
   interface Context {
     slots: import('./slots.ts').SlotsService
@@ -91,15 +115,23 @@ export function apply(ctx: Context): void {
   const connection = ctx.get('connection') as ConnectionHandle
   const sessions = new SessionsService(ctx, connection.api)
   const workspaces = new WorkspacesService(ctx, connection.api, sessions)
+  ctx.effect(
+    () => workspaces.startInitialSelection(),
+    'runtime: initial Workspace selection',
+  )
   const loop = connection.start({
     onMuxEnvelope: (envelope) => { sessions.handleMuxEnvelope(envelope) },
     onHostEnvelope: (envelope) => {
       sessions.handleHostEnvelope(envelope)
       workspaces.handleHostEnvelope(envelope)
+      // Typed-event bridge: the session layer ignores registry frames (no
+      // session routing); consumers (command directory caches) subscribe on ctx.
+      if (envelope.payload.type === 'host/commands-changed') ctx.emit('commands/changed')
     },
     onConnected: () => {
       sessions.handleConnected()
       workspaces.handleConnected()
+      ctx.emit('connection/reset')
     },
   })
   ctx.effect(() => () => { loop.stop() }, 'runtime: connection stream loop')

packages/client/runtime/src/client/sessions/conversation.ts

@@ -5,7 +5,7 @@
 
 import type { ContentBlock } from '@deepseek-ai/dsh-llm/types'
 import type {
-  RpcError, SessionId, ToolCallView, ToolResultView, WorkspaceId,
+  RpcError, SessionId, ToolCallView, ToolResultView,
 } from '@deepseek-ai/dsh-client-connection/client'
 import type { PendingInteraction } from './pending.ts'
 
@@ -156,6 +156,12 @@ export interface RunningToolCall {
 }
 
 
+/** One queued-message row mirrored from `session/queued` frames (key: the enqueueing prompt's rpcId when wire-sourced). */
+export interface QueuedMessage {
+  readonly key: string
+  readonly preview: string
+}
+
 /** In-progress assistant output (chunk accumulator product). */
 export interface PartialAssistant {
   turn: number
@@ -194,30 +200,6 @@ export interface PromptError {
   error: RpcError
 }
 
-/** Workspace target of a frontend-only Session. */
-export type SessionIntentTarget =
-  | { kind: 'workspace'; workspaceId: WorkspaceId }
-  | { kind: 'workspace-intent' }
-
-/** Publication state owned by a frontend Session before it joins the Host. */
-export interface SessionIntentSnapshot {
-  target: SessionIntentTarget
-  phase: 'ready' | 'connecting'
-  error?: { step: 'session'; message: string }
-}
-
-/** One editable prompt retained by its Session until the Host accepts it. */
-export interface PendingPrompt {
-  text: string
-  phase: 'editing' | 'sending' | 'failed'
-  /** Failed prerequisite retried before sending, or the send itself. */
-  retry: 'connect' | 'send'
-  /** Workspace needed when retrying Session attachment. */
-  workspaceId?: WorkspaceId
-  /** Last failure diagnostic, absent while editing or sending. */
-  error?: string
-}
-
 /** The immutable snapshot contract Session hands to uSES (see the web client architecture RFC). */
 export interface ConversationSnapshot {
   sessionId: SessionId
@@ -235,6 +217,8 @@ export interface ConversationSnapshot {
    */
   codeDispatches: ReadonlyMap<string, readonly CodeSubCall[]>
   pending: readonly PendingInteraction[]
+  /** Read-only inbox mirror (session/queued frames + mux-open baseline; cleared by the leave-running flip). */
+  queue: readonly QueuedMessage[]
   running: boolean
   /** Input-area shape (see {@link ComposerPhase}); derived here, switched on by consumers. */
   composerPhase: ComposerPhase
@@ -245,9 +229,16 @@ export interface ConversationSnapshot {
   hasMore: boolean
   loadingOlder: boolean
   promptError: PromptError | null
-  /** Frontend-only publication state; null for a Host-connected Session. */
-  intent: SessionIntentSnapshot | null
-  /** Session-owned editable prompt waiting for connection, attachment, or send. */
-  pendingPrompt: PendingPrompt | null
+  /**
+   * Whether this session still has an empty log (no user message yet).
+   * Mirrors the host summary's derived blank bit: seeded from `session.list`
+   * / the `host/session-added` frame, flipped false by the first ACCEPTED
+   * prompt locally (on the RPC success response — acceptance proves the
+   * user message is in the host log; a rejected first prompt keeps the
+   * session blank and reusable) and by any `running: true` status remotely,
+   * and re-aligned by every list re-pull (the summary stays authoritative).
+   * Blank sessions are hidden from session lists and reused by New Session.
+   */
+  blank: boolean
   lastAgentError: string | null
 }

packages/client/runtime/src/client/sessions/lineage.ts

@@ -15,6 +15,8 @@ export interface SessionListEntry {
   title?: string
   updatedAt: number
   running: boolean
+  /** Empty-log bit mirrored from the summary; lists hide blank sessions (filtering stays with the consumer). */
+  blank: boolean
   parentSessionId?: SessionId
   cwd?: string
   /** Lineage indent depth: root = 0; the UI just multiplies by the indent width. */

packages/client/runtime/src/client/sessions/manager.ts

@@ -11,7 +11,6 @@ import type { SessionListEntry, TitledSessionSummary } from './lineage.ts'
 import { flattenLineage } from './lineage.ts'
 import { Notifier } from './notifier.ts'
 import { Session } from './session.ts'
-import type { SessionIntentSnapshot, SessionIntentTarget } from './conversation.ts'
 
 /**
  * List arrival lifecycle, orthogonal to the pull-activity `state` axis:
@@ -23,19 +22,11 @@ import type { SessionIntentSnapshot, SessionIntentTarget } from './conversation.
  */
 export type SessionListPhase = 'pending' | 'ready'
 
-/** Session-owned frontend Intent projected into the global list snapshot. */
-export interface SessionIntentListSnapshot extends SessionIntentSnapshot {
-  sessionId: SessionId
-  prompt: string
-}
-
 /** Immutable session-list snapshot for useSessionList. */
 export interface SessionListSnapshot {
   items: readonly SessionListEntry[]
-  /** Selected real or frontend-only Session id. */
+  /** Selected Session id (validated against items; masked to undefined while its session is off the list). */
   current: SessionId | undefined
-  /** Sole page-local frontend Session projection; its state remains owned by Session. */
-  intent: SessionIntentListSnapshot | undefined
   state: 'idle' | 'loading' | 'error'
   /** Arrival lifecycle (see {@link SessionListPhase}); `state` stays the pull-activity axis. */
   phase: SessionListPhase
@@ -46,6 +37,8 @@ type SessionListMutation =
   | { kind: 'upsert'; summary: SessionSummary }
   | { kind: 'remove'; sessionId: SessionId }
   | { kind: 'status'; sessionId: SessionId; running: boolean }
+  /** Local first-send flip: the sender clears blank without waiting for a host frame. */
+  | { kind: 'engaged'; sessionId: SessionId }
 
 /** Per-session cap for pre-instantiation approval/question buffering (low-frequency frames; a few dozen covers any real backlog). */
 const PENDING_BUFFER_CAP = 32
@@ -76,8 +69,6 @@ export class SessionManager {
   private listMutations: SessionListMutation[] | null = null
 
   private selected: SessionId | undefined
-  private intentSessionId: SessionId | undefined
-  private stopIntentWatch: (() => void) | undefined
 
   private listSnapshotCache: SessionListSnapshot
   /** Entry-identity cache (§C.2 reference stability): list rebuilds reuse the previous entry
@@ -101,87 +92,38 @@ export class SessionManager {
     this.listSnapshotCache = this.buildListSnapshot()
   }
 
-  // ---- Selection and client-local intents ----
+  // ---- Selection ----
 
   /**
-   * Select a real Session and discard the unmaterialized intent.
-   * @param sessionId - listed real Session id.
+   * Select a listed Session.
+   * @param sessionId - listed Session id.
    */
   select(sessionId: SessionId): void {
     if (!this.summaries.some(summary => summary.sessionId === sessionId)) {
       throw new Error(`sessions.select: unknown session ${sessionId}`)
     }
-    this.discardIntent()
     this.selected = sessionId
     this.notifier.notifyNow()
   }
 
-  /** Clear selection and abandon any frontend-only Session. */
+  /** Clear the selection (the layout falls to the no-session view state). */
   clearSelection(): void {
-    this.discardIntent()
     this.selected = undefined
     this.notifier.notifyNow()
   }
 
-  /**
-   * Start a frontend Session against a real or still-local Workspace target.
-   * @param target - real Workspace or the WorkspacesService-owned local target.
-   * @param prompt - optional prompt retained when retargeting from a picker.
-   * @returns the frontend Session object that owns the Intent.
-   */
-  startIntent(target: SessionIntentTarget, prompt = ''): Session {
-    this.discardIntent()
-    const sessionId = `client-session-${crypto.randomUUID()}` as SessionId
-    const session = this.createSession(sessionId, { target, prompt })
-    this.sessions.set(sessionId, session)
-    this.intentSessionId = sessionId
-    this.selected = sessionId
-    this.stopIntentWatch = session.subscribe(() => {
-      if (this.intentSessionId !== sessionId) return
-      if (session.getSnapshot().intent === null) {
-        this.intentSessionId = undefined
-        this.stopIntentWatch?.()
-        this.stopIntentWatch = undefined
-      }
-      this.notifier.markDirty()
-    })
-    this.notifier.notifyNow()
-    return session
-  }
-
-  /**
-   * Resolve the active frontend Session Intent.
-   * @returns the active frontend Session, if one remains selected.
-   */
-  getIntent(): Session | undefined {
-    return this.intentSessionId === undefined ? undefined : this.sessions.get(this.intentSessionId)
-  }
-
-  /**
-   * Update the retained prompt of the active frontend Session.
-   * @param text - exact controlled-input value for the active frontend Session.
-   */
-  updateIntent(text: string): void {
-    const session = this.getIntent()
-    if (session === undefined) return
-    session.updatePendingPrompt(text)
-    // The intent watch defers via markDirty, but the hero composer reads this
-    // prompt from the LIST snapshot as a controlled value: it must flush in
-    // the same tick as onChange (see Notifier.notifyNow) or React rolls the
-    // textarea back and IME composition breaks.
-    this.notifier.notifyNow()
-  }
-
-  private discardIntent(): void {
-    const session = this.getIntent()
-    this.intentSessionId = undefined
-    this.stopIntentWatch?.()
-    this.stopIntentWatch = undefined
-    session?.abandonIntent()
-  }
-
   // ---- Instance management ----
 
+  /**
+   * Drop a session instance (scope-prune companion, decision 12: instance
+   * and scope share one lifecycle). The host session log is the durable
+   * truth — a later get() lazily rebuilds and open() backfills history.
+   * @param sessionId - the session to drop.
+   */
+  drop(sessionId: SessionId): void {
+    this.sessions.delete(sessionId)
+  }
+
   /**
    * Lazy build: return the existing instance or construct one (no auto-open —
    * open is triggered by the container's select callback).
@@ -193,31 +135,33 @@ export class SessionManager {
     if (session === undefined) {
       session = this.createSession(sessionId)
       this.sessions.set(sessionId, session)
-      // Sync the running bit from the list snapshot into the new instance (consistency when the list precedes open).
-      const summary = this.summaries.find(s => s.sessionId === sessionId)
-      if (summary !== undefined) session.handleRunning(summary.running)
-      // Replay approval/question frames buffered before instantiation (rpcId verbatim, same semantics as the subscribed baseline replay).
+      // Replay approval/question/queued frames buffered before instantiation (rpcId
+      // verbatim, same semantics as the subscribed baseline replay). Replay happens
+      // BEFORE the running-bit sync: a not-running summary must sweep replayed queue
+      // rows the same way a live status flip would (their retirement events dropped
+      // while the session was uninstantiated).
       const buffered = this.pendingBuffers.get(sessionId)
       if (buffered !== undefined) {
         this.pendingBuffers.delete(sessionId)
         for (const envelope of buffered) session.handleMuxEnvelope(envelope.rpcId, envelope.payload)
       }
+      // Sync the running and blank bits from the list snapshot into the new
+      // instance (consistency when the list precedes open).
+      const summary = this.summaries.find(s => s.sessionId === sessionId)
+      if (summary !== undefined) {
+        session.handleBlank(summary.blank)
+        session.handleRunning(summary.running)
+      }
     }
     return session
   }
 
-  private createSession(
-    sessionId: SessionId,
-    intent?: { target: SessionIntentTarget; prompt: string },
-  ): Session {
+  private createSession(sessionId: SessionId): Session {
     return new Session(sessionId, this.api, {
-      ...(intent === undefined ? {} : { intent }),
-      onPublished: (published) => {
-        this.sessions.set(published.sessionId, published)
-        this.recordMutation({
-          kind: 'upsert',
-          summary: { sessionId: published.sessionId, updatedAt: Date.now(), running: false },
-        })
+      // The sender's local first-send flip mirrors into the list row so the
+      // session surfaces (lists filter on blank) before any host frame lands.
+      onEngaged: (engaged) => {
+        this.recordMutation({ kind: 'engaged', sessionId: engaged.sessionId })
       },
     })
   }
@@ -244,8 +188,13 @@ export class SessionManager {
           this.summaries = summaries
           this.listState = 'idle'
           this.listPhase = 'ready'
-          // Push running bits down to instantiated Sessions (the list is the authoritative summary source).
-          for (const s of this.summaries) this.sessions.get(s.sessionId)?.handleRunning(s.running)
+          // Push running/blank bits down to instantiated Sessions (the list is the authoritative summary source).
+          for (const s of this.summaries) {
+            const session = this.sessions.get(s.sessionId)
+            if (session === undefined) continue
+            session.handleBlank(s.blank)
+            session.handleRunning(s.running)
+          }
         } else {
           this.listState = 'error'
           this.listError = result.error
@@ -266,7 +215,8 @@ export class SessionManager {
 
   /**
    * Contract session.create; on success merge into summaries immediately (no
-   * wait for the next refresh).
+   * wait for the next refresh). A created session is blank by definition
+   * (entity birth precedes the first message).
    * @param opts - target workspace or working directory, plus an optional caller-owned id.
    * @returns the create result.
    */
@@ -274,16 +224,14 @@ export class SessionManager {
     opts: { workspaceId?: WorkspaceId; cwd?: string; sessionId?: SessionId } = {},
   ): Promise<RpcResult<{ sessionId: SessionId }>> {
     try {
+      const shared = opts.sessionId === undefined ? {} : { sessionId: opts.sessionId }
       const payload = opts.workspaceId !== undefined
-        ? { workspaceId: opts.workspaceId, ...(opts.sessionId === undefined ? {} : { sessionId: opts.sessionId }) }
-        : {
-          ...(opts.cwd === undefined ? {} : { cwd: opts.cwd }),
-          ...(opts.sessionId === undefined ? {} : { sessionId: opts.sessionId }),
-        }
+        ? { workspaceId: opts.workspaceId, ...shared }
+        : { ...(opts.cwd === undefined ? {} : { cwd: opts.cwd }), ...shared }
       const { result } = await this.api.sessions.create(payload)
       if (result.ok) {
         this.recordMutation({ kind: 'upsert', summary: {
-          sessionId: result.value.sessionId, updatedAt: Date.now(), running: false,
+          sessionId: result.value.sessionId, updatedAt: Date.now(), running: false, blank: true,
           ...(opts.cwd !== undefined ? { cwd: opts.cwd } : {}),
         } })
       } else {
@@ -296,6 +244,7 @@ export class SessionManager {
             sessionId: publishedSessionId,
             updatedAt: Date.now(),
             running: false,
+            blank: true,
           } })
         }
       }
@@ -370,16 +319,31 @@ export class SessionManager {
         this.titleSnapshots.delete(frame.sessionId)
         this.notifier.markDirty()
       }
+      // New mux-generation baseline: buffered session/queued frames belong to
+      // the previous generation and the host is about to resend the live
+      // snapshot — drop them, or every reconnect appends a duplicate batch
+      // (and enough reconnects push real approval/question frames past the
+      // cap). Same re-baseline signal Session uses for its own mirror.
+      const buffered = this.pendingBuffers.get(frame.sessionId)
+      if (buffered !== undefined) {
+        const kept = buffered.filter(item => item.payload.type !== 'session/queued')
+        if (kept.length !== buffered.length) {
+          if (kept.length === 0) this.pendingBuffers.delete(frame.sessionId)
+          else this.pendingBuffers.set(frame.sessionId, kept)
+        }
+      }
     }
     const session = this.sessions.get(frame.sessionId)
     if (session === undefined) {
-      // Approval/question frames never hit history: buffer for replay on instantiation;
-      // everything else drops (not instantiated — history fully backfills on open).
+      // Approval/question/queued frames never hit history: buffer for replay on
+      // instantiation; everything else drops (not instantiated — history fully
+      // backfills on open).
       switch (frame.type) {
         case 'approval/requested':
         case 'approval/resolved':
         case 'question/requested':
-        case 'question/resolved': {
+        case 'question/resolved':
+        case 'session/queued': {
           const buffer = this.pendingBuffers.get(frame.sessionId) ?? []
           buffer.push(envelope)
           if (buffer.length > PENDING_BUFFER_CAP) buffer.splice(0, buffer.length - PENDING_BUFFER_CAP)
@@ -402,11 +366,11 @@ export class SessionManager {
     switch (frame.type) {
       case 'host/session-added': {
         this.mergeSummary({
-          sessionId: frame.sessionId, updatedAt: Date.now(), running: false,
+          sessionId: frame.sessionId, updatedAt: Date.now(), running: false, blank: frame.blank,
           ...(frame.parentSessionId !== undefined ? { parentSessionId: frame.parentSessionId } : {}),
           ...(frame.cwd !== undefined ? { cwd: frame.cwd } : {}),
         })
-        this.sessions.get(frame.sessionId)?.handlePublished()
+        this.sessions.get(frame.sessionId)?.handleBlank(frame.blank)
         return
       }
       case 'host/session-removed': {
@@ -448,6 +412,7 @@ export class SessionManager {
       const prev = this.entryCache.get(entry.sessionId)
       if (
         prev !== undefined && prev.updatedAt === entry.updatedAt && prev.running === entry.running
+        && prev.blank === entry.blank
         && prev.parentSessionId === entry.parentSessionId && prev.cwd === entry.cwd
         && prev.title === entry.title && prev.depth === entry.depth
       ) return prev
@@ -459,24 +424,13 @@ export class SessionManager {
     }
     const sameOrder = items.length === this.itemsCache.length && items.every((e, i) => e === this.itemsCache[i])
     if (!sameOrder) this.itemsCache = items
-    const intentSession = this.getIntent()
-    const intentState = intentSession?.getSnapshot()
-    const intent = intentSession !== undefined
-      && intentState !== undefined && intentState.intent !== null && intentState.pendingPrompt !== null
-      ? {
-        sessionId: intentSession.sessionId,
-        ...intentState.intent,
-        prompt: intentState.pendingPrompt.text,
-      }
-      : undefined
     const selected = this.selected
-    const current = selected !== undefined && (
-      intent?.sessionId === selected || items.some(item => item.sessionId === selected)
-    ) ? selected : undefined
+    const current = selected !== undefined && items.some(item => item.sessionId === selected)
+      ? selected
+      : undefined
     return {
       items: this.itemsCache,
       current,
-      intent,
       state: this.listState,
       phase: this.listPhase,
       error: this.listError,
@@ -492,18 +446,29 @@ function applyMutation(summaries: readonly SessionSummary[], mutation: SessionLi
       if (existing === undefined) return [mutation.summary, ...summaries]
       const filled: SessionSummary = {
         ...existing,
+        // Blank only lowers: a stale true (session-added racing the local
+        // first send) never re-hides an already-surfaced session.
+        blank: existing.blank && mutation.summary.blank,
         ...(existing.cwd === undefined && mutation.summary.cwd !== undefined ? { cwd: mutation.summary.cwd } : {}),
         ...(existing.parentSessionId === undefined && mutation.summary.parentSessionId !== undefined
           ? { parentSessionId: mutation.summary.parentSessionId } : {}),
       }
-      if (filled.cwd === existing.cwd && filled.parentSessionId === existing.parentSessionId) return [...summaries]
+      if (filled.cwd === existing.cwd && filled.parentSessionId === existing.parentSessionId
+        && filled.blank === existing.blank) return [...summaries]
       return summaries.map(summary => summary.sessionId === mutation.summary.sessionId ? filled : summary)
     }
     case 'remove':
       return summaries.filter(summary => summary.sessionId !== mutation.sessionId)
     case 'status':
-      return summaries.map(summary => summary.sessionId === mutation.sessionId && summary.running !== mutation.running
-        ? { ...summary, running: mutation.running }
+      // running:true doubles as the cross-端 blank flip (a blank session
+      // never runs, so the first running frame proves a message landed).
+      return summaries.map(summary => summary.sessionId === mutation.sessionId
+        && (summary.running !== mutation.running || (mutation.running && summary.blank))
+        ? { ...summary, running: mutation.running, blank: summary.blank && !mutation.running }
+        : summary)
+    case 'engaged':
+      return summaries.map(summary => summary.sessionId === mutation.sessionId && summary.blank
+        ? { ...summary, blank: false }
         : summary)
   }
 }

packages/client/runtime/src/client/sessions/notifier.ts

@@ -3,11 +3,17 @@
 // the flush rebuilds the snapshot cache BEFORE notifying (useSyncExternalStore requires a stable
 // getSnapshot reference). With no listeners the rebuild is skipped and only the dirty bit is set
 // (keeps frame storms cheap); the next getSnapshot rebuilds lazily.
+//
+// Freshness and notification are SEPARATE bits: a pull (ensureFresh) between
+// markDirty and the scheduled flush rebuilds the snapshot but must not
+// swallow the notification — push subscribers (object-layer watchers) would
+// otherwise starve whenever any reader pulls first.
 
 /** Subscription + microtask-batched notification primitive (shared by Session and SessionManager). */
 export class Notifier {
   private listeners = new Set<() => void>()
   private dirty = false
+  private notifyPending = false
   private scheduled = false
 
   /** @param rebuild - snapshot rebuild function injected by the owner (writes the owner's snapshotCache). */
@@ -28,14 +34,18 @@ export class Notifier {
   /** State-change entry: mark dirty and schedule the batched flush. */
   markDirty(): void {
     this.dirty = true
+    this.notifyPending = true
     if (this.scheduled) return
     this.scheduled = true
     queueMicrotask(() => {
       this.scheduled = false
-      if (!this.dirty) return
-      if (this.listeners.size === 0) return // lazy: no subscribers, keep dirty for the next getSnapshot
-      this.dirty = false
-      this.rebuild()
+      if (!this.notifyPending) return
+      if (this.listeners.size === 0) return // lazy: no subscribers; dirty (if still set) rebuilds on next getSnapshot
+      this.notifyPending = false
+      if (this.dirty) {
+        this.dirty = false
+        this.rebuild()
+      }
       for (const listener of this.listeners) listener()
     })
   }
@@ -46,13 +56,18 @@ export class Notifier {
    */
   notifyNow(): void {
     this.dirty = true
+    this.notifyPending = true
     if (this.listeners.size === 0) return // lazy: same as markDirty, next getSnapshot rebuilds
+    this.notifyPending = false
     this.dirty = false
     this.rebuild()
     for (const listener of this.listeners) listener()
   }
 
-  /** Pre-getSnapshot check: rebuild synchronously when dirty (read path before first subscribe / while unobserved). */
+  /**
+   * Pre-getSnapshot check: rebuild synchronously when dirty (read path
+   * before first subscribe / while unobserved). Notification stays pending.
+   */
   ensureFresh(): void {
     if (!this.dirty) return
     this.dirty = false

packages/client/runtime/src/client/sessions/service.ts

@@ -2,8 +2,9 @@
  * SessionsService: root sessions service — list snapshot store (manager
  * projection; carries `current`, the persisted selection every
  * session-scoped surface keys off — migrated here from ui-layout per the
- * slot-parity design), session scope tree (mintScope pattern: no-op plugin
- * Fiber + ctx.extend scope tag), stable SessionBinding cache, ancestry walk.
+ * slot-parity design), Agent scope tree (mintScope pattern: no-op plugin
+ * Fiber + ctx.extend scope tag; one scope per session, agent id === session
+ * id), stable SessionBinding cache, ancestry walk.
  *
  * Scope lifecycle is stage-driven: a scope is minted lazily on first
  * resolution (pure — resolution has no side effects and is render-safe);
@@ -16,15 +17,15 @@
  */
 import type { Context, Fiber } from 'cordis'
 import type { IApiClient, RpcError, SessionId, WorkspaceId } from '@deepseek-ai/dsh-client-connection/client'
-import type { SessionCell } from '@deepseek-ai/dsh-client-ui-slots'
+import type {
+  HostObservable, SessionMaybeProvideInfo, SessionProvideInfo,
+} from '@deepseek-ai/dsh-client-ui-slots'
 import type { SnapshotStore } from '../contract/store.ts'
 import { createSnapshotStore } from '../contract/store.ts'
+import { createScope, scopeOf as scopeTagOf } from '../agents/scope.ts'
 import { SessionManager } from './manager.ts'
-import type {
-  SessionIntentListSnapshot, SessionListPhase,
-} from './manager.ts'
+import type { SessionListPhase } from './manager.ts'
 import type { Session } from './session.ts'
-import type { SessionIntentTarget } from './conversation.ts'
 
 /** Session list row projected from the host list RPC plus live stream increments. */
 export interface SessionSummary {
@@ -36,6 +37,13 @@ export interface SessionSummary {
   cwd?: string
   parentId?: SessionId
   running: boolean
+  /**
+   * Empty-log bit (host summary derivation mirror). New Session reuses a blank
+   * one targeting the same workspace. Filtering stays with the consumer: the
+   * store carries every row, while the Workspace browser shows only the
+   * selected blank entry.
+   */
+  blank: boolean
   updatedAt: number
 }
 
@@ -48,17 +56,13 @@ export interface SessionListState {
   ids: SessionId[]
   byId: Record<SessionId, SessionSummary>
   current: SessionId | undefined
-  /** Frontend Session Intent projected from its owning Session object. */
-  intent: SessionIntentListSnapshot | undefined
   /** Arrival lifecycle projected 1:1 from the manager snapshot (see SessionListPhase): empty-with-ready means "truly no sessions". */
   phase: SessionListPhase
 }
 
-/** Structured session-create failure preserving partial publication identity. */
+/** Structured session-create failure. */
 export class SessionCreateError extends Error {
   override readonly name = 'SessionCreateError'
-  /** Definitely published by Host before Workspace attachment failed. */
-  readonly publishedSessionId: SessionId | undefined
 
   /**
    * @param rpcError - Host business or folded transport error.
@@ -69,9 +73,6 @@ export class SessionCreateError extends Error {
     readonly requestedSessionId: SessionId | undefined,
   ) {
     super(`session create failed: ${rpcError.code}: ${rpcError.message}`)
-    this.publishedSessionId = rpcError.code === 'workspace-attach-failed'
-      ? rpcError.details.sessionId
-      : undefined
   }
 }
 
@@ -82,20 +83,10 @@ export interface SessionBinding {
   readonly ctx: Context
 }
 
-/** Scope tag key (client counterpart of the host dsh-scope pattern). */
-const kScope = Symbol('dsh.client.scope')
-
-/**
- * Read the session scope tag off a context.
- * @param ctx - any client context.
- * @returns the session id, or undefined on root contexts.
- */
-export function scopeOf(ctx: Context): SessionId | undefined {
-  return (ctx as Context & { [kScope]?: SessionId })[kScope]
-}
-
-/** Shared no-op plugin backing each session scope fiber. */
-function sessionScope(): void {}
+// Scope primitives live in ../agents/scope.ts (the client mirror of host
+// dsh-scope, keyed by Agent identity); re-exported here so existing
+// consumers keep their import site.
+export { scopeOf } from '../agents/scope.ts'
 
 /**
  * Workspace display title of a session cwd: the path's last non-empty
@@ -128,8 +119,30 @@ interface ScopeRecord {
   fiber: Fiber
   ctx: Context
   binding: SessionBinding
-  /** Render-layer standard kit (identity-stable per scope; the renderer's per-cell caches key off it). */
-  cell: SessionCell
+  /** Render-layer standard-props bundle (identity-stable per scope; the renderer's per-info caches key off it). */
+  provideInfo: SessionProvideInfo
+}
+
+/** One plugin's per-session standard-props contribution (see {@link SessionsService.provide}). */
+export interface SessionProvideContribution {
+  /** Bare observable sources, keyed by hook base name ('input' → useInput). */
+  hooks?: Record<string, HostObservable<unknown>>
+  /** Stable plain members (action callbacks etc.), spread into standard props verbatim. */
+  props?: Record<string, unknown>
+}
+
+/**
+ * Static declaration plus per-session resolver for one standard-kit
+ * contribution. The declared names let the renderer construct the same hook
+ * and prop surface while no session is current.
+ */
+export interface SessionProvideDescriptor {
+  /** Hook base names (`input` becomes `useInput`). */
+  hooks?: readonly string[]
+  /** Plain standard-prop names. */
+  props?: readonly string[]
+  /** Resolve every declared member for one definite session. */
+  resolve(binding: SessionBinding): SessionProvideContribution
 }
 
 /** Root sessions service: list store, current selection, object-layer manager, scope tree, bindings, ancestry. */
@@ -150,6 +163,10 @@ export class SessionsService {
   private readonly selection: SnapshotStore<{ sessionId?: SessionId }>
 
   private readonly scopes = new Map<SessionId, ScopeRecord>()
+  /** Registered per-session standard-props providers, in registration order. */
+  private readonly providers: SessionProvideDescriptor[] = []
+  /** Static no-session projection, rebuilt only when the provider roster changes. */
+  private maybeInfo: SessionMaybeProvideInfo
   /**
    * The staged session id — follows `list.current` exactly, holding its last
    * defined value across masked gaps (a transiently absent selection blanks
@@ -170,7 +187,7 @@ export class SessionsService {
       { persist: { name: 'dsh.sessions.current' } })
     this.manager = new SessionManager(api, this.selection.getSnapshot().sessionId)
     this.list = createSnapshotStore<SessionListState>({
-      ids: [], byId: {}, current: undefined, intent: undefined, phase: 'pending',
+      ids: [], byId: {}, current: undefined, phase: 'pending',
     })
     // The manager owns wire truth; the store is its projection. Manager
     // notifications are already microtask-batched.
@@ -182,9 +199,97 @@ export class SessionsService {
     // the follower writes no list state — session.open()'s synchronous prefix
     // touches only session-side state and its own microtask-batched notifier.
     this.list.subscribe(() => { this.followCurrent() })
+    // The runtime's own contribution comes first: useSession rides the same
+    // provide channel every plugin uses (no renderer special case).
+    this.providers.push({
+      hooks: ['session'],
+      resolve: binding => ({ hooks: { session: binding.session } }),
+    })
+    this.maybeInfo = this.materializeMaybeProvideInfo()
     rootCtx.reflect.provide('sessions', this, undefined)
   }
 
+  /**
+   * Register a per-session standard-props provider: every session-scope slot
+   * component receives the contributed members as standard props (`hooks`
+   * sources become `use<Name>` selector hooks on the render side; `props`
+   * spread verbatim). Contributions materialize lazily with the session's
+   * scope record and die with it. Registration order is resolution order;
+   * duplicate member names fail loud at materialization.
+   * @param descriptor - static member roster plus per-session resolver.
+   * @returns disposer removing the provider (already-materialized bundles keep their members until their scope drops).
+   */
+  provide(descriptor: SessionProvideDescriptor): () => void {
+    this.providers.push(descriptor)
+    // Scopes may already exist (boot order: the list lands and resolves
+    // scopes before later plugins register) — their bundles must include
+    // every provider by first render, so re-materialize on roster change.
+    this.rematerializeProvideBundles()
+    return () => {
+      const at = this.providers.indexOf(descriptor)
+      if (at >= 0) this.providers.splice(at, 1)
+      this.rematerializeProvideBundles()
+    }
+  }
+
+  /** Rebuild every live scope's standard-props bundle after a provider roster change. */
+  private rematerializeProvideBundles(): void {
+    this.maybeInfo = this.materializeMaybeProvideInfo()
+    for (const record of this.scopes.values()) {
+      record.provideInfo = this.materializeProvideInfo(record.binding)
+    }
+  }
+
+  /** Build the static no-session kit and reject duplicate declared names. */
+  private materializeMaybeProvideInfo(): SessionMaybeProvideInfo {
+    const hooks: Record<string, undefined> = {}
+    const props: Record<string, undefined> = {}
+    for (const descriptor of this.providers) {
+      for (const name of descriptor.hooks ?? []) {
+        if (Object.hasOwn(hooks, name)) throw new Error(`sessions.provide: duplicate hook "${name}"`)
+        hooks[name] = undefined
+      }
+      for (const name of descriptor.props ?? []) {
+        if (Object.hasOwn(props, name)) throw new Error(`sessions.provide: duplicate prop "${name}"`)
+        props[name] = undefined
+      }
+    }
+    return { sessionId: undefined, hooks, props }
+  }
+
+  /** Materialize the standard-props bundle for one session (fails loud on duplicate member names). */
+  private materializeProvideInfo(binding: SessionBinding): SessionProvideInfo {
+    const hooks: Record<string, HostObservable<unknown>> = {}
+    const props: Record<string, unknown> = {}
+    for (const descriptor of this.providers) {
+      const contribution = descriptor.resolve(binding)
+      const contributedHooks = contribution.hooks ?? {}
+      const contributedProps = contribution.props ?? {}
+      for (const name of Object.keys(contributedHooks)) {
+        if (!(descriptor.hooks ?? []).includes(name)) {
+          throw new Error(`sessions.provide: undeclared hook "${name}"`)
+        }
+      }
+      for (const name of Object.keys(contributedProps)) {
+        if (!(descriptor.props ?? []).includes(name)) {
+          throw new Error(`sessions.provide: undeclared prop "${name}"`)
+        }
+      }
+      for (const name of descriptor.hooks ?? []) {
+        const source = contributedHooks[name]
+        if (source === undefined) throw new Error(`sessions.provide: missing hook "${name}"`)
+        if (Object.hasOwn(hooks, name)) throw new Error(`sessions.provide: duplicate hook "${name}"`)
+        hooks[name] = source
+      }
+      for (const name of descriptor.props ?? []) {
+        if (!Object.hasOwn(contributedProps, name)) throw new Error(`sessions.provide: missing prop "${name}"`)
+        if (Object.hasOwn(props, name)) throw new Error(`sessions.provide: duplicate prop "${name}"`)
+        props[name] = contributedProps[name]
+      }
+    }
+    return { sessionId: binding.sessionId, hooks, props }
+  }
+
   /**
    * Select a session as current. Unknown ids fail loud instead of navigating
    * nowhere.
@@ -205,32 +310,6 @@ export class SessionsService {
     this.manager.clearSelection()
   }
 
-  /**
-   * Start or retarget the sole client-local Session intent.
-   * @param target - resolved real or frontend-only Workspace target.
-   * @param prompt - optional prompt retained across retargeting.
-   * @returns the frontend Session object that owns the Intent.
-   */
-  startIntent(target: SessionIntentTarget, prompt = ''): Session {
-    return this.manager.startIntent(target, prompt)
-  }
-
-  /**
-   * Resolve the active frontend Session Intent.
-   * @returns the active frontend Session object, if one exists.
-   */
-  intent(): Session | undefined {
-    return this.manager.getIntent()
-  }
-
-  /**
-   * Update the retained prompt of the active frontend Session.
-   * @param text - exact controlled-input value for the current Session Intent.
-   */
-  updateIntent(text: string): void {
-    this.manager.updateIntent(text)
-  }
-
   /**
    * Refresh the real Session baseline, reusing an in-flight pull.
    * @returns completion of the current or newly started baseline pull.
@@ -261,21 +340,26 @@ export class SessionsService {
   }
 
   /**
-   * Create a session on the host.
+   * Create a session on the host. Resolution guarantee: by the time the
+   * promise resolves, the created session is in the list store and
+   * {@link SessionsService.binding} resolves it — callers (New Session
+   * draft hand-off) may address the scope synchronously, without waiting a
+   * notifier flush. The synchronous projection below makes this structural
+   * rather than an accident of microtask ordering.
    * @param opts - target workspace or directory and an optional preallocated id.
    * @returns the new session id.
-   * @throws {SessionCreateError} with the requested id and, after an attach
-   * failure, the definitely published id.
+   * @throws {SessionCreateError} with the requested id.
    */
   async create(opts: { workspaceId?: WorkspaceId; cwd?: string; sessionId?: SessionId } = {}): Promise<SessionId> {
     const result = await this.manager.create(opts)
     if (!result.ok) throw new SessionCreateError(result.error, opts.sessionId)
+    this.projectList()
     return result.value.sessionId
   }
 
   /**
-   * Resolve a session-scoped context view (use-and-discard).
-   * @param id - session id.
+   * Resolve an Agent-scoped context view (use-and-discard).
+   * @param id - session id (the agent identity — 1:1 same axis).
    * @returns scoped ctx, or undefined for a session neither listed nor already scoped.
    */
   scope(id: SessionId): Context | undefined {
@@ -283,7 +367,7 @@ export class SessionsService {
   }
 
   /**
-   * Read the session scope tag off a context. Service-method seam: fetch
+   * Read the Agent scope tag off a context. Service-method seam: fetch
    * bundles must reach scope resolution through ctx.sessions — a cross-bundle
    * value import of the standalone helper would inline a second module
    * instance whose private tag Symbol never matches.
@@ -291,7 +375,22 @@ export class SessionsService {
    * @returns the session id, or undefined on root contexts.
    */
   scopeOf(ctx: Context): SessionId | undefined {
-    return scopeOf(ctx)
+    return scopeTagOf(ctx)
+  }
+
+  /**
+   * Resolve the business Session behind an Agent-scoped context — the one
+   * hop every scoped consumer (event listeners, per-session controllers)
+   * takes from ctx-space into object-space (the client mirror of host
+   * `agent.session`). Same service-method seam as
+   * {@link SessionsService.scopeOf}.
+   * @param ctx - an Agent-scoped context.
+   * @returns the Session, or undefined when the ctx is untagged or its scope was pruned.
+   */
+  sessionOf(ctx: Context): Session | undefined {
+    const id = scopeTagOf(ctx)
+    if (id === undefined) return undefined
+    return this.scopes.get(id)?.binding.session
   }
 
   /**
@@ -305,16 +404,26 @@ export class SessionsService {
   }
 
   /**
-   * Resolve the render-layer session cell (SessionProvider's feed through
-   * the renderer host; ctx never enters the render layer). Pure resolution —
-   * render-safe: SessionProvider calls this during render, so no staging, no
-   * window side effects (StrictMode double-invokes and concurrent discarded
-   * passes must stay free).
+   * Resolve the render-layer standard-props bundle (SessionProvider's feed
+   * through the renderer host; ctx never enters the render layer). Pure
+   * resolution — render-safe: SessionProvider calls this during render, so no
+   * staging, no window side effects (StrictMode double-invokes and concurrent
+   * discarded passes must stay free).
    * @param id - session id.
-   * @returns cell, or undefined for a session neither listed nor already scoped.
+   * @returns the provide info, or undefined for a session neither listed nor already scoped.
    */
-  cell(id: string): SessionCell | undefined {
-    return this.resolve(id as SessionId)?.cell
+  provideInfo(id: string): SessionProvideInfo | undefined {
+    return this.resolve(id as SessionId)?.provideInfo
+  }
+
+  /**
+   * Resolve the current-session-optional standard kit. Unknown or absent ids
+   * return the static no-session projection rather than removing hook props.
+   * @param id - current session id, when selected.
+   * @returns a definite or no-session provide bundle.
+   */
+  maybeProvideInfo(id: string | undefined): SessionMaybeProvideInfo {
+    return (id === undefined ? undefined : this.provideInfo(id)) ?? this.maybeInfo
   }
 
   /**
@@ -360,29 +469,42 @@ export class SessionsService {
     return chain
   }
 
-  /** Lazily mint the scope + binding for a listed (or already-scoped) session. */
+  /**
+   * Lazily mint the scope + binding for an eligible session. Eligibility and
+   * prune share one predicate (decision 12): listed on the host — a scope is
+   * born when its session enters the client's view (list mirror row from the
+   * baseline pull, a create() echo, or the session-added frame) and dies with
+   * the prune when the row leaves.
+   */
   private resolve(id: SessionId): ScopeRecord | undefined {
     const existing = this.scopes.get(id)
     if (existing !== undefined) return existing
-    // Frozen scopes outlive the list; new scopes are only minted for listed sessions.
-    if (this.list.getSnapshot().byId[id] === undefined) return undefined
-    const fiber = this.rootCtx.plugin(sessionScope)
-    const ctx = fiber.ctx.extend({ [kScope]: id })
+    if (!this.eligible(id)) return undefined
+    const { fiber, ctx } = createScope(this.rootCtx, id)
     const session = this.manager.get(id)
+    // The Session owns its scoped dispatch point (host Agent.loopCtx mirror);
+    // mint and bind are one step so a live scope record implies a bound actx.
+    session.bindScope(ctx)
+    const binding: SessionBinding = { sessionId: id, session, ctx }
     const record: ScopeRecord = {
       fiber,
       ctx,
-      binding: { sessionId: id, session, ctx },
-      // Session is the observable; React binds a selector hook at its own seam.
-      cell: { sessionId: id, session },
+      binding,
+      // Sources are bare observables; React binds selector hooks at its own seam.
+      provideInfo: this.materializeProvideInfo(binding),
     }
     this.scopes.set(id, record)
     return record
   }
 
+  /** The one aliveness predicate shared by scope mint and prune: host-listed. */
+  private eligible(id: SessionId): boolean {
+    return this.list.getSnapshot().byId[id] !== undefined
+  }
+
   /** Project the manager's list snapshot into the store (title derivation is display-only). */
   private projectList(): void {
-    const { items, current, intent, phase } = this.manager.getListSnapshot()
+    const { items, current, phase } = this.manager.getListSnapshot()
     const ids: SessionId[] = []
     const byId: Record<SessionId, SessionSummary> = {}
     for (const entry of items) {
@@ -391,6 +513,7 @@ export class SessionsService {
         id: entry.sessionId,
         displayTitle: displayTitleOf(entry.title, entry.cwd, entry.sessionId),
         running: entry.running,
+        blank: entry.blank,
         updatedAt: entry.updatedAt,
         ...(entry.title !== undefined ? { title: entry.title } : {}),
         ...(entry.cwd !== undefined ? { cwd: entry.cwd } : {}),
@@ -398,19 +521,22 @@ export class SessionsService {
       }
     }
     const persisted = this.selection.getSnapshot().sessionId
-    if (intent?.sessionId === current) {
+    // No current (cleared, or masked gap) wipes the persisted cell — a reload
+    // stays on empty; the in-memory selection still resurfaces a masked id.
+    if (current === undefined) {
       if (persisted !== undefined) this.selection.set({})
-    } else if (current !== undefined && byId[current] !== undefined && persisted !== current) {
+    } else if (byId[current] !== undefined && persisted !== current) {
       this.selection.set({ sessionId: current })
     }
-    this.list.set({ ids, byId, current, intent, phase })
+    this.list.set({ ids, byId, current, phase })
     this.pruneScopes(byId)
   }
 
-  /** Tear down scopes for removed sessions off stage; the staged one defers until the stage moves. */
+  /** Tear down scope + instance for no-longer-eligible sessions off stage; the staged one defers until the stage moves. */
   private pruneScopes(byId: Record<SessionId, SessionSummary>): void {
+    void byId
     for (const [id, record] of this.scopes) {
-      if (byId[id] !== undefined) continue
+      if (this.eligible(id)) continue
       if (id === this.watched) {
         this.deferredRemovals.add(id)
         continue
@@ -421,12 +547,22 @@ export class SessionsService {
     }
   }
 
-  /** Dispose a scope fiber and its session-keyed slot-store instances together (single lifecycle axis). */
+  /**
+   * One teardown for the whole per-session axis (decision 12): the scope
+   * fiber (cascading every actx-registered effect: input shell, slash
+   * controller, popup, plugin stores, listeners), the session-keyed slot
+   * stores, and the Session instance itself — the host session log is the
+   * durable truth, a reopen lazily rebuilds and backfills via open().
+   */
   private dropScope(id: SessionId, record: ScopeRecord): void {
     void record.fiber.dispose()
+    // Release the Session's dispatch point with the scope it belongs to (a
+    // surviving instance — the live Intent — rebinds when resolve re-mints).
+    record.binding.session.unbindScope()
     // Optional lookup: slots and sessions are sibling services with no
     // declared dependency; a slots-less boot (object-layer tests) skips.
     this.rootCtx.get('slots')?.pruneStoreScope(id)
+    this.manager.drop(id)
   }
 
   /** Run deferred teardowns whose session is no longer staged (called when the stage moves). */
@@ -436,8 +572,8 @@ export class SessionsService {
        * stage move sweeps first, so the set cannot contain the id the stage just
        * moved to; kept as a guard against future extra sweep call sites. */
       if (id === this.watched) continue
-      // Still absent from the list? (A re-added id cancels the deferred teardown.)
-      if (this.list.getSnapshot().byId[id] !== undefined) {
+      // Eligible again? (A re-added id cancels the deferred teardown.)
+      if (this.eligible(id)) {
         this.deferredRemovals.delete(id)
         continue
       }

packages/client/runtime/src/client/sessions/service.ts.orig

@@ -0,0 +1,590 @@
+/**
+ * SessionsService: root sessions service — list snapshot store (manager
+ * projection; carries `current`, the persisted selection every
+ * session-scoped surface keys off — migrated here from ui-layout per the
+ * slot-parity design), Agent scope tree (mintScope pattern: no-op plugin
+ * Fiber + ctx.extend scope tag; one scope per session, agent id === session
+ * id), stable SessionBinding cache, ancestry walk.
+ *
+ * Scope lifecycle is stage-driven: a scope is minted lazily on first
+ * resolution (pure — resolution has no side effects and is render-safe);
+ * the event window and deferred teardown key off the STAGED session, which
+ * follows `list.current` exactly. Staging is the open signal: the window
+ * opens ⟺ the session is on stage (today the stage is `current`; the staged
+ * state can widen to a multi-pane list later). A session leaving the list
+ * tears its scope down immediately unless it is the staged one, whose scope
+ * survives frozen (read-only view) until the stage moves on.
+ */
+import type { Context, Fiber } from 'cordis'
+import type { IApiClient, RpcError, SessionId, WorkspaceId } from '@deepseek-ai/dsh-client-connection/client'
+import type {
+  HostObservable, SessionMaybeProvideInfo, SessionProvideInfo,
+} from '@deepseek-ai/dsh-client-ui-slots'
+import type { SnapshotStore } from '../contract/store.ts'
+import { createSnapshotStore } from '../contract/store.ts'
+import { createScope, scopeOf as scopeTagOf } from '../agents/scope.ts'
+import { SessionManager } from './manager.ts'
+import type { SessionListPhase } from './manager.ts'
+import type { Session } from './session.ts'
+
+/** Session list row projected from the host list RPC plus live stream increments. */
+export interface SessionSummary {
+  id: SessionId
+  /** Latest durable log-backed title, absent until the host projects one. */
+  title?: string
+  /** Human-facing label: durable title, project basename, then session id. */
+  displayTitle: string
+  cwd?: string
+  parentId?: SessionId
+  running: boolean
+  /**
+   * Empty-log bit (host summary derivation mirror). List surfaces hide blank
+   * sessions; New Session reuses a blank one targeting the same workspace.
+   * Filtering stays with the consumer — the store carries every row.
+   */
+  blank: boolean
+  updatedAt: number
+}
+
+/**
+ * Session list store shape. `current` rides the same snapshot (arbitrated:
+ * the single useSessions standard hook reads list and selection together —
+ * sidebar highlighting and SessionProvider share one fact source).
+ */
+export interface SessionListState {
+  ids: SessionId[]
+  byId: Record<SessionId, SessionSummary>
+  current: SessionId | undefined
+  /** Arrival lifecycle projected 1:1 from the manager snapshot (see SessionListPhase): empty-with-ready means "truly no sessions". */
+  phase: SessionListPhase
+}
+
+/** Structured session-create failure. */
+export class SessionCreateError extends Error {
+  override readonly name = 'SessionCreateError'
+
+  /**
+   * @param rpcError - Host business or folded transport error.
+   * @param requestedSessionId - caller-preallocated id used for later stream/list reconciliation.
+   */
+  constructor(
+    readonly rpcError: RpcError,
+    readonly requestedSessionId: SessionId | undefined,
+  ) {
+    super(`session create failed: ${rpcError.code}: ${rpcError.message}`)
+  }
+}
+
+/** Session assembly handle for SessionProvider/inject factories (identity-stable per session). */
+export interface SessionBinding {
+  readonly sessionId: SessionId
+  readonly session: Session
+  readonly ctx: Context
+}
+
+// Scope primitives live in ../agents/scope.ts (the client mirror of host
+// dsh-scope, keyed by Agent identity); re-exported here so existing
+// consumers keep their import site.
+export { scopeOf } from '../agents/scope.ts'
+
+/**
+ * Workspace display title of a session cwd: the path's last non-empty
+ * segment (both separators accepted; trailing separators ignored), or ''
+ * for separator-only paths — callers own their fallback (session id, raw
+ * cwd, default-directory copy). The repo-wide single basename derivation —
+ * every surface naming a workspace (picker rows, toggle labels, list titles)
+ * calls this instead of re-splitting paths.
+ * @param cwd - workspace directory path.
+ * @returns basename title, or '' when no non-empty segment exists.
+ */
+export function workspaceTitleOf(cwd: string): string {
+  return cwd.replace(/[/\\]+$/, '').split(/[/\\]/).pop() ?? ''
+}
+
+/**
+ * Display title projection: durable title, project directory basename, then
+ * the raw id.
+ */
+function displayTitleOf(title: string | undefined, cwd: string | undefined, id: SessionId): string {
+  if (title !== undefined) return title
+  if (cwd !== undefined && cwd !== '') {
+    const base = workspaceTitleOf(cwd)
+    if (base !== '') return base
+  }
+  return id
+}
+
+interface ScopeRecord {
+  fiber: Fiber
+  ctx: Context
+  binding: SessionBinding
+  /** Render-layer standard-props bundle (identity-stable per scope; the renderer's per-info caches key off it). */
+  provideInfo: SessionProvideInfo
+}
+
+/** One plugin's per-session standard-props contribution (see {@link SessionsService.provide}). */
+export interface SessionProvideContribution {
+  /** Bare observable sources, keyed by hook base name ('input' → useInput). */
+  hooks?: Record<string, HostObservable<unknown>>
+  /** Stable plain members (action callbacks etc.), spread into standard props verbatim. */
+  props?: Record<string, unknown>
+}
+
+/**
+ * Static declaration plus per-session resolver for one standard-kit
+ * contribution. The declared names let the renderer construct the same hook
+ * and prop surface while no session is current.
+ */
+export interface SessionProvideDescriptor {
+  /** Hook base names (`input` becomes `useInput`). */
+  hooks?: readonly string[]
+  /** Plain standard-prop names. */
+  props?: readonly string[]
+  /** Resolve every declared member for one definite session. */
+  resolve(binding: SessionBinding): SessionProvideContribution
+}
+
+/** Root sessions service: list store, current selection, object-layer manager, scope tree, bindings, ancestry. */
+export class SessionsService {
+  /** List snapshot store (list RPC + host stream increments; re-pulled on reconnect) — the useSessions standard feed, current included. */
+  readonly list: SnapshotStore<SessionListState>
+  /** The object-layer instance cluster and frame dispatch entry. */
+  private readonly manager: SessionManager
+
+  /**
+   * Persisted selection cell (the durable half of `list.current`). Private on
+   * purpose: reads go through the list snapshot; writes through {@link
+   * SessionsService.open} / {@link SessionsService.clear}. Projection
+   * validates it against the live list instead of destructively pruning, so a
+   * selection survives transient list states (reconnect re-pull) and
+   * resurfaces when its session returns.
+   */
+  private readonly selection: SnapshotStore<{ sessionId?: SessionId }>
+
+  private readonly scopes = new Map<SessionId, ScopeRecord>()
+  /** Registered per-session standard-props providers, in registration order. */
+  private readonly providers: SessionProvideDescriptor[] = []
+  /** Static no-session projection, rebuilt only when the provider roster changes. */
+  private maybeInfo: SessionMaybeProvideInfo
+  /**
+   * The staged session id — follows `list.current` exactly, holding its last
+   * defined value across masked gaps (a transiently absent selection blanks
+   * `current` without moving the stage, so reconnect re-pulls and removals
+   * keep the staged scope's frozen view alive until the stage moves on).
+   */
+  private watched: SessionId | undefined
+  /** Removed-while-staged sessions whose teardown waits for the stage to move away. */
+  private readonly deferredRemovals = new Set<SessionId>()
+
+  /**
+   * @param ctx - client root context (scope fibers mount under it).
+   * @param api - wire client shared with every Session.
+   */
+  constructor(private readonly rootCtx: Context, api: IApiClient) {
+    this.selection = createSnapshotStore<{ sessionId?: SessionId }>(
+      {},
+      { persist: { name: 'dsh.sessions.current' } })
+    this.manager = new SessionManager(api, this.selection.getSnapshot().sessionId)
+    this.list = createSnapshotStore<SessionListState>({
+      ids: [], byId: {}, current: undefined, phase: 'pending',
+    })
+    // The manager owns wire truth; the store is its projection. Manager
+    // notifications are already microtask-batched.
+    this.manager.subscribe(() => { this.projectList() })
+    // Stage follower: every current write (open() and projection alike)
+    // re-evaluates staging, so startup restore (persisted selection validated
+    // by the projection) and reconnect resurfacing open their window with no
+    // dedicated code path. Safe to run synchronously inside the store notify:
+    // the follower writes no list state — session.open()'s synchronous prefix
+    // touches only session-side state and its own microtask-batched notifier.
+    this.list.subscribe(() => { this.followCurrent() })
+    // The runtime's own contribution comes first: useSession rides the same
+    // provide channel every plugin uses (no renderer special case).
+    this.providers.push({
+      hooks: ['session'],
+      resolve: binding => ({ hooks: { session: binding.session } }),
+    })
+    this.maybeInfo = this.materializeMaybeProvideInfo()
+    rootCtx.reflect.provide('sessions', this, undefined)
+  }
+
+  /**
+   * Register a per-session standard-props provider: every session-scope slot
+   * component receives the contributed members as standard props (`hooks`
+   * sources become `use<Name>` selector hooks on the render side; `props`
+   * spread verbatim). Contributions materialize lazily with the session's
+   * scope record and die with it. Registration order is resolution order;
+   * duplicate member names fail loud at materialization.
+   * @param descriptor - static member roster plus per-session resolver.
+   * @returns disposer removing the provider (already-materialized bundles keep their members until their scope drops).
+   */
+  provide(descriptor: SessionProvideDescriptor): () => void {
+    this.providers.push(descriptor)
+    // Scopes may already exist (boot order: the list lands and resolves
+    // scopes before later plugins register) — their bundles must include
+    // every provider by first render, so re-materialize on roster change.
+    this.rematerializeProvideBundles()
+    return () => {
+      const at = this.providers.indexOf(descriptor)
+      if (at >= 0) this.providers.splice(at, 1)
+      this.rematerializeProvideBundles()
+    }
+  }
+
+  /** Rebuild every live scope's standard-props bundle after a provider roster change. */
+  private rematerializeProvideBundles(): void {
+    this.maybeInfo = this.materializeMaybeProvideInfo()
+    for (const record of this.scopes.values()) {
+      record.provideInfo = this.materializeProvideInfo(record.binding)
+    }
+  }
+
+  /** Build the static no-session kit and reject duplicate declared names. */
+  private materializeMaybeProvideInfo(): SessionMaybeProvideInfo {
+    const hooks: Record<string, undefined> = {}
+    const props: Record<string, undefined> = {}
+    for (const descriptor of this.providers) {
+      for (const name of descriptor.hooks ?? []) {
+        if (Object.hasOwn(hooks, name)) throw new Error(`sessions.provide: duplicate hook "${name}"`)
+        hooks[name] = undefined
+      }
+      for (const name of descriptor.props ?? []) {
+        if (Object.hasOwn(props, name)) throw new Error(`sessions.provide: duplicate prop "${name}"`)
+        props[name] = undefined
+      }
+    }
+    return { sessionId: undefined, hooks, props }
+  }
+
+  /** Materialize the standard-props bundle for one session (fails loud on duplicate member names). */
+  private materializeProvideInfo(binding: SessionBinding): SessionProvideInfo {
+    const hooks: Record<string, HostObservable<unknown>> = {}
+    const props: Record<string, unknown> = {}
+    for (const descriptor of this.providers) {
+      const contribution = descriptor.resolve(binding)
+      const contributedHooks = contribution.hooks ?? {}
+      const contributedProps = contribution.props ?? {}
+      for (const name of Object.keys(contributedHooks)) {
+        if (!(descriptor.hooks ?? []).includes(name)) {
+          throw new Error(`sessions.provide: undeclared hook "${name}"`)
+        }
+      }
+      for (const name of Object.keys(contributedProps)) {
+        if (!(descriptor.props ?? []).includes(name)) {
+          throw new Error(`sessions.provide: undeclared prop "${name}"`)
+        }
+      }
+      for (const name of descriptor.hooks ?? []) {
+        const source = contributedHooks[name]
+        if (source === undefined) throw new Error(`sessions.provide: missing hook "${name}"`)
+        if (Object.hasOwn(hooks, name)) throw new Error(`sessions.provide: duplicate hook "${name}"`)
+        hooks[name] = source
+      }
+      for (const name of descriptor.props ?? []) {
+        if (!Object.hasOwn(contributedProps, name)) throw new Error(`sessions.provide: missing prop "${name}"`)
+        if (Object.hasOwn(props, name)) throw new Error(`sessions.provide: duplicate prop "${name}"`)
+        props[name] = contributedProps[name]
+      }
+    }
+    return { sessionId: binding.sessionId, hooks, props }
+  }
+
+  /**
+   * Select a session as current. Unknown ids fail loud instead of navigating
+   * nowhere.
+   * @param id - session id (must exist in the list store).
+   */
+  open(id: SessionId): void {
+    this.manager.select(id)
+  }
+
+  /**
+   * Clear the current selection so the layout shows the no-session empty
+   * state (new-session affordance and the workspace preselection flow).
+   * Wipes the persisted selection too — a reload stays on empty until the
+   * user opens or starts a session. The staged scope keeps its frozen view
+   * per the masked-gap contract until the next open() moves the stage.
+   */
+  clear(): void {
+    this.manager.clearSelection()
+  }
+
+  /**
+   * Refresh the real Session baseline, reusing an in-flight pull.
+   * @returns completion of the current or newly started baseline pull.
+   */
+  refresh(): Promise<void> {
+    return this.manager.refreshList()
+  }
+
+  /**
+   * Route a mux stream envelope into the Session object layer.
+   * @param envelope - validated mux stream envelope.
+   */
+  handleMuxEnvelope(envelope: Parameters<SessionManager['handleMuxEnvelope']>[0]): void {
+    this.manager.handleMuxEnvelope(envelope)
+  }
+
+  /**
+   * Route a Host stream envelope into the Session object layer.
+   * @param envelope - validated Host stream envelope.
+   */
+  handleHostEnvelope(envelope: Parameters<SessionManager['handleHostEnvelope']>[0]): void {
+    this.manager.handleHostEnvelope(envelope)
+  }
+
+  /** Rebuild the Session baseline and every opened window after connection. */
+  handleConnected(): void {
+    this.manager.handleConnected()
+  }
+
+  /**
+   * Create a session on the host. Resolution guarantee: by the time the
+   * promise resolves, the created session is in the list store and
+   * {@link SessionsService.binding} resolves it — callers (New Session
+   * draft hand-off) may address the scope synchronously, without waiting a
+   * notifier flush. The synchronous projection below makes this structural
+   * rather than an accident of microtask ordering.
+   * @param opts - target workspace or directory and an optional preallocated id.
+   * @returns the new session id.
+   * @throws {SessionCreateError} with the requested id.
+   */
+  async create(opts: { workspaceId?: WorkspaceId; cwd?: string; sessionId?: SessionId } = {}): Promise<SessionId> {
+    const result = await this.manager.create(opts)
+    if (!result.ok) throw new SessionCreateError(result.error, opts.sessionId)
+    this.projectList()
+    return result.value.sessionId
+  }
+
+  /**
+   * Resolve an Agent-scoped context view (use-and-discard).
+   * @param id - session id (the agent identity — 1:1 same axis).
+   * @returns scoped ctx, or undefined for a session neither listed nor already scoped.
+   */
+  scope(id: SessionId): Context | undefined {
+    return this.resolve(id)?.ctx
+  }
+
+  /**
+   * Read the Agent scope tag off a context. Service-method seam: fetch
+   * bundles must reach scope resolution through ctx.sessions — a cross-bundle
+   * value import of the standalone helper would inline a second module
+   * instance whose private tag Symbol never matches.
+   * @param ctx - any client context.
+   * @returns the session id, or undefined on root contexts.
+   */
+  scopeOf(ctx: Context): SessionId | undefined {
+    return scopeTagOf(ctx)
+  }
+
+  /**
+   * Resolve the business Session behind an Agent-scoped context — the one
+   * hop every scoped consumer (event listeners, per-session controllers)
+   * takes from ctx-space into object-space (the client mirror of host
+   * `agent.session`). Same service-method seam as
+   * {@link SessionsService.scopeOf}.
+   * @param ctx - an Agent-scoped context.
+   * @returns the Session, or undefined when the ctx is untagged or its scope was pruned.
+   */
+  sessionOf(ctx: Context): Session | undefined {
+    const id = scopeTagOf(ctx)
+    if (id === undefined) return undefined
+    return this.scopes.get(id)?.binding.session
+  }
+
+  /**
+   * Resolve the stable session binding (scope-addressed assembly feed). Pure
+   * resolution — no staging, no window side effects.
+   * @param id - session id.
+   * @returns binding, or undefined for a session neither listed nor already scoped.
+   */
+  binding(id: SessionId): SessionBinding | undefined {
+    return this.resolve(id)?.binding
+  }
+
+  /**
+   * Resolve the render-layer standard-props bundle (SessionProvider's feed
+   * through the renderer host; ctx never enters the render layer). Pure
+   * resolution — render-safe: SessionProvider calls this during render, so no
+   * staging, no window side effects (StrictMode double-invokes and concurrent
+   * discarded passes must stay free).
+   * @param id - session id.
+   * @returns the provide info, or undefined for a session neither listed nor already scoped.
+   */
+  provideInfo(id: string): SessionProvideInfo | undefined {
+    return this.resolve(id as SessionId)?.provideInfo
+  }
+
+  /**
+   * Resolve the current-session-optional standard kit. Unknown or absent ids
+   * return the static no-session projection rather than removing hook props.
+   * @param id - current session id, when selected.
+   * @returns a definite or no-session provide bundle.
+   */
+  maybeProvideInfo(id: string | undefined): SessionMaybeProvideInfo {
+    return (id === undefined ? undefined : this.provideInfo(id)) ?? this.maybeInfo
+  }
+
+  /**
+   * Move the stage to the list's current session: sweep teardowns deferred
+   * behind the previous occupant and pull the new occupant's history window.
+   * Staging IS the open signal — the window opens ⟺ the session is on stage
+   * — and open() is idempotent (an in-flight or completed open no-ops; a
+   * failed one retries the next time current is touched).
+   */
+  private followCurrent(): void {
+    const snapshot = this.list.getSnapshot()
+    const current = snapshot.current
+    // A masked gap (current blanked while the selection's session is
+    // transiently absent) holds the stage: tearing down on the gap would
+    // destroy exactly the frozen scope the mask exists to preserve.
+    if (current === undefined || snapshot.byId[current] === undefined || current === this.watched) return
+    this.watched = current
+    this.sweepDeferred()
+    const record = this.resolve(current)
+    /* v8 ignore next 3 -- defensive: current is always a listed id (open()
+     * validates and the projection masks absent selections), so resolve
+     * cannot miss; kept so a future current writer cannot crash the notify. */
+    if (record !== undefined) {
+      void record.binding.session.open()
+    }
+  }
+
+  /**
+   * Breadcrumb feed: walk parentId links inside the list store.
+   * @param id - session id.
+   * @returns summaries from root ancestor to the session itself (empty when unknown; a broken link stops the walk).
+   */
+  ancestry(id: SessionId): SessionSummary[] {
+    const { byId } = this.list.getSnapshot()
+    const chain: SessionSummary[] = []
+    let cursor: SessionId | undefined = id
+    while (cursor !== undefined) {
+      const summary: SessionSummary | undefined = byId[cursor]
+      if (summary === undefined || chain.includes(summary)) break
+      chain.unshift(summary)
+      cursor = summary.parentId
+    }
+    return chain
+  }
+
+  /**
+   * Lazily mint the scope + binding for an eligible session. Eligibility and
+   * prune share one predicate (decision 12): listed on the host — a scope is
+   * born when its session enters the client's view (list mirror row from the
+   * baseline pull, a create() echo, or the session-added frame) and dies with
+   * the prune when the row leaves.
+   */
+  private resolve(id: SessionId): ScopeRecord | undefined {
+    const existing = this.scopes.get(id)
+    if (existing !== undefined) return existing
+    if (!this.eligible(id)) return undefined
+    const { fiber, ctx } = createScope(this.rootCtx, id)
+    const session = this.manager.get(id)
+    // The Session owns its scoped dispatch point (host Agent.loopCtx mirror);
+    // mint and bind are one step so a live scope record implies a bound actx.
+    session.bindScope(ctx)
+    const binding: SessionBinding = { sessionId: id, session, ctx }
+    const record: ScopeRecord = {
+      fiber,
+      ctx,
+      binding,
+      // Sources are bare observables; React binds selector hooks at its own seam.
+      provideInfo: this.materializeProvideInfo(binding),
+    }
+    this.scopes.set(id, record)
+    return record
+  }
+
+  /** The one aliveness predicate shared by scope mint and prune: host-listed. */
+  private eligible(id: SessionId): boolean {
+    return this.list.getSnapshot().byId[id] !== undefined
+  }
+
+  /** Project the manager's list snapshot into the store (title derivation is display-only). */
+  private projectList(): void {
+    const { items, current, phase } = this.manager.getListSnapshot()
+    const ids: SessionId[] = []
+    const byId: Record<SessionId, SessionSummary> = {}
+    for (const entry of items) {
+      ids.push(entry.sessionId)
+      byId[entry.sessionId] = {
+        id: entry.sessionId,
+        displayTitle: displayTitleOf(entry.title, entry.cwd, entry.sessionId),
+        running: entry.running,
+        blank: entry.blank,
+        updatedAt: entry.updatedAt,
+        ...(entry.title !== undefined ? { title: entry.title } : {}),
+        ...(entry.cwd !== undefined ? { cwd: entry.cwd } : {}),
+        ...(entry.parentSessionId !== undefined ? { parentId: entry.parentSessionId } : {}),
+      }
+    }
+    const persisted = this.selection.getSnapshot().sessionId
+    // No current (cleared, or masked gap) wipes the persisted cell — a reload
+    // stays on empty; the in-memory selection still resurfaces a masked id.
+    if (current === undefined) {
+      if (persisted !== undefined) this.selection.set({})
+    } else if (byId[current] !== undefined && persisted !== current) {
+      this.selection.set({ sessionId: current })
+    }
+    this.list.set({ ids, byId, current, phase })
+    this.pruneScopes(byId)
+  }
+
+  /** Tear down scope + instance for no-longer-eligible sessions off stage; the staged one defers until the stage moves. */
+  private pruneScopes(byId: Record<SessionId, SessionSummary>): void {
+    void byId
+    for (const [id, record] of this.scopes) {
+      if (this.eligible(id)) continue
+      if (id === this.watched) {
+        this.deferredRemovals.add(id)
+        continue
+      }
+      this.scopes.delete(id)
+      this.deferredRemovals.delete(id)
+      this.dropScope(id, record)
+    }
+  }
+
+  /**
+   * One teardown for the whole per-session axis (decision 12): the scope
+   * fiber (cascading every actx-registered effect: input shell, slash
+   * controller, popup, plugin stores, listeners), the session-keyed slot
+   * stores, and the Session instance itself — the host session log is the
+   * durable truth, a reopen lazily rebuilds and backfills via open().
+   */
+  private dropScope(id: SessionId, record: ScopeRecord): void {
+    void record.fiber.dispose()
+    // Release the Session's dispatch point with the scope it belongs to (a
+    // surviving instance — the live Intent — rebinds when resolve re-mints).
+    record.binding.session.unbindScope()
+    // Optional lookup: slots and sessions are sibling services with no
+    // declared dependency; a slots-less boot (object-layer tests) skips.
+    this.rootCtx.get('slots')?.pruneStoreScope(id)
+    this.manager.drop(id)
+  }
+
+  /** Run deferred teardowns whose session is no longer staged (called when the stage moves). */
+  private sweepDeferred(): void {
+    for (const id of [...this.deferredRemovals]) {
+      /* v8 ignore next -- defensive: only the staged id ever defers, and every
+       * stage move sweeps first, so the set cannot contain the id the stage just
+       * moved to; kept as a guard against future extra sweep call sites. */
+      if (id === this.watched) continue
+      // Eligible again? (A re-added id cancels the deferred teardown.)
+      if (this.eligible(id)) {
+        this.deferredRemovals.delete(id)
+        continue
+      }
+      const record = this.scopes.get(id)
+      this.deferredRemovals.delete(id)
+      /* v8 ignore next -- defensive: prune deletes a scope and its deferral
+       * together, so a deferred id always still owns its record; kept so a
+       * future teardown path cannot double-dispose. */
+      if (record !== undefined) {
+        this.scopes.delete(id)
+        this.dropScope(id, record)
+      }
+    }
+  }
+}

packages/client/runtime/src/client/sessions/session.ts

@@ -1,18 +1,19 @@
 // Sessions remain resident after creation so they continue consuming mux frames off-screen.
 
+import type { Context } from 'cordis'
 import type { ContentBlock } from '@deepseek-ai/dsh-llm/types'
 import type { SessionEvent } from '@deepseek-ai/dsh-session/types'
 import type {
   HistoryEntry, IApiClient, MuxFrame, RpcError, RpcId, RpcResult,
-  SessionId, ToolEventView, WorkspaceId,
+  SessionId, ToolEventView,
 } from '@deepseek-ai/dsh-client-connection/client'
 // Value import from the inline-safe wire layer (not the connection plugin):
 // plugin-to-plugin value imports are a bundle purity error.
 import { transportError } from '@deepseek-ai/dsh-host-apiproxy/api'
 import type { ObservableSnapshot } from '../contract/store.ts'
 import type {
-  CodeSubCall, ComposerPhase, ConversationNode, ConversationSnapshot, OpenState, PendingPrompt,
-  PromptError, RunningToolCall, SessionIntentSnapshot, SessionIntentTarget,
+  CodeSubCall, ComposerPhase, ConversationNode, ConversationSnapshot, OpenState,
+  PromptError, QueuedMessage, RunningToolCall,
 } from './conversation.ts'
 import type { PendingInteraction } from './pending.ts'
 import { PendingWait } from './pending.ts'
@@ -23,10 +24,37 @@ import { PartialAccumulator } from './partial.ts'
 /** Messages requested per history page. */
 export const PAGE_MESSAGES = 50
 
-/** Optional frontend Intent and publication observer for a Session object. */
+/** Manager-owned observers of a Session object's local state edges. */
 export interface SessionOptions {
-  intent?: { target: SessionIntentTarget; prompt: string }
-  onPublished?(session: Session): void
+  /**
+   * First ACCEPTED prompt on a blank session (fires at most once, on the
+   * prompt RPC's success response): the manager mirrors the blank→false flip
+   * into its list row so the session surfaces without waiting for a host
+   * frame. Acceptance is the flip point because it proves the user message
+   * is in the host log; a rejected first prompt keeps the session blank
+   * (hidden, still reusable by connectWorkspace).
+   */
+  onEngaged?(session: Session): void
+}
+
+/** Queue-row preview cap: the dock renders one line, the full content never leaves the host mirror. */
+const QUEUE_PREVIEW_CHARS = 200
+
+/** Internal inbox-mirror entry: the snapshot row plus the retirement-matching fields the frames carry. */
+interface QueuedEntry {
+  row: QueuedMessage
+  steering: boolean
+  /** JSON-serialized MessageSource (steering retirement matches by source, the host-mirror precedent). */
+  sourceJson: string
+}
+
+/** Single-line queue-row preview: text blocks flattened, non-text as tags, capped by code point. */
+function queuePreviewOf(content: readonly ContentBlock[]): string {
+  const flat = content
+    .map(block => (block.type === 'text' ? block.text : `[${block.type}]`))
+    .join(' ').replace(/\s+/g, ' ').trim()
+  const chars = Array.from(flat)
+  return chars.length > QUEUE_PREVIEW_CHARS ? `${chars.slice(0, QUEUE_PREVIEW_CHARS).join('')}…` : flat
 }
 
 /**
@@ -64,6 +92,11 @@ export class Session implements ObservableSnapshot<ConversationSnapshot> {
   private callsCache: { rev: number; value: RunningToolCall[] } | null = null
   private pendingRev = 0
   private pendingCache: { rev: number; value: PendingInteraction[] } | null = null
+  /** Inbox mirror (session/queued frames + mux-open baseline). Queue frames never hit history,
+   *  so this is stream-only state: reconnect clears it and the fresh baseline re-populates. */
+  private queued: QueuedEntry[] = []
+  private queueRev = 0
+  private queueCache: { rev: number; value: QueuedMessage[] } | null = null
   private frozenRev = 0
   private nodesCache: { folded: readonly ConversationNode[]; frozenRev: number; value: readonly ConversationNode[] } | null = null
   /** `run_code` sub-dispatches by parent callId (window-derived, like openCalls). Appends
@@ -78,12 +111,10 @@ export class Session implements ObservableSnapshot<ConversationSnapshot> {
    * engaging edge of the phase machine (see ComposerPhase).
    */
   private promptAttempted = false
+  /** Empty-log mirror (see ConversationSnapshot.blank); monotone false once flipped. */
+  private blankBit = false
   private removed = false
   private promptError: PromptError | null = null
-  private intent: SessionIntentSnapshot | null
-  private pendingPrompt: PendingPrompt | null
-  private intentGeneration = 0
-  private published: boolean
   private lastAgentError: string | null = null
   /** Live events buffered during open/resync and stitched by sequence once history lands. */
   private liveBuffer: { event: SessionEvent; view: ToolEventView | undefined }[] = []
@@ -96,27 +127,46 @@ export class Session implements ObservableSnapshot<ConversationSnapshot> {
   private readonly notifier = new Notifier(() => {
     this.snapshotCache = this.buildSnapshot()
   })
+  /**
+   * Agent-scoped cordis context, bound once by SessionsService when it
+   * mints the scope (the client mirror of the host Agent's loopCtx). The
+   * Session dispatches its own scoped events through it; undefined means
+   * unbound (bare object-layer construction) or already pruned — both skip
+   * dispatch-dependent behavior rather than fail.
+   */
+  private actx: Context | undefined
 
   /**
-   * @param sessionId - stable identity shared by the frontend Intent and Host entity.
+   * @param sessionId - Host session identity (client sessions are always Host-born).
    * @param api - shared wire client.
-   * @param options - optional frontend-only initial state and publication observer.
+   * @param options - optional manager-owned state observers.
    */
   constructor(
     readonly sessionId: SessionId,
     private readonly api: IApiClient,
     private readonly options: SessionOptions = {},
   ) {
-    this.intent = options.intent === undefined
-      ? null
-      : { target: options.intent.target, phase: 'ready' }
-    this.pendingPrompt = options.intent === undefined
-      ? null
-      : { text: options.intent.prompt, phase: 'editing', retry: 'send' }
-    this.published = options.intent === undefined
     this.snapshotCache = this.buildSnapshot()
   }
 
+  /**
+   * Bind the Agent-scoped context minted by SessionsService (single write;
+   * a second bind is a wiring error and throws). Direction stays one-way at
+   * the seam: consumers still reach the Session via `sessions.sessionOf`,
+   * while the Session holds its own dispatch point (host Agent.loopCtx
+   * mirror).
+   * @param actx - the agent's scoped context.
+   */
+  bindScope(actx: Context): void {
+    if (this.actx !== undefined) throw new Error(`session ${this.sessionId} already has a bound scope`)
+    this.actx = actx
+  }
+
+  /** Release the bound scope at prune time (a later rebind accompanies a freshly minted scope). */
+  unbindScope(): void {
+    this.actx = undefined
+  }
+
   // ---- Operations ----
 
   /**
@@ -142,64 +192,22 @@ export class Session implements ObservableSnapshot<ConversationSnapshot> {
     if (!result.ok) {
       this.promptError = { op: 'send', error: result.error }
       this.notifier.markDirty()
+      return result
+    }
+    // Blank flips on ACCEPTANCE, not attempt: an accepted prompt has logged
+    // its user/message on the host (events.length > 0 is fact, not
+    // optimism), while a rejected first prompt must keep the session blank
+    // — the client-side blank mirror only ever lowers, so flipping early on
+    // a failure would surface the session forever and strip its
+    // connectWorkspace reuse eligibility against the host's authority.
+    if (this.blankBit) {
+      this.blankBit = false
+      this.options.onEngaged?.(this)
+      this.notifier.markDirty()
     }
     return result
   }
 
-  /**
-   * Update this Session's retained prompt while it remains editable.
-   * @param text - exact controlled value of this Session's retained prompt.
-   */
-  updatePendingPrompt(text: string): void {
-    const pending = this.pendingPrompt
-    if (pending === null || pending.phase === 'sending') return
-    this.pendingPrompt = { ...pending, text }
-    this.notifier.notifyNow()
-  }
-
-  /**
-   * Connect this frontend Session to a real Workspace and flush its retained prompt.
-   * @param workspaceId - real Workspace target.
-   */
-  connect(workspaceId: WorkspaceId): void {
-    const intent = this.intent
-    const pending = this.pendingPrompt
-    if (intent === null || intent.phase === 'connecting' || pending === null || pending.text.trim() === '') return
-    const connecting: SessionIntentSnapshot = {
-      target: { kind: 'workspace', workspaceId },
-      phase: 'connecting',
-    }
-    const queued: PendingPrompt = {
-      ...pending,
-      phase: 'sending',
-      retry: 'connect',
-      workspaceId,
-    }
-    delete queued.error
-    this.intent = connecting
-    this.pendingPrompt = queued
-    this.notifier.notifyNow()
-    void this.flushPendingPrompt()
-  }
-
-  /** Stop a superseded frontend Intent from automatically sending after publication. */
-  abandonIntent(): void {
-    if (this.intent === null) return
-    this.intentGeneration += 1
-  }
-
-  /** Retry this Session's retained prompt from its failed prerequisite. */
-  retryPendingPrompt(): void {
-    const pending = this.pendingPrompt
-    if (pending === null || pending.phase === 'sending' || pending.text.trim() === '') return
-    const sending: PendingPrompt = { ...pending, phase: 'sending' }
-    delete sending.error
-    this.pendingPrompt = sending
-    this.promptError = null
-    this.notifier.markDirty()
-    void this.flushPendingPrompt()
-  }
-
   /**
    * Stop: contract session.cancel 1:1; failures land in promptError (same error-strip display slot).
    * @returns the cancel result.
@@ -272,6 +280,11 @@ export class Session implements ObservableSnapshot<ConversationSnapshot> {
    *  in-flight open first — its history request rode the dead connection and must not settle
    *  the fresh generation into 'error' (audit S4). */
   async resync(): Promise<void> {
+    // The queue mirror is NOT cleared here: onConnected (which drives resync)
+    // races the mux frames — the fresh generation's baseline may have landed
+    // already, and the host never resends it. The mirror re-baselines on the
+    // session/subscribed frame instead (same stream as the queue snapshot
+    // that follows it, so ordering is guaranteed).
     if (this.openState === 'cold') return // never opened: no window to rebuild (doOpen flips to 'loading' synchronously, so cold implies no in-flight open)
     this.openGeneration++
     this.openPromise = null
@@ -320,12 +333,35 @@ export class Session implements ObservableSnapshot<ConversationSnapshot> {
   handleMuxEnvelope(rpcId: RpcId, frame: MuxFrame): void {
     switch (frame.type) {
       case 'session/event': {
+        this.retireQueued(frame.event)
         this.acceptLiveEvent(frame.event, frame.view)
         return
       }
+      case 'session/queued': {
+        // Row key: the enqueueing prompt's rpcId when it rode this wire (the
+        // provisional-echo reconciliation key); otherwise the frame envelope id.
+        const key = 'rpcId' in frame.source ? String(frame.source.rpcId) : `f:${rpcId}`
+        this.queued.push({
+          row: { key, preview: queuePreviewOf(frame.content) },
+          steering: frame.steering,
+          sourceJson: JSON.stringify(frame.source),
+        })
+        this.queueRev++
+        this.notifier.markDirty()
+        return
+      }
       case 'session/subscribed': {
         this.subscribedLastSeq = frame.lastSeq
-        return // pure baseline bookkeeping, no visible change
+        // New mux-generation baseline: the host pushes this session's queue
+        // snapshot AFTER the subscribed frame on the same stream, so the
+        // stale mirror clears here — race-free against onConnected/resync
+        // timing (clearing there could wipe a baseline that already landed).
+        if (this.queued.length > 0) {
+          this.queued = []
+          this.queueRev++
+          this.notifier.markDirty()
+        }
+        return
       }
       case 'approval/requested': {
         const { type: _type, sessionId: _sid, ...payload } = frame
@@ -362,14 +398,38 @@ export class Session implements ObservableSnapshot<ConversationSnapshot> {
    * @param running - the new running state.
    */
   handleRunning(running: boolean): void {
+    // Leave-running sweep (host queuedMirror precedent): discard paths (cancel,
+    // terminal steering drop) have no per-entry frame, so ANY not-running signal
+    // with a nonempty mirror clears it — checked before the equality return so a
+    // stale replay on an already-idle session still sweeps.
+    if (!running && this.queued.length > 0) {
+      this.queued = []
+      this.queueRev++
+      this.notifier.markDirty()
+    }
+    // Turn-start conversion: a blank session never runs, so the first
+    // running:true proves another端's first message landed (设计稿 2.2).
+    if (running && this.blankBit) {
+      this.blankBit = false
+      this.notifier.markDirty()
+    }
     if (this.running === running) return
     this.running = running
     this.notifier.markDirty()
   }
 
-  /** Mark that Host publication is known without resolving an uncertain local create response. */
-  handlePublished(): void {
-    this.markPublished()
+  /**
+   * Blank-bit relay from the authoritative summary source (list baseline and
+   * the session-added frame). Monotone: once any signal (local first send,
+   * running flip, an earlier summary) cleared it, a stale true never
+   * re-blanks.
+   * @param blank - the summary's derived empty-log bit.
+   */
+  handleBlank(blank: boolean): void {
+    if (blank === this.blankBit) return
+    if (blank && (this.promptAttempted || this.running)) return
+    this.blankBit = blank
+    this.notifier.markDirty()
   }
 
   /** host/session-removed relay: flag the snapshot (instance survives — resident-instance rule). */
@@ -405,112 +465,6 @@ export class Session implements ObservableSnapshot<ConversationSnapshot> {
     this.pendingRev++
   }
 
-  /** Advance the retained prompt through Session attachment and submission. */
-  private async flushPendingPrompt(): Promise<void> {
-    const pending = this.pendingPrompt
-    if (pending?.phase === 'sending') {
-      const ready = pending.retry === 'connect'
-        ? await this.attachPendingPrompt(pending)
-        : pending
-      if (ready !== null) await this.sendPendingPrompt(ready)
-    }
-  }
-
-  /** Complete the Host Session prerequisite and return the prompt's send step. */
-  private async attachPendingPrompt(pending: PendingPrompt): Promise<PendingPrompt | null> {
-    const workspaceId = pending.workspaceId
-    if (workspaceId === undefined) throw new Error('a Session attachment requires a Workspace id')
-    const originIntent = this.intent
-    const originGeneration = this.intentGeneration
-    let result: RpcResult<{ sessionId: SessionId }>
-    try {
-      result = (await this.api.sessions.create({ sessionId: this.sessionId, workspaceId })).result
-    } catch (error) {
-      result = transportError(error)
-    }
-    let ready: PendingPrompt | null = null
-    if (result.ok) {
-      ready = this.completePendingAttachment(pending, originIntent, originGeneration)
-    } else {
-      this.failPendingAttachment(pending, originIntent, originGeneration, result.error)
-    }
-    this.notifier.markDirty()
-    return ready
-  }
-
-  /** Move a published Session to the send step unless its page intent was superseded. */
-  private completePendingAttachment(
-    pending: PendingPrompt,
-    originIntent: SessionIntentSnapshot | null,
-    originGeneration: number,
-  ): PendingPrompt | null {
-    this.markPublished()
-    this.intent = null
-    this.promptAttempted = true
-    const superseded = originIntent !== null && originGeneration !== this.intentGeneration
-    const next: PendingPrompt = {
-      ...pending,
-      phase: superseded ? 'failed' : 'sending',
-      retry: 'send',
-      ...(superseded ? { error: 'Message was not sent because you navigated away.' } : {}),
-    }
-    if (!superseded) delete next.error
-    this.pendingPrompt = next
-    return superseded ? null : next
-  }
-
-  /** Retain the prompt at the failed attachment step that owns the retry. */
-  private failPendingAttachment(
-    pending: PendingPrompt,
-    originIntent: SessionIntentSnapshot | null,
-    originGeneration: number,
-    error: RpcError,
-  ): void {
-    const partiallyPublished = error.code === 'workspace-attach-failed'
-    if (partiallyPublished) {
-      this.markPublished()
-      this.intent = null
-      this.promptAttempted = true
-    }
-    const activeIntent = !partiallyPublished
-      && originIntent !== null
-      && originGeneration === this.intentGeneration
-      && this.intent === originIntent
-    if (activeIntent) {
-      this.intent = {
-        target: originIntent.target,
-        phase: 'ready',
-        error: { step: 'session', message: rpcErrorMessage(error) },
-      }
-      this.pendingPrompt = { ...pending, phase: 'editing' }
-    }
-    if (!activeIntent && (partiallyPublished || originIntent === null) && this.pendingPrompt === pending) {
-      this.pendingPrompt = { ...pending, phase: 'failed', error: rpcErrorMessage(error) }
-    }
-  }
-
-  /** Submit the retained prompt and keep it only when Host rejects the send. */
-  private async sendPendingPrompt(pending: PendingPrompt): Promise<void> {
-    const result = await this.prompt([{ type: 'text', text: pending.text.trim() }], 'queue')
-    if (this.pendingPrompt === pending) {
-      this.pendingPrompt = result.ok
-        ? null
-        : {
-          ...pending,
-          retry: 'send',
-          phase: 'failed',
-          error: rpcErrorMessage(result.error),
-        }
-      this.notifier.markDirty()
-    }
-  }
-
-  private markPublished(): void {
-    if (this.published) return
-    this.published = true
-    this.options.onPublished?.(this)
-  }
-
   /** @param generation - openGeneration at launch; every await re-checks it and a stale pass
    *  drops all writes (resync superseded this open — its outcome belongs to a dead connection). */
   private async doOpen(generation: number): Promise<void> {
@@ -613,6 +567,27 @@ export class Session implements ObservableSnapshot<ConversationSnapshot> {
     }
   }
 
+  /** Consumption-event retirement, mirroring the host queuedMirror rules: a message-triggered
+   *  turn/start claims the oldest non-steering entry; a steering/message drains the oldest
+   *  steering entry with the same source (loop-authored steering matches nothing and drops none). */
+  private retireQueued(event: SessionEvent): void {
+    if (this.queued.length === 0) return
+    let index = -1
+    if (event.type === 'turn/start') {
+      if (event.data.trigger.kind !== 'message') return
+      index = this.queued.findIndex(entry => !entry.steering)
+    } else if (event.type === 'steering/message') {
+      const source = JSON.stringify(event.data.source)
+      index = this.queued.findIndex(entry => entry.steering && entry.sourceJson === source)
+    } else {
+      return
+    }
+    if (index < 0) return
+    this.queued.splice(index, 1)
+    this.queueRev++
+    this.notifier.markDirty()
+  }
+
   /** Per-event side effects (right column of the §A.9 dispatch table):
    *  chunk accumulation / partial clear on finalize / openCalls add-remove. */
   private applyEventSideEffects(event: SessionEvent, view?: ToolEventView): void {
@@ -791,6 +766,9 @@ export class Session implements ObservableSnapshot<ConversationSnapshot> {
     if (this.dispatchesCache === null || this.dispatchesCache.rev !== this.dispatchesRev) {
       this.dispatchesCache = { rev: this.dispatchesRev, value: new Map(this.codeDispatches) }
     }
+    if (this.queueCache === null || this.queueCache.rev !== this.queueRev) {
+      this.queueCache = { rev: this.queueRev, value: this.queued.map(entry => entry.row) }
+    }
     const partial = this.partial?.toPartial() ?? null
     return {
       sessionId: this.sessionId,
@@ -800,6 +778,7 @@ export class Session implements ObservableSnapshot<ConversationSnapshot> {
       runningCalls: this.callsCache.value,
       pending: this.pendingCache.value,
       codeDispatches: this.dispatchesCache.value,
+      queue: this.queueCache.value,
       running: this.running,
       composerPhase: derivePhase(
         nodes.length > 0 || partial !== null || this.running || this.pendingCache.value.length > 0,
@@ -811,17 +790,12 @@ export class Session implements ObservableSnapshot<ConversationSnapshot> {
       hasMore: this.hasMore,
       loadingOlder: this.loadingOlder,
       promptError: this.promptError,
-      intent: this.intent,
-      pendingPrompt: this.pendingPrompt,
+      blank: this.blankBit,
       lastAgentError: this.lastAgentError,
     }
   }
 }
 
-function rpcErrorMessage(error: RpcError): string {
-  return `${error.code}: ${error.message}`
-}
-
 /**
  * The composerPhase judgment — the single site that knows the predicate
  * (consumers switch on the result, never re-derive). Monotone per session

packages/client/runtime/src/client/slots.ts

@@ -235,7 +235,7 @@ export class SlotsService extends Service {
     }
   }
 
-  /** Build once after both object-layer services mount; session cells still resolve lazily. */
+  /** Build once after both object-layer services mount; per-session provide bundles still resolve lazily. */
   private hostFace(): SlotRendererHost {
     if (this._host !== undefined) return this._host
     const sessions = this.ctx.get('sessions')
@@ -264,7 +264,8 @@ export class SlotsService extends Service {
       sessions: {
         list: sessions.list,
         current,
-        cell: id => sessions.cell(id),
+        provideInfo: id => sessions.provideInfo(id),
+        maybeProvideInfo: id => sessions.maybeProvideInfo(id),
       },
       workspaces: { list: workspaces.list },
     }
@@ -275,13 +276,13 @@ export class SlotsService extends Service {
   private resolveStore(handle: EngineStoreHandle, sessionId: string | undefined): StoreInstanceLike {
     const record = this._stores.get(handle)
     if (record === undefined) throw new Error('store handle is not registered (entry unloaded, or the handle never went through register)')
-    const key = record.scope === 'session' ? sessionId : ROOT_INSTANCE_KEY
-    if (key === undefined) throw new Error('session-scoped store resolution requires a session id')
+    const key = record.scope === 'root' ? ROOT_INSTANCE_KEY : sessionId
+    if (key === undefined) throw new Error(`${record.scope} store resolution requires a session id`)
     let instance = record.instances.get(key)
     if (instance === undefined) {
       // Session instances get the scope key (the engine suffixes the persist
       // key per session); root instances stay keyless.
-      instance = record.scope === 'session' ? handle.create(key) : handle.create()
+      instance = record.scope === 'root' ? handle.create() : handle.create(key)
       record.instances.set(key, instance)
     }
     return instance

packages/client/runtime/src/client/workspaces/manager.ts

@@ -6,11 +6,7 @@ import type {
 import { transportError } from '@deepseek-ai/dsh-host-apiproxy/api'
 import { mergeOrderedBaseline } from '../ordered-baseline.ts'
 import { Notifier } from '../sessions/notifier.ts'
-import {
-  Workspace, type WorkspaceCreateInput, type WorkspaceIntentSnapshot,
-} from './workspace.ts'
-
-export type { WorkspaceIntentSnapshot } from './workspace.ts'
+import { Workspace, type WorkspaceCreateInput } from './workspace.ts'
 
 /** Monotone workspace-list arrival lifecycle. */
 export type WorkspaceListPhase = 'pending' | 'ready'
@@ -18,8 +14,6 @@ export type WorkspaceListPhase = 'pending' | 'ready'
 /** Immutable workspace-list snapshot. */
 export interface WorkspaceListSnapshot {
   items: readonly WorkspaceView[]
-  /** The sole page-local Workspace intent; never persisted or sent over the Host stream. */
-  intent: WorkspaceIntentSnapshot | undefined
   state: 'idle' | 'loading' | 'error'
   phase: WorkspaceListPhase
   error: RpcError | null
@@ -28,7 +22,6 @@ export interface WorkspaceListSnapshot {
 /** Workspace object cluster driven by one list baseline and changed-frame upserts. */
 export class WorkspaceManager {
   private items: Workspace[] = []
-  private intent: Workspace | undefined
   private itemViewsSource: readonly Workspace[] | null = null
   private itemViewsCache: readonly WorkspaceView[] = []
   private state: WorkspaceListSnapshot['state'] = 'idle'
@@ -46,44 +39,6 @@ export class WorkspaceManager {
     this.snapshotCache = this.buildSnapshot()
   }
 
-  /**
-   * Replace the current client-local Workspace intent object.
-   * @param name - directory/display name used if the intent is materialized.
-   * @returns the new intent snapshot.
-   */
-  startIntent(name = 'workspace'): WorkspaceIntentSnapshot {
-    this.intent = new Workspace(this.api, { name })
-    this.notifier.notifyNow()
-    return this.intent.getSnapshot().intent as WorkspaceIntentSnapshot
-  }
-
-  /** Discard the current client-local Workspace intent. */
-  discardIntent(): void {
-    if (this.intent === undefined) return
-    this.intent = undefined
-    this.notifier.notifyNow()
-  }
-
-  /**
-   * Materialize the current Workspace intent through the ordinary Host create seam.
-   * A superseded intent is never cleared by an older completion.
-   * @returns the Host create result, or undefined when no intent exists.
-   */
-  async materializeIntent(): Promise<RpcResult<{ workspace: WorkspaceView; created: boolean }> | undefined> {
-    const intent = this.intent
-    if (intent?.getSnapshot().intent?.phase !== 'ready') return undefined
-    const completion = intent.materialize()
-    if (completion === undefined) return undefined
-    this.notifier.notifyNow()
-    const result = await completion
-    if (result.ok) {
-      this.upsert(result.value.workspace, intent)
-      if (this.intent === intent) this.intent = undefined
-    }
-    this.notifier.markDirty()
-    return result
-  }
-
   /**
    * Refresh from workspace.list. The first successful response establishes
    * Host order; later responses update membership and values without moving
@@ -212,7 +167,6 @@ export class WorkspaceManager {
   private buildSnapshot(): WorkspaceListSnapshot {
     return {
       items: this.itemViews(),
-      intent: this.intent?.getSnapshot().intent,
       state: this.state,
       phase: this.phase,
       error: this.error,

packages/client/runtime/src/client/workspaces/service.ts

@@ -7,13 +7,11 @@ import type {
 import type { SnapshotStore } from '../contract/store.ts'
 import { createSnapshotStore } from '../contract/store.ts'
 import type { SessionsService } from '../sessions/service.ts'
-import { WorkspaceManager, type WorkspaceIntentSnapshot, type WorkspaceListPhase } from './manager.ts'
+import { WorkspaceManager, type WorkspaceListPhase } from './manager.ts'
 
 /** Workspace list plus the two-baseline readiness and default-target projection. */
 export interface WorkspaceListState {
   items: readonly WorkspaceView[]
-  /** Sole client-local Workspace projection; its state remains owned by Workspace. */
-  intent: WorkspaceIntentSnapshot | undefined
   state: 'idle' | 'loading' | 'error'
   phase: WorkspaceListPhase
   error: RpcError | null
@@ -29,64 +27,128 @@ export class WorkspacesService {
   readonly list: SnapshotStore<WorkspaceListState>
   /** Workspace baseline and frame owner. */
   private readonly manager: WorkspaceManager
-  private initialSessionResolved = false
-  private composingIntent = false
+  /** In-flight blank-session creates keyed by workspace (connectWorkspace coalescing). */
+  private readonly connecting = new Map<WorkspaceId, Promise<SessionId>>()
+  /** Guards the runtime-owned one-shot initial-selection subscription. */
+  private initialSelectionStarted = false
 
   /**
    * @param ctx - client root context.
    * @param api - shared wire client.
-   * @param sessions - lower-level Session service used for recency and cross-domain intent orchestration.
+   * @param sessions - lower-level Session service used for recency and blank-session reuse.
    */
   constructor(ctx: Context, api: IApiClient, private readonly sessions: SessionsService) {
     this.manager = new WorkspaceManager(api)
     this.list = createSnapshotStore<WorkspaceListState>({
-      items: [], intent: undefined, state: 'idle', phase: 'pending', error: null,
+      items: [], state: 'idle', phase: 'pending', error: null,
       baselinesReady: false, recentWorkspaceId: undefined,
     })
-    this.manager.subscribe(() => { if (!this.composingIntent) this.project() })
-    this.sessions.list.subscribe(() => { if (!this.composingIntent) this.project() })
+    this.manager.subscribe(() => { this.project() })
+    this.sessions.list.subscribe(() => { this.project() })
     ctx.reflect.provide('workspaces', this, undefined)
   }
 
   /**
-   * Start the sole Session intent, resolving the default Workspace here.
-   * @param workspaceId - optional explicit real Workspace target.
-   * @param prompt - optional prompt retained while retargeting.
+   * Resolve the session a New Session flow lands in once this Workspace is
+   * chosen: reuse the workspace's existing blank session when one is in the
+   * list mirror, else create a fresh one on the host (`session.create` births
+   * the full Session+Agent — the client holds no intermediate state). The
+   * caller owns navigation: take the returned id to `sessions.open`.
+   * Resolution guarantee (both arms): the returned id is already in the list
+   * store and `sessions.binding(id)` resolves synchronously — draft hand-off
+   * may write the new scope's machine before opening.
+   * @param workspaceId - chosen Workspace (must be in the workspace list).
+   * @returns the reused or newly created session id.
    */
-  startSession(workspaceId?: WorkspaceId, prompt = ''): void {
-    const snapshot = this.list.getSnapshot()
-    const resolved = workspaceId ?? snapshot.recentWorkspaceId ?? snapshot.items[0]?.workspaceId
-    this.composingIntent = true
-    try {
-      if (resolved === undefined) {
-        this.manager.startIntent()
-        this.sessions.startIntent({ kind: 'workspace-intent' }, prompt)
-      } else {
-        this.manager.discardIntent()
-        this.sessions.startIntent({ kind: 'workspace', workspaceId: resolved }, prompt)
+  async connectWorkspace(workspaceId: WorkspaceId): Promise<SessionId> {
+    const workspace = this.list.getSnapshot().items.find(item => item.workspaceId === workspaceId)
+    if (workspace === undefined) throw new Error(`workspaces.connectWorkspace: unknown workspace ${workspaceId}`)
+    // Coalesce concurrent connects: a create's summary lands without cwd
+    // until the host frame arrives, so a second call inside that window
+    // would miss the reuse scan and mint another hidden blank session.
+    const inflight = this.connecting.get(workspaceId)
+    if (inflight !== undefined) return inflight
+    // Reuse: blank && same canonical cwd (workspace.path is the host realpath
+    // canon; summary cwd is the session header passthrough of the same canon).
+    const sessions = this.sessions.list.getSnapshot()
+    for (const id of sessions.ids) {
+      const summary = sessions.byId[id]
+      if (summary !== undefined && summary.blank && summary.cwd === workspace.path) return summary.id
+    }
+    const attempt = this.sessions.create({ workspaceId })
+      .finally(() => { this.connecting.delete(workspaceId) })
+    this.connecting.set(workspaceId, attempt)
+    return attempt
+  }
+
+  /**
+   * Follow the first complete Workspace/Session baseline and select a default
+   * session exactly once. A restored current session wins; otherwise the most
+   * recent Workspace is connected (reusing or creating its blank session).
+   * Later explicit clears stay cleared instead of retriggering this startup
+   * policy. A failed connect may retry on the next baseline projection.
+   * @returns disposer for the baseline subscription; late work cannot navigate after disposal.
+   */
+  startInitialSelection(): () => void {
+    if (this.initialSelectionStarted) {
+      throw new Error('workspaces.startInitialSelection: already started')
+    }
+    this.initialSelectionStarted = true
+    let state: 'waiting' | 'connecting' | 'done' = 'waiting'
+    let disposed = false
+    const reconcile = (): void => {
+      if (disposed || state !== 'waiting') return
+      const workspace = this.list.getSnapshot()
+      if (!workspace.baselinesReady) return
+      const current = this.sessions.list.getSnapshot().current
+      const target = workspace.recentWorkspaceId
+      if (current !== undefined || target === undefined) {
+        state = 'done'
+        return
       }
-    } finally {
-      this.composingIntent = false
-      this.project()
+      state = 'connecting'
+      void this.connectWorkspace(target).then(
+        (sessionId) => {
+          if (disposed) return
+          if (this.sessions.list.getSnapshot().current === undefined) {
+            this.sessions.open(sessionId)
+          }
+          state = 'done'
+        },
+        (reason: unknown) => {
+          if (disposed) return
+          state = 'waiting'
+          console.warn('initial workspace selection failed:', reason)
+        },
+      )
+    }
+    const unsubscribe = this.list.subscribe(reconcile)
+    reconcile()
+    return () => {
+      disposed = true
+      unsubscribe()
     }
   }
 
-  /** Connect the current frontend Workspace and Session, then flush the Session-owned prompt. */
-  sendSession(): void {
-    const session = this.sessions.intent()
-    const target = session?.getSnapshot().intent?.target
-    if (session === undefined || target === undefined) return
-    if (target.kind === 'workspace') {
-      session.connect(target.workspaceId)
+  /**
+   * The shared New Session action behind the shell entry points (sidebar
+   * button, workspace browser): resolve the target Workspace — explicit wins,
+   * else the recent-Workspace projection — connect its blank session and
+   * navigate there; with no Workspace at all, clear the selection into the
+   * New Session view state. Connect failures are non-fatal (console
+   * diagnostics; the current view stays usable).
+   * @param workspaceId - explicit target Workspace for scoped actions.
+   */
+  startSession(workspaceId?: WorkspaceId): void {
+    const target = workspaceId ?? this.list.getSnapshot().recentWorkspaceId
+    if (target === undefined) {
+      this.sessions.clear()
       return
     }
-    if (session.getSnapshot().pendingPrompt?.text.trim() === '') return
-    void this.manager.materializeIntent().then((result) => {
-      if (this.sessions.intent() !== session) return
-      if (result?.ok) {
-        session.connect(result.value.workspace.workspaceId)
-      }
-    })
+    void this.connectWorkspace(target).then(
+      (sessionId) => { this.sessions.open(sessionId) },
+      (reason: unknown) => { console.warn('new session failed:', reason) },
+    )
   }
 
   /**
@@ -153,20 +215,15 @@ export class WorkspacesService {
   private project(): void {
     const workspace = this.manager.getSnapshot()
     const sessions = this.sessions.list.getSnapshot()
-    if (workspace.intent !== undefined && sessions.intent?.target.kind !== 'workspace-intent') {
-      this.manager.discardIntent()
-      return
-    }
     const baselinesReady = workspace.phase === 'ready' && sessions.phase === 'ready'
     this.list.set({
-      ...workspace,
+      items: workspace.items,
+      state: workspace.state,
+      phase: workspace.phase,
+      error: workspace.error,
       baselinesReady,
       recentWorkspaceId: baselinesReady ? recentWorkspace(workspace.items, sessions.byId) : undefined,
     })
-    if (!this.initialSessionResolved && baselinesReady) {
-      this.initialSessionResolved = true
-      if (sessions.current === undefined && sessions.intent === undefined) this.startSession()
-    }
   }
 }
 

packages/client/runtime/tests/client-apply.spec.ts

@@ -8,7 +8,9 @@ import { describe, expect, it } from 'vitest'
 import type { ConnectionHandle } from '@deepseek-ai/dsh-client-connection/client'
 import type { ConnectionSinks } from '@deepseek-ai/dsh-client-connection/client'
 import * as RuntimeClient from '../src/client/index.ts'
-import { FakeApiClient } from './fake-api.ts'
+import type { SessionsService } from '../src/client/sessions/service.ts'
+import type { WorkspacesService } from '../src/client/workspaces/service.ts'
+import { FakeApiClient, ok } from './fake-api.ts'
 
 interface Bench {
   ctx: Context
@@ -33,6 +35,10 @@ async function mount(): Promise<Bench> {
   return bench
 }
 
+async function flushMicrotasks(): Promise<void> {
+  for (let i = 0; i < 12; i++) await Promise.resolve()
+}
+
 describe('runtime client apply', () => {
   it('mounts slots, Sessions, and Workspaces and fans host frames into both managers', async () => {
     const bench = await mount()
@@ -50,7 +56,7 @@ describe('runtime client apply', () => {
     // Frame sinks reach the object layer: a host session-added lands in the list store.
     bench.sinks?.onHostEnvelope?.({
       rpcId: 'r1' as never,
-      payload: { type: 'host/session-added', sessionId: 's-new' } as never,
+      payload: { type: 'host/session-added', blank: true, sessionId: 's-new' } as never,
     })
     await Promise.resolve()
     expect((sessions as { list: { getSnapshot(): { ids: string[] } } }).list.getSnapshot().ids).toContain('s-new')
@@ -71,6 +77,31 @@ describe('runtime client apply', () => {
     bench.sinks?.onConnected?.()
   })
 
+  it('selects the recent Workspace once when the first baselines have no current session', async () => {
+    const bench = await mount()
+    bench.api.onWorkspaceList = () => Promise.resolve(ok({
+      items: [{
+        workspaceId: 'w-recent', path: '/w/recent', title: 'recent', sessionIds: [],
+        createdAt: '2026-01-01T00:00:00.000Z', updatedAt: '2026-01-01T00:00:00.000Z',
+      }] as never[],
+    }))
+    bench.api.onList = () => Promise.resolve(ok({ items: [] }))
+
+    bench.sinks?.onConnected?.()
+    await flushMicrotasks()
+
+    const sessions = bench.ctx.get('sessions') as SessionsService
+    const workspaces = bench.ctx.get('workspaces') as WorkspacesService
+    expect(bench.api.callsOf('session.create')).toEqual([{ workspaceId: 'w-recent' }])
+    expect(sessions.list.getSnapshot().current).toBe('fk-new')
+
+    sessions.clear()
+    await workspaces.refresh()
+    await flushMicrotasks()
+    expect(sessions.list.getSnapshot().current).toBeUndefined()
+    expect(bench.api.callsOf('session.create')).toHaveLength(1)
+  })
+
   it('stops the stream loop when the plugin fiber unloads', async () => {
     const bench = await mount()
     const fiber = [...bench.ctx.registry.values()].find(f => f.name?.includes('client'))

packages/client/runtime/tests/fake-api.ts

@@ -2,7 +2,8 @@
 // data source on a real clock; behavior tests need per-case responses and
 // deferred-controlled timing). Streams are hand pumps: pushMux/pushHost.
 import type {
-  ClientResponse, HostFrame, IApiClient, MuxFrame, RpcError, RpcReceipt, RpcRequest, RpcResponse, SessionId,
+  ClientResponse, CommandDescriptor, CommandExecuteResult, HostFrame, IApiClient, MuxFrame,
+  RpcError, RpcReceipt, RpcRequest, RpcResponse, SessionId, SkillEntry,
   WorkspaceId, WorkspaceView,
 } from '@deepseek-ai/dsh-client-connection/client'
 import { RpcId } from '@deepseek-ai/dsh-client-connection/client'
@@ -106,6 +107,25 @@ export class FakeApiClient implements IApiClient {
       this.record('workspace.insertSessionBefore', payload, this.onWorkspaceInsertSessionBefore(payload)),
   }
 
+  // Payloads stay `unknown` (lint-lane note above); response rows are the real
+  // wire shapes so cases can program requires-bearing catalogs and dual-address
+  // skill lists without casts.
+  onCommandList: (payload: unknown) => Promise<RpcResponse<{ commands: CommandDescriptor[] }>>
+    = () => Promise.resolve(ok({ commands: [] }))
+  onCommandExecute: (payload: unknown) => Promise<RpcResponse<{ matched: boolean; result?: CommandExecuteResult }>>
+    = () => Promise.resolve(ok({ matched: false }))
+  onSkillList: (payload: unknown) => Promise<RpcResponse<{ skills: SkillEntry[] }>>
+    = () => Promise.resolve(ok({ skills: [] }))
+
+  readonly commands: IApiClient['commands'] = {
+    list: (payload: unknown) => this.record('command.list', payload, this.onCommandList(payload)),
+    execute: (payload: unknown) => this.record('command.execute', payload, this.onCommandExecute(payload)),
+  }
+
+  readonly skills: IApiClient['skills'] = {
+    list: (payload: unknown) => this.record('skill.list', payload, this.onSkillList(payload)),
+  }
+
   /** When true, streams never fire onOpen (misbehaving-carrier material for the handshake timeout guard). */
   suppressStreamOpen = false
 

packages/client/runtime/tests/lineage.spec.ts

@@ -8,7 +8,7 @@ import type { SessionId, SessionSummary } from '@deepseek-ai/dsh-client-connecti
 import { flattenLineage } from '../src/client/sessions/lineage.ts'
 
 const s = (id: string, updatedAt: number, parent?: string): SessionSummary => ({
-  sessionId: id as SessionId, updatedAt, running: false,
+  sessionId: id as SessionId, updatedAt, running: false, blank: false,
   ...(parent !== undefined ? { parentSessionId: parent as SessionId } : {}),
 })
 

packages/client/runtime/tests/manager.spec.ts

@@ -12,8 +12,10 @@ import { entries, plainTurn } from './event-script.ts'
 const S1 = 'fk-m1' as SessionId
 const S2 = 'fk-m2' as SessionId
 
-function summary(sessionId: SessionId, over: Partial<{ updatedAt: number; running: boolean; parentSessionId: SessionId }> = {}) {
-  return { sessionId, updatedAt: 100, running: false, ...over }
+type SummaryOver = Partial<{ updatedAt: number; running: boolean; blank: boolean; parentSessionId: SessionId }>
+
+function summary(sessionId: SessionId, over: SummaryOver = {}) {
+  return { sessionId, updatedAt: 100, running: false, blank: false, ...over }
 }
 
 describe('instances', () => {
@@ -81,7 +83,7 @@ describe('list lifecycle', () => {
     const hydration = manager.refreshList()
     manager.handleHostEnvelope({
       rpcId: 'during-first' as never,
-      payload: { type: 'host/session-added', sessionId: S2 },
+      payload: { type: 'host/session-added', blank: true, sessionId: S2 },
     })
     first.resolve(ok({ items: [summary(S1)] as never[] }))
     await hydration
@@ -157,7 +159,7 @@ describe('list lifecycle', () => {
     expect(titled.items[1]?.title).toBeUndefined()
 
     manager.handleHostEnvelope({ rpcId: 'removed' as never, payload: { type: 'host/session-removed', sessionId: S1 } })
-    manager.handleHostEnvelope({ rpcId: 'readded' as never, payload: { type: 'host/session-added', sessionId: S1 } })
+    manager.handleHostEnvelope({ rpcId: 'readded' as never, payload: { type: 'host/session-added', blank: true, sessionId: S1 } })
     expect(manager.getListSnapshot().items.find(item => item.sessionId === S1)?.title).toBeUndefined()
   })
 
@@ -196,8 +198,8 @@ describe('host frame routing', () => {
   it('adds/removes/flips sessions from host frames and keeps removed instances resident', async () => {
     const api = new FakeApiClient()
     const manager = new SessionManager(api)
-    manager.handleHostEnvelope({ rpcId: 'h1' as never, payload: { type: 'host/session-added', sessionId: S1 } })
-    manager.handleHostEnvelope({ rpcId: 'h2' as never, payload: { type: 'host/session-added', sessionId: S1 } }) // dup: ignored
+    manager.handleHostEnvelope({ rpcId: 'h1' as never, payload: { type: 'host/session-added', blank: true, sessionId: S1 } })
+    manager.handleHostEnvelope({ rpcId: 'h2' as never, payload: { type: 'host/session-added', blank: true, sessionId: S1 } }) // dup: ignored
     expect(manager.getListSnapshot().items).toHaveLength(1)
 
     const session = manager.get(S1)
@@ -273,14 +275,14 @@ describe('remaining branches', () => {
 
     manager.handleHostEnvelope({
       rpcId: 'published-later' as never,
-      payload: { type: 'host/session-added', sessionId: S1, cwd: '/w/one' },
+      payload: { type: 'host/session-added', blank: true, sessionId: S1, cwd: '/w/one' },
     })
     expect(manager.getListSnapshot().items).toEqual([
       expect.objectContaining({ sessionId: S1, cwd: '/w/one' }),
     ])
     manager.handleHostEnvelope({
       rpcId: 'duplicate-frame' as never,
-      payload: { type: 'host/session-added', sessionId: S1, cwd: '/w/one' },
+      payload: { type: 'host/session-added', blank: true, sessionId: S1, cwd: '/w/one' },
     })
     expect(manager.getListSnapshot().items).toHaveLength(1)
   })
@@ -295,7 +297,7 @@ describe('remaining branches', () => {
     expect(notified).toBeGreaterThan(0)
     const seen = notified
     unsubscribe()
-    manager.handleHostEnvelope({ rpcId: 'h' as never, payload: { type: 'host/session-added', sessionId: S1 } })
+    manager.handleHostEnvelope({ rpcId: 'h' as never, payload: { type: 'host/session-added', blank: true, sessionId: S1 } })
     await new Promise(resolve => setTimeout(resolve, 0))
     expect(notified).toBe(seen)
   })
@@ -334,8 +336,8 @@ describe('remaining branches', () => {
   it('carries parentSessionId from host/session-added into the lineage row', () => {
     const api = new FakeApiClient()
     const manager = new SessionManager(api)
-    manager.handleHostEnvelope({ rpcId: 'h1' as never, payload: { type: 'host/session-added', sessionId: S1 } })
-    manager.handleHostEnvelope({ rpcId: 'h2' as never, payload: { type: 'host/session-added', sessionId: S2, parentSessionId: S1 } })
+    manager.handleHostEnvelope({ rpcId: 'h1' as never, payload: { type: 'host/session-added', blank: true, sessionId: S1 } })
+    manager.handleHostEnvelope({ rpcId: 'h2' as never, payload: { type: 'host/session-added', blank: true, sessionId: S2, parentSessionId: S1 } })
     const items = manager.getListSnapshot().items
     expect(items.find(e => e.sessionId === S2)).toMatchObject({ parentSessionId: S1, depth: 1 })
   })

packages/client/runtime/tests/queue-store.spec.ts

@@ -0,0 +1,193 @@
+/**
+ * Queue mirror semantics (web input-triggers queue cut 1): session/queued
+ * intake, host-rule retirement (message turn/start claims oldest non-steering;
+ * steering/message drains by source), leave-running sweep, reconnect reset,
+ * pre-instantiation buffering, and snapshot reference stability.
+ */
+import { describe, expect, it } from 'vitest'
+import type { ContentBlock } from '@deepseek-ai/dsh-llm/types'
+import type { MuxFrame, RpcId, SessionId } from '@deepseek-ai/dsh-client-connection/client'
+import { Session } from '../src/client/sessions/session.ts'
+import { SessionManager } from '../src/client/sessions/manager.ts'
+import { FakeApiClient } from './fake-api.ts'
+import { ev } from './event-script.ts'
+
+const SID = 'fk-q1' as SessionId
+const text = (t: string): ContentBlock[] => [{ type: 'text', text: t }]
+const rid = (id: string): RpcId => id as RpcId
+
+/** session/queued frame with the wire-sourced rpcId key (the host prompt path). */
+function queuedFrame(body: string, rpcId: string, steering = false): MuxFrame {
+  return {
+    type: 'session/queued', sessionId: SID, content: text(body),
+    source: { kind: 'user', rpcId: rid(rpcId) } as never, steering,
+  }
+}
+
+function makeSession(): Session {
+  return new Session(SID, new FakeApiClient())
+}
+
+describe('queue intake', () => {
+  it('lands a queued frame as a row keyed by the source rpcId with a flat preview', () => {
+    const session = makeSession()
+    session.handleMuxEnvelope(rid('env-1'), queuedFrame('第一条  排队\n消息', 'p-1'))
+    const queue = session.getSnapshot().queue
+    expect(queue).toEqual([{ key: 'p-1', preview: '第一条 排队 消息' }])
+  })
+
+  it('falls back to the envelope rpcId when the source carries none, and tags non-text blocks', () => {
+    const session = makeSession()
+    session.handleMuxEnvelope(rid('env-2'), {
+      type: 'session/queued', sessionId: SID,
+      content: [{ type: 'text', text: 'hi' }, { type: 'image', data: 'x' } as never],
+      source: { kind: 'plugin', plugin: 'loop' }, steering: false,
+    })
+    expect(session.getSnapshot().queue).toEqual([{ key: 'f:env-2', preview: 'hi [image]' }])
+  })
+
+  it('caps the preview at 200 code points with an ellipsis', () => {
+    const session = makeSession()
+    session.handleMuxEnvelope(rid('env-3'), queuedFrame('长'.repeat(201), 'p-cap'))
+    const preview = session.getSnapshot().queue[0]?.preview ?? ''
+    expect(Array.from(preview)).toHaveLength(201) // 200 + …
+    expect(preview.endsWith('…')).toBe(true)
+  })
+
+  it('keeps the queue array reference stable across unrelated snapshot swaps', () => {
+    const session = makeSession()
+    session.handleMuxEnvelope(rid('env-4'), queuedFrame('稳定', 'p-s'))
+    const before = session.getSnapshot().queue
+    session.handleAgentError('unrelated') // dirties the snapshot without touching the queue
+    expect(session.getSnapshot().queue).toBe(before)
+  })
+})
+
+describe('queue retirement (host queuedMirror rules)', () => {
+  it('a message-triggered turn/start claims the oldest non-steering row', () => {
+    const session = makeSession()
+    session.handleMuxEnvelope(rid('e1'), queuedFrame('先', 'p-1'))
+    session.handleMuxEnvelope(rid('e2'), queuedFrame('后', 'p-2'))
+    session.handleMuxEnvelope(rid('e3'), { type: 'session/event', sessionId: SID, event: ev.turnStart(0, 0) })
+    expect(session.getSnapshot().queue.map(r => r.key)).toEqual(['p-2'])
+  })
+
+  it('an injection-triggered turn/start claims nothing', () => {
+    const session = makeSession()
+    session.handleMuxEnvelope(rid('e1'), queuedFrame('留', 'p-1'))
+    const injection = {
+      ...ev.turnStart(0, 0),
+      data: { turn: 0, trigger: { kind: 'injection', source: { kind: 'plugin', plugin: 'x' } } },
+    } as never
+    session.handleMuxEnvelope(rid('e2'), { type: 'session/event', sessionId: SID, event: injection })
+    expect(session.getSnapshot().queue).toHaveLength(1)
+  })
+
+  it('steering/message drains the source-matched steering row only', () => {
+    const session = makeSession()
+    session.handleMuxEnvelope(rid('e1'), queuedFrame('普通', 'p-1'))
+    session.handleMuxEnvelope(rid('e2'), queuedFrame('插话', 'p-2', true))
+    // Loop-authored steering (different source) must not consume the user entry.
+    const foreignSteering = {
+      seq: 0, time: 1,
+      type: 'steering/message', surfaceOp: 'append',
+      data: { turn: 0, content: text('loop'), source: { kind: 'plugin', plugin: 'loop' } },
+    } as never
+    session.handleMuxEnvelope(rid('e3'), { type: 'session/event', sessionId: SID, event: foreignSteering })
+    expect(session.getSnapshot().queue).toHaveLength(2)
+    const matchedSteering = {
+      seq: 1, time: 2,
+      type: 'steering/message', surfaceOp: 'append',
+      data: { turn: 0, content: text('插话'), source: { kind: 'user', rpcId: rid('p-2') } },
+    } as never
+    session.handleMuxEnvelope(rid('e4'), { type: 'session/event', sessionId: SID, event: matchedSteering })
+    expect(session.getSnapshot().queue.map(r => r.key)).toEqual(['p-1'])
+  })
+
+  it('a leave-running flip sweeps the whole mirror (cancel/terminal-drop cover)', () => {
+    const session = makeSession()
+    session.handleRunning(true)
+    session.handleMuxEnvelope(rid('e1'), queuedFrame('一', 'p-1'))
+    session.handleMuxEnvelope(rid('e2'), queuedFrame('二', 'p-2', true))
+    session.handleRunning(false)
+    expect(session.getSnapshot().queue).toEqual([])
+  })
+
+  it('a stale not-running relay on an idle session still sweeps replayed rows', () => {
+    const session = makeSession()
+    session.handleMuxEnvelope(rid('e1'), queuedFrame('孤儿', 'p-1'))
+    session.handleRunning(false) // running already false: equality path must not skip the sweep
+    expect(session.getSnapshot().queue).toEqual([])
+  })
+})
+
+describe('queue reconnect semantics', () => {
+  it('session/subscribed re-baselines the mirror: stale rows drop, the following snapshot lands fresh', () => {
+    const session = makeSession()
+    session.handleMuxEnvelope(rid('e1'), queuedFrame('旧连接', 'p-old'))
+    // New mux generation: subscribed arrives first on the same stream...
+    session.handleMuxEnvelope(rid('e2'), { type: 'session/subscribed', sessionId: SID, lastSeq: 10 })
+    expect(session.getSnapshot().queue).toEqual([])
+    // ...then the queue snapshot replays the live inbox.
+    session.handleMuxEnvelope(rid('e3'), queuedFrame('新基线', 'p-new'))
+    expect(session.getSnapshot().queue.map(r => r.key)).toEqual(['p-new'])
+  })
+
+  it('resync must NOT clear the mirror (regression: onConnected races the mux baseline)', async () => {
+    const session = makeSession()
+    // Reconnect ordering that broke: mux opened first and already delivered
+    // the fresh generation's baseline; host stream (and with it onConnected →
+    // resync) lands after. The host never resends — clearing here left the
+    // dock empty until the next enqueue.
+    session.handleMuxEnvelope(rid('e1'), { type: 'session/subscribed', sessionId: SID, lastSeq: 5 })
+    session.handleMuxEnvelope(rid('e2'), queuedFrame('新基线', 'p-fresh'))
+    await session.resync()
+    expect(session.getSnapshot().queue.map(r => r.key)).toEqual(['p-fresh'])
+  })
+})
+
+describe('manager buffering of queued frames', () => {
+  it('buffers session/queued for uninstantiated sessions and replays before the running sync', () => {
+    const api = new FakeApiClient()
+    const manager = new SessionManager(api)
+    manager.handleMuxEnvelope({ rpcId: rid('b1'), payload: queuedFrame('预热', 'p-b1') })
+    // Instantiation replays the buffer; no summary exists, so no running sweep runs.
+    const session = manager.get(SID)
+    expect(session.getSnapshot().queue.map(r => r.key)).toEqual(['p-b1'])
+    // The buffer is consumed: a second get must not double-replay.
+    expect(manager.get(SID).getSnapshot().queue).toHaveLength(1)
+  })
+
+  it('a not-running list summary sweeps replayed rows at instantiation', async () => {
+    const api = new FakeApiClient()
+    api.onList = () => Promise.resolve(ok([{ sessionId: SID, updatedAt: 1, running: false }]))
+    const manager = new SessionManager(api)
+    await manager.refreshList()
+    manager.handleMuxEnvelope({ rpcId: rid('b2'), payload: queuedFrame('该扫掉', 'p-b2') })
+    expect(manager.get(SID).getSnapshot().queue).toEqual([])
+  })
+
+  it('subscribed re-baselines the uninstantiated buffer: stale queued frames drop, non-queue frames survive (regression: reconnect duplication)', () => {
+    const api = new FakeApiClient()
+    const manager = new SessionManager(api)
+    // Generation 1 baseline lands while the session is uninstantiated, along
+    // with a pending approval (never re-derivable from history).
+    manager.handleMuxEnvelope({ rpcId: rid('g1a'), payload: queuedFrame('第一代', 'p-g1') })
+    manager.handleMuxEnvelope({
+      rpcId: rid('g1b'),
+      payload: { type: 'approval/requested', sessionId: SID, approvalId: 'ap-1' as never, toolName: 'bash' },
+    })
+    // Reconnect: generation 2 replays subscribed + the SAME live queue entry.
+    manager.handleMuxEnvelope({ rpcId: rid('g2a'), payload: { type: 'session/subscribed', sessionId: SID, lastSeq: 3 } })
+    manager.handleMuxEnvelope({ rpcId: rid('g2b'), payload: queuedFrame('第一代', 'p-g1') })
+    const snapshot = manager.get(SID).getSnapshot()
+    // One queue row (no duplicate batch); the approval survived the re-baseline.
+    expect(snapshot.queue.map(r => r.key)).toEqual(['p-g1'])
+    expect(snapshot.pending.map(p => p.kind)).toEqual(['approval'])
+  })
+})
+
+/** ok wrapper with a typed items payload (the shared helper pins value to never[]). */
+function ok(items: { sessionId: SessionId; updatedAt: number; running: boolean }[]) {
+  return { rpcId: rid(`ok-${items.length}`), result: { ok: true as const, value: { items: items as never[] } } }
+}

packages/client/runtime/tests/scope.spec.ts

@@ -0,0 +1,84 @@
+/**
+ * Agent-scope primitive spec: the actx minted by createScope carries the
+ * tag and the dispatch filter itself, so plain cordis dispatch with the actx
+ * as subject routes by agent — same-agent tagged listeners receive,
+ * foreign-agent ones are filtered out, untagged listeners hear everything,
+ * and a subject-less root dispatch stays unfiltered. Scope-owned listeners
+ * dispose with the fiber.
+ */
+import { Context } from 'cordis'
+import { describe, expect, it } from 'vitest'
+import type { SessionId } from '@deepseek-ai/dsh-client-connection/client'
+import { createScope, scopeOf } from '../src/client/agents/scope.ts'
+
+const sid = (k: string): SessionId => k as SessionId
+
+declare module 'cordis' {
+  interface Events {
+    /**
+     * Test-only routed probe event.
+     * @param payload - marker payload.
+     * @mode bail
+     */
+    'test/scope-probe'(payload: { from: string }): true | undefined
+  }
+}
+
+function bench() {
+  const root = new Context()
+  const a = createScope(root, sid('a'))
+  const b = createScope(root, sid('b'))
+  const seen: string[] = []
+  const listen = (label: string, ctx: Context, answer?: true) => {
+    ctx.on('test/scope-probe', (payload) => {
+      seen.push(`${label}:${payload.from}`)
+      return answer
+    })
+  }
+  return { root, a, b, seen, listen }
+}
+
+describe('createScope', () => {
+  it('tags the ctx (scopeOf) and leaves the root untagged', () => {
+    const { root, a } = bench()
+    expect(scopeOf(a.ctx)).toBe(sid('a'))
+    expect(scopeOf(root)).toBeUndefined()
+  })
+
+  it('scoped dispatch reaches same-session and untagged listeners, never a foreign session', () => {
+    const { root, a, b, seen, listen } = bench()
+    listen('a', a.ctx)
+    listen('b', b.ctx)
+    listen('root', root)
+    a.ctx.bail(a.ctx, 'test/scope-probe', { from: 'a' })
+    expect(seen).toEqual(['a:a', 'root:a'])
+    seen.length = 0
+    b.ctx.emit(b.ctx, 'test/scope-probe', { from: 'b' })
+    expect(seen).toEqual(['b:b', 'root:b'])
+  })
+
+  it('bail answers the first same-scope listener and skips filtered foreign ones', () => {
+    const { a, b, listen } = bench()
+    listen('b', b.ctx, true) // registered first, but foreign → filtered out
+    expect(a.ctx.bail(a.ctx, 'test/scope-probe', { from: 'a' })).toBeUndefined()
+    listen('a', a.ctx, true)
+    expect(a.ctx.bail(a.ctx, 'test/scope-probe', { from: 'a' })).toBe(true)
+  })
+
+  it('a subject-less root dispatch is unfiltered (every listener hears it)', () => {
+    const { root, a, b, seen, listen } = bench()
+    listen('a', a.ctx)
+    listen('b', b.ctx)
+    listen('root', root)
+    root.emit('test/scope-probe', { from: 'root' })
+    expect(seen).toEqual(['a:root', 'b:root', 'root:root'])
+  })
+
+  it('fiber disposal removes scope-owned listeners', async () => {
+    const { a, seen, listen } = bench()
+    listen('a', a.ctx)
+    await a.fiber.dispose()
+    a.ctx.emit(a.ctx, 'test/scope-probe', { from: 'late' })
+    expect(seen).toEqual([])
+  })
+})

packages/client/runtime/tests/session-intents.spec.ts

@@ -1,219 +0,0 @@
-import { Context } from 'cordis'
-import { describe, expect, it, vi } from 'vitest'
-import type { SessionId, WorkspaceId, WorkspaceView } from '@deepseek-ai/dsh-client-connection/client'
-import { SessionsService } from '../src/client/sessions/service.ts'
-import { WorkspacesService } from '../src/client/workspaces/service.ts'
-import { FakeApiClient, deferred, err, ok } from './fake-api.ts'
-
-const sid = (id: string): SessionId => id as SessionId
-const wid = (id: string): WorkspaceId => id as WorkspaceId
-
-function workspace(id: string, sessionIds: SessionId[] = []): WorkspaceView {
-  return {
-    workspaceId: wid(id),
-    path: `/w/${id}`,
-    title: id,
-    sessionIds,
-    createdAt: '2026-01-01T00:00:00.000Z',
-    updatedAt: '2026-01-01T00:00:00.000Z',
-  }
-}
-
-async function ready(
-  api: FakeApiClient,
-  workspaces: WorkspacesService,
-  sessions: SessionsService,
-  workspaceRows: WorkspaceView[],
-  sessionRows: { sessionId: SessionId; updatedAt: number; running: boolean }[] = [],
-): Promise<void> {
-  api.onWorkspaceList = () => Promise.resolve(ok({ items: workspaceRows as never[] }))
-  api.onList = () => Promise.resolve(ok({ items: sessionRows as never[] }))
-  await Promise.all([workspaces.refresh(), sessions.refresh()])
-  await Promise.resolve()
-}
-
-function services(api: FakeApiClient): { sessions: SessionsService; workspaces: WorkspacesService } {
-  const ctx = new Context()
-  const sessions = new SessionsService(ctx, api)
-  const workspaces = new WorkspacesService(ctx, api, sessions)
-  return { sessions, workspaces }
-}
-
-function pendingPrompt(sessions: SessionsService, sessionId: SessionId) {
-  return sessions.binding(sessionId)?.session.getSnapshot().pendingPrompt
-}
-
-describe('frontend Session and Workspace intents', () => {
-  it('resolves the initial intent into the most recently active Workspace', async () => {
-    const api = new FakeApiClient()
-    const { sessions, workspaces } = services(api)
-    const old = workspace('old', [sid('s-old')])
-    const recent = workspace('recent', [sid('s-recent')])
-    await ready(api, workspaces, sessions, [old, recent], [
-      { sessionId: sid('s-old'), updatedAt: 1, running: false },
-      { sessionId: sid('s-recent'), updatedAt: 2, running: false },
-    ])
-    expect(sessions.list.getSnapshot().intent).toMatchObject({
-      target: { kind: 'workspace', workspaceId: 'recent' },
-      phase: 'ready',
-    })
-    expect(workspaces.list.getSnapshot().intent).toBeUndefined()
-  })
-
-  it('echoes updateIntent into the list snapshot in the same tick (controlled-input contract)', async () => {
-    const api = new FakeApiClient()
-    const { sessions, workspaces } = services(api)
-    await ready(api, workspaces, sessions, [workspace('target')])
-    let notified = 0
-    sessions.list.subscribe(() => { notified += 1 })
-    // IME composition drives change events that a controlled textarea must see
-    // reflected before the handler returns; a microtask-deferred echo makes
-    // React roll the DOM back and the composition commits partial keystrokes.
-    sessions.updateIntent('你')
-    expect(sessions.list.getSnapshot().intent?.prompt).toBe('你')
-    expect(notified).toBeGreaterThan(0)
-  })
-
-  it('ignores updateIntent with no active Intent', async () => {
-    const api = new FakeApiClient()
-    const { sessions, workspaces } = services(api)
-    await ready(api, workspaces, sessions, [workspace('only', [sid('s-real')])], [
-      { sessionId: sid('s-real'), updatedAt: 1, running: false },
-    ])
-    sessions.open(sid('s-real'))
-    expect(sessions.list.getSnapshot().intent).toBeUndefined()
-    let notified = 0
-    sessions.list.subscribe(() => { notified += 1 })
-    sessions.updateIntent('dropped')
-    expect(notified).toBe(0)
-  })
-
-  it('materializes zero-state Workspace and Session intents and retains a rejected first prompt', async () => {
-    const api = new FakeApiClient()
-    const { sessions, workspaces } = services(api)
-    await ready(api, workspaces, sessions, [])
-    expect(workspaces.list.getSnapshot().intent).toMatchObject({ name: 'workspace', phase: 'ready' })
-    sessions.updateIntent('first prompt')
-    api.onWorkspaceCreate = () => Promise.resolve(ok({ workspace: workspace('created'), created: true }))
-    api.onCreate = payload => Promise.resolve(ok({
-      sessionId: (payload as { sessionId: SessionId }).sessionId,
-    }))
-    api.onPrompt = () => Promise.resolve(err({ code: 'internal', message: 'prompt offline', details: {} }))
-    workspaces.sendSession()
-    await vi.waitFor(() => {
-      const sessionId = sessions.list.getSnapshot().current as SessionId
-      expect(pendingPrompt(sessions, sessionId)).toMatchObject({
-        text: 'first prompt', phase: 'failed', retry: 'send',
-      })
-    })
-    expect(api.callsOf('workspace.create')).toEqual([{ name: 'workspace' }])
-    const create = api.callsOf('session.create')[0] as { workspaceId: WorkspaceId; sessionId: SessionId }
-    expect(create.workspaceId).toBe('created')
-    expect(api.callsOf('session.prompt')).toEqual([{
-      sessionId: create.sessionId,
-      mode: 'queue',
-      content: [{ type: 'text', text: 'first prompt' }],
-    }])
-    expect(workspaces.list.getSnapshot().intent).toBeUndefined()
-  })
-
-  it('turns Workspace attachment failure into a focused real Session and retries its prompt', async () => {
-    const api = new FakeApiClient()
-    const { sessions, workspaces } = services(api)
-    const target = workspace('target')
-    await ready(api, workspaces, sessions, [target])
-    sessions.updateIntent('keep this')
-    api.onCreate = (payload) => {
-      const sessionId = (payload as { sessionId: SessionId }).sessionId
-      return Promise.resolve(err({
-        code: 'workspace-attach-failed',
-        message: 'attach rejected',
-        details: { sessionId, workspaceId: target.workspaceId },
-      }))
-    }
-    workspaces.sendSession()
-    await vi.waitFor(() => {
-      const snapshot = sessions.list.getSnapshot()
-      expect(snapshot.intent).toBeUndefined()
-      expect(pendingPrompt(sessions, snapshot.current as SessionId)).toMatchObject({
-        text: 'keep this', phase: 'failed', retry: 'connect',
-      })
-    })
-    const published = sessions.list.getSnapshot().current as SessionId
-    const session = sessions.binding(published)!.session
-    session.updatePendingPrompt('retry this')
-    api.onCreate = () => Promise.resolve(ok({ sessionId: published }))
-    session.retryPendingPrompt()
-    await vi.waitFor(() => {
-      expect(pendingPrompt(sessions, published)).toBeNull()
-    })
-    expect(api.callsOf('session.prompt').at(-1)).toMatchObject({
-      sessionId: published,
-      content: [{ type: 'text', text: 'retry this' }],
-    })
-  })
-
-  it('does not send after navigation while Session creation is in flight', async () => {
-    const api = new FakeApiClient()
-    const { sessions, workspaces } = services(api)
-    const target = workspace('target')
-    await ready(api, workspaces, sessions, [target])
-    const gate = deferred<Awaited<ReturnType<FakeApiClient['onCreate']>>>()
-    api.onCreate = () => gate.promise
-    sessions.updateIntent('do not send yet')
-    workspaces.sendSession()
-    await vi.waitFor(() => { expect(api.callsOf('session.create')).toHaveLength(1) })
-    const requested = (api.callsOf('session.create')[0] as { sessionId: SessionId }).sessionId
-    workspaces.startSession(target.workspaceId)
-    const replacement = sessions.list.getSnapshot().intent!
-    gate.resolve(ok({ sessionId: requested }))
-    await vi.waitFor(() => {
-      expect(pendingPrompt(sessions, requested)).toMatchObject({
-        text: 'do not send yet', phase: 'failed', retry: 'send',
-      })
-    })
-    expect(api.callsOf('session.prompt')).toEqual([])
-    expect(sessions.list.getSnapshot()).toMatchObject({
-      current: replacement.sessionId,
-      intent: { sessionId: replacement.sessionId },
-    })
-  })
-
-  it('keeps a lost-response Intent and retries creation with its preallocated id', async () => {
-    const api = new FakeApiClient()
-    const { sessions, workspaces } = services(api)
-    const target = workspace('target')
-    await ready(api, workspaces, sessions, [target])
-    sessions.updateIntent('preserve me')
-    api.onCreate = () => Promise.reject(new Error('response lost'))
-    workspaces.sendSession()
-    await vi.waitFor(() => {
-      expect(sessions.list.getSnapshot().intent?.error).toMatchObject({ step: 'session' })
-    })
-    const requested = sessions.list.getSnapshot().intent?.sessionId as SessionId
-    sessions.handleHostEnvelope({
-      rpcId: 'published-later' as never,
-      payload: { type: 'host/session-added', sessionId: requested, cwd: target.path },
-    })
-    expect(sessions.list.getSnapshot()).toMatchObject({
-      current: requested,
-      intent: { sessionId: requested, error: { step: 'session' } },
-    })
-    expect(sessions.intent()?.getSnapshot().pendingPrompt).toMatchObject({
-      text: 'preserve me', phase: 'editing',
-    })
-
-    api.onCreate = payload => Promise.resolve(ok({
-      sessionId: (payload as { sessionId: SessionId }).sessionId,
-    }))
-    workspaces.sendSession()
-    await vi.waitFor(() => {
-      expect(api.callsOf('session.create')).toHaveLength(2)
-      expect(api.callsOf('session.prompt')).toHaveLength(1)
-      expect(sessions.list.getSnapshot()).toMatchObject({ current: requested, intent: undefined })
-      expect(pendingPrompt(sessions, requested)).toBeNull()
-    })
-    expect(api.callsOf('session.create').map(call => (call as { sessionId: SessionId }).sessionId))
-      .toEqual([requested, requested])
-  })
-})

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

@@ -10,7 +10,7 @@ import { Context } from 'cordis'
 import { afterEach, describe, expect, it, vi } from 'vitest'
 import type { SessionId } from '@deepseek-ai/dsh-client-connection/client'
 import { SessionCreateError, SessionsService, scopeOf } from '../src/client/sessions/service.ts'
-import { FakeApiClient, ok } from './fake-api.ts'
+import { FakeApiClient, deferred, ok } from './fake-api.ts'
 
 const sid = (s: string): SessionId => s as SessionId
 
@@ -28,10 +28,12 @@ function bench(): Bench {
 }
 
 /** Refresh the manager list from programmable rows and flush the microtask batch. */
-async function feedList(b: Bench, rows: { id: string; cwd?: string; parentId?: string; running?: boolean }[]): Promise<void> {
+type FeedRow = { id: string; cwd?: string; parentId?: string; running?: boolean; blank?: boolean }
+
+async function feedList(b: Bench, rows: FeedRow[]): Promise<void> {
   b.api.onList = () => Promise.resolve(ok({
     items: rows.map(r => ({
-      sessionId: sid(r.id), updatedAt: 1, running: r.running ?? false,
+      sessionId: sid(r.id), updatedAt: 1, running: r.running ?? false, blank: r.blank ?? false,
       ...(r.cwd !== undefined ? { cwd: r.cwd } : {}),
       ...(r.parentId !== undefined ? { parentSessionId: sid(r.parentId) } : {}),
     })),
@@ -61,7 +63,7 @@ describe('list store projection', () => {
   it('reflects live increments (host stream via manager) into the store', async () => {
     const b = bench()
     await feedList(b, [{ id: 's1' }])
-    b.svc.handleHostEnvelope({ rpcId: 'r1' as never, payload: { type: 'host/session-added', sessionId: sid('s2') } as never })
+    b.svc.handleHostEnvelope({ rpcId: 'r1' as never, payload: { type: 'host/session-added', blank: true, sessionId: sid('s2') } as never })
     await Promise.resolve()
     expect(b.svc.list.getSnapshot().ids).toContain('s2')
   })
@@ -77,7 +79,7 @@ describe('scope tree', () => {
     expect(scopeOf(scoped as Context)).toBe('s1')
     expect(scopeOf(b.ctx)).toBeUndefined()
     const binding = b.svc.binding(sid('s1'))
-    expect(binding?.session).toBe(b.svc.cell('s1')?.session)
+    expect(binding?.session).toBe(b.svc.provideInfo('s1')?.hooks['session'])
     expect(b.svc.binding(sid('s1'))).toBe(binding)
     expect(binding?.ctx).toBe(scoped)
   })
@@ -184,20 +186,20 @@ describe('cell (render-layer session kit)', () => {
   it('resolves an identity-stable {sessionId, session} cell; unknown ids yield undefined', async () => {
     const b = bench()
     await feedList(b, [{ id: 's1' }])
-    const cell = b.svc.cell('s1')
-    expect(cell).toBeDefined()
-    expect(cell?.sessionId).toBe('s1')
-    // The cell carries the observable; hook binding happens in React.
-    expect(cell?.session).toBe(b.svc.binding(sid('s1'))?.session)
-    expect(b.svc.cell('s1')).toBe(cell)
-    expect(b.svc.cell('ghost')).toBeUndefined()
+    const info = b.svc.provideInfo('s1')
+    expect(info).toBeDefined()
+    expect(info?.sessionId).toBe('s1')
+    // The bundle carries bare observables; hook binding happens in React.
+    expect(info?.hooks['session']).toBe(b.svc.binding(sid('s1'))?.session)
+    expect(b.svc.provideInfo('s1')).toBe(info)
+    expect(b.svc.provideInfo('ghost')).toBeUndefined()
   })
 
-  it('cell()/binding() are pure resolution: no staging, no deferred sweep', async () => {
+  it('provideInfo()/binding() are pure resolution: no staging, no deferred sweep', async () => {
     const b = bench()
     await feedList(b, [{ id: 's1' }, { id: 's2' }])
     b.svc.open(sid('s1')) // staged
-    b.svc.cell('s2') // resolution only — must NOT move the stage
+    b.svc.provideInfo('s2') // resolution only — must NOT move the stage
     b.svc.binding(sid('s2'))
     await feedList(b, [{ id: 's2' }]) // s1 removed: still staged → deferred, scope survives
     expect(b.svc.scope(sid('s1'))).toBeDefined()
@@ -209,7 +211,7 @@ describe('cell (render-layer session kit)', () => {
     const historyCalls = () => b.api.calls.filter(c => c.method === 'session.history')
     // Resolution is addressing, not staging: no window pull.
     b.svc.scope(sid('s1'))
-    b.svc.cell('s1')
+    b.svc.provideInfo('s1')
     b.svc.binding(sid('s1'))
     expect(historyCalls()).toHaveLength(0)
     b.svc.open(sid('s1'))
@@ -296,12 +298,24 @@ describe('create', () => {
     const failure = await b.svc.create({ sessionId: sid('candidate') }).catch((error: unknown) => error)
     expect(failure).toBeInstanceOf(SessionCreateError)
     expect(failure).toMatchObject({
-      requestedSessionId: 'candidate', publishedSessionId: undefined,
+      requestedSessionId: 'candidate',
       rpcError: { code: 'internal', message: '爆了' },
     })
   })
 
-  it('surfaces the definitely published id after Workspace attachment fails', async () => {
+  it('resolves with the session already listed and binding-resolvable (no flush wait)', async () => {
+    const b = bench()
+    b.api.onCreate = () => Promise.resolve(ok({ sessionId: sid('born') }))
+    const born = await b.svc.create({ workspaceId: 'ws' as never })
+    // Synchronously after resolution — the draft hand-off contract: the
+    // create echo IS the entity entering the client's view (blank row +
+    // resolvable scope/binding), no notifier flush in between.
+    expect(b.svc.list.getSnapshot().byId[born]).toMatchObject({ id: 'born', blank: true })
+    expect(b.svc.binding(born)).toBeDefined()
+    expect(b.svc.scope(born)).toBeDefined()
+  })
+
+  it('lists the published id after Workspace attachment fails (publication precedes attachment)', async () => {
     const b = bench()
     b.api.onCreate = () => Promise.resolve({
       rpcId: 'attach' as never,
@@ -318,11 +332,111 @@ describe('create', () => {
       sessionId: sid('published'),
     }).catch((error: unknown) => error)
     await Promise.resolve()
+    expect(failure).toBeInstanceOf(SessionCreateError)
     expect(failure).toMatchObject({
-      publishedSessionId: 'published', requestedSessionId: 'published',
+      requestedSessionId: 'published',
       rpcError: { code: 'workspace-attach-failed' },
     })
-    expect(b.svc.list.getSnapshot().byId[sid('published')]).toMatchObject({ id: 'published' })
+    expect(b.svc.list.getSnapshot().byId[sid('published')]).toMatchObject({ id: 'published', blank: true })
+  })
+})
+
+describe('scope lifecycle rides the list mirror (entity parity: no client-side pre-birth)', () => {
+  it('a session-added frame births the row (blank) and makes the scope resolvable; removal prunes it', async () => {
+    const b = bench()
+    await feedList(b, [])
+    expect(b.svc.scope(sid('s-new'))).toBeUndefined() // not in view: no scope, no exceptions
+    b.svc.handleHostEnvelope({
+      rpcId: 'add' as never,
+      payload: { type: 'host/session-added', sessionId: sid('s-new'), blank: true, cwd: '/w/a' } as never,
+    })
+    await Promise.resolve()
+    const scoped = b.svc.scope(sid('s-new'))
+    expect(scoped).toBeDefined()
+    expect(scopeOf(scoped as Context)).toBe('s-new')
+    b.svc.handleHostEnvelope({
+      rpcId: 'rm' as never,
+      payload: { type: 'host/session-removed', sessionId: sid('s-new') },
+    })
+    await Promise.resolve()
+    expect(b.svc.scope(sid('s-new'))).toBeUndefined()
+  })
+})
+
+describe('blank mirror', () => {
+  it('flips blank=false from the running:true status frame (cross-client conversion)', async () => {
+    const b = bench()
+    await feedList(b, [{ id: 's1', blank: true }])
+    expect(b.svc.list.getSnapshot().byId[sid('s1')]).toMatchObject({ blank: true })
+    b.svc.handleHostEnvelope({
+      rpcId: 'st' as never,
+      payload: { type: 'host/session-status', sessionId: sid('s1'), running: true },
+    })
+    await Promise.resolve()
+    expect(b.svc.list.getSnapshot().byId[sid('s1')]).toMatchObject({ blank: false, running: true })
+    // The instantiated Session mirrors the same flip.
+    expect(b.svc.binding(sid('s1'))?.session.getSnapshot().blank).toBe(false)
+  })
+
+  it('flips blank=false on prompt ACCEPTANCE, not on the attempt', async () => {
+    const b = bench()
+    await feedList(b, [{ id: 's1', blank: true, cwd: '/w/a' }])
+    const session = b.svc.binding(sid('s1'))!.session
+    expect(session.getSnapshot().blank).toBe(true)
+    const gate = deferred<Awaited<ReturnType<FakeApiClient['onPrompt']>>>()
+    b.api.onPrompt = () => gate.promise
+    const send = session.prompt([{ type: 'text', text: 'hi' }], 'queue')
+    // In flight: still blank (the flip point is the success response, which
+    // proves the user message reached the host log).
+    expect(session.getSnapshot().blank).toBe(true)
+    gate.resolve(ok({ accepted: true as const }))
+    await send
+    expect(session.getSnapshot().blank).toBe(false)
+    await Promise.resolve()
+    expect(b.svc.list.getSnapshot().byId[sid('s1')]).toMatchObject({ blank: false })
+  })
+
+  it('keeps a rejected first prompt blank: hidden and still reusable', async () => {
+    const b = bench()
+    await feedList(b, [{ id: 's1', blank: true, cwd: '/w/a' }])
+    const session = b.svc.binding(sid('s1'))!.session
+    b.api.onPrompt = () => Promise.resolve({
+      rpcId: 'busy' as never,
+      result: { ok: false as const, error: { code: 'internal' as const, message: 'agent busy', details: {} } },
+    } as never)
+    const result = await session.prompt([{ type: 'text', text: 'hi' }], 'queue')
+    expect(result.ok).toBe(false)
+    // No flip on failure: local stays aligned with the host authority
+    // (events.length still 0), so the session stays hidden and reusable.
+    expect(session.getSnapshot().blank).toBe(true)
+    await Promise.resolve()
+    expect(b.svc.list.getSnapshot().byId[sid('s1')]).toMatchObject({ blank: true })
+  })
+
+  it('takes session-added blank=true as the hidden birth and list blank as reconnect authority', async () => {
+    const b = bench()
+    await feedList(b, [])
+    b.svc.handleHostEnvelope({
+      rpcId: 'add' as never,
+      payload: { type: 'host/session-added', sessionId: sid('s-new'), blank: true, cwd: '/w/a' } as never,
+    })
+    await Promise.resolve()
+    expect(b.svc.list.getSnapshot().byId[sid('s-new')]).toMatchObject({ blank: true })
+    // Reconnect re-pull: the summary's blank=false wins (authoritative alignment).
+    await feedList(b, [{ id: 's-new', blank: false, cwd: '/w/a' }])
+    expect(b.svc.list.getSnapshot().byId[sid('s-new')]).toMatchObject({ blank: false })
+  })
+
+  it('never re-blanks: a stale blank=true summary cannot hide an engaged session', async () => {
+    const b = bench()
+    await feedList(b, [{ id: 's1', blank: true }])
+    const session = b.svc.binding(sid('s1'))!.session
+    await session.prompt([{ type: 'text', text: 'hi' }], 'queue')
+    await Promise.resolve()
+    expect(b.svc.list.getSnapshot().byId[sid('s1')]).toMatchObject({ blank: false })
+    // The next list pull still claims blank (host hasn't logged the message yet).
+    await feedList(b, [{ id: 's1', blank: true }])
+    expect(b.svc.binding(sid('s1'))?.session.getSnapshot().blank).toBe(false)
   })
 })
 

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

@@ -97,13 +97,17 @@ function fakeWorkspaces() {
   return { list: { getSnapshot: () => state, subscribe: () => () => undefined } }
 }
 
-/** Minimal sessions face for the host seam (list observable + cell). */
+/** Minimal sessions face for the host seam (list observable + provide bundle). */
 function fakeSessions() {
   const state = { ids: [], byId: {}, current: undefined as string | undefined }
   return {
     list: { getSnapshot: () => state, subscribe: () => () => undefined },
-    cell: (id: string) => (id === 'known'
-      ? { sessionId: id, session: { getSnapshot: () => undefined, subscribe: () => () => undefined } }
+    provideInfo: (id: string) => (id === 'known'
+      ? {
+        sessionId: id,
+        hooks: { session: { getSnapshot: () => undefined, subscribe: () => () => undefined } },
+        props: {},
+      }
       : undefined),
   }
 }
@@ -228,13 +232,13 @@ describe('host face', () => {
     expect(host.entriesOf('t.host')).toHaveLength(0)
   })
 
-  it('exposes sessions list/current/cell (current riding the list snapshot)', async () => {
+  it('exposes sessions list/current/provideInfo (current riding the list snapshot)', async () => {
     const bench = await boot()
     const host = captureHost(bench)
     expect(host.sessions.list.getSnapshot()).toMatchObject({ ids: [] })
     expect(host.sessions.current.getSnapshot()).toBeUndefined()
-    expect(host.sessions.cell('known')).toMatchObject({ sessionId: 'known' })
-    expect(host.sessions.cell('ghost')).toBeUndefined()
+    expect(host.sessions.provideInfo('known')).toMatchObject({ sessionId: 'known' })
+    expect(host.sessions.provideInfo('ghost')).toBeUndefined()
   })
 
   it('exposes the independent Workspace list source', async () => {

packages/client/runtime/tests/wire-events.spec.ts

@@ -0,0 +1,55 @@
+/**
+ * Wire-to-typed-event bridge (web input-triggers cut 1): host/commands-changed
+ * → ctx 'commands/changed'; each established connection generation →
+ * ctx 'connection/reset' (the forced cache-invalidation broadcast).
+ */
+import { Context } from 'cordis'
+import { describe, expect, it } from 'vitest'
+import type { ConnectionHandle, ConnectionSinks } from '@deepseek-ai/dsh-client-connection/client'
+import * as RuntimeClient from '../src/client/index.ts'
+import { FakeApiClient } from './fake-api.ts'
+
+interface Bench {
+  ctx: Context
+  sinks: ConnectionSinks | undefined
+}
+
+async function mount(): Promise<Bench> {
+  const ctx = new Context()
+  const api = new FakeApiClient()
+  const bench: Bench = { ctx, sinks: undefined }
+  const handle: ConnectionHandle = {
+    api,
+    start: (sinks) => {
+      bench.sinks = sinks
+      return { stop: () => {} }
+    },
+  }
+  ctx.reflect.provide('connection', handle)
+  await ctx.plugin(RuntimeClient).await()
+  return bench
+}
+
+describe('wire event bridge', () => {
+  it('broadcasts commands/changed on a host/commands-changed frame, not on other host frames', async () => {
+    const bench = await mount()
+    let changed = 0
+    bench.ctx.on('commands/changed', () => { changed++ })
+    bench.sinks?.onHostEnvelope?.({ rpcId: 'r1' as never, payload: { type: 'host/commands-changed' } })
+    expect(changed).toBe(1)
+    bench.sinks?.onHostEnvelope?.({
+      rpcId: 'r2' as never,
+      payload: { type: 'host/session-status', sessionId: 's1' as never, running: true },
+    })
+    expect(changed).toBe(1)
+  })
+
+  it('broadcasts connection/reset on every established generation (reconnect invalidation)', async () => {
+    const bench = await mount()
+    let resets = 0
+    bench.ctx.on('connection/reset', () => { resets++ })
+    bench.sinks?.onConnected?.()
+    bench.sinks?.onConnected?.() // second generation after a reconnect
+    expect(resets).toBe(2)
+  })
+})

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

@@ -17,38 +17,6 @@ function workspace(id: string, sessionIds: SessionId[] = [], createdAt = '2026-0
 }
 
 describe('WorkspaceManager', () => {
-  it('owns, materializes, retries, supersedes, and discards Workspace objects with local intents', async () => {
-    const api = new FakeApiClient()
-    const manager = new WorkspaceManager(api)
-    manager.startIntent('first')
-    expect(manager.getSnapshot().intent).toEqual({ name: 'first', phase: 'ready' })
-
-    api.onWorkspaceCreate = () => Promise.resolve(err({
-      code: 'workspace-name-conflict', message: 'taken', details: { name: 'first' },
-    } as never))
-    await expect(manager.materializeIntent()).resolves.toMatchObject({ ok: false })
-    expect(manager.getSnapshot().intent).toMatchObject({ name: 'first', phase: 'ready' })
-    expect(typeof manager.getSnapshot().intent?.error).toBe('string')
-
-    const gate = deferred<Awaited<ReturnType<FakeApiClient['onWorkspaceCreate']>>>()
-    api.onWorkspaceCreate = () => gate.promise
-    const stale = manager.materializeIntent()
-    expect(manager.getSnapshot().intent?.phase).toBe('creating')
-    manager.startIntent('replacement')
-    gate.resolve(ok({ workspace: workspace('first'), created: true }))
-    await stale
-    expect(manager.getSnapshot().intent).toEqual({ name: 'replacement', phase: 'ready' })
-
-    api.onWorkspaceCreate = () => Promise.resolve(ok({ workspace: workspace('replacement'), created: true }))
-    await expect(manager.materializeIntent()).resolves.toMatchObject({ ok: true })
-    expect(manager.getSnapshot().intent).toBeUndefined()
-    await expect(manager.materializeIntent()).resolves.toBeUndefined()
-    manager.discardIntent()
-    manager.startIntent('discarded')
-    manager.discardIntent()
-    expect(manager.getSnapshot().intent).toBeUndefined()
-  })
-
   it('replays changed frames over hydration and keeps established order on refresh', async () => {
     const api = new FakeApiClient()
     const gate = deferred<Awaited<ReturnType<FakeApiClient['onWorkspaceList']>>>()
@@ -111,7 +79,7 @@ describe('WorkspaceManager', () => {
 })
 
 describe('WorkspacesService', () => {
-  it('feeds SessionManager readiness and recent-Workspace targeting without changing Host order', async () => {
+  it('feeds readiness and recent-Workspace targeting without changing Host order', async () => {
     const ctx = new Context()
     const api = new FakeApiClient()
     const sessions = new SessionsService(ctx, api)
@@ -127,7 +95,7 @@ describe('WorkspacesService', () => {
     expect(workspaces.list.getSnapshot()).toMatchObject({ baselinesReady: false, recentWorkspaceId: undefined })
 
     api.onList = () => Promise.resolve(ok({
-      items: [{ sessionId: sid('s-active'), updatedAt: Date.parse('2026-02-01'), running: false }] as never[],
+      items: [{ sessionId: sid('s-active'), updatedAt: Date.parse('2026-02-01'), running: false, blank: false }] as never[],
     }))
     await sessions.refresh()
     await Promise.resolve()
@@ -136,12 +104,65 @@ describe('WorkspacesService', () => {
       baselinesReady: true,
       recentWorkspaceId: 'active',
     })
-    expect(sessions.list.getSnapshot().intent).toMatchObject({
-      target: { kind: 'workspace', workspaceId: 'active' },
-    })
     expect(workspaces.list.getSnapshot().items.map(item => item.workspaceId)).toEqual(['stable-first', 'active'])
   })
 
+  it('connectWorkspace reuses the workspace-matched blank session and creates otherwise', async () => {
+    const ctx = new Context()
+    const api = new FakeApiClient()
+    const sessions = new SessionsService(ctx, api)
+    const workspaces = new WorkspacesService(ctx, api, sessions)
+    api.onWorkspaceList = () => Promise.resolve(ok({
+      items: [workspace('alpha'), workspace('beta')] as never[],
+    }))
+    api.onList = () => Promise.resolve(ok({
+      items: [
+        // Blank session already parked in alpha (cwd == workspace path canon).
+        { sessionId: sid('s-blank'), updatedAt: 2, running: false, blank: true, cwd: '/w/alpha' },
+        // Non-blank sibling in beta must never be reused.
+        { sessionId: sid('s-active'), updatedAt: 3, running: false, blank: false, cwd: '/w/beta' },
+      ] as never[],
+    }))
+    await Promise.all([workspaces.refresh(), sessions.refresh()])
+    await Promise.resolve()
+
+    // Hit: same workspace → the parked blank session comes back, no create RPC.
+    await expect(workspaces.connectWorkspace(wid('alpha'))).resolves.toBe('s-blank')
+    expect(api.callsOf('session.create')).toEqual([])
+    // Resolution guarantee: the id is binding-resolvable synchronously.
+    expect(sessions.binding(sid('s-blank'))).toBeDefined()
+
+    // Miss: beta has only a non-blank session → host create with workspaceId.
+    api.onCreate = () => Promise.resolve(ok({ sessionId: sid('s-fresh') }))
+    await expect(workspaces.connectWorkspace(wid('beta'))).resolves.toBe('s-fresh')
+    expect(api.callsOf('session.create')).toEqual([{ workspaceId: 'beta' }])
+    // Same guarantee on the create arm (draft hand-off writes the machine pre-open).
+    expect(sessions.binding(sid('s-fresh'))).toBeDefined()
+
+    // Unknown workspace fails loud instead of silently creating in nowhere.
+    await expect(workspaces.connectWorkspace(wid('ghost'))).rejects.toThrow(/unknown workspace ghost/)
+  })
+
+  it('a rejected first prompt keeps the blank session eligible for connectWorkspace reuse', async () => {
+    const ctx = new Context()
+    const api = new FakeApiClient()
+    const sessions = new SessionsService(ctx, api)
+    const workspaces = new WorkspacesService(ctx, api, sessions)
+    api.onWorkspaceList = () => Promise.resolve(ok({ items: [workspace('alpha')] as never[] }))
+    api.onList = () => Promise.resolve(ok({
+      items: [{ sessionId: sid('s-blank'), updatedAt: 2, running: false, blank: true, cwd: '/w/alpha' }] as never[],
+    }))
+    await Promise.all([workspaces.refresh(), sessions.refresh()])
+    await Promise.resolve()
+    const session = sessions.binding(sid('s-blank'))!.session
+    api.onPrompt = () => Promise.resolve(err({ code: 'internal', message: 'agent busy', details: {} }) as never)
+    await session.prompt([{ type: 'text', text: 'hi' }], 'queue')
+    await Promise.resolve()
+    // Failure leaves blank intact, so the same session is still the reuse hit.
+    await expect(workspaces.connectWorkspace(wid('alpha'))).resolves.toBe('s-blank')
+    expect(api.callsOf('session.create')).toEqual([])
+  })
+
   it('returns created Workspaces and preserves Host business errors', async () => {
     const ctx = new Context()
     const api = new FakeApiClient()

packages/client/ui-command/README.i18n.yaml

@@ -0,0 +1,6 @@
+# Bilingual-pair consistency record (docs/i18n/README.md): the git blob hash of each
+# 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
+README.md: 17bc4edd7d002d6bba4470c9418a9179b2cb131b
+README.zh.md: 1291556409b993aa893e102386f75c45bb195adf

packages/client/ui-command/README.md

@@ -0,0 +1,26 @@
+# @deepseek-ai/dsh-client-ui-command
+
+English | [中文](README.zh.md)
+
+Client command surface (`ctx.command`): the session-keyed command-directory cache, the `/` command source with matchSpace/matchEnter adjudication hooks, three-kind dispatch (execute / popupSelect / leadingInput), and the popupSelect registration face for business packages. Contract: the [web command surfaces Agent Note](../../../.agents/notes/implemented/architecture/2026-07-25-web-command-surfaces-and-assembly.zh.md).
+
+`src/client/contract.ts` is the frozen business face: `CommandServiceContract.register(name, spec)` is everything a business package consumes; `CommandUiSpec{options, onSelect}` keeps popup data self-served — the shell component is this package's and business never sees it. Command kinds derive per dispatch, never per registration: a host descriptor with `input` is leadingInput, a registered `CommandUiSpec` is popupSelect, everything else is execute.
+
+`CommandDirectory` (`src/client/directory.ts`) is the one wire-derived cache, keyed by session: every session is agent-backed, so `command.list({sessionId})` is the only address shape and the source's scope-birth `warm` hook prewarms the session's entry. Entries are soft-invalidated by the `commands/changed` typed event (old snapshot serves while the repull flies), hard-invalidated by `connection/reset`, epoch-guarded so a superseded pull can never overwrite a newer one. `matchSpace` answers synchronously from this cache only; `matchEnter` strong-waits it on the SubmitAttempt signal and rejects on warmup failure — a `/` line is never silently downgraded to a plain prompt.
+
+`PopupSelectController` (`src/client/popup.ts`) is the headless shell state: `PopupSelectView` self-registers into `conversation.input.overlay` (the SlotMap key is ui-conversation's; this package pulls the declaration in with a type-only import — no runtime edge). The shell is a transient layer holding focus while open; token-segment consumption after onSelect runs both branches through `consumeTokenSegment` (menu-path span CAS, enter-path bare-token equality) against the draft face the wiring layer binds via `bindDraft`.
+
+The `/client` export surface is the plugin body (`apply`/`inject`), `CommandService`, the directory and popup classes with their state types, and the frozen contract types; the shell component itself is internal to the overlay registration.
+
+## Model Experience
+
+Indirectly, through the host `command.execute` RPC this package's dispatch and `claim.submit` paths trigger: a matched command's handler mutates host domain state that other packages project into the next request (the `/plan` handler flips plan mode, whose owning package injects its `plan:policy` system-prompt section), while the command line itself, the detached result, and every menu/notice rendering stay client-side and never enter the session log.
+
+#### KV Cache effect
+
+None directly; this package neither assembles nor sends a provider request. Command handlers it triggers may change what the owning host packages contribute to the next request's system prompt (a section appearing or disappearing replaces earlier request tokens and invalidates the provider prefix from that point), but that effect is owned and documented by each command's host package.
+
+## Known Limitations and Deferred Work
+
+- **The popupSelect shell has no shipped business consumer** — model selection (host `selectModel`) is the design's reference case and lands with its own feature work; until then the shell is exercised by package tests only.
+- **Detached-result notices fall back to the console off-session** — the fire-and-forget paths route results to the triggering session's composer via `SessionInput.notify`; after session teardown the console line is the only remaining surface.

packages/client/ui-command/README.zh.md

@@ -0,0 +1,26 @@
+# @deepseek-ai/dsh-client-ui-command
+
+[English](README.md) | 中文
+
+客户端命令业务面（`ctx.command`）：以会话为 key 的命令目录缓存、带 matchSpace／matchEnter 裁决钩子的 `/` 命令 source、三型派发（execute／popupSelect／leadingInput），以及面向业务包的 popupSelect 注册面。契约：[Web 命令业务面 Agent Note（agent 决策记录）](../../../.agents/notes/implemented/architecture/2026-07-25-web-command-surfaces-and-assembly.zh.md)。
+
+`src/client/contract.ts` 是冻结的业务表层：`CommandServiceContract.register(name, spec)` 是业务包消费的全部内容；`CommandUiSpec{options, onSelect}` 让 popup 数据自给自足——壳组件归本包所有，业务永远见不到它。命令三型按每次派发派生，绝不在注册时定型：带 `input` 的 host descriptor 是 leadingInput，注册了 `CommandUiSpec` 的是 popupSelect，其余全部是 execute。
+
+`CommandDirectory`（`src/client/directory.ts`）是唯一的 wire 派生缓存，以会话为 key：每个会话恒为 agent-backed，因此 `command.list({sessionId})` 是唯一的寻址形状，source 的 scope 出生 `warm` 钩子会预热该会话的缓存项。缓存项由 `commands/changed` 类型化事件软失效（重拉在途期间旧快照继续服务），由 `connection/reset` 硬失效，并以 epoch 把关，被取代的旧拉取永远无法覆盖更新的结果。`matchSpace` 只凭该缓存同步应答；`matchEnter` 在 SubmitAttempt 信号上强等缓存，预热失败即拒绝——`/` 开头的一行绝不会被静默降级为普通提示词。
+
+`PopupSelectController`（`src/client/popup.ts`）是无头的壳状态：`PopupSelectView` 自行注册进 `conversation.input.overlay`（SlotMap key 归 ui-conversation 所有；本包只以 type-only 导入引入该声明——没有运行时依赖边）。壳是打开期间持有焦点的瞬态层；onSelect 之后的 token 片段消费在两条分支上都经 `consumeTokenSegment` 执行（菜单路径做 span CAS，回车路径做裸 token 相等比较），作用于接线层经 `bindDraft` 绑定的草稿表层。
+
+`/client` 导出表层是插件主体（`apply`／`inject`）、`CommandService`、目录类和 popup 类及其状态类型，以及冻结的契约类型；壳组件本身是 overlay 注册的内部实现。
+
+## 模型体验
+
+间接影响，途径是本包的派发与 `claim.submit` 路径触发的 host `command.execute` RPC：匹配命中的命令，其 handler 会修改 host 领域状态，其他包再把该状态投影进下一个请求（`/plan` 的 handler 翻转 plan 模式，其归属包注入 `plan:policy` 系统提示词 section），而命令行本身、detached result 与所有菜单／notice 渲染都留在客户端，永不进入会话日志。
+
+#### KV Cache 影响
+
+无直接影响；该包既不组装也不发送提供方请求。它触发的命令 handler 可能改变归属 host 包对下一个请求系统提示词的贡献（某个 section 的出现或消失会替换较早的请求 token，并使提供方前缀从该点起失效），但这一影响由各命令的 host 包拥有并记录。
+
+## 已知限制与暂缓事项
+
+- **popupSelect 壳还没有已上架的业务消费者**：模型选择（host `selectModel`）是设计的参照用例，将随其自身的功能工作落地；在此之前，壳只由包测试演练。
+- **脱离会话后，detached result 的 notice 回退到 console**：fire-and-forget 路径经 `SessionInput.notify` 把结果送到触发会话的编辑器；会话拆除后，console 输出行是仅剩的呈现面。

packages/client/ui-command/package.json

@@ -0,0 +1,72 @@
+{
+  "name": "@deepseek-ai/dsh-client-ui-command",
+  "description": "Client command surface: global directory cache, '/' source, three command UI kinds, popupSelect registry",
+  "version": "0.0.1",
+  "private": true,
+  "type": "module",
+  "main": "lib/index.js",
+  "types": "lib/types/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./lib/types/index.d.ts",
+      "default": "./lib/index.js"
+    },
+    "./invariant": {
+      "types": "./lib/types/invariant.d.ts",
+      "default": "./lib/invariant.js"
+    },
+    "./client": {
+      "types": "./lib/types/client/index.d.ts",
+      "default": "./lib/client.js"
+    },
+    "./src/*": "./src/*",
+    "./package.json": "./package.json"
+  },
+  "dshClient": {
+    "inject": [
+      "@deepseek-ai/dsh-client-runtime",
+      "@deepseek-ai/dsh-client-ui-slash",
+      "@deepseek-ai/dsh-client-ui-conversation"
+    ],
+    "platform": "web"
+  },
+  "scripts": {
+    "bundle": "tsdown",
+    "watch": "tsdown --watch"
+  },
+  "license": "BSD-3-Clause",
+  "dependencies": {
+    "clsx": "^2.0.0"
+  },
+  "peerDependencies": {
+    "@deepseek-ai/dsh-client-connection": "^0.0.1",
+    "@deepseek-ai/dsh-client-runtime": "^0.0.1",
+    "@deepseek-ai/dsh-client-ui-conversation": "^0.0.1",
+    "@deepseek-ai/dsh-client-ui-primitives": "^0.0.1",
+    "@deepseek-ai/dsh-client-ui-slash": "^0.0.1",
+    "@deepseek-ai/dsh-client-ui-slots": "^0.0.1",
+    "@deepseek-ai/dsh-invariants": "^0.0.1",
+    "cordis": "^4.0.0-rc.7",
+    "react": "^18.2.0"
+  },
+  "devDependencies": {
+    "@deepseek-ai/dsh-client-connection": "workspace:^",
+    "@deepseek-ai/dsh-client-runtime": "workspace:^",
+    "@deepseek-ai/dsh-client-ui-conversation": "workspace:^",
+    "@deepseek-ai/dsh-client-ui-primitives": "workspace:^",
+    "@deepseek-ai/dsh-client-ui-slash": "workspace:^",
+    "@deepseek-ai/dsh-client-ui-slots": "workspace:^",
+    "@deepseek-ai/dsh-invariants": "workspace:^",
+    "@types/react": "~18.3.1",
+    "cordis": "^4.0.0-rc.7",
+    "react": "^18.2.0"
+  },
+  "files": [
+    "lib/index.js",
+    "lib/invariant.js",
+    "lib/client.js",
+    "lib/types/**/*.d.ts",
+    "lib/types/**/*.d.ts.map",
+    "src"
+  ]
+}

packages/client/ui-command/src/client/PopupSelectView.module.css

@@ -0,0 +1,98 @@
+/* Official popupSelect shell card: menu-surface tokens (same family as
+ * ui-primitives Menu.module.css — figma MenuDropdown r12 / hairline /
+ * shadow-lv3), anchored by the conversation.input.overlay slot. */
+
+.card {
+  /* The overlay anchor is a zero-height strip on the composer card's top
+     edge; entries float themselves above it (same rule as MenuView). */
+  position: absolute;
+  bottom: calc(100% + 4px);
+  left: 0;
+  z-index: 100;
+  padding: 4px;
+  display: flex;
+  flex-direction: column;
+  min-width: 220px;
+  max-height: 320px;
+  overflow-y: auto;
+  border: 1px solid var(--dsw-alias-border-inverted);
+  border-radius: 12px;
+  background: var(--dsw-specific-menu);
+  box-shadow: var(--dsw-shadow-lv3);
+  outline: none;
+}
+
+.row {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  padding: 6px 8px;
+  border-radius: 8px;
+  cursor: pointer;
+  font-size: 13px;
+  color: var(--dsw-alias-text-primary);
+}
+
+.rowActive {
+  background: var(--dsw-alias-fill-hover);
+}
+
+.label {
+  flex: 1;
+  white-space: nowrap;
+  overflow: hidden;
+  text-overflow: ellipsis;
+}
+
+.detail {
+  font-size: 12px;
+  color: var(--dsw-alias-text-tertiary);
+  white-space: nowrap;
+}
+
+.check {
+  display: inline-flex;
+  color: var(--dsw-alias-text-secondary);
+}
+
+.status {
+  padding: 8px;
+  font-size: 12px;
+  color: var(--dsw-alias-text-tertiary);
+}
+
+.search {
+  margin: 2px 2px 4px;
+  padding: 6px 8px;
+  border: 1px solid var(--dsw-alias-border-inverted);
+  border-radius: 8px;
+  background: transparent;
+  font-size: 13px;
+  color: var(--dsw-alias-text-primary);
+  outline: none;
+}
+
+.error {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  padding: 6px 8px;
+  font-size: 12px;
+  color: var(--dsw-alias-state-error-primary);
+}
+
+.errorText {
+  flex: 1;
+  overflow: hidden;
+  text-overflow: ellipsis;
+}
+
+.retry {
+  padding: 2px 8px;
+  border: 1px solid var(--dsw-alias-border-inverted);
+  border-radius: 6px;
+  background: transparent;
+  font-size: 12px;
+  color: var(--dsw-alias-text-primary);
+  cursor: pointer;
+}

packages/client/ui-command/src/client/PopupSelectView.tsx

@@ -0,0 +1,133 @@
+/**
+ * Official popupSelect shell: renders one session's PopupSelectController
+ * store into the conversation.input.overlay anchor. Unlike the slash menu
+ * (combobox — textarea keeps focus), this shell HOLDS focus while open: the
+ * inner search input takes focus, plain typing filters the loaded options
+ * locally, Enter/↑↓ drive the filtered highlight, Escape dismisses back to
+ * the composer, and ←→ keep the search input's native caret. Any pointer
+ * interaction outside the box dismisses (the click's own target takes
+ * focus). Closed state renders null; the overlay slot stays mounted.
+ */
+import { useEffect, useRef } from 'react'
+import { useSyncExternalStore } from 'react'
+import clsx from 'clsx'
+import { IconCheckOutline16 } from '@deepseek-ai/dsh-client-ui-primitives'
+import { filterOptions } from './popup.ts'
+import type { PopupSelectController } from './popup.ts'
+import css from './PopupSelectView.module.css'
+
+/** Injected business face of the popupSelect overlay entry. */
+export interface PopupSelectInjected {
+  /** The session's shell controller (state store + verbs; the view never touches the open-context type). */
+  popup: PopupSelectController
+}
+
+/**
+ * Render the popupSelect shell overlay entry.
+ * @param props - injected face: the session's shell controller.
+ * @returns the select card while open; null while closed.
+ */
+export function PopupSelectView({ popup }: PopupSelectInjected) {
+  const state = useSyncExternalStore(
+    fn => popup.state.subscribe(fn),
+    () => popup.state.getSnapshot(),
+  )
+  const cardRef = useRef<HTMLDivElement>(null)
+  const searchRef = useRef<HTMLInputElement>(null)
+
+  // Focus ownership: the search input grabs on open (the design's
+  // transient-layer rule), and ANY outside pointer interaction dismisses —
+  // capture phase so a click landing anywhere else (textarea included)
+  // closes the shell before its own handlers run; that click's target then
+  // takes focus naturally, so no focusComposer here.
+  useEffect(() => {
+    if (!state.open) return
+    searchRef.current?.focus()
+    const onPointerDown = (ev: PointerEvent): void => {
+      if (cardRef.current !== null && ev.target instanceof Node && cardRef.current.contains(ev.target)) return
+      popup.dismiss()
+    }
+    document.addEventListener('pointerdown', onPointerDown, true)
+    return () => { document.removeEventListener('pointerdown', onPointerDown, true) }
+  }, [state.open, popup])
+
+  if (!state.open) return null
+
+  const rows = filterOptions(state.options, state.search)
+
+  const onKeyDown = (ev: React.KeyboardEvent<HTMLDivElement>): void => {
+    // ArrowLeft/ArrowRight fall through on purpose: the search input keeps
+    // its native caret movement.
+    switch (ev.key) {
+      case 'ArrowDown':
+        ev.preventDefault()
+        popup.move(1)
+        return
+      case 'ArrowUp':
+        ev.preventDefault()
+        popup.move(-1)
+        return
+      case 'Enter':
+        ev.preventDefault()
+        void popup.select(state.active)
+        return
+      case 'Escape':
+        ev.preventDefault()
+        popup.dismiss({ focusComposer: true })
+        return
+      default:
+    }
+  }
+
+  return (
+    <div
+      ref={cardRef}
+      className={css.card}
+      aria-label={`/${String(state.command)} options`}
+      onKeyDown={onKeyDown}
+    >
+      <input
+        ref={searchRef}
+        className={css.search}
+        type="text"
+        placeholder="Search…"
+        aria-label="Filter options"
+        value={state.search}
+        readOnly={state.submitting}
+        onChange={(ev) => { popup.setSearch(ev.currentTarget.value) }}
+      />
+      {state.error !== null && (
+        <div className={css.error} role="alert">
+          <span className={css.errorText}>{state.error}</span>
+          {state.status === 'failed' && (
+            <button type="button" className={css.retry} onClick={() => { popup.retry() }}>Retry</button>
+          )}
+        </div>
+      )}
+      {state.status === 'pending' && <div className={css.status}>Loading options…</div>}
+      {state.submitting && <div className={css.status}>Applying…</div>}
+      {state.status === 'ready' && rows.length === 0 && <div className={css.status}>No options</div>}
+      {state.status === 'ready' && (
+        <div role="listbox" aria-label={`/${String(state.command)} matches`}>
+          {rows.map((option, index) => (
+            <div
+              key={option.id}
+              role="option"
+              aria-selected={index === state.active}
+              className={clsx(css.row, index === state.active && css.rowActive)}
+              // mousedown would race the document capture listener; the shell
+              // owns focus anyway, so a plain click (inside the card → no
+              // dismiss) works.
+              onClick={() => { void popup.select(index) }}
+              onMouseEnter={() => { popup.highlight(index) }}
+            >
+              <span className={css.label}>{option.label}</span>
+              {option.detail !== undefined && <span className={css.detail}>{option.detail}</span>}
+              {option.active === true && <span className={css.check}><IconCheckOutline16 /></span>}
+            </div>
+          ))}
+        </div>
+      )}
+    </div>
+  )
+}

packages/client/ui-command/src/client/contract.ts

@@ -0,0 +1,55 @@
+/**
+ * Frozen contract of the client command surface. Types only. The
+ * CommandService (`ctx.command`) implements this face; business packages
+ * consume `register` alone.
+ */
+import type { ClientContext } from '@deepseek-ai/dsh-client-runtime/client'
+import type { ClientSessionContext } from '@deepseek-ai/dsh-client-ui-slash/client'
+
+/** One option row of a popupSelect shell. */
+export interface SelectOption {
+  readonly id: string
+  readonly label: string
+  readonly detail?: string
+  readonly active?: boolean
+}
+
+/**
+ * Business registration for the popupSelect command kind. Data is
+ * self-served: options/onSelect use the business package's own protocol.
+ * The shell component is owned by ui-command; business never sees it. Both
+ * callbacks receive the ClientSessionContext captured at popup open.
+ */
+export type CommandUiSpec = {
+  readonly kind: 'popupSelect'
+  options(session: ClientSessionContext, signal: AbortSignal): Promise<readonly SelectOption[]>
+  onSelect(option: SelectOption, session: ClientSessionContext): void | Promise<void>
+}
+
+/**
+ * One client-owned command contribution: a slash-menu entry whose behavior
+ * lives entirely on the client (no host descriptor). Merged with the host
+ * catalog by name — a collision with a host command fails loud at candidate
+ * synthesis, never shadows.
+ */
+export interface CommandContribution {
+  /** Command name without the leading slash (unique across contributions). */
+  readonly name: string
+  /** Menu row description. */
+  readonly description: string
+  /** Capability filter, called with a fresh projection per candidate pass. */
+  available(session: ClientSessionContext): boolean
+  /** The command's UI behavior (this phase: popupSelect only). */
+  readonly ui: CommandUiSpec
+}
+
+/** The `ctx.command` service face visible to business packages. */
+export interface CommandServiceContract {
+  /**
+   * Register one client command contribution; effect disposer. Duplicate
+   * names throw at registration.
+   */
+  register(contribution: CommandContribution): () => void
+  /** Resolve the per-session popup controller for one session scope (wiring/overlay layer). */
+  popupFor(actx: ClientContext): unknown
+}

packages/client/ui-command/src/client/directory.ts

@@ -0,0 +1,175 @@
+/**
+ * Command-directory cache keyed by session: one entry per served catalog —
+ * every session is agent-backed, so `command.list({sessionId})` is the only
+ * address shape. Each entry keeps the single-flight / soft-hard invalidation
+ * / epoch-guard behavior of the original global cache; the session-key axis
+ * is the only extra dimension.
+ */
+import type { IApiClient, SessionId } from '@deepseek-ai/dsh-client-connection/client'
+
+/** command.list success value, derived so the wire type authority stays in apiproxy. */
+type ListValue = Extract<Awaited<ReturnType<IApiClient['commands']['list']>>['result'], { ok: true }>['value']
+
+/** One host command descriptor as served to the client. */
+export type CommandDescriptor = ListValue['commands'][number]
+
+/**
+ * cold = never pulled; pending = pull in flight with nothing servable;
+ * ready = snapshot serving (a soft-invalidate repull keeps this status);
+ * failed = last winning pull rejected, snapshot dropped.
+ */
+export type DirectoryStatus = 'cold' | 'pending' | 'ready' | 'failed'
+
+/** Injected pull (the service binds command.list off the root connection). */
+export type FetchCommands = (sessionId: SessionId) => Promise<readonly CommandDescriptor[]>
+
+/** One session key's cache cell. */
+class Entry {
+  state: DirectoryStatus = 'cold'
+  commands: readonly CommandDescriptor[] = []
+  /** Bumped at each pull start; only the latest pull may publish its outcome. */
+  epoch = 0
+  lastError: unknown
+  waiters: Array<() => void> = []
+}
+
+/** The session-keyed directory cache. Plain class — the owning service wires events and RPC. */
+export class CommandDirectory {
+  private readonly entries = new Map<SessionId, Entry>()
+
+  constructor(private readonly fetchCommands: FetchCommands) {}
+
+  /**
+   * Current cache status for one session.
+   * @param sessionId - session key.
+   * @returns the entry status (cold when never touched).
+   */
+  status(sessionId: SessionId): DirectoryStatus {
+    return this.entries.get(sessionId)?.state ?? 'cold'
+  }
+
+  /**
+   * Synchronous exact-name lookup over one session's hot snapshot.
+   * @param sessionId - session key.
+   * @param name - command name without the leading slash.
+   * @returns the descriptor, or undefined when absent or the entry is not ready.
+   */
+  resolve(sessionId: SessionId, name: string): CommandDescriptor | undefined {
+    const entry = this.entries.get(sessionId)
+    if (entry === undefined || entry.state !== 'ready') return undefined
+    return entry.commands.find(c => c.name === name)
+  }
+
+  /** Soft invalidation (commands-changed): background repull on every touched key; ready snapshots keep serving. */
+  invalidateAll(): void {
+    for (const key of this.entries.keys()) void this.refresh(key)
+  }
+
+  /**
+   * Hard reset on reconnect: every entry drops its snapshot (the agent world
+   * may have changed shape across the generation) and prewarms.
+   */
+  resetConnected(): void {
+    for (const [key, entry] of this.entries) {
+      entry.state = 'cold'
+      entry.commands = []
+      void this.refresh(key)
+    }
+  }
+
+  /**
+   * Fire-and-forget prewarm of one session (the command source's scope-birth
+   * warm hook lands here).
+   * @param sessionId - session key.
+   */
+  warm(sessionId: SessionId): void {
+    const entry = this.entry(sessionId)
+    if (entry.state === 'cold' || entry.state === 'failed') void this.refresh(sessionId)
+  }
+
+  /**
+   * Start one pull for one session. Publishes ready/failed only while it is
+   * still the key's latest pull (epoch guard); a ready snapshot is not
+   * demoted while the pull flies.
+   * @param sessionId - session key.
+   * @returns settled when this pull's outcome is published or discarded.
+   */
+  async refresh(sessionId: SessionId): Promise<void> {
+    const entry = this.entry(sessionId)
+    const epoch = ++entry.epoch
+    if (entry.state !== 'ready') entry.state = 'pending'
+    try {
+      const commands = await this.fetchCommands(sessionId)
+      if (epoch !== entry.epoch) return
+      entry.commands = commands
+      entry.state = 'ready'
+      entry.lastError = undefined
+    } catch (error) {
+      if (epoch !== entry.epoch) return
+      entry.commands = []
+      entry.state = 'failed'
+      entry.lastError = error
+    } finally {
+      if (epoch === entry.epoch) notifyWaiters(entry)
+    }
+  }
+
+  /**
+   * Strong-wait until one session's catalog is servable (the enter-
+   * adjudication "directory must be reached" rule): ready returns at once;
+   * cold/failed launch a fresh pull; pending joins the flying one. Rejects
+   * when the awaited pull fails or the signal aborts.
+   * @param sessionId - session key.
+   * @param signal - attempt-scoped abort (the SubmitAttempt signal).
+   * @returns the hot command snapshot.
+   */
+  async ensureReady(sessionId: SessionId, signal: AbortSignal): Promise<readonly CommandDescriptor[]> {
+    const entry = this.entry(sessionId)
+    while (true) {
+      if (entry.state === 'ready') return entry.commands
+      if (entry.state !== 'pending') void this.refresh(sessionId)
+      await settled(entry, signal)
+      if (entry.state === 'failed') {
+        throw new Error(`command directory warmup failed: ${entry.lastError instanceof Error ? entry.lastError.message : String(entry.lastError)}`)
+      }
+      // Still pending (the awaited pull was superseded) → wait for the winner.
+    }
+  }
+
+  private entry(sessionId: SessionId): Entry {
+    let entry = this.entries.get(sessionId)
+    if (entry === undefined) {
+      entry = new Entry()
+      this.entries.set(sessionId, entry)
+    }
+    return entry
+  }
+}
+
+/** One settlement tick for one entry: resolves at the next winning publish, rejects on abort. */
+function settled(entry: Entry, signal: AbortSignal): Promise<void> {
+  if (signal.aborted) return Promise.reject(abortReason(signal))
+  return new Promise((resolve, reject) => {
+    const waiter = (): void => {
+      signal.removeEventListener('abort', onAbort)
+      resolve()
+    }
+    const onAbort = (): void => {
+      entry.waiters = entry.waiters.filter(w => w !== waiter)
+      reject(abortReason(signal))
+    }
+    signal.addEventListener('abort', onAbort, { once: true })
+    entry.waiters.push(waiter)
+  })
+}
+
+function notifyWaiters(entry: Entry): void {
+  const woken = entry.waiters
+  entry.waiters = []
+  for (const wake of woken) wake()
+}
+
+/** Normalize an abort into an Error rejection. */
+function abortReason(signal: AbortSignal): Error {
+  return signal.reason instanceof Error ? signal.reason : new Error('command directory wait aborted')
+}

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

@@ -0,0 +1,61 @@
+/**
+ * Command UI plugin, browser half: CommandService (`ctx.command`) owning the
+ * capability-keyed directory cache, the '/' command source, the client
+ * contribution registry, and the per-session popupSelect controllers; the
+ * popupSelect shell self-registers into conversation.input.overlay with
+ * per-session resolution.
+ */
+import type { ClientContext } from '@deepseek-ai/dsh-client-runtime/client'
+// Type-only: pulls the 'conversation.input.overlay' SlotMap declaration (the
+// key's owner) into this program so the overlay registration below typechecks
+// against the real declaration — no runtime edge to ui-conversation.
+import type {} from '@deepseek-ai/dsh-client-ui-conversation/client'
+import { CommandService } from './service.ts'
+import type { PopupSelectInjected } from './PopupSelectView.tsx'
+import { PopupSelectView } from './PopupSelectView.tsx'
+
+export { CommandService } from './service.ts'
+export { CommandDirectory } from './directory.ts'
+export type { CommandDescriptor, DirectoryStatus } from './directory.ts'
+export { filterOptions, PopupSelectController } from './popup.ts'
+export type { PopupSelectDeps, PopupSpec, PopupState, TokenSegment } from './popup.ts'
+export type { PopupSelectInjected } from './PopupSelectView.tsx'
+export type {
+  CommandContribution, CommandServiceContract, CommandUiSpec, SelectOption,
+} from './contract.ts'
+
+declare module 'cordis' {
+  interface Context {
+    command: CommandService
+  }
+}
+
+/** Required services: the '/' source registry plus the scope + wire faces the service reads. */
+export const inject = ['slash', 'sessions', 'connection']
+
+/**
+ * Client plugin body: mount the service, then register the popupSelect shell
+ * into the input overlay once its declarer is up.
+ * @param ctx - client root context.
+ */
+export function apply(ctx: ClientContext): void {
+  ctx.plugin(CommandService)
+  // Conditional mount, same seam as ui-slash's MenuView registration:
+  // 'conversation.input.overlay' is declared by the conversation composer
+  // entry, and the conversation service's presence is the registration-safe
+  // signal that the declaration is on the ledger.
+  ctx.inject(['slots', 'conversation', 'command', 'sessions'], (scope: ClientContext) => {
+    const command = scope.command
+    const sessions = scope.sessions
+    scope.effect(() => scope.slots.register({
+      name: 'conversation.input.overlay',
+      id: 'command-popup',
+      order: 1,
+      inject: (sessionId): PopupSelectInjected => {
+        const actx = sessions.scope(sessionId)
+        if (actx === undefined) throw new Error(`ui-command: session "${String(sessionId)}" resolved no scope`)
+        return { popup: command.popupFor(actx) }
+      },
+    }, PopupSelectView), 'ui-command: popupSelect overlay registration')
+  })
+}

packages/client/ui-command/src/client/popup.ts

@@ -0,0 +1,251 @@
+/**
+ * Headless popupSelect shell state (design §10): one controller per client
+ * session, owned by CommandService's per-session map and torn down by the
+ * session scope disposer. The shell is a transient layer (never in the input
+ * state machine): it loads options once, filters them locally against the
+ * shell's own search text, and settles a selection through the context
+ * captured at open time. Draft consumption and composer focus are injected
+ * callbacks — the session wiring dispatches the consume-token event (the
+ * Input side owns the span/bare-token CAS guard) and focuses the composer;
+ * the controller never touches the input machine.
+ */
+import { createSnapshotStore } from '@deepseek-ai/dsh-client-runtime/client'
+import type { SnapshotStore } from '@deepseek-ai/dsh-client-runtime/client'
+import type { TokenSpan } from '@deepseek-ai/dsh-client-ui-slash/client'
+import type { SelectOption } from './contract.ts'
+
+/**
+ * The command token segment snapshotted at shell-open time, replayed to the
+ * injected {@link PopupSelectDeps.consume} callback after a successful
+ * selection. The Input side guards it: a menu-path span consumes iff draftRev
+ * is unchanged, an enter-path line iff the trimmed draft still equals the
+ * bare token.
+ */
+export type TokenSegment =
+  | { readonly via: 'menu'; readonly span: TokenSpan }
+  | { readonly via: 'enter'; readonly token: string }
+
+/**
+ * Structural business spec the shell settles against — the popupSelect half
+ * of CommandUiSpec, generic in the context value the opener captures (the
+ * session wiring passes its session projection; the controller only carries
+ * it from open() to the callbacks).
+ */
+export interface PopupSpec<TCtx> {
+  /** Load the option rows once per open (retry after failure reuses the same signal). */
+  options(context: TCtx, signal: AbortSignal): Promise<readonly SelectOption[]>
+  /** Settle the picked option against the open-time context. */
+  onSelect(option: SelectOption, context: TCtx): void | Promise<void>
+}
+
+/** Injected session-wiring callbacks of one controller (tests pass fakes). */
+export interface PopupSelectDeps {
+  /**
+   * Consume the open-time token segment after a successful onSelect (the
+   * wiring dispatches the consume-token event to the opening session).
+   * @param segment - the open-time token segment snapshot.
+   * @returns whether the token was consumed; false (CAS miss) is benign and
+   * never retried.
+   */
+  consume(segment: TokenSegment): boolean
+  /** Return focus to the session composer (successful settle and Escape close paths). */
+  focusComposer(): void
+}
+
+/** Popup shell state (the shell component renders from here; closed = render null). */
+export interface PopupState {
+  readonly open: boolean
+  /** Command name the shell is open for (null while closed). */
+  readonly command: string | null
+  /** Options-load lifecycle; 'failed' keeps the shell open for retry(). */
+  readonly status: 'pending' | 'ready' | 'failed'
+  /** Options as loaded — never re-fetched per keystroke; views render {@link filterOptions} over them. */
+  readonly options: readonly SelectOption[]
+  /** Local filter text over the loaded options. */
+  readonly search: string
+  /** Highlight index into the filtered row list (0 when empty/pending). */
+  readonly active: number
+  /** A select() settlement is in flight: further select/search/highlight no-op until it settles. */
+  readonly submitting: boolean
+  /** Surfaced settlement failure (options load or onSelect); null when none. */
+  readonly error: string | null
+}
+
+const CLOSED: PopupState = {
+  open: false, command: null, status: 'pending', options: [], search: '', active: 0, submitting: false, error: null,
+}
+
+/**
+ * Filter option rows against the shell's local search text (case-insensitive
+ * substring over label and detail; blank search keeps every row).
+ * @param options - the loaded rows.
+ * @param search - the shell's search text.
+ * @returns the rows the shell shows and highlights over.
+ */
+export function filterOptions(options: readonly SelectOption[], search: string): readonly SelectOption[] {
+  const query = search.trim().toLowerCase()
+  if (query === '') return options
+  return options.filter(o => o.label.toLowerCase().includes(query) || (o.detail?.toLowerCase().includes(query) ?? false))
+}
+
+/** One open shell's bindings (spec + open-time context + segment snapshot + options-fetch abort). */
+interface OpenBinding<TCtx> {
+  readonly command: string
+  readonly spec: PopupSpec<TCtx>
+  readonly context: TCtx
+  readonly segment: TokenSegment
+  readonly abort: AbortController
+}
+
+/** The shell's error-strip line for a settlement failure. */
+function errorText(error: unknown): string {
+  return error instanceof Error ? error.message : String(error)
+}
+
+/**
+ * Headless controller of one session's popupSelect shell. Late settlements
+ * lose their write rights through binding identity: dismiss/dispose/reopen
+ * swap the binding, so a settling options fetch or onSelect that no longer
+ * matches writes nothing and consumes nothing.
+ */
+export class PopupSelectController<TCtx = unknown> {
+  /** Shell state store (the overlay component subscribes here). */
+  readonly state: SnapshotStore<PopupState> = createSnapshotStore<PopupState>(CLOSED)
+  private binding: OpenBinding<TCtx> | null = null
+
+  /**
+   * @param deps - session-wiring callbacks (token consumption + composer focus).
+   */
+  constructor(private readonly deps: PopupSelectDeps) {}
+
+  /**
+   * Open the shell for one command: publish pending state and fetch options
+   * once through the business spec. A reopen supersedes the previous shell
+   * (its options fetch is aborted, its late settlements are dropped).
+   * @param command - command name the shell serves.
+   * @param spec - the registered popupSelect spec.
+   * @param context - open-time context snapshot, handed verbatim to options/onSelect.
+   * @param segment - open-time token segment snapshot for post-select consumption.
+   */
+  open(command: string, spec: PopupSpec<TCtx>, context: TCtx, segment: TokenSegment): void {
+    this.binding?.abort.abort()
+    const binding: OpenBinding<TCtx> = { command, spec, context, segment, abort: new AbortController() }
+    this.binding = binding
+    this.state.set({ ...CLOSED, open: true, command })
+    this.load(binding)
+  }
+
+  /** Run the one options fetch of a binding; settlement rights die with the binding. */
+  private load(binding: OpenBinding<TCtx>): void {
+    binding.spec.options(binding.context, binding.abort.signal).then(
+      (options) => {
+        if (this.binding !== binding) return
+        this.state.set({ ...this.state.getSnapshot(), status: 'ready', options, active: 0, error: null })
+      },
+      (error: unknown) => {
+        if (this.binding !== binding) return
+        console.error(`[ui-command] popupSelect options failed for /${binding.command}:`, error)
+        this.state.set({ ...this.state.getSnapshot(), status: 'failed', options: [], active: 0, error: errorText(error) })
+      },
+    )
+  }
+
+  /** Re-run a failed options fetch (search survives; no-op unless status is 'failed'). */
+  retry(): void {
+    const binding = this.binding
+    const s = this.state.getSnapshot()
+    if (binding === null || !s.open || s.status !== 'failed') return
+    this.state.set({ ...s, status: 'pending', error: null })
+    this.load(binding)
+  }
+
+  /**
+   * Replace the local search text (pure local filter — the provider is never
+   * re-queried) and rebase the highlight onto the new filtered list.
+   * @param search - the shell search input's text.
+   */
+  setSearch(search: string): void {
+    const s = this.state.getSnapshot()
+    if (!s.open || s.submitting || search === s.search) return
+    this.state.set({ ...s, search, active: 0 })
+  }
+
+  /**
+   * Move the highlight across the filtered rows (wraps around; no-op unless
+   * options are ready and no selection is in flight).
+   * @param dir - +1 down, -1 up.
+   */
+  move(dir: 1 | -1): void {
+    const s = this.state.getSnapshot()
+    if (!s.open || s.status !== 'ready' || s.submitting) return
+    const rows = filterOptions(s.options, s.search)
+    if (rows.length === 0) return
+    const active = (s.active + dir + rows.length) % rows.length
+    this.state.set({ ...s, active })
+  }
+
+  /**
+   * Set the highlight directly (pointer hover; no-op unless ready, idle, and
+   * in filtered range).
+   * @param index - filtered-row index.
+   */
+  highlight(index: number): void {
+    const s = this.state.getSnapshot()
+    if (!s.open || s.status !== 'ready' || s.submitting) return
+    if (index < 0 || index >= filterOptions(s.options, s.search).length || index === s.active) return
+    this.state.set({ ...s, active: index })
+  }
+
+  /**
+   * Select one filtered row: single-flight — the first call enters
+   * `submitting` and later calls no-op until it settles. Success consumes the
+   * open-time token segment (a false CAS answer is benign), closes, and
+   * returns focus to the composer. Failure keeps the shell open with search,
+   * highlight, and token intact, surfaces the error, and re-arms select as
+   * the retry.
+   * @param index - filtered-row index (callers pass the highlight or the clicked row).
+   * @returns settled when the attempt has closed the shell or surfaced its failure.
+   */
+  async select(index: number): Promise<void> {
+    const binding = this.binding
+    const s = this.state.getSnapshot()
+    if (binding === null || !s.open || s.status !== 'ready' || s.submitting) return
+    const option = filterOptions(s.options, s.search)[index]
+    if (option === undefined) return
+    this.state.set({ ...s, submitting: true, error: null })
+    try {
+      await binding.spec.onSelect(option, binding.context)
+    } catch (error) {
+      console.error(`[ui-command] popupSelect onSelect failed for /${binding.command}:`, error)
+      if (this.binding !== binding) return // dismissed/reopened/disposed while onSelect flew
+      this.state.set({ ...this.state.getSnapshot(), submitting: false, error: errorText(error) })
+      return
+    }
+    if (this.binding !== binding) return // late success: no state write, no consumption
+    this.deps.consume(binding.segment)
+    this.binding = null
+    this.state.set(CLOSED)
+    this.deps.focusComposer()
+  }
+
+  /**
+   * Close the shell; aborts a flying options fetch and revokes settlement
+   * rights. An outside pointer interaction dismisses plainly (the click's own
+   * target takes focus); Escape passes focusComposer to return focus explicitly.
+   * @param opts - focusComposer: also restore composer focus (Escape path).
+   */
+  dismiss(opts?: { readonly focusComposer?: boolean }): void {
+    if (this.binding === null) return
+    this.binding.abort.abort()
+    this.binding = null
+    this.state.set(CLOSED)
+    if (opts?.focusComposer === true) this.deps.focusComposer()
+  }
+
+  /** Scope-teardown disposer: abort in-flight work and clear state (no focus side effect). */
+  dispose(): void {
+    this.binding?.abort.abort()
+    this.binding = null
+    this.state.set(CLOSED)
+  }
+}

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

@@ -0,0 +1,292 @@
+/**
+ * CommandService (`ctx.command`): the '/' command source over the
+ * session-keyed directory, the client-contribution registry, and the
+ * per-session popupSelect controllers. Candidate synthesis merges the host
+ * catalog with contributions by availability, then query/position filtering;
+ * a host/contribution name collision fails loud. Every execute addresses the
+ * session's agent by sessionId — sessions are always agent-backed.
+ */
+import { Service } from 'cordis'
+import type { Context } from 'cordis'
+import type { ConnectionHandle, SessionId } from '@deepseek-ai/dsh-client-connection/client'
+import type { ClientContext, SessionsService } from '@deepseek-ai/dsh-client-runtime/client'
+import type {
+  CandidateRequest, ClientSessionContext, CommandClaim, PickOutcome, SlashCandidate, SlashPick,
+  SlashServiceContract, SubmitOutcome,
+} from '@deepseek-ai/dsh-client-ui-slash/client'
+import type { CommandContribution, CommandServiceContract } from './contract.ts'
+import type { CommandDescriptor } from './directory.ts'
+import { CommandDirectory } from './directory.ts'
+import { PopupSelectController } from './popup.ts'
+import type { TokenSegment } from './popup.ts'
+
+/** Live mutable state in one holder (service methods run behind the caller-ctx tracker). */
+interface LiveState {
+  readonly contributions: Map<string, CommandContribution>
+  readonly popups: Map<SessionId, PopupSelectController<ClientSessionContext>>
+}
+
+/** Command surface: session-keyed directory + '/' source + contribution registry + per-session popups. */
+export class CommandService extends Service implements CommandServiceContract {
+  static inject = ['slash', 'sessions', 'connection']
+
+  private readonly directory: CommandDirectory
+  private readonly live: LiveState = { contributions: new Map(), popups: new Map() }
+
+  /**
+   * @param ctx - owning root context (plugin fiber; the service registers
+   * itself as `command` and follows that fiber's lifetime).
+   */
+  constructor(ctx: Context) {
+    super(ctx, 'command')
+    const connection = ctx.get('connection') as ConnectionHandle | undefined
+    if (connection === undefined) throw new Error('ui-command: connection service unavailable')
+    this.directory = new CommandDirectory(async (sessionId) => {
+      const { result } = await connection.api.commands.list({ sessionId })
+      if (!result.ok) throw new Error(`command.list failed: ${result.error.code}: ${result.error.message}`)
+      return result.value.commands
+    })
+    const slash = ctx.get('slash') as SlashServiceContract | undefined
+    if (slash === undefined) throw new Error('ui-command: slash service unavailable')
+    ctx.effect(() => slash.registerSource({
+      trigger: '/',
+      name: 'command',
+      candidates: (session, req) => this.candidates(session, req),
+      onPick: pick => this.dispatch(pick),
+      matchSpace: (session, token) => this.matchSpace(session, token),
+      matchEnter: (session, line, signal) => this.matchEnter(session, line, signal),
+      warm: (session) => { this.directory.warm(session.sessionId) },
+    }), 'command: slash source')
+    ctx.on('commands/changed', () => { this.directory.invalidateAll() })
+    ctx.on('connection/reset', () => { this.directory.resetConnected() })
+  }
+
+  /**
+   * Register one client command contribution; effect disposer (rides the
+   * caller's fiber). Duplicate names throw.
+   * @param contribution - the contribution (descriptor + availability + popup spec).
+   * @returns the disposer removing the registration.
+   */
+  register(contribution: CommandContribution): () => void {
+    const dispose = this.ctx.effect(() => {
+      const { contributions } = this.live
+      if (contributions.has(contribution.name)) {
+        throw new Error(`ui-command: duplicate contribution for /${contribution.name}`)
+      }
+      contributions.set(contribution.name, contribution)
+      return () => { contributions.delete(contribution.name) }
+    }, 'command.register()')
+    return () => { void dispose() }
+  }
+
+  /**
+   * Resolve the per-session popup controller (lazy; dies with the session
+   * scope). The controller's consume callback dispatches the scoped
+   * consume-token event back to this session; focusComposer reaches the
+   * composer through the overlay slot currency.
+   * @param actx - session-scope ctx.
+   * @returns the resident controller.
+   */
+  popupFor(actx: ClientContext): PopupSelectController<ClientSessionContext> {
+    const sessions = this.sessions()
+    const id = sessions.scopeOf(actx)
+    if (id === undefined) throw new Error('command.popupFor requires a session scope')
+    const { popups } = this.live
+    const existing = popups.get(id)
+    if (existing !== undefined) return existing
+    const controller = new PopupSelectController<ClientSessionContext>({
+      consume: segment => actx.bail(actx, 'slash/input-consume-token', {
+        guard: segment.via === 'menu'
+          ? { kind: 'span', span: segment.span }
+          : { kind: 'bare-token', token: segment.token },
+      }) === true,
+      focusComposer: () => { this.focusHooks.get(id)?.() },
+    })
+    popups.set(id, controller)
+    actx.effect(() => () => {
+      controller.dispose()
+      popups.delete(id)
+      this.focusHooks.delete(id)
+    }, 'command: session popup')
+    return controller
+  }
+
+  /** Composer focus hooks by session (the overlay wiring binds the textarea focus here). */
+  private readonly focusHooks = new Map<SessionId, () => void>()
+
+  /**
+   * Bind one session's composer-focus hook (overlay slot wiring; unbind on unmount).
+   * @param id - session id.
+   * @param focus - textarea focus callback.
+   * @returns the unbind disposer.
+   */
+  bindComposerFocus(id: SessionId, focus: () => void): () => void {
+    this.focusHooks.set(id, focus)
+    return () => {
+      if (this.focusHooks.get(id) === focus) this.focusHooks.delete(id)
+    }
+  }
+
+  /** Menu candidates: host catalog + contribution availability, then query/position filtering. */
+  private async candidates(session: ClientSessionContext, req: CandidateRequest): Promise<readonly SlashCandidate[]> {
+    const list = await this.directory.ensureReady(session.sessionId, req.signal)
+    const rows: SlashCandidate[] = []
+    const seen = new Set<string>()
+    for (const c of list) {
+      seen.add(c.name)
+      rows.push({ name: c.name, description: c.description, ...(c.input !== undefined ? { hint: c.input.hint } : {}) })
+    }
+    for (const contribution of this.live.contributions.values()) {
+      if (!contribution.available(session)) continue
+      if (seen.has(contribution.name)) {
+        throw new Error(`ui-command: contribution /${contribution.name} collides with a host command`)
+      }
+      rows.push({ name: contribution.name, description: contribution.description })
+    }
+    return rows
+      .filter(c => c.name.startsWith(req.query))
+      .filter(c => req.position === 'leading' || c.hint === undefined)
+  }
+
+  /** Decision table, menu column: contribution → popup; host input → claim; host bare → detached execute. */
+  private dispatch(pick: SlashPick): PickOutcome {
+    const name = pick.candidate.name
+    const contribution = this.live.contributions.get(name)
+    if (contribution !== undefined && contribution.available(pick.session)) {
+      this.openPopup(contribution, pick.session, { via: 'menu', span: pick.span })
+      return 'handled'
+    }
+    const desc = this.directory.resolve(pick.session.sessionId, name)
+    if (desc === undefined) return undefined // snapshot swapped between menu and pick → miss
+    if (desc.input !== undefined) return { claim: this.leadingClaim(desc, pick.session) }
+    // Menu-pick execute consumes the trigger span before the detached run
+    // (scoped event; the input owns the CAS guard).
+    this.consumeVia(pick.session.sessionId, { via: 'menu', span: pick.span })
+    this.runDetached(desc, pick.session, `/${name}`)
+    return 'handled'
+  }
+
+  /** Decision table, space column: hot-key sync check; only host leadingInput claims. */
+  private matchSpace(session: ClientSessionContext, token: string): PickOutcome {
+    if (!token.startsWith('/')) return undefined
+    const name = token.slice(1)
+    if (this.live.contributions.has(name)) return undefined // popup kinds never claim on space
+    const desc = this.directory.resolve(session.sessionId, name)
+    if (desc === undefined || desc.input === undefined) return undefined
+    return { claim: this.leadingClaim(desc, session) }
+  }
+
+  /**
+   * Decision table, enter column. Strong-waits the session's catalog (a
+   * warmup failure rejects — never a silent downgrade). Contributions and
+   * bare host commands act on the bare token only; leadingInput claims
+   * args-tolerant.
+   */
+  private async matchEnter(session: ClientSessionContext, line: string, signal: AbortSignal): Promise<PickOutcome> {
+    const trimmed = line.trim()
+    if (!trimmed.startsWith('/')) return undefined
+    const ws = trimmed.search(/\s/)
+    const token = ws === -1 ? trimmed : trimmed.slice(0, ws)
+    const bare = ws === -1
+    const name = token.slice(1)
+    if (name === '') return undefined
+    const contribution = this.live.contributions.get(name)
+    if (contribution !== undefined && contribution.available(session)) {
+      if (!bare) return undefined
+      this.openPopup(contribution, session, { via: 'enter', token })
+      return 'handled'
+    }
+    await this.directory.ensureReady(session.sessionId, signal)
+    const desc = this.directory.resolve(session.sessionId, name)
+    if (desc === undefined) return undefined
+    if (desc.input !== undefined) return { claim: this.leadingClaim(desc, session) }
+    if (!bare) return undefined
+    this.consumeVia(session.sessionId, { via: 'enter', token })
+    this.runDetached(desc, session, trimmed)
+    return 'handled'
+  }
+
+  /** Open the session's popup for one contribution (menu pick / bare enter). */
+  private openPopup(
+    contribution: CommandContribution,
+    session: ClientSessionContext,
+    segment: TokenSegment,
+  ): void {
+    const actx = this.scopeFor(session.sessionId)
+    if (actx === undefined) return
+    this.popupFor(actx).open(contribution.name, contribution.ui, session, segment)
+  }
+
+  /** Build the leadingInput claim: token `/name ` + the command.execute submit transaction. */
+  private leadingClaim(desc: CommandDescriptor, session: ClientSessionContext): CommandClaim {
+    const token = `/${desc.name} `
+    return {
+      token,
+      ...(desc.input !== undefined ? { hint: desc.input.hint } : {}),
+      submit: (args, _actx) => this.execute(session, token + args),
+    }
+  }
+
+  /** The command.execute transaction, addressed to the session's agent. */
+  private async execute(
+    session: ClientSessionContext,
+    line: string,
+  ): Promise<SubmitOutcome> {
+    const connection = this.ctx.get('connection') as ConnectionHandle
+    const { result } = await connection.api.commands.execute({ sessionId: session.sessionId, line })
+    if (!result.ok) throw new Error(`command.execute failed: ${result.error.code}: ${result.error.message}`)
+    if (!result.value.matched) return { kind: 'error', text: `unknown or malformed command: ${line}` }
+    const detached = result.value.result
+    return detached === undefined
+      ? { kind: 'success' }
+      : { kind: detached.kind, ...(detached.text !== undefined ? { text: detached.text } : {}) }
+  }
+
+  /**
+   * Fire-and-forget execute for the internal ('handled') paths. The detached
+   * result surfaces as a notice routed to the triggering session's composer,
+   * so a late result lands on its own session after a switch.
+   */
+  private runDetached(desc: CommandDescriptor, session: ClientSessionContext, line: string): void {
+    void this.execute(session, line).then(
+      (outcome) => {
+        if (outcome.kind === 'error') this.noticeFor(session.sessionId, desc.name, 'error', outcome.text ?? `/${desc.name} failed`)
+        else if (outcome.text !== undefined) this.noticeFor(session.sessionId, desc.name, 'info', outcome.text)
+      },
+      (error: unknown) => {
+        this.noticeFor(session.sessionId, desc.name, 'error', error instanceof Error ? error.message : String(error))
+      },
+    )
+  }
+
+  /** Dispatch a consume-token event to one session (menu-pick / bare-enter execute paths). */
+  private consumeVia(id: SessionId, segment: TokenSegment): void {
+    const actx = this.scopeFor(id)
+    if (actx === undefined) return
+    actx.bail(actx, 'slash/input-consume-token', {
+      guard: segment.via === 'menu'
+        ? { kind: 'span', span: segment.span }
+        : { kind: 'bare-token', token: segment.token },
+    })
+  }
+
+  /** Route a detached result to the session's composer notice channel (scope gone = attempt died with it). */
+  private noticeFor(id: SessionId, _name: string, level: 'info' | 'error', text: string): void {
+    const actx = this.scopeFor(id)
+    if (actx === undefined) return
+    const conversation = actx.get('conversation')
+    if (conversation === undefined) return
+    conversation.input.for(actx).notify(level, text)
+  }
+
+  /** id → actx interchange (registered exchange point: this service coordinates for projection-only sources). */
+  private scopeFor(id: SessionId): ClientContext | undefined {
+    return this.sessions().scope(id)
+  }
+
+  private sessions(): SessionsService {
+    const sessions = this.ctx.get('sessions')
+    if (sessions === undefined) throw new Error('ui-command: sessions service unavailable')
+    return sessions
+  }
+}

packages/client/ui-command/src/css-modules.d.ts

@@ -0,0 +1,6 @@
+declare module '*.module.css' {
+  const classes: Record<string, string>
+  export default classes
+}
+
+declare module '*.css'

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

@@ -0,0 +1,10 @@
+/**
+ * Command UI plugin, node half. Pure UI plugin: the empty apply exists so
+ * the plugin appears in the host cordis.yml / Loader; the browser half ships
+ * via exports["./client"], discovered through the package.json dshClient
+ * declaration. The host command registry itself mounts separately
+ * (bootHost + CommandService).
+ */
+
+/** Host plugin body — no host-side behavior for the command UI plugin. */
+export function apply(): void {}

packages/client/ui-command/src/invariant.ts

@@ -0,0 +1,31 @@
+/**
+ * Package-owned invariant companion for `@deepseek-ai/dsh-client-ui-command`.
+ * @module @deepseek-ai/dsh-client-ui-command/invariant
+ */
+
+/* jscpd:ignore-start */
+import type { Context } from 'cordis'
+import type { InvariantInstaller } from '@deepseek-ai/dsh-invariants'
+
+const PACKAGE_NAME = '@deepseek-ai/dsh-client-ui-command'
+
+/** Cordis companion plugin name. */
+export const name = 'client-ui-command-invariant'
+/** Service required before the companion can reserve package ownership. */
+export const inject = ['invariants']
+
+/**
+ * No runtime invariant: a browser-side source over the wire command
+ * directory — it emits no cordis events and owns no cross-plugin mutable
+ * state; dispatch and cache behavior are asserted by this package's specs.
+ */
+const install: InvariantInstaller = () => {}
+
+/**
+ * Register this package's invariant companion.
+ * @param ctx - Cordis context carrying the invariant service.
+ * @returns the installed registration's disposer after setup succeeds.
+ */
+export const apply = (ctx: Context): Promise<() => void> =>
+  Promise.resolve(ctx.invariants.register(PACKAGE_NAME, install))
+/* jscpd:ignore-end */

packages/client/ui-command/tests/browser-plugin.spec.ts

@@ -0,0 +1,83 @@
+/**
+ * ui-command browser half on a real cordis Context with fake slash/slots
+ * faces and real session scopes: the plugin body mounts CommandService as
+ * `command`, the popupSelect shell registers into conversation.input.overlay
+ * once the conversation seam is up with a per-session inject (sessionId →
+ * scope → popupFor; unknown id fails loud), both fold up on fiber disposal
+ * (HMR safety), and the service satisfies the frozen CommandServiceContract.
+ */
+import { Context } from 'cordis'
+import { describe, expect, it } from 'vitest'
+import { createScope, scopeOf } from '@deepseek-ai/dsh-client-runtime/client'
+import type { SessionId } from '@deepseek-ai/dsh-client-runtime/client'
+import type { SlashSource } from '@deepseek-ai/dsh-client-ui-slash/client'
+import type { CommandServiceContract } from '../src/client/contract.ts'
+import type { PopupSelectInjected } from '../src/client/PopupSelectView.tsx'
+import { apply, CommandService, inject } from '../src/client/index.ts'
+
+const sid = (k: string): SessionId => k as SessionId
+
+async function bench() {
+  const ctx = new Context()
+  const sources = new Map<string, SlashSource>()
+  const overlays = new Map<string, { inject: unknown }>()
+  ctx.provide('slash', {
+    registerSource(src: SlashSource) {
+      sources.set(`${src.trigger} ${src.name}`, src)
+      return () => { sources.delete(`${src.trigger} ${src.name}`) }
+    },
+  })
+  const scopes = new Map<SessionId, Context>()
+  ctx.provide('sessions', {
+    scope: (id: SessionId) => scopes.get(id),
+    scopeOf: (c: Context) => scopeOf(c),
+  })
+  ctx.provide('connection', { api: { commands: { list: () => Promise.resolve({ result: { ok: true, value: { commands: [] } } }) } } })
+  ctx.provide('slots', {
+    register(options: { name: string; id?: string; inject?: unknown }) {
+      const key = `${options.name}#${options.id ?? ''}`
+      overlays.set(key, { inject: options.inject })
+      return () => { overlays.delete(key) }
+    },
+  })
+  ctx.provide('conversation', {})
+  const fiber = ctx.plugin({ inject: [...inject], apply })
+  await fiber.await()
+  const mint = (key: string) => {
+    const handle = createScope(ctx, sid(key))
+    scopes.set(sid(key), handle.ctx)
+    return handle
+  }
+  return { ctx, fiber, sources, overlays, mint }
+}
+
+describe('apply', () => {
+  it('declares the services it binds', () => {
+    expect(inject).toEqual(['slash', 'sessions', 'connection'])
+  })
+
+  it('mounts ctx.command, registers the source and the overlay entry, and folds up on disposal', async () => {
+    const { ctx, fiber, sources, overlays } = await bench()
+    const command = ctx.get('command')
+    expect(command).toBeInstanceOf(CommandService)
+    // Frozen-contract conformance (compile-time check rides the assignment).
+    const contract: CommandServiceContract = command as CommandService
+    expect(typeof contract.register).toBe('function')
+    expect(typeof contract.popupFor).toBe('function')
+    expect([...sources.keys()]).toEqual(['/ command'])
+    expect([...overlays.keys()]).toEqual(['conversation.input.overlay#command-popup'])
+    await fiber.dispose()
+    expect(sources.size).toBe(0)
+    expect(overlays.size).toBe(0)
+  })
+
+  it('the overlay inject resolves the per-session popup controller by sessionId and fails loud on an unknown id', async () => {
+    const { ctx, overlays, mint } = await bench()
+    const command = ctx.get('command') as CommandService
+    const scope = mint('s1')
+    const entry = overlays.get('conversation.input.overlay#command-popup')!
+    const injectEntry = entry.inject as (sessionId: SessionId) => PopupSelectInjected
+    expect(injectEntry(sid('s1')).popup).toBe(command.popupFor(scope.ctx))
+    expect(() => injectEntry(sid('ghost'))).toThrow(/resolved no scope/)
+  })
+})

packages/client/ui-command/tests/directory.spec.ts

@@ -0,0 +1,293 @@
+/**
+ * CommandDirectory unit tests over the session-key axis: per-key status
+ * transitions and epoch guard, key isolation across sessions, soft
+ * invalidation (invalidateAll), the reconnect hard reset (resetConnected:
+ * every entry drops its snapshot and prewarms), the warm hook's cold/failed
+ * gate, and the per-key ensureReady strong-wait policy.
+ */
+import { describe, expect, it } from 'vitest'
+import type { SessionId } from '@deepseek-ai/dsh-client-connection/client'
+import type { CommandDescriptor } from '../src/client/directory.ts'
+import { CommandDirectory } from '../src/client/directory.ts'
+
+const sid = (k: string): SessionId => k as SessionId
+const S1 = sid('s1')
+const S2 = sid('s2')
+
+function deferred<T>() {
+  let resolve!: (value: T) => void
+  let reject!: (reason?: unknown) => void
+  const promise = new Promise<T>((res, rej) => { resolve = res; reject = rej })
+  return { promise, resolve, reject }
+}
+
+const CMDS: CommandDescriptor[] = [
+  { name: 'plan', description: 'plan mode' },
+  { name: 'goal', description: 'set goal', input: { hint: 'goal text' } },
+]
+
+const S2_CMDS: CommandDescriptor[] = [
+  ...CMDS,
+  { name: 'attach', description: 'attach a file', input: { hint: 'path' } },
+]
+
+/** Directory over per-key pull queues: each fetch appends a hand-settled deferred. */
+function bench() {
+  const pulls = new Map<SessionId, Array<ReturnType<typeof deferred<readonly CommandDescriptor[]>>>>()
+  const calls: SessionId[] = []
+  const dir = new CommandDirectory((key) => {
+    calls.push(key)
+    const d = deferred<readonly CommandDescriptor[]>()
+    const queue = pulls.get(key) ?? []
+    queue.push(d)
+    pulls.set(key, queue)
+    return d.promise
+  })
+  const pull = (key: SessionId, i: number) => {
+    const d = pulls.get(key)?.[i]
+    if (d === undefined) throw new Error(`no pull #${i} for ${key}`)
+    return d
+  }
+  return { dir, pull, calls, countOf: (key: SessionId) => pulls.get(key)?.length ?? 0 }
+}
+
+describe('status and resolve (per key)', () => {
+  it('starts cold and resolves nothing', () => {
+    const { dir } = bench()
+    expect(dir.status(S1)).toBe('cold')
+    expect(dir.resolve(S1, 'plan')).toBeUndefined()
+  })
+
+  it('serves exact-name lookups once ready, undefined for unknown names', async () => {
+    const { dir, pull } = bench()
+    const refreshed = dir.refresh(S1)
+    expect(dir.status(S1)).toBe('pending')
+    pull(S1, 0).resolve(CMDS)
+    await refreshed
+    expect(dir.status(S1)).toBe('ready')
+    expect(dir.resolve(S1, 'goal')).toEqual(CMDS[1])
+    expect(dir.resolve(S1, 'nope')).toBeUndefined()
+  })
+
+  it('drops the snapshot and records failure on a failed pull', async () => {
+    const { dir, pull } = bench()
+    const refreshed = dir.refresh(S1)
+    pull(S1, 0).reject(new Error('boom'))
+    await refreshed
+    expect(dir.status(S1)).toBe('failed')
+    expect(dir.resolve(S1, 'plan')).toBeUndefined()
+  })
+
+  it('keys are isolated: one session catalog landing leaves another cold', async () => {
+    const { dir, pull } = bench()
+    const refreshed = dir.refresh(S1)
+    pull(S1, 0).resolve(CMDS)
+    await refreshed
+    expect(dir.status(S2)).toBe('cold')
+    expect(dir.resolve(S2, 'plan')).toBeUndefined()
+
+    const other = dir.refresh(S2)
+    pull(S2, 0).resolve(S2_CMDS)
+    await other
+    expect(dir.resolve(S2, 'attach')).toBeDefined()
+    expect(dir.resolve(S1, 'attach')).toBeUndefined()
+  })
+})
+
+describe('epoch guard (per key)', () => {
+  it('a superseded pull cannot overwrite the newer one (old resolves after new)', async () => {
+    const { dir, pull } = bench()
+    const first = dir.refresh(S1)
+    const second = dir.refresh(S1)
+    pull(S1, 1).resolve(CMDS)
+    await second
+    expect(dir.resolve(S1, 'plan')).toBeDefined()
+    pull(S1, 0).resolve([{ name: 'stale', description: 'old world' }])
+    await first
+    expect(dir.resolve(S1, 'stale')).toBeUndefined()
+    expect(dir.resolve(S1, 'plan')).toBeDefined()
+  })
+
+  it('a superseded failure cannot demote the newer success', async () => {
+    const { dir, pull } = bench()
+    const first = dir.refresh(S1)
+    const second = dir.refresh(S1)
+    pull(S1, 1).resolve(CMDS)
+    await second
+    pull(S1, 0).reject(new Error('late failure'))
+    await first
+    expect(dir.status(S1)).toBe('ready')
+    expect(dir.resolve(S1, 'plan')).toBeDefined()
+  })
+
+  it('epochs are per key: one session supersede leaves another session epoch alone', async () => {
+    const { dir, pull } = bench()
+    const one = dir.refresh(S1)
+    void dir.refresh(S2)
+    void dir.refresh(S2) // supersedes the s2 pull only
+    pull(S1, 0).resolve(CMDS)
+    await one
+    expect(dir.status(S1)).toBe('ready')
+  })
+})
+
+describe('invalidateAll (commands-changed soft)', () => {
+  it('repulls every touched key in the background while ready snapshots keep serving', async () => {
+    const { dir, pull, countOf } = bench()
+    const a = dir.refresh(S1)
+    const b = dir.refresh(S2)
+    pull(S1, 0).resolve(CMDS)
+    pull(S2, 0).resolve(S2_CMDS)
+    await Promise.all([a, b])
+
+    dir.invalidateAll()
+    expect(countOf(S1)).toBe(2)
+    expect(countOf(S2)).toBe(2)
+    expect(dir.status(S1)).toBe('ready')
+    expect(dir.resolve(S2, 'attach')).toBeDefined()
+
+    pull(S1, 1).resolve([{ name: 'fresh', description: 'new world' }])
+    await Promise.resolve()
+    await Promise.resolve()
+    expect(dir.resolve(S1, 'fresh')).toBeDefined()
+    expect(dir.resolve(S1, 'plan')).toBeUndefined()
+  })
+
+  it('an untouched directory invalidates to nothing (no keys, no pulls)', () => {
+    const { dir, calls } = bench()
+    dir.invalidateAll()
+    expect(calls).toEqual([])
+  })
+})
+
+describe('resetConnected (reconnect hard)', () => {
+  it('every entry drops its snapshot immediately and prewarms', async () => {
+    const { dir, pull, countOf } = bench()
+    const a = dir.refresh(S1)
+    const b = dir.refresh(S2)
+    pull(S1, 0).resolve(CMDS)
+    pull(S2, 0).resolve(S2_CMDS)
+    await Promise.all([a, b])
+
+    dir.resetConnected()
+    // Hard: the agent world may have changed shape across the generation.
+    expect(dir.status(S1)).toBe('pending')
+    expect(dir.resolve(S1, 'plan')).toBeUndefined()
+    expect(dir.status(S2)).toBe('pending')
+    expect(dir.resolve(S2, 'attach')).toBeUndefined()
+    expect(countOf(S1)).toBe(2)
+    expect(countOf(S2)).toBe(2)
+
+    pull(S1, 1).resolve(CMDS)
+    pull(S2, 1).resolve(S2_CMDS)
+    await Promise.resolve()
+    await Promise.resolve()
+    expect(dir.status(S1)).toBe('ready')
+    expect(dir.resolve(S2, 'attach')).toBeDefined()
+  })
+})
+
+describe('warm', () => {
+  it('launches a pull from cold, again after failure, and never over pending/ready', async () => {
+    const { dir, pull, countOf } = bench()
+    dir.warm(S1)
+    expect(countOf(S1)).toBe(1)
+    dir.warm(S1) // pending → no second pull
+    expect(countOf(S1)).toBe(1)
+
+    pull(S1, 0).reject(new Error('boom'))
+    await Promise.resolve()
+    await Promise.resolve()
+    expect(dir.status(S1)).toBe('failed')
+    dir.warm(S1) // failed → retry
+    expect(countOf(S1)).toBe(2)
+
+    pull(S1, 1).resolve(CMDS)
+    await Promise.resolve()
+    await Promise.resolve()
+    dir.warm(S1) // ready → no-op
+    expect(countOf(S1)).toBe(2)
+  })
+
+  it('warms keys independently', () => {
+    const { dir, countOf } = bench()
+    dir.warm(S2)
+    expect(countOf(S2)).toBe(1)
+    expect(countOf(S1)).toBe(0)
+  })
+})
+
+describe('ensureReady (per key)', () => {
+  const signal = () => new AbortController().signal
+
+  it('returns the hot snapshot at once when ready', async () => {
+    const { dir, pull, countOf } = bench()
+    const warm = dir.refresh(S1)
+    pull(S1, 0).resolve(CMDS)
+    await warm
+    await expect(dir.ensureReady(S1, signal())).resolves.toEqual(CMDS)
+    expect(countOf(S1)).toBe(1)
+  })
+
+  it('launches a pull from cold and resolves on arrival, without touching other keys', async () => {
+    const { dir, pull, countOf } = bench()
+    const wait = dir.ensureReady(S2, signal())
+    expect(dir.status(S2)).toBe('pending')
+    pull(S2, 0).resolve(S2_CMDS)
+    await expect(wait).resolves.toEqual(S2_CMDS)
+    expect(countOf(S1)).toBe(0)
+  })
+
+  it('joins a flying pull instead of starting a second one', async () => {
+    const { dir, pull, countOf } = bench()
+    void dir.refresh(S1)
+    const wait = dir.ensureReady(S1, signal())
+    expect(countOf(S1)).toBe(1)
+    pull(S1, 0).resolve(CMDS)
+    await expect(wait).resolves.toEqual(CMDS)
+  })
+
+  it('rejects when the awaited pull fails (no silent downgrade)', async () => {
+    const { dir, pull } = bench()
+    const wait = dir.ensureReady(S1, signal())
+    pull(S1, 0).reject(new Error('warmup boom'))
+    await expect(wait).rejects.toThrow('command directory warmup failed: warmup boom')
+  })
+
+  it('retries from failed state with a fresh pull', async () => {
+    const { dir, pull } = bench()
+    const first = dir.ensureReady(S1, signal())
+    pull(S1, 0).reject(new Error('boom'))
+    await expect(first).rejects.toThrow()
+    const second = dir.ensureReady(S1, signal())
+    pull(S1, 1).resolve(CMDS)
+    await expect(second).resolves.toEqual(CMDS)
+  })
+
+  it('rejects on abort while waiting', async () => {
+    const { dir } = bench()
+    const ac = new AbortController()
+    const wait = dir.ensureReady(S1, ac.signal)
+    ac.abort(new Error('attempt superseded'))
+    await expect(wait).rejects.toThrow('attempt superseded')
+  })
+
+  it('rejects immediately on an already-aborted signal', async () => {
+    const { dir, pull } = bench()
+    const warm = dir.refresh(S1)
+    pull(S1, 0).reject(new Error('irrelevant'))
+    await warm
+    const ac = new AbortController()
+    ac.abort() // bare abort: the DOMException reason is itself an Error and travels as-is
+    await expect(dir.ensureReady(S1, ac.signal)).rejects.toThrow(/aborted/)
+  })
+
+  it('keeps waiting across a superseded pull and settles on the winner', async () => {
+    const { dir, pull } = bench()
+    const wait = dir.ensureReady(S1, signal())
+    void dir.refresh(S1) // supersedes pull #0 with pull #1
+    pull(S1, 0).resolve([{ name: 'stale', description: 'loser' }])
+    pull(S1, 1).resolve(CMDS)
+    await expect(wait).resolves.toEqual(CMDS)
+  })
+})

packages/client/ui-command/tests/popup-view.spec.tsx

@@ -0,0 +1,174 @@
+// @vitest-environment jsdom
+/**
+ * PopupSelectView interaction spec (design §10.2): the search input takes
+ * focus on open and plain typing filters locally, ↑↓ move the filtered
+ * highlight while ←→ stay native to the input, Enter selects single-flight,
+ * Escape dismisses back through focusComposer, outside pointerdown dismisses
+ * plainly, and the submitting/failed states render pending text and a
+ * working retry button.
+ */
+import { afterEach, describe, expect, it, vi } from 'vitest'
+import { act, cleanup, fireEvent, render, screen } from '@testing-library/react'
+import type { SelectOption } from '../src/client/contract.ts'
+import type { PopupSpec, TokenSegment } from '../src/client/popup.ts'
+import { PopupSelectController } from '../src/client/popup.ts'
+import { PopupSelectView } from '../src/client/PopupSelectView.tsx'
+
+afterEach(cleanup)
+
+const OPTIONS: SelectOption[] = [
+  { id: 'dark', label: 'Dark' },
+  { id: 'light', label: 'Light', active: true },
+  { id: 'sepia', label: 'Sepia', detail: 'warm' },
+]
+
+const SEGMENT: TokenSegment = { via: 'enter', token: '/theme' }
+
+function spec(overrides: Partial<PopupSpec<string>> = {}): PopupSpec<string> {
+  return {
+    options: () => Promise.resolve(OPTIONS),
+    onSelect: () => undefined,
+    ...overrides,
+  }
+}
+
+async function mountOpen(overrides: Partial<PopupSpec<string>> = {}, consumeResult = true) {
+  const consume = vi.fn((_segment: TokenSegment) => consumeResult)
+  const focusComposer = vi.fn()
+  const popup = new PopupSelectController<string>({ consume, focusComposer })
+  const view = render(<PopupSelectView popup={popup} />)
+  await act(async () => {
+    popup.open('theme', spec(overrides), 'ctx-A', SEGMENT)
+    await Promise.resolve()
+  })
+  return { popup, view, consume, focusComposer, search: screen.getByRole('textbox', { name: 'Filter options' }) }
+}
+
+function rowLabels(): string[] {
+  return screen.getAllByRole('option').map(o => o.querySelector('span')!.textContent!)
+}
+
+describe('PopupSelectView', () => {
+  it('renders null while closed, opens with focus in the search input', async () => {
+    const popup = new PopupSelectController<string>({ consume: () => true, focusComposer: () => {} })
+    const view = render(<PopupSelectView popup={popup} />)
+    expect(view.container.childElementCount).toBe(0)
+    await act(async () => {
+      popup.open('theme', spec(), 'ctx-A', SEGMENT)
+      await Promise.resolve()
+    })
+    const search = screen.getByRole('textbox', { name: 'Filter options' })
+    expect(document.activeElement).toBe(search)
+    expect(rowLabels()).toEqual(['Dark', 'Light', 'Sepia'])
+  })
+
+  it('typing filters rows locally and rebases the highlight', async () => {
+    const options = vi.fn(() => Promise.resolve(OPTIONS))
+    const { search } = await mountOpen({ options })
+    act(() => { fireEvent.change(search, { target: { value: 'li' } }) })
+    expect(rowLabels()).toEqual(['Light'])
+    expect(screen.getByRole('option').getAttribute('aria-selected')).toBe('true')
+    expect(options).toHaveBeenCalledTimes(1)
+    act(() => { fireEvent.change(search, { target: { value: 'zzz' } }) })
+    expect(screen.queryByRole('option')).toBeNull()
+    expect(screen.queryByText('No options')).not.toBeNull()
+  })
+
+  it('ArrowUp/Down move the filtered highlight; ArrowLeft/Right are left to the native caret', async () => {
+    const { search } = await mountOpen()
+    act(() => { fireEvent.keyDown(search, { key: 'ArrowDown' }) })
+    let options = screen.getAllByRole('option')
+    expect(options[1]!.getAttribute('aria-selected')).toBe('true')
+    act(() => { fireEvent.keyDown(search, { key: 'ArrowUp' }) })
+    options = screen.getAllByRole('option')
+    expect(options[0]!.getAttribute('aria-selected')).toBe('true')
+    // fireEvent returns false when preventDefault was called: arrow left/right must NOT be intercepted.
+    expect(fireEvent.keyDown(search, { key: 'ArrowLeft' })).toBe(true)
+    expect(fireEvent.keyDown(search, { key: 'ArrowRight' })).toBe(true)
+  })
+
+  it('Enter selects the highlighted row: onSelect, consume, close, focusComposer', async () => {
+    const seen: Array<{ option: SelectOption; context: string }> = []
+    const { view, search, consume, focusComposer } = await mountOpen({
+      onSelect: (option, context) => { seen.push({ option, context }) },
+    })
+    act(() => { fireEvent.keyDown(search, { key: 'ArrowDown' }) })
+    await act(async () => { fireEvent.keyDown(search, { key: 'Enter' }) })
+    expect(seen).toEqual([{ option: OPTIONS[1], context: 'ctx-A' }])
+    expect(consume).toHaveBeenCalledExactlyOnceWith(SEGMENT)
+    expect(focusComposer).toHaveBeenCalledTimes(1)
+    expect(view.container.childElementCount).toBe(0)
+  })
+
+  it('click selects a row; mouseenter moves the highlight', async () => {
+    const seen: SelectOption[] = []
+    const { view } = await mountOpen({ onSelect: (option) => { seen.push(option) } })
+    const options = screen.getAllByRole('option')
+    act(() => { fireEvent.mouseEnter(options[2]!) })
+    expect(screen.getAllByRole('option')[2]!.getAttribute('aria-selected')).toBe('true')
+    await act(async () => { fireEvent.click(options[2]!) })
+    expect(seen).toEqual([OPTIONS[2]])
+    expect(view.container.childElementCount).toBe(0)
+  })
+
+  it('submitting shows pending, locks the search input, and further Enter/click no-op', async () => {
+    let release!: () => void
+    const onSelect = vi.fn(() => new Promise<void>((resolve) => { release = resolve }))
+    const { search, consume } = await mountOpen({ onSelect })
+    await act(async () => { fireEvent.keyDown(search, { key: 'Enter' }) })
+    expect(screen.queryByText('Applying…')).not.toBeNull()
+    expect((search as HTMLInputElement).readOnly).toBe(true)
+    await act(async () => {
+      fireEvent.keyDown(search, { key: 'Enter' })
+      fireEvent.click(screen.getAllByRole('option')[1]!)
+    })
+    expect(onSelect).toHaveBeenCalledTimes(1)
+    await act(async () => {
+      release()
+      await Promise.resolve()
+    })
+    expect(consume).toHaveBeenCalledTimes(1)
+  })
+
+  it('a failed options load shows the error with a Retry button that reloads', async () => {
+    let attempts = 0
+    await mountOpen({
+      options: () => {
+        attempts += 1
+        return attempts === 1 ? Promise.reject(new Error('directory down')) : Promise.resolve(OPTIONS)
+      },
+    })
+    expect(screen.getByRole('alert').textContent).toContain('directory down')
+    await act(async () => {
+      fireEvent.click(screen.getByRole('button', { name: 'Retry' }))
+      await Promise.resolve()
+    })
+    expect(attempts).toBe(2)
+    expect(rowLabels()).toEqual(['Dark', 'Light', 'Sepia'])
+  })
+
+  it('an onSelect failure keeps the shell open with the error strip and no retry button (re-select is the retry)', async () => {
+    const { search, consume } = await mountOpen({ onSelect: () => Promise.reject(new Error('host rejected')) })
+    await act(async () => { fireEvent.keyDown(search, { key: 'Enter' }) })
+    expect(screen.getByRole('alert').textContent).toContain('host rejected')
+    expect(screen.queryByRole('button', { name: 'Retry' })).toBeNull()
+    expect(consume).not.toHaveBeenCalled()
+    expect(screen.getAllByRole('option').length).toBe(3)
+  })
+
+  it('Escape dismisses and restores composer focus', async () => {
+    const { view, search, focusComposer } = await mountOpen()
+    act(() => { fireEvent.keyDown(search, { key: 'Escape' }) })
+    expect(view.container.childElementCount).toBe(0)
+    expect(focusComposer).toHaveBeenCalledTimes(1)
+  })
+
+  it('an outside pointerdown dismisses without focusComposer; an inside one does not dismiss', async () => {
+    const { view, focusComposer } = await mountOpen()
+    act(() => { fireEvent.pointerDown(screen.getAllByRole('option')[0]!) })
+    expect(view.container.childElementCount).not.toBe(0)
+    act(() => { fireEvent.pointerDown(document.body) })
+    expect(view.container.childElementCount).toBe(0)
+    expect(focusComposer).not.toHaveBeenCalled()
+  })
+})

packages/client/ui-command/tests/popup.spec.ts

@@ -0,0 +1,356 @@
+/**
+ * PopupSelectController behavior (design §10.2/§10.3): one options load per
+ * open with local search filtering, filtered highlight movement,
+ * single-flight select with open-time context, consume-on-success (CAS miss
+ * benign), failure-keeps-open retry semantics for both options and onSelect,
+ * and binding-identity revocation of late settlements after
+ * dismiss/reopen/dispose.
+ */
+import { describe, expect, it, vi } from 'vitest'
+import type { SelectOption } from '../src/client/contract.ts'
+import type { PopupSpec, TokenSegment } from '../src/client/popup.ts'
+import { filterOptions, PopupSelectController } from '../src/client/popup.ts'
+
+interface Ctx { readonly session: string }
+const CTX_A: Ctx = { session: 'A' }
+
+const OPTIONS: SelectOption[] = [
+  { id: 'dark', label: 'Dark' },
+  { id: 'light', label: 'Light', active: true },
+  { id: 'sepia', label: 'Sepia', detail: 'warm' },
+]
+
+const SEGMENT: TokenSegment = { via: 'enter', token: '/theme' }
+
+function spec(overrides: Partial<PopupSpec<Ctx>> = {}): PopupSpec<Ctx> {
+  return {
+    options: () => Promise.resolve(OPTIONS),
+    onSelect: () => undefined,
+    ...overrides,
+  }
+}
+
+/** Fake session wiring: records consume/focus calls; consume answer is settable per test. */
+function makeDeps(consumeResult = true) {
+  const consume = vi.fn((_segment: TokenSegment) => consumeResult)
+  const focusComposer = vi.fn()
+  return { consume, focusComposer }
+}
+
+async function readyPopup(overrides: Partial<PopupSpec<Ctx>> = {}, deps = makeDeps()) {
+  const popup = new PopupSelectController<Ctx>(deps)
+  popup.open('theme', spec(overrides), CTX_A, SEGMENT)
+  await Promise.resolve()
+  return { popup, deps }
+}
+
+describe('filterOptions', () => {
+  it('matches case-insensitively over label and detail; blank keeps all', () => {
+    expect(filterOptions(OPTIONS, '')).toBe(OPTIONS)
+    expect(filterOptions(OPTIONS, '  ')).toBe(OPTIONS)
+    expect(filterOptions(OPTIONS, 'DARK')).toEqual([OPTIONS[0]])
+    expect(filterOptions(OPTIONS, 'warm')).toEqual([OPTIONS[2]])
+    expect(filterOptions(OPTIONS, 'nope')).toEqual([])
+  })
+})
+
+describe('open and options load', () => {
+  it('publishes pending immediately, ready when options land', async () => {
+    const popup = new PopupSelectController<Ctx>(makeDeps())
+    let release!: (options: readonly SelectOption[]) => void
+    popup.open('theme', spec({ options: () => new Promise((resolve) => { release = resolve }) }), CTX_A, SEGMENT)
+    expect(popup.state.getSnapshot()).toMatchObject({ open: true, command: 'theme', status: 'pending', search: '', submitting: false, error: null })
+    release(OPTIONS)
+    await Promise.resolve()
+    expect(popup.state.getSnapshot()).toMatchObject({ status: 'ready', options: OPTIONS, active: 0 })
+  })
+
+  it('loads options exactly once: search filters locally without re-querying the provider', async () => {
+    const options = vi.fn(() => Promise.resolve(OPTIONS))
+    const { popup } = await readyPopup({ options })
+    popup.setSearch('li')
+    popup.setSearch('light')
+    const s = popup.state.getSnapshot()
+    expect(options).toHaveBeenCalledTimes(1)
+    expect(s.options).toEqual(OPTIONS) // original array retained; filtering is view-side
+    expect(s.search).toBe('light')
+    expect(filterOptions(s.options, s.search)).toEqual([OPTIONS[1]])
+  })
+
+  it('a reopen aborts the old load and drops its late arrival', async () => {
+    const popup = new PopupSelectController<Ctx>(makeDeps())
+    let firstSignal!: AbortSignal
+    let releaseFirst!: (options: readonly SelectOption[]) => void
+    popup.open('alpha', spec({
+      options: (_ctx, signal) => {
+        firstSignal = signal
+        return new Promise((resolve) => { releaseFirst = resolve })
+      },
+    }), CTX_A, SEGMENT)
+    popup.open('beta', spec(), CTX_A, SEGMENT)
+    expect(firstSignal.aborted).toBe(true)
+    releaseFirst([{ id: 'stale', label: 'stale' }])
+    await Promise.resolve()
+    const s = popup.state.getSnapshot()
+    expect(s.command).toBe('beta')
+    expect(s.options).toEqual(OPTIONS)
+  })
+
+  it('dispose aborts the flying load, clears state, and drops the late arrival', async () => {
+    const popup = new PopupSelectController<Ctx>(makeDeps())
+    let signal!: AbortSignal
+    let release!: (options: readonly SelectOption[]) => void
+    popup.open('theme', spec({
+      options: (_ctx, s) => {
+        signal = s
+        return new Promise((resolve) => { release = resolve })
+      },
+    }), CTX_A, SEGMENT)
+    popup.dispose()
+    expect(signal.aborted).toBe(true)
+    expect(popup.state.getSnapshot().open).toBe(false)
+    release(OPTIONS)
+    await Promise.resolve()
+    expect(popup.state.getSnapshot().open).toBe(false)
+  })
+
+  it('an options failure keeps the shell open with search retained, surfaces the error, and retry reloads', async () => {
+    let attempts = 0
+    const { popup } = await readyPopup({
+      options: () => {
+        attempts += 1
+        return attempts === 1 ? Promise.reject(new Error('directory down')) : Promise.resolve(OPTIONS)
+      },
+    })
+    await Promise.resolve()
+    popup.setSearch('da')
+    // The failure landed before setSearch (readyPopup awaited); search must survive it and retry.
+    expect(popup.state.getSnapshot()).toMatchObject({ open: true, status: 'failed', error: 'directory down', search: 'da' })
+    popup.retry()
+    expect(popup.state.getSnapshot()).toMatchObject({ status: 'pending', error: null })
+    await Promise.resolve()
+    expect(popup.state.getSnapshot()).toMatchObject({ status: 'ready', options: OPTIONS, search: 'da' })
+    expect(attempts).toBe(2)
+  })
+
+  it('retry is a no-op unless the options load failed', async () => {
+    const { popup } = await readyPopup()
+    popup.retry()
+    expect(popup.state.getSnapshot().status).toBe('ready')
+    const closed = new PopupSelectController<Ctx>(makeDeps())
+    closed.retry()
+    expect(closed.state.getSnapshot().open).toBe(false)
+  })
+})
+
+describe('search / move / highlight over the filtered list', () => {
+  it('setSearch rebases the highlight to 0 and ignores closed shells and identical text', async () => {
+    const { popup } = await readyPopup()
+    popup.move(1)
+    expect(popup.state.getSnapshot().active).toBe(1)
+    popup.setSearch('s')
+    expect(popup.state.getSnapshot()).toMatchObject({ search: 's', active: 0 })
+    const before = popup.state.getSnapshot()
+    popup.setSearch('s')
+    expect(popup.state.getSnapshot()).toBe(before)
+    const closed = new PopupSelectController<Ctx>(makeDeps())
+    closed.setSearch('x')
+    expect(closed.state.getSnapshot().search).toBe('')
+  })
+
+  it('move wraps across the FILTERED rows', async () => {
+    const { popup } = await readyPopup()
+    popup.setSearch('a') // Dark, Sepia (detail 'warm' also matches 'a'? label match: Dark, Sepia)
+    const rows = filterOptions(popup.state.getSnapshot().options, 'a')
+    expect(rows.length).toBe(2)
+    popup.move(1)
+    expect(popup.state.getSnapshot().active).toBe(1)
+    popup.move(1)
+    expect(popup.state.getSnapshot().active).toBe(0)
+    popup.move(-1)
+    expect(popup.state.getSnapshot().active).toBe(1)
+  })
+
+  it('move is a no-op while pending, closed, or when the filter matches nothing', async () => {
+    const pending = new PopupSelectController<Ctx>(makeDeps())
+    pending.open('theme', spec({ options: () => new Promise(() => {}) }), CTX_A, SEGMENT)
+    pending.move(1)
+    expect(pending.state.getSnapshot().active).toBe(0)
+    const closed = new PopupSelectController<Ctx>(makeDeps())
+    closed.move(1)
+    expect(closed.state.getSnapshot().active).toBe(0)
+    const { popup } = await readyPopup()
+    popup.setSearch('nope')
+    popup.move(1)
+    expect(popup.state.getSnapshot().active).toBe(0)
+  })
+
+  it('highlight sets the active filtered row and ignores out-of-range or same-index calls', async () => {
+    const { popup } = await readyPopup()
+    popup.highlight(1)
+    expect(popup.state.getSnapshot().active).toBe(1)
+    popup.highlight(99)
+    popup.highlight(-1)
+    popup.highlight(1)
+    expect(popup.state.getSnapshot().active).toBe(1)
+    popup.setSearch('dark') // one filtered row → index 1 now out of range
+    popup.highlight(1)
+    expect(popup.state.getSnapshot().active).toBe(0)
+  })
+})
+
+describe('select', () => {
+  it('runs onSelect with the filtered option and the open-time context, consumes, closes, refocuses', async () => {
+    const seen: Array<{ option: SelectOption; context: Ctx }> = []
+    const deps = makeDeps()
+    const { popup } = await readyPopup({
+      onSelect: (option, context) => { seen.push({ option, context }) },
+    }, deps)
+    popup.setSearch('light')
+    await popup.select(0)
+    expect(seen).toEqual([{ option: OPTIONS[1], context: CTX_A }])
+    expect(deps.consume).toHaveBeenCalledExactlyOnceWith(SEGMENT)
+    expect(deps.focusComposer).toHaveBeenCalledTimes(1)
+    expect(popup.state.getSnapshot().open).toBe(false)
+  })
+
+  it('is single-flight: the first call enters submitting, later Enter/click calls no-op', async () => {
+    let release!: () => void
+    const onSelect = vi.fn(() => new Promise<void>((resolve) => { release = resolve }))
+    const deps = makeDeps()
+    const { popup } = await readyPopup({ onSelect }, deps)
+    const first = popup.select(0)
+    expect(popup.state.getSnapshot().submitting).toBe(true)
+    await popup.select(0)
+    await popup.select(1)
+    popup.setSearch('x') // locked while submitting
+    popup.move(1)
+    popup.highlight(1)
+    expect(popup.state.getSnapshot()).toMatchObject({ search: '', active: 0 })
+    release()
+    await first
+    expect(onSelect).toHaveBeenCalledTimes(1)
+    expect(deps.consume).toHaveBeenCalledTimes(1)
+    expect(popup.state.getSnapshot().open).toBe(false)
+  })
+
+  it('a consume CAS miss is benign: no retry, still closes and refocuses', async () => {
+    const deps = makeDeps(false)
+    const { popup } = await readyPopup({}, deps)
+    await popup.select(0)
+    expect(deps.consume).toHaveBeenCalledTimes(1)
+    expect(deps.focusComposer).toHaveBeenCalledTimes(1)
+    expect(popup.state.getSnapshot().open).toBe(false)
+  })
+
+  it('an onSelect failure keeps the shell open with search/highlight/token intact, no consumption, and select re-arms', async () => {
+    let attempts = 0
+    const deps = makeDeps()
+    const { popup } = await readyPopup({
+      onSelect: () => {
+        attempts += 1
+        if (attempts === 1) throw new Error('host rejected')
+        return undefined
+      },
+    }, deps)
+    popup.setSearch('a')
+    popup.move(1)
+    await popup.select(1)
+    expect(popup.state.getSnapshot()).toMatchObject({
+      open: true, status: 'ready', submitting: false, error: 'host rejected', search: 'a', active: 1,
+    })
+    expect(deps.consume).not.toHaveBeenCalled()
+    await popup.select(1) // retry = selecting again
+    expect(deps.consume).toHaveBeenCalledExactlyOnceWith(SEGMENT)
+    expect(popup.state.getSnapshot().open).toBe(false)
+  })
+
+  it('ignores selects while closed, pending, failed, or out of filtered range', async () => {
+    const closed = new PopupSelectController<Ctx>(makeDeps())
+    await closed.select(0)
+    expect(closed.state.getSnapshot().open).toBe(false)
+    const failedDeps = makeDeps()
+    const { popup: failed } = await readyPopup({ options: () => Promise.reject(new Error('x')) }, failedDeps)
+    await failed.select(0)
+    expect(failedDeps.consume).not.toHaveBeenCalled()
+    const deps = makeDeps()
+    const { popup } = await readyPopup({}, deps)
+    popup.setSearch('dark')
+    await popup.select(1) // only one filtered row
+    expect(deps.consume).not.toHaveBeenCalled()
+    expect(popup.state.getSnapshot().open).toBe(true)
+  })
+
+  it('a dismiss racing a succeeding onSelect revokes it: no consume, no focus, state stays closed', async () => {
+    let release!: () => void
+    const deps = makeDeps()
+    const { popup } = await readyPopup({
+      onSelect: () => new Promise<void>((resolve) => { release = resolve }),
+    }, deps)
+    const selecting = popup.select(0)
+    popup.dismiss()
+    release()
+    await selecting
+    expect(deps.consume).not.toHaveBeenCalled()
+    expect(deps.focusComposer).not.toHaveBeenCalled()
+    expect(popup.state.getSnapshot().open).toBe(false)
+  })
+
+  it('a dispose racing a failing onSelect revokes its error write', async () => {
+    let reject!: (error: Error) => void
+    const deps = makeDeps()
+    const { popup } = await readyPopup({
+      onSelect: () => new Promise<void>((_resolve, rej) => { reject = rej }),
+    }, deps)
+    const selecting = popup.select(0)
+    popup.dispose()
+    reject(new Error('late'))
+    await selecting
+    expect(popup.state.getSnapshot()).toMatchObject({ open: false, error: null })
+    expect(deps.consume).not.toHaveBeenCalled()
+  })
+
+  it('a reopen racing a succeeding onSelect keeps the new shell: no consume of the old segment', async () => {
+    let release!: () => void
+    const deps = makeDeps()
+    const { popup } = await readyPopup({
+      onSelect: () => new Promise<void>((resolve) => { release = resolve }),
+    }, deps)
+    const selecting = popup.select(0)
+    popup.open('other', spec(), CTX_A, { via: 'enter', token: '/other' })
+    release()
+    await selecting
+    await Promise.resolve()
+    expect(deps.consume).not.toHaveBeenCalled()
+    expect(popup.state.getSnapshot()).toMatchObject({ open: true, command: 'other' })
+  })
+})
+
+describe('dismiss / dispose', () => {
+  it('dismiss closes, aborts the flying fetch, and is a no-op when already closed', async () => {
+    const deps = makeDeps()
+    const popup = new PopupSelectController<Ctx>(deps)
+    let signal!: AbortSignal
+    popup.open('theme', spec({
+      options: (_ctx, s) => {
+        signal = s
+        return new Promise(() => {})
+      },
+    }), CTX_A, SEGMENT)
+    popup.dismiss()
+    expect(signal.aborted).toBe(true)
+    expect(popup.state.getSnapshot().open).toBe(false)
+    expect(deps.focusComposer).not.toHaveBeenCalled() // outside-pointer path: the click's target takes focus
+    popup.dismiss()
+    popup.dispose()
+    expect(popup.state.getSnapshot().open).toBe(false)
+  })
+
+  it('the Escape path restores composer focus explicitly', async () => {
+    const deps = makeDeps()
+    const { popup } = await readyPopup({}, deps)
+    popup.dismiss({ focusComposer: true })
+    expect(deps.focusComposer).toHaveBeenCalledTimes(1)
+    expect(popup.state.getSnapshot().open).toBe(false)
+  })
+})

packages/client/ui-command/tests/service.spec.ts

@@ -0,0 +1,548 @@
+/**
+ * CommandService tests on a real cordis Context with fake slash/connection
+ * faces and real session scopes (createScope): session-keyed candidate
+ * synthesis (host catalog by sessionId + contributions by availability,
+ * collision fail-loud), the dispatch decision table cell by cell, matchSpace
+ * hot-key policy, matchEnter strong-wait / reject, the sessionId execute
+ * payload, the scoped consume-token dispatch, per-session popupFor
+ * lifecycle, and the directory invalidation event subscriptions.
+ */
+import { Context } from 'cordis'
+import { describe, expect, it, vi } from 'vitest'
+import { createScope, scopeOf } from '@deepseek-ai/dsh-client-runtime/client'
+import type { SessionId } from '@deepseek-ai/dsh-client-runtime/client'
+import type { ClientSessionContext, ConsumeTokenRequest, SlashPick, SlashSource } from '@deepseek-ai/dsh-client-ui-slash/client'
+import type { CommandContribution, CommandUiSpec, SelectOption } from '../src/client/contract.ts'
+import type { CommandDescriptor } from '../src/client/directory.ts'
+import { CommandService } from '../src/client/service.ts'
+
+const sid = (k: string): SessionId => k as SessionId
+
+/** The agent-backed session projection (single state; identity only). */
+const proj = (id: string): ClientSessionContext => ({ sessionId: sid(id) })
+
+const S1_CMDS: CommandDescriptor[] = [
+  { name: 'plan', description: 'bare kind' },
+  { name: 'goal', description: 'leadingInput kind', input: { hint: 'goal text' } },
+]
+
+const S2_CMDS: CommandDescriptor[] = [
+  ...S1_CMDS,
+  { name: 'attach', description: 'scoped shadow', input: { hint: 'path' } },
+]
+
+type ExecuteValue = { matched: boolean; result?: { kind: 'success' | 'error'; text?: string } }
+
+interface BenchOptions {
+  /** Scripted catalog per list payload; default serves the fixed catalogs by session. */
+  commands?: (payload: { sessionId: SessionId }) => Promise<{ commands: CommandDescriptor[] }>
+  execute?: (payload: { sessionId: SessionId; line: string }) => Promise<ExecuteValue>
+}
+
+async function bench(opts: BenchOptions = {}) {
+  const ctx = new Context()
+  const registered = new Map<string, SlashSource>()
+  const listCalls: Array<{ sessionId: SessionId }> = []
+  const executeCalls: Array<{ sessionId: SessionId; line: string }> = []
+  const api = {
+    commands: {
+      list: async (payload: { sessionId: SessionId }) => {
+        listCalls.push(payload)
+        const value = await (opts.commands ?? (p => Promise.resolve({
+          commands: p.sessionId === sid('s2') ? S2_CMDS : S1_CMDS,
+        })))(payload)
+        return { result: { ok: true as const, value } }
+      },
+      execute: async (payload: { sessionId: SessionId; line: string }) => {
+        executeCalls.push(payload)
+        const value = await (opts.execute ?? (() => Promise.resolve({ matched: true })))(payload)
+        return { result: { ok: true as const, value } }
+      },
+    },
+  }
+  ctx.provide('slash', {
+    registerSource(src: SlashSource) {
+      const key = `${src.trigger} ${src.name}`
+      registered.set(key, src)
+      return () => { registered.delete(key) }
+    },
+  })
+  // Real scope tags behind a fake sessions face (scope/scopeOf are all the service reads).
+  const scopes = new Map<SessionId, { ctx: Context; fiber: { dispose(): Promise<void> } }>()
+  ctx.provide('sessions', {
+    scope: (id: SessionId) => scopes.get(id)?.ctx,
+    scopeOf: (c: Context) => scopeOf(c),
+  })
+  ctx.provide('connection', { api })
+  /** Notices the fake conversation face collected (runDetached routing). */
+  const notices: Array<{ scope: SessionId | undefined; level: 'info' | 'error'; text: string }> = []
+  ctx.provide('conversation', {
+    input: {
+      for: (actx: Context) => ({
+        notify: (level: 'info' | 'error', text: string) => {
+          notices.push({ scope: scopeOf(actx), level, text })
+        },
+      }),
+    },
+  })
+  const fiber = ctx.plugin(CommandService)
+  await fiber.await()
+  const command = ctx.get('command') as CommandService
+  const source = registered.get('/ command')
+  if (source === undefined) throw new Error('command source not registered')
+  const mint = (key: string) => {
+    const handle = createScope(ctx, sid(key))
+    scopes.set(sid(key), handle)
+    return handle
+  }
+  /** Warm one session's catalog through the source's own candidate pull. */
+  const warm = async (session: ClientSessionContext) => {
+    await source.candidates(session, { query: '', position: 'leading', signal: new AbortController().signal })
+  }
+  return { ctx, fiber, command, source, mint, warm, listCalls, executeCalls, registered, notices }
+}
+
+function menuPick(source: SlashSource, name: string, session: ClientSessionContext, end?: number) {
+  const pick: SlashPick = {
+    candidate: { name },
+    session,
+    position: 'leading',
+    via: 'menu',
+    span: { start: 0, end: end ?? name.length + 1, draftRev: 3 },
+  }
+  return source.onPick(pick)
+}
+
+const themeUi = (over: Partial<CommandUiSpec> = {}): CommandUiSpec => ({
+  kind: 'popupSelect',
+  options: () => Promise.resolve([{ id: 'dark', label: 'Dark' }]),
+  onSelect: () => undefined,
+  ...over,
+})
+
+const themeContribution = (over: Partial<CommandContribution> = {}): CommandContribution => ({
+  name: 'theme',
+  description: 'client popup kind',
+  available: () => true,
+  ui: themeUi(),
+  ...over,
+})
+
+const req = (query: string, position: 'leading' | 'inline' = 'leading') =>
+  ({ query, position, signal: new AbortController().signal })
+
+describe('registration', () => {
+  it('registers the "/" source with matchSpace/matchEnter/warm hooks and removes it on fiber disposal', async () => {
+    const { registered, source, fiber } = await bench()
+    expect(typeof source.matchSpace).toBe('function')
+    expect(typeof source.matchEnter).toBe('function')
+    expect(typeof source.warm).toBe('function')
+    expect([...registered.keys()]).toEqual(['/ command'])
+    await fiber.dispose()
+    expect(registered.size).toBe(0)
+  })
+
+  it('the warm hook prewarms the session key: one pull per session, no duplicate over pending', async () => {
+    const { source, listCalls } = await bench()
+    source.warm!(proj('s1'))
+    expect(listCalls).toEqual([{ sessionId: sid('s1') }])
+    source.warm!(proj('s2'))
+    expect(listCalls).toEqual([{ sessionId: sid('s1') }, { sessionId: sid('s2') }])
+    source.warm!(proj('s1')) // s1 already pending → no duplicate pull
+    expect(listCalls).toHaveLength(2)
+  })
+})
+
+describe('candidates', () => {
+  it('pulls the session catalog; prefix filter and hint mapping apply', async () => {
+    const { source, listCalls } = await bench()
+    const list = await source.candidates(proj('s1'), req('g'))
+    expect(listCalls).toEqual([{ sessionId: sid('s1') }])
+    expect(list).toEqual([{ name: 'goal', description: 'leadingInput kind', hint: 'goal text' }])
+  })
+
+  it('catalogs are per session: another session pulls its own key', async () => {
+    const { source, listCalls } = await bench()
+    const names = (await source.candidates(proj('s2'), req(''))).map(c => c.name)
+    expect(listCalls).toEqual([{ sessionId: sid('s2') }])
+    expect(names).toEqual(['plan', 'goal', 'attach'])
+  })
+
+  it('hides leadingInput commands at inline position', async () => {
+    const { source } = await bench()
+    const names = (await source.candidates(proj('s1'), req('', 'inline'))).map(c => c.name)
+    expect(names).toEqual(['plan'])
+  })
+
+  it('merges available contributions and filters unavailable ones with the per-call projection', async () => {
+    const { command, source } = await bench()
+    const available = vi.fn((session: ClientSessionContext) => session.sessionId === sid('s1'))
+    command.register(themeContribution({ available }))
+    const s1Names = (await source.candidates(proj('s1'), req(''))).map(c => c.name)
+    expect(s1Names).toEqual(['plan', 'goal', 'theme'])
+    expect(available).toHaveBeenLastCalledWith(proj('s1'))
+    const s2Names = (await source.candidates(proj('s2'), req(''))).map(c => c.name)
+    expect(s2Names).not.toContain('theme')
+  })
+
+  it('contribution rows ride the same query prefix filter', async () => {
+    const { command, source } = await bench()
+    command.register(themeContribution())
+    const names = (await source.candidates(proj('s1'), req('th'))).map(c => c.name)
+    expect(names).toEqual(['theme'])
+  })
+
+  it('a contribution/host name collision fails loud', async () => {
+    const { command, source } = await bench()
+    command.register(themeContribution({ name: 'plan' }))
+    await expect(source.candidates(proj('s1'), req(''))).rejects.toThrow('collides with a host command')
+  })
+})
+
+describe('dispatch (menu column)', () => {
+  it('contribution → opens the session popup with the open-time projection, no execute', async () => {
+    const { command, source, mint, warm, executeCalls } = await bench()
+    const options = vi.fn((_s: ClientSessionContext) => Promise.resolve([{ id: 'dark', label: 'Dark' }]))
+    command.register(themeContribution({ ui: themeUi({ options }) }))
+    const scope = mint('s1')
+    await warm(proj('s1'))
+    expect(menuPick(source, 'theme', proj('s1'))).toBe('handled')
+    const popup = command.popupFor(scope.ctx)
+    expect(popup.state.getSnapshot()).toMatchObject({ open: true, command: 'theme' })
+    expect(options).toHaveBeenCalledExactlyOnceWith(proj('s1'), expect.any(AbortSignal))
+    expect(executeCalls).toEqual([])
+  })
+
+  it('an unavailable contribution falls through to the host catalog', async () => {
+    const { command, source, mint, warm } = await bench()
+    command.register(themeContribution({ available: () => false }))
+    const scope = mint('s1')
+    await warm(proj('s1'))
+    expect(menuPick(source, 'theme', proj('s1'))).toBeUndefined() // no host 'theme' either
+    expect(command.popupFor(scope.ctx).state.getSnapshot().open).toBe(false)
+  })
+
+  it('host leadingInput → {claim} with token "/name " and hint; claiming never executes', async () => {
+    const { source, warm, executeCalls } = await bench()
+    await warm(proj('s1'))
+    const outcome = menuPick(source, 'goal', proj('s1'))
+    if (outcome === undefined || outcome === 'handled' || !('claim' in outcome)) throw new Error('expected claim')
+    expect(outcome.claim.token).toBe('/goal ')
+    expect(outcome.claim.hint).toBe('goal text')
+    expect(executeCalls).toEqual([])
+  })
+
+  it('host bare → consume-token span guard on the session scope + detached execute', async () => {
+    const { source, mint, warm, executeCalls } = await bench()
+    const scope = mint('s1')
+    const consumes: ConsumeTokenRequest[] = []
+    scope.ctx.on('slash/input-consume-token', (r) => {
+      consumes.push(r)
+      return true
+    })
+    await warm(proj('s1'))
+    expect(menuPick(source, 'plan', proj('s1'), 5)).toBe('handled')
+    expect(consumes).toEqual([{ guard: { kind: 'span', span: { start: 0, end: 5, draftRev: 3 } } }])
+    await Promise.resolve()
+    expect(executeCalls).toEqual([{ sessionId: sid('s1'), line: '/plan' }])
+  })
+
+  it('a name the directory no longer serves → undefined (snapshot swapped between menu and pick)', async () => {
+    const { source, warm } = await bench()
+    await warm(proj('s1'))
+    expect(menuPick(source, 'gone', proj('s1'))).toBeUndefined()
+  })
+})
+
+describe('matchSpace (space column)', () => {
+  it('answers undefined from a not-ready key (no waiting, no RPC)', async () => {
+    const { source, listCalls } = await bench()
+    expect(source.matchSpace!(proj('s1'), '/goal')).toBeUndefined()
+    expect(listCalls).toEqual([])
+  })
+
+  it('hot leadingInput exact token → {claim}; the key axis is the session', async () => {
+    const { source, warm } = await bench()
+    await warm(proj('s2'))
+    const outcome = source.matchSpace!(proj('s2'), '/attach')
+    if (outcome === undefined || outcome === 'handled' || !('claim' in outcome)) throw new Error('expected claim')
+    expect(outcome.claim.token).toBe('/attach ')
+    // s1's key is still cold: the same token answers undefined there.
+    expect(source.matchSpace!(proj('s1'), '/attach')).toBeUndefined()
+  })
+
+  it('bare kind and contribution names stay plain text', async () => {
+    const { command, source, warm } = await bench()
+    command.register(themeContribution())
+    await warm(proj('s1'))
+    expect(source.matchSpace!(proj('s1'), '/plan')).toBeUndefined()
+    expect(source.matchSpace!(proj('s1'), '/theme')).toBeUndefined()
+  })
+
+  it('unknown token / non-slash token → undefined', async () => {
+    const { source, warm } = await bench()
+    await warm(proj('s1'))
+    expect(source.matchSpace!(proj('s1'), '/nope')).toBeUndefined()
+    expect(source.matchSpace!(proj('s1'), 'plan')).toBeUndefined()
+  })
+})
+
+describe('matchEnter (enter column)', () => {
+  const signal = () => new AbortController().signal
+
+  it('strong-waits a cold key before adjudicating', async () => {
+    let release!: (value: { commands: CommandDescriptor[] }) => void
+    const { source } = await bench({
+      commands: () => new Promise((resolve) => { release = resolve }),
+    })
+    const wait = source.matchEnter!(proj('s1'), '/goal args', signal())
+    release({ commands: S1_CMDS })
+    const outcome = await wait
+    if (outcome === undefined || outcome === 'handled' || !('claim' in outcome)) throw new Error('expected claim')
+    expect(outcome.claim.token).toBe('/goal ')
+  })
+
+  it('rejects when warmup fails (never a silent downgrade)', async () => {
+    const { source } = await bench({
+      commands: () => Promise.reject(new Error('warmup boom')),
+    })
+    await expect(source.matchEnter!(proj('s1'), '/goal', signal())).rejects.toThrow('warmup boom')
+  })
+
+  it('leadingInput claims args-tolerant (bare and with trailing text)', async () => {
+    const { source, warm } = await bench()
+    await warm(proj('s1'))
+    for (const line of ['/goal', '/goal refactor the loop']) {
+      const outcome = await source.matchEnter!(proj('s1'), line, signal())
+      if (outcome === undefined || outcome === 'handled' || !('claim' in outcome)) throw new Error('expected claim')
+      expect(outcome.claim.token).toBe('/goal ')
+    }
+  })
+
+  it('bare host command executes detached with the bare-token consume guard', async () => {
+    const { source, mint, warm, executeCalls } = await bench()
+    const scope = mint('s1')
+    const consumes: ConsumeTokenRequest[] = []
+    scope.ctx.on('slash/input-consume-token', (r) => {
+      consumes.push(r)
+      return true
+    })
+    await warm(proj('s1'))
+    await expect(source.matchEnter!(proj('s1'), '/plan', signal())).resolves.toBe('handled')
+    expect(consumes).toEqual([{ guard: { kind: 'bare-token', token: '/plan' } }])
+    await Promise.resolve()
+    expect(executeCalls).toEqual([{ sessionId: sid('s1'), line: '/plan' }])
+  })
+
+  it('bare kind with trailing text → undefined and no RPC (default sink owns the line)', async () => {
+    const { source, warm, executeCalls } = await bench()
+    await warm(proj('s1'))
+    await expect(source.matchEnter!(proj('s1'), '/plan now', signal())).resolves.toBeUndefined()
+    expect(executeCalls).toEqual([])
+  })
+
+  it('contribution: bare token opens the popup without touching the directory; args → undefined', async () => {
+    const { command, source, mint, listCalls } = await bench()
+    command.register(themeContribution())
+    const scope = mint('s1')
+    await expect(source.matchEnter!(proj('s1'), '/theme', signal())).resolves.toBe('handled')
+    expect(command.popupFor(scope.ctx).state.getSnapshot().open).toBe(true)
+    expect(listCalls).toEqual([]) // contribution short-circuits ahead of ensureReady
+    await expect(source.matchEnter!(proj('s1'), '/theme dark', signal())).resolves.toBeUndefined()
+  })
+
+  it('unknown name, bare "/", and non-slash lines → undefined', async () => {
+    const { source, warm } = await bench()
+    await warm(proj('s1'))
+    await expect(source.matchEnter!(proj('s1'), '/nope', signal())).resolves.toBeUndefined()
+    await expect(source.matchEnter!(proj('s1'), '/', signal())).resolves.toBeUndefined()
+    await expect(source.matchEnter!(proj('s1'), 'plain text', signal())).resolves.toBeUndefined()
+  })
+})
+
+describe('execute payload', () => {
+  it('claim.submit addresses the session and maps the detached result', async () => {
+    const { source, warm, executeCalls } = await bench({
+      execute: () => Promise.resolve({ matched: true, result: { kind: 'success', text: 'goal set' } }),
+    })
+    await warm(proj('s1'))
+    const outcome = source.matchSpace!(proj('s1'), '/goal')
+    if (outcome === undefined || outcome === 'handled' || !('claim' in outcome)) throw new Error('expected claim')
+    const settled = await outcome.claim.submit('ship it', new Context())
+    expect(executeCalls).toEqual([{ sessionId: sid('s1'), line: '/goal ship it' }])
+    expect(settled).toEqual({ kind: 'success', text: 'goal set' })
+  })
+
+  it('maps matched:false to an error outcome and a matched bare result to success', async () => {
+    const claimOf = async (opts: BenchOptions) => {
+      const b = await bench(opts)
+      await b.warm(proj('s1'))
+      const outcome = b.source.matchSpace!(proj('s1'), '/goal')
+      if (outcome === undefined || outcome === 'handled' || !('claim' in outcome)) throw new Error('expected claim')
+      return outcome.claim
+    }
+    const first = await claimOf({ execute: () => Promise.resolve({ matched: false }) })
+    const bad = await first.submit('x', new Context())
+    expect(bad.kind).toBe('error')
+    const second = await claimOf({ execute: () => Promise.resolve({ matched: true }) })
+    await expect(second.submit('', new Context())).resolves.toEqual({ kind: 'success' })
+  })
+})
+
+describe('detached result notices', () => {
+  const flush = () => new Promise(resolve => setTimeout(resolve, 0))
+
+  it('success text → info; error result → error; rejection → error, all on the triggering session', async () => {
+    let mode: 'info' | 'error' | 'reject' = 'info'
+    const { source, mint, warm, notices } = await bench({
+      execute: () => {
+        if (mode === 'reject') return Promise.reject(new Error('network down'))
+        return Promise.resolve({
+          matched: true,
+          result: mode === 'info'
+            ? { kind: 'success' as const, text: 'compacted 12 messages' }
+            : { kind: 'error' as const, text: 'plan mode refused' },
+        })
+      },
+    })
+    mint('s1')
+    await warm(proj('s1'))
+    menuPick(source, 'plan', proj('s1'))
+    await flush()
+    expect(notices).toEqual([{ scope: sid('s1'), level: 'info', text: 'compacted 12 messages' }])
+
+    notices.length = 0
+    mode = 'error'
+    await source.matchEnter!(proj('s1'), '/plan', new AbortController().signal)
+    await flush()
+    expect(notices).toEqual([{ scope: sid('s1'), level: 'error', text: 'plan mode refused' }])
+
+    notices.length = 0
+    mode = 'reject'
+    menuPick(source, 'plan', proj('s1'))
+    await flush()
+    expect(notices).toEqual([{ scope: sid('s1'), level: 'error', text: 'network down' }])
+  })
+
+  it('success without text stays silent; a torn-down scope drops the notice', async () => {
+    const { source, warm, notices } = await bench({
+      execute: () => Promise.resolve({ matched: true, result: { kind: 'success' as const, text: 'orphan' } }),
+    })
+    await warm(proj('ghost')) // never minted: scopeFor misses
+    menuPick(source, 'plan', proj('ghost'))
+    await flush()
+    expect(notices).toEqual([])
+  })
+})
+
+describe('register (contribution face)', () => {
+  it('duplicate registration throws; the disposer frees the name', async () => {
+    const { command } = await bench()
+    const dispose = command.register(themeContribution())
+    expect(() => command.register(themeContribution())).toThrow('duplicate contribution')
+    dispose()
+    command.register(themeContribution())()
+  })
+})
+
+describe('popupFor', () => {
+  it('resolves lazily per session; a foreign session gets its own controller; unscoped ctx throws', async () => {
+    const { ctx, command, mint } = await bench()
+    const a = mint('s1')
+    const first = command.popupFor(a.ctx)
+    expect(command.popupFor(a.ctx)).toBe(first)
+    expect(command.popupFor(mint('s2').ctx)).not.toBe(first)
+    expect(() => command.popupFor(ctx)).toThrow('requires a session scope')
+  })
+
+  it('a successful select dispatches the scoped consume-token and fires the bound composer focus', async () => {
+    const { command, source, mint } = await bench()
+    const onSelect = vi.fn()
+    command.register(themeContribution({ ui: themeUi({ onSelect }) }))
+    const scope = mint('s1')
+    const consumes: ConsumeTokenRequest[] = []
+    scope.ctx.on('slash/input-consume-token', (r) => {
+      consumes.push(r)
+      return true
+    })
+    const focus = vi.fn()
+    command.bindComposerFocus(sid('s1'), focus)
+
+    expect(menuPick(source, 'theme', proj('s1'), 6)).toBe('handled')
+    const popup = command.popupFor(scope.ctx)
+    await Promise.resolve() // options land
+    await popup.select(0)
+    expect(onSelect).toHaveBeenCalledExactlyOnceWith({ id: 'dark', label: 'Dark' } satisfies SelectOption, proj('s1'))
+    expect(consumes).toEqual([{ guard: { kind: 'span', span: { start: 0, end: 6, draftRev: 3 } } }])
+    expect(focus).toHaveBeenCalledTimes(1)
+  })
+
+  it('the enter path opens with the bare-token guard', async () => {
+    const { command, source, mint } = await bench()
+    command.register(themeContribution())
+    const scope = mint('s1')
+    const consumes: ConsumeTokenRequest[] = []
+    scope.ctx.on('slash/input-consume-token', (r) => {
+      consumes.push(r)
+      return true
+    })
+    await source.matchEnter!(proj('s1'), '/theme', new AbortController().signal)
+    const popup = command.popupFor(scope.ctx)
+    await Promise.resolve()
+    await popup.select(0)
+    expect(consumes).toEqual([{ guard: { kind: 'bare-token', token: '/theme' } }])
+  })
+
+  it('the scope disposer disposes the controller and a re-mint resolves fresh', async () => {
+    const { command, source, mint } = await bench()
+    command.register(themeContribution())
+    const scope = mint('s1')
+    await source.matchEnter!(proj('s1'), '/theme', new AbortController().signal)
+    const popup = command.popupFor(scope.ctx)
+    expect(popup.state.getSnapshot().open).toBe(true)
+
+    await scope.fiber.dispose()
+    expect(popup.state.getSnapshot().open).toBe(false)
+    expect(command.popupFor(mint('s1').ctx)).not.toBe(popup)
+  })
+})
+
+describe('directory invalidation events', () => {
+  it('commands/changed repulls in the background while the old snapshot serves', async () => {
+    let round = 0
+    const { ctx, source, warm } = await bench({
+      commands: () => {
+        round += 1
+        return Promise.resolve({
+          commands: round === 1
+            ? S1_CMDS
+            : [{ name: 'fresh', description: '', input: { hint: 'h' } }],
+        })
+      },
+    })
+    await warm(proj('s1'))
+    ctx.emit('commands/changed')
+    await new Promise(resolve => setTimeout(resolve, 0))
+    expect(source.matchSpace!(proj('s1'), '/fresh')).not.toBeUndefined()
+    expect(source.matchSpace!(proj('s1'), '/goal')).toBeUndefined()
+  })
+
+  it('connection/reset hard-drops every session key until its rewarm lands', async () => {
+    let block = false
+    let release!: (value: { commands: CommandDescriptor[] }) => void
+    const { ctx, source, warm } = await bench({
+      commands: () => (block
+        ? new Promise((resolve) => { release = resolve })
+        : Promise.resolve({ commands: S2_CMDS })),
+    })
+    await warm(proj('s2'))
+    expect(source.matchSpace!(proj('s2'), '/attach')).not.toBeUndefined()
+    block = true
+    ctx.emit('connection/reset')
+    // Hard reset: silent until the rewarm lands.
+    expect(source.matchSpace!(proj('s2'), '/attach')).toBeUndefined()
+    release({ commands: S2_CMDS })
+    await new Promise(resolve => setTimeout(resolve, 0))
+    expect(source.matchSpace!(proj('s2'), '/attach')).not.toBeUndefined()
+  })
+})

packages/client/ui-command/tsconfig.json

@@ -0,0 +1,36 @@
+{
+  "extends": "../../../tsconfig.base.client.json",
+  "compilerOptions": {
+    "rootDir": "src",
+    "outDir": "lib/types"
+  },
+  "include": [
+    "src"
+  ],
+  "references": [
+    {
+      "path": "../../../vendor/cordis"
+    },
+    {
+      "path": "../connection"
+    },
+    {
+      "path": "../runtime"
+    },
+    {
+      "path": "../ui-conversation"
+    },
+    {
+      "path": "../ui-primitives"
+    },
+    {
+      "path": "../ui-slash"
+    },
+    {
+      "path": "../ui-slots"
+    },
+    {
+      "path": "../../support/invariants"
+    }
+  ]
+}

packages/client/ui-command/tsdown.config.ts

@@ -0,0 +1,3 @@
+import { clientBundle } from '../tsdown.client.ts'
+
+export default clientBundle('@deepseek-ai/dsh-client-ui-command', ['lib/types/index.js', 'lib/types/invariant.js'])

packages/client/ui-conversation/package.json

@@ -41,6 +41,7 @@
   "peerDependencies": {
     "@deepseek-ai/dsh-client-runtime": "^0.0.1",
     "@deepseek-ai/dsh-client-ui-primitives": "^0.0.1",
+    "@deepseek-ai/dsh-client-ui-slash": "^0.0.1",
     "@deepseek-ai/dsh-client-ui-slots": "^0.0.1",
     "@deepseek-ai/dsh-invariants": "^0.0.1",
     "cordis": "^4.0.0-rc.7",
@@ -50,6 +51,7 @@
     "@deepseek-ai/dsh-client-runtime": "workspace:^",
     "@deepseek-ai/dsh-client-ui-layout": "workspace:^",
     "@deepseek-ai/dsh-client-ui-primitives": "workspace:^",
+    "@deepseek-ai/dsh-client-ui-slash": "workspace:^",
     "@deepseek-ai/dsh-client-ui-slots": "workspace:^",
     "@deepseek-ai/dsh-invariants": "workspace:^",
     "@types/react": "~18.3.1",

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

@@ -5,15 +5,18 @@ import type { SessionId, SessionsService } from '@deepseek-ai/dsh-client-runtime
 import type {} from '@deepseek-ai/dsh-client-ui-layout/client'
 import type { ViewTab } from './contract/views.ts'
 import type {
-  ChatViewInjected, ConversationInjected, DetailsInjected, EmptyStateInjected,
+  ChatViewInjected, ComposerBarInjected, ConversationInjected, ConversationSessionInjected, DetailsInjected,
 } from './contract/slots.ts'
 import { createChatStore } from './stores.ts'
 import { ConversationService } from './service.ts'
+import { InputHub } from './input/hub.ts'
+import { InputBar } from './skeleton/InputBar.tsx'
 import { ChatView } from './chat/ChatView.tsx'
 import { bashToolviewSample } from './toolviews/bash-sample.tsx'
+import { queueDockEntry } from './queue/QueueDock.tsx'
 import { ConversationRoot } from './skeleton/ConversationRoot.tsx'
+import { ConversationSession } from './skeleton/ConversationSession.tsx'
 import { DetailsPanel } from './skeleton/DetailsPanel.tsx'
-import { EmptyState } from './skeleton/EmptyState.tsx'
 
 /** Services required by the conversation plugin. */
 export const inject = ['slots', 'layout', 'sessions', 'workspaces']
@@ -49,50 +52,100 @@ export function apply(ctx: Context): void {
     return tabs
   }
 
-  // Conversation occupant. Declaring the view ring here is claiming it:
-  // ConversationRoot is the only component authorized to render the ring.
+  // The per-session input machine registry (InputService face; published as
+  // ctx.conversation.input by the service below sharing this one instance).
+  const inputHub = new InputHub(ctx)
+
+  // Decision 19/20: the input machine feeds every session-scope slot
+  // component through the standard provide channel — the 'input' hook plus
+  // the two public actions. Materialization is the shell creation trigger
+  // (per-session lazy; scope disposer tears down).
+  ctx.effect(() => sessions.provide({
+    hooks: ['input'],
+    props: ['inputActions'],
+    resolve: (binding) => {
+      const shell = inputHub.shellFor(binding)
+      return {
+        hooks: { input: shell.state },
+        props: { inputActions: shell.actions },
+      }
+    },
+  }), 'ui-conversation: input standard-kit provider')
+
+  // Resident current-session-optional shell. It owns the stable Hero/composer
+  // frame while strict session slots fill only their session-bound regions.
   slots.register({
     name: 'conversation',
-    // The composer chain rides the same declaration table: takeover plugins
-    // register selector-routed replacements of the InputBar.
     children: {
-      'conversation.view': { kind: 'list', scope: 'session' },
+      'conversation.session': { kind: 'single', scope: 'session' },
       'conversation.composer': { kind: 'chain', scope: 'session' },
+      'conversation.composer.bar': { kind: 'single', scope: 'session' },
+      'conversation.input.overlay': { kind: 'list', scope: 'session' },
+      'conversation.input.dock': { kind: 'list', scope: 'session' },
+      'conversation.composer.dock': { kind: 'list', scope: 'session' },
+      'conversation.input.left': { kind: 'list', scope: 'session' },
+      'conversation.input.right': { kind: 'list', scope: 'session' },
+      'conversation.hero.workspace': { kind: 'single', scope: 'root' },
     },
+    inject: (sessionId: SessionId | undefined): ConversationInjected => ({
+      selectWorkspace: (workspaceId) => {
+        void workspaces.connectWorkspace(workspaceId).then((nextId) => {
+          if (sessionId !== undefined && nextId !== sessionId) {
+            const from = inputHub.shell(sessionId)
+            const draft = from.snapshot.draft
+            if (draft !== '') {
+              inputHub.shell(nextId).setDraft(draft)
+              from.setDraft('')
+            }
+          }
+          sessions.open(nextId)
+        }).catch(() => {
+          // Failure leaves the current Hero state available to retry.
+        })
+      },
+    }),
+  }, ConversationRoot)
+
+  // The strict session subtree owns only per-session store and view content;
+  // the resident parent keeps Hero and composer layout identity stable.
+  slots.register({
+    name: 'conversation.session',
+    children: { 'conversation.view': { kind: 'list', scope: 'session' } },
     store: chatStore,
-    inject: (sessionId: SessionId, actions: BoundActions<typeof chatStore>): ConversationInjected => {
-      // History pull is NOT triggered here: the runtime sessions service opens
-      // the event window when the watch lands on the session (cell/binding
-      // resolution) — an inject factory assembles callbacks, it has no side
-      // effect on session state.
-      const scoped = scopedConversation(sessions, sessionId)
+    inject: (sessionId: SessionId, _actions: BoundActions<typeof chatStore>): ConversationSessionInjected => ({
+      views: {
+        list: viewTabs,
+        subscribe: fn => slots.subscribe('conversation.view', fn),
+        version: () => slots.getVersion('conversation.view'),
+      },
+      bindDraftMirror: write => inputHub.shell(sessionId).bindMirror(write),
+      open: (id) => { sessions.open(id) },
+    }),
+  }, ConversationSession)
+
+  // The default composer body: its own single slot inside the composer
+  // chain's fallback (decision 20). Public machine surface arrives via the
+  // provide channel above; the keyboard command face and the stop/retry
+  // 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).
+    children: {
+      'conversation.input.plan': { kind: 'single', scope: 'session' },
+      'conversation.input.model': { kind: 'single', scope: 'session' },
+    },
+    inject: (sessionId: SessionId): ComposerBarInjected => {
       return {
-        views: {
-          list: viewTabs,
-          subscribe: fn => slots.subscribe('conversation.view', fn),
-          version: () => slots.getVersion('conversation.view'),
-        },
-        send: (text, mode) => {
-          const trimmed = text.trim()
-          if (trimmed === '') return
-          // Optimistic clear with failure restore (choreography lives with the
-          // sender; the business failure also lands in snapshot.promptError).
-          // The store write path stays inside the declared actions set:
-          // restoreDraft itself no-ops once the user typed something new.
-          actions.clearDraft()
-          void scoped.send(trimmed, mode).catch(() => { actions.restoreDraft(trimmed) })
-        },
+        keyboard: inputHub.keyboard(sessionId),
         stop: () => {
-          scoped.cancel().catch(() => {
+          scopedConversation(sessions, sessionId).cancel().catch(() => {
             // Stop failure surfaces via snapshot.promptError; nothing to restore.
           })
         },
-        open: (sessionId) => { sessions.open(sessionId) },
-        updateSessionPrompt: (text) => { scoped.updatePendingPrompt(text) },
-        retrySessionPrompt: () => { scoped.retryPendingPrompt() },
       }
     },
-  }, ConversationRoot)
+  }, InputBar)
 
   // The chat view: first entry of the ring this package just declared.
   // Declaring the keyed toolview hole here is claiming it: ChatView is the
@@ -124,11 +177,15 @@ export function apply(ctx: Context): void {
   // toolview registrants using `inject: ['conversation']` as their load-order
   // seam: the service being present implies the chat entry (and with it the
   // 'conversation.chat.toolview' declaration) is on the ledger.
-  ctx.plugin(ConversationService)
+  ctx.plugin(ConversationService, { input: inputHub })
 
   // The bash sample rides that exact seam, in third-party posture.
   ctx.plugin(bashToolviewSample)
 
+  // The read-only queue dock entry (T9 file territory) rides the same
+  // registration seam into the input dock declared above.
+  ctx.plugin(queueDockEntry)
+
   slots.register({
     name: 'details',
     store: chatStore,
@@ -137,13 +194,4 @@ export function apply(ctx: Context): void {
     }),
   }, DetailsPanel)
 
-  slots.register({
-    name: 'conversation.empty',
-    children: { 'conversation.empty.workspace': { kind: 'single', scope: 'root' } },
-    inject: (): EmptyStateInjected => ({
-      startSession: (workspaceId, prompt) => { workspaces.startSession(workspaceId, prompt) },
-      updateSessionPrompt: (text) => { sessions.updateIntent(text) },
-      sendSession: () => { workspaces.sendSession() },
-    }),
-  }, EmptyState)
 }

packages/client/ui-conversation/src/client/chat/MessageItem.module.css

@@ -32,3 +32,18 @@
 .contextRow {
   padding: 2px 0;
 }
+
+/* Reference chip projection inside a user bubble (`<skill>name</skill>` model
+   spans render as chips; free geometry — no textarea pairing here). */
+.refChip {
+  display: inline-block;
+  margin: 0 2px;
+  padding: 0 8px;
+  border-radius: 6px;
+  background: rgba(97, 135, 216, 0.22);
+  color: var(--dsw-alias-label-primary);
+  font-size: 0.85em;
+  line-height: 1.6;
+  white-space: nowrap;
+  vertical-align: baseline;
+}

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

@@ -4,6 +4,7 @@
 // streaming because unchanged nodes keep their references.
 
 import { memo } from 'react'
+import type { ReactNode } from 'react'
 import type {
   ContextMessageNode, SteeringMessageNode, UnknownSurfaceNode, UserMessageNode,
 } from '@deepseek-ai/dsh-client-runtime/client'
@@ -25,6 +26,38 @@ function contentText(content: readonly unknown[]): { text: string; rest: unknown
   return { text: texts.join(''), rest }
 }
 
+/**
+ * Display projection of reference forms in a user bubble (free geometry — no
+ * textarea alignment constraint here); everything else stays plain text. The
+ * logged model text remains the single truth; this is presentation only. Two
+ * shapes decorate: legacy `<skill>name</skill>` spans (pre-decision-21
+ * history) and plain-text `/name` / `@name` word-boundary tokens (decision
+ * 21: the sent text IS the reference — the bubble uses the same plainest
+ * token scan as the composer, minus the lexicon: sent tokens were validated
+ * at compose time, so shape alone decorates).
+ */
+function projectUserText(text: string): ReactNode {
+  const re = /<skill>([^<]+)<\/skill>|(^|\s)([/@][\w-]+)(?=\s|$)/g
+  const parts: ReactNode[] = []
+  let cursor = 0
+  let m: RegExpExecArray | null
+  while ((m = re.exec(text)) !== null) {
+    const legacy = m[1] !== undefined
+    const tokenStart = legacy ? m.index : m.index + (m[2]?.length ?? 0)
+    const label = legacy ? `/${m[1]}` : m[3] ?? ''
+    if (tokenStart > cursor) parts.push(<MessageText key={cursor} text={text.slice(cursor, tokenStart)} />)
+    parts.push(
+      <span key={tokenStart} className={css.refChip} data-ref-chip={label.startsWith('@') ? 'subagent' : 'skill'}>
+        {label}
+      </span>,
+    )
+    cursor = legacy ? m.index + m[0].length : tokenStart + label.length
+  }
+  if (parts.length === 0) return <MessageText text={text} />
+  if (cursor < text.length) parts.push(<MessageText key={cursor} text={text.slice(cursor)} />)
+  return <>{parts}</>
+}
+
 export const MessageItem = memo(function MessageItem({ node }: MessageItemProps) {
   switch (node.kind) {
     case 'user':
@@ -34,7 +67,7 @@ export const MessageItem = memo(function MessageItem({ node }: MessageItemProps)
         <div className={css.userRow}>
           <div className={css.bubble}>
             {node.kind === 'steering' && <span className={css.badge}>插话</span>}
-            <MessageText text={text} />
+            {projectUserText(text)}
             {rest.map((block, i) => <JsonBlock key={i} label="附加内容块" payload={block} />)}
           </div>
         </div>

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

@@ -1,12 +1,22 @@
 /** 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, WorkspaceId } from '@deepseek-ai/dsh-client-runtime/client'
+import type { ReactNode, RefObject } from 'react'
+import type {
+  MaybeSnapshotSelectorHook, PropsRenderSlots, PropsRuntime, PropsStore, SnapshotSelectorHook,
+} from '@deepseek-ai/dsh-client-ui-slots'
+import type { ConversationSnapshot, PendingInteraction, SessionId, ToolCallBlock, WorkspaceId } from '@deepseek-ai/dsh-client-runtime/client'
+import type {} from '@deepseek-ai/dsh-client-ui-layout/client'
+import type { ComposerKeyboard, InputActions, InputState } from '../input/contract.ts'
 import type { createChatStore } from '../stores.ts'
 import type { CallId, SelectionTarget, ViewTab } from './views.ts'
 
 declare module '@deepseek-ai/dsh-client-ui-slots' {
   interface SlotMap {
+    /**
+     * Strict-session content inside the resident conversation shell. This
+     * subtree owns the per-session chat store, header, and view ring and is
+     * remounted when the current session id changes.
+     */
+    'conversation.session': { kind: 'single'; scope: 'session'; owner: ConversationSessionOwnerProps }
     /**
      * The conversation view ring: one list entry per view tab (chat here;
      * trajectory/waterfall from ui-trajectory), rendered one-at-a-time by
@@ -31,9 +41,83 @@ 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 }
+    /**
+     * The hero-phase Workspace picker hole: rendered by ConversationRoot
+     * while the session is blank (picking another workspace switches to that
+     * workspace's blank session, draft carried). Root scope: the picker
+     * reads the global workspace list.
+     */
+    'conversation.hero.workspace': { kind: 'single'; scope: 'root'; owner: EmptyWorkspaceOwnerProps }
+    // 'conversation.input.overlay' merges in ui-slash (dedup ruling: the
+    // dependency direction is the hard constraint — ui-slash cannot import
+    // this package, while this package's input contract already imports
+    // ui-slash, so the type arrives transitively). The runtime declaration
+    // (children table in apply.ts) stays here with the other input slots.
+    /**
+     * Stacked strip above the input (queue rows / GoalBar / attachments;
+     * design §6 MIX evidence: entries coexist in fixed order).
+     */
+    'conversation.input.dock': { kind: 'list'; scope: 'session'; owner: InputZone }
+    /** The composer top-edge band (stats line family). */
+    'conversation.composer.dock': { kind: 'list'; scope: 'session'; owner: InputZone }
+    /** Tool-row left region inside the input card (existing chrome stays in place beside entries). */
+    'conversation.input.left': { kind: 'list'; scope: 'session'; owner: InputZone }
+    /** Tool-row right region inside the input card. */
+    'conversation.input.right': { kind: 'list'; scope: 'session'; owner: InputZone }
+    /**
+     * The default composer body: a single slot rendered as the composer
+     * chain's fallback (decision 20 — a real entry, not a chain rider, so a
+     * takeover election hides rather than unmounts it and the textarea DOM
+     * survives). InputBar registers here from this package's apply; its
+     * machine state arrives through the standard provide channel (useInput +
+     * inputActions), the keyboard command face through its own inject.
+     */
+    '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).
+     */
+    'conversation.input.plan': { kind: 'single'; scope: 'session'; owner: InputControlOwnerProps }
+    /**
+     * The model-select seat in the composer tool row (right group). Same
+     * empty-until-registered contract as the plan seat.
+     */
+    'conversation.input.model': { kind: 'single'; scope: 'session'; owner: InputControlOwnerProps }
   }
+
+  /**
+   * ui-conversation's members of the session standard kit, provided through
+   * `sessions.provide` (decision 19/20): every session-scope slot component
+   * receives the input machine's state hook and the two public actions.
+   */
+  interface SessionStandardProps {
+    /** Selector hook over the session's live input machine state. */
+    useInput: SnapshotSelectorHook<InputState>
+    /** The public input action face (stable identity per session). */
+    inputActions: InputActions
+  }
+
+  /** Input members for the resident composer while current session is optional. */
+  interface SessionMaybeStandardProps {
+    useInput: MaybeSnapshotSelectorHook<InputState>
+    inputActions: InputActions | undefined
+  }
+}
+
+/** Owner share of the strict session content seat. */
+export interface ConversationSessionOwnerProps {
+}
+
+/**
+ * The input-region slot currency (plan §1.4): dock/left/right entries read
+ * the conversation snapshot and the live input state as owner props (both
+ * are point-in-time snapshots — the dispatching skeleton re-renders on
+ * either store's change, so entries stay current without subscribing).
+ */
+export interface InputZone {
+  readonly session: ConversationSnapshot
+  readonly input: InputState
 }
 
 /**
@@ -87,24 +171,72 @@ export type ChatStore = ReturnType<typeof createChatStore>
 
 /** Business callbacks injected into the conversation slot. */
 export interface ConversationInjected {
+  /**
+   * Connect the selected Workspace and open its reusable/new blank session.
+   * When a blank session is already current, carry its draft to the target.
+   */
+  selectWorkspace(workspaceId: WorkspaceId): void
+}
+
+/** Business callbacks injected into the strict session content seat. */
+export interface ConversationSessionInjected {
   /** Views projected from the `conversation.view` slot ledger. */
   views: {
     list(): readonly ViewTab[]
     subscribe(fn: () => void): () => void
     version(): number
   }
-  /** Send choreography: trims, clears the draft optimistically, restores it on failure. */
-  send(text: string, mode: 'queue' | 'steer'): void
-  /** Cancel the in-flight turn (failure surfaces via snapshot.promptError). */
-  stop(): void
+  /** Bind the input machine's draft persistence mirror to the session store. */
+  bindDraftMirror(write: (text: string) => void): () => 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
 }
 
+/**
+ * Owner share of the composer-bar slot: ConversationRoot's layout-phase
+ * inputs plus the input-region child-slot content it renders (the region
+ * slots stay declared/rendered by the conversation entry; the bar hosts the
+ * results as chrome).
+ */
+export interface ComposerBarOwnerProps {
+  /** Hero = empty-state centered card; composer = resident bottom bar. */
+  variant: 'hero' | 'composer'
+  placeholder?: string
+  /** Optional content rendered above the textarea. */
+  accessory?: ReactNode
+  /** Floating overlay anchor content (menu / popup shell entries), rendered inside the card. */
+  overlay?: ReactNode
+  /** input.left slot entries (tool row, beside the resident chrome). */
+  leftItems?: ReactNode
+  /** input.right slot entries (tool row, before the primary button). */
+  rightItems?: ReactNode
+  onAdd?: () => void
+  addLabel?: string
+}
+
+/** Injected share of the composer-bar entry (package-internal faces). */
+export interface ComposerBarInjected {
+  /** The InputBar-exclusive keyboard/DOM command face (decision 20 private plane). */
+  keyboard: ComposerKeyboard
+  /** Cancel the in-flight turn. */
+  stop(): void
+}
+
+/**
+ * Owner share of the two named composer control seats (plan / model): the
+ * bar passes its disable state; the filling entry owns everything else.
+ */
+export interface InputControlOwnerProps {
+  /** Session-removed lock (the bar's chrome disable state). */
+  locked: boolean
+}
+
+/** Full composer-bar component props: standard kit & owner share & control-seat render share & injected share. */
+export type ComposerBarProps =
+  PropsRuntime<'conversation.composer.bar'>
+  & PropsRenderSlots<'conversation.input.plan' | 'conversation.input.model'>
+  & ComposerBarInjected
+
 /**
  * Composer chain currency: what ConversationRoot dispatches at its
  * renderSlotChain site. The owner declares the currency only — never a
@@ -116,10 +248,26 @@ export interface ComposerChainProps {
   interactions: readonly PendingInteraction[]
 }
 
-/** Full conversation-slot component props: runtime & child-render (view ring + composer chain) & store & injected shares. */
+/**
+ * Full conversation-slot component props: runtime & child-render (view ring
+ * + composer chain/bar + input-region + hero picker slots) & store & injected shares.
+ */
 export type ConversationSlotProps =
-  PropsRuntime<'conversation'> & PropsRenderSlots<'conversation.view' | 'conversation.composer'>
-  & PropsStore<ChatStore> & ConversationInjected
+  PropsRuntime<'conversation'> & PropsRenderSlots<
+    | 'conversation.session' | 'conversation.composer' | 'conversation.composer.bar'
+    | 'conversation.input.overlay'
+    | 'conversation.input.dock' | 'conversation.composer.dock'
+    | 'conversation.input.left' | 'conversation.input.right'
+    | 'conversation.hero.workspace'
+  >
+  & ConversationInjected
+
+/** Full strict-session content props: per-session store, view ring, and callbacks. */
+export type ConversationSessionSlotProps =
+  PropsRuntime<'conversation.session'>
+  & PropsRenderSlots<'conversation.view'>
+  & PropsStore<ChatStore>
+  & ConversationSessionInjected
 
 /**
  * Injected share of the chat view entry: the two callbacks whose targets live
@@ -148,24 +296,10 @@ 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
 
-/** Owner share common to the empty hero's Workspace picker. */
+/** Owner share common to the hero / New-Session Workspace pickers. */
 export interface EmptyWorkspaceOwnerProps {
   open: boolean
   anchorRef?: RefObject<HTMLElement>
   onPick(workspaceId: WorkspaceId): void
   onClose(): void
 }
-
-/** 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

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

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

@@ -0,0 +1,269 @@
+/**
+ * Frozen input-machine contract (design §9.1, eng. plan §3.9-3.12). Types
+ * only. Three-tier visibility: business packages see InputState via the
+ * InputZone currency; the scoped input events carry the mutation verbs; the
+ * conversation wiring layer alone sees the full SessionInput. InputMachine
+ * (machine.ts) is package-private and never exported.
+ */
+import type { ClientContext, SnapshotStore } from '@deepseek-ai/dsh-client-runtime/client'
+import type {
+  ArbitrateKey, ArbitrateOutcome, CommandClaim, ConsumeTokenRequest, PickOutcome,
+  ReferenceInsert, SubmitOutcome, TokenSpan,
+} from '@deepseek-ai/dsh-client-ui-slash/client'
+
+/**
+ * The scoped-event application verbs: the hub's bail listeners call these,
+ * and the boolean answer IS the event's bail value (true ⟺ the machine
+ * accepted after phase and span/bare-token guards).
+ */
+export interface InputTarget {
+  /** Replace the trigger span with claim.token and enter claimed (span-CAS'd). */
+  beginCommand(claim: CommandClaim, span: TokenSpan): boolean
+  /** Replace the trigger span with one reference occurrence (span-CAS'd). */
+  insertReference(ref: ReferenceInsert, span: TokenSpan): boolean
+}
+
+/** Per-session input facade owned by the conversation wiring layer. */
+export interface SessionInput extends InputTarget {
+  /** Single write path for draft text (all mutation rides machine events). */
+  setDraft(text: string): void
+  /** THE complexity sink: enter adjudication, submit transaction, and the default sink live inside. */
+  submit(mode?: 'queue' | 'steer'): void
+  /**
+   * Surface a notice outside the machine's own effect stream: detached
+   * command results and business notifications render through here.
+   * Session-routed — resolving the facade via InputService.for(actx) lands
+   * the notice on that session's composer, so a result arriving after a
+   * session switch still reaches its own session.
+   * @param level - severity tier.
+   * @param text - notice body.
+   */
+  notify(level: 'info' | 'error', text: string): void
+  /** Input state store (InputZone currency + decorations read here). */
+  readonly state: SnapshotStore<InputState>
+}
+
+/** Session-addressed access to the per-session input facade. */
+export interface InputService {
+  /** Resolve the facade for one session-scope ctx. */
+  for(actx: ClientContext): SessionInput
+}
+
+/**
+ * The public input action face provided to every session-scope slot
+ * component (decision 20): two stable-identity void callbacks, mirroring the
+ * useStore+actions convention. Command-style handles (track/arbitrate/space/
+ * undo/paste/…) stay InputBar-private and never ride this face.
+ */
+export interface InputActions {
+  /** Single public draft write path (full next draft; occurrence math via diff scan). */
+  setDraft(text: string): void
+  /** Enter submission (adjudication / claim transaction / default sink inside). */
+  submit(mode?: 'queue' | 'steer'): void
+}
+
+/** One surfaced notice (command results, adjudication failures). seq keys re-render of repeats. */
+export interface InputNotice {
+  readonly level: 'info' | 'error'
+  readonly text: string
+  readonly seq: number
+}
+
+/**
+ * The InputBar-exclusive keyboard/DOM command face (decision 20): synchronous
+ * returns and event-handler semantics that must not enter the public provide
+ * channel. Handed to the composer-bar entry through its own inject —
+ * package-internal, never across a plugin boundary. The session shell
+ * satisfies it structurally.
+ */
+export interface ComposerKeyboard {
+  /** Latest surfaced notice store (null after none). */
+  readonly notices: SnapshotStore<InputNotice | null>
+  /** Live machine state for event-handler reads (render reads go through useInput). */
+  readonly snapshot: InputState
+  /** Draft write with the DOM-observed edit shape (narrows occurrence math). */
+  setDraft(text: string, editRange?: EditRange): void
+  /** Newline at the selection as a machine transaction (Ctrl+Enter path). */
+  newline(selection: EditSelection): void
+  undo(): void
+  redo(): void
+  /** Paste over the selection (sync components ride the same transaction). */
+  pasteBegin(text: string, selection: EditSelection, components?: readonly PasteComponent[], generation?: number): void
+  /** Caret/selection gestures the machine cannot observe end the paste attempt. */
+  invalidatePaste(): void
+  /** Feed a draft/caret change through trigger detection (guard derived from phase). */
+  track(draft: string, caret: number): void
+  /** Keyboard arbitration while the menu is open ('pass' when no pipeline). */
+  arbitrate(key: ArbitrateKey, composing: boolean): ArbitrateOutcome
+  /** Space adjudication; true = the input applied a claim — caller preventDefaults. */
+  space(): boolean
+  /** Dismiss the popupSelect shell (any interaction outside the box). */
+  dismissPopup(): void
+  /** Hot plain-text reference lexicons for the decoration scan (decision 21; empty Map without a pipeline). */
+  lexicon(): ReadonlyMap<'/' | '@', readonly string[]>
+}
+
+/** One queued-message row projected from the session/queued frames (T9 supplies the store). */
+export interface QueuedMessage {
+  /** Stable row key: the enqueueing prompt's rpcId. */
+  readonly key: string
+  readonly preview: string
+}
+
+/** Guard union of the scoped consume-token event, checked by the machine. */
+export type ConsumeTokenGuard = ConsumeTokenRequest['guard']
+
+/** Half-open [start, end) range/selection in draft character coordinates. */
+export interface EditSelection {
+  readonly start: number
+  readonly end: number
+}
+
+/**
+ * One edit applied to the previous draft: [start, end) in the PREVIOUS
+ * draft's coordinates was replaced by insertedLength characters. Supplied by
+ * the wiring layer when the DOM event exposes the edit shape; absent, the
+ * machine recovers it with a prefix/suffix common-scan diff.
+ */
+export interface EditRange extends EditSelection {
+  readonly insertedLength: number
+}
+
+/**
+ * One reference chip occurrence, backing exactly one U+FFFC placeholder in
+ * the draft (design §9.1 底层表示). Identity is occurrenceId — same-named
+ * references stay independently addressable. label/clipboardText are the
+ * owner's insert-time projections, cached so the chip survives owner loss
+ * (invalid flips instead of dropping the occurrence).
+ */
+export interface Occurrence {
+  /** Machine-minted stable identity (monotonic per machine). */
+  readonly occurrenceId: number
+  /** Owning source name (serializer routing key). */
+  readonly source: string
+  /** Owner-scoped reference id. */
+  readonly ref: string
+  /** Placeholder offset in the draft; the occurrence occupies exactly [offset, offset+1). */
+  readonly offset: number
+  /** Chip display label (insert-time cache). */
+  readonly label: string
+  /** Clipboard / persistence projection, e.g. `/name` (insert-time cache, never the model form). */
+  readonly clipboardText: string
+  /** Owner-resolution failure flag: chip renders invalid; serialization must fail. */
+  readonly invalid?: boolean
+}
+
+/** One sync-matched paste component; start/end are relative to the pasted text. */
+export interface PasteComponent extends EditSelection {
+  readonly reference: ReferenceInsert
+}
+
+/**
+ * Live paste-match attempt published while async matching may still upgrade
+ * pasted tokens (design §9.1 剪贴板 round-trip). Any non-paste transaction,
+ * submit start, invalidate-paste, or release ends it; a paste-upgrade keeps
+ * it current (later tokens re-CAS against the advanced draftRev).
+ */
+export interface PasteAttemptState {
+  /** Machine-minted attempt identity (paste-upgrade must match it). */
+  readonly attemptId: number
+  /** Pasted range in the draft as of the paste transaction. */
+  readonly insertedRange: EditSelection
+  /** Caller-supplied projection generation echoed back (the controller drops cross-generation results). */
+  readonly generation: number
+}
+
+/**
+ * InputMachine construction knobs. The machine never reads an ambient clock:
+ * `now` is the only time source, injected by the shell (tests inject a
+ * fake). The default clock is constant, i.e. consecutive single-char typing
+ * always coalesces until a non-typing transaction intervenes.
+ */
+export interface InputMachineOptions {
+  /** Single-char typing undo-merge window in ms (default 1000). */
+  readonly mergeWindowMs?: number
+  /** Monotonic clock for typing-merge decisions (default: constant 0). */
+  readonly now?: () => number
+}
+
+/** Published input state (the currency; per-session). */
+export interface InputState {
+  readonly draft: string
+  /** Monotonic draft revision (span CAS compares against this). */
+  readonly draftRev: number
+  readonly phase: 'plain' | 'adjudicating' | 'claimed' | 'submitting'
+  /** Present exactly while claimed/submitting (claim snapshot during flight; submit closure withheld). */
+  readonly claim?: { readonly token: string; readonly hint?: string }
+  /** Chip occurrence table, sorted by offset (one U+FFFC per entry). */
+  readonly occurrences: readonly Occurrence[]
+  /** Live paste-match attempt (absent when no paste is matchable). */
+  readonly paste?: PasteAttemptState
+  /** Read-only queue projection (session/queued frames + connect snapshot). */
+  readonly queue: readonly QueuedMessage[]
+}
+
+/**
+ * One in-flight submission attempt: the ONLY id concept in the submit plane.
+ * Created on enter; carried by adjudicated/submit-settled events; stale
+ * attempts are dropped (anti-backwash). release/session teardown aborts the
+ * current attempt, keeping the promise bounded.
+ */
+export interface SubmitAttempt {
+  readonly seq: number
+  readonly signal: AbortSignal
+  /** Draft at enter time; rollback restores it only while the live draft still equals it. */
+  readonly draftSnapshot: string
+}
+
+/**
+ * InputMachine input events (the machine's single write path). Every draft
+ * mutation is one transaction: draft edit, occurrence reconciliation, and
+ * undo-log push are atomic inside dispatch(). Events carrying `at` stamp the
+ * injected clock reading; only single-char typing coalescing reads it.
+ */
+export type InputEvent =
+  /** Full next draft from the textarea; editRange narrows the occurrence math (absent → diff scan). */
+  | { readonly type: 'draft-changed'; readonly draft: string; readonly editRange?: EditRange }
+  /** Insert '\n' replacing the selection (F1: the execCommand newline path moved into the machine). */
+  | { readonly type: 'newline'; readonly selection: EditSelection }
+  | { readonly type: 'begin-command'; readonly claim: CommandClaim; readonly span: TokenSpan }
+  /** Place one U+FFFC at the span and mint the occurrence (scoped insert-reference event payload). */
+  | { readonly type: 'insert-ref'; readonly reference: ReferenceInsert; readonly span: TokenSpan }
+  /** Delete a settled command token; success is observable as a draftRev advance. */
+  | { readonly type: 'consume-token'; readonly guard: ConsumeTokenGuard }
+  /** Owner-resolution result: exactly the listed occurrences are invalid (style bit; not a transaction). */
+  | { readonly type: 'set-invalid'; readonly invalidIds: readonly number[] }
+  | { readonly type: 'undo' }
+  | { readonly type: 'redo' }
+  /**
+   * Paste text replacing the selection, one transaction. Hot-snapshot sync
+   * matches ride in as components (chips minted inside the SAME transaction:
+   * one undo returns to pre-paste); a PasteMatchAttempt opens for the async
+   * remainder. Component ranges must be disjoint and inside the pasted text.
+   */
+  | { readonly type: 'paste-begin'; readonly text: string; readonly selection: EditSelection; readonly components?: readonly PasteComponent[]; readonly generation?: number }
+  /** Async match landed: upgrade one pasted token to a chip as an INDEPENDENT transaction (undo #1 → text, undo #2 → pre-paste). */
+  | { readonly type: 'paste-upgrade'; readonly attemptId: number; readonly span: TokenSpan; readonly reference: ReferenceInsert }
+  /** Shell-observed attempt killers the machine cannot see itself (caret/selection ops, Slash interaction updates). */
+  | { readonly type: 'invalidate-paste' }
+  | { readonly type: 'enter'; readonly mode: 'queue' | 'steer' }
+  | { readonly type: 'adjudicated'; readonly attempt: SubmitAttempt; readonly outcome: PickOutcome }
+  | { readonly type: 'adjudication-failed'; readonly attempt: SubmitAttempt; readonly message: string }
+  | { readonly type: 'submit-settled'; readonly attempt: SubmitAttempt; readonly ok: boolean; readonly outcome?: SubmitOutcome; readonly message?: string }
+  /**
+   * An ordinary (default-sink) send was accepted: clear the draft as a COMMIT —
+   * undo must not resurrect sent content (mirrors submit-settled's success arm).
+   */
+  | { readonly type: 'send-committed' }
+  | { readonly type: 'release' }
+
+/**
+ * InputMachine output effects (executed by the SessionInput shell; the
+ * machine stays pure). Draft/occurrence mutations carry no effect — the
+ * shell publishes the state store after every dispatch.
+ */
+export type InputEffect =
+  | { readonly type: 'adjudicate'; readonly attempt: SubmitAttempt; readonly draft: string }
+  | { readonly type: 'begin-submit'; readonly attempt: SubmitAttempt; readonly claim: CommandClaim; readonly args: string }
+  | { readonly type: 'default-sink'; readonly draft: string; readonly mode: 'queue' | 'steer' }
+  | { readonly type: 'notice'; readonly level: 'info' | 'error'; readonly text: string }

packages/client/ui-conversation/src/client/input/decorations.ts

@@ -0,0 +1,105 @@
+/**
+ * Draft decoration pure core (design §9.1: chips render from the occurrence
+ * table at placeholder offsets; the claim token renders as a mirror-layer
+ * highlight, the claim hint as ghost text). Zero React — the skeleton renders
+ * the instructions; tests drive this directly.
+ */
+import type { InputState } from './contract.ts'
+
+/** The claim-token highlight range (always draft-leading while the watch holds). */
+export interface TokenRange {
+  readonly start: number
+  readonly end: number
+}
+
+/** One chip render instruction: the placeholder at `offset` draws as `label`. */
+export interface ChipRender {
+  /** Stable render key (same-labeled chips stay independent). */
+  readonly occurrenceId: number
+  /** Placeholder offset in the draft (the chip occupies [offset, offset+1)). */
+  readonly offset: number
+  readonly label: string
+  /** Owner-resolution failure styling bit. */
+  readonly invalid: boolean
+}
+
+/**
+ * One plain-text reference range (decision 21): a `/name` or `@name` token
+ * whose name is on the trigger's lexicon. Pure derivation — editing the text
+ * out of match shape simply drops the range next scan.
+ */
+export interface TextRefRange {
+  readonly start: number
+  readonly end: number
+  readonly trigger: '/' | '@'
+}
+
+/** Decoration product: claim token range + chip instructions + text-ref ranges + the ghost hint. */
+export interface DraftDecorations {
+  /** Claim token range while claimed/submitting and the prefix watch holds; null otherwise. */
+  readonly token: TokenRange | null
+  /** Chip render instructions in draft order (occurrence table is offset-sorted). */
+  readonly chips: readonly ChipRender[]
+  /** Scan-derived plain-text reference ranges (empty without a lexicon). */
+  readonly textRefs: readonly TextRefRange[]
+  /** Ghost hint shown while the claim's args are blank; null otherwise. */
+  readonly hint: string | null
+}
+
+/** Token matcher: a trigger char at line start or after whitespace, then a word-ish name (never crosses \n). */
+const TEXT_REF_RE = /(^|\s)([/@])([\w-]+)/g
+
+/**
+ * Scan the draft for plain-text reference tokens against the hot lexicons
+ * (decision 21). Word-boundary discipline: the trigger must sit at the draft
+ * start or after whitespace ('x/name' never matches); the name must be an
+ * exact lexicon member.
+ * @param draft - draft text.
+ * @param lexicon - per-trigger name lists (a missing trigger scans nothing).
+ * @returns matched ranges in draft order.
+ */
+export function scanTextRefs(
+  draft: string, lexicon: ReadonlyMap<'/' | '@', readonly string[]>,
+): TextRefRange[] {
+  if (lexicon.size === 0 || draft === '') return []
+  const out: TextRefRange[] = []
+  TEXT_REF_RE.lastIndex = 0
+  let m: RegExpExecArray | null
+  while ((m = TEXT_REF_RE.exec(draft)) !== null) {
+    const trigger = m[2] as '/' | '@'
+    const name = m[3] ?? ''
+    if (lexicon.get(trigger)?.includes(name)) {
+      const start = m.index + (m[1]?.length ?? 0)
+      out.push({ start, end: start + 1 + name.length, trigger })
+    }
+  }
+  return out
+}
+
+/** The empty lexicon (default: zero text-ref decorations, old call sites unchanged). */
+const EMPTY_LEXICON: ReadonlyMap<'/' | '@', readonly string[]> = new Map()
+
+/**
+ * Derive the mirror-layer decorations from the input state.
+ * @param state - published input state.
+ * @param lexicon - optional per-trigger reference lexicons (decision 21 scan).
+ * @returns token range, chip instructions, text-ref ranges, and the ghost hint.
+ */
+export function deriveDecorations(
+  state: InputState, lexicon: ReadonlyMap<'/' | '@', readonly string[]> = EMPTY_LEXICON,
+): DraftDecorations {
+  const { draft, claim, phase, occurrences } = state
+  const claimActive = (phase === 'claimed' || phase === 'submitting')
+    && claim !== undefined && draft.startsWith(claim.token)
+  const token: TokenRange | null = claimActive ? { start: 0, end: claim.token.length } : null
+  const chips = occurrences.map(o => ({
+    occurrenceId: o.occurrenceId,
+    offset: o.offset,
+    label: o.label,
+    invalid: o.invalid === true,
+  }))
+  const hint = claimActive && claim.hint !== undefined && draft.slice(claim.token.length).trim() === ''
+    ? claim.hint
+    : null
+  return { token, chips, textRefs: scanTextRefs(draft, lexicon), hint }
+}

packages/client/ui-conversation/src/client/input/facade.ts

@@ -0,0 +1,446 @@
+/**
+ * SessionInput shell over the pure input machine: the sole machine caller
+ * and effect executor. Owns the InputState store (machine state + the queue
+ * overlay), the notice channel, and the submit transaction plumbing
+ * (adjudicate via the session's SlashController; claim.submit; default
+ * sink). Package-private; the hub alone constructs it and wires the scoped
+ * event listeners onto it.
+ */
+import type { ClientContext, ObservableSnapshot, SnapshotStore } from '@deepseek-ai/dsh-client-runtime/client'
+import { createSnapshotStore } from '@deepseek-ai/dsh-client-runtime/client'
+import type {
+  ArbitrateKey, ArbitrateOutcome, CommandClaim, ConsumeTokenRequest, PickOutcome,
+  ReferenceInsert, SlashController, TokenSpan,
+} from '@deepseek-ai/dsh-client-ui-slash/client'
+import type {
+  EditRange, EditSelection, InputActions, InputEffect, InputNotice, InputState,
+  PasteComponent, QueuedMessage, SessionInput, SubmitAttempt,
+} from './contract.ts'
+import { InputMachine } from './machine.ts'
+
+/** Popup face the shell needs (dismissal only; typed structurally to avoid a value import). */
+export interface PopupDismissFace {
+  dismiss(): void
+}
+
+/**
+ * Construction seams of one facade. The slash/popup faces are THUNKS: the
+ * shell is created inside the sessions provide materialization (before the
+ * scope record is queryable), where `slash.sessionOf`/`command.popupFor`
+ * cannot resolve yet — resolution defers to first interactive use.
+ */
+export interface SessionInputDeps {
+  /** Session-scope ctx handed to claim.submit transactions. */
+  actx: ClientContext
+  /** Enter adjudication face resolver; absent/undefined answer = every '/' line falls to the default sink. */
+  slash?: (() => SlashController | undefined) | undefined
+  /** PopupSelect shell face resolver (dismissal on submit lock / escape). */
+  popup?: (() => PopupDismissFace | undefined) | undefined
+  /** Queue read face; overlaid onto InputState.queue (absent = empty). */
+  queue?: ObservableSnapshot<readonly QueuedMessage[]> | undefined
+  /** The plain-message sink (send choreography / materialize fork — the hub owns it). */
+  defaultSink(text: string, mode: 'queue' | 'steer'): void
+}
+
+/** Guard tier from the machine phase. */
+function guardOf(phase: InputState['phase']): 'plain' | 'claimed' | 'frozen' {
+  switch (phase) {
+    case 'plain': return 'plain'
+    case 'claimed': return 'claimed'
+    default: return 'frozen' // adjudicating / submitting
+  }
+}
+
+const EMPTY_QUEUE: readonly QueuedMessage[] = []
+
+/** No-pipeline lexicon: zero text-ref decorations. */
+const EMPTY_LEXICON: ReadonlyMap<'/' | '@', readonly string[]> = new Map()
+
+/**
+ * The per-session input facade: scoped-event application verbs +
+ * setDraft/submit + the published InputState store.
+ */
+export class SessionInputShell implements SessionInput {
+  /** Published machine state + queue overlay (the InputZone currency source). */
+  readonly state: SnapshotStore<InputState>
+  /** Latest surfaced notice (null after clear); the wiring renders it beside the error strip. */
+  readonly notices: SnapshotStore<InputNotice | null> = createSnapshotStore<InputNotice | null>(null)
+  /** The public provide-channel action face (one stable identity per session — decision 20). */
+  readonly actions: InputActions = {
+    setDraft: (text) => { this.setDraft(text) },
+    submit: (mode) => { this.submit(mode) },
+  }
+
+  // Real wall clock: the typing-run merge window must actually expire in
+  // production (the machine's no-clock default is a constant for pure tests).
+  private readonly core = new InputMachine({ now: () => Date.now() })
+  private noticeSeq = 0
+  private lastDraft = ''
+  private disposed = false
+  /** Draft persistence mirror (chat store write; receives the clipboard projection, never raw placeholders). */
+  private mirrorFn: ((text: string) => void) | undefined
+
+  constructor(private readonly deps: SessionInputDeps) {
+    this.state = createSnapshotStore<InputState>(this.compose())
+    deps.queue?.subscribe(() => { this.publish() })
+  }
+
+  // ---- SessionInput face ----
+
+  /**
+   * Single draft write path (all mutation rides machine events).
+   * @param text - the full next draft.
+   * @param editRange - the DOM-observed edit shape, when the caller knows it
+   * (narrows the machine's occurrence math; absent → diff scan).
+   */
+  setDraft(text: string, editRange?: EditRange): void {
+    this.run(this.core.dispatch({ type: 'draft-changed', draft: text, ...(editRange !== undefined ? { editRange } : {}) }))
+  }
+
+  /**
+   * Clear the draft as a successful-send commit: no undo unit is recorded and
+   * the undo history is cut, so Ctrl/Cmd-Z cannot resurrect sent content
+   * (the command path gets the same discipline from submit-settled success).
+   */
+  commitSend(): void {
+    this.run(this.core.dispatch({ type: 'send-committed' }))
+  }
+
+  /**
+   * Insert a newline at the selection as one machine transaction (the
+   * execCommand path is gone — a second undo history would fork).
+   * @param selection - current DOM selection in draft coordinates.
+   */
+  newline(selection: EditSelection): void {
+    this.run(this.core.dispatch({ type: 'newline', selection }))
+  }
+
+  /** Undo the latest transaction (InputBar intercepts the platform chord). */
+  undo(): void {
+    this.run(this.core.dispatch({ type: 'undo' }))
+  }
+
+  /** Redo the latest undone transaction. */
+  redo(): void {
+    this.run(this.core.dispatch({ type: 'redo' }))
+  }
+
+  /**
+   * Paste text over the selection in one transaction, with any hot-snapshot
+   * sync matches componentized inside it.
+   * @param text - pasted plain text.
+   * @param selection - replaced selection in draft coordinates.
+   * @param components - sync-matched reference components (disjoint, inside `text`).
+   * @param generation - projection generation for late async-upgrade guards.
+   */
+  pasteBegin(text: string, selection: EditSelection, components?: readonly PasteComponent[], generation?: number): void {
+    this.run(this.core.dispatch({
+      type: 'paste-begin', text, selection,
+      ...(components !== undefined ? { components } : {}),
+      ...(generation !== undefined ? { generation } : {}),
+    }))
+  }
+
+  /** End the live paste-match attempt (caret/selection ops and Slash updates the machine cannot see). */
+  invalidatePaste(): void {
+    this.run(this.core.dispatch({ type: 'invalidate-paste' }))
+  }
+
+  /**
+   * Enter adjudication + submit transaction + default sink. Effects fan out
+   * from the machine; this method only feeds the event. Lock entry
+   * (adjudicating/submitting) force-closes the transient layers: the popup
+   * dismisses and the menu tracks frozen.
+   * @param mode - default-sink mode (queue appends; steer interrupts).
+   */
+  submit(mode: 'queue' | 'steer' = 'queue'): void {
+    this.run(this.core.dispatch({ type: 'enter', mode }))
+    const phase = this.snapshot.phase
+    if (phase === 'adjudicating' || phase === 'submitting') {
+      this.deps.popup?.()?.dismiss()
+      this.deps.slash?.()?.track(this.snapshot.draft, 0, { tier: 'frozen' }, this.snapshot.draftRev)
+    }
+  }
+
+  /**
+   * Feed a draft/caret change through trigger detection (guard derived from
+   * the machine phase).
+   * @param draft - live draft text.
+   * @param caret - caret position in draft coordinates.
+   */
+  track(draft: string, caret: number): void {
+    this.deps.slash?.()?.track(draft, caret, { tier: guardOf(this.snapshot.phase) }, this.snapshot.draftRev)
+  }
+
+  /**
+   * Keyboard arbitration while the menu is open.
+   * @param key - the intercepted key.
+   * @param composing - IME composition guard state.
+   * @returns the menu's verdict; 'pass' when no pipeline is mounted.
+   */
+  arbitrate(key: ArbitrateKey, composing: boolean): ArbitrateOutcome {
+    return this.deps.slash?.()?.arbitrate(key, composing) ?? 'pass'
+  }
+
+  /**
+   * Space adjudication over the controller's hot state.
+   * @returns true = a claim/insert was applied — the caller preventDefaults.
+   */
+  space(): boolean {
+    const slash = this.deps.slash?.()
+    if (slash === undefined) return false
+    const consumed = slash.onSpace()
+    // Machine-driven draft replacement never passes through onChange, so
+    // re-track: the caret lands after the token, where detection sees
+    // whitespace and closes the menu.
+    if (consumed) {
+      const next = this.snapshot
+      slash.track(next.draft, next.draft.length, { tier: guardOf(next.phase) }, next.draftRev)
+    }
+    return consumed
+  }
+
+  /** Dismiss the popupSelect shell (any interaction outside the box). */
+  dismissPopup(): void {
+    this.deps.popup?.()?.dismiss()
+  }
+
+  /**
+   * Hot plain-text reference lexicons for the decoration scan (decision 21).
+   * @returns the controller's per-trigger aggregation; empty Map without a pipeline.
+   */
+  lexicon(): ReadonlyMap<'/' | '@', readonly string[]> {
+    return this.deps.slash?.()?.lexicon() ?? EMPTY_LEXICON
+  }
+
+  /**
+   * Apply one command claim (scoped begin-command event listener body).
+   * @param claim - the command claim from the pick path.
+   * @param span - pick-time span snapshot.
+   * @returns whether the machine accepted (phase + span CAS passed and the draft mutated).
+   */
+  beginCommand(claim: CommandClaim, span: TokenSpan): boolean {
+    const before = this.core.state.draftRev
+    this.run(this.core.dispatch({ type: 'begin-command', claim, span }))
+    return this.core.state.phase === 'claimed' && this.core.state.draftRev !== before
+  }
+
+  /**
+   * Apply one reference insertion (scoped insert-reference event listener body).
+   * @param ref - the reference insertion from the pick path.
+   * @param span - pick-time span snapshot.
+   * @returns whether the machine accepted.
+   */
+  insertReference(ref: ReferenceInsert, span: TokenSpan): boolean {
+    const before = this.core.state.draftRev
+    this.run(this.core.dispatch({ type: 'insert-ref', reference: ref, span }))
+    return this.core.state.draftRev !== before
+  }
+
+  /**
+   * Consume one command token after business success (scoped consume-token
+   * event listener body). Span guard: revision CAS then splice; bare-token
+   * guard: trimmed-draft equality then clear.
+   * @param guard - exact span or bare-token guard.
+   * @returns whether the token was consumed.
+   */
+  consumeToken(guard: ConsumeTokenRequest['guard']): boolean {
+    const snapshot = this.core.state
+    if (guard.kind === 'span') {
+      if (guard.span.draftRev !== snapshot.draftRev) return false
+      const draft = snapshot.draft
+      this.setDraft(draft.slice(0, guard.span.start) + draft.slice(guard.span.end))
+      return true
+    }
+    if (snapshot.draft.trim() !== guard.token) return false
+    this.setDraft('')
+    return true
+  }
+
+  /**
+   * Insert plain reference text over the pick-time span (scoped insert-text
+   * event listener body, decision 21). Same CAS-then-splice shape as the
+   * consume-token span branch: the machine sees an ordinary draft-changed
+   * transaction (one undo step), no occurrence is minted — the chip look is
+   * a scan-derived decoration, never state.
+   * @param text - the plain reference text to splice in (e.g. `/name `).
+   * @param span - pick-time span snapshot (draftRev CAS).
+   * @returns whether the text was applied.
+   */
+  insertText(text: string, span: TokenSpan): boolean {
+    const snapshot = this.core.state
+    if (span.draftRev !== snapshot.draftRev) return false
+    const draft = snapshot.draft
+    this.setDraft(draft.slice(0, span.start) + text + draft.slice(span.end))
+    return true
+  }
+
+  /**
+   * Surface a notice from outside the machine (detached command results).
+   * @param level - severity tier.
+   * @param text - notice body.
+   */
+  notify(level: 'info' | 'error', text: string): void {
+    this.noticeSeq += 1
+    this.notices.set({ level, text, seq: this.noticeSeq })
+  }
+
+  // ---- wiring-layer extras (not on the frozen SessionInput face) ----
+
+  /** Teardown: abort any in-flight attempt and stop accepting async settlements. */
+  dispose(): void {
+    this.disposed = true
+    this.run(this.core.dispatch({ type: 'release' }))
+  }
+
+  /** Read the live machine state (guard derivation reads here). */
+  get snapshot(): InputState {
+    return this.state.getSnapshot()
+  }
+
+  /**
+   * Bind the draft persistence mirror (chat store write). Adopt-on-bind: the
+   * store draft may hold a persisted value from a previous mount; the caller
+   * seeds it via setDraft BEFORE binding, and afterwards every machine-adopted
+   * draft mirrors out.
+   * @param write - store draft write.
+   * @returns the unbind disposer.
+   */
+  bindMirror(write: (text: string) => void): () => void {
+    this.mirrorFn = write
+    return () => {
+      if (this.mirrorFn === write) this.mirrorFn = undefined
+    }
+  }
+
+  // ---- effect executor ----
+
+  private run(effects: readonly InputEffect[]): void {
+    for (const fx of effects) this.execute(fx)
+    this.publish()
+  }
+
+  private execute(fx: InputEffect): void {
+    switch (fx.type) {
+      case 'notice': {
+        this.noticeSeq += 1
+        this.notices.set({ level: fx.level, text: fx.text, seq: this.noticeSeq })
+        return
+      }
+      case 'adjudicate': {
+        this.adjudicate(fx.attempt, fx.draft)
+        return
+      }
+      case 'begin-submit': {
+        this.beginSubmit(fx.attempt, fx.claim, fx.args)
+        return
+      }
+      case 'default-sink': {
+        this.sinkSerialized(fx.draft, fx.mode)
+        return
+      }
+      default:
+        return // machine-internal effects (mirror rides publish)
+    }
+  }
+
+  /**
+   * Prompt serialization before the sink (design §3.12): expand each
+   * placeholder to its owner's model form via the session controller's
+   * codec routing. Owner missing / serialize failure / disposal blocks the
+   * send — notice + draft and chips retained, never a silent downgrade to
+   * the clipboard text. Chip-free drafts skip the async detour.
+   */
+  private sinkSerialized(draft: string, mode: 'queue' | 'steer'): void {
+    const occurrences = this.core.state.occurrences
+    if (occurrences.length === 0) {
+      this.deps.defaultSink(draft.trim(), mode)
+      return
+    }
+    const slash = this.deps.slash?.()
+    const controller = new AbortController()
+    void Promise.all(occurrences.map(async (o) => {
+      if (slash === undefined) throw new Error(`no serializer for reference source "${o.source}"`)
+      return { offset: o.offset, text: await slash.serializeReference(o.source, o.ref, controller.signal) }
+    })).then(
+      (parts) => {
+        if (this.disposed) return
+        // Splice model forms over their placeholders (offsets are draft-time;
+        // parts arrive offset-sorted since the table is).
+        let out = ''
+        let cursor = 0
+        for (const part of parts) {
+          out += draft.slice(cursor, part.offset) + part.text
+          cursor = part.offset + 1
+        }
+        out += draft.slice(cursor)
+        this.deps.defaultSink(out.trim(), mode)
+      },
+      (error: unknown) => {
+        controller.abort()
+        if (this.disposed) return
+        const message = error instanceof Error ? error.message : String(error)
+        this.notify('error', message)
+      },
+    )
+  }
+
+  /** Enter adjudication: poll the session controller; failure = notice + draft retained (never a silent downgrade). */
+  private adjudicate(attempt: SubmitAttempt, draft: string): void {
+    const slash = this.deps.slash?.()
+    if (slash === undefined) {
+      // No pipeline mounted: the '/' line is an ordinary message.
+      this.run(this.core.dispatch({ type: 'adjudicated', attempt, outcome: undefined }))
+      return
+    }
+    slash.adjudicate(draft.trim(), attempt.signal).then(
+      (outcome: PickOutcome) => {
+        if (this.dead(attempt)) return
+        this.run(this.core.dispatch({ type: 'adjudicated', attempt, outcome }))
+      },
+      (error: unknown) => {
+        if (this.dead(attempt)) return
+        const message = error instanceof Error ? error.message : String(error)
+        this.run(this.core.dispatch({ type: 'adjudication-failed', attempt, message }))
+      },
+    )
+  }
+
+  /** The submit transaction: claim.submit against the session scope; ok maps from the outcome kind. */
+  private beginSubmit(attempt: SubmitAttempt, claim: CommandClaim, args: string): void {
+    Promise.resolve()
+      .then(() => claim.submit(args, this.deps.actx))
+      .then(
+        (outcome) => {
+          if (this.dead(attempt)) return
+          this.run(this.core.dispatch({
+            type: 'submit-settled', attempt, ok: outcome.kind === 'success', outcome,
+          }))
+        },
+        (error: unknown) => {
+          if (this.dead(attempt)) return
+          const message = error instanceof Error ? error.message : String(error)
+          this.run(this.core.dispatch({ type: 'submit-settled', attempt, ok: false, message }))
+        },
+      )
+  }
+
+  /** Late-settlement guard: superseded attempts and disposed facades drop silently. */
+  private dead(attempt: SubmitAttempt): boolean {
+    return this.disposed || attempt.signal.aborted
+  }
+
+  private compose(): InputState {
+    const core = this.core.state
+    return { ...core, queue: this.deps.queue?.getSnapshot() ?? EMPTY_QUEUE }
+  }
+
+  private publish(): void {
+    const next = this.compose()
+    this.state.set(next)
+    if (next.draft !== this.lastDraft) {
+      this.lastDraft = next.draft
+      this.mirrorFn?.(next.draft)
+    }
+  }
+}