@deepseek-ai/dsh-client-connection 0.0.1-rc.2 → 0.0.1-rc.3

package/README.i18n.yaml

@@ -2,5 +2,5 @@
 # side as of the last confirmed-consistent state. Both languages carry equal authority;
 # after editing either side, bring the other along and re-record with:
 #   pnpm run verify-translation-pairing --write packages/client/connection/README.md
-README.md: a82bb55ab65df2732ad16248d2cc9aa15b60e94d
-README.zh.md: d4c19db8e74e3562ec55b5ef60675aef79b82008
+README.md: 3315552dd0400697d5a96639598c5f5bb2bb4f5b
+README.zh.md: 0dc251f1e5410bd0d74ef450c6d8df3dc9cdab81

package/README.md

@@ -2,7 +2,7 @@
 
 English | [中文](README.zh.md)
 
-Wire consumer layer: the client plugin's apply mounts `ctx.connection` (shared api client + current-page loopback state + observable generation-scoped `hostDescription` + single-consumer stream-loop starter); the export face carries the wire contract types, the `AbstractApiClient` abstraction, and the loop's sink/config types. Each successful readiness handshake publishes the exact `host.describe` value before `onConnected`; generation loss and explicit stop clear it, so native-capability consumers never retain a disconnected answer. The browser carrier uses HTTP POST for unary and respond operations and opens one downlink-only WebSocket each for `events.mux` and `events.host`; the in-process carrier satisfies the same two-stream abstraction. The Host half owns the single `/api` route and its Fetch bridge; a registered TypeRT interceptor claims its Remote endpoints before the API Proxy fallback. Loopback hostname classification stays package-internal: the `/api` Host fence and WebSocket upgrades use it directly, while other client plugins consume the derived `ctx.connection.isLoopback` state. The node half's `/api` route pins the privileged method set (`host.pickDirectory`, `host.openPath`, and the whole configuration plane — `settings.describe`/`openDocument`/`update`/`replace`/`mutate` and `credentials.describe`/`set`/`unset`; reads and native actions included, since describing returns the exposed configuration, opening acts on the Host desktop, and probing an arbitrary reference reports where a credential comes from — and the agent-preset authoring plane, `agentPreset.read`/`copy`/`openDocument`/`remove`, since a composition names the plugins a session runs, so reading one is reconnaissance, and copy/remove/openDocument manage the roster and drive the host desktop (authoring is copy-only, so none of them accepts composition text or a path); `agentPreset.list` and `agentPreset.select` stay out — the roster carries only ids and trust, and choosing a preset grants nothing `session.create`'s own `agentPreset` did not, over a default that already carries bash) to loopback by passing the trust fence with an empty trust list — a declared `trustedHosts` authority reaches every other method, while these stay loopback-local until a real authentication layer exists. The platform carriers and ConnectionController loop are package-internal; apply selects and drives them. The downlink boundary is documented in the [WebSocket downlink carrier Agent Note](../../../.agents/notes/implemented/architecture/2026-08-04-websocket-downlink-carrier.md).
+Wire consumer layer: the client plugin's apply mounts `ctx.connection` (shared api client + current-page loopback state + observable generation-scoped `hostDescription` + single-consumer stream-loop starter); the export face carries the wire contract types, the `AbstractApiClient` abstraction, and the loop's sink/config types. Each successful readiness handshake publishes the exact `host.describe` value before `onConnected`; generation loss and explicit stop clear it, so native-capability consumers never retain a disconnected answer. The browser carrier uses HTTP POST for unary and respond operations and opens one downlink-only WebSocket each for `events.mux` and `events.host`; the in-process carrier satisfies the same two-stream abstraction. The Host half owns the single `/api` route and its Fetch bridge; a registered Typert interceptor claims its Remote endpoints before the API Proxy fallback. Loopback hostname classification stays package-internal: the `/api` Host fence and WebSocket upgrades use it directly, while other client plugins consume the derived `ctx.connection.isLoopback` state. The node half's `/api` route pins the privileged method set (`host.pickDirectory`, `host.openPath`, and the whole configuration plane — `settings.describe`/`openDocument`/`update`/`replace`/`mutate` and `credentials.describe`/`set`/`unset`; reads and native actions included, since describing returns the exposed configuration, opening acts on the Host desktop, and probing an arbitrary reference reports where a credential comes from — and the agent-preset authoring plane, `agentPreset.read`/`copy`/`openDocument`/`remove`, since a composition names the plugins a session runs, so reading one is reconnaissance, and copy/remove/openDocument manage the roster and drive the host desktop (authoring is copy-only, so none of them accepts composition text or a path); `agentPreset.list` and `agentPreset.select` stay out — the roster carries only ids and trust, and choosing a preset grants nothing `session.create`'s own `agentPreset` did not, over a default that already carries bash) to loopback by passing the trust fence with an empty trust list — a declared `trustedHosts` authority reaches every other method, while these stay loopback-local until a real authentication layer exists. The platform carriers and ConnectionController loop are package-internal; apply selects and drives them. The downlink boundary is documented in the [WebSocket downlink carrier Agent Note](../../../.agents/notes/implemented/architecture/2026-08-04-websocket-downlink-carrier.md).
 
 ## /api browser-trust fence
 
@@ -23,3 +23,4 @@ None; this package neither assembles nor sends a provider request.
 ## Known Limitations and Deferred Work
 
 - **History resumes an unattached session** — opening history may create the host-side agent and add latency to the first open; there is no persistence-only read path.
+- **The `/api` bridge buffers each request body in memory** — `maxRequestBodyBytes` (default 160 MiB, sized for the default 100 MiB aggregate image limit after base64 expansion plus envelope headroom) is therefore also the per-request resident bound; a streaming body path would be needed to lower it without shrinking the image limits.

package/README.zh.md

@@ -2,15 +2,15 @@
 
 [English](README.md) | 中文
 
-协议消费层：客户端插件的 apply 会挂载 `ctx.connection`（共享 API 客户端 + 当前页面的 loopback 状态 + 可观察且按 generation 生效的 `hostDescription` + 单消费方流循环启动器）；导出表层携带协议约定类型、`AbstractApiClient` 抽象，以及循环的 sink／配置类型。每次就绪握手成功后，都会在 `onConnected` 之前发布完整的 `host.describe` 值；generation 失效或显式 stop 会清空它，因此原生能力消费者不会保留已经断线的判断。浏览器载体以 HTTP POST 发送 unary／respond，并为 `events.mux` 与 `events.host` 各开一条只下行的 WebSocket；进程内载体满足同一双流抽象。Host half 持有唯一 `/api` route 及其 Fetch bridge；已注册的 TypeRT interceptor 会先认领自己的 Remote endpoint，未认领请求再回退 API Proxy。Loopback hostname 判定逻辑留在包内部：`/api` Host fence 与 WebSocket upgrade 会直接使用它，其他客户端插件则消费派生的 `ctx.connection.isLoopback` 状态。node 半侧的 `/api` 路由让特权方法集（`host.pickDirectory`、`host.openPath`，以及整个配置面——`settings.describe`/`openDocument`/`update`/`replace`/`mutate` 与 `credentials.describe`/`set`/`unset`；读取与原生操作也在内，因为 describe 会返回已暴露的配置、打开操作会作用于 Host 桌面，而探测任意引用会报出某条凭据来自何处——以及 agent preset 的创作面 `agentPreset.read`/`copy`/`openDocument`/`remove`，因为组装指明了一个会话所运行的插件，读取它是侦察，而 copy/remove/openDocument 管理名单并驱动宿主桌面（创作只有复制一种写入，因此这些方法都不接收组装文本或路径）；`agentPreset.list` 与 `agentPreset.select` 不在其中——名单只携带 id 与信任级别，而选择一个 preset 并不比 `session.create` 自带的 `agentPreset` 多给任何能力，何况默认 preset 本就带着 bash）以空信任表过信任 fence，从而钉在回环——已声明的 `trustedHosts` 授权可达其余全部方法，而这些方法在真正的认证层出现之前仍只限回环本机。平台载体与 ConnectionController 循环属于包内部；apply 负责选择并驱动它们。下行边界见 [WebSocket 下行载体 Agent Note](../../../.agents/notes/implemented/architecture/2026-08-04-websocket-downlink-carrier.md)。
+协议消费层：客户端插件的 apply 会挂载 `ctx.connection`（共享 API 客户端 + 当前页面的 loopback 状态 + 可观察且按 generation 生效的 `hostDescription` + 单消费方流循环启动器）；导出表层携带协议约定类型、`AbstractApiClient` 抽象，以及循环的 sink／配置类型。每次就绪握手成功后，都会在 `onConnected` 之前发布完整的 `host.describe` 值；generation 失效或显式 stop 会清空它，因此原生能力消费者不会保留已经断线的判断。浏览器载体以 HTTP POST 发送 unary／respond，并为 `events.mux` 与 `events.host` 各开一条只下行的 WebSocket；进程内载体满足同一双流抽象。Host half 持有唯一 `/api` route 及其 Fetch bridge；已注册的 Typert interceptor 会先认领自己的 Remote endpoint，未认领请求再回退 API Proxy。Loopback hostname 判定逻辑留在包内部：`/api` Host fence 与 WebSocket upgrade 会直接使用它，其他客户端插件则消费派生的 `ctx.connection.isLoopback` 状态。node 半侧的 `/api` 路由让特权方法集（`host.pickDirectory`、`host.openPath`，以及整个配置面——`settings.describe`/`openDocument`/`update`/`replace`/`mutate` 与 `credentials.describe`/`set`/`unset`；读取与原生操作也在内，因为 describe 会返回已暴露的配置、打开操作会作用于 Host 桌面，而探测任意引用会报出某条凭据来自何处——以及 agent（智能体） preset 的创作面 `agentPreset.read`/`copy`/`openDocument`/`remove`，因为组装指明了一个会话所运行的插件，读取它是侦察，而 copy/remove/openDocument 管理名单并驱动宿主桌面（创作只有复制一种写入，因此这些方法都不接收组装文本或路径）；`agentPreset.list` 与 `agentPreset.select` 不在其中——名单只携带 id 与信任级别，而选择一个 preset 并不比 `session.create` 自带的 `agentPreset` 多给任何能力，何况默认 preset 本就带着 bash）以空信任表过信任 fence，从而钉在回环——已声明的 `trustedHosts` 授权可达其余全部方法，而这些方法在真正的认证层出现之前仍只限回环本机。平台载体与 ConnectionController 循环属于包内部；apply 负责选择并驱动它们。下行边界见 [WebSocket 下行载体 Agent Note](../../../.agents/notes/implemented/architecture/2026-08-04-websocket-downlink-carrier.md)。
 
 ## /api 浏览器信任栅栏
 
