dsh-baton-mcp 0.5.9 → 0.6.0-next.0

package/README.md

@@ -69,6 +69,29 @@ That is all. If Harness says it could not register, run `npx -y dsh-baton-mcp se
 - **Codex** waits inside `dsh_wait`, up to 270 s per call, just under its 300 s tool timeout. An unfinished wait returns only the state, so Codex calls again without summarising. Codex gets no `wait_command`: its terminal cannot wake it, so it would poll.
 - Codex asks you to approve MCP tool calls: approve the `dsh-baton` tools. For unattended `codex exec` runs, add `--approve-for-me`.
 
+**How a hand-over is checked** (from 0.6.0): the client sends the task with `checks`, the project's own test commands such as `npm test`. dsh-baton notes the folder's files before the run, and when the run ends it lists the files created, changed and deleted and runs the checks itself; this `evidence` comes from dsh-baton, not from the DeepSeek reply. The message also asks Harness to have a read-only sub-agent check the work against every requirement and end with a table (requirement, met, file:line). The client accepts from the evidence and that table, sends anything not met back in one message, and reads code only for rows not met. A new session starts in the folder the conversation works in unless `cwd` names another one.
+
+## Token usage
+
+Measured on 2026-10-25/26 with plain-language requests (what a user would type, plus "hand it to DeepSeek Harness"), the same model in both arms, three runs per cell, and every run checked by the same hidden acceptance test. Cost per task at list price; DeepSeek at its peak price, the most conservative case:
+
+| Task | Claude Code alone | Claude Code → 0.6.0 | Codex alone | Codex → 0.6.0 |
+|---|---|---|---|---|
+| Medium: CLI, modules, tests | $1.07 | $0.37 client, $0.55 with DeepSeek | $0.17 | $0.09 client, $0.29 with DeepSeek |
+| Large: web app, API, tests | $2.13 | $0.41 client, $0.70 with DeepSeek | $0.41 | $0.10 client, $0.41 with DeepSeek |
+
+- **Claude Code** spends 65–81% less, and still about half or less once DeepSeek is added.
+- **Codex** (gpt-6.1-sol, high) spends half to three quarters less of its own model, so a ChatGPT Plus 5-hour window lasts more than twice as long: 0.8% instead of 1.9% per medium task, 1.0% instead of 4.3% per large one. Sol is cheap, so with DeepSeek added a medium task costs more in total than doing it in Codex, and a large one about the same; the saving is in the subscription quota. With a pricier model the total drops too.
+- All 12 runs of 0.6.0 passed the acceptance test the first time.
+
+The [full report](./docs/benchmarks/token-usage-2026-10.md) has the method, every run, the earlier builds that were compared, raw data and scripts.
+
+<p align="center">
+  <img src="./docs/benchmarks/token-usage-2026-10/charts/natural-total-claude-release.svg" width="100%" alt="Claude Code cost per task: alone vs handed over, with and without the DeepSeek share">
+  <img src="./docs/benchmarks/token-usage-2026-10/charts/natural-total-codex-release.svg" width="100%" alt="Codex cost per task: alone vs handed over, with and without the DeepSeek share">
+  <img src="./docs/benchmarks/token-usage-2026-10/charts/natural-codex-quota-release.svg" width="100%" alt="Codex Plus 5-hour window used per task">
+</p>
+
 ## Tools
 
 <p align="center">
@@ -88,9 +111,9 @@ That is all. If Harness says it could not register, run `npx -y dsh-baton-mcp se
 | `dsh_create_workspace` | Register a folder as a workspace (creates the folder if missing); returns the existing one if already registered |
 | `dsh_list_sessions` | Sessions newest first, with title, folder and running state; filter by folder or text. Archived sessions are left out |
 | `dsh_read_session` | Recent prompts and replies of one session (with tool names); `archived: true` for an archived session |
