dsh-remote-bridge 2.4.2 → 2.4.3

package/README.en.md

@@ -9,7 +9,7 @@
 </p>
 
 <p align="center">
-  <img alt="Version" src="https://img.shields.io/badge/version-v2.4.2-087f8c">
+  <img alt="Version" src="https://img.shields.io/badge/version-v2.4.3-087f8c">
   <img alt="DSH plugin" src="https://img.shields.io/badge/DeepSeek_Harness-plugin-1f2328">
   <img alt="Platforms" src="https://img.shields.io/badge/platform-Windows%20%7C%20macOS%20%7C%20Linux-586069">
   <img alt="License" src="https://img.shields.io/badge/license-AGPL--3.0-2da44e">
@@ -27,6 +27,18 @@ The interface is bilingual and defaults to Chinese. Prebuilt packages run on Win
 > with `dsh-api-gateway`, leaving the upstream release unable to start on 0.2.x — it surfaces as
 > "adding an authorized root returns 405". Background, rationale, changes, and test results are in
 > [DSH 0.2.x compatibility notes](./docs/project/DSH-0.2-COMPAT.md).
+>
+> **Adaptation to DSH 0.2.1-rc.2** (rechecked 2026-10-20; see `docs/project/DSH-0.2.1-ADAPTATION.md`):
+> this plugin **deliberately imports no `@deepseek-ai/*` package** — every host service is consumed
+> through a structural type injected by the running Host (see the header comment in
+> `src/host/dsh-0.2-bridge.ts`). Checked one by one against the installed `0.2.1-rc.2` packages:
+> all 10 `inject` service names in `cordis.patch.yml` **still exist with unchanged signatures**, and
+> `engines.dsh` is recognized by the 0.2.1 kernel (`prepareProfileEntries` in
+> `dsh-app-boot/lib/index.js`) — an unmet range only sets that entry to `disabled` and prints to
+> stderr; **the host process does not exit**. So no code change is needed to run on `0.2.1-rc.2`.
+> The only point still needing on-device confirmation is the injection surface of
+> `permissionPresets` (never injectable on 0.2.0 either, where the plugin already falls back to a
+> built-in catalog).
 
 ## What it looks like
 
@@ -63,7 +75,12 @@ So seeing `dsh-workspace` in a REST address or the state directory is **expected
 ### Requirements
 
 - A working DeepSeek Harness WebUI installation