-node 半侧在桥接或 upgrade 前守卫 `/api` 下的每个入口（`src/api-request-trust.ts`）。每个请求——无论是否带浏览器标记——`Host` 都必须是回环地址权威，或与某个 `trustedHosts` 条目匹配：带端口的 `host:port` 条目精确匹配，不带端口的条目匹配任意端口，两侧均经 WHATWG 归一化后比较（DNS rebinding 防御）。刻意不为无浏览器标记的 HTTP 请求开捷径：明文 HTTP 下浏览器的图片与导航读取既不带 `Origin` 也不带 Fetch-Metadata，因此无标记请求仍可能是被重绑页面发起的、响应可被读走的读取，而 Host 是重绑唯一伪造不了的请求头；WebSocket 浏览器握手会带 `Origin` 并通过同一道比较。非浏览器客户端经由回环地址、CLI 推导的 LAN IP 字面量或已声明的权威通过同一道栅栏。当标记存在时，`Origin` 必须与 Host 权威完全一致；显式的 `sec-fetch-site: cross-site` 标记一律拒绝。不是纯的、规范形 `host[:port]` 权威的 `trustedHosts` 条目——即 WHATWG 解析读回后与原文不完全一致的——会让插件加载明确报错：否则解析会悄悄授权 `harness.internal/path` 这类笔误里的 hostname，或把悬空冒号、补零端口放大成任意端口授权。HTTP 失败在任何 RPC 分发之前以纯 403 应答，upgrade 失败在启动任何 event stream 前拒绝握手。因此非回环（`--host 0.0.0.0`）部署需要让自己的服务权威被信任：dsh CLI 会自行推导本机的 LAN IP 字面量，其 `--trusted-host` flag 用于声明具名权威，所以 cordis.yml 中的 `trustedHosts` 面向 CLI 不参与引导的组合。这道栅栏是可达性策略，而不是认证；Web 载体不提供认证层。决策记录：[api 浏览器信任边界 Agent Note](../../../.agents/notes/implemented/architecture/2026-07-28-api-browser-trust-boundary.md)。
+node 半侧在桥接或 upgrade 前守卫 `/api` 下的每个入口（`src/api-request-trust.ts`）。每个请求——无论是否带浏览器标记——`Host` 都必须是回环地址权威，或与某个 `trustedHosts` 条目匹配：带端口的 `host:port` 条目精确匹配，不带端口的条目匹配任意端口，两侧均经 WHATWG 归一化后比较（DNS rebinding 防御）。刻意不为无浏览器标记的 HTTP 请求开捷径：明文 HTTP 下浏览器的图片与导航读取既不带 `Origin` 也不带 Fetch-Metadata，因此无标记请求仍可能是被重绑页面发起的、响应可被读走的读取，而 Host 是重绑唯一伪造不了的请求头；WebSocket 浏览器握手会带 `Origin` 并通过同一道比较。非浏览器客户端经由回环地址、CLI（命令行界面）推导的 LAN IP 字面量或已声明的权威通过同一道栅栏。当标记存在时，如附带 `Origin`，则它必须与 Host 权威完全一致；显式的 `sec-fetch-site: cross-site` 标记一律拒绝。不是纯的、规范形 `host[:port]` 权威的 `trustedHosts` 条目——即 WHATWG 解析读回后与原文不完全一致的——会让插件加载明确报错：否则解析会悄悄授权 `harness.internal/path` 这类笔误里的 hostname，或把悬空冒号、补零端口放大成任意端口授权。HTTP 失败在任何 RPC 分发之前以纯 403 应答，upgrade 失败在启动任何事件流前拒绝握手。因此非回环（`--host 0.0.0.0`）部署需要让自己的服务权威被信任：dsh CLI 会自行推导本机的 LAN IP 字面量，其 `--trusted-host` flag 用于声明具名权威，所以 cordis.yml 中的 `trustedHosts` 面向 CLI 不参与引导的组合。这道栅栏是可达性策略，而不是认证；Web 载体不提供认证层。决策记录：[api 浏览器信任边界 Agent Note](../../../.agents/notes/implemented/architecture/2026-07-28-api-browser-trust-boundary.md)。
 
 ## `/api` WebSocket 下行
 
-`/api/events.mux` 与 `/api/events.host` 各接受一条 WebSocket upgrade，并只向浏览器发送对应的 `ServerRequest` text message；客户端不会在这些 socket 上发送业务数据。任一 socket 结束都会使当前 connection generation 失败并重建两条流，连接就绪仍要求两条 socket open 且 `host.describe` HTTP 调用成功。Host teardown 会终止两条 socket、中止各自的 source，并等待 source 清理完成后再返回。普通网络 GET 这些路径会返回 426，不保留 SSE 回退；`toFetchHandler` 的 SSE 编解码只服务进程内同构载体。
+`/api/events.mux` 与 `/api/events.host` 各接受一条 WebSocket upgrade，并只向浏览器发送对应的 `ServerRequest` 文本消息；客户端不会在这些 socket 上发送业务数据。任一 socket 结束都会使当前 connection generation 失败并重建两条流，连接就绪仍要求两条 socket 均已打开且 `host.describe` HTTP 调用成功。Host teardown 会终止两条 socket、中止各自的 source，并等待 source 清理完成后再返回。普通网络 GET 这些路径会返回 426，不保留 SSE（Server-Sent Events）回退；`toFetchHandler` 的 SSE 编解码只服务进程内同构载体。
 
 ## 模型体验
 