-| `dsh_send` | Send a message: `session_id` continues that session; `cwd` or `workspace_id` starts a new one (a `cwd` that is not a workspace yet is registered first). Returns a `run_id` at once. In Harness the message is marked "Sent by Claude / ChatGPT from another chat". An archived session is refused: unarchive it in Harness, or start a new session. To a busy session, `mode` `followup` queues the message after the current turn and `steer` adds it to the running turn; left out, it does what Harness's own setting says (Settings → sending while busy: queue or steer), and `followup` when that cannot be read. `mode_source` says which applied |
+| `dsh_send` | Send a message: `session_id` continues that session; otherwise a new one starts in `cwd` or `workspace_id`, or, with neither, in the folder the conversation works in (a `cwd` that is not a workspace yet is registered first; a `cwd` outside the conversation's folder is allowed and noted in `folder_note`). `checks`: test commands dsh-baton runs itself when the run ends (see How a hand-over is checked). Returns a `run_id` at once. In Harness the message is marked "Sent by Claude / ChatGPT from another chat". An archived session is refused: unarchive it in Harness, or start a new session. To a busy session, `mode` `followup` queues the message after the current turn and `steer` adds it to the running turn; left out, it does what Harness's own setting says (Settings → sending while busy: queue or steer), and `followup` when that cannot be read. `mode_source` says which applied |
 | `dsh_status` | Run progress: state, recent text and tool calls, final reply; `waiting_on` when the turn is over but sub-agents or jobs still run; `human_interjections` when someone typed in the Harness UI mid-run; state `interrupted` for a run cut short by a Harness restart |
-| `dsh_wait` | Wait for the run to end (or until it stops to ask a person, see `dsh_answer`): up to 270 s per call for Codex, 50 s for other clients. Still going: returns `timed_out` with just the state; call it again. Clients that can wait in the background use `dsh_send`'s `wait_command` instead. `dsh_status` is a one-off look, not a way to wait |
+| `dsh_wait` | Wait for the run to end; a finished run carries `evidence` (files changed, check results) when the message was sent with `checks` (or until it stops to ask a person, see `dsh_answer`): up to 270 s per call for Codex, 50 s for other clients. Still going: returns `timed_out` with just the state; call it again. Clients that can wait in the background use `dsh_send`'s `wait_command` instead. `dsh_status` is a one-off look, not a way to wait |
 | `dsh_answer` | Answer the questions a run stopped to ask (Harness's ask_user_question): per question, an option number or label, free text, or skip; one at a time or all at once. `dsh_wait` and `wait_command` return as soon as a run asks, with the questions (`needs_input`, `question`; the option Harness's model would pick is in `harness_suggested`, apart from the labels). The assistant answers by its own judgment only when you told it to decide, and then passes `reason` and tells you what it chose and why; otherwise it brings you the questions, starting with its own recommendation and reason. You can also answer in the Harness window: whoever answers first wins |
 | `dsh_session_activity` | What a session is doing now: running turn, sub-agents (any depth), background jobs; `archived: true` for an archived session |
 | `dsh_update_queued` | Change a message still waiting in the queue of a busy session, by its `run_id`: `edit` its text, `remove` it, or `steer` it into the running turn now. Once it has reached the conversation it can no longer be changed |
@@ -98,7 +121,7 @@ That is all. If Harness says it could not register, run `npx -y dsh-baton-mcp se
 | `dsh_rename_session` | Rename a session |
 | `dsh_rename_workspace` | Rename a workspace (sidebar title only; the folder is not moved) |
 | `dsh_list_runs` | Recent runs, optionally of one session |
-| `dsh_call` | Backup entry: calls any `dsh_*` tool by name, for a conversation whose tool list predates an update; an unknown name lists the tools |
+| `dsh_call` | Calls any `dsh_*` tool by name: the less used tools (create and rename workspace, rename session, session activity, update queued, list runs) are not in the tool list from 0.6.0 on, to keep every request short, and are reached this way; also for a conversation whose tool list predates an update. An unknown name lists the tools |
 
 </details>
 

package/README.zh-CN.md

@@ -69,6 +69,29 @@ Codex 和 Claude 轮流往同一个 Harness 对话发消息，每条都标明是
 - **Codex** 在 `dsh_wait` 里等待，每次最多 270 秒，刚好低于它 300 秒的工具超时。没做完时只返回状态，Codex 会直接再调用，不会去总结进度。Codex 不会收到 `wait_command`：它的终端无法在命令结束时唤醒它，只能轮询。
 - Codex 调用 MCP 工具时会请你批准，批准 `dsh-baton` 的工具即可；无人值守的 `codex exec` 加上 `--approve-for-me`。
 
+**转交之后怎么验收**（0.6.0 起）：客户端发任务时附上 `checks`，也就是项目自己的测试命令，比如 `npm test`。dsh-baton 在运行前记下文件夹里的文件，运行结束后自己列出新建、修改、删除了哪些文件，并自己跑一遍这些命令；这份 `evidence`（证据）来自 dsh-baton，不是 DeepSeek 的自述。消息末尾还会请 Harness 派一个只读子智能体，对照每条需求复查，最后附一张表（需求、是否满足、依据在哪个文件第几行）。客户端凭证据和这张表验收，没满足的一次性发回去修，只对没满足的行看代码。新开对话默认建在当前对话所在的文件夹，除非用 `cwd` 指定别的文件夹。
+
+## Token 用量实测
+
+2026-10-25/26 实测：用户用大白话提需求（末尾加一句「交给 DeepSeek Harness 去做」），两边用同一个模型，每格跑 3 次，每次都用同一套隐藏的验收脚本检查。下表是每个任务的平均花费，按标价计；DeepSeek 按高峰价，是最保守的算法：
+
+| 任务 | Claude Code 自己做 | Claude Code → 0.6.0 | Codex 自己做 | Codex → 0.6.0 |
+|---|---|---|---|---|
+| 中号：命令行工具、分模块、测试 | $1.07 | 主 Agent $0.37，含 DeepSeek $0.55 | $0.17 | 主 Agent $0.09，含 DeepSeek $0.29 |
+| 大号：网页应用、接口、测试 | $2.13 | 主 Agent $0.41，含 DeepSeek $0.70 | $0.41 | 主 Agent $0.10，含 DeepSeek $0.41 |
+
+- **Claude Code** 自己的花费少 65–81%，加上 DeepSeek 后总价也只有自己做的一半左右甚至更少。
+- **Codex**（gpt-6.1-sol，high）自己模型的花费少一半到四分之三，ChatGPT Plus 的 5 小时额度能多撑一倍以上：中号任务从 1.9% 降到 0.8%，大号从 4.3% 降到 1.0%。Sol 本身很便宜，加上 DeepSeek 后，中号的总价比 Codex 自己做还贵，大号基本持平；省下的是订阅额度。主模型越贵，总价也越省。
+- 0.6.0 的 12 次运行全部一次通过验收。
+
+[完整报告](./docs/benchmarks/token-usage-2026-10.md)里有方法、每一次运行、对比过的其他版本、原始数据和脚本。
+
+<p align="center">
+  <img src="./docs/benchmarks/token-usage-2026-10/charts/natural-total-claude-release.zh.svg" width="100%" alt="Claude Code 每个任务的花费：自己做与转交，含与不含 DeepSeek">
+  <img src="./docs/benchmarks/token-usage-2026-10/charts/natural-total-codex-release.zh.svg" width="100%" alt="Codex 每个任务的花费：自己做与转交，含与不含 DeepSeek">
+  <img src="./docs/benchmarks/token-usage-2026-10/charts/natural-codex-quota-release.zh.svg" width="100%" alt="Codex Plus 每个任务占用的 5 小时额度">
+</p>
+
 ## 工具
 
 <p align="center">
@@ -88,9 +111,9 @@ Codex 和 Claude 轮流往同一个 Harness 对话发消息，每条都标明是
 | `dsh_create_workspace` | 把一个文件夹登记为工作区（文件夹不存在会先创建）；已登记的直接返回原来那个 |
 | `dsh_list_sessions` | 列出对话（最新在前），带标题、目录、是否在跑；可按目录或关键字过滤。已归档的对话不会列出 |
 | `dsh_read_session` | 读某个对话最近的消息和回复（含用到的工具名）；已归档的对话会带 `archived: true` |
-| `dsh_send` | 发消息。带 `session_id` 续接那个对话；带 `cwd` 或 `workspace_id` 新开对话（`cwd` 还不是工作区时会先登记）。立即返回 `run_id`。Harness 里这条消息会标注「由 Claude / ChatGPT 从另一个聊天发送」。已归档的对话会被拒绝：先在 Harness 里取消归档，或新开对话。对话正忙时，`mode` 为 `followup` 会排在当前回合之后，`steer` 会插进正在跑的回合；不传时跟随 Harness 自己的设置（设置 → 繁忙时的发送行为：排队发送或插话发送），读不到设置时按 `followup`。返回里的 `mode_source` 说明用的是哪种 |
+| `dsh_send` | 发消息。带 `session_id` 续接那个对话；否则新开对话，建在 `cwd` 或 `workspace_id` 指定的位置，都不带时建在当前对话所在的文件夹（`cwd` 还不是工作区时会先登记；指定的 `cwd` 在当前对话文件夹之外也可以，结果里的 `folder_note` 会提醒）。`checks`：运行结束后 dsh-baton 自己跑的测试命令（见「转交之后怎么验收」）。立即返回 `run_id`。Harness 里这条消息会标注「由 Claude / ChatGPT 从另一个聊天发送」。已归档的对话会被拒绝：先在 Harness 里取消归档，或新开对话。对话正忙时，`mode` 为 `followup` 会排在当前回合之后，`steer` 会插进正在跑的回合；不传时跟随 Harness 自己的设置（设置 → 繁忙时的发送行为：排队发送或插话发送），读不到设置时按 `followup`。返回里的 `mode_source` 说明用的是哪种 |
 | `dsh_status` | 查看运行进度：状态、最近的文字和工具调用、最终回复；回合结束但子智能体/后台任务还在跑时给出 `waiting_on`；中途有人在 Harness 界面里发消息时给出 `human_interjections`；被 Harness 重启打断的任务状态为 `interrupted` |
-| `dsh_wait` | 等运行结束（或者等到它停下来问人，见 `dsh_answer`）：Codex 每次最多等 270 秒，其他客户端 50 秒。没做完会带 `timed_out`，只返回状态，再调用一次即可。能在后台等待的客户端改用 `dsh_send` 返回的 `wait_command`。`dsh_status` 只用来看一眼，不用来等待 |
+| `dsh_wait` | 等运行结束；发消息时带了 `checks` 的，结束后会附上 `evidence`（改了哪些文件、测试结果）（或者等到它停下来问人，见 `dsh_answer`）：Codex 每次最多等 270 秒，其他客户端 50 秒。没做完会带 `timed_out`，只返回状态，再调用一次即可。能在后台等待的客户端改用 `dsh_send` 返回的 `wait_command`。`dsh_status` 只用来看一眼，不用来等待 |
 | `dsh_answer` | 回答运行中途提出的问题（Harness 的 ask_user_question）：每道题可以填选项编号或选项文字、自由填写，或者跳过；可以逐题回答，也可以一次答完。运行一提问，`dsh_wait` 和 `wait_command` 就会立刻返回，并带上题目（`needs_input`、`question`；Harness 那边模型推荐的选项单独放在 `harness_suggested` 里，不再写在选项文字中）。只有你说过让它自己决定时，助手才会按自己的判断回答，这时它会带上 `reason`，并告诉你选了什么、为什么；否则它会把题目转给你，开头先写它自己的建议和理由。你也可以直接在 Harness 窗口里回答，谁先答就算谁的 |
 | `dsh_session_activity` | 对话此刻在做什么：正在跑的回合、子智能体（任意层级）、后台任务；已归档的对话会带 `archived: true` |
 | `dsh_update_queued` | 按 `run_id` 修改还在忙碌对话队列里等待的消息：`edit` 改文字，`remove` 撤回，`steer` 立刻插进正在跑的回合。消息一旦进入对话就改不了了 |
@@ -98,7 +121,7 @@ Codex 和 Claude 轮流往同一个 Harness 对话发消息，每条都标明是
 | `dsh_rename_session` | 给对话改名 |
 | `dsh_rename_workspace` | 给工作区改名（只改侧边栏标题，不动文件夹） |
 | `dsh_list_runs` | 列出最近的运行，可按会话筛选 |
-| `dsh_call` | 备用入口：按名字调用任意 `dsh_*` 工具，用于对话的工具列表还是更新前的旧版时；名字不存在时会列出所有可用工具 |
+| `dsh_call` | 按名字调用任意 `dsh_*` 工具：0.6.0 起，不常用的工具（新建和重命名工作区、重命名对话、对话动态、修改排队消息、运行列表）不再出现在工具列表里，好让每次请求更短，改由这里调用；对话的工具列表还是更新前的旧版时也用它。名字不存在时会列出所有可用工具 |
 
 </details>
 

package/host/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-baton-host",
-  "version": "0.5.9",
+  "version": "0.6.0-next.0",
   "description": "DeepSeek Harness plugin for dsh-baton: adding it is the whole install. Switched on, it registers the dsh-baton MCP server for Claude Code and Codex, then takes the baton over a local, owner-only control socket, runs it in a specific session through the host's own session controller, and hands the result back when the turn is done.",
   "type": "module",
   "main": "lib/index.js",
@@ -20,7 +20,7 @@
     "LICENSE"
   ],
   "dependencies": {
-    "dsh-baton-mcp": "0.5.9"
+    "dsh-baton-mcp": "0.6.0-next.0"
   },
   "license": "MIT",
   "dsh": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-baton-mcp",
-  "version": "0.5.9",
+  "version": "0.6.0-next.0",
   "mcpName": "io.github.JialaoLiu/dsh-baton",
   "description": "Pass the baton from Claude Code, Codex or any MCP client to a local DeepSeek Harness: an MCP server that hands off tasks, continues a specific session, shows the run live in Harness and hands the result back when it is done.",
   "type": "module",

package/server.json

@@ -7,12 +7,12 @@
     "url": "https://github.com/JialaoLiu/dsh-baton",
     "source": "github"
   },
-  "version": "0.5.9",
+  "version": "0.6.0-next.0",
   "packages": [
     {
       "registryType": "npm",
       "identifier": "dsh-baton-mcp",
-      "version": "0.5.9",
+      "version": "0.6.0-next.0",
       "transport": {
         "type": "stdio"
       }

package/src/cli.mjs

@@ -65,8 +65,9 @@ async function main() {
     case 'wait': {
       const st = await core.api.wait({ run_id: rest[0], timeout_s: Number(flags.timeout) || 24 * 3600 })
       print({
-        ...(st.decided_for_user ? { hint: 'Required in your reply: you chose an answer for the user during this run, so start your reply by telling the user, in their language, what you chose and why (decided_for_user: answers and reason), then give the result. Passing on only final_text is not enough.', decided_for_user: st.decided_for_user } : {}),
+        ...(st.decided_for_user ? { hint: 'Required in your reply: you chose an answer for the user during this run, so start your reply by telling the user, in their language, what you chose and why (decided_for_user: answers and reason), then give the result. Passing on only final_text is not enough. ' + core.ENDED_HINT, decided_for_user: st.decided_for_user } : {}),
         run_id: st.run_id, state: st.state, session_id: st.session_id, timed_out: !!st.timed_out, error: st.error, final_text: st.final_text,
+        ...(st.state === 'completed' && !st.decided_for_user ? { hint: core.ENDED_HINT } : {}),
         ...(st.needs_input ? { needs_input: st.needs_input, question: st.question, ...(st.question ? { relay: core.relayText(st.question) } : {}), hint: st.question ? 'The run asks the user something. If the user allowed you to decide, choose by your own judgment and answer with dsh_answer (or dsh-baton answer), passing reason, and tell the user what you chose and why. Otherwise show the user relay, written in the user\'s language, with its first line filled in with your own pick and a reason from your own judgment of the question and the task (harness_suggested is only the asker\'s pick, never a reason by itself), and ask the user first. Then wait again.' : 'The run waits for a person in the Harness UI. Tell the user, then wait again.' } : {}) })
       process.exitCode = st.state === 'completed' ? 0 : st.needs_input ? 3 : 1
       return

package/src/core.mjs

@@ -9,6 +9,7 @@ import net from 'node:net'
 import { spawn, execFileSync } from 'node:child_process'
 import { fileURLToPath } from 'node:url'
 import { setting, batonHome, socketEndpoint, hostEndpoints } from '../host/lib/socket.js'
+import * as evidence from './evidence.mjs'
 
 const HERE = path.dirname(fileURLToPath(import.meta.url))
 export const ROOT = path.resolve(HERE, '..')
@@ -526,6 +527,12 @@ async function useHost() {
   return up
 }
 
+// Said with a finished run's reply: review from the evidence dsh-baton produced, read code only
+// where it points, and send every fix back in one message.
+export const REVIEW_REQUEST = '\n\n---\nWhen the work is done, start a read-only sub-agent to check it against every requirement above, then end your final reply with its table: requirement | met (yes / no / unclear) | evidence (file:line or test name). Fix anything marked no before replying.'
+
+export const ENDED_HINT = 'evidence is produced by dsh-baton (files changed, checks it ran), not by the Harness reply: trust it over final_text. If a check failed, a requirement has no check, or a file the task needs is missing from evidence.changes, send all fixes back in one message to the same session, quoting the failing output; do not reproduce failures or write test scripts yourself. If every check passed and final_text ends with a review table whose rows are all met, accept it without reading code; read code only for rows marked no or unclear.'
+
 // The asking model marks its favourite option in the label ("(Recommended)", "（推荐）").
 // Clients relaying the question tended to repeat that mark as their own advice, so the
 // label is cleaned and the mark moves to harness_suggested: what the asker suggests, kept
@@ -586,6 +593,23 @@ const shaped = (st) => {
   return Array.isArray(st.answers) ? { ...out, answers: st.answers.map((a) => (Array.isArray(a?.selected) ? { ...a, selected: a.selected.map(cleanLabel) } : a)) } : out
 }
 
+// The folder a run works in: given with dsh_send, or that of its workspace or session.
+async function runFolder(a, st) {
+  if (a.cwd) return path.resolve(a.cwd.replace(/^~(?=$|[\\/])/, os.homedir()))
+  if (st?.cwd) return st.cwd
+  try {
+    if (a.workspace_id) return (await api.workspaces()).find((w) => w.id === a.workspace_id)?.path
+    const sid = a.session_id ?? st?.session_id
+    if (sid) return (await api.list_sessions({ query: sid, limit: 5 })).find((x) => x.session_id === sid)?.cwd
+  } catch { /* no folder, no evidence */ }
+  return undefined
+}
+const withEvidence = (st) => {
+  if (!st || !ENDED.has(st.state) || !st.run_id) return st
+  const ev = evidence.collect(config.batonHome, st.run_id)
+  return ev ? { ...st, evidence: ev } : st
+}
+
 const tag = (backend, value) => (Array.isArray(value) ? value.map((v) => ({ ...v, backend })) : { ...value, backend })
 
 export const api = {
@@ -603,16 +627,22 @@ export const api = {
   async read_session(a) {
     return (await useHost()) ? tag('host', await hostCall('read_session', a)) : tag('headless', readSession(a))
   },
-  async send(a) {
-    if (await useHost()) return tag('host', await hostCall('send', a))
-    return tag('headless', await waitForSessionId(startRun(a)))
+  // checks stay here: dsh-baton runs them itself when the run ends (see evidence.mjs).
+  // A hand-over (a message with checks) also asks Harness to have a read-only sub-agent
+  // review the work against the spec and end with a table, so the client can decide from
+  // that table and the evidence instead of reading the code itself.
+  async send({ checks, ...a }) {
+    if (Array.isArray(checks) && checks.length && typeof a.message === 'string') a = { ...a, message: `${a.message}${REVIEW_REQUEST}` }
+    const st = (await useHost()) ? tag('host', await hostCall('send', a)) : tag('headless', await waitForSessionId(startRun(a)))
+    evidence.prepare(config.batonHome, { run_id: st.run_id, cwd: await runFolder(a, st), checks })
+    return st
   },
   async status({ run_id, tail = 20 }) {
-    return shaped(isHostRun(run_id) ? tag('host', await hostCall('status', { run_id, tail })) : tag('headless', runStatus(run_id, { tail })))
+    return withEvidence(shaped(isHostRun(run_id) ? tag('host', await hostCall('status', { run_id, tail })) : tag('headless', runStatus(run_id, { tail }))))
   },
   async wait({ run_id, timeout_s = 300 }) {
-    if (isHostRun(run_id)) return shaped(tag('host', await hostCall('wait', { run_id, timeout_s }, { timeoutMs: (timeout_s + 15) * 1000 })))
-    return tag('headless', await waitRun(run_id, { timeout_s }))
+    if (isHostRun(run_id)) return withEvidence(shaped(tag('host', await hostCall('wait', { run_id, timeout_s }, { timeoutMs: (timeout_s + 15) * 1000 }))))
+    return withEvidence(tag('headless', await waitRun(run_id, { timeout_s })))
   },
   async cancel({ run_id, session_id }) {
     if (run_id && !isHostRun(run_id)) return tag('headless', cancelRun(run_id))

package/src/evidence.mjs

@@ -0,0 +1,101 @@
+// Evidence for a finished run that does not come from the Harness model: which files the run
+// created, changed or deleted (a snapshot of the folder taken at dsh_send, compared when the
+// run ends), and the result of check commands the client gave with dsh_send, run here by
+// dsh-baton in that folder. The Harness reply can say "all tests pass"; this says whether
+// they do. Kept in a file per run, because the client may wait from another process.
+import fs from 'node:fs'
+import path from 'node:path'
+import crypto from 'node:crypto'
+import { spawnSync } from 'node:child_process'
+
+const SKIP = new Set(['node_modules', '.git', '.hg', '.svn', 'dist', 'build', '.next', '.cache', 'coverage', '__pycache__', '.venv', 'venv', 'target'])
+const MAX_FILES = 3000
+const MAX_TEXT = 512 * 1024
+const CHECK_TIMEOUT_MS = 120_000
+const CHECKS_TOTAL_MS = 180_000
+const TAIL_LINES = 15
+
+const fileOf = (home, runId) => path.join(home, 'evidence', `${String(runId).replace(/[^\w.-]/g, '_')}.json`)
+
+// path -> { hash, lines } for the files under dir (bounded; big or binary files keep only a hash).
+function snapshot(dir) {
+  const files = {}
+  let count = 0, truncated = false
+  const walk = (d) => {
+    let entries = []
+    try { entries = fs.readdirSync(d, { withFileTypes: true }) } catch { return }
+    for (const e of entries) {
+      if (count >= MAX_FILES) { truncated = true; return }
+      const p = path.join(d, e.name)
+      if (e.isDirectory()) { if (!SKIP.has(e.name)) walk(p); continue }
+      if (!e.isFile()) continue
+      count++
+      try {
+        const buf = fs.readFileSync(p)
+        const text = buf.length <= MAX_TEXT && !buf.includes(0)
+        files[path.relative(dir, p).split(path.sep).join('/')] = {
+          hash: crypto.createHash('sha1').update(buf).digest('hex'),
+          lines: text ? (buf.length ? buf.toString('utf8').split('\n').length - (buf.at(-1) === 10 ? 1 : 0) : 0) : null,
+        }
+      } catch { /* unreadable: left out */ }
+    }
+  }
+  walk(dir)
+  return { files, truncated }
+}
+
+export function prepare(home, { run_id, cwd, checks }) {
+  if (!run_id || !cwd || !fs.existsSync(cwd)) return
+  try {
+    fs.mkdirSync(path.join(home, 'evidence'), { recursive: true, mode: 0o700 })
+    const list = Array.isArray(checks) ? checks.filter((c) => typeof c === 'string' && c.trim()).slice(0, 10) : []
+    fs.writeFileSync(fileOf(home, run_id), JSON.stringify({ cwd, checks: list, before: snapshot(cwd), at: Date.now() }), { mode: 0o600 })
+    // Keep the folder small: the 50 newest runs.
+    const dir = path.join(home, 'evidence')
+    const old = fs.readdirSync(dir).map((n) => ({ n, t: fs.statSync(path.join(dir, n)).mtimeMs })).sort((a, b) => b.t - a.t).slice(50)
+    for (const { n } of old) fs.rmSync(path.join(dir, n), { force: true })
+  } catch { /* evidence is extra; sending never fails over it */ }
+}
+
+function runCheck(command, cwd, timeout) {
+  const t0 = Date.now()
+  const r = spawnSync(command, { cwd, shell: true, encoding: 'utf8', timeout, maxBuffer: 16 * 1024 * 1024, env: { ...process.env, CI: '1' } })
+  const out = `${r.stdout ?? ''}${r.stderr ? `\n${r.stderr}` : ''}`.trimEnd().split('\n')
+  return {
+    command,
+    exit_code: r.status,
+    passed: r.status === 0,
+    ...(r.error?.code === 'ETIMEDOUT' || r.signal ? { timed_out: true } : {}),
+    seconds: Math.round((Date.now() - t0) / 100) / 10,
+    output_tail: out.slice(-TAIL_LINES).join('\n'),
+  }
+}
+
+// The evidence for a run that ended, computed once and then read back.
+export function collect(home, runId) {
+  const file = fileOf(home, runId)
+  let rec
+  try { rec = JSON.parse(fs.readFileSync(file, 'utf8')) } catch { return null }
+  if (rec.result) return rec.result
+  const after = snapshot(rec.cwd)
+  const before = rec.before.files
+  const created = [], modified = [], deleted = []
+  for (const [p, f] of Object.entries(after.files)) {
+    if (!before[p]) created.push({ path: p, lines: f.lines })
+    else if (before[p].hash !== f.hash) modified.push({ path: p, lines_before: before[p].lines, lines_after: f.lines })
+  }
+  for (const p of Object.keys(before)) if (!after.files[p]) deleted.push(p)
+  const checks = []
+  const deadline = Date.now() + CHECKS_TOTAL_MS
+  for (const c of rec.checks) {
+    const left = deadline - Date.now()
+    checks.push(left > 1000 ? runCheck(c, rec.cwd, Math.min(CHECK_TIMEOUT_MS, left)) : { command: c, skipped: 'out of time' })
+  }
+  const result = {
+    source: 'dsh-baton, not the Harness model',
+    changes: { created, modified, deleted, ...(after.truncated || rec.before.truncated ? { truncated: true } : {}) },
+    ...(checks.length ? { checks, all_checks_passed: checks.every((c) => c.passed) } : {}),
+  }
+  try { fs.writeFileSync(file, JSON.stringify({ ...rec, before: undefined, result }), { mode: 0o600 }) } catch { /* recomputed next time */ }
+  return result
+}

package/src/folder.mjs

@@ -0,0 +1,70 @@
+// The folder the client's conversation works in, so a new Harness session starts next to it
+// instead of in a folder the model guessed (an old workspace from dsh_list_workspaces, or
+// ~/.codex). Codex sends its thread id with every tool call; that thread's rollout file starts
+// with a session_meta line that records the thread's cwd. The MCP server's own folder is not
+// enough there: the Codex app starts it in one folder for all of its projects. Other clients
+// (Claude Code) start the server in the project folder.
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+
+const codexHome = () => process.env.CODEX_HOME || path.join(os.homedir(), '.codex')
+const DAYS_SEARCHED = 120
+const found = new Map()
+
+const newestFirst = (dir) => { try { return fs.readdirSync(dir).filter((n) => /^\d+$/.test(n)).sort().reverse() } catch { return [] } }
+
+// sessions/<yyyy>/<mm>/<dd>/rollout-<time>-<thread id>.jsonl, newest days first.
+function codexThreadCwd(threadId) {
+  if (!/^[\w-]+$/.test(threadId ?? '')) return undefined
+  if (found.has(threadId)) return found.get(threadId)
+  const root = path.join(codexHome(), 'sessions')
+  let days = 0
+  for (const y of newestFirst(root)) for (const m of newestFirst(path.join(root, y))) for (const d of newestFirst(path.join(root, y, m))) {
+    if (++days > DAYS_SEARCHED) return undefined
+    const dir = path.join(root, y, m, d)
+    const file = fs.readdirSync(dir).find((n) => n.endsWith(`-${threadId}.jsonl`))
+    if (!file) continue
+    try {
+      const fd = fs.openSync(path.join(dir, file), 'r')
+      const buf = Buffer.alloc(64 * 1024)
+      const n = fs.readSync(fd, buf, 0, buf.length, 0)
+      fs.closeSync(fd)
+      const cwd = JSON.parse(buf.subarray(0, n).toString('utf8').split('\n')[0]).payload?.cwd
+      if (typeof cwd === 'string' && cwd) { found.set(threadId, cwd); return cwd }
+    } catch { /* unreadable: fall back */ }
+    return undefined
+  }
+  return undefined
+}
+
+// The server's own folder counts only when it looks like a project: not the home folder,
+// not the file-system root and not a client's own settings folder.
+function serverCwd() {
+  const cwd = process.cwd()
+  const home = os.homedir()
+  const real = (p) => { try { return fs.realpathSync(p) } catch { return p } }
+  const inside = (dir) => { const r = path.relative(real(dir), real(cwd)); return r === '' || (!r.startsWith('..') && !path.isAbsolute(r)) }
+  if (cwd === home || cwd === path.parse(cwd).root) return undefined
+  if (inside(codexHome()) || inside(path.join(home, '.claude'))) return undefined
+  return cwd
+}
+
+export function conversationFolder(meta, isCodex) {
+  if (isCodex) {
+    const threadId = meta?.['x-codex-turn-metadata']?.thread_id ?? meta?.threadId
+    const cwd = codexThreadCwd(threadId)
+    if (cwd) return cwd
+  }
+  return serverCwd()
+}
+
+const norm = (p) => {
+  const r = path.resolve(p.replace(/^~(?=$|[\\/])/, os.homedir()))
+  return process.platform === 'win32' || process.platform === 'darwin' ? r.toLowerCase() : r
+}
+// True when folder is the conversation's folder or inside it.
+export function within(folder, conversation) {
+  const r = path.relative(norm(conversation), norm(folder))
+  return r === '' || (!r.startsWith('..') && !path.isAbsolute(r))
+}

package/src/mcp.mjs

@@ -4,6 +4,7 @@ import readline from 'node:readline'
 import path from 'node:path'
 import * as core from './core.mjs'
 import { stableNodePath } from './setup.mjs'
+import { conversationFolder, within } from './folder.mjs'
 
 const SERVER = { name: 'dsh-baton', version: core.VERSION }
 const PROTOCOLS = ['2025-06-18', '2025-03-26', '2024-11-05']
@@ -30,7 +31,7 @@ const codeModeYield = () => {
   const ms = (waitSeconds() + 20) * 1000
   return `Required when you call tools from a script cell ("Script running with cell ID …"): the script that calls dsh_wait must start with the line // @exec: {"yield_time_ms": ${ms}}, never a shorter value; if the cell still yields, resume it with wait and yield_time_ms ${ms} (or the largest value wait accepts), never a short value such as 30000 or 55000.`
 }
