@songtonyli/dsh-cli 0.1.12 → 0.1.13

package/node_modules/@deepseek-ai/dsh-agent-presets/presets/ptc/agent.cordis.yml

@@ -281,3 +281,7 @@
 
 - id: present
   name: '@deepseek-ai/dsh-tool-present'
+
+- id: tool-plugin-manager
+  name: '@deepseek-ai/dsh-plugin-manager/tools'
+  disabled: true

package/node_modules/@deepseek-ai/dsh-agent-presets/presets/standard/agent.cordis.yml

@@ -260,3 +260,7 @@
 
 - id: present
   name: '@deepseek-ai/dsh-tool-present'
+
+- id: tool-plugin-manager
+  name: '@deepseek-ai/dsh-plugin-manager/tools'
+  disabled: true

package/node_modules/@deepseek-ai/dsh-agent-tool-presentation/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@deepseek-ai/dsh-agent-tool-presentation",
   "description": "Agent-plane presentation selector: composes one agent's tools as PTC mode, native, or both",
-  "version": "0.1.6-alpha.1",
+  "version": "0.1.6-alpha.2",
   "publishConfig": {
     "access": "public"
   },
@@ -30,16 +30,16 @@
     "@deepseek-ai/schemastery": "3.18.2"
   },
   "peerDependencies": {
-    "@deepseek-ai/dsh-tools": "0.1.6-alpha.1",
+    "@deepseek-ai/dsh-tools": "0.1.6-alpha.2",
     "@deepseek-ai/cordis": "4.0.2"
   },
   "devDependencies": {
-    "@deepseek-ai/dsh-agent": "0.1.6-alpha.1",
-    "@deepseek-ai/dsh-ptc-runtime": "0.1.6-alpha.1",
-    "@deepseek-ai/dsh-scope": "0.1.6-alpha.1",
-    "@deepseek-ai/dsh-session": "0.1.6-alpha.1",
-    "@deepseek-ai/dsh-system-prompt": "0.1.6-alpha.1",
-    "@deepseek-ai/dsh-tools": "0.1.6-alpha.1",
+    "@deepseek-ai/dsh-agent": "0.1.6-alpha.2",
+    "@deepseek-ai/dsh-ptc-runtime": "0.1.6-alpha.2",
+    "@deepseek-ai/dsh-scope": "0.1.6-alpha.2",
+    "@deepseek-ai/dsh-session": "0.1.6-alpha.2",
+    "@deepseek-ai/dsh-system-prompt": "0.1.6-alpha.2",
+    "@deepseek-ai/dsh-tools": "0.1.6-alpha.2",
     "@deepseek-ai/cordis": "4.0.2"
   }
 }

package/node_modules/@deepseek-ai/dsh-anonymous-user-id/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@deepseek-ai/dsh-anonymous-user-id",
   "description": "Shared anonymous user identity for DeepSeek Harness telemetry and feedback correlation",
-  "version": "0.1.6-alpha.1",
+  "version": "0.1.6-alpha.2",
   "publishConfig": {
     "access": "public"
   },
@@ -27,13 +27,13 @@
   ],
   "license": "MIT",
   "peerDependencies": {
-    "@deepseek-ai/dsh-brand": "0.1.6-alpha.1",
-    "@deepseek-ai/dsh-home-paths": "0.1.6-alpha.1",
+    "@deepseek-ai/dsh-brand": "0.1.6-alpha.2",
+    "@deepseek-ai/dsh-home-paths": "0.1.6-alpha.2",
     "@deepseek-ai/cordis": "4.0.2"
   },
   "devDependencies": {
-    "@deepseek-ai/dsh-brand": "0.1.6-alpha.1",
-    "@deepseek-ai/dsh-home-paths": "0.1.6-alpha.1",
+    "@deepseek-ai/dsh-brand": "0.1.6-alpha.2",
+    "@deepseek-ai/dsh-home-paths": "0.1.6-alpha.2",
     "@deepseek-ai/cordis": "4.0.2"
   }
 }

package/node_modules/@deepseek-ai/dsh-api-authorization-controller/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@deepseek-ai/dsh-api-authorization-controller",
   "description": "Remote owner for browser sign-in over the authorization seam: flow listing, streamed attempts, prompt answers, and sign-out",
-  "version": "0.1.6-alpha.1",
+  "version": "0.1.6-alpha.2",
   "publishConfig": {
     "access": "public"
   },
@@ -48,19 +48,19 @@
   },
   "peerDependencies": {
     "@deepseek-ai/cordis": "4.0.2",
-    "@deepseek-ai/dsh-authorization": "0.1.6-alpha.1",
-    "@deepseek-ai/dsh-credentials": "0.1.6-alpha.1",
-    "@deepseek-ai/dsh-typert-protocol": "0.1.6-alpha.1"
+    "@deepseek-ai/dsh-authorization": "0.1.6-alpha.2",
+    "@deepseek-ai/dsh-credentials": "0.1.6-alpha.2",
+    "@deepseek-ai/dsh-typert-protocol": "0.1.6-alpha.2"
   },
   "devDependencies": {
     "@deepseek-ai/cordis": "4.0.2",
     "@deepseek-ai/cordis-plugin-include": "1.0.7",
     "@deepseek-ai/cordis-plugin-loader": "1.0.3",
-    "@deepseek-ai/dsh-authorization": "0.1.6-alpha.1",
-    "@deepseek-ai/dsh-credentials": "0.1.6-alpha.1",
-    "@deepseek-ai/dsh-credentials-local": "0.1.6-alpha.1",
-    "@deepseek-ai/dsh-llm": "0.1.6-alpha.1",
-    "@deepseek-ai/dsh-llm-pi-ai": "0.1.6-alpha.1",
-    "@deepseek-ai/dsh-typert-protocol": "0.1.6-alpha.1"
+    "@deepseek-ai/dsh-authorization": "0.1.6-alpha.2",
+    "@deepseek-ai/dsh-credentials": "0.1.6-alpha.2",
+    "@deepseek-ai/dsh-credentials-local": "0.1.6-alpha.2",
+    "@deepseek-ai/dsh-llm": "0.1.6-alpha.2",
+    "@deepseek-ai/dsh-llm-pi-ai": "0.1.6-alpha.2",
+    "@deepseek-ai/dsh-typert-protocol": "0.1.6-alpha.2"
   }
 }

