dsh-plugin-subagent-bridge 0.15.1 → 0.16.0

package/README.md

@@ -1,39 +1,38 @@
 # dsh-plugin-subagent-bridge
 
+> Let Codex or Claude Code drive DeepSeek Harness sessions as subagents — and let DSH drive them back.
+
 [![license](https://img.shields.io/badge/license-MIT-green)](LICENSE)
 [![dsh](https://img.shields.io/badge/DSH-%5E0.2.1--0-2f6fed)](https://github.com/deepseek-ai/deepseek-harness)
 <!-- M8ven ownership proof — keep this line in place; it verifies the publisher. -->
 [![M8ven Score](https://m8ven.ai/badge/mcp/dogtiti-dsh-plugin-subagent-bridge-8a3t8k?v=f15f3e56c3fa22e8aafb88cf5428501f)](https://m8ven.ai/mcp/dogtiti-dsh-plugin-subagent-bridge-8a3t8k?s=readme)
 
-在 DeepSeek Harness 宿主内部提供**本机回环 MCP 端点**，让另一个智能体把任务派给 DSH 会话并取回结果；反过来，DSH 里的 agent 也能把任务派给 Codex 或 Claude Code。
-
-两个方向共用同一个插件，各自遵守对方产品的 `maxDepth: 1`：**能派活，不能再派回来**。
+[中文说明](README.zh-CN.md)
 
----
+The plugin runs inside the Harness host and exposes a loopback MCP endpoint. It uses public host services (`sessionController`, `sessions`, `workspaceRegistry`, `userQuestions`) — no credential files, no cookie forgery.
 
-## 能力一览
+## Highlights
 
-| 方向 | 入口 | 一次调用做什么 |
-| --- | --- | --- |
-| Codex / 任意 MCP 客户端 → DSH | `dsh_task` | 开会话、投递、阻塞到这一轮结束，只回最终答案 |
-| 同上，并行 | `dsh_spawn` + `dsh_wait` | 立刻返回句柄，多个 worker 同时跑，再批量等 |
-| 同上，续派 | `dsh_followup` | 复用 worker 的上下文再派一轮 |
-| DSH → Codex | `codex_dispatch` | 跑一次 `codex exec`，回最终回答与可续接的线程 id |
-| DSH → Claude Code | `claude_dispatch` | 跑一次 `claude -p`，回最终回答与可续接的 session id |
+- **One tool call, one answer.** `dsh_task` opens a session, delivers the message, blocks until the turn ends, and returns only the final assistant text.
+- **Parallel workers.** `dsh_spawn` returns immediately; `dsh_wait` blocks until any of them settles.
+- **Per-call model and project.** Pin a worker to `provider/model` and file it under a named workspace without touching profile defaults.
+- **Queue or steer.** Choose whether a follow-up waits for the running turn or is inserted into it.
+- **Unattended by default.** Workers are told to assume a reasonable default instead of stopping to ask.
+- **Reverse direction.** `codex_dispatch` and `claude_dispatch` hand work to Codex or Claude Code, with resumable threads.
+- **Loop guard.** Depth and rate limits stop the two agents from delegating to each other in circles.
 
-插件运行在宿主进程内，直接用公开服务（`sessionController`、`sessions`、`workspaceRegistry`、`userQuestions`），不需要读凭据文件，也不需要伪造 cookie。
+## Requirements
 
----
+- DeepSeek Harness `^0.2.1-0`.
+- Codex CLI (`codex`) and/or Claude Code CLI (`claude`) on `PATH` for the reverse direction.
 
-## 安装
+## Install
 
 ```bash
 git clone https://github.com/Dogtiti/dsh-plugin-subagent-bridge
 ```
 
-Plugins → 添加 → 选该目录。
-
-启动后在 `127.0.0.1:47821` 监听，并把端点写到 `~/.dsh/bridge/endpoint.json`（目录 0700、文件 0600）：
+Open **Plugins → Add** in DSH and pick that directory. On start the plugin listens on `127.0.0.1:47821` and writes the endpoint file:
 
 ```json
 {
@@ -45,184 +44,169 @@ Plugins → 添加 → 选该目录。
 }
 ```
 
-## 接到 Codex
+`~/.dsh/bridge/endpoint.json`, directory `0700`, file `0600`.
+
+## Connect
+
+### Codex
 
 ```bash
 codex mcp add dsh-bridge --url "$(node -p "require(process.env.HOME+'/.dsh/bridge/endpoint.json').url")"
-codex mcp list          # 验证
-codex mcp remove dsh-bridge   # 移除
+codex mcp list                # verify
+codex mcp remove dsh-bridge   # remove
 ```
 
-桌面 App 与 CLI 共用 `~/.codex/config.toml`，两端都会看到这条。
+The desktop app and the CLI share `~/.codex/config.toml`, so both see it. The token lives in the URL path, so no environment variable is needed — the desktop app cannot receive custom ones when launched from Finder. `Authorization: Bearer <token>` works too.
 
-> token 放在 URL 路径里（能力 URL），所以 Codex 侧不需要配环境变量——桌面 App 从 Finder 启动时拿不到自定义环境变量。也支持 `Authorization: Bearer <token>`，需要时可用 `--bearer-token-env-var`。
-
-Claude Code 同理：
+### Claude Code
 
 ```bash
-claude mcp add --transport http dsh-bridge "<上面那个 url>" --scope user
+claude mcp add --transport http dsh-bridge "<the url above>" --scope user
 ```
 
----
-
-## 正向：Codex → DSH
-
-### 工具
-
-| 工具 | 作用 |
-| --- | --- |
-| `dsh_task` | **同步**派活：开会话、投递、阻塞到这一轮结束，只返回**最终回答** |
-| `dsh_spawn` | **异步**派活：立刻返回 `task_name` + `sessionId`，可并行开多个 |
-| `dsh_followup` | 给已有 worker 再派一轮（复用上下文） |
-| `dsh_wait` | 一次等多批 worker，任一到达终态即返回 |
-| `dsh_close` | 关闭 worker，释放并发名额（不删除会话） |
-| `dsh_answer` | 代用户回答 worker 提出的问题（见「问题上报」） |
-| `dsh_list_workers` | 列出本桥开的 worker 及实时状态 |
-| `dsh_dispatch` | 向指定会话投递一条用户消息并开始一轮；返回 `requestId` 与 `seqAtDispatch` |
-| `dsh_read_result` | **长轮询**读该会话在 `seqAtDispatch` 之后的全部助手文本（看过程用；要结果用 `dsh_wait`） |
-| `dsh_list_sessions` | 列出会话**元数据**（id、标题、工作目录、是否运行、最后活动时间） |
-
-### 基本用法
+## Usage
 
 ```js
-// 同步：等它跑完，直接拿最终答案
-dsh_task({ prompt: "审一下 src/bridge.ts 的错误处理", cwd: "/repo", timeoutSeconds: 300 })
+// Synchronous: wait for the turn, get the answer
+dsh_task({ prompt: "Review the error handling in src/bridge.ts", cwd: "/repo" })
 
-// 并行：先拿句柄，再批量等
+// Asynchronous: hand out work, then wait for all of it
 dsh_spawn({ task_name: "audit_api", message: "…", cwd: "/repo" })
 dsh_spawn({ task_name: "audit_ui",  message: "…", cwd: "/repo" })
 dsh_wait({ targets: ["audit_api", "audit_ui"], timeoutMs: 240000 })
 
-// 续派：复用 worker 的上下文
-dsh_followup({ worker: "audit_api", message: "把第 3 条展开，给出补丁" })
+// Continue an existing worker
+dsh_followup({ worker: "audit_api", message: "Expand item 3 and attach a patch" })
 ```
 
-边界：
+## Tools
 
-- `dsh_list_sessions` **只返回元数据**，不含任何消息内容；
-- `dsh_read_result` 只对**本桥派发过**的会话生效，从未派发过的会话一律拒绝。
+| Tool | Purpose |
+| --- | --- |
+| `dsh_task` | Synchronous dispatch: create session, deliver, block to end of turn, return the final answer |
+| `dsh_spawn` | Asynchronous dispatch: returns `task_name` + `sessionId` immediately |
+| `dsh_followup` | Another round on an existing worker, reusing its context |
+| `dsh_wait` | Wait on several workers at once; returns when any reaches a terminal state |
+| `dsh_close` | Close a worker and free its slot (the session stays) |
+| `dsh_answer` | Answer a worker's question (limited — see below) |
+| `dsh_list_workers` | List workers started by this bridge and their live status |
+| `dsh_dispatch` | Deliver one message to any session; returns `requestId` and `seqAtDispatch` |
+| `dsh_read_result` | Long-poll the assistant text produced after `seqAtDispatch` |
+| `dsh_list_sessions` | List session metadata only (id, title, cwd, running, last activity) |
 
-### 指定模型
+`dsh_list_sessions` never returns message content, and `dsh_read_result` only works for sessions this bridge has dispatched to.
 
-`dsh_task`、`dsh_spawn`、`dsh_followup` 都可以带 `model`：
+### Model
 
 ```js
 dsh_task({ prompt: "…", model: "zai-coding-cn/glm-5.3", reasoningEffort: "max" })
 dsh_spawn({ task_name: "review", message: "…", model: "opencode-go/deepseek-v4.1-flash" })
 ```
 
-- 写法是 `provider/model`；只写模型名时沿用当前默认 provider；
-- `reasoningEffort` 可选，取值随模型；
-- 不传就完全不动会话；
-- 实测：请求确实切到指定模型，且**不会改写 profile 的默认模型**。
+- `provider/model`; a bare model id keeps the current default provider.
+- `reasoningEffort` is optional and model-dependent.
+- Omitted means the session is untouched.
+- The switch happens before the first prompt, so the worker's first turn already runs on it, and the profile default model is not modified.
 
-实现上是在建好会话、发第一个 prompt **之前**调一次 `selectModel`，所以 worker 第一轮就在新模型上跑。
+### Workspace
 
-### 项目归属（`workspace`）
-
-DSH 的侧边栏分组（项目 / workspace）和工作目录是两回事：新建会话默认落在「未分组」，除非所在目录已经是项目。
+DSH groups sessions into projects; a new session lands under "Ungrouped" unless its directory is already a project.
 
 ```js
-dsh_task({ prompt: "…", cwd: "/repo/clawer", workspace: true })     // 用目录名建项目
+dsh_task({ prompt: "…", cwd: "/repo/clawer", workspace: true })    // create, titled after the directory
 dsh_spawn({ task_name: "w1", message: "…", cwd: "/repo/clawer", workspace: "Clawer" })
-dsh_task({ prompt: "…", cwd: "/repo/clawer" })                      // 只复用，不创建
+dsh_task({ prompt: "…", cwd: "/repo/clawer" })                     // reuse only
 ```
 
-- 目录不存在时先递归创建，再做项目登记（登记要求目录已存在）；
-- 目录已经是项目 → **复用，不改标题**；
-- 返回里带 `workspace: { id, title, path }`；
-- 项目操作失败不影响派发本身。
+Missing directories are created first (registration requires an existing directory). An existing project is reused without retitling. The result carries `workspace: { id, title, path }`. A failure here never fails the dispatch.
 
-### 排队还是插话（`mode`）
+### Queue or steer
 
-DSH 的「繁忙时的发送行为」只有两种，桥原样交给调用方：
+DSH's "sending while busy" has exactly two behaviours:
 
-| `mode` | DSH 里的名字 | 行为 |
-| --- | --- | --- |
-| `queue`（默认） | 排队发送 | 等当前回合跑完，作为新回合处理 |
-| `steer` | 插话发送 | 并入当前回合，模型下一步就能看到 |
+| `mode` | Behaviour |
+| --- | --- |
+| `queue` (default) | Wait for the current turn, then deliver as a new turn |
+| `steer` | Insert into the current turn; the model sees it at the next step |
 
 ```js
-dsh_followup({ worker: "w1", message: "接下来只改 src 下的文件", mode: "steer" })
+dsh_followup({ worker: "w1", message: "Only touch files under src from here", mode: "steer" })
 ```
 
-两个实测结论：
+Two measured facts:
 
-1. **`steer` 不打断正在执行的工具**——worker 若正卡在 `sleep 90` 这类调用里，消息要等它返回才被看到（实测 70 秒）。真想立刻停下是界面上的「取消」，不是投递模式。
-2. **`steer` 不新开回合**（turn 编号不变），所以桥等的是「当前回合结束」；等「下一回合」会一直等到超时。
+1. **`steer` does not interrupt a running tool call.** A worker inside `sleep 90` only sees the message when that call returns (70s in our test). Stopping it is the UI's cancel action, not a delivery mode.
+2. **`steer` does not open a new turn** — the turn number stays the same, so the bridge waits for the *current* turn to end. Waiting for the next one blocks until the timeout.
 
-`dsh_task` 对正在运行的会话默认拒绝，错误信息会提示改用 `steer`。插话的回复和原任务在同一回合里，桥会定位到**自己那条 user/message** 之后再取回答，避免混进原任务后续步骤的输出。
+`dsh_task` refuses a running session unless `mode: "steer"` is given, and the error message says so. A steered reply shares the turn with the original task, so the bridge anchors the answer on its own user message rather than the turn's last assistant text.
 
-### 无人值守（`assumeDefaults`）
+### Unattended workers
 
-worker 卡在 `ask_user_question` 上时需要有人在界面上点一下，但调用方是另一个 agent 时那个人往往不在。因此桥在派发时**自动追加一条常驻指令**：
+A worker that calls `ask_user_question` waits for a human. When the caller is another agent, nobody is there. So the bridge appends a standing instruction to every delegated task:
 
 ```
-（如果缺少必要信息或需要在多个方案里选择，直接采用最合理的默认做法继续做完，
-  不要把选择权抛回给用户、不要调用 ask_user_question 等回答；
-  在结果里用一行说明你假设了什么。）
+(If information is missing, or a choice between options is required, pick the most
+ reasonable default, finish the task, and state the assumption in one line. Do not
+ hand the decision back to the user and do not call ask_user_question.)
 ```
 
-- 默认开启，`assumeDefaults: false` 可关；
-- `dsh_task`、`dsh_spawn`、`dsh_followup` 三条路径都会加；
-- prompt 里本来就提到 `ask_user_question` 时不追加。
+Set your own wording with `assumptionPolicy`:
 
-效果：worker 不会停下来等人，而是选一个合理默认做法做完并交代假设，调用方据此复核。
+```yaml
+config:
+  assumptionPolicy: "If information is missing, pick the most reasonable default, finish the task, and state the assumption in one line. Do not ask the user and do not call ask_user_question."
+```
+
+On by default (`assumeDefaults: false` disables it). It is skipped when the prompt already mentions `ask_user_question`.
 
-### 问题上报（`pendingQuestion`）
+> The built-in default text is Chinese (`如果缺少必要信息……`), which every model in this host reads; the block above is that instruction in English. Set `assumptionPolicy` to send English verbatim.
 
-worker 真的问了问题时，`dsh_wait` 会把问题原样带出来：
+### Questions (`pendingQuestion`)
+
+If a worker does ask, `dsh_wait` reports it:
 
 ```jsonc
 {
   "status": { "w1": "running" },
-  "timedOut": true,
   "pendingQuestion": {
     "callId": "call_abc",
-    "questions": [{
-      "id": "mode",
-      "question": "用哪种模式？",
-      "header": "Choose Mode",
-      "options": [{ "label": "快速", "description": "只跑单测" }, { "label": "完整" }]
-    }]
+    "questions": [{ "id": "mode", "question": "Which mode?", "options": [{ "label": "Fast" }] }]
   },
   "next": "blocked on a question: answer it with dsh_answer, or call dsh_wait again"
 }
 ```
 
-`dsh_answer({ worker, answers: [{ id, selected: [...] }] })` 用来代答。**已知限制**：DSH 的 `userQuestions.answer()` 只接受已经超时、进入 `continued` 状态的问题；还阻塞在工具调用里的问题是 Web UI 的 answerer 接管的，桥答不了（实测返回 `answered: false`）。所以实际使用中更该依赖上面的 `assumeDefaults`，而不是等 worker 提问。
+`dsh_answer({ worker, answers: [{ id: "mode", selected: ["Fast"] }] })` submits a batch.
 
----
+**Known limit:** DSH's `userQuestions.answer()` only accepts questions that have already timed out into the `continued` state. A question still blocking inside the tool call belongs to the web UI's answerer, and the bridge cannot answer it (`answered: false` in practice). Prefer `assumeDefaults` over waiting for a question.
 
-## 反向：DSH → Codex / Claude Code
+## Reverse direction
 
-两个工具都会给本部署的 Agent 注册，参数形状一致，差别只在底层 CLI。
+Both tools are registered for agents of this deployment.
 
 ### `codex_dispatch`
 
-| 参数 | 说明 |
+| Parameter | Description |
 | --- | --- |
-| `prompt` | 必填，任务正文 |
-| `cwd` | 工作目录，默认当前会话目录 |
-| `resume` | Codex 线程 id，续接同一线程 |
+| `prompt` | Required task text |
+| `cwd` | Working directory; defaults to the calling session's |
+| `resume` | Codex thread id to continue |
 | `sandbox` | `read-only` / `workspace-write` / `danger-full-access` |
 
-返回 `{ ok, text, threadId, exitCode, durationMs }`。执行 `codex exec [resume <id>] --json -o <临时文件>`，从事件流取 `thread.started`、从 `-o` 取最终消息。**`resume` 时 `sandbox` 与 `cwd` 不生效**——`codex exec resume` 不接受 `-s` / `-C`。
+Returns `{ ok, text, threadId, exitCode, durationMs }`. Runs `codex exec [resume <id>] --json -o <tmpfile>`, reads `thread.started` from the event stream and the final message from the `-o` file. **`sandbox` and `cwd` are ignored on `resume`** — `codex exec resume` accepts neither.
 
 ### `claude_dispatch`
 
-| 参数 | 说明 |
+| Parameter | Description |
 | --- | --- |
-| `prompt` | 必填，任务正文 |
-| `cwd` | 工作目录 |
-| `resume` | Claude Code 的 session id |
-| `model` | 模型别名或 id；不传则用配置，再退回 CLI 自己的设置 |
-
-返回 `{ ok, text, sessionId, durationMs }`。执行 `claude -p --output-format json`，只读 stdout 的单个 JSON 对象；**stderr 的警告不算失败**（模型名带 `[1M]` 后缀时 CLI 会警告，但结果正常）。
+| `prompt` | Required task text |
+| `cwd` | Working directory |
+| `resume` | Claude Code session id |
+| `model` | Model alias or id; falls back to config, then to the CLI's own setting |
 
----
+Returns `{ ok, text, sessionId, durationMs }`. Runs `claude -p --output-format json` and reads the single JSON object on stdout. **stderr is advisory** — the CLI warns about an unrecognised model suffix while still succeeding.
 
-## 配置
+## Configuration
 
 ```yaml
 - insert:
@@ -232,148 +216,109 @@ worker 真的问了问题时，`dsh_wait` 会把问题原样带出来：
         port: 47821
 ```
 
-| 键 | 默认 | 说明 |
+| Key | Default | Description |
 | --- | --- | --- |
-| `enabled` | `true` | 总开关；关闭后不监听、不写端点文件 |
-| `port` | `47821` | 回环端口；固定端口让客户端那条 URL 重启后依然有效 |
-| `endpointFile` | `~/.dsh/bridge/endpoint.json` | 端点与令牌落盘位置 |
-| `maxResultChars` | `20000` | 单次结果返回的最大字符数（超出保留尾部） |
-| `taskTimeoutSeconds` | `300` | `dsh_task` 等待上限（客户端可覆盖，最大 240） |
-| `assumeDefaults` | `true` | 派发时追加「自行决策」的常驻指令 |
-| `workersFile` | `~/.dsh/bridge/workers.json` | worker 注册表（0600） |
-| `maxHops` | `1` | 跨工具委派层数上限 |
-| `dispatchPerMinute` | `10` | 滚动窗口内的派发次数 |
-| `dispatchWindowMs` | `60000` | 上述窗口长度 |
-| `maxWorkersPerRoot` | `4` | **每个工作目录**的 worker 上限 |
-| `maxWorkers` | `12` | 全局上限 |
-| `workerTtlMs` | `86400000` | 记录过期后不再占名额 |
-| `waitTimeoutMs` | `240000` | `dsh_wait` 默认超时 |
-| `readWaitSeconds` | `25` | `dsh_read_result` 默认长轮询时长 |
-| `codexBin` | `codex` | Codex 可执行文件；含 `/` 时严格按路径解析 |
-| `codexSandbox` | `workspace-write` | `codex_dispatch` 默认 sandbox |
-| `codexTimeoutMs` | `300000` | 单次 `codex_dispatch` 超时 |
-| `claudeBin` | `claude` | Claude Code 可执行文件 |
-| `claudeModel` | 空 | 默认让 Claude CLI 用自己的设置 |
-| `claudeTimeoutMs` | `300000` | 单次 `claude_dispatch` 超时 |
-
-端口被占用时不会静默换端口：端点文件里写入 `error` 字段，宿主日志打印 `subagent-bridge: could not start on port …`。
-
----
-
-## 护栏与限制
-
-### 防环
-
-两个 agent 都接了同一个桥时存在真实环路：DSH worker → `codex_dispatch` → 那次 Codex 也能看到 `dsh-bridge` → 又 `dsh_spawn` → …。双方进程内的深度规则都管不到这条链（桥建的 worker 是顶层会话，深度恒为 0）。
-
-**① 深度（`maxHops`，默认 1）**：每次派发都计算 `max(在飞链路深度, 调用方深度) + 1`，超限直接报错：
+| `enabled` | `true` | Master switch; when off, no listener and no endpoint file |
+| `port` | `47821` | Loopback port; fixed so the client URL survives restarts |
+| `endpointFile` | `~/.dsh/bridge/endpoint.json` | Where the endpoint and token are written |
+| `maxResultChars` | `20000` | Cap on a single result payload (the head is kept) |
+| `taskTimeoutSeconds` | `300` | `dsh_task` wait cap (client may override, max 240) |
+| `assumeDefaults` | `true` | Append the decide-and-continue instruction |
+| `assumptionPolicy` | *(empty)* | Replacement text for the instruction; empty uses the built-in Chinese default |
+| `workersFile` | `~/.dsh/bridge/workers.json` | Worker registry (`0600`) |
+| `maxHops` | `1` | Delegation depth limit |
+| `dispatchPerMinute` | `10` | Dispatches allowed per window |
+| `dispatchWindowMs` | `60000` | Window length |
+| `maxWorkersPerRoot` | `4` | Workers per working directory |
+| `maxWorkers` | `12` | Global worker cap |
+| `workerTtlMs` | `86400000` | Records stop counting once stale |
+| `waitTimeoutMs` | `240000` | Default `dsh_wait` timeout |
+| `readWaitSeconds` | `25` | Default `dsh_read_result` long-poll |
+| `codexBin` | `codex` | Codex executable; a value with `/` is resolved strictly |
+| `codexSandbox` | `workspace-write` | Default sandbox for `codex_dispatch` |
+| `codexTimeoutMs` | `300000` | Per-run timeout |
+| `claudeBin` | `claude` | Claude Code executable |
+| `claudeModel` | *(empty)* | Empty means the CLI's own setting |
+| `claudeTimeoutMs` | `300000` | Per-run timeout |
+
+A busy port is reported, not silently replaced: the endpoint file gets an `error` field and the host log prints `subagent-bridge: could not start on port …`.
+
+## Guardrails
+
+**Depth.** Both agents can see the same bridge, so a circle is possible: DSH worker → `codex_dispatch` → that Codex run → `dsh_spawn` → … Each dispatch computes `max(in-flight depth, caller depth) + 1` and refuses beyond `maxHops`:
 
 ```
 codex_dispatch would create delegation depth 2, but maxHops is 1.
 Carry the work out directly instead of delegating again.
 ```
 
-**② 速率（`dispatchPerMinute`，默认 10）**：拦截广度型失控与紧循环重试：
+**Rate.** `dispatchPerMinute` (default 10) catches bursts and tight retry loops:
 
 ```
 rate limit: 10 dispatches per 60s reached; retry in 23s
 ```
 
-### 名额
-
-- 每个 `cwd` 默认 **4 个**（`maxWorkersPerRoot`），全局 **12 个**（`maxWorkers`）；
-- **完成但没 `dsh_close` 的仍占名额**；
-- 记录 **24 小时**没更新自动释放；
-- 阻塞式 `dsh_task` 不计入名额，只登记。
-
-按 `cwd` 分桶而不是按会话，是因为 MCP 端点共享、请求里没有会话身份；`cwd` 是唯一由调用方稳定提供、且语义上对应「一个项目」的维度。
-
-### 跨重启
-
-worker 注册表和每轮的时间基线落在 `~/.dsh/bridge/workers.json`：
+**Slots.** 4 workers per `cwd`, 12 globally. A finished worker keeps its slot until `dsh_close`; records older than 24h stop counting. Blocking `dsh_task` calls are registered but do not consume a slot. Buckets are keyed by `cwd` because the MCP endpoint is shared and carries no session identity.
 
-- 重启后 `dsh_list_workers` 仍能看到之前的 worker；
-- 已结束的 worker，`dsh_wait` 直接返回缓存里的最终回答；
-- 重启时还在跑的，会话未打开时状态为 `offline`；
-- `dsh_followup` 会开新一轮并清掉旧回答；
-- 最多保留 200 条，超出先淘汰最旧的已关闭 worker。
+**Persistence.** `workers.json` keeps the registry and each turn's baseline: workers survive a restart, finished ones replay their cached answer, cold sessions report `offline`, and the file keeps at most 200 records.
 
-### 安全模型
+**Security.** Loopback only; every request needs the token in the path or a bearer header, compared in constant time; the token is generated once and persisted. Holding the endpoint file is equivalent to being able to send messages to sessions — keep its `0600`/`0700` permissions. DSH's own sandbox and approval rules still apply to anything delivered.
 
-- 只监听 `127.0.0.1`；
-- 请求必须带令牌：路径 `/mcp/<token>` 或 `Authorization: Bearer <token>`，定长时间比较；
-- 令牌首次启动生成并持久化，能力 URL 稳定；
-- 能力等价于「向指定会话投递消息」：能读到端点文件的进程就能派活，文件 0600、目录 0700；
-- DSH 侧的权限策略不受影响，派进去的消息仍按会话自身的 sandbox / 审批策略执行。
-
----
-
-## 实现
+## How it works
 
 ```
-Codex / 任意 MCP 客户端
-  │  POST /mcp/<token>   JSON-RPC（stateless，单次 JSON 响应）
+Codex / any MCP client
+  │  POST /mcp/<token>   JSON-RPC (stateless, single JSON response)
   ▼
-dsh-plugin-subagent-bridge（宿主进程内）
-  · node:http 监听 127.0.0.1:47821
+dsh-plugin-subagent-bridge (inside the host process)
+  · node:http on 127.0.0.1:47821
   · initialize / tools/list / tools/call / ping
   · sessionController.prompt({ sessionId, requestId, mode, content })
-  · sessions.get(id).snapshotEvents() 读回助手文本
+  · sessions.get(id).snapshotEvents() to read text back
 ```
 
-协议是 **streamable HTTP 的无状态子集**：每个 POST 返回一段 `application/json`，不做服务端推送，因此取结果用**长轮询**——`dsh_read_result` 在服务端等，客户端一次调用即可拿到答案；客户端断开时服务端立即停止等待。
+The protocol is a stateless subset of streamable HTTP: each POST returns one `application/json` body and nothing is pushed, so results are collected by long polling. The server stops waiting the moment the client disconnects.
 
----
+## Skills
 
-## 配套 skill
+Two installable skills turn this into behaviour a model follows rather than a tool it might forget:
 
-`skills/` 下有两份可直接安装的 skill，把「什么时候该派活、怎么派、怎么收尾」写成模型能读的规则：
-
-| Skill | 装给谁 | 作用 |
+| Skill | Install to | Purpose |
 | --- | --- | --- |
-| `deepseek-worker` | Codex | 让 Codex 把任务当 subagent 派给 DSH（`dsh_task`），一次调用等结果 |
-| `delegate-to-external-agent` | DSH | 让 DSH 的 agent 在需要独立视角/复核时派给 Codex 或 Claude Code，含两者差别与续接方式 |
+| `deepseek-worker` | Codex | When and how Codex should delegate to DSH |
+| `delegate-to-external-agent` | DSH | When DSH should delegate to Codex or Claude Code |
 
 ```bash
-# Codex 侧
 mkdir -p ~/.codex/skills && cp -R skills/deepseek-worker ~/.codex/skills/
-
-# DSH 侧
-mkdir -p ~/.dsh/skills && cp -R skills/delegate-to-external-agent ~/.dsh/skills/
+mkdir -p ~/.dsh/skills  && cp -R skills/delegate-to-external-agent ~/.dsh/skills/
 ```
 
-两份都是标准 `SKILL.md`：YAML frontmatter（`name` + `description`）+ 正文。**触发靠 description**——模型平时只看到名字和描述，判断相关了才读正文，所以描述里写满了中英触发语和「不要用」的边界。改完立刻生效，不用重启。
+Both are plain `SKILL.md` files: YAML frontmatter (`name` + `description`) plus body. Triggering depends entirely on the description, so they carry bilingual trigger phrases and explicit "don't use" boundaries. Changes take effect without a restart.
 
----
+## Compatibility
 
-## 兼容性
+- DSH `^0.2.1-0` (`engines.dsh`).
+- MCP protocol versions `2025-06-18`, `2025-03-26`, `2024-11-05`; unknown versions fall back to the newest.
+- Requires the public services `sessionController`, `sessions`, `workspaceRegistry`, `userQuestions`. Missing ones surface as explicit tool errors.
 
-- DSH `^0.2.1-0`（`engines.dsh`）；
-- MCP 协议版本：`2025-06-18`、`2025-03-26`、`2024-11-05`（按客户端请求回显，未知版本回落到最新）；
-- 依赖宿主公开服务 `sessionController`、`sessions`、`workspaceRegistry`、`userQuestions`；不可用时工具返回明确错误。
-
-## 开发
+## Development
 
 ```bash
 node --test "test/*.test.mjs"
 ```
 
-83 项，覆盖握手与版本协商、工具清单与参数校验、派发调用形状、结果读取的时间基线、长轮询、真实 HTTP 往返（含 404/405/202 与 bearer 分支）、`codex exec` 事件解析与二进制解析、成功/失败/超时三种运行结果、resume 的参数分叉、只回最终回答、`dsh_wait` 的四种终态、并发上限与释放、followup 重基线、注册表落盘与重启复原、`maxHops` 与速率限制、按 `cwd` 分桶的预算、工作区归属、`workspace` 创建与复用、`queue` / `steer` 的投递与等待、插话回答的定位、`claude` 输出解析与 resume 参数、`assumeDefaults` 指令注入、`pendingQuestion` 与 `dsh_answer`。
-
-`test/persistence.test.mjs` 单独覆盖持久化：文件权限、缺失/损坏记录、并发写、冷会话缓存与 `offline`。
-
----
+83 tests: handshake and version negotiation, tool list and argument validation, dispatch call shape, result baselines, long polling, real HTTP round trips (404/405/202 and bearer), `codex exec` event parsing, binary resolution, success/failure/timeout runs, resume argument split, final-answer-only behaviour, `dsh_wait` terminal states, slot limits and release, followup rebaselining, registry persistence and restart recovery, `maxHops` and rate limiting, per-`cwd` budgets, workspace creation and reuse, `queue`/`steer` delivery and waiting, anchors for steered answers, Claude output parsing and resume arguments, `assumeDefaults` injection, `pendingQuestion` and `dsh_answer`.
 
-## 相关插件
+## Related
 
-| 插件 | 说明 |
+| Plugin | Description |
 | --- | --- |
-| **dsh-plugin-subagent-bridge**（本仓库） | 让 Codex 通过本机 MCP 把 DSH 当 subagent 用，反向也能派给 Codex / Claude Code |
-| [dsh-plugin-composer-predict](https://github.com/Dogtiti/dsh-plugin-composer-predict) | 预测下一条指令并显示为占位文字，`Tab` 采纳 |
-| [dsh-plugin-composer-history](https://github.com/Dogtiti/dsh-plugin-composer-history) | 输入框中按 `↑` / `↓` 回填历史消息 |
-| [dsh-plugin-usage-panel](https://github.com/Dogtiti/dsh-plugin-usage-panel) | 在模型选择器旁显示供应商套餐额度余量 |
-| [dsh-plugin-provider-icons](https://github.com/Dogtiti/dsh-plugin-provider-icons) | 在模型名旁显示供应商品牌 logo |
+| **dsh-plugin-subagent-bridge** (this repo) | Let Codex drive DSH as a subagent, and DSH drive Codex / Claude Code |
+| [dsh-plugin-composer-predict](https://github.com/Dogtiti/dsh-plugin-composer-predict) | Predicts the next instruction as placeholder text; `Tab` accepts |
+| [dsh-plugin-composer-history](https://github.com/Dogtiti/dsh-plugin-composer-history) | `↑` / `↓` in the composer to recall previous messages |
+| [dsh-plugin-usage-panel](https://github.com/Dogtiti/dsh-plugin-usage-panel) | Provider quota next to the model picker |
+| [dsh-plugin-provider-icons](https://github.com/Dogtiti/dsh-plugin-provider-icons) | Provider logos next to model names |
 
-## 许可
+## License
 
 MIT © [Dogtiti](https://github.com/Dogtiti)

package/README.zh-CN.md

@@ -0,0 +1,322 @@
+# dsh-plugin-subagent-bridge
+
+> 让 Codex 或 Claude Code 把 DeepSeek Harness 会话当作 subagent 来用 —— 反过来，DSH 也能把任务派给它们。
+
+[![license](https://img.shields.io/badge/license-MIT-green)](LICENSE)
+[![dsh](https://img.shields.io/badge/DSH-%5E0.2.1--0-2f6fed)](https://github.com/deepseek-ai/deepseek-harness)
+<!-- M8ven ownership proof — keep this line in place; it verifies the publisher. -->
+[![M8ven Score](https://m8ven.ai/badge/mcp/dogtiti-dsh-plugin-subagent-bridge-8a3t8k?v=f15f3e56c3fa22e8aafb88cf5428501f)](https://m8ven.ai/mcp/dogtiti-dsh-plugin-subagent-bridge-8a3t8k?s=readme)
+
+[English](README.md)
+
+插件运行在 Harness 宿主进程内，对外暴露一个回环 MCP 端点。它只用宿主公开服务（`sessionController`、`sessions`、`workspaceRegistry`、`userQuestions`）——不读凭据文件，也不伪造 cookie。
+
+## 特性
+
+- **一次调用，一个答案。** `dsh_task` 开会话、投递消息、阻塞到这一轮结束，只返回最终的助手文本。
+- **并行 worker。** `dsh_spawn` 立即返回；`dsh_wait` 阻塞到其中任意一个到达终态。
+- **按次指定模型与项目。** 把 worker 钉在 `provider/model` 上、归入指定项目，且不改动 profile 默认值。
+- **排队或插话。** 由调用方决定后续消息是等当前回合，还是插进当前回合。
+- **默认无人值守。** worker 被告知采用合理默认继续，而不是停下来提问。
+- **反向能力。** `codex_dispatch` 与 `claude_dispatch` 把任务交给 Codex 或 Claude Code，且线程可续接。
+- **防环。** 深度与速率限制阻止两个 agent 互相派活绕圈。
+
+## 环境要求
+
+- DeepSeek Harness `^0.2.1-0`。
+- 反向方向需要 `PATH` 上有 Codex CLI（`codex`）和/或 Claude Code CLI（`claude`）。
+
+## 安装
+
+```bash
+git clone https://github.com/Dogtiti/dsh-plugin-subagent-bridge
+```
+
+在 DSH 里打开 **Plugins → 添加**，选择该目录。启动后插件监听 `127.0.0.1:47821`，并写入端点文件：
+
+```json
+{
+  "url": "http://127.0.0.1:47821/mcp/<token>",
+  "port": 47821,
+  "token": "<token>",
+  "pid": 12345,
+  "startedAt": "2026-10-22T12:30:00.000Z"
+}
+```
+
+`~/.dsh/bridge/endpoint.json`，目录 `0700`，文件 `0600`。
+
+## 连接
+
+### Codex
+
+```bash
+codex mcp add dsh-bridge --url "$(node -p "require(process.env.HOME+'/.dsh/bridge/endpoint.json').url")"
+codex mcp list                # 验证
+codex mcp remove dsh-bridge   # 移除
+```
+
+桌面 App 与 CLI 共用 `~/.codex/config.toml`，两端都能看到。token 放在 URL 路径里，因此不需要环境变量——桌面 App 从 Finder 启动时拿不到自定义环境变量。也支持 `Authorization: Bearer <token>`。
+
+### Claude Code
+
+```bash
+claude mcp add --transport http dsh-bridge "<上面那个 url>" --scope user
+```
+
+## 用法
+
+```js
+// 同步：等这一轮跑完，直接拿答案
+dsh_task({ prompt: "审一下 src/bridge.ts 的错误处理", cwd: "/repo" })
+
+// 异步：先派活，再一起等
+dsh_spawn({ task_name: "audit_api", message: "…", cwd: "/repo" })
+dsh_spawn({ task_name: "audit_ui",  message: "…", cwd: "/repo" })
+dsh_wait({ targets: ["audit_api", "audit_ui"], timeoutMs: 240000 })
+
+// 续派：复用已有 worker 的上下文
+dsh_followup({ worker: "audit_api", message: "把第 3 条展开，附上补丁" })
+```
+
+## 工具
+
+| 工具 | 作用 |
+| --- | --- |
+| `dsh_task` | 同步派活：开会话、投递、阻塞到回合结束，返回最终回答 |
+| `dsh_spawn` | 异步派活：立刻返回 `task_name` + `sessionId` |
+| `dsh_followup` | 在已有 worker 上再派一轮，复用其上下文 |
+| `dsh_wait` | 一次等多个 worker，任一到达终态即返回 |
+| `dsh_close` | 关闭 worker 并释放名额（会话保留） |
+| `dsh_answer` | 回答 worker 提出的问题（有已知限制，见下） |
+| `dsh_list_workers` | 列出本桥开的 worker 及实时状态 |
+| `dsh_dispatch` | 向任意会话投递一条消息；返回 `requestId` 与 `seqAtDispatch` |
+| `dsh_read_result` | 长轮询读取 `seqAtDispatch` 之后产生的助手文本 |
+| `dsh_list_sessions` | 只列会话元数据（id、标题、cwd、是否运行、最后活动时间） |
+
+`dsh_list_sessions` 从不返回消息内容；`dsh_read_result` 只对本桥派发过的会话有效。
+
+### 指定模型
+
+```js
+dsh_task({ prompt: "…", model: "zai-coding-cn/glm-5.3", reasoningEffort: "max" })
+dsh_spawn({ task_name: "review", message: "…", model: "opencode-go/deepseek-v4.1-flash" })
+```
+
+- 写法是 `provider/model`；只写模型名时沿用当前默认 provider。
+- `reasoningEffort` 可选，取值随模型。
+- 不传则完全不动会话。
+- 切换发生在第一次 prompt 之前，所以 worker 第一轮就已经在新模型上跑，且不会改动 profile 的默认模型。
+
+### 项目归属
+
+DSH 把会话分组为项目；新建会话默认落在「未分组」，除非所在目录已经是项目。
+
+```js
+dsh_task({ prompt: "…", cwd: "/repo/clawer", workspace: true })    // 创建，标题取目录名
+dsh_spawn({ task_name: "w1", message: "…", cwd: "/repo/clawer", workspace: "Clawer" })
+dsh_task({ prompt: "…", cwd: "/repo/clawer" })                     // 只复用
+```
+
+目录不存在会先创建（登记要求目录已存在）。已是项目则复用且**不改标题**。返回里带 `workspace: { id, title, path }`。项目操作失败不会让派发失败。
+
+### 排队或插话
+
+DSH 的「繁忙时的发送行为」只有两种：
+
+| `mode` | 行为 |
+| --- | --- |
+| `queue`（默认） | 等当前回合结束，作为新回合投递 |
+| `steer` | 插入当前回合，模型在下一步就能看到 |
+
+```js
+dsh_followup({ worker: "w1", message: "接下来只改 src 下的文件", mode: "steer" })
+```
+
+两个实测结论：
+
+1. **`steer` 不打断正在执行的工具调用。** worker 若正卡在 `sleep 90` 里，要等那次调用返回才看得到消息（实测 70 秒）。真的停下是界面上的「取消」，不是投递模式。
+2. **`steer` 不新开回合** —— turn 编号不变，所以桥等的是**当前**回合结束；等「下一个回合」会一直阻塞到超时。
+
+`dsh_task` 对运行中的会话默认拒绝，除非传 `mode: "steer"`，错误信息里也这么写。插话的回复与原任务同一回合，所以桥以**自己那条用户消息**为锚点取回答，而不是这一轮最后一条助手文本。
+
+### 无人值守
+
+调用 `ask_user_question` 的 worker 会等人回答。调用方是另一个 agent 时，没有人在这。因此桥给每个派发的任务追加一条常驻指令：
+
+```
+（如果缺少必要信息或需要在多个方案里选择，直接采用最合理的默认做法继续做完，
+  不要把选择权抛回给用户、不要调用 ask_user_question 等回答；
+  在结果里用一行说明你假设了什么。）
+```
+
+默认开启（`assumeDefaults: false` 可关闭）。prompt 里本来就提到 `ask_user_question` 时不追加。
+
+想换成自己的措辞——比如英文——用 `assumptionPolicy`：
+
+```yaml
+config:
+  assumptionPolicy: "If information is missing, pick the most reasonable default, finish the task, and state the assumption in one line. Do not ask the user or call ask_user_question."
+```
+
+### 问题上报
+
+worker 真的提问时，`dsh_wait` 会把问题带出来：
+
+```jsonc
+{
+  "status": { "w1": "running" },
+  "pendingQuestion": {
+    "callId": "call_abc",
+    "questions": [{ "id": "mode", "question": "用哪种模式？", "options": [{ "label": "快速" }] }]
+  },
+  "next": "blocked on a question: answer it with dsh_answer, or call dsh_wait again"
+}
+```
+
+`dsh_answer({ worker, answers: [{ id: "mode", selected: ["快速"] }] })` 提交答案。
+
+**已知限制：** DSH 的 `userQuestions.answer()` 只接受已经超时进入 `continued` 状态的问题。仍阻塞在工具调用里的问题由 Web UI 的 answerer 接管，桥答不了（实测返回 `answered: false`）。实际使用中应依赖 `assumeDefaults`，而不是等 worker 提问。
+
+## 反向方向
+
+两个工具都注册给本部署的 Agent。
+
+### `codex_dispatch`
+
+| 参数 | 说明 |
+| --- | --- |
+| `prompt` | 必填，任务正文 |
+| `cwd` | 工作目录；默认用调用方会话的目录 |
+| `resume` | Codex 线程 id，用于续接 |
+| `sandbox` | `read-only` / `workspace-write` / `danger-full-access` |
+
+返回 `{ ok, text, threadId, exitCode, durationMs }`。执行 `codex exec [resume <id>] --json -o <临时文件>`，从事件流读 `thread.started`，从 `-o` 文件读最终消息。**`resume` 时 `sandbox` 与 `cwd` 均不生效** —— `codex exec resume` 不接受这两个参数。
+
+### `claude_dispatch`
+
+| 参数 | 说明 |
+| --- | --- |
+| `prompt` | 必填，任务正文 |
+| `cwd` | 工作目录 |
+| `resume` | Claude Code 的 session id |
+| `model` | 模型别名或 id；不传则用配置，再退回 CLI 自己的设置 |
+
+返回 `{ ok, text, sessionId, durationMs }`。执行 `claude -p --output-format json`，只读 stdout 上的单个 JSON 对象。**stderr 只是提示** —— 模型名后缀不被识别时 CLI 会警告，但结果仍然正常。
+
+## 配置
+
+```yaml
+- insert:
+    - id: subagent-bridge
+      name: 'dsh-plugin-subagent-bridge'
+      config:
+        port: 47821
+```
+
+| 键 | 默认 | 说明 |
+| --- | --- | --- |
+| `enabled` | `true` | 总开关；关闭后不监听、不写端点文件 |
+| `port` | `47821` | 回环端口；固定端口让客户端 URL 重启后依然有效 |
+| `endpointFile` | `~/.dsh/bridge/endpoint.json` | 端点与令牌写入位置 |
+| `maxResultChars` | `20000` | 单次结果载荷上限（保留开头） |
+| `taskTimeoutSeconds` | `300` | `dsh_task` 等待上限（客户端可覆盖，最大 240） |
+| `assumeDefaults` | `true` | 追加「自行决策」指令 |
+| `assumptionPolicy` | 空 | 替换指令正文；空表示用内置中文默认 |
+| `workersFile` | `~/.dsh/bridge/workers.json` | worker 注册表（`0600`） |
+| `maxHops` | `1` | 委派深度上限 |
+| `dispatchPerMinute` | `10` | 每个窗口允许的派发次数 |
+| `dispatchWindowMs` | `60000` | 窗口长度 |
+| `maxWorkersPerRoot` | `4` | 每个工作目录的 worker 上限 |
+| `maxWorkers` | `12` | 全局 worker 上限 |
+| `workerTtlMs` | `86400000` | 记录过期后不再占名额 |
+| `waitTimeoutMs` | `240000` | `dsh_wait` 默认超时 |
+| `readWaitSeconds` | `25` | `dsh_read_result` 默认长轮询时长 |
+| `codexBin` | `codex` | Codex 可执行文件；含 `/` 时严格按路径解析 |
+| `codexSandbox` | `workspace-write` | `codex_dispatch` 默认 sandbox |
+| `codexTimeoutMs` | `300000` | 单次运行超时 |
+| `claudeBin` | `claude` | Claude Code 可执行文件 |
+| `claudeModel` | 空 | 空表示用 CLI 自己的设置 |
+| `claudeTimeoutMs` | `300000` | 单次运行超时 |
+
+端口被占用时会**报错而不是静默换端口**：端点文件里写入 `error` 字段，宿主日志打印 `subagent-bridge: could not start on port …`。
+
+## 护栏
+
+**深度。** 两个 agent 都能看到同一个桥，因此存在环路：DSH worker → `codex_dispatch` → 那次 Codex → `dsh_spawn` → … 每次派发都计算 `max(在飞链路深度, 调用方深度) + 1`，超过 `maxHops` 直接拒绝：
+
+```
+codex_dispatch would create delegation depth 2, but maxHops is 1.
+Carry the work out directly instead of delegating again.
+```
+
+**速率。** `dispatchPerMinute`（默认 10）拦截突发与紧循环重试：
+
+```
+rate limit: 10 dispatches per 60s reached; retry in 23s
+```
+
+**名额。** 每个 `cwd` 4 个，全局 12 个。完成的 worker 在 `dsh_close` 之前仍占名额；记录超过 24 小时自动不再计数。阻塞式 `dsh_task` 只登记、不占名额。按 `cwd` 分桶是因为 MCP 端点共享且请求里没有会话身份。
+
+**持久化。** `workers.json` 保存注册表与每轮基线：重启后 worker 仍在，已完成的直接回放缓存答案，冷会话报告 `offline`，文件最多保留 200 条。
+
+**安全。** 只监听回环；每个请求都要令牌（路径或 bearer 头），常量时间比较；令牌只生成一次并持久化。拿到端点文件等价于能向会话投递消息——保持 `0600`/`0700` 权限。DSH 自身的 sandbox 与审批规则对投递内容依然生效。
+
+## 工作原理
+
+```
+Codex / 任意 MCP 客户端
+  │  POST /mcp/<token>   JSON-RPC（无状态，单次 JSON 响应）
+  ▼
+dsh-plugin-subagent-bridge（宿主进程内）
+  · node:http 监听 127.0.0.1:47821
+  · initialize / tools/list / tools/call / ping
+  · sessionController.prompt({ sessionId, requestId, mode, content })
+  · sessions.get(id).snapshotEvents() 读回文本
+```
+
+协议是 streamable HTTP 的无状态子集：每个 POST 返回一个 `application/json`，没有任何推送，所以结果靠长轮询取。客户端一断开，服务端立刻停止等待。
+
+## 配套 skill
+
+两份可安装的 skill 把这些能力变成模型会遵循的行为，而不是它可能忘记的工具：
+
+| Skill | 装给谁 | 作用 |
+| --- | --- | --- |
+| `deepseek-worker` | Codex | Codex 何时、如何把任务派给 DSH |
+| `delegate-to-external-agent` | DSH | DSH 何时该派给 Codex 或 Claude Code |
+
+```bash
+mkdir -p ~/.codex/skills && cp -R skills/deepseek-worker ~/.codex/skills/
+mkdir -p ~/.dsh/skills  && cp -R skills/delegate-to-external-agent ~/.dsh/skills/
+```
+
+两份都是普通 `SKILL.md`：YAML frontmatter（`name` + `description`）加正文。触发全靠 description，所以里面写了中英触发语和明确的「不要用」边界。改完不用重启即刻生效。
+
+## 兼容性
+
+- DSH `^0.2.1-0`（`engines.dsh`）。
+- MCP 协议版本 `2025-06-18`、`2025-03-26`、`2024-11-05`；未知版本回落到最新。
+- 依赖公开服务 `sessionController`、`sessions`、`workspaceRegistry`、`userQuestions`；缺失时以明确的工具错误呈现。
+
+## 开发
+
+```bash
+node --test "test/*.test.mjs"
+```
+
+83 项测试：握手与版本协商、工具清单与参数校验、派发调用形状、结果基线、长轮询、真实 HTTP 往返（404/405/202 与 bearer）、`codex exec` 事件解析、二进制解析、成功/失败/超时、resume 参数分叉、只回最终回答、`dsh_wait` 终态、名额上限与释放、followup 重基线、注册表持久化与重启恢复、`maxHops` 与速率限制、按 `cwd` 的预算、项目创建与复用、`queue`/`steer` 投递与等待、插话回答的锚点、Claude 输出解析与 resume 参数、`assumeDefaults` 注入、`pendingQuestion` 与 `dsh_answer`。
+
+## 相关插件
+
+| 插件 | 说明 |
+| --- | --- |
+| **dsh-plugin-subagent-bridge**（本仓库） | 让 Codex 把 DSH 当 subagent 用，DSH 也能派给 Codex / Claude Code |
+| [dsh-plugin-composer-predict](https://github.com/Dogtiti/dsh-plugin-composer-predict) | 预测下一条指令并显示为占位文字，`Tab` 采纳 |
+| [dsh-plugin-composer-history](https://github.com/Dogtiti/dsh-plugin-composer-history) | 输入框中按 `↑` / `↓` 回填历史消息 |
+| [dsh-plugin-usage-panel](https://github.com/Dogtiti/dsh-plugin-usage-panel) | 在模型选择器旁显示供应商额度余量 |
+| [dsh-plugin-provider-icons](https://github.com/Dogtiti/dsh-plugin-provider-icons) | 在模型名旁显示供应商品牌 logo |
+
+## 许可
+
+MIT © [Dogtiti](https://github.com/Dogtiti)

package/index.js

@@ -76,6 +76,7 @@ const DEFAULTS = {
   codexSandbox: 'workspace-write',
   codexTimeoutMs: 300000,
   assumeDefaults: true,
+  assumptionPolicy: '',
   claudeBin: 'claude',
   claudeModel: '',
   claudeTimeoutMs: 300000,
@@ -329,7 +330,9 @@ const ASSUMPTION_POLICY =
 function withAssumptionPolicy(settings, message) {
   if (settings.assumeDefaults !== true) return message
   if (message.includes('ask_user_question')) return message
-  return `${message}\n\n（${ASSUMPTION_POLICY}）`
+  const custom = typeof settings.assumptionPolicy === 'string' ? settings.assumptionPolicy.trim() : ''
+  const policy = custom === '' ? ASSUMPTION_POLICY : custom
+  return `${message}\n\n（${policy}）`
 }
 
 /**
@@ -2336,6 +2339,10 @@ function resolveSettings(config) {
       merged.assumeDefaults = value === true || value === 'true'
       continue
     }
+    if (key === 'assumptionPolicy' && typeof value === 'string') {
+      merged.assumptionPolicy = value.trim()
+      continue
+    }
     if (key === 'claudeBin' && typeof value === 'string' && value !== '') merged.claudeBin = value
     if (key === 'claudeModel' && typeof value === 'string') merged.claudeModel = value
     if (key === 'workersFile' && typeof value === 'string' && value !== '') merged.workersFile = expandHome(value)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-plugin-subagent-bridge",
-  "version": "0.15.1",
+  "version": "0.16.0",
   "type": "module",
   "description": "Subagent bridge: lets Codex delegate a task to DeepSeek Harness the way it would spawn a subagent (one call, waits for the answer), plus a codex_dispatch tool for the reverse direction.",
   "keywords": [
@@ -28,7 +28,9 @@
     "cordis.patch.yml",
     "locale/*.json",
     "icon.svg",
-    "skills/*/SKILL.md"
+    "skills/*/SKILL.md",
+    "README.md",
+    "README.zh-CN.md"
   ],
   "engines": {
     "dsh": "^0.2.1-0"