-const NO_POLL = 'While waiting, make no other calls: no dsh_status, dsh_session_activity or dsh_read_session, and do not list or read the target folder or files to check progress. The final dsh_wait result carries the reply of the run; check files only after the run ends, if needed.'
+const NO_POLL = 'While waiting, make no other calls (no dsh_status, dsh_session_activity or dsh_read_session) and do not list or read the target folder to check progress.'
 const ARCHIVED = 'Sessions not in dsh_list_sessions are archived or gone: do not look for them on disk.'
 // What to do when a run stops to ask a person (dsh_wait, wait_command and the instructions say it).
 const ASKED = 'If the user told you to decide such questions yourself, choose by your own judgment of the question and the task, call dsh_answer with reason (one sentence on why), then tell the user what you chose and why. Otherwise relay the questions to the user and start with your own advice, on a line of its own: "My recommendation: <option>, because <reason>", the reason drawn from your own judgment of the question and the task (harness_suggested only shows what the asking model would pick; it is never a reason by itself, and your pick may differ). Then list the options, wait for the user\'s decision and submit it with dsh_answer. Never answer on the user\'s behalf without that permission.'
@@ -49,6 +50,17 @@ const nodeMode = process.versions.electron ? 'ELECTRON_RUN_AS_NODE=1 ' : ''
 const waitCommand = (runId) =>
   /^[\w.-]+$/.test(runId ?? '') ? `${nodeMode}${quote(stableNodePath())} ${quote(path.join(core.ROOT, 'src', 'cli.mjs'))} wait ${runId}` : undefined
 