package/node_modules/@deepseek-ai/dsh-api-gateway/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/api/gateway/README.md
-README.md: 561081c3a5de716e563eaa9764f387e329365504
-README.zh.md: 9588b194efc64d14a17a69323a14d6118d0e7d7e
+README.md: 1460f5a27062ffcac09c68358dc7b186241a1baa
+README.zh.md: 79ed379faad8498cfdf249a0accb437f6d5f98e3

package/node_modules/@deepseek-ai/dsh-api-gateway/README.md

@@ -24,7 +24,7 @@ Two-sided Typert RPC endpoint for Host and Client Cordis environments. The Host
 <a id="host-service-typertgatewayservice-ctx-key-typertgateway"></a>
 ## Host service: `TypertGatewayService` (ctx key: `typertGateway`)
 
-`ctx.typertGateway.invoke()` resolves the current descriptor and Cordis Service for each call, validates exact named arguments, resolves registered object or Context identities, invokes the public business method, and validates its result. Business Services extend `TypertRemoteService` and mark methods with `@Remote` or `@RemoteScope` from [`dsh-typert-protocol`](../../typert/protocol/README.md); `bindTypertRemote()` remains available when another base class owns inheritance.
+`ctx.typertGateway.invoke()` resolves the current descriptor and Cordis Service for each call, validates exact named arguments, resolves registered object or Context identities, and invokes the public business method. Business Services extend `TypertRemoteService` and mark methods with `@Remote` or `@RemoteScope` from [`dsh-typert-protocol`](../../typert/protocol/README.md); `bindTypertRemote()` remains available when another base class owns inheritance.
 
 Strict mode reads generated invocation descriptors from `ctx.typert.local`. Lookup parameters use the currently active resolver in `ctx.typert.lookups`: the business package registers the stable declaration and default policy, while Host composition can override resolution behavior with effect-scoped `configure()`; `@RemoteScope` resolves its receiver through a registered Host Context adapter. SRC mode is a development fallback for endpoints that have never had a strict definition; it parses simple parameter names and accepts only JSON-safe values for non-lookup parameters. Withdrawing an observed strict definition fails instead of weakening validation.
 
@@ -32,16 +32,18 @@ The Host entry registers a trusted-host interceptor on Connection's shared `/api
 
 A cancellation-aware Remote method declares `signal: AbortSignal` as its final Host parameter. The signal is descriptor metadata rather than a wire argument: Connection supplies it to the Gateway, and the Gateway injects it after decoded business parameters. SRC recognizes the reserved final name, while strict generation additionally requires the global `AbortSignal` type.
 
-A stream Remote uses `@Remote({ mode: 'stream' })` and returns an `Iterable` or `AsyncIterable`. `ctx.typertGateway.stream()` applies the same endpoint, argument, lookup, and cancellation checks as unary invocation, then validates each yielded item with the generated result codec. The Client opens the Gateway-owned `/api/remote.mux` WebSocket when its plugin activates and keeps it connected while idle. Connection owns the retry schedule; before each retry it asks the mux to cancel any candidate or active socket and make exactly one fresh physical attempt. The Host sends Ping control frames at the configured `websocketHeartbeatIntervalMs` interval (two seconds by default), and the browser answers Pong at the WebSocket protocol layer, so idle network intermediaries see traffic without any Remote stream frame. A socket that has not answered the previous Ping is terminated at the next interval. Independently cancellable logical streams share that socket; an in-process Connection carrier provides equivalent streams directly without opening it.
+A stream Remote uses `@Remote({ mode: 'stream' })` and returns an `Iterable` or `AsyncIterable`. `ctx.typertGateway.stream()` applies the same endpoint, argument, lookup, and cancellation checks as unary invocation, then returns a cancellation-aware iterable over the business items. The Client opens the Gateway-owned `/api/remote.mux` WebSocket when its plugin activates and keeps it connected while idle. Connection owns the retry schedule; before each retry it asks the mux to cancel any candidate or active socket and make exactly one fresh physical attempt. The Host sends Ping control frames at the configured `websocketHeartbeatIntervalMs` interval (two seconds by default), and the browser answers Pong at the WebSocket protocol layer, so idle network intermediaries see traffic without any Remote stream frame. A socket that has not answered the previous Ping is terminated at the next interval. Independently cancellable logical streams share that socket; an in-process Connection carrier provides equivalent streams directly without opening it.
 
 Host composition can register one application event source through `registerRemoteEvents()`. Gateway reserves the internal `$events` logical endpoint for that source, accepts only empty `args`, and aborts streams opened by the registration when the source is withdrawn. API Remotes owns the event selection, argument validation, per-Client queues, and the Host home sent in the opening `{ type: 'ready', clientId, host: { home } }` frame. Its source factory attaches incremental listeners synchronously, so the Client publishes the generation and starts baseline reads only after incremental delivery is ready.
 
 <a id="client-service-clientremote-ctx-key-remote"></a>
 ## Client service: `ClientRemote` (ctx key: `remote`)
 