@@ -23,3 +23,4 @@ node 半侧在桥接或 upgrade 前守卫 `/api` 下的每个入口（`src/api-r
 ## 已知限制与暂缓事项
 
 - **History 会恢复未附加的会话**：打开 history 可能创建宿主侧 agent，并增加首次打开的延迟；没有仅从持久化读取的路径。
+- **`/api` 桥把每个请求体整体缓冲在内存里**：`maxRequestBodyBytes`（默认 160 MiB，按默认 100 MiB 图片总量上限经 base64 膨胀加信封余量得出）因此同时是单请求的驻留内存上界；要降低它而不缩小图片限额，需要流式请求体路径。

package/lib/client.js

@@ -145,7 +145,18 @@ window.__ModuleLoader__.load({
 			}
 		};
 		//#endregion
-		//#region ../../llm/llm/src/brand.ts
+		//#region ../../llm/llm/lib/types/brand.js
+		/**
+		* dsh-llm's owned branded ids: tool-call correlation and provider request
+		* diagnostics.
+		*
+		* The `Branded<B>` primitive itself lives in `@deepseek-ai/dsh-brand` (a
+		* zero-dependency type-only package) so every owner of a cross-boundary id can
+		* brand it without depending on dsh-llm; see that package's README for the
+		* nominal-typing policy.
+		*
+		* @module @deepseek-ai/dsh-llm/brand
+		*/
 		/**
 		* Brand a message identifier.
 		* @param id - the opaque message identifier.
@@ -163,7 +174,7 @@ window.__ModuleLoader__.load({
 			return id;
 		}
 		//#endregion
-		//#region ../../llm/llm/src/call-config.ts
+		//#region ../../llm/llm/lib/types/call-config.js
 		/**
 		* Deep-freeze a value in place with an iterative traversal, guarding cycles,
 		* so later mutation throws without imposing a JavaScript call-stack depth cap.
@@ -210,7 +221,7 @@ window.__ModuleLoader__.load({
 			return value;
 		}
 		//#endregion
-		//#region ../../llm/llm/src/message.ts
+		//#region ../../llm/llm/lib/types/message.js
 		/** Message value types, identity, and immutable construction helpers. */
 		/**
 		* Detach and deep-freeze a message whose identity already exists.
@@ -276,8 +287,33 @@ window.__ModuleLoader__.load({
 				}]
 			});
 		}
+		/**
+		* Whether a stream chunk carries visible model output (the first-token
+		* boundary shared by client step timing and the whole-log sessionStats
+		* projection). Empty deltas (heartbeats, empty tool-call frames) do not count
+		* as a first token.
+		* @param chunk - the stream chunk to test.
+		* @returns true when the chunk contains a non-empty text/reasoning/tool delta.
+		*/
+		function isTokenDelta(chunk) {
+			switch (chunk.type) {
+				case "text-delta":
+				case "reasoning-delta": return chunk.text !== "";
+				case "tool-call-delta": return chunk.argumentsDelta !== "" || chunk.name !== void 0;
+				default: return false;
+			}
+		}
 		//#endregion
-		//#region ../../core/session/src/surface.ts
+		//#region ../../core/session/lib/types/surface.js
+		/**
+		* Surface layer on top of the session event log: an ordered view of events
+		* that produce LLM messages. The append-only log remains the source of truth.
+		*
+		* Browser-safe: web clients consume this subpath export, so it must stay free
+		* of `node:` imports (they break the vite bundle).
+		*
+		* @module @deepseek-ai/dsh-session/surface
+		*/
 		/** Runtime counterpart of the message-producing event union. */
 		const SURFACE_EVENT_TYPES = new Set([
 			"user/message",
@@ -484,7 +520,13 @@ window.__ModuleLoader__.load({
 			};
 		}
 		//#endregion
-		//#region ../../host/apiproxy/src/api/rpc.ts
+		//#region ../../host/apiproxy/lib/types/api/rpc.js
+		/**
+		* Four-quadrant RPC message model. Channels and messages are decoupled: HTTP,
+		* WebSocket, and in-process SSE are physical carriers, while logical messages
+		* are channel-independent and form a four-member discriminated union.
+		* api/ contract layer: zero Node dependencies, importable from the browser.
+		*/
 		/**
 		* Brands a string as RpcId (same precedent as core `SessionId()`). Minted by the initiator:
 		* client-request → client mints; server-request → host mints (answerable frames get a stable
@@ -4837,7 +4879,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 			return /* @__PURE__ */ _superRefine(fn, params);
 		}
 		//#endregion
-		//#region ../../host/apiproxy/src/api/rpc.schema.ts
+		//#region ../../host/apiproxy/lib/types/api/rpc.schema.js
 		/**
 		* Message-layer zod schemas: the four wire full forms + error body +
 		* carrier receipt. The payload slot is unknown in the full-form schemas — business payloads
@@ -5127,7 +5169,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 		const serverResponseSchema = object({
 			type: literal("server-response"),
 			rpcId: rpcIdSchema,
-			result: rpcResultSchema(unknown())
+			result: rpcResultSchema(unknown().optional())
 		});
 		/** ServerRequest full form (payload stays wide). */
 		const serverRequestSchema = object({
@@ -5143,7 +5185,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 			object({
 				type: literal("client-response"),
 				rpcId: rpcIdSchema,
-				result: rpcResultSchema(unknown())
+				result: rpcResultSchema(unknown().optional())
 			})
 		]);
 		/** Carrier receipt schema. */
@@ -5152,7 +5194,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 			reason: union([literal("not-pending"), literal("bad-response")])
 		})]);
 		//#endregion
-		//#region ../../host/apiproxy/src/api/session-search.ts
+		//#region ../../host/apiproxy/lib/types/api/session-search.js
 		/**
 		* Return the longest prefix containing at most `maximum` Unicode code points.
 		* @param value - text to bound.
@@ -5170,7 +5212,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 			return value;
 		}
 		//#endregion
-		//#region ../../host/apiproxy/src/api/sessions.schema.ts
+		//#region ../../host/apiproxy/lib/types/api/sessions.schema.js
 		/**
 		* sessions domain zod schemas (names derived from map keys: sessionListRequestSchema /
 		* sessionListValueSchema). SessionEvent passthrough = strict envelope (type/seq/time) + wide
@@ -5314,6 +5356,13 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 			asOfSeq: number().int().min(-1),
 			values: record(string(), unknown())
 		});
+		object({
+			maxImageBytes: number().int().positive(),
+			maxImagesPerMessage: number().int().positive(),
+			maxMessageImageBytes: number().int().positive(),
+			maxImagePixels: number().int().positive(),
+			mediaTypes: array(string())
+		});
 		/** session.history response value (projections rides the tail page only). */
 		const sessionHistoryValueSchema = object({
 			events: array(historyEntrySchema),
@@ -5407,7 +5456,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 		/** session.cancel response value. */
 		const sessionCancelValueSchema = object({ accepted: literal(true) });
 		//#endregion
-		//#region ../../host/apiproxy/src/api/approvals.schema.ts
+		//#region ../../host/apiproxy/lib/types/api/approvals.schema.js
 		/**
 		* approvals domain zod schemas (respond is a client-response; the payload schema serves
 		* the /api/respond endpoint's second parse after routing via the pending table).
@@ -5441,7 +5490,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 			finishedAt: number().int().nonnegative().optional()
 		});
 		//#endregion
-		//#region ../../host/apiproxy/src/api/workspace.schema.ts
+		//#region ../../host/apiproxy/lib/types/api/workspace.schema.js
 		/**
 		* workspace domain zod schemas (names derived from map keys). The
 		* WorkspaceId brand cast lives in sessions.schema (see the note there) and
@@ -5477,6 +5526,12 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 		object({ workspaceId: workspaceIdSchema });
 		/** workspace.delete response value. */
 		const workspaceDeleteValueSchema = object({ deleted: literal(true) });
+		object({
+			workspaceId: workspaceIdSchema,
+			beforeWorkspaceId: workspaceIdSchema.optional()
+		});
+		/** workspace.insertBefore response value: the complete durable display order. */
+		const workspaceInsertBeforeValueSchema = object({ workspaceIds: array(workspaceIdSchema) });
 		object({
 			workspaceId: workspaceIdSchema,
 			sessionId: sessionIdSchema,
@@ -5488,13 +5543,13 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 		/** workspace.archiveSession response value: the full updated archive set. */
 		const workspaceArchiveSessionValueSchema = object({ archivedSessionIds: array(sessionIdSchema) });
 		//#endregion
-		//#region ../../host/apiproxy/src/api/events.schema.ts
+		//#region ../../host/apiproxy/lib/types/api/events.schema.js
 		/**
 		* events domain zod schemas: MuxFrame / HostFrame unions (discriminatedUnion('type')).
 		* A frame is the payload slot of the ServerRequest full form; the SessionEvent inside
 		* a session/event frame reuses sessions.schema's strict-envelope + wide-data passthrough branch.
 		*/
-		/** Question fields validated strictly against core dsh-user-interaction. */
+		/** Question fields validated strictly against core dsh-user-questions. */
 		const askUserQuestionItemSchema = object({
 			id: string(),
 			question: string(),
@@ -5578,9 +5633,9 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 				}))
 			}),
 			object({
-				type: literal("session/tasks"),
+				type: literal("session/jobs"),
 				sessionId: sessionIdSchema,
-				tasks: array(taskViewSchema)
+				jobs: array(taskViewSchema)
 			}),
 			object({
 				type: literal("session/projection"),
@@ -5627,6 +5682,10 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 				type: literal("host/workspace-removed"),
 				workspaceId: workspaceIdSchema
 			}),
+			object({
+				type: literal("host/workspace-order-changed"),
+				workspaceIds: array(workspaceIdSchema)
+			}),
 			object({
 				type: literal("host/archived-sessions-changed"),
 				archivedSessionIds: array(sessionIdSchema)
@@ -5679,34 +5738,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 		/** host.openPath response value. */
 		const hostOpenPathValueSchema = object({ opened: literal(true) });
 		//#endregion
-		//#region ../../host/apiproxy/src/api/commands.schema.ts
-		/**
-		* commands domain zod schemas (names derived from map keys: commandListRequestSchema /
-		* commandListValueSchema / commandExecuteRequestSchema / commandExecuteValueSchema).
-		*/
-		/** CommandDescriptor row of command.list. */
-		const commandDescriptorSchema = object({
-			name: string().min(1),
-			description: string(),
-			input: object({ hint: string() }).optional()
-		});
-		object({ sessionId: sessionIdSchema });
-		/** command.list response value. */
-		const commandListValueSchema = object({ commands: array(commandDescriptorSchema) });
-		object({
-			sessionId: sessionIdSchema,
-			line: string()
-		});
-		/** CommandId: one brand cast after schema validation (the only cast point in this domain). */
-		const commandIdSchema = string().min(1);
-		/** command.execute response value: pure admission — outcomes ride the logged
-		* lifecycle events; commandId (present exactly when matched) correlates with them. */
-		const commandExecuteValueSchema = object({
-			matched: boolean(),
-			commandId: commandIdSchema.optional()
-		});
-		//#endregion
-		//#region ../../host/apiproxy/src/api/skills.schema.ts
+		//#region ../../host/apiproxy/lib/types/api/skills.schema.js
 		/**
 		* skills domain zod schemas (names derived from map keys: skillListRequestSchema /
 		* skillListValueSchema).
@@ -5722,7 +5754,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 		/** skill.list response value. */
 		const skillListValueSchema = object({ skills: array(skillEntrySchema) });
 		//#endregion
-		//#region ../../host/apiproxy/src/api/agent-presets.schema.ts
+		//#region ../../host/apiproxy/lib/types/api/agent-presets.schema.js
 		/**
 		* agent-presets domain zod schemas (names derived from map keys:
 		* agentPresetListRequestSchema / agentPresetListValueSchema).
@@ -5775,7 +5807,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 		/** agentPreset.remove response value. */
 		const agentPresetRemoveValueSchema = object({});
 		//#endregion
-		//#region ../../host/apiproxy/src/api/goals.schema.ts
+		//#region ../../host/apiproxy/lib/types/api/goals.schema.js
 		/**
 		* goals domain zod schemas. Mutation-only shapes: every value schema is a
 		* `{ ref }` acknowledgement (clear: `{ cleared }`) — the current goal state
@@ -5828,7 +5860,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 		/** goal.clear response value. */
 		const goalClearValueSchema = object({ cleared: literal(true) });
 		//#endregion
-		//#region ../../host/apiproxy/src/api/settings.schema.ts
+		//#region ../../host/apiproxy/lib/types/api/settings.schema.js
 		/**
 		* settings domain zod schemas (names derived from map keys: settingsDescribeRequestSchema /
 		* settingsDescribeValueSchema / settingsUpdate* / settingsReplace*).
@@ -5890,7 +5922,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 		/** settings.replace response value. */
 		const settingsReplaceValueSchema = settingsNamespaceViewSchema;
 		//#endregion
-		//#region ../../host/apiproxy/src/api/credentials.schema.ts
+		//#region ../../host/apiproxy/lib/types/api/credentials.schema.js
 		/**
 		* credentials domain zod schemas (names derived from map keys:
 		* credentialsDescribeRequestSchema / credentialsDescribeValueSchema / …).
@@ -5918,7 +5950,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 		/** credentials.unset response value. */
 		const credentialsUnsetValueSchema = object({});
 		//#endregion
-		//#region ../../host/apiproxy/src/api/llm.schema.ts
+		//#region ../../host/apiproxy/lib/types/api/llm.schema.js
 		/**
 		* llm domain zod schemas (names derived from map keys: llmProvidersRequestSchema /
 		* llmProvidersValueSchema / llmModelsRequestSchema / llmModelsValueSchema).
@@ -5958,7 +5990,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 		/** llm.discoverModels response value. */
 		const llmDiscoverModelsValueSchema = object({ models: array(discoveredModelViewSchema) });
 		//#endregion
-		//#region ../../host/apiproxy/src/api/subagents.schema.ts
+		//#region ../../host/apiproxy/lib/types/api/subagents.schema.js
 		/** Zod schemas for the browser-safe subagent domain. */
 		/** Healthy and diagnostic durable catalog rows. */
 		const subagentListEntrySchema = union([
@@ -6022,7 +6054,13 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 		/** subagent.interrupt response value. */
 		const subagentInterruptValueSchema = object({ accepted: literal(true) });
 		//#endregion
-		//#region ../../host/apiproxy/src/fetch/client.ts
+		//#region ../../host/apiproxy/lib/types/fetch/client.js
+		/**
+		* Client side of the fetch carrier. AbstractApiClient holds every protocol invariant: rpcId minting,
+		* four-quadrant envelope wrap/unwrap, zod parsing, in-process SSE frame decoding, and the payload-direct
+		* IApiClient domain methods (business code never mints). Platform differences ride two aspects:
+		* abstract doFetch (transport) + overridable onEnvelope (tap). ApiProxy (the impl face) is untouched.
+		*/
 		/**
 		* S→C second-level parse table: value schema by method (the response-path
 		* mirror of the handler's request table; key coverage compiler-enforced against RpcMethodMap).
@@ -6053,10 +6091,9 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 			"workspace.create": workspaceCreateValueSchema,
 			"workspace.rename": workspaceRenameValueSchema,
 			"workspace.delete": workspaceDeleteValueSchema,
+			"workspace.insertBefore": workspaceInsertBeforeValueSchema,
 			"workspace.insertSessionBefore": workspaceInsertSessionBeforeValueSchema,
 			"workspace.archiveSession": workspaceArchiveSessionValueSchema,
-			"command.list": commandListValueSchema,
-			"command.execute": commandExecuteValueSchema,
 			"skill.list": skillListValueSchema,
 			"agentPreset.list": agentPresetListValueSchema,
 			"agentPreset.select": agentPresetSelectValueSchema,
@@ -6272,13 +6309,10 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 				create: (payload, signal) => this.callUnary("workspace.create", payload, signal),
 				rename: (payload, signal) => this.callUnary("workspace.rename", payload, signal),
 				delete: (payload, signal) => this.callUnary("workspace.delete", payload, signal),
+				insertBefore: (payload, signal) => this.callUnary("workspace.insertBefore", payload, signal),
 				insertSessionBefore: (payload, signal) => this.callUnary("workspace.insertSessionBefore", payload, signal),
 				archiveSession: (payload, signal) => this.callUnary("workspace.archiveSession", payload, signal)
 			};
-			commands = {
-				list: (payload, signal) => this.callUnary("command.list", payload, signal),
-				execute: (payload, signal) => this.callUnary("command.execute", payload, signal, "caller-signal-only")
-			};
 			skills = { list: (payload, signal) => this.callUnary("skill.list", payload, signal) };
 			agentPresets = {
 				list: (payload, signal) => this.callUnary("agentPreset.list", payload, signal),
@@ -6415,7 +6449,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 		* TERMINAL_EXIT_STATUS and deliberately absent from this text: the real bash
 		* presenter CONSUMES its `[exit code: N]` marker out of the body, because a
 		* terminal card shows the exit as its own pill and leaving the marker in would
-		* render it twice (packages/bash/tool-bash/src/render.ts).
+		* render it twice (packages/shell/tool-bash/src/render.ts).
 		*/
 		const TERMINAL_OUTPUT_FIXTURE = [
 			sgr(1, "Running 4 checks"),
@@ -6424,7 +6458,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 			`${sgr(32, "✓")} duplication                                        2.10s`,
 			`${sgr(31, "✗")} unit                                               8.41s`,
 			"",
-			sgr(90, "packages/client/ui-primitives/tests/terminal-block.spec.tsx"),
+			sgr(90, "packages/client/ui-primitives/tests/terminal-block.client.spec.tsx"),
 			`  ${sgr(31, "FAIL")} caps output at the configured line budget`,
 			"    expected 16 lines, received 24",
 			"",
@@ -6526,7 +6560,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 			"packages/client/ui-primitives/src/SearchBlock.module.css",
 			"packages/client/ui-tool/src/client/tool/models/search-card-model.ts",
 			"packages/client/ui-tool/src/client/tool/toolviews/search-row.tsx",
-			"packages/client/ui-tool/tests/search-card.spec.tsx"
+			"packages/client/ui-tool/tests/search-card.client.spec.tsx"
 		];
 		/**
 		* The model-facing glob render text — the newline-joined path list plus a
@@ -6688,7 +6722,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 				cacheWriteTokens: turn % 10 === 0 ? 4 : 0
 			};
 		}
-		/** fx-alpha history script: 74 turns (~150+ messages -> 4 pages at PAGE_MESSAGES=50),
+		/** fx-alpha history script: 75 turns (~150+ messages -> 4 pages at PAGE_MESSAGES=50),
 		*  mixing reasoning blocks / tool call+result / context. */
 		function buildAlphaLog() {
 			const events = [];
@@ -7057,6 +7091,45 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 				type: "turn/start",
 				data: { turn: 72 }
 			});
+			push({
+				type: "user/message",
+				surfaceOp: "append",
+				data: userMessage(text("问题 72：请完整列出全部一百条条目。"))
+			});
+			push({
+				type: "step/start",
+				data: {
+					turn: 72,
+					step: 0
+				}
+			});
+			push({
+				type: "assistant/message",
+				surfaceOp: "append",
+				data: {
+					turn: 72,
+					step: 0,
+					message: assistantMessage(text("条目 1：第一条。条目 2：第二条。条目 3：这一条写到一半被"))
+				}
+			});
+			push({
+				type: "step/end",
+				data: {
+					turn: 72,
+					step: 0
+				}
+			});
+			push({
+				type: "turn/end",
+				data: {
+					turn: 72,
+					reason: { kind: "max-tokens" }
+				}
+			});
+			push({
+				type: "turn/start",
+				data: { turn: 73 }
+			});
 			push({
 				type: "user/message",
 				surfaceOp: "append",
@@ -7068,7 +7141,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 			push({
 				type: "step/start",
 				data: {
-					turn: 72,
+					turn: 73,
 					step: 0
 				}
 			});
@@ -7076,7 +7149,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 				type: "assistant/message",
 				surfaceOp: "append",
 				data: {
-					turn: 72,
+					turn: 73,
 					step: 0,
 					message: assistantMessage([...text("结构化模型图片："), {
 						type: "image",
@@ -7087,18 +7160,18 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 			push({
 				type: "step/end",
 				data: {
-					turn: 72,
+					turn: 73,
 					step: 0
 				}
 			});
 			push({
 				type: "turn/end",
 				data: {
-					turn: 72,
+					turn: 73,
 					reason: { kind: "completed" }
 				}
 			});
-			toolTurn(73, "todo_write", JSON.stringify({ todos: fixtureTodos }), "Updated todo list: 1 pending, 2 in progress, 1 completed.");
+			toolTurn(74, "todo_write", JSON.stringify({ todos: fixtureTodos }), "Updated todo list: 1 pending, 2 in progress, 1 completed.");
 			const callIndex = events.length - 4;
 			const callTime = events[callIndex]?.time;
 			events.splice(callIndex + 1, 0, {
@@ -7319,7 +7392,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 			};
 		}
 		/** Fixture parallel of the host's projection units: whole current values per key over the full log. */
-		/** Fixture preset table (the host PermissionService defaults). */
+		/** Fixture preset table (the host PermissionPresetService defaults). */
 		const PERMISSION_PRESETS = {
 			"workspace-write": {
 				sandbox: "workspace-write",
@@ -7405,6 +7478,73 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 			}
 			return totals;
 		}
+		/** Fixture parallel of session-stats' whole-log counting and wall-time fold. */
+		function sessionStatsOf(log) {
+			const value = {
+				turns: 0,
+				steps: 0,
+				llmMs: 0,
+				toolMs: 0,
+				ttftMs: 0,
+				ttftSteps: 0,
+				decodeMs: 0,
+				decodeTokens: 0
+			};
+			let lastTurn = null;
+			let openStep = null;
+			const pendingCalls = /* @__PURE__ */ new Map();
+			for (const event of log) switch (event.type) {
+				case "step/start":
+					openStep = {
+						turn: event.data.turn,
+						step: event.data.step,
+						startTime: event.time,
+						firstTokenTime: null
+					};
+					break;
+				case "assistant/chunk":
+					if (openStep !== null && openStep.turn === event.data.turn && openStep.step === event.data.step && openStep.firstTokenTime === null && isTokenDelta(event.data.chunk)) openStep.firstTokenTime = event.time;
+					break;
+				case "assistant/message":
+					if (openStep === null || openStep.turn !== event.data.turn || openStep.step !== event.data.step) break;
+					value.llmMs += Math.max(0, event.time - openStep.startTime);
+					if (openStep.firstTokenTime !== null) {
+						value.ttftMs += Math.max(0, openStep.firstTokenTime - openStep.startTime);
+						value.ttftSteps += 1;
+						const outputTokens = event.data.usage?.outputTokens;
+						if (typeof outputTokens === "number" && Number.isFinite(outputTokens) && outputTokens >= 0) {
+							value.decodeMs += Math.max(0, event.time - openStep.firstTokenTime);
+							value.decodeTokens += outputTokens;
+						}
+					}
+					openStep = null;
+					break;
+				case "tool/call":
+					pendingCalls.set(event.data.callId, event.time);
+					break;
+				case "tool/result": {
+					const callId = event.data.message.source.callId;
+					const dispatched = pendingCalls.get(callId);
+					if (dispatched === void 0) break;
+					pendingCalls.delete(callId);
+					value.toolMs += Math.max(0, event.time - dispatched);
+					break;
+				}
+				case "step/end":
+					if (event.data.turn !== lastTurn) {
+						value.turns += 1;
+						lastTurn = event.data.turn;
+					}
+					value.steps += 1;
+					openStep = null;
+					break;
+				case "turn/end":
+					pendingCalls.clear();
+					break;
+				default: break;
+			}
+			return value;
+		}
 		/** Fixed token-meter heuristic constants mirrored by this client-only fixture. */
 		const CHARS_PER_TOKEN = 4;
 		const BLOCK_OVERHEAD = 4;
@@ -7474,6 +7614,19 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 			values["tokenUsage"] = tokenUsageOf(log);
 			values["contextPressure"] = contextPressureOf(log);
 			values["contextBreakdown"] = contextBreakdownOf(log);
+			values["sessionStats"] = sessionStatsOf(log);
+			values["imageLimits"] = {
+				maxImageBytes: 5 * 1024 * 1024,
+				maxImagesPerMessage: 20,
+				maxMessageImageBytes: 100 * 1024 * 1024,
+				maxImagePixels: 4e7,
+				mediaTypes: [
+					"image/png",
+					"image/jpeg",
+					"image/webp",
+					"image/gif"
+				]
+			};
 			return values;
 		}
 		/** Host push-frame parallel: emit one session/projection frame per key the given event advanced. */
@@ -7507,6 +7660,13 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 				value: contextBreakdownOf(log),
 				seq: event.seq
 			});
+			if (type === "assistant/message" || type === "tool/result" || type === "step/end") frames.push({
+				type: "session/projection",
+				sessionId: id,
+				key: "sessionStats",
+				value: sessionStatsOf(log),
+				seq: event.seq
+			});
 			if (frames.length > 0) return frames;
 			if (type === "session/title") {
 				const values = projectionValuesOf(log);
@@ -7820,7 +7980,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 				}]
 			]);
 			let fixtureDefaultPreset = "standard";
-			const nextTurn = new Map([[sid("fx-alpha"), 74]]);
+			const nextTurn = new Map([[sid("fx-alpha"), 75]]);
 			let nextSession = 1;
 			let nextRpc = 1;
 			let attachedSessions = options.empty ? 0 : 1;
@@ -8048,6 +8208,200 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 					details: { sessionId: id }
 				}
 			} : void 0;
+			/** Canonical fixture implementation of the generated Commands Remote contract. */
+			const commandRemotes = {
+				list(id) {
+					const missing = requireGoalSession(id);
+					if (missing !== void 0) return missing;
+					return {
+						ok: true,
+						value: [
+							{
+								name: "compact",
+								description: "fixture：压缩当前会话上下文"
+							},
+							{
+								name: "echo",
+								description: "fixture：回显参数",
+								input: { hint: "text to echo" }
+							},
+							{
+								name: "goal",
+								description: "set or view the goal for a long-running task",
+								input: { hint: "<objective>" }
+							},
+							{
+								name: "permission",
+								description: "Switch the permission preset (sandbox mode + approval policy)",
+								input: { hint: "<preset>" }
+							},
+							{
+								name: "plan",
+								description: "Enter or leave plan mode",
+								input: { hint: "[off|message]" }
+							}
+						]
+					};
+				},
+				execute(id, line) {
+					const missing = requireGoalSession(id);
+					if (missing !== void 0) return missing;
+					const match = /^\/(\S+)((?:\s.*)?)$/.exec(line.trim());
+					const name = match?.[1];
+					const args = match?.[2] ?? "";
+					if (name === "permission") {
+						const preset = args.trim();
+						const commandId = `fx-cmd-${logOf(id).length}`;
+						append(id, {
+							type: "command/run",
+							data: {
+								commandId,
+								name,
+								args,
+								source: { kind: "user" }
+							}
+						});
+						const spec = PERMISSION_PRESETS[preset];
+						let result;
+						if (preset === "") result = {
+							kind: "success",
+							text: `current preset ${permissionSelectOf(logOf(id)).currentValue} (available: ${Object.keys(PERMISSION_PRESETS).join(", ")})`
+						};
+						else if (spec === void 0) result = {
+							kind: "error",
+							text: `unknown preset "${preset}" (available: ${Object.keys(PERMISSION_PRESETS).join(", ")})`
+						};
+						else {
+							if (permissionSelectOf(logOf(id)).currentValue !== preset) append(id, {
+								type: "permission/preset",
+								data: { preset }
+							});
+							append(id, {
+								type: "sandbox/mode",
+								data: { mode: spec.sandbox }
+							});
+							append(id, {
+								type: "approval/policy",
+								data: { policy: spec.approval }
+							});
+							result = {
+								kind: "success",
+								text: `preset ${preset}`
+							};
+						}
+						append(id, {
+							type: "command/done",
+							data: {
+								commandId,
+								...result
+							}
+						});
+						return {
+							ok: true,
+							value: {
+								commandId,
+								result
+							}
+						};
+					}
+					if (name === "goal") {
+						const commandId = `fx-cmd-${logOf(id).length}`;
+						append(id, {
+							type: "command/run",
+							data: {
+								commandId,
+								name,
+								args,
+								source: { kind: "user" }
+							}
+						});
+						const objective = args.trim();
+						const current = backscanGoal(logOf(id));
+						let text;
+						if (objective === "") text = current === null ? "No goal is set. Usage: /goal <objective>" : `Current goal: ${current.goal.objective}`;
+						else if (current !== null && current.goal.phase !== "complete") text = `A goal already exists (${current.goal.objective}). Clear it first.`;
+						else text = `Goal created: ${appendGoalChange(id, {
+							kind: "goal/change",
+							version: 1,
+							operation: "create",
+							goal: {
+								id: `fx-goal-${logOf(id).length}`,
+								revision: 1,
+								objective,
+								phase: "active",
+								maxGoalRounds: 256
+							},
+							roundsStarted: 0,
+							createdAt: Date.now(),
+							updatedAt: Date.now()
+						}).goal.objective}`;
+						const result = {
+							kind: "success",
+							text
+						};
+						append(id, {
+							type: "command/done",
+							data: {
+								commandId,
+								...result
+							}
+						});
+						return {
+							ok: true,
+							value: {
+								commandId,
+								result
+							}
+						};
+					}
+					const running = summaryOf(id)?.running === true;
+					const outcomes = {
+						compact: "fixture：已压缩（假动作）",
+						echo: args.trim(),
+						plan: args.trim() === "off" ? running ? "Leaving plan mode (applies from the next step)." : "Plan mode off." : running ? "Entering plan mode (applies from the next step). Use /plan off to leave." : "Plan mode on. Use /plan off to leave."
+					};
+					const text = name === void 0 ? void 0 : outcomes[name];
+					if (name === void 0 || text === void 0) return {
+						ok: true,
+						value: void 0
+					};
+					const commandId = `fx-cmd-${logOf(id).length}`;
+					append(id, {
+						type: "command/run",
+						data: {
+							commandId,
+							name,
+							args,
+							source: { kind: "user" }
+						}
+					});
+					if (name === "plan" && !running) {
+						const plan = foldPlan(logOf(id));
+						if (plan.wanted !== null && plan.wanted !== plan.active) append(id, {
+							type: "plan/mode",
+							data: { active: plan.wanted }
+						});
+					}
+					const result = {
+						kind: "success",
+						...text === "" ? {} : { text }
+					};
+					append(id, {
+						type: "command/done",
+						data: {
+							commandId,
+							...result
+						}
+					});
+					return {
+						ok: true,
+						value: {
+							commandId,
+							result
+						}
+					};
+				}
+			};
 			const goalView = (projection) => ({
 				...projection.goal,
 				roundsStarted: projection.roundsStarted,
@@ -9079,6 +9433,30 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 							});
 							return ok(request, { deleted: true });
 						},
+						insertBefore: (request) => {
+							const { workspaceId, beforeWorkspaceId } = request.payload;
+							const source = workspaces.findIndex((workspace) => workspace.workspaceId === workspaceId);
+							const anchor = beforeWorkspaceId === void 0 ? workspaces.length : workspaces.findIndex((workspace) => workspace.workspaceId === beforeWorkspaceId);
+							const missing = source === -1 ? workspaceId : anchor === -1 ? beforeWorkspaceId : void 0;
+							if (missing !== void 0) return err(request, {
+								code: "workspace-not-found",
+								message: `no workspace ${missing}`,
+								details: { workspaceId: missing }
+							});
+							if (beforeWorkspaceId !== workspaceId) {
+								const previousOrder = workspaces.map((candidate) => candidate.workspaceId);
+								const [workspace] = workspaces.splice(source, 1);
+								/* v8 ignore next -- source was resolved from the same array immediately above. */
+								if (workspace === void 0) throw new Error(`fixture lost workspace ${workspaceId}`);
+								const at = beforeWorkspaceId === void 0 ? workspaces.length : workspaces.findIndex((candidate) => candidate.workspaceId === beforeWorkspaceId);
+								workspaces.splice(at, 0, workspace);
+								if (workspaces.some((candidate, index) => candidate.workspaceId !== previousOrder[index])) emitHost({
+									type: "host/workspace-order-changed",
+									workspaceIds: workspaces.map((candidate) => candidate.workspaceId)
+								});
+							}
+							return ok(request, { workspaceIds: workspaces.map((candidate) => candidate.workspaceId) });
+						},
 						insertSessionBefore: (request) => {
 							const { workspaceId, sessionId, beforeSessionId } = request.payload;
 							const workspace = workspaces.find((w) => w.workspaceId === workspaceId);
@@ -9127,185 +9505,6 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 							return ok(request, { archivedSessionIds: [...archivedSessionIds] });
 						}
 					},
-					commands: {
-						list: (request) => {
-							const missing = requireSession(request);
-							if (missing !== void 0) return missing;
-							return ok(request, { commands: [
-								{
-									name: "compact",
-									description: "fixture：压缩当前会话上下文"
-								},
-								{
-									name: "echo",
-									description: "fixture：回显参数",
-									input: { hint: "text to echo" }
-								},
-								{
-									name: "goal",
-									description: "set or view the goal for a long-running task",
-									input: { hint: "<objective>" }
-								},
-								{
-									name: "permission",
-									description: "Switch the permission preset (sandbox mode + approval policy)",
-									input: { hint: "<preset>" }
-								},
-								{
-									name: "plan",
-									description: "Enter or leave plan mode",
-									input: { hint: "[off|message]" }
-								}
-							] });
-						},
-						execute: (request) => {
-							const missing = requireSession(request);
-							if (missing !== void 0) return missing;
-							const id = request.payload.sessionId;
-							const match = /^\/(\S+)((?:\s.*)?)$/.exec(request.payload.line.trim());
-							const name = match?.[1];
-							const args = match?.[2] ?? "";
-							if (name === "permission") {
-								const preset = args.trim();
-								const commandId = `fx-cmd-${logOf(id).length}`;
-								append(id, {
-									type: "command/run",
-									data: {
-										commandId,
-										name,
-										args,
-										source: { kind: "user" }
-									}
-								});
-								const spec = PERMISSION_PRESETS[preset];
-								if (preset === "") {
-									const current = permissionSelectOf(logOf(id)).currentValue;
-									append(id, {
-										type: "command/done",
-										data: {
-											commandId,
-											kind: "success",
-											text: `current preset ${current} (available: ${Object.keys(PERMISSION_PRESETS).join(", ")})`
-										}
-									});
-								} else if (spec === void 0) append(id, {
-									type: "command/done",
-									data: {
-										commandId,
-										kind: "error",
-										text: `unknown preset "${preset}" (available: ${Object.keys(PERMISSION_PRESETS).join(", ")})`
-									}
-								});
-								else {
-									if (permissionSelectOf(logOf(id)).currentValue !== preset) append(id, {
-										type: "permission/preset",
-										data: { preset }
-									});
-									append(id, {
-										type: "sandbox/mode",
-										data: { mode: spec.sandbox }
-									});
-									append(id, {
-										type: "approval/policy",
-										data: { policy: spec.approval }
-									});
-									append(id, {
-										type: "command/done",
-										data: {
-											commandId,
-											kind: "success",
-											text: `preset ${preset}`
-										}
-									});
-								}
-								return ok(request, {
-									matched: true,
-									commandId
-								});
-							}
-							if (name === "goal") {
-								const commandId = `fx-cmd-${logOf(id).length}`;
-								append(id, {
-									type: "command/run",
-									data: {
-										commandId,
-										name,
-										args,
-										source: { kind: "user" }
-									}
-								});
-								const objective = args.trim();
-								const current = backscanGoal(logOf(id));
-								let text;
-								if (objective === "") text = current === null ? "No goal is set. Usage: /goal <objective>" : `Current goal: ${current.goal.objective}`;
-								else if (current !== null && current.goal.phase !== "complete") text = `A goal already exists (${current.goal.objective}). Clear it first.`;
-								else text = `Goal created: ${appendGoalChange(id, {
-									kind: "goal/change",
-									version: 1,
-									operation: "create",
-									goal: {
-										id: `fx-goal-${logOf(id).length}`,
-										revision: 1,
-										objective,
-										phase: "active",
-										maxGoalRounds: 256
-									},
-									roundsStarted: 0,
-									createdAt: Date.now(),
-									updatedAt: Date.now()
-								}).goal.objective}`;
-								append(id, {
-									type: "command/done",
-									data: {
-										commandId,
-										kind: "success",
-										text
-									}
-								});
-								return ok(request, {
-									matched: true,
-									commandId
-								});
-							}
-							const running = summaryOf(id)?.running === true;
-							const outcomes = {
-								compact: "fixture：已压缩（假动作）",
-								echo: args.trim(),
-								plan: args.trim() === "off" ? running ? "Leaving plan mode (applies from the next step)." : "Plan mode off." : running ? "Entering plan mode (applies from the next step). Use /plan off to leave." : "Plan mode on. Use /plan off to leave."
-							};
-							const text = name === void 0 ? void 0 : outcomes[name];
-							if (name === void 0 || text === void 0) return ok(request, { matched: false });
-							const commandId = `fx-cmd-${logOf(id).length}`;
-							append(id, {
-								type: "command/run",
-								data: {
-									commandId,
-									name,
-									args,
-									source: { kind: "user" }
-								}
-							});
-							if (name === "plan" && !running) {
-								const plan = foldPlan(logOf(id));
-								if (plan.wanted !== null && plan.wanted !== plan.active) append(id, {
-									type: "plan/mode",
-									data: { active: plan.wanted }
-								});
-							}
-							append(id, {
-								type: "command/done",
-								data: {
-									commandId,
-									kind: "success",
-									...text === "" ? {} : { text }
-								}
-							});
-							return ok(request, {
-								matched: true,
-								commandId
-							});
-						}
-					},
 					agentPresets: {
 						list: (request) => ok(request, {
 							presets: [...fixturePresets].map(([id, preset]) => ({
@@ -9632,6 +9831,8 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 					const args = payload.args;
 					const sessionId = args.agentId;
 					switch (endpoint) {
+						case "commands/list": return Promise.resolve(commandRemotes.list(sessionId));
+						case "commands/execute": return Promise.resolve(commandRemotes.execute(sessionId, args.line));
 						case "goals/create": return Promise.resolve(goalRemotes.create(sessionId, {
 							objective: args.request?.objective,
 							...args.request?.maxGoalRounds === void 0 ? {} : { maxGoalRounds: args.request.maxGoalRounds }
@@ -9712,10 +9913,9 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 					case "workspace.create": return this.api.workspace.create(request);
 					case "workspace.rename": return this.api.workspace.rename(request);
 					case "workspace.delete": return this.api.workspace.delete(request);
+					case "workspace.insertBefore": return this.api.workspace.insertBefore(request);
 					case "workspace.insertSessionBefore": return this.api.workspace.insertSessionBefore(request);
 					case "workspace.archiveSession": return this.api.workspace.archiveSession(request);
-					case "command.list": return this.api.commands.list(request);
-					case "command.execute": return this.api.commands.execute(request, signal);
 					case "skill.list": return this.api.skills.list(request);
 					case "agentPreset.list": return this.api.agentPresets.list(request);
 					case "agentPreset.select": return this.api.agentPresets.select(request);

package/lib/index.js

@@ -22,6 +22,11 @@ const HOST_EVENTS_PATH = `${API_PATH}/events.host`;
 * node:http ↔ WHATWG fetch bridge for the /api transport (host side of the
 * web carrier; the fetch-shaped handler itself is transport-agnostic).
 */
+/** Default carrier cap for all HTTP RPC bodies: sized for the default
+* aggregate image limit (100 MiB) after base64 expansion plus envelope
+* headroom (~134.3 MiB required), rounded up for slack. The bridge buffers
+* each body in memory, so this cap is also the per-request resident bound. */
+const DEFAULT_MAX_REQUEST_BODY_BYTES = 160 * 1024 * 1024;
 /**
 * Bridge one node:http request to the fetch-shaped handler (client close
 * aborts; SSE bodies stream out chunk by chunk).
@@ -30,7 +35,7 @@ const HOST_EVENTS_PATH = `${API_PATH}/events.host`;
 * @param apiHandler - fetch-shaped API carrier the request is dispatched to.
 * @param maxRequestBodyBytes - maximum body bytes buffered before dispatch.
 */
-async function bridge(req, res, apiHandler, maxRequestBodyBytes = 32 * 1024 * 1024) {
+async function bridge(req, res, apiHandler, maxRequestBodyBytes = DEFAULT_MAX_REQUEST_BODY_BYTES) {
 	const abort = new AbortController();
 	res.on("close", () => {
 		if (!res.writableEnded) abort.abort();
@@ -249,7 +254,7 @@ var HostConnectionService = class extends Service {
 				await bridge(req, res, fetchHandler);
 			}
 		};
-		return owner.effect(() => owner.httpServer.register(route), `client-connection: ${channel} rpc channel`);
+		return owner.effect(() => owner.webServer.register(route), `client-connection: ${channel} rpc channel`);
 	}
 	registerInterceptor(owner, channel, matches, handler, options) {
 		if (channel !== "/api") throw new Error(`connection: invalid shared RPC channel ${JSON.stringify(channel)}`);
@@ -470,10 +475,8 @@ function assertImageBodyCapacity(ctx, maxRequestBodyBytes) {
 	const requiredImageBodyBytes = Math.ceil(attachments.imageLimits.maxMessageImageBytes * 4 / 3) + REQUEST_ENVELOPE_HEADROOM_BYTES;
 	if (maxRequestBodyBytes < requiredImageBodyBytes) throw new Error(`client-connection maxRequestBodyBytes (${String(maxRequestBodyBytes)}) must be at least ${String(requiredImageBodyBytes)} for the configured aggregate image limit`);
 }
-/** Default carrier cap for all HTTP RPC bodies. */
-const DEFAULT_MAX_REQUEST_BODY_BYTES = 32 * 1024 * 1024;
 /** Services required before providing Connection; API Proxy is an optional `/api` fallback. */
-const inject = ["httpServer"];
+const inject = ["webServer"];
 const Config = z.object({
 	trustedHosts: z.array(String).default([]),
 	maxRequestBodyBytes: z.natural().min(1).default(DEFAULT_MAX_REQUEST_BODY_BYTES)
@@ -526,7 +529,7 @@ const PRIVILEGED_METHODS = new Set([
 */
 function apply(ctx, config) {
 	const trustedHosts = config?.trustedHosts ?? [];
-	const maxRequestBodyBytes = config?.maxRequestBodyBytes ?? DEFAULT_MAX_REQUEST_BODY_BYTES;
+	const maxRequestBodyBytes = config?.maxRequestBodyBytes ?? 167772160;
 	for (const entry of trustedHosts) assertTrustedAuthority(entry);
 	if (ctx.get("apiProxy") !== void 0) assertImageBodyCapacity(ctx, maxRequestBodyBytes);
 	const fetchHandler = new HostConnectionService(ctx, trustedHosts).createSharedFetchHandler(API_PATH, { async fetch(request) {
@@ -556,12 +559,12 @@ function apply(ctx, config) {
 			await bridge(req, res, fetchHandler, maxRequestBodyBytes);
 		}
 	};
-	ctx.effect(() => ctx.httpServer.register(route), "client-connection: /api route");
+	ctx.effect(() => ctx.webServer.register(route), "client-connection: /api route");
 	ctx.inject(["apiProxy"], (apiCtx) => {
 		assertImageBodyCapacity(apiCtx, maxRequestBodyBytes);
 		const downlinks = new WebSocketDownlinks(apiCtx.apiProxy);
 		const registerDownlink = (path, handle) => {
-			apiCtx.effect(() => apiCtx.httpServer.registerUpgrade({
+			apiCtx.effect(() => apiCtx.webServer.registerUpgrade({
 				path,
 				handler: (req, socket, head) => {
 					if (!isTrustedApiRequest(req, trustedHosts)) {

package/lib/types/client/api.d.ts

@@ -1,4 +1,4 @@
-export type { ApiProxy, SessionsApi, SessionSearchItem, SessionSummary, PromptContentPart, HostApi, EventsApi, MuxFrame, HostFrame, ApprovalResponsePayload, QuestionResponsePayload, HistoryEntry, ToolEventView, DirectoryEntry, DirectoryListing, ResponseValue, WorkspaceApi, WorkspaceId, WorkspaceView, CommandsApi, CommandDescriptor, SkillsApi, SkillEntry, ModelCatalogFailure, ModelCatalogModel, ModelProviderGroup, ModelReasoning, ModelReasoningEffort, ModelSelection, QueueAction, QueuedInboxItem, SessionModels, GoalsApi, GoalRef, SettingsApi, SettingsNamespaceView, SettingsPathOpView, SettingsSecretView, CredentialsApi, CredentialView, ConfigurableProviderView, DiscoveredModelView, LlmApi, SubagentsApi, SubagentAddress, SubagentCatalog, SubagentListEntry, SubagentPromptReceipt, TaskView, } from '@deepseek-ai/dsh-host-apiproxy/api';
+export type { ApiProxy, SessionsApi, SessionSearchItem, SessionSummary, PromptContentPart, HostApi, EventsApi, MuxFrame, HostFrame, ApprovalResponsePayload, QuestionResponsePayload, HistoryEntry, ToolEventView, DirectoryEntry, DirectoryListing, ResponseValue, WorkspaceApi, WorkspaceId, WorkspaceView, SkillsApi, SkillEntry, ModelCatalogFailure, ModelCatalogModel, ModelProviderGroup, ModelReasoning, ModelReasoningEffort, ModelSelection, QueueAction, QueuedInboxItem, SessionModels, GoalsApi, GoalRef, SettingsApi, SettingsNamespaceView, SettingsPathOpView, SettingsSecretView, CredentialsApi, CredentialView, ConfigurableProviderView, DiscoveredModelView, LlmApi, SubagentsApi, SubagentAddress, SubagentCatalog, SubagentListEntry, SubagentPromptReceipt, JobView, } from '@deepseek-ai/dsh-host-apiproxy/api';
 export type { ToolCallView, ToolResultView } from '@deepseek-ai/dsh-tools/presentation';
 export type { RpcRequest, RpcResponse, RpcResult, RpcError, RpcErrorCode, ClientRequest, ServerResponse, ServerRequest, ClientResponse, RpcMessage, RpcReceipt, } from '@deepseek-ai/dsh-host-apiproxy/api';
 export { RpcId, SESSION_SEARCH_RESULT_LIMIT, transportError, } from '@deepseek-ai/dsh-host-apiproxy/api';

package/lib/types/client/fixture.d.ts

@@ -22,6 +22,20 @@ export interface FixtureOptions {
  * @returns an ApiProxy backed entirely by in-memory state — no host process, no network.
  */
 export declare function createFixtureApi(options?: FixtureOptions): ApiProxy;
+/** Both fixture faces over one state graph. */
+export interface FixtureWorld {
+    /** Legacy unary/stream API the fixture still answers. */
+    readonly api: ApiProxy;
+    /** Generic Remote caller for the endpoints business services own. */
+    readonly rpc: ClientConnectionRpc;
+}
+/**
+ * Build both fixture faces so a caller can drive the Remote endpoints and the
+ * legacy API against one in-memory state graph.
+ * @param options - fixture branches for empty state and failure timing.
+ * @returns the legacy API face and the Remote RPC face.
+ */
+export declare function createFixtureFaces(options?: FixtureOptions): FixtureWorld;
 /**
  * Fixture platform subclass: there is no HTTP at all, so instead of a doFetch transport it
  * overrides the protocol-level virtuals (callUnary/openMux/openHost/respond) to dispatch

package/lib/types/client/index.d.ts

@@ -7,7 +7,7 @@ import type { Context } from '@deepseek-ai/cordis';
 import type { HostDescription, IApiClient } from './api.ts';
 import { type ConnectionConfig, type ConnectionSinks, type ConnectionState } from './connection.ts';
 import type { ClientConnectionRpc } from '../rpc.ts';
-export type { ApiProxy, SessionsApi, SessionSearchItem, SessionSummary, PromptContentPart, HostApi, EventsApi, MuxFrame, HostFrame, ApprovalResponsePayload, QuestionResponsePayload, HistoryEntry, ToolEventView, DirectoryEntry, DirectoryListing, ToolCallView, ToolResultView, WorkspaceApi, WorkspaceId, WorkspaceView, CommandsApi, CommandDescriptor, SkillsApi, SkillEntry, ModelCatalogFailure, ModelCatalogModel, ModelProviderGroup, ModelReasoning, MessageId, ModelReasoningEffort, ModelSelection, QueueAction, QueuedInboxItem, SessionModels, SubagentsApi, SubagentAddress, SubagentCatalog, SubagentListEntry, SubagentPromptReceipt, TaskView, RpcRequest, RpcResponse, RpcResult, RpcError, RpcErrorCode, ClientRequest, ServerResponse, ServerRequest, ClientResponse, RpcMessage, RpcReceipt, HostDescription, IApiClient, SessionId, SessionEvent, ContentBlock, StreamChunk, GoalsApi, GoalRef, SettingsApi, SettingsNamespaceView, SettingsPathOpView, SettingsSecretView, CredentialsApi, CredentialView, ConfigurableProviderView, DiscoveredModelView, LlmApi, } from './api.ts';
+export type { ApiProxy, SessionsApi, SessionSearchItem, SessionSummary, PromptContentPart, HostApi, EventsApi, MuxFrame, HostFrame, ApprovalResponsePayload, QuestionResponsePayload, HistoryEntry, ToolEventView, DirectoryEntry, DirectoryListing, ToolCallView, ToolResultView, WorkspaceApi, WorkspaceId, WorkspaceView, SkillsApi, SkillEntry, ModelCatalogFailure, ModelCatalogModel, ModelProviderGroup, ModelReasoning, MessageId, ModelReasoningEffort, ModelSelection, QueueAction, QueuedInboxItem, SessionModels, SubagentsApi, SubagentAddress, SubagentCatalog, SubagentListEntry, SubagentPromptReceipt, JobView, RpcRequest, RpcResponse, RpcResult, RpcError, RpcErrorCode, ClientRequest, ServerResponse, ServerRequest, ClientResponse, RpcMessage, RpcReceipt, HostDescription, IApiClient, SessionId, SessionEvent, ContentBlock, StreamChunk, GoalsApi, GoalRef, SettingsApi, SettingsNamespaceView, SettingsPathOpView, SettingsSecretView, CredentialsApi, CredentialView, ConfigurableProviderView, DiscoveredModelView, LlmApi, } from './api.ts';
 export { RpcId, AbstractApiClient, transportError, } from './api.ts';
 export type { ConnectionConfig, ConnectionSinks, ConnectionState };
 export type { ClientConnectionRpc } from '../rpc.ts';

package/lib/types/http-bridge.d.ts

@@ -3,6 +3,11 @@
  * web carrier; the fetch-shaped handler itself is transport-agnostic).
  */
 import type { IncomingMessage, ServerResponse } from 'node:http';
+/** Default carrier cap for all HTTP RPC bodies: sized for the default
+ * aggregate image limit (100 MiB) after base64 expansion plus envelope
+ * headroom (~134.3 MiB required), rounded up for slack. The bridge buffers
+ * each body in memory, so this cap is also the per-request resident bound. */
+export declare const DEFAULT_MAX_REQUEST_BODY_BYTES: number;
 /** Transport-independent request handler consumed by the Host HTTP bridge. */
 export interface FetchHandler {
     /**

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@deepseek-ai/dsh-client-connection",
   "description": "Wire consumer layer: HTTP-up/WebSocket-down client, ConnectionController dual streams with reconnect, and fixture api",
-  "version": "0.0.1-rc.2",
+  "version": "0.0.1-rc.3",
   "publishConfig": {
     "access": "restricted"
   },
@@ -39,13 +39,13 @@
   "license": "BSD-3-Clause",
   "dependencies": {
     "ws": "^8.21.0",
-    "@deepseek-ai/dsh-commands": "^0.0.1-rc.2",
-    "@deepseek-ai/dsh-attachment": "^0.0.1-rc.2",
-    "@deepseek-ai/dsh-host-apiproxy": "^0.0.1-rc.2",
-    "@deepseek-ai/dsh-session": "^0.0.1-rc.2",
-    "@deepseek-ai/dsh-tools": "^0.0.1-rc.2",
-    "@deepseek-ai/schemastery": "^3.18.1-rc.1",
-    "@deepseek-ai/dsh-llm": "^0.0.1-rc.2"
+    "@deepseek-ai/dsh-attachment": "^0.0.1-rc.3",
+    "@deepseek-ai/dsh-host-apiproxy": "^0.0.1-rc.3",
+    "@deepseek-ai/dsh-commands": "^0.0.1-rc.3",
+    "@deepseek-ai/dsh-llm": "^0.0.1-rc.3",
+    "@deepseek-ai/dsh-session": "^0.0.1-rc.3",
+    "@deepseek-ai/dsh-tools": "^0.0.1-rc.3",
+    "@deepseek-ai/schemastery": "^3.18.1-rc.1"
   },
   "files": [
     "lib/index.js",
@@ -54,14 +54,14 @@
     "lib/types/**/*.d.ts"
   ],
   "peerDependencies": {
-    "@deepseek-ai/dsh-host-webserver": "^0.0.1-rc.2",
-    "@deepseek-ai/dsh-invariants": "^0.0.1-rc.2",
+    "@deepseek-ai/dsh-host-webserver": "^0.0.1-rc.3",
+    "@deepseek-ai/dsh-invariants": "^0.0.1-rc.3",
     "@deepseek-ai/cordis": "^4.0.1-rc.1"
   },
   "devDependencies": {
     "@types/ws": "^8.18.1",
-    "@deepseek-ai/dsh-host-webserver": "^0.0.1-rc.2",
-    "@deepseek-ai/cordis": "^4.0.1-rc.1",
-    "@deepseek-ai/dsh-invariants": "^0.0.1-rc.2"
+    "@deepseek-ai/dsh-host-webserver": "^0.0.1-rc.3",
+    "@deepseek-ai/dsh-invariants": "^0.0.1-rc.3",
+    "@deepseek-ai/cordis": "^4.0.1-rc.1"
   }
 }