+// The result of a run that ended, kept short: the client already knows what it sent, and a
+// completed run's event log is only the work behind final_text (dsh_status still has it).
+// A run that did not complete keeps its last events, to show where it stopped.
+function ended({ recent_events, message_preview, backend, ...st }) {
+  const out = { ...st, ...(st.state !== 'completed' && recent_events?.length ? { recent_events: recent_events.slice(-5) } : {}) }
+  // decided_for_user first, so a client that skims to final_text still meets it.
+  return st.decided_for_user
+    ? { hint: `${DECIDED_HINT} ${core.ENDED_HINT}`, decided_for_user: st.decided_for_user, ...out }
+    : { ...out, hint: core.ENDED_HINT }
+}
+
 // Wait in short chunks, reporting progress between them (clients that support it can
 // show it or reset their timer). An unfinished wait returns only the state, not the run's
 // recent events, so the client has nothing to summarise and simply waits again.
@@ -61,8 +73,7 @@ async function waitInChunks({ run_id }, progress) {
     const t0 = Date.now()
     const st = await core.api.wait({ run_id, timeout_s: Math.max(1, Math.min(WAIT_CHUNK_S, left)) })
     if (st.needs_input) return { ...st, ...(st.question ? { relay: core.relayText(st.question) } : {}), hint: NEEDS_INPUT_HINT(st) }
-    // First in the result, so a client that skims to final_text still meets it.
-    if (!st.timed_out) return st.decided_for_user ? { hint: DECIDED_HINT, decided_for_user: st.decided_for_user, ...st } : st
+    if (!st.timed_out) return ended(st)
     // Never spin: a chunk that came back early still takes a moment before the next one.
     if (Date.now() - t0 < 500) await new Promise((r) => setTimeout(r, 500))
     if (Date.now() >= deadline) {
@@ -78,6 +89,11 @@ async function waitInChunks({ run_id }, progress) {
   }
 }
 
+// Long event texts are cut in results: the client rarely needs them whole (dsh_read_session has them).
+const clip = (st) => (Array.isArray(st?.recent_events)
+  ? { ...st, recent_events: st.recent_events.map((e) => Object.fromEntries(Object.entries(e).map(([k, v]) => [k, typeof v === 'string' && v.length > 300 ? `${v.slice(0, 300)}…` : v]))) }
+  : st)
+
 // MCP tool annotations. Every tool only talks to the local Harness (no open world).
 const hints = (readOnlyHint, destructiveHint, idempotentHint) => ({ readOnlyHint, destructiveHint, idempotentHint, openWorldHint: false })
 const READ = hints(true, false, true)
@@ -88,38 +104,46 @@ const TOOLS = [
   {
     name: 'dsh_list_workspaces',
     annotations: annotations('List workspaces'),
-    description: 'List the workspaces (project folders) in the DeepSeek Harness sidebar; dsh_list_sessions lists the sessions inside them and dsh_create_workspace adds one. Returns id, path, title and session_count for each; the id is the workspace_id for dsh_send and dsh_rename_workspace. Read-only. Needs the dsh-baton-host plugin.',
+    description: 'List the DeepSeek Harness workspaces (project folders): id, path, title and session_count. The id is the workspace_id for dsh_send. Read-only. Needs the dsh-baton-host plugin.',
     inputSchema: { type: 'object', properties: {} },
     run: () => core.api.workspaces(),
   },
   {
     name: 'dsh_create_workspace',
+    hidden: true, // not in tools/list; reachable directly or through dsh_call
     annotations: annotations('Create workspace', EDIT),
-    description: 'Add a folder to the DeepSeek Harness sidebar as a workspace without starting a session; dsh_list_workspaces only lists existing ones, and dsh_send with a cwd registers the folder by itself. Creates the folder unless create_dir is false. Idempotent: an already registered folder returns its existing workspace. Returns id, path, title and created (false when it already existed). Needs the dsh-baton-host plugin.',
+    description: 'Register a folder as a Harness workspace without starting a session (dsh_send with cwd does this too). Creates the folder unless create_dir is false; an already registered folder returns its workspace. Returns id, path, title and created. Needs the dsh-baton-host plugin.',
     inputSchema: { type: 'object', required: ['path'], properties: { path: str('Absolute folder path (~ allowed)'), title: str('Sidebar title; defaults to the folder name'), create_dir: { type: 'boolean', description: 'Create the folder if missing', default: true } } },
     run: (a) => core.api.create_workspace(a),
   },
   {
     name: 'dsh_list_sessions',
     annotations: annotations('List sessions'),
-    description: `List saved DeepSeek Harness sessions (conversations), newest first, to find a session_id; dsh_list_runs lists only the messages sent through dsh_send. Returns session_id, title, cwd, updated_at, running and bridge_runs (active dsh-baton run ids) for each. There is no paging: the list stops at limit, so to see older sessions raise limit or narrow it with cwd or query. Read-only. ${ARCHIVED}`,
+    description: `List Harness sessions, newest first, to find a session_id: session_id, title, cwd, updated_at, running and bridge_runs. No paging: raise limit or narrow it with cwd or query. Read-only. ${ARCHIVED}`,
     inputSchema: { type: 'object', properties: { cwd: str('Only sessions of this workspace folder'), query: str('Case-insensitive text to match in title, folder or session id'), limit: int('Max sessions returned', 20), include_subagents: { type: 'boolean', description: 'Also list sub-agent sessions', default: false } } },
     run: (a) => core.api.list_sessions(a),
   },
   {
     name: 'dsh_read_session',
     annotations: annotations('Read session'),
-    description: 'Read what was said in one session (its past messages), to catch up before continuing it; dsh_session_activity shows what it is doing now and dsh_status follows one run. Returns title, cwd, total_messages and the last messages, each with role (user or assistant), time, text and the names of tools the assistant called (tool output is not included). Read-only.',
+    description: 'Read the last messages of a session (role, time, text and the names of tools called; no tool output), to catch up before continuing it. Read-only.',
     inputSchema: { type: 'object', required: ['session_id'], properties: { session_id: str('Session id from dsh_list_sessions, e.g. session-…'), last: int('How many of the most recent messages to return; total_messages tells how many there are', 10) } },
     run: (a) => core.api.read_session(a),
   },
   {
     name: 'dsh_send',
     annotations: annotations('Send message', hints(false, false, false)),
-    description: 'Send a message to a DeepSeek Harness session and return at once with a run_id, without waiting for the reply; dsh_wait then waits for it. With session_id it continues that existing session (same context, no new session); with cwd or workspace_id it starts a new session there (a cwd that is not a workspace yet is registered in the sidebar first). The turn runs in the background. If the session is already working, mode followup queues the message after the current turn and steer adds it to the running turn; each message gets its own run_id. Leave mode out to do what the user set in Harness (Settings, sending while busy: queue or steer); followup when that setting cannot be read. The result says which mode was used and why (mode_source: explicit, harness or default). A queued message can still be edited, removed or turned into a steer with dsh_update_queued. The message is delivered verbatim as a user message, with no prefix or label added: write it in the language the user works in, self-contained (Harness does not see this conversation), and say who is asking only if it matters. Then wait for the reply with dsh_wait (or the wait_command it returns, where offered).',
-    inputSchema: { type: 'object', required: ['message'], properties: { message: str('The task or reply to send'), session_id: str('Existing session to continue'), cwd: str('Workspace folder for a new session'), workspace_id: str('Harness workspace for a new session (from dsh_list_workspaces)'), mode: { type: 'string', enum: ['followup', 'steer'], description: "followup queues after the current turn; steer injects into a running turn. Omit to follow Harness's busy-send setting" } } },
-    run: async (a) => {
-      const st = await core.api.send({ ...a, sender: core.senderOf(core.setting('SENDER') || clientName) })
+    description: 'Send a message to a Harness session and return at once with a run_id; then wait for the reply with dsh_wait (or the wait_command it returns, where offered). session_id continues that session; without it a new session starts in cwd or workspace_id, or, with neither, in the folder this conversation works in (a new cwd is registered first). If the session is busy, mode followup queues the message and steer adds it to the running turn; leave mode out to follow the Harness setting. The message arrives verbatim as a user message (with checks, a short request for a sub-agent review table is appended): make it self-contained (Harness does not see this conversation), in the user\'s language.',
+    inputSchema: { type: 'object', required: ['message'], properties: { message: str('The task or reply to send'), session_id: str('Existing session to continue'), cwd: str('Workspace folder for a new session; leave out to use the folder this conversation works in'), workspace_id: str('Harness workspace for a new session (from dsh_list_workspaces)'), mode: { type: 'string', enum: ['followup', 'steer'], description: "followup queues after the current turn; steer injects into a running turn. Omit to follow Harness's busy-send setting" }, checks: { type: 'array', items: { type: 'string' }, description: 'The project\'s own test commands, e.g. npm test (ask Harness in the message to write tests for each requirement). Do not write check scripts yourself. dsh-baton runs them in the folder when the run ends and returns exit codes and the last output lines as evidence.' } } },
+    run: async (a, { meta } = {}) => {
+      // A new session goes to this conversation's folder unless the call names another one;
+      // a different folder is allowed but said back, so a wrong guess does not go unnoticed.
+      const here = a.session_id ? undefined : conversationFolder(meta, isCodex())
+      const args = here && !a.cwd && !a.workspace_id ? { ...a, cwd: here } : a
+      const folder = here && a.cwd && !within(a.cwd, here)
+        ? { folder_note: `This conversation works in ${here}; the new session was started in ${a.cwd} as asked. If that was not intended, cancel it and send again without cwd.` }
+        : args !== a ? { cwd: here } : {}
+      const st = { ...(await core.api.send({ ...args, sender: core.senderOf(core.setting('SENDER') || clientName) })), ...folder }
       // Codex has no wake-on-exit for shell commands: offered wait_command, it runs it in a
       // terminal and polls that, so it gets dsh_wait only.
       if (isCodex()) return { ...st, hint: `Run started. Call dsh_wait with this run_id; it returns when the run ends or stops to ask the user something. ${NO_POLL} ${codeModeYield()}` }
@@ -133,21 +157,21 @@ const TOOLS = [
   {
     name: 'dsh_status',
     annotations: annotations('Run status'),
-    description: 'Look once at one run sent with dsh_send, without waiting; dsh_wait waits for it to end and dsh_session_activity covers the whole session. Returns state (queued/running/waiting/completed/failed/cancelled, or interrupted when a Harness restart cut it short), session_id, recent events (text, tool calls), final reply, waiting_on when the turn is over but sub-agents or background jobs are still working, and human_interjections when someone typed in the Harness UI during the run (its result then reflects that input too). A one-off look, never a way to wait: to wait for the reply use dsh_wait, and if dsh_wait timed out, call dsh_wait again.',
-    inputSchema: { type: 'object', required: ['run_id'], properties: { run_id: str('Run id from dsh_send'), tail: int('How many recent events', 20) } },
-    run: (a) => core.api.status(a),
+    description: 'Look once at a run without waiting: state (queued/running/waiting/completed/failed/cancelled/interrupted), recent events, final reply, waiting_on (sub-agents or jobs still working) and human_interjections. Never a way to wait: use dsh_wait.',
+    inputSchema: { type: 'object', required: ['run_id'], properties: { run_id: str('Run id from dsh_send'), tail: int('How many recent events', 5) } },
+    run: async (a) => clip(await core.api.status({ tail: 5, ...a })),
   },
   {
     name: 'dsh_wait',
     annotations: annotations('Wait for run'),
-    description: () => `Wait for a run sent with dsh_send to end and return its final status and reply; dsh_status only looks once.${isCodex() ? '' : ' Prefer the background wait_command from dsh_send when your client can run background shell commands and wake you when they exit: it costs no turns while waiting.'} It also returns at once when the run stops to ask a person: needs_input is answer (the questions are in question; show the user relay with its first line filled in with your own pick and reason, harness_suggested being only the asker's pick, then reply with dsh_answer) or harness-ui (an approval only a person can give in Harness). Each call waits up to ${waitSeconds()} s (set by the server to stay under this client's tool timeout); if the run is still going it returns timed_out: true with just the state: then call dsh_wait again with the same run_id, without summarising progress.${isCodex() ? ` ${NO_POLL} ${codeModeYield()}` : ''} Sends progress notifications while waiting when the client asks for them.`,
+    description: () => `Wait for a run sent with dsh_send to end and return its state and final reply.${isCodex() ? '' : ' Prefer the background wait_command from dsh_send if your client wakes you when a background command exits: it costs no turns.'} It also returns at once when the run stops to ask a person: needs_input answer (question and relay; reply with dsh_answer) or harness-ui (an approval only a person can give in Harness). Each call waits up to ${waitSeconds()} s; if it returns timed_out: true, call dsh_wait again with the same run_id, without a progress note.${isCodex() ? ` ${NO_POLL} ${codeModeYield()}` : ''}`,
     inputSchema: { type: 'object', required: ['run_id'], properties: { run_id: str('Run id from dsh_send') } },
     run: (a, { progress }) => waitInChunks(a, progress),
   },
   {
     name: 'dsh_answer',
     annotations: annotations('Answer question', hints(false, false, false)),
-    description: `Answer the questions a run sent with dsh_send is waiting on (Harness's ask_user_question, shown in dsh_wait / dsh_status as question); dsh_send sends a new message instead, and dsh_update_queued changes one still in the queue. Per question: choose option numbers or labels, text for a free-text answer (with a single choice it replaces the option), or skip. When the user let you decide, pass reason. Several questions can be answered in one call or one at a time: the answer reaches Harness once every question has one (submitted: true; until then remaining lists the rest). The run then continues; wait for it again. Whoever answers first wins: if the user answers in the Harness window, this call reports there is no open question. ${ASKED}`,
+    description: 'Answer the questions a waiting run asked (question in dsh_wait or dsh_status). Per question: option numbers or labels in choose, text for a free answer, or skip. Pass reason when the user let you decide. The answer reaches Harness once every question has one (submitted: true; remaining lists the rest); then wait for the run again. If the user already answered in Harness, it reports that there is no open question.',
     inputSchema: {
       type: 'object', required: ['run_id', 'answers'], properties: {
         run_id: str('Run id that is waiting (needs_input: answer)'),
@@ -176,43 +200,48 @@ const TOOLS = [
   },
   {
     name: 'dsh_rename_session',
+    hidden: true, // not in tools/list; reachable directly or through dsh_call
     annotations: annotations('Rename session', EDIT),
-    description: 'Set the title of one DeepSeek Harness session (a conversation); dsh_rename_workspace renames a workspace (project folder) instead. Only the title changes; the conversation and any running turn are untouched. Can be called again at any time to change it back or to something else. Returns session_id and the saved title.',
+    description: 'Set the title of a Harness session; nothing else changes. Returns session_id and title.',
     inputSchema: { type: 'object', required: ['session_id', 'title'], properties: { session_id: str('Session id from dsh_list_sessions'), title: str('New title; surrounding spaces are trimmed and it must not be empty') } },
     run: (a) => core.api.rename_session(a),
   },
   {
     name: 'dsh_rename_workspace',
+    hidden: true, // not in tools/list; reachable directly or through dsh_call
     annotations: annotations('Rename workspace', EDIT),
-    description: 'Set the sidebar title of a DeepSeek Harness workspace (project folder); dsh_rename_session renames a single session instead. The folder on disk is not moved or renamed. Identify it by workspace_id or path. Can be called again to change it back. Returns id, path and the saved title.',
+    description: 'Set the sidebar title of a workspace, by workspace_id or path; the folder is not renamed. Returns id, path and title.',
     inputSchema: { type: 'object', required: ['title'], properties: { workspace_id: str('Workspace id from dsh_list_workspaces'), path: str('Workspace folder, used when workspace_id is not given'), title: str('New title; surrounding spaces are trimmed and it must not be empty') } },
     run: (a) => core.api.rename_workspace(a),
   },
   {
     name: 'dsh_session_activity',
+    hidden: true, // not in tools/list; reachable directly or through dsh_call
     annotations: annotations('Session activity'),
-    description: 'Show what one session is doing right now, across all its work; dsh_status follows a single run and dsh_read_session shows past messages. Returns busy, activity (its running turn, sub-agents at any depth, background jobs and reminders) and bridge_runs (active dsh-baton runs). Read-only. Check it before dsh_send to a session that might be busy, or before dsh_cancel.',
+    description: 'What a session is doing now: busy, activity (running turn, sub-agents, background jobs, reminders) and bridge_runs. Read-only. Check it before dsh_send to a busy session or before dsh_cancel.',
     inputSchema: { type: 'object', required: ['session_id'], properties: { session_id: str('Session id from dsh_list_sessions') } },
     run: (a) => core.api.activity(a),
   },
   {
     name: 'dsh_cancel',
     annotations: annotations('Cancel session work', hints(false, true, true)),
-    description: 'Stop everything a session is doing (running turn, sub-agents, background jobs, reminders), by run_id or session_id; the session itself is kept, and this is the only tool that stops work. It retries a few times until the session is quiet, then returns session_id, run (when run_id was given), attempts, still_busy, activity (whatever is still going), queued_runs and removed_from_queue. Harness also drops the messages still waiting in the session queue: their runs end as cancelled and are listed in removed_from_queue; to drop just one queued message, use dsh_update_queued instead. Safe to repeat: on an idle session it does nothing and returns still_busy: false. Use dsh_session_activity first to see what would be stopped.',
+    description: 'Stop everything a session is doing (turn, sub-agents, background jobs, reminders), by run_id or session_id; the session is kept. Messages queued in it are dropped too (removed_from_queue); to drop one queued message use dsh_update_queued. Safe to repeat. Returns still_busy, activity and removed_from_queue.',
     inputSchema: { type: 'object', properties: { run_id: str('Run id from dsh_send; stops the session that run belongs to'), session_id: str('Session id, to stop work dsh-baton did not start') } },
     run: (a) => core.api.cancel(a),
   },
   {
     name: 'dsh_update_queued',
+    hidden: true, // not in tools/list; reachable directly or through dsh_call
     annotations: annotations('Change queued message', hints(false, true, false)),
-    description: 'Change one message sent with dsh_send that is still waiting in Harness\'s queue behind a running turn; dsh_send sends a new one and dsh_cancel stops the whole session. action edit replaces its text with message, remove deletes it (its run ends as cancelled), steer moves it into the running turn now. Only for a run whose state is queued: once its message has reached the conversation it can no longer be changed, and the error says so. Returns the run (with message_preview after an edit) and the action taken.',
+    description: 'Change a dsh_send message still queued behind a running turn: edit replaces its text, remove deletes it, steer sends it into the running turn now. Only while its run is queued.',
     inputSchema: { type: 'object', required: ['run_id', 'action'], properties: { run_id: str('Run id from dsh_send of the queued message'), action: { type: 'string', enum: ['edit', 'remove', 'steer'], description: 'edit replaces the text, remove deletes the message, steer sends it into the running turn now' }, message: str('New text for action edit (plain text, not empty)') } },
     run: (a) => core.api.update_queued(a),
   },
   {
     name: 'dsh_list_runs',
+    hidden: true, // not in tools/list; reachable directly or through dsh_call
     annotations: annotations('List runs'),
-    description: 'List the runs sent through dsh_send (the latest 100 are kept), newest first, to recover a lost run_id or review past hand-overs (session_id narrows it to one session); dsh_list_sessions lists Harness sessions instead. Returns run_id, session_id, state, started_at, ended_at, message_preview, final_text and error for each; dsh_status shows one run in detail. Read-only.',
+    description: 'List the runs sent with dsh_send, newest first (the last 100 are kept), to recover a run_id: run_id, session_id, state, times, message_preview, final_text and error. Read-only.',
     inputSchema: { type: 'object', properties: { session_id: str('Only runs sent to this session'), limit: int('Max runs returned', 10) } },
     run: (a) => core.api.list_runs(a),
   },
@@ -230,7 +259,7 @@ const catalog = () => TOOLS.filter((t) => t.name !== 'dsh_call').map((t) => ({
 TOOLS.push({
   name: 'dsh_call',
   annotations: annotations('Call dsh-baton tool by name', hints(false, true, false)),
-  description: 'Backup entry that calls any dsh-baton tool by name, for when this conversation\'s tool list is out of date: dsh-baton was updated without a restart and a tool it now has (named in the update note) is not among your tools. Normally call the dsh_* tools directly; this runs the same code with the same arguments and returns exactly what the named tool returns, so it can do whatever that tool does (including sending, cancelling or answering). With a name that does not exist it changes nothing and returns the list of available tools with their input schemas.',
+  description: 'Call a dsh-baton tool by name, for a tool this conversation does not list (dsh-baton was updated without a restart; the update note names it). Runs the same code as a direct call, so it can do whatever that tool does. An unknown name changes nothing and returns the tools with their input schemas.',
   inputSchema: {
     type: 'object', required: ['name'], properties: {
       name: str('Tool name, e.g. dsh_send or a tool added by an update'),
@@ -260,13 +289,13 @@ async function handle(req) {
         protocolVersion: PROTOCOLS.includes(asked) ? asked : PROTOCOLS[0],
         capabilities: { tools: {} },
         serverInfo: SERVER,
-        instructions: `Hands tasks to a local DeepSeek Harness and passes the results back. Typical flow: dsh_list_workspaces (or dsh_create_workspace) to pick a folder, dsh_list_sessions to find a session, dsh_send {session_id, message} to continue it (or {cwd, message} to start one), then wait for the reply: ${isCodex() ? 'call dsh_wait with the run_id until it returns the final state (not dsh_status)' : 'run the wait_command it returns as a background shell command if your client wakes you when one exits, otherwise call dsh_wait'}. Then dsh_read_session to read the conversation, dsh_session_activity to see what a session is doing, dsh_update_queued to edit or withdraw a message still waiting in its queue, and dsh_cancel to stop it; dsh_list_runs recovers a lost run_id. A run that stops to ask the user something ends the wait at once with needs_input and the questions; answer with dsh_answer. ${ASKED} ${ARCHIVED} If a note says dsh-baton was updated and names a tool you do not have, call it through dsh_call {name, arguments}.`,
+        instructions: `Hands tasks to a local DeepSeek Harness and passes the results back. To hand over a task, call dsh_send {message, checks} directly (no need to list anything first; the new session starts in the folder this conversation works in, or pass cwd for another folder): message is the full, explicit spec (ask for tests that cover each requirement), checks are the project's own test commands such as npm test; do not write check scripts yourself. To continue a session, dsh_send {session_id, message}. Then wait for the reply: ${isCodex() ? 'call dsh_wait with the run_id until it returns the final state (not dsh_status)' : 'run the wait_command it returns as a background shell command if your client wakes you when one exits, otherwise call dsh_wait'}. A run that stops to ask the user something ends the wait with needs_input and the questions; answer with dsh_answer. ${ASKED} ${ARCHIVED} If a note says dsh-baton was updated and names a tool you do not have, call it through dsh_call {name, arguments}.`,
       }
     }
     case 'ping':
       return {}
     case 'tools/list':
-      return { tools: TOOLS.map(({ run, ...t }) => ({ ...t, description: typeof t.description === 'function' ? t.description() : t.description })) }
+      return { tools: TOOLS.filter((t) => !t.hidden).map(({ run, hidden, ...t }) => ({ ...t, description: typeof t.description === 'function' ? t.description() : t.description })) }
     case 'tools/call': {
       const tool = TOOLS.find((t) => t.name === req.params?.name)
       if (!tool) throw Object.assign(new Error(`Unknown tool: ${req.params?.name}`), { code: -32602 })
@@ -275,8 +304,9 @@ async function handle(req) {
         const token = req.params?._meta?.progressToken
         const progress = token === undefined ? undefined : (done, message) =>
           send({ jsonrpc: '2.0', method: 'notifications/progress', params: { progressToken: token, progress: done, message } })
-        const result = await tool.run(req.params.arguments || {}, { progress })
-        const content = [{ type: 'text', text: JSON.stringify(result, null, 2) }]
+        const result = await tool.run(req.params.arguments || {}, { progress, meta: req.params?._meta })
+        // Compact JSON: indentation is paid for again on every later request of the conversation.
+        const content = [{ type: 'text', text: JSON.stringify(result) }]
         // Said once per server process, the first time a call finds the versions apart.
         const warning = !versionWarned && core.versionWarning()
         if (warning) { versionWarned = true; content.push({ type: 'text', text: `Note for the user: ${warning}` }) }