-`ctx.remote.$mount()` validates and registers a generated Host-for-Client contribution, then installs concrete direct and scoped methods for the calling Cordis fiber. Each namespace is a traced `remote.<namespace>` child Service and unloads after its last method is withdrawn. Duplicate endpoints, namespace collisions, and descriptors without strict generated codecs fail before methods become callable.
+The browser carrier accepts the shell-owned stream origin described by [Connection](../../client/connection/README.md#use-this-package); logical stream framing and lifecycle remain unchanged.
 
-Each unary call validates positional inputs, constructs the descriptor's exact named `args`, and sends it through `ctx.connection.rpc.call('/api', endpoint, ...)`. A generated stream method returns an `AsyncIterable` and opens one logical stream through an in-process Connection carrier when available, otherwise through the shared Gateway WebSocket. Generated cancellation-aware methods accept a final optional `AbortSignal`; the Client combines it with the contribution mount lifetime before invoking the carrier. Unary results and every stream item are validated before reaching application code. Withdrawing a contribution removes its descriptors and methods together, aborts in-flight calls and streams, and makes retained method handles reject.
+`ctx.remote.$mount()` validates and registers a generated Host-for-Client contribution, then installs concrete direct and scoped methods for the calling Cordis fiber. Each namespace is a traced `remote.<namespace>` child Service and unloads after its last method is withdrawn. Duplicate endpoints, namespace collisions, and Client-supplied fields without strict generated codecs fail before methods become callable.
+
+Each unary call checks positional arity, constructs the descriptor's exact named `args`, and sends the typed values through `ctx.connection.rpc.call('/api', endpoint, ...)` without executing Client-side schemas; the Host validates the received wire fields before business invocation. A generated stream method returns an `AsyncIterable` and opens one logical stream through an in-process Connection carrier when available, otherwise through the shared Gateway WebSocket. Generated cancellation-aware methods accept a final optional `AbortSignal`; the Client combines it with the contribution mount lifetime before invoking the carrier. Successful unary results and stream items pass through without Client-side type parsing. Withdrawing a contribution removes its descriptors and methods together, aborts in-flight calls and streams, and makes retained method handles reject.
 
 Every unary call resolves to `RemoteResult<T>` — `{ ok: true, value }` or `{ ok: false, error }` — and never rejects for a carrier problem: this face folds an offline carrier into the error branch and answers `gateway/cancelled` when the caller's signal aborts, so no consumer wraps a call to recover one. Only an assembly fault still rejects: wrong arity, an unmounted method, a withdrawn contribution, a missing Context adapter. `error` is a live `RemoteError` instance, so `throw result.error` keeps throw semantics, and `isRemoteFailure(value)` is the one predicate a consumer needs — a caught value it accepts carries a Host code, and anything it rejects is a local fault the caller should let crash. `carrierFailure(endpoint, error)` and `cancelledFailure(endpoint, cause)` build those two folded results, so a test stand-in for this face folds identically.
 
@@ -51,6 +53,8 @@ Every unary call resolves to `RemoteResult<T>` — `{ ok: true, value }` or `{ o
 
 `ctx.remote.$on()` subscribes to one forwarded Host event. Its legal keys are exactly the Host assembly's forwarding selection, and the listener type is the owning package's own Cordis `Events` declaration, so no second signature can drift from it. Each subscription belongs to the calling fiber and disappears with it. The Client Remote service registers the `$events` pump as a Connection generation source when it activates, whether any `$on` listener exists. Browsers use Remote mux, while in-process compositions use `connection.rpc.open`; the opening `ready` item establishes a Connection generation and supplies its Host facts. Carrier failure, Remote stream failure, unexpected normal completion, a non-ready opening item, or a malformed event item ends that generation and lets Connection reopen it under continuous, capped jittered exponential backoff. Ordinary notifications run in registration order and isolate listener failures. Agent-scoped waterfalls let a listener return a result, call `next()`, or reject; Gateway returns that outcome through the existing HTTP unary carrier.
 
+Client waterfall Context resolution stays synchronous. A resolver can return a borrowed Context or `TypertOwnedValue<Context>`; Gateway releases the owned value only after handler use and reply settlement. Context-resolution failures retain the existing report-and-delegate behavior, while handler failures produce rejected replies. Cancellation suppresses late replies without releasing a Context still used by the handler. Every handler must observe `request.signal` and settle after cancellation; plugin disposal and Connection generation replacement wait for outstanding handlers to settle. Session Context acquisition itself performs no history I/O.
+
 `ctx.remote` exposes no Connection lifecycle control. A consumer whose responsibility includes recovery reads `ctx.connection.state` and calls `ctx.connection.reconnect()` directly; ordinary Remote consumers stay on generated namespaces and `$stream()`.
 
 Generated declaration merges provide the TypeScript API through the shared `TypertClientRemote` contract. The Client entry contains no Host Service or Host Cordis interface merge, and method lookup and invocation use ordinary objects and functions rather than a JavaScript Proxy.
@@ -70,7 +74,7 @@ No direct effect; invoked business Services own any model-visible result.
 
 - The Connection adapter answers `gateway/internal` with empty details for dispatch failures and unclassified exceptions; a `RemoteError` thrown by an owner or by Gateway itself crosses the wire with its own code, message, and details. Its `cause` chain and the `TypertGatewayError` subclass identity survive only for same-process callers.
 - SRC mode supports unique identifier parameters without destructuring, defaults, or rest parameters. It validates JSON safety rather than generated business types and never infers optional fields.
-- Only strict generated contributions can mount on the Client face. SRC markers have no Client codec or type projection.
+- Every Client-supplied field requires a strict generated codec when its contribution mounts. SRC markers have no Client type projection and are not normal Client contribution inputs.
 - `$stream()` supervises carrier replacement but does not infer replay semantics; each domain owns its resume cursor or replacement-baseline validation and normal-end classification. Connection generations reopen the internal `$events` stream; one-way notifications are not replayed, while pending scoped waterfalls retain their event id across replay.
 - Lookup resolvers are configured per key; an individual Remote parameter or endpoint cannot currently select a live-only policy under the same `agent`/`session` key.
 - Forwarded events reach `$on` without business-payload projection or redaction. Ordinary notifications are not replayed after reconnect; Agent-scoped waterfalls project only the top-level Agent identity needed to select the Client Context and carry their own pending lifetime.

package/node_modules/@deepseek-ai/dsh-api-gateway/README.zh.md

@@ -24,7 +24,7 @@ kind: "package-reference"
 <a id="host-service-typertgatewayservice-ctx-key-typertgateway"></a>
 ## Host 服务：`TypertGatewayService`（ctx key：`typertGateway`）
 
-每次调用时，`ctx.typertGateway.invoke()` 都会解析当前的描述符和 Cordis 服务，校验具名参数是否完全匹配，解析已注册的对象或 Context 身份标识，调用公开的业务方法，并校验其结果。业务服务继承 [`dsh-typert-protocol`](../../typert/protocol/README.zh.md) 的 `TypertRemoteService`，并用 `@Remote` 或 `@RemoteScope` 标记方法；已有其他基类时仍可改用 `bindTypertRemote()`。
+每次调用时，`ctx.typertGateway.invoke()` 都会解析当前的描述符和 Cordis 服务，校验具名参数是否完全匹配，解析已注册的对象或 Context 身份标识，并调用公开的业务方法。业务服务继承 [`dsh-typert-protocol`](../../typert/protocol/README.zh.md) 的 `TypertRemoteService`，并用 `@Remote` 或 `@RemoteScope` 标记方法；已有其他基类时仍可改用 `bindTypertRemote()`。
 
 严格模式从 `ctx.typert.local` 读取生成的调用描述符。查找参数使用 `ctx.typert.lookups` 中当前有效的解析器：业务包注册稳定声明与默认策略，Host 组合可用 effect-scoped `configure()` 覆盖解析行为；`@RemoteScope` 则通过已注册的 Host Context 适配器解析其接收者。SRC 模式是开发阶段的回退路径，适用于从未具备严格定义的端点；它解析简单参数名，并且只允许非查找参数使用可安全表示为 JSON 的值。已观测到的严格定义一旦撤回，系统会直接报错，而不会降低校验强度。
 
@@ -32,16 +32,18 @@ Connection 可用时，Host 入口会在 Connection 共享的 `/api` FetchHandle
 
 支持取消的 Remote 方法会把 `signal: AbortSignal` 声明为最后一个 Host 参数。signal 是 descriptor 元数据，而不是 wire 参数：Connection 将它提供给 Gateway，Gateway 则在已解码的业务参数之后注入它。SRC 识别这个保留的末位参数名，严格生成还要求它具有全局 `AbortSignal` 类型。
 
-流式 Remote 使用 `@Remote({ mode: 'stream' })` 并返回 `Iterable` 或 `AsyncIterable`。`ctx.typertGateway.stream()` 执行与一元调用相同的 endpoint、参数、lookup 和取消校验，再用生成的 result codec 校验每个产出项。Client 插件激活时打开 Gateway 自有的 `/api/remote.mux` WebSocket，并让它在空闲时保持连接。Connection 拥有重试调度；每次 retry 前，它要求 mux 取消候选或活动 socket，并且只做一次全新的物理连接尝试。Host 按配置的 `websocketHeartbeatIntervalMs` 间隔（默认 2 秒）发送 Ping 控制帧，浏览器在 WebSocket 协议层自动回复 Pong，使空闲网络中间层持续看到流量，而不新增 Remote 流帧。若 socket 尚未回复上一次 Ping，Host 会在下一间隔终止它。可独立取消的逻辑流共享这条连接；进程内 Connection 载体直接提供等价的流，不打开该 WebSocket。
+流式 Remote 使用 `@Remote({ mode: 'stream' })` 并返回 `Iterable` 或 `AsyncIterable`。`ctx.typertGateway.stream()` 执行与一元调用相同的 endpoint、参数、lookup 和取消校验，再返回可取消的业务项 iterable。Client 插件激活时打开 Gateway 自有的 `/api/remote.mux` WebSocket，并让它在空闲时保持连接。Connection 拥有重试调度；每次 retry 前，它要求 mux 取消候选或活动 socket，并且只做一次全新的物理连接尝试。Host 按配置的 `websocketHeartbeatIntervalMs` 间隔（默认 2 秒）发送 Ping 控制帧，浏览器在 WebSocket 协议层自动回复 Pong，使空闲网络中间层持续看到流量，而不新增 Remote 流帧。若 socket 尚未回复上一次 Ping，Host 会在下一间隔终止它。可独立取消的逻辑流共享这条连接；进程内 Connection 载体直接提供等价的流，不打开该 WebSocket。
 
 Host 组合可通过 `registerRemoteEvents()` 注册唯一的应用事件 source。Gateway 为它保留内部 `$events` logical endpoint，只接受空 `args`，并在 source 撤回时中止该注册打开的流。事件名单、参数校验、每个 Client 的队列及 opening `{ type: 'ready', clientId, host: { home } }` frame 中的 Host home 由 API Remotes 拥有。source factory 在返回 iterable 前同步挂好增量 listener，因此 Client 只在增量投递就绪后发布 generation 并开始 baseline 读取。
 
 <a id="client-service-clientremote-ctx-key-remote"></a>
 ## Client 服务：`ClientRemote`（ctx key：`remote`）
 
-`ctx.remote.$mount()` 会校验并注册生成的 Host-for-Client 贡献项，然后为发起调用的 Cordis fiber 安装具体的直接方法和作用域方法。每个 namespace 都是可追踪的 `remote.<namespace>` 子 Service，并在最后一个方法撤回后卸载。重复端点、命名空间冲突，以及缺少生成的严格编解码器的描述符，都会在方法可调用前报错。
+浏览器载体接受 [Connection](../../client/connection/README.zh.md#use-this-package) 定义的 shell 所拥有的流 origin；逻辑流帧与生命周期保持一致。
 
-每次一元调用都会校验位置参数，构造与描述符完全匹配的具名 `args`，再通过 `ctx.connection.rpc.call('/api', endpoint, ...)` 发送。生成的流方法返回 `AsyncIterable`，并在进程内 Connection 载体可用时通过它打开逻辑流，否则通过共享的 Gateway WebSocket 打开。生成的支持取消的方法接受最后一个可选 `AbortSignal`；Client 会在调用载体前将它与贡献项的挂载生命周期合并。一元结果和每个流项都经过校验后才会交给应用代码。撤回贡献项会同时移除其描述符和方法、中止正在进行的调用与流，并使外部仍持有的方法句柄在调用时返回拒绝。
+`ctx.remote.$mount()` 会校验并注册生成的 Host-for-Client 贡献项，然后为发起调用的 Cordis fiber 安装具体的直接方法和作用域方法。每个 namespace 都是可追踪的 `remote.<namespace>` 子 Service，并在最后一个方法撤回后卸载。重复端点、命名空间冲突，以及缺少生成的严格 codec 的 Client 供值字段，都会在方法可调用前报错。
+
+每次一元调用都会检查位置参数数量，构造与描述符完全匹配的具名 `args`，再把带类型的值原样交给 `ctx.connection.rpc.call('/api', endpoint, ...)`，而不执行 Client 侧 schema；Host 会在业务调用前校验收到的 wire 字段。生成的流方法返回 `AsyncIterable`，并在进程内 Connection 载体可用时通过它打开逻辑流，否则通过共享的 Gateway WebSocket 打开。生成的支持取消的方法接受最后一个可选 `AbortSignal`；Client 会在调用载体前将它与贡献项的挂载生命周期合并。成功的一元结果与流项不经 Client 侧类型解析直接传递。撤回贡献项会同时移除其描述符和方法、中止正在进行的调用与流，并使外部仍持有的方法句柄在调用时返回拒绝。
 
 每次一元调用都解析为 `RemoteResult<T>`——`{ ok: true, value }` 或 `{ ok: false, error }`——且绝不因载体问题 reject：本面把断线载体折入错误分支，调用方 signal 中止时答以 `gateway/cancelled`，因此没有消费方需要包一层来兜载体失败。只有装配故障仍会 reject：参数个数不符、方法未挂载、贡献已撤下、缺少 Context 适配器。`error` 是活的 `RemoteError` 实例，所以 `throw result.error` 保持 throw 语义；而 `isRemoteFailure(value)` 是消费方唯一需要的谓词——它认下的捕获值带着 Host 码，它拒绝的一律是本地故障，调用方应当让其崩掉。`carrierFailure(endpoint, error)` 与 `cancelledFailure(endpoint, cause)` 构造这两种折叠结果，测试里的替代实现据此采用相同的折叠方式。
 
@@ -51,6 +53,8 @@ Host 组合可通过 `registerRemoteEvents()` 注册唯一的应用事件 source
 
 `ctx.remote.$on()` 订阅一条被转发的 Host 事件。它的合法键恰好等于 Host 装配声明的转发选择，listener 类型就是事件所属包自己的 Cordis `Events` 声明，因此不存在会与之漂移的第二份签名。每个订阅归属调用方 fiber，并随该 fiber 一起消失。Client Remote 服务激活时就把 `$events` pump 注册为 Connection generation source，无论当前是否存在 `$on` listener。浏览器使用 Remote mux，进程内组合使用 `connection.rpc.open`；opening `ready` 项建立 Connection generation 并提供 Host 信息。物理 carrier 失败、Remote 流故障、意外正常结束、非 ready 首项或畸形事件项都会终止该 generation，由 Connection 按持续且间隔封顶的带抖动指数退避重开。普通通知按注册顺序运行并隔离 listener 失败；Agent-scoped waterfall（瀑布式事件）允许 listener 返回结果、调用 `next()` 或拒绝，Gateway 再通过现有 HTTP 一元载体回送该结果。
 
+Client waterfall 的 Context 解析保持同步。解析器可以返回借用的 Context 或 `TypertOwnedValue<Context>`；Gateway 仅在处理器使用和回复结算均结束后释放 owned value。Context 解析失败保留既有的记录错误并委托语义，处理器失败产生拒绝回复。取消会抑制迟到回复，但不会释放处理器仍在使用的 Context。每个 handler 都必须响应 `request.signal` 并在取消后结束；插件销毁与 Connection generation 替换会等待未结束的 handler 结算。Session Context 的获取本身不执行历史 I/O。
+
 `ctx.remote` 不暴露 Connection 生命周期控制。只有职责包含恢复的消费方才直接读取 `ctx.connection.state` 并调用 `ctx.connection.reconnect()`；普通 Remote 消费方仍只使用生成的 namespace 与 `$stream()`。
 
 生成的声明合并通过共享的 `TypertClientRemote` 约定提供 TypeScript API。Client 入口不包含 Host 服务或 Host Cordis 接口合并；方法查找和调用使用普通对象与函数，而不使用 JavaScript Proxy。
@@ -70,7 +74,7 @@ Host 组合可通过 `registerRemoteEvents()` 注册唯一的应用事件 source
 
 - Connection 适配器对分发故障与未归类异常答以 `gateway/internal`，且不附带详细信息；拥有方或 Gateway 自己抛出的 `RemoteError` 带着自有码、message 与 details 过线。其 `cause` 链与 `TypertGatewayError` 子类身份只对同进程调用方留存。
 - SRC 模式仅支持名称唯一的标识符参数，不支持解构、默认值或剩余参数。它只校验值能否安全表示为 JSON，不校验生成的业务类型，也绝不会推断可选字段。
-- Client 侧只能挂载严格模式生成的贡献项。SRC 标记不具备 Client 编解码器或类型投影。
+- contribution 挂载时，每个由 Client 供值的字段都必须具备生成的严格 codec。SRC 标记没有 Client 类型投影，不是常规的 Client contribution 输入。
 - `$stream()` 监督载体替换，但不推断回放语义；各领域自行拥有恢复 cursor 或替换 baseline 的校验，以及正常结束的分类。Connection generation 会重开内部 `$events` 流；单向通知不会重放，仍处于 pending 的 scoped waterfall 则沿用同一个 event id 重放。
 - lookup 解析器按 key 配置；当前无法让单个 Remote 参数或 endpoint 在同一 `agent`/`session` key 下选择 live-only 策略。
 - 被转发的事件到达 `$on` 时不做业务载荷投影或脱敏。普通通知在重连后不重放；Agent-scoped waterfall 只投影选择 Client Context 所需的顶层 Agent 身份，并自行携带 pending 生命周期。

package/node_modules/@deepseek-ai/dsh-api-gateway/lib/client.js

@@ -42,6 +42,17 @@ window.__ModuleLoader__.load({
 		function remoteErrorOf(value) {
 			if (typeof value === "object" && value !== null && value.isDSHRemoteError === true && typeof value.code === "string") return value;
 		}
+		/** Generic invocation-owned values returned by synchronous Client Context resolvers. */
+		/** Shared identity across independently bundled Context providers and Gateway. */
+		const TYPERT_OWNED_VALUE = Symbol.for("dsh.typert.owned-value");
+		/**
+		* Identify invocation-owned values using the shared marker.
+		* @param value - borrowed or owned resolver result.
+		* @returns whether the result carries invocation cleanup.
+		*/
+		function isTypertOwnedValue(value) {
+			return typeof value === "object" && value !== null && TYPERT_OWNED_VALUE in value && value[TYPERT_OWNED_VALUE] === true;
+		}
 		//#endregion
 		//#region lib/types/stream-protocol.js
 		/** Wire messages for Gateway-owned Remote streams and event-result RPCs. */
@@ -540,7 +551,7 @@ window.__ModuleLoader__.load({
 		};
 		function remoteStreamUrl() {
 			const location = globalThis.location;
-			const base = location?.origin !== void 0 && location.origin !== "null" ? location.origin : INTERNAL_BASE;
+			const base = globalThis.__DSH_TRANSPORT__?.streamBaseUrl ?? (location?.origin !== void 0 && location.origin !== "null" ? location.origin : INTERNAL_BASE);
 			const url = new URL(REMOTE_STREAM_MUX_PATH, base);
 			url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
 			return url.href;
@@ -653,30 +664,36 @@ window.__ModuleLoader__.load({
 			}
 			async answer(frame, clientId, signal) {
 				const adapter = this.ownerCtx.typert.contexts.getClient("agent");
-				let target;
+				let resolved;
 				try {
-					target = adapter?.resolve(frame.agentId);
+					resolved = adapter?.resolve(frame.agentId);
 				} catch (error) {
 					this.reportError(frame.event, error);
 				}
-				let outcome = { kind: "next" };
-				if (target !== void 0) try {
-					outcome = await this.dispatchWaterfall(target, frame, signal);
-				} catch (error) {
+				const owned = isTypertOwnedValue(resolved) ? resolved : void 0;
+				try {
+					const target = isTypertOwnedValue(resolved) ? resolved.value : resolved;
+					let outcome = { kind: "next" };
+					if (target !== void 0) try {
+						outcome = await this.dispatchWaterfall(target, frame, signal);
+					} catch (error) {
+						if (signal.aborted) return;
+						outcome = {
+							kind: "rejected",
+							error: projectRemoteEventRejection(error)
+						};
+					}
 					if (signal.aborted) return;
-					outcome = {
-						kind: "rejected",
-						error: projectRemoteEventRejection(error)
+					const result = {
+						clientId,
+						eventId: frame.eventId,
+						outcome: outcome.kind === "result" && outcome.value === void 0 ? { kind: "result" } : outcome
 					};
+					const response = await this.connection.rpc.call("/api", REMOTE_EVENT_RESULT_ENDPOINT, { args: result }, signal);
+					if (!response.ok) throw new Error(response.error.message);
+				} finally {
+					owned?.[Symbol.dispose]();
 				}
-				if (signal.aborted) return;
-				const result = {
-					clientId,
-					eventId: frame.eventId,
-					outcome: outcome.kind === "result" && outcome.value === void 0 ? { kind: "result" } : outcome
-				};
-				const response = await this.connection.rpc.call("/api", REMOTE_EVENT_RESULT_ENDPOINT, { args: result }, signal);
-				if (!response.ok) throw new Error(response.error.message);
 			}
 			async dispatchWaterfall(target, frame, signal) {
 				const request = {
@@ -684,7 +701,7 @@ window.__ModuleLoader__.load({
 					agent: target,
 					signal
 				};
-				const value = await abortable(Promise.resolve(privateEvents(target).waterfall(target, this.eventKey(frame.event), request, () => Promise.resolve(REMOTE_EVENT_NEXT))), signal);
+				const value = await privateEvents(target).waterfall(target, this.eventKey(frame.event), request, () => Promise.resolve(REMOTE_EVENT_NEXT));
 				if (value !== REMOTE_EVENT_NEXT && value !== void 0 && !isRemoteJsonValue(value)) throw new TypeError("Remote event listener result is not lossless JSON data");
 				return value === REMOTE_EVENT_NEXT ? { kind: "next" } : {
 					kind: "result",
@@ -755,23 +772,6 @@ window.__ModuleLoader__.load({
 		function invalidRemoteEventFrame() {
 			throw new TypeError("client api: invalid forwarded Remote event frame");
 		}
-		/** Race listener completion against its delivery lifetime. */
-		async function abortable(value, signal) {
-			signal.throwIfAborted();
-			let rejectAbort;
-			const aborted = new Promise((_resolve, reject) => {
-				rejectAbort = reject;
-			});
-			const onAbort = () => {
-				rejectAbort?.(signal.reason);
-			};
-			signal.addEventListener("abort", onAbort, { once: true });
-			try {
-				return await Promise.race([Promise.resolve(value), aborted]);
-			} finally {
-				signal.removeEventListener("abort", onAbort);
-			}
-		}
 		function privateEvents(ctx) {
 			return ctx;
 		}
@@ -1517,7 +1517,7 @@ window.__ModuleLoader__.load({
 					if ((this.namespaces.get(descriptor.namespace)?.service)?.has(kind, descriptor.method) === true) throw new Error(`client api: ${kind} method ${endpointOf(descriptor)} is already mounted`);
 				};
 				for (const descriptor of contribution.descriptors) {
-					requireStrictDescriptor(descriptor);
+					requireStrictInputs(descriptor);
 					if (descriptor.invocation.kind === "direct") add(direct, descriptor, "direct");
 					if (scopedProjection(descriptor) !== void 0) add(scoped, descriptor, "scoped");
 				}
@@ -1653,12 +1653,12 @@ window.__ModuleLoader__.load({
 					if (boundIdentity === void 0 && adapter === void 0) throw new Error(`client api: ${endpoint} has no Client Context adapter for ${JSON.stringify(projection.context)}`);
 					const identity = boundIdentity === void 0 ? adapter?.identity(callerCtx) : boundIdentity.value;
 					if (identity === void 0) throw new Error(`client api: ${endpoint} requires a ${JSON.stringify(projection.context)} Context`);
-					args[projection.wire] = parseInput(projection.codec, identity, endpoint, projection.wire);
+					args[projection.wire] = identity;
 				}
 				let valueIndex = 0;
 				descriptor.parameters.forEach((parameter, parameterIndex) => {
 					if (parameterIndex === projection?.parameterIndex) return;
-					const value = parseInput(parameter.codec, values[valueIndex], endpoint, parameter.wire);
+					const value = values[valueIndex];
 					if (value !== void 0) args[parameter.wire] = value;
 					valueIndex += 1;
 				});
@@ -1803,8 +1803,7 @@ window.__ModuleLoader__.load({
 		function scopedProjection(descriptor) {
 			if (descriptor.invocation.kind === "context") return {
 				context: descriptor.invocation.context,
-				wire: descriptor.invocation.wire,
-				codec: descriptor.invocation.codec
+				wire: descriptor.invocation.wire
 			};
 			if (descriptor.scope === void 0) return void 0;
 			const lookupParameters = descriptor.parameters.map((parameter, index) => ({
@@ -1816,11 +1815,10 @@ window.__ModuleLoader__.load({
 			return {
 				context: descriptor.scope.context,
 				wire: descriptor.scope.wire,
-				codec: selected.parameter.codec,
 				parameterIndex: selected.index
 			};
 		}
-		function requireStrictDescriptor(descriptor) {
+		function requireStrictInputs(descriptor) {
 			const endpoint = endpointOf(descriptor);
 			for (const parameter of descriptor.parameters) requireStrictCodec(parameter.codec, endpoint, parameter.wire);
 			if (descriptor.invocation.kind === "context") requireStrictCodec(descriptor.invocation.codec, endpoint, descriptor.invocation.wire);
@@ -1828,14 +1826,6 @@ window.__ModuleLoader__.load({
 		function requireStrictCodec(codec, endpoint, field) {
 			if (codec.mode !== "strict") throw new Error(`client api: generated Remote ${endpoint} field ${JSON.stringify(field)} has no strict codec`);
 		}
-		function parseInput(codec, value, endpoint, field) {
-			if (codec.mode !== "strict") throw new Error(`client api: generated Remote ${endpoint} field ${JSON.stringify(field)} has no strict codec`);
-			try {
-				return codec.create().parse(value);
-			} catch (cause) {
-				throw new Error(`client api: ${endpoint} rejected ${JSON.stringify(field)}`, { cause });
-			}
-		}
 		/** The namespace retired before or during the call, so no request outcome exists. */
 		function withdrawn(endpoint) {
 			return internalFailure(`client api: Remote method ${endpoint} is no longer mounted`);

package/node_modules/@deepseek-ai/dsh-api-gateway/lib/types/client/index.js

@@ -149,7 +149,7 @@ class ClientRemoteService extends Service {
             }
         };
         for (const descriptor of contribution.descriptors) {
-            requireStrictDescriptor(descriptor);
+            requireStrictInputs(descriptor);
             if (descriptor.invocation.kind === 'direct')
                 add(direct, descriptor, 'direct');
             if (scopedProjection(descriptor) !== undefined)
@@ -328,13 +328,13 @@ class ClientRemoteService extends Service {
             if (identity === undefined) {
                 throw new Error(`client api: ${endpoint} requires a ${JSON.stringify(projection.context)} Context`);
             }
-            args[projection.wire] = parseInput(projection.codec, identity, endpoint, projection.wire);
+            args[projection.wire] = identity;
         }
         let valueIndex = 0;
         descriptor.parameters.forEach((parameter, parameterIndex) => {
             if (parameterIndex === projection?.parameterIndex)
                 return;
-            const value = parseInput(parameter.codec, values[valueIndex], endpoint, parameter.wire);
+            const value = values[valueIndex];
             if (value !== undefined)
                 args[parameter.wire] = value;
             valueIndex += 1;
@@ -477,7 +477,6 @@ function scopedProjection(descriptor) {
         return {
             context: descriptor.invocation.context,
             wire: descriptor.invocation.wire,
-            codec: descriptor.invocation.codec,
         };
     }
     if (descriptor.scope === undefined)
@@ -494,11 +493,10 @@ function scopedProjection(descriptor) {
     return {
         context: descriptor.scope.context,
         wire: descriptor.scope.wire,
-        codec: selected.parameter.codec,
         parameterIndex: selected.index,
     };
 }
-function requireStrictDescriptor(descriptor) {
+function requireStrictInputs(descriptor) {
     const endpoint = endpointOf(descriptor);
     for (const parameter of descriptor.parameters) {
         requireStrictCodec(parameter.codec, endpoint, parameter.wire);
@@ -512,17 +510,6 @@ function requireStrictCodec(codec, endpoint, field) {
         throw new Error(`client api: generated Remote ${endpoint} field ${JSON.stringify(field)} has no strict codec`);
     }
 }
-function parseInput(codec, value, endpoint, field) {
-    if (codec.mode !== 'strict') {
-        throw new Error(`client api: generated Remote ${endpoint} field ${JSON.stringify(field)} has no strict codec`);
-    }
-    try {
-        return codec.create().parse(value);
-    }
-    catch (cause) {
-        throw new Error(`client api: ${endpoint} rejected ${JSON.stringify(field)}`, { cause });
-    }
-}
 /** The namespace retired before or during the call, so no request outcome exists. */
 function withdrawn(endpoint) {
     return internalFailure(`client api: Remote method ${endpoint} is no longer mounted`);

package/node_modules/@deepseek-ai/dsh-api-gateway/lib/types/client/remote-events.js

@@ -1,4 +1,5 @@
 /** Client owner for forwarded Remote Event subscriptions and deliveries. */
+import { isTypertOwnedValue } from '@deepseek-ai/dsh-typert-protocol';
 import { randomUUID } from '@deepseek-ai/dsh-util-crypto';
 import { REMOTE_EVENT_RESULT_ENDPOINT, REMOTE_EVENT_STREAM_ENDPOINT, REMOTE_EVENT_STREAM_PAYLOAD, isRemoteEventAgentId, isRemoteEventClientId, isRemoteEventId, isRemoteJsonValue, projectRemoteEventRejection, } from "../stream-protocol.js";
 /** Private end-of-chain marker that cannot collide with a JSON listener result. */
@@ -116,36 +117,43 @@ export class ClientRemoteEvents {
     }
     async answer(frame, clientId, signal) {
         const adapter = this.ownerCtx.typert.contexts.getClient('agent');
-        let target;
+        let resolved;
         try {
-            target = adapter?.resolve(frame.agentId);
+            resolved = adapter?.resolve(frame.agentId);
         }
         catch (error) {
             this.reportError(frame.event, error);
         }
-        let outcome = { kind: 'next' };
-        if (target !== undefined) {
-            try {
-                outcome = await this.dispatchWaterfall(target, frame, signal);
-            }
-            catch (error) {
-                if (signal.aborted)
-                    return;
-                outcome = { kind: 'rejected', error: projectRemoteEventRejection(error) };
+        const owned = isTypertOwnedValue(resolved) ? resolved : undefined;
+        try {
+            const target = isTypertOwnedValue(resolved) ? resolved.value : resolved;
+            let outcome = { kind: 'next' };
+            if (target !== undefined) {
+                try {
+                    outcome = await this.dispatchWaterfall(target, frame, signal);
+                }
+                catch (error) {
+                    if (signal.aborted)
+                        return;
+                    outcome = { kind: 'rejected', error: projectRemoteEventRejection(error) };
+                }
             }
+            if (signal.aborted)
+                return;
+            const result = {
+                clientId,
+                eventId: frame.eventId,
+                outcome: outcome.kind === 'result' && outcome.value === undefined
+                    ? { kind: 'result' }
+                    : outcome,
+            };
+            const response = await this.connection.rpc.call('/api', REMOTE_EVENT_RESULT_ENDPOINT, { args: result }, signal);
+            if (!response.ok)
+                throw new Error(response.error.message);
+        }
+        finally {
+            owned?.[Symbol.dispose]();
         }
-        if (signal.aborted)
-            return;
-        const result = {
-            clientId,
-            eventId: frame.eventId,
-            outcome: outcome.kind === 'result' && outcome.value === undefined
-                ? { kind: 'result' }
-                : outcome,
-        };
-        const response = await this.connection.rpc.call('/api', REMOTE_EVENT_RESULT_ENDPOINT, { args: result }, signal);
-        if (!response.ok)
-            throw new Error(response.error.message);
     }
     async dispatchWaterfall(target, frame, signal) {
         const request = {
@@ -153,7 +161,8 @@ export class ClientRemoteEvents {
             agent: target,
             signal,
         };
-        const value = await abortable(Promise.resolve(privateEvents(target).waterfall(target, this.eventKey(frame.event), request, () => Promise.resolve(REMOTE_EVENT_NEXT))), signal);
+        // Cancellation reaches the handler, whose Context remains owned until it settles.
+        const value = await privateEvents(target).waterfall(target, this.eventKey(frame.event), request, () => Promise.resolve(REMOTE_EVENT_NEXT));
         if (value !== REMOTE_EVENT_NEXT && value !== undefined && !isRemoteJsonValue(value)) {
             throw new TypeError('Remote event listener result is not lossless JSON data');
         }
@@ -232,20 +241,6 @@ function validRemoteEventName(value) {
 function invalidRemoteEventFrame() {
     throw new TypeError('client api: invalid forwarded Remote event frame');
 }
-/** Race listener completion against its delivery lifetime. */
-async function abortable(value, signal) {
-    signal.throwIfAborted();
-    let rejectAbort;
-    const aborted = new Promise((_resolve, reject) => { rejectAbort = reject; });
-    const onAbort = () => { rejectAbort?.(signal.reason); };
-    signal.addEventListener('abort', onAbort, { once: true });
-    try {
-        return await Promise.race([Promise.resolve(value), aborted]);
-    }
-    finally {
-        signal.removeEventListener('abort', onAbort);
-    }
-}
 function privateEvents(ctx) {
     return ctx;
 }

package/node_modules/@deepseek-ai/dsh-api-gateway/lib/types/client/stream-client.js

@@ -281,7 +281,8 @@ class StreamInbox {
 }
 function remoteStreamUrl() {
     const location = globalThis.location;
-    const base = location?.origin !== undefined && location.origin !== 'null' ? location.origin : INTERNAL_BASE;
+    const transport = globalThis.__DSH_TRANSPORT__;
+    const base = transport?.streamBaseUrl ?? (location?.origin !== undefined && location.origin !== 'null' ? location.origin : INTERNAL_BASE);
     const url = new URL(REMOTE_STREAM_MUX_PATH, base);
     url.protocol = url.protocol === 'https:' ? 'wss:' : 'ws:';
     return url.href;