-- DSH kernel `0.1.x` or `0.2.x` (0.2.x is supported by this branch's compatibility layer — see [DSH 0.2.x compatibility notes](./docs/project/DSH-0.2-COMPAT.md))
+- DSH kernel **`>=0.2.0-rc.2 <0.3.0`** (compatible with `0.2.0-rc.2` and every later `0.2.x`, including
+  `0.2.1-rc.2`; supported by this branch's compatibility layer — see
+  [DSH 0.2.x compatibility notes](./docs/project/DSH-0.2-COMPAT.md)).
+  `package.json` declares the same range under `engines.dsh`; the kernel resolves it with semver and
+  only **disables** the plugin when unmet (the host process keeps running), with the user able to
+  grant an exact-version exemption as the kernel suggests.
 - Node.js `^22.19.0` or `>=24.0.0`
 - Port `3090`, or another available port
 
@@ -77,10 +94,10 @@ dsh plugin --profile web add dsh-remote-bridge
 dsh plugin --profile web add dsh-remote-bridge --registry https://registry.npmmirror.com
 
 # 2. tarball from the GitHub release
-dsh plugin --profile web add https://github.com/westanke/dsh-remote-bridge/releases/download/v2.4.2/dsh-remote-bridge-v2.4.2.tgz
+dsh plugin --profile web add https://github.com/westanke/dsh-remote-bridge/releases/download/v2.4.3/dsh-remote-bridge-v2.4.3.tgz
 
 # 3. tarball from the Gitee release (faster from mainland China)
-dsh plugin --profile web add https://gitee.com/westanke/dsh-remote-bridge/releases/download/v2.4.2/dsh-remote-bridge-v2.4.2.tgz
+dsh plugin --profile web add https://gitee.com/westanke/dsh-remote-bridge/releases/download/v2.4.3/dsh-remote-bridge-v2.4.3.tgz
 
 npx @deepseek-ai/dsh web
 ```
@@ -97,7 +114,7 @@ Restart DSH after installation, then open settings — The section is titled **
 To install a downloaded release archive:
 
 ```sh
-dsh plugin --profile web add ./dsh-remote-bridge-v2.4.2.tgz
+dsh plugin --profile web add ./dsh-remote-bridge-v2.4.3.tgz
 ```
 
 ## First connection
@@ -329,13 +346,13 @@ pnpm pack
 
 `pnpm check` covers type-checking, documentation consistency, and tests. It currently passes **30 test files / 226 cases**, plus **4 browser-layer cases** (Playwright measuring real computed styles).
 
-`npm pack` produces roughly a **0.53 MB** archive (v2.4.2 measured 558,704 bytes, SHA-256 `0260fe57…e3067f`): 2.2.0 dropped the standalone page and its editor dependencies and turned source maps off, down from 1.72 MB; it has since grown slightly with projection passthrough and the permission BFF.
+`npm pack` produces roughly a **0.55 MB** archive (v2.4.3 measured 572,951 bytes, SHA-256 `38f25c10…299c93`): 2.2.0 dropped the standalone page and its editor dependencies and turned source maps off, down from 1.72 MB; it has since grown slightly with projection passthrough and the permission BFF.
 
-v2.4.2 was developed against DSH `master@47f943859bef60e4160492346772ded9b24f765a`. CI covers Windows, Ubuntu, and macOS.
+v2.4.3 was verified on DSH **0.2.1-rc.2** on real hardware: all 14/14 host services injected, the three jobs endpoints exercised, and the permission catalog returned the kernel's real three presets. The development baseline is `master@47f943859bef60e4160492346772ded9b24f765a` (kernel 0.2.0-rc.2); see `engines.dsh` above for the supported range. CI covers Windows, Ubuntu, and macOS.
 
 ## Project
 
-- Version: `v2.4.2`
+- Version: `v2.4.3`
 - Author: upstream [Hakunm](https://github.com/Hakunm); this fork maintained by [westanke](https://github.com/westanke)
 - Repository: [GitHub](https://github.com/westanke/dsh-remote-bridge) · [Gitee](https://gitee.com/westanke/dsh-remote-bridge)
 - npm: [`dsh-remote-bridge`](https://www.npmjs.com/package/dsh-remote-bridge) ([mainland-China mirror](https://registry.npmmirror.com/dsh-remote-bridge))

package/README.md

@@ -9,7 +9,7 @@
 </p>
 
 <p align="center">
-  <img alt="Version" src="https://img.shields.io/badge/version-v2.4.2-087f8c">
+  <img alt="Version" src="https://img.shields.io/badge/version-v2.4.3-087f8c">
   <img alt="DSH plugin" src="https://img.shields.io/badge/DeepSeek_Harness-plugin-1f2328">
   <img alt="Platforms" src="https://img.shields.io/badge/platform-Windows%20%7C%20macOS%20%7C%20Linux-586069">
   <img alt="License" src="https://img.shields.io/badge/license-AGPL--3.0-2da44e">
@@ -25,6 +25,14 @@
 > 0.2.x 用 `dsh-api-gateway` 替换了提供 `apiProxy` 服务的 `dsh-host-apiproxy`，导致上游版本在
 > 0.2.x 上无法启动（表现为「添加根目录返回 405」）。兼容层的完整说明——基于什么、为什么、改了什么、
 > 测了什么——见 [DSH 0.2.x 兼容性适配说明](./docs/project/DSH-0.2-COMPAT.md)。
+>
+> **对 DSH 0.2.1-rc.2 的适配结论**（2026-10-20 复核，依据 `/media/wangke/OFFICE/workspace/dsh-remote-bridge/docs/project/DSH-0.2.1-ADAPTATION.md`）：
+> 本插件**刻意不 import 任何 `@deepseek-ai/*` 包**，全部宿主服务经结构类型 + Host 注入消费
+> （见 `src/host/dsh-0.2-bridge.ts` 头注释）。逐一到 `0.2.1-rc.2` 实装包核对：`cordis.patch.yml`
+> 的 10 项 `inject` 服务名**全部仍存在且签名未变**，`engines.dsh` 在 0.2.1 被内核识别
+> （`dsh-app-boot/lib/index.js` 的 `prepareProfileEntries`），不满足时只把该 entry 置
+> `disabled` 并打 stderr，**宿主进程不退出**。故本插件无需改码即可运行于 `0.2.1-rc.2`。
+> 唯一需真机定论的是 `permissionPresets` 的注入面（0.2.0 上即注不进，已降级到内置目录）。
 
 ## 实际效果
 
@@ -62,7 +70,8 @@
 ### 环境要求
 
 - 已安装并能正常启动的 DeepSeek Harness WebUI
-- DSH 内核 `0.1.x` 或 `0.2.x`（0.2.x 由本分支的兼容层支持，见 [DSH 0.2.x 兼容性适配说明](./docs/project/DSH-0.2-COMPAT.md)）
+- DSH 内核 **`>=0.2.0-rc.2 <0.3.0`**（兼容 `0.2.0-rc.2` 及其后全部 `0.2.x`，含 `0.2.1-rc.2`；由本分支的兼容层支持，见 [DSH 0.2.x 兼容性适配说明](./docs/project/DSH-0.2-COMPAT.md)）。
+  `package.json` 的 `engines.dsh` 已声明同一范围 —— 内核按 semver 裁决，不满足时该插件被**禁用**（宿主进程不退出），用户可按内核提示授予精确版本豁免。
 - Node.js `^22.19.0` 或 `>=24.0.0`
 - 默认端口 `3090` 可用，或准备一个其他端口
 
@@ -76,10 +85,10 @@ dsh plugin --profile web add dsh-remote-bridge
 dsh plugin --profile web add dsh-remote-bridge --registry https://registry.npmmirror.com
 
 # ② GitHub Release 的 tarball
-dsh plugin --profile web add https://github.com/westanke/dsh-remote-bridge/releases/download/v2.4.2/dsh-remote-bridge-v2.4.2.tgz
+dsh plugin --profile web add https://github.com/westanke/dsh-remote-bridge/releases/download/v2.4.3/dsh-remote-bridge-v2.4.3.tgz
 
 # ③ Gitee Release 的 tarball（国内访问更快）
-dsh plugin --profile web add https://gitee.com/westanke/dsh-remote-bridge/releases/download/v2.4.2/dsh-remote-bridge-v2.4.2.tgz
+dsh plugin --profile web add https://gitee.com/westanke/dsh-remote-bridge/releases/download/v2.4.3/dsh-remote-bridge-v2.4.3.tgz
 
 npx @deepseek-ai/dsh web
 ```
@@ -95,7 +104,7 @@ npx @deepseek-ai/dsh web
 从 GitHub Release 下载离线安装包时，可直接安装 tarball：
 
 ```sh
-dsh plugin --profile web add ./dsh-remote-bridge-v2.4.2.tgz
+dsh plugin --profile web add ./dsh-remote-bridge-v2.4.3.tgz
 ```
 
 ## 第一次使用
@@ -323,13 +332,15 @@ pnpm pack
 
 `pnpm check` 覆盖类型检查、文档一致性与测试；当前 **30 个测试文件 / 226 个用例**，外加 **4 个浏览器层用例**（Playwright 实测量出的计算样式），全部通过。
 
-`npm pack` 的产物约 **0.53 MB**（v2.4.2 实测 558,704 字节，SHA-256 `0260fe57…e3067f`）：2.2.0 删除独立页及其编辑器依赖、并关闭 source map 之后从 1.72 MB 降下来，之后随投影透传与权限 BFF 小幅增长。
+`npm pack` 的产物约 **0.55 MB**（v2.4.3 实测 572,951 字节，SHA-256 `38f25c10…299c93`）：2.2.0 删除独立页及其编辑器依赖、并关闭 source map 之后从 1.72 MB 降下来，之后随投影透传与权限 BFF 小幅增长。
 
-v2.4.2 基于 DSH `master@47f943859bef60e4160492346772ded9b24f765a` 开发，CI 覆盖 Windows、Ubuntu 和 macOS。
+v2.4.3 在 DSH **0.2.1-rc.2** 上完成真机验证：14/14 宿主服务全部可注入、三个 jobs 端点实测通过、
+权限档位目录返回内核真实三档。开发基线为 `master@47f943859bef60e4160492346772ded9b24f765a`（内核 0.2.0-rc.2），
+兼容范围见上文 `engines.dsh`。CI 覆盖 Windows、Ubuntu 和 macOS。
 
 ## 项目信息
 
-- 当前版本：`v2.4.2`
+- 当前版本：`v2.4.3`
 - 作者：上游 [Hakunm](https://github.com/Hakunm)，本 fork 维护 [westanke](https://github.com/westanke)
 - 仓库：[GitHub](https://github.com/westanke/dsh-remote-bridge) · [Gitee](https://gitee.com/westanke/dsh-remote-bridge)
 - npm：[`dsh-remote-bridge`](https://www.npmjs.com/package/dsh-remote-bridge)（[国内镜像](https://registry.npmmirror.com/dsh-remote-bridge)）

package/cordis.patch.yml

@@ -6,7 +6,38 @@
       # DSH 0.2.x host services (see src/host/dsh-0.2-bridge.ts). The pre-0.2
       # `apiProxy` facade is rebuilt from these; `@deepseek-ai/dsh-host-apiproxy`
       # stopped shipping at 0.1.1-rc.2 and nothing provides `apiProxy` after it.
-      inject: [sessionController, workspaceController, workspaceRegistry, settingsController, credentialsController, agentPresets, llm, webServer, agents, commands]
+      #
+      # ⚠️ 这份列表**必须**与 `src/index.ts` 导出的 `inject` 完全一致。
+      # 原因（2026-10-20 实测，代价是三次重启）：patch 里的 `inject` **覆盖**
+      # 插件自己导出的 `inject`，不是取并集。于是插件声明了、这里漏了的服务
+      # 读起来会报 `cannot get property "x" without inject` ——
+      # 与「内核压根没有这个服务」的报错**一模一样**，肉眼分不出来。
+      #
+      # 这一条曾长期掩盖真相：`permissionPresets` 一直以为「web profile 注不进、
+      # 只能走内置兜底目录」，实际是这里没声明它。`jobController` 加进来之后
+      # 同样注不进，才顺着 `_refresh()` 的 INACTIVE 逻辑反查到这条覆盖规则。
+      inject: [
+        sessionController,
+        workspaceController,
+        workspaceRegistry,
+        settingsController,
+        credentialsController,
+        agentPresets,
+        # 权限档位目录（`ctx.permissionPresets`）：内核把它做成独立的 Typert
+        # 远程服务，会话投影那条 wire 视图只给 currentValue、不带候选项。
+        permissionPresets,
+        llm,
+        webServer,
+        agents,
+        commands,
+        # 后台任务（`ctx.jobController`）：远程场景下任务跑飞了要能停掉。
+        jobController,
+        # 文件上传服务（`ctx.fileUploads`）：用它而不是内核那条只绑 loopback 的
+        # /api/session/uploadFileBinary HTTP 路由。
+        fileUploads,
+        # 附件存储（`ctx.attachments`）：会话历史里的图片以 attachmentId 引用存在。
+        attachments,
+      ]
       config:
         # 状态目录**不改名**：已装的机器上有既有数据库与回收站，换目录等于让用户
         # 的授权根配置和回收站全部消失。改名只动「装的时候叫什么、bundle 叫什么」。

package/docs/api/asyncapi.yaml

@@ -1,7 +1,7 @@
 asyncapi: 3.0.0
 info:
   title: DeepSeek Harness Mobile Events
-  version: 2.4.2
+  version: 2.4.3
   description: |
     Live file and authorized DSH chat events. Reconnect clients must refresh
     REST state; unbounded replay is not provided.

package/docs/api/openapi.yaml

@@ -1,7 +1,7 @@
 openapi: 3.1.0
 info:
   title: DeepSeek Harness Mobile API
-  version: 2.4.2
+  version: 2.4.3
   description: Versioned file and chat BFF for mobile and third-party DSH clients. HTTP and HTTPS are both supported.
 servers:
   - url: http://127.0.0.1:3090/api/v1
@@ -25,6 +25,62 @@ paths:
                   ok: { type: boolean, const: true }
                   version: { type: string, const: v1 }
                   pluginVersion: { type: string, const: 2.4.2 }
+  /debug/host-services:
+    get:
+      operationId: hostServices
+      summary: Host service injection probe
+      description: |
+        Reports which DSH host services the plugin actually resolved on the running
+        kernel. This plugin deliberately imports no `@deepseek-ai/*` package and
+        consumes every host service through a structural type injected by the Host,
+        so "is the service there at all" is otherwise unanswerable without guessing.
+
+        `injected` covers the services named in the plugin's `inject` declaration;
+        `observed` covers services confirmed present in the web profile but not yet
+        consumed (currently only `workingDirectory`, added by DSH 0.2.1).
+
+        Requires a device token or loopback admin, like every other authenticated
+        endpoint: it exposes host internals.
+      responses:
+        '200':
+          description: Injection probe snapshot taken while the plugin applied.
+          content:
+            application/json:
+              schema:
+                type: object
+                required: [pluginVersion, injected, observed, summary]
+                properties:
+                  pluginVersion: { type: string }
+                  injected:
+                    type: array
+                    items:
+                      type: object
+                      required: [name, available, resolvable]
+                      properties:
+                        name: { type: string }
+                        available: { type: boolean }
+                        resolvable: { type: boolean }
+                        error: { type: string }
+                  observed:
+                    type: array
+                    items:
+                      type: object
+                      required: [name, available, resolvable]
+                      properties:
+                        name: { type: string }
+                        available: { type: boolean }
+                        resolvable: { type: boolean }
+                        error: { type: string }
+                  summary:
+                    type: object
+                    required: [injectedTotal, injectedAvailable, injectedMissing, observedAvailable]
+                    properties:
+                      injectedTotal: { type: integer }
+                      injectedAvailable: { type: integer }
+                      injectedMissing: { type: array, items: { type: string } }
+                      observedAvailable: { type: array, items: { type: string } }
+        '404':
+          description: The probe is not compiled into this build.
   /pairings/exchange:
     post:
       security: []
@@ -583,6 +639,94 @@ paths:
       responses:
         '200': { description: Session archived. }
         '404': { $ref: '#/components/responses/Error' }
+  /chat/sessions/{sessionId}/jobs:
+    parameters:
+      - name: sessionId
+        in: path
+        required: true
+        schema: { type: string }
+    get:
+      operationId: listSessionJobs
+      summary: Background jobs a session can see
+      description: |
+        The roster this session can observe: its own jobs plus every unowned job.
+        The kernel's owner fence is the only access rule, so `sessionId` is
+        required and must not be guessed by the client.
+      responses:
+        '200':
+          description: The complete roster (whole-set, not a page).
+          content:
+            application/json:
+              schema:
+                type: object
+                required: [jobs]
+                properties:
+                  jobs:
+                    type: array
+                    items: { $ref: '#/components/schemas/JobView' }
+        '404': { $ref: '#/components/responses/Error' }
+  /chat/sessions/{sessionId}/jobs/{jobId}/output:
+    parameters:
+      - name: sessionId
+        in: path
+        required: true
+        schema: { type: string }
+      - name: jobId
+        in: path
+        required: true
+        schema: { type: string }
+      - name: from
+        in: query
+        required: false
+        description: Absolute byte offset to resume from (a prior response's `next`). Omitted starts at the oldest retained byte.
+        schema: { type: integer }
+    get:
+      operationId: readJobOutput
+      summary: Retained output of one background job
+      responses:
+        '200':
+          description: Flattened output plus the offset to resume from.
+          content:
+            application/json:
+              schema:
+                type: object
+                required: [jobId, text, next, lossy]
+                properties:
+                  jobId: { type: string }
+                  text: { type: string }
+                  next: { type: integer }
+                  lossy: { type: boolean }
+                  status: { $ref: '#/components/schemas/JobStatus' }
+        '404': { $ref: '#/components/responses/Error' }
+  /chat/sessions/{sessionId}/jobs/{jobId}/kill:
+    parameters:
+      - name: sessionId
+        in: path
+        required: true
+        schema: { type: string }
+      - name: jobId
+        in: path
+        required: true
+        schema: { type: string }
+    post:
+      operationId: killSessionJob
+      summary: Stop one background job on a human's behalf
+      description: |
+        Records `cancelled by the user` as the reason. The owning agent still
+        receives its completion notice, because a human kill is not one the
+        model requested.
+      responses:
+        '200':
+          description: The registry's admission.
+          content:
+            application/json:
+              schema:
+                type: object
+                required: [jobId, outcome]
+                properties:
+                  jobId: { type: string }
+                  outcome: { type: string, enum: [requested, already-finished] }
+        '404': { $ref: '#/components/responses/Error' }
   /chat/sessions/{sessionId}/messages:
     parameters:
       - name: sessionId
@@ -1329,3 +1473,21 @@ components:
             message: { type: string }
             requestId: { type: string, format: uuid }
             details: { type: object, additionalProperties: true }
+    JobStatus:
+      type: string
+      description: Lifecycle state. `running` and `stopping` are live; the rest are terminal.
+      enum: [running, stopping, completed, killed, failed]
+    JobView:
+      type: object
+      description: Read-only projection of one background job.
+      required: [id, kind, label, status, startedAt]
+      properties:
+        id: { type: string, description: 'Registry-issued id, e.g. `bash-<short-uuid>`.' }
+        kind: { type: string, description: 'Producer kind; `bash` is the only host-registered one today.' }
+        label: { type: string, description: Producer-supplied one-line label. }
+        owner: { type: string, description: Owning session; absent for an unowned job. }
+        status: { $ref: '#/components/schemas/JobStatus' }
+        progress: { type: string, description: 'Live progress line (`3/10`); cleared at settlement.' }
+        detail: { type: string, description: 'Terminal reason (`exit code: 3`); a recorded kill reason is merged in.' }
+        startedAt: { type: integer, format: epoch-ms }
+        finishedAt: { type: integer, format: epoch-ms, description: Absent while live. }

package/kotlin-sdk/src/main/kotlin/ai/deepseek/dsh/workspace/DshWorkspaceClient.kt

@@ -514,6 +514,51 @@ class DshWorkspaceClient(
         executeUnit("chat/sessions/$sessionId/archive", "POST", null)
     }
 
+    /**
+     * 这个会话可见的后台任务清单（它自己的 + 所有无主任务）。
+     *
+     * 服务端只读内核流的第一帧 —— 内核保证首帧就是全量 truth，
+     * 所以这里返回的是完整清单，不是一个分页。
+     */
+    fun listSessionJobs(sessionId: String): List<JobView> = executeJson(
+        "chat/sessions/$sessionId/jobs",
+        "GET",
+        null,
+        JobListEnvelope.serializer(),
+    ).jobs
+
+    /**
+     * 读一个后台任务已保留的输出。
+     *
+     * [from] 是**绝对字节偏移**，传上一次返回的 [JobOutput.next] 即可增量续读；
+     * 传 null 从最旧的保留字节开始。
+     *
+     * [JobOutput.lossy] 为 true 时，请求偏移与返回内容之间有字节被留存策略吃掉 ——
+     * 这段输出不是完整的，调用方应当提示用户。
+     */
+    fun readJobOutput(sessionId: String, jobId: String, from: Long? = null): JobOutput {
+        val query = if (from == null) "" else "?from=$from"
+        return executeJson(
+            "chat/sessions/$sessionId/jobs/$jobId/output$query",
+            "GET",
+            null,
+            JobOutput.serializer(),
+        )
+    }
+
+    /**
+     * 终止一个后台任务。
+     *
+     * 返回 `requested`（已受理）或 `already-finished`（已是终态、无需再杀）——
+     * 调用方应据此显示「已终止」或「它已经结束了」，后者不是前者的成功说法。
+     */
+    fun killSessionJob(sessionId: String, jobId: String): JobKillResult = executeJson(
+        "chat/sessions/$sessionId/jobs/$jobId/kill",
+        "POST",
+        null,
+        JobKillResult.serializer(),
+    )
+
     fun listPendingApprovals(sessionId: String): List<PendingApproval> = executeJson(
         "chat/sessions/$sessionId/approvals",
         "GET",
@@ -726,3 +771,59 @@ class EventSubscription internal constructor(
 @Serializable private data class SendMessageRequest(val text: String, val mode: String, val clientRequestId: String)
 @Serializable private data class ErrorEnvelope(val error: ApiErrorBody)
 @Serializable private data class ApiErrorBody(val code: String, val message: String, val requestId: String)
+
+/** 后台任务的生命周期状态。`running` / `stopping` 存活中，其余为终态。 */
+@Serializable
+enum class JobStatus {
+    @SerialName("running") RUNNING,
+    @SerialName("stopping") STOPPING,
+    @SerialName("completed") COMPLETED,
+    @SerialName("killed") KILLED,
+    @SerialName("failed") FAILED,
+}
+
+/**
+ * 一个后台任务的只读投影。
+ *
+ * 服务端逐个字段校验过类型，所以这里除 [status] / [startedAt] / [id] / [kind] / [label]
+ * 之外的字段都可空 —— 内核没给就是没有，客户端不该看到一个 `owner: undefined`。
+ */
+@Serializable
+data class JobView(
+    val id: String,
+    val kind: String,
+    val label: String,
+    val owner: String? = null,
+    val status: JobStatus,
+    /** 生产者的实时进度行（`3/10`）；终态时被清空。 */
+    val progress: String? = null,
+    /** 终态原因（`exit code: 3`）；记录过的人工取消原因会并进来。 */
+    val detail: String? = null,
+    /** 注册时刻（epoch ms）。 */
+    val startedAt: Long,
+    /** 落定时刻（epoch ms）；存活中为 null。 */
+    val finishedAt: Long? = null,
+)
+
+@Serializable private data class JobListEnvelope(val jobs: List<JobView>)
+
+/** 一个后台任务已保留的输出。 */
+@Serializable
+data class JobOutput(
+    val jobId: String,
+    val text: String,
+    /** 绝对字节偏移；下次增量续读传它。 */
+    val next: Long,
+    /** true = 请求偏移与返回内容之间有字节被留存策略吃掉，这段输出不完整。 */
+    val lossy: Boolean,
+    /** 读到终态帧时带上；流被提前切断时为 null。 */
+    val status: JobStatus? = null,
+)
+
+/** 终止结果。 */
+@Serializable
+data class JobKillResult(
+    val jobId: String,
+    /** `requested` 已受理；`already-finished` 已是终态、无需再杀。 */
+    val outcome: String,
+)

package/lib/index.d.ts

@@ -671,6 +671,57 @@ interface AgentPresetsLike {
 interface PermissionPresetsLike {
   catalog(): Promise<unknown>;
 }
+/**
+ * 内核 `dsh-api-job-controller`（cordis 服务名 `jobController`）。
+ *
+ * 后台任务（目前只有 bash 一种 producer kind）的只读观察 + 人类取消。
+ *
+ * **`list` 与 `follow` 是流，不是一次性查询** —— 内核类型上就是
+ * `AsyncIterable<JobListFrame>` / `AsyncIterable<JobFollowFrame>`。但 list 的首帧
+ * 就是全量 truth（内核注释原文：「Whole-set replacement, so a reconnect's first
+ * frame is already the truth」），所以 REST 侧读**第一帧**即可得到完整清单，
+ * 不必把 HTTP 变成长连接（手机端耗电、断线重连都更难）。
+ *
+ * 只有 `kill` 是同步的，且它的返回只有两种：`requested` / `already-finished`
+ * —— 没有「不存在」这一档，未知 job 走 `job/not-found` 远程错误。
+ *
+ * 结构类型照 `dsh-api-job-controller/lib/types/{index,types}.d.ts` 与
+ * `dsh-jobs/lib/types/view.d.ts` 抄，只留本插件真用到的那部分。
+ */
+interface JobControllerLike {
+  /** 流：首帧全量，随后每次生命周期提交后一帧。 */
+  list(request: {
+    sessionId: string;
+  }, signal: AbortSignal): AsyncIterable<{
+    type?: string;
+    jobs?: readonly unknown[];
+  }>;
+  /** 流：opened 锚点 → 若干 output 批次 → 终态 status，之后正常关闭。 */
+  follow(request: {
+    sessionId?: string;
+    jobId: string;
+    from?: number;
+  }, signal: AbortSignal): AsyncIterable<{
+    type?: string;
+    job?: unknown;
+    from?: number;
+    chunks?: readonly unknown[];
+    next?: number;
+    lossy?: true;
+  }>;
+  /**
+   * 人类取消。返回 `requested`（已受理）或 `already-finished`（已终态，无需再杀）。
+   *
+   * 注意它**不是** Promise：内核类型上就是同步返回。调用方 `await` 它也合法
+   * （await 非 Promise 返回原值），所以这里按内核原样声明成同步。
+   */
+  kill(request: {
+    sessionId: string;
+    jobId: string;
+  }): {
+    outcome: 'requested' | 'already-finished';
+  };
+}
 interface LlmLike {
   /** Live routes, as `{ id, name }` rows. */
   listProviders(): readonly {
@@ -711,6 +762,16 @@ interface Dsh02HostServices {
   credentialsController: CredentialsControllerLike;
   agentPresets: AgentPresetsLike;
   permissionPresets: PermissionPresetsLike;
+  /**
+   * 后台任务控制器（`ctx.jobController`，`@deepseek-ai/dsh-api-job-controller`）。
+   *
+   * 为什么要它：远程场景下「任务跑飞了停不掉」是真焦虑 —— 人不在电脑前，
+   * 一个卡住的 bash 任务只能干等。手机端需要能看到清单并终止它。
+   *
+   * 与 `sessionController` 不同，这个是 `TypertRemoteService`（不是 `@Remote`
+   * 控制器集合），但结构类型消费方式完全一样：只声明用到的成员，缺了就明确报错。
+   */
+  jobController: JobControllerLike;
   llm: LlmLike;
   /**
    * 内核附件存储（`ctx.attachments`）；会话历史里的图片要经它取字节。
@@ -1533,6 +1594,136 @@ declare class WorkspaceEventBus {
   subscribe(listener: (event: WorkspaceEvent) => void): () => void;
 }
 //#endregion
+//#region src/host/host-service-probe.d.ts
+interface ServiceProbe {
+  name: string;
+  /** 服务是否可解析。`false` = cordis 认为没有插件提供它。 */
+  available: boolean;
+  /** 解析失败时的错误信息（成功时为 undefined）。 */
+  error?: string;
+  /** 解析到的值是否像一个可用的服务对象（非 null/非 undefined）。 */
+  resolvable: boolean;
+}
+interface HostServiceReport {
+  /** 探针执行时的内核运行时版本，供比对「哪个版本注入面是这样」。 */
+  pluginVersion: string;
+  injected: ServiceProbe[];
+  observed: ServiceProbe[];
+  /** 注入面摘要：注入了几个、缺几个。缺的那几个就是「功能可能静默不工作」的清单。 */
+  summary: {
+    injectedTotal: number;
+    injectedAvailable: number;
+    injectedMissing: readonly string[];
+    observedAvailable: readonly string[];
+  };
+}
+//#endregion
+//#region src/host/job-adapter.d.ts
+/**
+ * 后台任务（background jobs）。
+ *
+ * ## 为什么需要它
+ *
+ * 远程场景下有个真焦虑：用户在手机上让 agent 跑个长任务（bash 构建、批量处理），
+ * 然后切到别的会话或者放下手机 —— **此时没有任何地方能看到「它还在跑吗」，
+ * 更没有地方能「让它停下」**。任务跑飞了只能干等，或者回到电脑前。
+ *
+ * 而内核一直有这套能力：`dsh-api-job-controller` 在 web profile 里挂着，
+ * 提供 roster 流（`list`）、单任务输出观察流（`follow`）与人类取消（`kill`）。
+ * 官方 WebUI 有 Jobs 面板（`client-ui-jobs` + `IconJobs`），本桥此前 26 个能力位里
+ * **一个 job 相关的都没有**。
+ *
+ * ## 为什么 REST 只读第一帧，不做长连接
+ *
+ * 内核的 `list` 是 `AsyncIterable<JobListFrame>`，但内核注释写得很清楚：
+ * 「Whole-set replacement, so a reconnect's first frame is already the truth」——
+ * **首帧就是完整真相**。所以：
+ *
+ * - REST `GET /jobs` 读第一帧就够，返回完整清单；
+ * - 不把 HTTP 变成长连接：手机端长连接耗电、断线重连复杂、而且清单本来就该「拉一次就是真的」；
+ * - 实时推送留给后续（若要，走 WebSocket 事件帧，与 chat.* 同一条通道）。
+ *
+ * ## 为什么端点挂在会话维度下
+ *
+ * 内核的 `list(request)` 与 `kill(request)` **都要 `sessionId`** —— 返回的是
+ * 「该会话自己的任务 + 所有无主任务」，owner fence 是唯一的访问规则。
+ * 所以本模块的每个方法都要调用方给出 `sessionId`，**不能替客户端猜** ——
+ * 猜错会让一个会话看到另一个会话的任务。`kill` 同理：请求里的 session 就是
+ * 那次围栏读写的调用者。
+ *
+ * 所以 REST 也必须是会话维度的：`/chat/sessions/{sessionId}/jobs`。
+ * 做成顶层 `/jobs` 就得让客户端额外猜一个 session，那是把内核的围栏语义
+ * 搬到桥外面，早晚出「一个会话看到另一个会话的任务」这种事。
+ *
+ * 可见性由内核裁决，本模块不二次判断：内核抛 `job/not-found` 就转成 404。
+ */
+/** 一个后台任务的对外视图（内核 `JobView` 的结构投影）。 */
+interface JobView {
+  id: string;
+  kind: string;
+  label: string;
+  /** 属主会话；无主任务没有这个字段（任何调用方都可见）。 */
+  owner?: string;
+  status: 'running' | 'stopping' | 'completed' | 'killed' | 'failed';
+  /** 生产者的实时进度行（`3/10`、当前阶段）；终态时被清空。 */
+  progress?: string;
+  /** 终态原因（`exit code: 3`）；记录过的 kill 原因会并进来。 */
+  detail?: string;
+  /** 注册时刻（epoch ms）。 */
+  startedAt: number;
+  /** 落定时刻（epoch ms）；存活中无此字段。 */
+  finishedAt?: number;
+}
+/** `GET /jobs` 的响应。 */
+interface JobListResult {
+  jobs: JobView[];
+}
+/** `POST /jobs/{jobId}/kill` 的响应。 */
+interface JobKillResult {
+  jobId: string;
+  /** `requested` = 已受理；`already-finished` = 已是终态，无需再杀。 */
+  outcome: 'requested' | 'already-finished';
+}
+declare class JobAdapter {
+  private readonly host;
+  constructor(host: {
+    jobController: JobControllerLike;
+  });
+  /**
+   * 列出某个会话可见的后台任务。
+   *
+   * 读流的**第一帧**（内核保证它是全量 truth）。若流首帧就不是 `rows`
+   * （内核升级改了帧型），明确报错而不是返回空清单 ——
+   * 空清单会被客户端理解成「没有任务」，那是**假的**。
+   */
+  list(sessionId: string, signal: AbortSignal): Promise<JobListResult>;
+  /**
+   * 读一个任务已保留的输出（从指定字节偏移继续）。
+   *
+   * 内核的 `follow` 是流：`opened` 锚点 → 若干 `output` 批次 → 终态 `status`。
+   * 这里**只读到第一个终态帧或流结束为止**，把批次摊平成一个文本块 ——
+   * 手机端要看的是「这任务打印了什么」，不是逐帧的字节偏移记账。
+   *
+   * 但 `next` 偏移会一并返回：客户端想增量续读时，拿它当 `from` 再调一次即可，
+   * 不必从头拉。`lossy` 也透出去，让客户端知道「有字节被留存策略吃掉了」，
+   * 而不是把一段对不上的输出当成完整的。
+   */
+  follow(sessionId: string, jobId: string, from: number | undefined, signal: AbortSignal): Promise<{
+    jobId: string;
+    text: string;
+    next: number;
+    lossy: boolean;
+    status?: JobView['status'];
+  }>;
+  /**
+   * 终止一个后台任务。
+   *
+   * 内核的 `kill` 是**同步**的，且只有 `requested` / `already-finished` 两种返回；
+   * 「这个任务不存在或该会话看不到它」走 `job/not-found` 远程错误，在这里转成 404。
+   */
+  kill(sessionId: string, jobId: string): JobKillResult;
+}
+//#endregion
 //#region src/host/cloudflared.d.ts
 /**
  * Cloudflare 隧道（cloudflared）管理。
@@ -1725,6 +1916,20 @@ interface RouterOptions {
    * 生产路径由 `index.ts` 传入与交接实际使用**同一个**目录，避免「界面显示 A、落盘在 B」。
    */
   imageFallbackDir?: string;
+  /**
+   * 宿主服务注入面探针报告（见 `host-service-probe.ts`）。
+   *
+   * 可选：不注入则该端点返回 404，测试因此不必每条都补一个字段。
+   * 生产路径由 `index.ts` 在 apply 期间采集后传入 —— 必须是**快照**，
+   * 因为 cordis 的注入属性只在 apply 执行期间可读（见探针文件头注释）。
+   */
+  hostServiceReport?: HostServiceReport;
+  /**
+   * 后台任务（`/chat/sessions/{sessionId}/jobs`）。
+   *
+   * 可选：不注入则这些端点返回 404，测试不必每条都补一个字段。
+   */
+  jobs?: JobAdapter;
 }
 declare class ApiRouter {
   private readonly options;

package/lib/index.js

@@ -1528,12 +1528,36 @@ const FALLBACK_PERMISSION_CATALOG = {
 	defaultPreset: "workspace-write"
 };
 /**
+* 从 follow 的 snapshot 帧里取投影基线。
+*
+* 0.2.1 起 `SessionFollowFrame` 的 snapshot 分支自带
+* `projections: SessionProjectionBaseline`，所以正常情况下**不需要**再打一次
+* `sessionController.projections()`。这个函数就是那个判断：有就用，没有返回 undefined
+* 让调用方回落。
+*
+* 为什么用结构探测而不是类型收窄：本插件刻意不 import `@deepseek-ai/*`，
+* `snapshot` 在这里是结构类型，看不到内核的判别联合。按形状判断是唯一办法，
+* 也与本文件其余部分的风格一致。
+*/
+function projectionsOf(snapshot) {
+	if (snapshot === null || typeof snapshot !== "object") return void 0;
+	const projections = snapshot.projections;
+	if (projections === null || typeof projections !== "object") return void 0;
+	const values = projections.values;
+	if (values === null || typeof values !== "object") return void 0;
+	const asOfSeq = projections.asOfSeq;
+	return {
+		...typeof asOfSeq === "number" ? { asOfSeq } : {},
+		values
+	};
+}
+/**
 * 读会话的**投影基线**（`permissions` / `modelSelection` / `title` …）。
 *
 * @patch
 * id: history-projections-passthrough
 * for: 内核 `sessionController.follow()` 的 snapshot 与 `page()` 都**不返回 projections**
-*      （类型上就是 `{ cursor, records, hasMore }`），而客户端要靠
+*      （0.2.0 的类型上就是 `{ cursor, records, hasMore }`），而客户端要靠
 *      `projections.values.permissions` 才能显示会话的当前权限档位。
 *      内核那边确实注册了这条投影（`dsh-permission-presets` 里
 *      `ctx.sessionProjections.register({ key: 'permissions', … })`），
@@ -1542,6 +1566,9 @@ const FALLBACK_PERMISSION_CATALOG = {
 *      不补的后果是 Android 客户端的权限档位 Pill 与 ⋯ 菜单权限项**从不渲染**
 *      —— v2.2.44 真机验收实测到了这个，而当时 `PARITY.md` 还把它标成 `done`。
 * until: 内核把 projections 并进 follow/page 的返回。
+*       **0.2.1 已达成**：snapshot 分支现在自带 `projections`，history 首屏走
+*       `projectionsOf(snapshot)`，不再打这次 RPC。本函数降级为**老内核回落路径**，
+*       保留到最低支持版本升过 0.2.1 之后再删。
 * test: tests/history-projections.spec.ts
 */
 async function readSessionProjections(host, sessionId, signal) {
@@ -1755,7 +1782,7 @@ function createDsh02ApiProxy(host, options = {}) {
 						events: [],
 						hasMore: false
 					};
-					const projections = await readSessionProjections(host, sessionId, controller.signal);
+					const projections = projectionsOf(snapshot) ?? await readSessionProjections(host, sessionId, controller.signal);
 					const withProjections = (payload) => projections === void 0 ? payload : {
 						...payload,
 						projections
@@ -2009,7 +2036,7 @@ function createDsh02ApiProxy(host, options = {}) {
 }
 //#endregion
 //#region src/shared/version.ts
-const PLUGIN_VERSION = "2.4.2";
+const PLUGIN_VERSION = "2.4.3";
 //#endregion
 //#region src/host/capabilities.ts
 /**
@@ -2087,7 +2114,10 @@ const BRIDGE_CAPABILITIES = [
 	"turn-failure-v1",
 	"history-byte-budget-v1",
 	"interaction-replay-v1",
-	"session-snapshot-v1"
+	"session-snapshot-v1",
+	"job-list-v1",
+	"job-output-v1",
+	"job-kill-v1"
 ];
 /**
 * `connection.ready` 事件的载荷。
@@ -4011,6 +4041,267 @@ function trashView(record) {
 		status: record.status
 	};
 }
+//#endregion
+//#region src/host/host-service-probe.ts
+/**
+* 宿主服务注入面探针。
+*
+* 为什么需要它：本插件刻意不 import 任何 `@deepseek-ai/*`（见
+* docs/project/COMPATIBILITY.md），全部宿主服务按结构类型 + Host 注入消费。
+* 好处是跨内核版本零漂移，**代价是「服务到底注进来了没有」只能靠猜** ——
+* cordis 的注入属性是惰性访问器，读一个没人提供的服务会抛
+* `cannot get property "x" without inject`，而这个错误只在真的去读的那一刻出现。
+*
+* 于是历史上反复出现同一类事故：某功能静默不工作，两侧日志都不说一句话，
+* 排错者先从客户端查起，查到服务端才发现服务压根没注入。
+* 2.0.0 的 `attachments`、2.0.2 的 `fileUploads` 都是这么炸的（见
+* dsh-0.2-bridge.ts 里那段长注释）。
+*
+* 这个探针把「猜」变成「问」：在 apply 期间（注入属性还可读时）逐个试读一次，
+* 记录每个服务的**可解析性**，之后任何时候都能回答「0.2.x 上到底有哪些服务可用」。
+* 它不改变任何行为 —— 纯粹是观测。
+*
+* 使用方式：`GET /dsh-workspace-api/api/v1/debug/host-services`
+* （需要设备 token 或 loopback admin，与其它 REST 端点同一套鉴权）。
+*/
+/** 插件 `src/index.ts` 里 inject 声明的全部服务名。 */
+const INJECTED_SERVICE_NAMES = [
+	"sessionController",
+	"workspaceController",
+	"workspaceRegistry",
+	"settingsController",
+	"credentialsController",
+	"agentPresets",
+	"permissionPresets",
+	"llm",
+	"webServer",
+	"agents",
+	"commands",
+	"jobController",
+	"fileUploads",
+	"attachments"
+];
+/** 0.2.1 新增、插件尚未 inject 但已确认存在于 web profile 的服务。 */
+const OBSERVED_ONLY_SERVICE_NAMES = ["workingDirectory", "workspaceFiles"];
+/**
+* 在注入属性**仍可读**的时机（即 `apply` 执行期间）逐个试读服务。
+*
+* 为什么必须在 apply 期间读、不能留到 HTTP 回调里：cordis 的注入属性是
+* 有生命周期的惰性访问器，`apply` 一结束就读不到了（会抛
+* `cannot get property "attachments" without inject`）。这正是
+* dsh-0.2-bridge.ts 里 `optionalService` 那段注释记的教训 ——
+* 2.0.1 把读取留到回调里，结果整个插件激活失败。
+*
+* @param host - `ctx` 本身（不是取到的服务对象）。
+* @returns 每个服务的可解析性报告。
+*/
+function probeHostServices(host, pluginVersion) {
+	const probeOne = (name) => {
+		let available = false;
+		let resolvable = false;
+		let error;
+		try {
+			const value = host[name];
+			available = true;
+			resolvable = value !== null && value !== void 0;
+			if (!resolvable) error = "resolved to null/undefined";
+		} catch (caught) {
+			error = caught instanceof Error ? caught.message : String(caught);
+		}
+		return {
+			name,
+			available,
+			resolvable,
+			...error === void 0 ? {} : { error }
+		};
+	};
+	const injected = INJECTED_SERVICE_NAMES.map(probeOne);
+	const observed = OBSERVED_ONLY_SERVICE_NAMES.map(probeOne);
+	return {
+		pluginVersion,
+		injected,
+		observed,
+		summary: {
+			injectedTotal: injected.length,
+			injectedAvailable: injected.filter((service) => service.available).length,
+			injectedMissing: injected.filter((service) => !service.available).map((service) => service.name),
+			observedAvailable: observed.filter((service) => service.available).map((service) => service.name)
+		}
+	};
+}
+//#endregion
+//#region src/host/job-adapter.ts
+/**
+* job 适配层的错误。
+*
+* **继承 `ApiError` 而不是另起一套**：两者的形状（status + code + message）
+* 完全一致，继承之后 router 现有的 `asApiError` 直接就能把它转成正确的
+* HTTP 响应，不必在路由里再写一层转换。这是刻意少造一个概念。
+*/
+var JobApiError = class extends ApiError {};
+/** 把内核 `JobView` 收敛成对外形状。
+*
+* 只挑客户端真用得上的字段，并且**逐个校验类型** —— 内核返回的是结构类型，
+* 一个字段形状变了就该在这里显形，而不是把一个 `undefined` 透给客户端
+* 让它的严格解码器报 `Field 'x' is required`。
+*/
+function toJobView(raw) {
+	if (raw === null || typeof raw !== "object") throw new JobApiError(502, "JOB_SHAPE_INVALID", "The kernel returned a malformed job row.");
+	const job = raw;
+	const id = job["id"];
+	const kind = job["kind"];
+	const label = job["label"];
+	const status = job["status"];
+	const startedAt = job["startedAt"];
+	if (typeof id !== "string" || typeof kind !== "string" || typeof label !== "string") throw new JobApiError(502, "JOB_SHAPE_INVALID", "The kernel returned a job row without id/kind/label.");
+	if (typeof status !== "string" || ![
+		"running",
+		"stopping",
+		"completed",
+		"killed",
+		"failed"
+	].includes(status)) throw new JobApiError(502, "JOB_SHAPE_INVALID", `The kernel returned an unknown job status: ${String(status)}`);
+	if (typeof startedAt !== "number") throw new JobApiError(502, "JOB_SHAPE_INVALID", "The kernel returned a job row without startedAt.");
+	const owner = job["owner"];
+	const progress = job["progress"];
+	const detail = job["detail"];
+	const finishedAt = job["finishedAt"];
+	return {
+		id,
+		kind,
+		label,
+		...typeof owner === "string" ? { owner } : {},
+		status,
+		...typeof progress === "string" ? { progress } : {},
+		...typeof detail === "string" ? { detail } : {},
+		startedAt,
+		...typeof finishedAt === "number" ? { finishedAt } : {}
+	};
+}
+var JobAdapter = class {
+	host;
+	constructor(host) {
+		this.host = host;
+	}
+	/**
+	* 列出某个会话可见的后台任务。
+	*
+	* 读流的**第一帧**（内核保证它是全量 truth）。若流首帧就不是 `rows`
+	* （内核升级改了帧型），明确报错而不是返回空清单 ——
+	* 空清单会被客户端理解成「没有任务」，那是**假的**。
+	*/
+	async list(sessionId, signal) {
+		const frame = (await this.host.jobController.list({ sessionId }, signal)[Symbol.asyncIterator]().next()).value;
+		if (frame === void 0 || frame === null) throw new JobApiError(502, "JOB_STREAM_EMPTY", "The job roster stream closed before its first frame.");
+		if (frame.type !== "rows") throw new JobApiError(502, "JOB_FRAME_UNKNOWN", `Unexpected first job frame: ${String(frame.type)}`);
+		const jobs = frame.jobs;
+		if (!Array.isArray(jobs)) throw new JobApiError(502, "JOB_SHAPE_INVALID", "The job roster frame carried no rows array.");
+		return { jobs: jobs.map(toJobView) };
+	}
+	/**
+	* 读一个任务已保留的输出（从指定字节偏移继续）。
+	*
+	* 内核的 `follow` 是流：`opened` 锚点 → 若干 `output` 批次 → 终态 `status`。
+	* 这里**只读到第一个终态帧或流结束为止**，把批次摊平成一个文本块 ——
+	* 手机端要看的是「这任务打印了什么」，不是逐帧的字节偏移记账。
+	*
+	* 但 `next` 偏移会一并返回：客户端想增量续读时，拿它当 `from` 再调一次即可，
+	* 不必从头拉。`lossy` 也透出去，让客户端知道「有字节被留存策略吃掉了」，
+	* 而不是把一段对不上的输出当成完整的。
+	*/
+	async follow(sessionId, jobId, from, signal) {
+		const stream = this.host.jobController.follow({
+			sessionId,
+			jobId,
+			...from === void 0 ? {} : { from }
+		}, signal);
+		const parts = [];
+		let next = from ?? 0;
+		let lossy = false;
+		let status;
+		let sawOpened = false;
+		try {
+			for await (const frame of stream) {
+				if (frame === null || typeof frame !== "object") continue;
+				if (frame.type === "opened") {
+					sawOpened = true;
+					status = toJobView(frame.job).status;
+					next = typeof frame.from === "number" ? frame.from : next;
+					continue;
+				}
+				if (frame.type === "output") {
+					const chunks = frame.chunks;
+					if (Array.isArray(chunks)) {
+						for (const chunk of chunks) if (chunk !== null && typeof chunk === "object" && typeof chunk.text === "string") parts.push(chunk.text);
+					}
+					if (typeof frame.next === "number") next = frame.next;
+					if (frame.lossy === true) lossy = true;
+					continue;
+				}
+				if (frame.type === "status") {
+					status = toJobView(frame.job).status;
+					break;
+				}
+			}
+		} catch (error) {
+			if (isJobNotFound(error)) throw new JobApiError(404, "JOB_NOT_FOUND", `No observable job ${jobId} for this session.`);
+			throw new JobApiError(502, "JOB_FOLLOW_FAILED", error instanceof Error ? error.message : String(error));
+		}
+		if (!sawOpened) throw new JobApiError(502, "JOB_STREAM_EMPTY", "The job observation stream closed before its anchor.");
+		return {
+			jobId,
+			text: parts.join(""),
+			next,
+			lossy,
+			...status === void 0 ? {} : { status }
+		};
+	}
+	/**
+	* 终止一个后台任务。
+	*
+	* 内核的 `kill` 是**同步**的，且只有 `requested` / `already-finished` 两种返回；
+	* 「这个任务不存在或该会话看不到它」走 `job/not-found` 远程错误，在这里转成 404。
+	*/
+	kill(sessionId, jobId) {
+		let value;
+		try {
+			value = this.host.jobController.kill({
+				sessionId,
+				jobId
+			});
+		} catch (error) {
+			if (isJobNotFound(error)) throw new JobApiError(404, "JOB_NOT_FOUND", `No killable job ${jobId} in this session.`);
+			throw new JobApiError(502, "JOB_KILL_FAILED", error instanceof Error ? error.message : String(error));
+		}
+		return {
+			jobId,
+			outcome: value.outcome
+		};
+	}
+};
+/** 内核 `job/not-found` 远程错误的识别。
+*
+* 内核的「任务不存在」有**两种错误形态**，判别必须都覆盖（2026-10-20 真机实测）：
+*
+* 1. **`kill`（同步 Remote 调用）**：抛带 `code: 'job/not-found'` 的 Remote 错误
+*    （`RemoteErrorDetailsMap` 里登记的那种）。看 code，不猜文案。
+* 2. **`follow` / `list`（AsyncIterable 流）**：流里 throw 的是普通
+*    `Error("unknown job <id>")`，**没有 code 元数据** —— 流帧协议里没有
+*    Remote 错误通道。只能认 message 前缀 `unknown job`。
+*
+* 这条曾漏过第二形态：output 对不存在的 job 返回 502 JOB_FOLLOW_FAILED
+* （「内核失败」）而非 404 JOB_NOT_FOUND（「任务不存在」）——
+* 客户端会把一次查错当成一次内核故障。真机一打就现形。
+*/
+function isJobNotFound(error) {
+	if (error === null || typeof error !== "object") return false;
+	const candidate = error;
+	if (candidate.code === "job/not-found") return true;
+	const details = candidate.details;
+	if (details !== null && typeof details === "object" && details.code === "job/not-found") return true;
+	if (typeof candidate.message !== "string") return false;
+	return candidate.message.includes("job/not-found") || candidate.message.startsWith("unknown job");
+}
 function normalizeListenerHost(value) {
 	if (typeof value !== "string" || value.trim() === "" || isIP(value.trim()) === 0) throw new ApiError(400, "LISTENER_HOST_INVALID", "host must be a numeric IPv4 or IPv6 address.");
 	return value.trim();
@@ -4662,6 +4953,32 @@ function stringifyWire(value) {
 }
 //#endregion
 //#region src/host/router.ts
+function matchJobRoute(pathname) {
+	const jobs = pathname.match(/^\/api\/v1\/chat\/sessions\/([^/]+)\/jobs$/);
+	if (jobs !== null) return {
+		kind: "list",
+		sessionId: decodeURIComponent(jobs[1])
+	};
+	const output = pathname.match(/^\/api\/v1\/chat\/sessions\/([^/]+)\/jobs\/([^/]+)\/output$/);
+	if (output !== null) return {
+		kind: "output",
+		sessionId: decodeURIComponent(output[1]),
+		jobId: decodeURIComponent(output[2])
+	};
+	const kill = pathname.match(/^\/api\/v1\/chat\/sessions\/([^/]+)\/jobs\/([^/]+)\/kill$/);
+	if (kill !== null) return {
+		kind: "kill",
+		sessionId: decodeURIComponent(kill[1]),
+		jobId: decodeURIComponent(kill[2])
+	};
+	const bare = pathname.match(/^\/api\/v1\/chat\/sessions\/([^/]+)\/jobs\/([^/]+)$/);
+	if (bare !== null) return {
+		kind: "unknown",
+		sessionId: decodeURIComponent(bare[1]),
+		jobId: decodeURIComponent(bare[2])
+	};
+	return null;
+}
 var ApiRouter = class {
 	options;
 	constructor(options) {
@@ -4706,6 +5023,12 @@ var ApiRouter = class {
 			});
 			return;
 		}
+		if (method === "GET" && pathname === "/api/v1/debug/host-services") {
+			const report = this.options.hostServiceReport;
+			if (report === void 0) throw new ApiError(404, "NOT_FOUND", "host service probe is not available in this build.");
+			sendJson(res, 200, report);
+			return;
+		}
 		if (method === "POST" && pathname === "/api/v1/pairings/exchange") {
 			this.options.auth.pairingAttempts.consume(requestAddress(req));
 			const body = await readJson(req, 16384);
@@ -4990,6 +5313,35 @@ var ApiRouter = class {
 			sendJson(res, 200, { archived: true });
 			return;
 		}
+		const jobDispatch = matchJobRoute(pathname);
+		if (jobDispatch !== null) {
+			const jobs = this.options.jobs;
+			if (jobs === void 0) throw new ApiError(404, "NOT_FOUND", "Background jobs are not available in this build.");
+			if (method === "GET" && jobDispatch.kind === "list") {
+				this.options.auth.requireScope(principal, "chat.read");
+				sendJson(res, 200, await jobs.list(jobDispatch.sessionId, AbortSignal.timeout(15e3)));
+				return;
+			}
+			if (method === "GET" && jobDispatch.kind === "output") {
+				this.options.auth.requireScope(principal, "chat.read");
+				const from = url.searchParams.get("from");
+				const offset = from === null ? void 0 : Number(from);
+				if (offset !== void 0 && !Number.isFinite(offset)) throw new ApiError(400, "QUERY_INVALID", "from must be a finite byte offset.");
+				sendJson(res, 200, await jobs.follow(jobDispatch.sessionId, jobDispatch.jobId, offset, AbortSignal.timeout(3e4)));
+				return;
+			}
+			if (method === "POST" && jobDispatch.kind === "kill") {
+				this.options.auth.requireScope(principal, "chat.write");
+				const result = jobs.kill(jobDispatch.sessionId, jobDispatch.jobId);
+				this.audit(principal, "chat.job.kill", void 0, void 0, requestId, {
+					sessionId: jobDispatch.sessionId,
+					jobId: jobDispatch.jobId
+				});
+				sendJson(res, 200, result);
+				return;
+			}
+			throw new ApiError(405, "METHOD_NOT_ALLOWED", "Unsupported method for the jobs resource.");
+		}
 		const messagesRoute = pathname.match(/^\/api\/v1\/chat\/sessions\/([^/]+)\/messages$/);
 		if (messagesRoute !== null) {
 			const sessionId = decodeURIComponent(messagesRoute[1]);
@@ -6371,6 +6723,7 @@ const inject = [
 	"webServer",
 	"agents",
 	"commands",
+	"jobController",
 	"fileUploads",
 	"attachments"
 ];
@@ -6406,7 +6759,24 @@ async function apply(ctx, config = {}) {
 		commands: ctx.commands
 	});
 	const settings = new DshSettingsAdapter(apiProxy);
+	let hostServiceReport;
+	try {
+		hostServiceReport = probeHostServices(ctx, PLUGIN_VERSION);
+		const { injectedAvailable, injectedTotal, injectedMissing } = hostServiceReport.summary;
+		const detail = injectedMissing.length === 0 ? "" : `，缺失：${injectedMissing.join(", ")}`;
+		ctx.logger.info(`dsh-remote-bridge: host services ${injectedAvailable}/${injectedTotal} 可注入${detail}`);
+		if (hostServiceReport.summary.observedAvailable.length > 0) ctx.logger.info(`dsh-remote-bridge: 观测到可用但未 inject 的服务：${hostServiceReport.summary.observedAvailable.join(", ")}`);
+	} catch (error) {
+		ctx.logger.warn(/* @__PURE__ */ new Error(`dsh-remote-bridge: host service probe failed: ${String(error)}`));
+	}
 	let router;
+	let jobControllerAvailable = false;
+	try {
+		ctx.jobController;
+		jobControllerAvailable = true;
+	} catch {
+		ctx.logger.warn(/* @__PURE__ */ new Error("dsh-remote-bridge: ctx.jobController unavailable, background-job endpoints disabled"));
+	}
 	const remote = new RemoteApiServer({
 		port,
 		remoteHost,
@@ -6426,7 +6796,9 @@ async function apply(ctx, config = {}) {
 		tunnels: new CloudflaredTunnelManager(),
 		cloudflaredBinDir: path.join(dataDir, "cloudflared-bin"),
 		maxUploadBytes,
-		imageFallbackDir: imageHandoffDir
+		imageFallbackDir: imageHandoffDir,
+		...hostServiceReport === void 0 ? {} : { hostServiceReport },
+		...jobControllerAvailable ? { jobs: new JobAdapter({ jobController: ctx.jobController }) } : {}
 	});
 	try {
 		await remote.start();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-remote-bridge",
-  "version": "2.4.2",
+  "version": "2.4.3",
   "description": "Versioned REST bridge for DeepSeek Harness: remote access for trusted clients (chat, files, devices) plus a Phone-settings panel inside the DSH WebUI.",
   "type": "module",
   "packageManager": "pnpm@11.19.0",
@@ -61,7 +61,8 @@
     "prepack": "npm run check"
   },
   "engines": {
-    "node": "^22.19.0 || >=24.0.0"
+    "node": "^22.19.0 || >=24.0.0",
+    "dsh": ">=0.2.0-rc.2 <0.3.0"
   },
   "keywords": [
     "dsh-plugin",