dsh-baton-mcp 0.5.8 → 0.5.9

package/README.md

@@ -91,13 +91,14 @@ That is all. If Harness says it could not register, run `npx -y dsh-baton-mcp se
 | `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_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_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 recommended option marked). The assistant answers by its own judgment only when you told it to decide; otherwise it brings you the questions with its recommendation. You can also answer in the Harness window: whoever answers first wins |
+| `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 |
 | `dsh_cancel` | Stop everything a session is doing, by `run_id` or `session_id`: turn, sub-agents, jobs. Harness also drops the messages waiting in its queue; their runs end as `cancelled` |
 | `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 |
 
 </details>
 
@@ -142,6 +143,8 @@ When the plugin is unreachable, the MCP server falls back to Harness's `dsh head
 
 **What the plugin does when switched on.** It copies the MCP server to `~/.dsh-baton/app`, a folder that stays put, and writes the MCP entry into `~/.claude.json` and `~/.codex/config.toml` directly, keeping a `*.bak-dsh-baton` backup of each. It starts the server with your own Node.js ≥ 22.15 when it finds one on `PATH`; without one, with Harness's own runtime (the Harness app in Node mode, `ELECTRON_RUN_AS_NODE=1`), so nothing else has to be installed. Either way it works with only the desktop apps installed, when `claude` / `codex` are not on your `PATH`. It runs again on each Harness start: an entry that is already right, or a working one that starts another copy of dsh-baton, is left alone. In Harness, the source switches to the npm registry ("Official npm registry", 「npm 官方源」) by itself once you type the package name, and no restart is needed. To turn the registration off, set `DSH_BATON_AUTO_REGISTER=0` for Harness.
 
+**Updates need no restart.** When a newer version lands in `~/.dsh-baton/app` (a plugin update, `setup`, or a copy by hand), conversations already open in Claude Code and Codex use it from their next `dsh_*` call: the server checks the folder before each call, starts the new version, and says once in that call's result that it was updated. A `dsh_wait` that is already running finishes on the old version first. If the new version cannot start, the old one keeps working and the result says why. A tool added in the new version shows up in Claude Code at once (the server tells the client its tool list changed); Codex keeps the tool list a conversation started with, so it does not show a new tool until the next conversation; from 0.5.9 on it can still use one at once through `dsh_call`, which the update note points to, and the tools it already has run the new code right away. This works from the version after 0.5.8 on; a server started from 0.5.8 or earlier needs one last restart (or `/mcp` reconnect) to pick it up.
+
 **`npx -y dsh-baton-mcp setup`** does the same registration from a terminal: for a plugin that could not register, or when you come from an MCP directory. With the plugin already registered it changes nothing, then points you to the plugin if it is missing.
 
 **Updating.** Harness has an update button only for its official plugins, so: Plugins → dsh-baton-host → **Uninstall**, then **Add plugin** → `dsh-baton-host`. For a while after a release, Harness installs the previous version instead (pnpm's `minimumReleaseAge` holds back versions published very recently, and the install dialog says so); to get the new one at once, type the version: `dsh-baton-host@0.5.0`. Switched on again, the plugin brings the MCP server to the same version; new conversations use it. If the two are ever out of step, the first tool call that notices it says so.

package/README.zh-CN.md

@@ -91,13 +91,14 @@ Codex 和 Claude 轮流往同一个 Harness 对话发消息，每条都标明是
 | `dsh_send` | 发消息。带 `session_id` 续接那个对话；带 `cwd` 或 `workspace_id` 新开对话（`cwd` 还不是工作区时会先登记）。立即返回 `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_answer` | 回答运行中途提出的问题（Harness 的 ask_user_question）：每道题可以填选项编号或选项文字、自由填写，或者跳过；可以逐题回答，也可以一次答完。运行一提问，`dsh_wait` 和 `wait_command` 就会立刻返回，并带上题目（`needs_input`、`question`，推荐选项会标出来）。只有你说过让它自己决定时，助手才会按自己的判断回答；否则它会把题目和它的建议转给你。你也可以直接在 Harness 窗口里回答，谁先答就算谁的 |
+| `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` 立刻插进正在跑的回合。消息一旦进入对话就改不了了 |
 | `dsh_cancel` | 按 `run_id` 或 `session_id` 停掉整个对话的工作：当前回合、子智能体、后台任务。Harness 会同时清掉队列里等待的消息，这些运行记为 `cancelled` |
 | `dsh_rename_session` | 给对话改名 |
 | `dsh_rename_workspace` | 给工作区改名（只改侧边栏标题，不动文件夹） |
 | `dsh_list_runs` | 列出最近的运行，可按会话筛选 |
+| `dsh_call` | 备用入口：按名字调用任意 `dsh_*` 工具，用于对话的工具列表还是更新前的旧版时；名字不存在时会列出所有可用工具 |
 
 </details>
 
@@ -144,6 +145,8 @@ dsh-baton rename-workspace ~/code/new-app 新名字
 
 **插件启用时做了什么。**它把 MCP 服务器复制到 `~/.dsh-baton/app` 这个固定的文件夹，再直接把 MCP 注册写进 `~/.claude.json` 和 `~/.codex/config.toml`，各留一份 `*.bak-dsh-baton` 备份。电脑上有 Node.js ≥ 22.15（在 `PATH` 里能找到）就用它启动服务器；没有的话，就用 Harness 自带的运行环境（Harness 应用本身以 Node 模式运行，`ELECTRON_RUN_AS_NODE=1`），不用另外安装任何东西。两种情况下，只装了桌面应用、`claude` / `codex` 不在 `PATH` 里也能用。每次 Harness 启动都会再检查一遍：已经正确的注册、或者指向另一份可用 dsh-baton 的注册，都不会改动。在 Harness 里输入包名后，安装源会自动切到「npm 官方源」（英文界面是 "Official npm registry"），不用另外选择，也不用重启。不想让插件自动注册，给 Harness 设置 `DSH_BATON_AUTO_REGISTER=0`。
 
+**更新不用重启。**新版本装进 `~/.dsh-baton/app` 后（插件更新、`setup` 或手动复制），Claude Code 和 Codex 里已经开着的对话，下一次调用 `dsh_*` 工具时就会用上：服务器每次调用前检查这个文件夹，启动新版本，并在这次调用的结果里提示一次已经更新。正在进行的 `dsh_wait` 会先在旧版本里跑完。新版本启动失败时，旧版本继续工作，结果里会说明原因。新版本新增的工具，Claude Code 里马上就能用（服务器会通知客户端工具列表变了）；Codex 一直用对话开始时的工具列表，新工具要到下一个新对话才会显示；从 0.5.9 起，旧对话里也能通过 `dsh_call` 马上用上新功能（更新提示里会写明），已有的工具也会立刻用上新代码。这个功能从 0.5.8 之后的版本开始有效；由 0.5.8 或更早版本启动的服务器，还需要最后重启一次（或在 `/mcp` 里重新连接）。
+
 **`npx -y dsh-baton-mcp setup`** 在终端里做同样的注册：用于插件没能注册的情况，或者从 MCP 目录过来的用户。插件已经注册过时它什么都不改；插件没装的话，它会提示去添加。
 
 **更新。**Harness 只给官方插件提供"更新"按钮，所以要：插件 → dsh-baton-host → **卸载**，再**添加插件** → `dsh-baton-host`。新版本刚发布的一段时间里，Harness 会装上一个版本（pnpm 的 `minimumReleaseAge` 会暂缓刚发布的版本，安装弹窗里会说明）；想马上用新版，输入带版本号的名字：`dsh-baton-host@0.5.0`。重新启用后，插件会把 MCP 服务器也更新到同一版本，新开的对话就会用上。万一两边版本对不上，第一次发现不一致的工具调用会提示。

package/host/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-baton-host",
-  "version": "0.5.8",
+  "version": "0.5.9",
   "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.8"
+    "dsh-baton-mcp": "0.5.9"
   },
   "license": "MIT",
   "dsh": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-baton-mcp",
-  "version": "0.5.8",
+  "version": "0.5.9",
   "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.8",
+  "version": "0.5.9",
   "packages": [
     {
       "registryType": "npm",
       "identifier": "dsh-baton-mcp",
-      "version": "0.5.8",
+      "version": "0.5.9",
       "transport": {
         "type": "stdio"
       }

package/src/cli.mjs

@@ -64,8 +64,10 @@ async function main() {
       return print(await core.api.status({ run_id: rest[0] }))
     case 'wait': {
       const st = await core.api.wait({ run_id: rest[0], timeout_s: Number(flags.timeout) || 24 * 3600 })
-      print({ 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.needs_input ? { needs_input: st.needs_input, question: st.question, hint: st.question ? 'The run asks the user something: answer with dsh_answer (or dsh-baton answer), only by your own judgment if the user allowed that; otherwise show the user the questions with your own recommendation and a reason from your own judgment of the question and the task ("it is marked recommended" is not a reason) and ask first. Then wait again.' : 'The run waits for a person in the Harness UI. Tell the user, then wait again.' } : {}) })
+      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 } : {}),
+        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.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

@@ -526,6 +526,66 @@ async function useHost() {
   return up
 }
 
+// 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
+// apart from the recommendation the client has to form itself. Harness still matches a
+// cleaned label when it is chosen by label.
+const MARK = /\s*(?:\((?:recommended|推荐)\)|（(?:recommended|推荐)）)\s*/gi
+const cleanLabel = (label) => String(label).replace(MARK, ' ').trim()
+export function shapeQuestion(question) {
+  if (!Array.isArray(question?.questions)) return question
+  return {
+    ...question,
+    questions: question.questions.map((q) => {
+      let suggested = null
+      const options = (q.options ?? []).map(({ recommended, ...o }) => {
+        const label = cleanLabel(o.label)
+        if (!suggested && (recommended || label !== o.label)) suggested = { number: o.number, label }
+        return { ...o, label }
+      })
+      return { ...q, options, ...(suggested ? { harness_suggested: suggested } : {}) }
+    }),
+  }
+}
+// The question laid out for the user, ready to show: the first line is left for the
+// client's own recommendation, the asker's pick comes last and only as information.
+// Weaker models fill in a template more reliably than they follow a paragraph of rules.
+export function relayText(question) {
+  if (!Array.isArray(question?.questions)) return undefined
+  const blocks = question.questions.map((q, i) => {
+    const head = `${question.questions.length > 1 ? `${i + 1}. ` : ''}${q.question}${q.multi_select ? ' (several can be chosen)' : ''}`
+    const options = (q.options ?? []).map((o) => `  ${o.number}. ${o.label}${o.description ? ` - ${o.description}` : ''}`)
+    const asker = q.harness_suggested ? [`  (The model in Harness that asked would pick: ${q.harness_suggested.label})`] : []
+    return [head, ...options, ...asker].join('\n')
+  })
+  return ['My recommendation: <your pick>, because <your own reason>', '', ...blocks].join('\n')
+}
+
+// When the client chose for the user (dsh_answer with reason), the choice and reason are
+// kept until the run ends: the final wait result carries them, so the client tells the
+// user then, instead of only passing on the reply. A file, because the client may wait
+// from another process (wait_command).
+const reasonsFile = () => path.join(config.batonHome, 'answer-reasons.json')
+const readReasons = () => { try { return JSON.parse(fs.readFileSync(reasonsFile(), 'utf8')) } catch { return {} } }
+function rememberReason(runId, answers, reason) {
+  try {
+    const all = readReasons()
+    all[runId] = { answers: (answers ?? []).map((a) => ({ id: a.id, selected: (a.selected ?? []).map(cleanLabel), ...(a.custom ? { text: a.custom } : {}) })), reason, at: Date.now() }
+    const kept = Object.entries(all).sort((x, y) => y[1].at - x[1].at).slice(0, 50)
+    ensurePrivateDir(config.batonHome)
+    fs.writeFileSync(reasonsFile(), JSON.stringify(Object.fromEntries(kept)), { mode: 0o600 })
+  } catch { /* the reason is a courtesy; answering never fails over it */ }
+}
+const ENDED = new Set(['completed', 'failed', 'cancelled', 'interrupted'])
+const shaped = (st) => {
+  if (!st || typeof st !== 'object') return st
+  let out = st.question ? { ...st, question: shapeQuestion(st.question) } : st
+  const decided = ENDED.has(st.state) && st.run_id ? readReasons()[st.run_id] : null
+  if (decided) out = { ...out, decided_for_user: { answers: decided.answers, reason: decided.reason } }
+  return Array.isArray(st.answers) ? { ...out, answers: st.answers.map((a) => (Array.isArray(a?.selected) ? { ...a, selected: a.selected.map(cleanLabel) } : a)) } : out
+}
+
 const tag = (backend, value) => (Array.isArray(value) ? value.map((v) => ({ ...v, backend })) : { ...value, backend })
 
 export const api = {
@@ -548,10 +608,10 @@ export const api = {
     return tag('headless', await waitForSessionId(startRun(a)))
   },
   async status({ run_id, tail = 20 }) {
-    return isHostRun(run_id) ? tag('host', await hostCall('status', { run_id, tail })) : tag('headless', runStatus(run_id, { tail }))
+    return 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 tag('host', await hostCall('wait', { run_id, timeout_s }, { timeoutMs: (timeout_s + 15) * 1000 }))
+    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 }))
   },
   async cancel({ run_id, session_id }) {
@@ -579,10 +639,15 @@ export const api = {
       throw new Error(`The Harness plugin dsh-baton-host ${hostVersion ?? ''} is too old to change queued messages; this MCP server is ${VERSION}. Update the plugin in Harness: Plugins → dsh-baton-host → Uninstall, then Add plugin → dsh-baton-host@${VERSION}.`.replace('  ', ' '))
     }
   },
-  async answer(a) {
+  // reason (why the client chose, when the user let it decide) stays here: it is for the
+  // user, not for Harness.
+  async answer({ reason, ...a }) {
     if (!(await useHost())) throw new Error('Answering a question needs the dsh-baton-host plugin running inside DeepSeek Harness.')
     try {
-      return await hostCall('answer', a)
+      const result = shaped(await hostCall('answer', a))
+      if (!(typeof reason === 'string' && reason.trim())) return result
+      if (result.submitted) rememberReason(a.run_id, result.answers, reason.trim())
+      return { ...result, reason: reason.trim() }
     } catch (error) {
       if (!/Unknown method: answer/.test(error?.message)) throw error
       throw new Error(`The Harness plugin dsh-baton-host ${hostVersion ?? ''} is too old to answer questions; this MCP server is ${VERSION}. Answer in the Harness window, or update the plugin: Plugins → dsh-baton-host → Uninstall, then Add plugin → dsh-baton-host@${VERSION}.`.replace('  ', ' '))
@@ -591,6 +656,6 @@ export const api = {
   async list_runs({ limit = 10, session_id } = {}) {
     // An older plugin ignores session_id, so the host's runs are filtered here too.
     const host = (await hostAvailable()) ? tag('host', await hostCall('list_runs', { limit: session_id ? 100 : limit, session_id })).filter((r) => !session_id || r.session_id === session_id) : []
-    return [...host, ...tag('headless', listRuns({ limit, session_id }))].sort((x, y) => String(y.started_at).localeCompare(String(x.started_at))).slice(0, limit)
+    return [...host, ...tag('headless', listRuns({ limit, session_id }))].sort((x, y) => String(y.started_at).localeCompare(String(x.started_at))).slice(0, limit).map(shaped)
   },
 }

package/src/mcp.mjs

@@ -0,0 +1,327 @@
+// The MCP server itself (newline-delimited JSON-RPC 2.0 over stdio, no dependencies). It
+// runs as a child of server.mjs, which starts a fresh one when a newer version is installed.
+import readline from 'node:readline'
+import path from 'node:path'
+import * as core from './core.mjs'
+import { stableNodePath } from './setup.mjs'
+
+const SERVER = { name: 'dsh-baton', version: core.VERSION }
+const PROTOCOLS = ['2025-06-18', '2025-03-26', '2024-11-05']
+
+const str = (description) => ({ type: 'string', description })
+const int = (description, d) => ({ type: 'integer', description, default: d })
+
+// How long one dsh_wait call waits, chosen by the server so it always ends before the
+// client gives up on the tool call: Codex stops a call after 300 s, so it gets 270 s;
+// other clients get 50 s (Claude Code waits with wait_command instead). DSH_BATON_WAIT_S
+// overrides it for a client whose timeout was raised. A timeout_s from the model is
+// ignored, so a model cannot pick a short wait and poll.
+const MAX_WAIT_S = 24 * 3600
+const envWait = Math.floor(Number(core.setting('WAIT_S')))
+const isCodex = () => core.senderOf(clientName) === 'codex'
+const waitSeconds = () => {
+  if (envWait >= 1) return Math.min(envWait, MAX_WAIT_S)
+  return isCodex() ? 270 : 50
+}
+const WAIT_CHUNK_S = 10
+// The Codex app runs tools from a script cell that yields every 30 s and wakes the model
+// to resume it; a yield longer than one dsh_wait keeps the whole wait in one turn.
+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 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.'
+const DECIDED_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.'
+const NEEDS_INPUT_HINT = (st) => st.question
+  ? `The run stopped to ask the user ${st.question.count} question(s) (in question). Unless the user let you decide, show the user relay, written in the user's language, with its first line filled in with your own pick and reason (not the asker's pick and not its option description repeated), then ask which they want. ${ASKED} After answering, wait for the run again.`
+  : 'The run waits for something only a person can do in the Harness UI (an approval, for example). Tell the user, then wait for the run again.'
+
+// A shell command that blocks until a run ends and prints its reply. Run in the
+// background by a client that wakes the model when the command exits (Claude Code),
+// it waits without spending any turns. Plain "<node>" "<cli>" wait <id> form: it runs
+// in POSIX shells and in Git Bash, which Claude Code uses on Windows too. Registered on
+// Harness's own binary (no Node.js installed), the command keeps it in Node mode.
+const quote = (p) => `"${p}"`
+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
+
+// 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.
+async function waitInChunks({ run_id }, progress) {
+  const total = waitSeconds()
+  const started = Date.now()
+  const deadline = started + total * 1000
+  for (;;) {
+    const left = Math.ceil((deadline - Date.now()) / 1000)
+    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
+    // 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) {
+      return {
+        run_id, state: st.state, timed_out: true,
+        ...(st.waiting_on ? { waiting_on: st.waiting_on } : {}),
+        hint: st.state === 'waiting'
+          ? 'The run is still waiting for a person (see dsh_status for its question). Answer it with dsh_answer if you may, or tell the user; then call dsh_wait again.'
+          : `Still ${st.state}. Call dsh_wait again with the same run_id, with no other calls in between and no progress note.`,
+      }
+    }
+    progress?.(Math.round((Date.now() - started) / 1000), `run ${run_id} is ${st.state}`)
+  }
+}
+
+// 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)
+const EDIT = hints(false, false, true) // changes something, and the same call again changes nothing more
+const annotations = (title, h = READ) => ({ title, ...h })
+
+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.',
+    inputSchema: { type: 'object', properties: {} },
+    run: () => core.api.workspaces(),
+  },
+  {
+    name: 'dsh_create_workspace',
+    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.',
+    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}`,
+    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.',
+    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) })
+      // 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()}` }
+      return {
+        ...st,
+        wait_command: waitCommand(st.run_id),
+        hint: 'Run started. If you can run a shell command in the background and are woken when it exits (Claude Code: Bash with run_in_background), run wait_command that way: it ends when the run ends, or stops to ask the user something, and prints the reply or the questions, with no polling. Otherwise call dsh_wait with this run_id.',
+      }
+    },
+  },
+  {
+    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),
+  },
+  {
+    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.`,
+    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}`,
+    inputSchema: {
+      type: 'object', required: ['run_id', 'answers'], properties: {
+        run_id: str('Run id that is waiting (needs_input: answer)'),
+        answers: {
+          type: 'array', description: 'One entry per question answered now', items: {
+            type: 'object', properties: {
+              id: str('Question id from question.questions[].id; may be left out when there is one question'),
+              choose: { type: 'array', items: { type: ['integer', 'string'] }, description: 'Option numbers (1 = first) or labels; one for a single-choice question' },
+              text: str('Free-text answer'),
+              skip: { type: 'boolean', description: 'Skip this question' },
+            },
+          },
+        },
+        reason: str('Required when the user let you decide: one sentence on why you chose this, from your own judgment of the question and the task; it is returned for you to tell the user and not sent to Harness'),
+      },
+    },
+    run: async (a) => {
+      const st = await core.api.answer(a)
+      return {
+        ...st,
+        hint: st.reason
+          ? 'Tell the user what you chose and this reason. Then wait for the run again.'
+          : 'If you chose on the user\'s behalf, tell them what you chose and why, from your own judgment of the task (that the asker suggested it is not a reason); next time pass reason. Then wait for the run again.',
+      }
+    },
+  },
+  {
+    name: 'dsh_rename_session',
+    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.',
+    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',
+    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.',
+    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',
+    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.',
+    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.',
+    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',
+    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.',
+    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',
+    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.',
+    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),
+  },
+]
+
+// A client keeps the tool list a conversation started with (Codex does), so a tool added by
+// an update installed without a restart is missing there. dsh_call reaches it by name, along
+// the same path as a direct call.
+const firstSentence = (text) => text.split(/(?<=\.)\s/)[0]
+const catalog = () => TOOLS.filter((t) => t.name !== 'dsh_call').map((t) => ({
+  name: t.name,
+  description: firstSentence(typeof t.description === 'function' ? t.description() : t.description),
+  inputSchema: t.inputSchema,
+}))
+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.',
+  inputSchema: {
+    type: 'object', required: ['name'], properties: {
+      name: str('Tool name, e.g. dsh_send or a tool added by an update'),
+      arguments: { type: 'object', description: 'Arguments for that tool, as its input schema describes them (see the list returned for an unknown name)', default: {} },
+    },
+  },
+  run: (a, ctx) => {
+    const tool = TOOLS.find((t) => t.name === a.name && t.name !== 'dsh_call')
+    if (!tool) throw new Error(`No dsh-baton tool named ${JSON.stringify(a.name ?? null)}. Available tools (call them with dsh_call {name, arguments} if this conversation does not show them):\n${JSON.stringify(catalog(), null, 2)}`)
+    return tool.run(a.arguments && typeof a.arguments === 'object' ? a.arguments : {}, ctx)
+  },
+})
+
+let clientName = null
+let versionWarned = false
+
+function send(msg) {
+  process.stdout.write(JSON.stringify(msg) + '\n')
+}
+
+async function handle(req) {
+  switch (req.method) {
+    case 'initialize': {
+      const asked = req.params?.protocolVersion
+      clientName = req.params?.clientInfo?.name ?? null
+      return {
+        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}.`,
+      }
+    }
+    case 'ping':
+      return {}
+    case 'tools/list':
+      return { tools: TOOLS.map(({ run, ...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 })
+      try {
+        // MCP progress: only when the client sent a progressToken with this call.
+        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) }]
+        // 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}` }) }
+        return { content }
+      } catch (e) {
+        return { content: [{ type: 'text', text: e.message }], isError: true }
+      }
+    }
+    default:
+      throw Object.assign(new Error(`Method not found: ${req.method}`), { code: -32601 })
+  }
+}
+
+const rl = readline.createInterface({ input: process.stdin })
+
+// Exit when the client goes away: stdin closes, or the parent process dies
+// and we get re-parented. Otherwise orphaned servers pile up.
+let inFlight = 0
+let stdinClosed = false
+// Writes to a piped stdout are asynchronous: flush the last reply before exiting.
+const exitIfDone = () => { if (stdinClosed && inFlight === 0) process.stdout.write('', () => process.exit(0)) }
+rl.on('close', () => { stdinClosed = true; exitIfDone() })
+const parentPid = process.ppid
+// Windows does not re-parent orphans (ppid stays the same), so there the parent is checked directly.
+const parentGone = () => {
+  if (process.platform !== 'win32') return false
+  try { process.kill(parentPid, 0); return false } catch (e) { return e.code !== 'EPERM' }
+}
+setInterval(() => { if (process.ppid !== parentPid || parentGone()) process.exit(0) }, 5000).unref()
+
+rl.on('line', async (line) => {
+  if (!line.trim()) return
+  let req
+  try { req = JSON.parse(line) } catch { return send({ jsonrpc: '2.0', id: null, error: { code: -32700, message: 'Parse error' } }) }
+  if (req === null || typeof req !== 'object' || Array.isArray(req) || typeof req.method !== 'string') {
+    return send({ jsonrpc: '2.0', id: req?.id ?? null, error: { code: -32600, message: 'Invalid Request' } })
+  }
+  if (req.id === undefined) return // notification
+  inFlight++
+  try {
+    send({ jsonrpc: '2.0', id: req.id, result: await handle(req) })
+  } catch (e) {
+    send({ jsonrpc: '2.0', id: req.id, error: { code: e.code || -32603, message: e.message } })
+  } finally {
+    inFlight--
+    exitIfDone()
+  }
+})

package/src/server.mjs

@@ -1,290 +1,226 @@
 #!/usr/bin/env node
-// MCP server over stdio (newline-delimited JSON-RPC 2.0), no dependencies.
-import readline from 'node:readline'
+// What MCP clients start: a thin shell that holds the stdio connection and passes every
+// message to the server proper (mcp.mjs), run as a child process. Before each tools/list
+// and tools/call it checks package.json; when a newer copy was installed over this folder
+// (by the Harness plugin, setup or by hand) it starts a fresh child from the new files and
+// sends the call there, so an open conversation uses the new version without a restart or
+// a reconnect. Calls still running in the old child (a long dsh_wait) finish there first.
+// If the new child cannot start, the old one keeps serving and the reply says why.
+import fs from 'node:fs'
 import path from 'node:path'
-import * as core from './core.mjs'
-import { stableNodePath } from './setup.mjs'
-
-const SERVER = { name: 'dsh-baton', version: core.VERSION }
-const PROTOCOLS = ['2025-06-18', '2025-03-26', '2024-11-05']
+import readline from 'node:readline'
+import { spawn } from 'node:child_process'
+import { fileURLToPath } from 'node:url'
 
-const str = (description) => ({ type: 'string', description })
-const int = (description, d) => ({ type: 'integer', description, default: d })
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..')
+const START_TIMEOUT_MS = Number(process.env.DSH_BATON_START_TIMEOUT_MS) || 15000
 
-// How long one dsh_wait call waits, chosen by the server so it always ends before the
-// client gives up on the tool call: Codex stops a call after 300 s, so it gets 270 s;
-// other clients get 50 s (Claude Code waits with wait_command instead). DSH_BATON_WAIT_S
-// overrides it for a client whose timeout was raised. A timeout_s from the model is
-// ignored, so a model cannot pick a short wait and poll.
-const MAX_WAIT_S = 24 * 3600
-const envWait = Math.floor(Number(core.setting('WAIT_S')))
-const isCodex = () => core.senderOf(clientName) === 'codex'
-const waitSeconds = () => {
-  if (envWait >= 1) return Math.min(envWait, MAX_WAIT_S)
-  return isCodex() ? 270 : 50
+function send(msg) {
+  process.stdout.write(JSON.stringify(msg) + '\n')
 }
-const WAIT_CHUNK_S = 10
-// The Codex app runs tools from a script cell that yields every 30 s and wakes the model
-// to resume it; a yield longer than one dsh_wait keeps the whole wait in one turn.
-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.`
+
+// What identifies an installed copy: its version, and the time package.json was written
+// (a copy with the same version, such as a test build, still counts as new). The installer
+// writes package.json after src, so a new stamp means the new files are in place.
+function stamp() {
+  try {
+    const file = path.join(ROOT, 'package.json')
+    return `${JSON.parse(fs.readFileSync(file, 'utf8')).version}@${fs.statSync(file).mtimeMs}`
+  } catch {
+    return null
+  }
 }
-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 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, answer with dsh_answer by your own judgment (the recommended option is only a suggestion). Otherwise show the user the questions and options, add your own recommendation with a short reason drawn from your own judgment of the question and the task (it may differ from the option marked recommended; "it is marked recommended" is not a reason), wait for their decision, then submit it with dsh_answer. Never answer on the user\'s behalf without that permission.'
-const NEEDS_INPUT_HINT = (st) => st.question
-  ? `The run stopped to ask the user ${st.question.count} question(s) (in question). ${ASKED} After answering, wait for the run again.`
-  : 'The run waits for something only a person can do in the Harness UI (an approval, for example). Tell the user, then wait for the run again.'
 
-// A shell command that blocks until a run ends and prints its reply. Run in the
-// background by a client that wakes the model when the command exits (Claude Code),
-// it waits without spending any turns. Plain "<node>" "<cli>" wait <id> form: it runs
-// in POSIX shells and in Git Bash, which Claude Code uses on Windows too. Registered on
-// Harness's own binary (no Node.js installed), the command keeps it in Node mode.
-const quote = (p) => `"${p}"`
-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
+let nextInternal = 0
+const children = new Set()
 
-// 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.
-async function waitInChunks({ run_id }, progress) {
-  const total = waitSeconds()
-  const started = Date.now()
-  const deadline = started + total * 1000
-  for (;;) {
-    const left = Math.ceil((deadline - Date.now()) / 1000)
-    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, hint: NEEDS_INPUT_HINT(st) }
-    if (!st.timed_out) return 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) {
-      return {
-        run_id, state: st.state, timed_out: true,
-        ...(st.waiting_on ? { waiting_on: st.waiting_on } : {}),
-        hint: st.state === 'waiting'
-          ? 'The run is still waiting for a person (see dsh_status for its question). Answer it with dsh_answer if you may, or tell the user; then call dsh_wait again.'
-          : `Still ${st.state}. Call dsh_wait again with the same run_id, with no other calls in between and no progress note.`,
-      }
-    }
-    progress?.(Math.round((Date.now() - started) / 1000), `run ${run_id} is ${st.state}`)
+function startChild() {
+  const proc = spawn(process.execPath, [path.join(ROOT, 'src', 'mcp.mjs')], {
+    stdio: ['pipe', 'pipe', 'inherit'],
+    windowsHide: true,
+    env: process.versions.electron ? { ...process.env, ELECTRON_RUN_AS_NODE: '1' } : process.env,
+  })
+  const child = {
+    proc,
+    clientCalls: new Map(), // client request id -> optional rewrite of the result
+    internal: new Map(), // the shell's own requests: id -> { resolve, reject }
+    retired: false,
+    exited: false,
+    write(msg) { if (!this.exited && proc.stdin.writable) proc.stdin.write(JSON.stringify(msg) + '\n') },
+    request(method, params) {
+      const id = `dsh-baton-shell-${++nextInternal}`
+      return new Promise((resolve, reject) => {
+        this.internal.set(id, { resolve, reject })
+        this.write({ jsonrpc: '2.0', id, method, params })
+      })
+    },
+    // Stop taking calls; it exits on its own once the last one it holds has answered.
+    retire() { this.retired = true; this.closeIfIdle() },
+    closeIfIdle() { if (this.retired && this.clientCalls.size === 0 && this.internal.size === 0) proc.stdin.end() },
   }
+  children.add(child)
+  proc.stdin.on('error', () => {})
+  readline.createInterface({ input: proc.stdout }).on('line', (line) => {
+    let msg
+    try { msg = JSON.parse(line) } catch { return }
+    const own = child.internal.get(msg.id)
+    if (own) {
+      child.internal.delete(msg.id)
+      msg.error ? own.reject(new Error(msg.error.message)) : own.resolve(msg.result)
+    } else if (msg.id !== undefined && child.clientCalls.has(msg.id)) {
+      const rewrite = child.clientCalls.get(msg.id)
+      child.clientCalls.delete(msg.id)
+      send(rewrite && msg.result ? { ...msg, result: rewrite(msg.result) } : msg)
+    } else {
+      send(msg) // notifications (progress) and replies to malformed requests
+    }
+    child.closeIfIdle()
+  })
+  proc.on('error', () => {})
+  proc.on('exit', (code) => {
+    child.exited = true
+    children.delete(child)
+    for (const [id] of child.clientCalls) send({ jsonrpc: '2.0', id, error: { code: -32603, message: `The dsh-baton server process stopped (exit code ${code}).` } })
+    for (const [, own] of child.internal) own.reject(new Error(`exited with code ${code}`))
+    child.clientCalls.clear()
+    child.internal.clear()
+    if (current === child) current = null
+    exitIfDone()
+  })
+  return child
 }
 
-// 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)
-const EDIT = hints(false, false, true) // changes something, and the same call again changes nothing more
-const annotations = (title, h = READ) => ({ title, ...h })
+let current = null
+let currentStamp = null
+let currentVersion = null
+let failedStamp = null
+let initParams = null
+let lastTools = null // the tool list the client last saw, to tell it when that changes
+let note = null // said once, with the next tools/call result
 
-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.',
-    inputSchema: { type: 'object', properties: {} },
-    run: () => core.api.workspaces(),
-  },
-  {
-    name: 'dsh_create_workspace',
-    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.',
-    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}`,
-    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.',
-    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) })
-      // 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()}` }
-      return {
-        ...st,
-        wait_command: waitCommand(st.run_id),
-        hint: 'Run started. If you can run a shell command in the background and are woken when it exits (Claude Code: Bash with run_in_background), run wait_command that way: it ends when the run ends, or stops to ask the user something, and prints the reply or the questions, with no polling. Otherwise call dsh_wait with this run_id.',
-      }
-    },
-  },
-  {
-    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),
-  },
-  {
-    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; relay them with your own recommendation and a reason from your own judgment of the task, not the recommended mark, 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.`,
-    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. 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}`,
-    inputSchema: {
-      type: 'object', required: ['run_id', 'answers'], properties: {
-        run_id: str('Run id that is waiting (needs_input: answer)'),
-        answers: {
-          type: 'array', description: 'One entry per question answered now', items: {
-            type: 'object', properties: {
-              id: str('Question id from question.questions[].id; may be left out when there is one question'),
-              choose: { type: 'array', items: { type: ['integer', 'string'] }, description: 'Option numbers (1 = first) or labels; one for a single-choice question' },
-              text: str('Free-text answer'),
-              skip: { type: 'boolean', description: 'Skip this question' },
-            },
-          },
-        },
-      },
-    },
-    run: (a) => core.api.answer(a),
-  },
-  {
-    name: 'dsh_rename_session',
-    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.',
-    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',
-    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.',
-    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',
-    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.',
-    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.',
-    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',
-    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.',
-    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',
-    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.',
-    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),
-  },
-]
+const withTimeout = (promise, ms, what) => Promise.race([
+  promise,
+  new Promise((_, reject) => setTimeout(() => reject(new Error(`${what} did not answer within ${ms / 1000} s`)), ms).unref()),
+])
 
-let clientName = null
-let versionWarned = false
+// A child that stopped is replaced on the next message; once the client has initialized,
+// the replacement is initialized the same way before it takes calls.
+async function ensureChild() {
+  if (current) return current
+  currentStamp = stamp()
+  const child = current = startChild()
+  if (initParams) {
+    try {
+      const init = await withTimeout(child.request('initialize', initParams), START_TIMEOUT_MS, 'The restarted server')
+      currentVersion = init?.serverInfo?.version ?? currentVersion
+      child.write({ jsonrpc: '2.0', method: 'notifications/initialized' })
+    } catch { /* its calls then fail with the reason */ }
+  }
+  return child
+}
 
-function send(msg) {
-  process.stdout.write(JSON.stringify(msg) + '\n')
+// Start a child from the newly installed files and make it the one that takes calls.
+async function reloadIfInstalled() {
+  if (!initParams || !current) return
+  const now = stamp()
+  if (!now || now === currentStamp || now === failedStamp) return
+  const next = startChild()
+  try {
+    const init = await withTimeout(next.request('initialize', initParams), START_TIMEOUT_MS, 'The new version')
+    next.write({ jsonrpc: '2.0', method: 'notifications/initialized' })
+    const { tools } = await withTimeout(next.request('tools/list', {}), START_TIMEOUT_MS, 'The new version')
+    // What the old version had, to name what is new (the client may not show new tools).
+    const had = await withTimeout(current.request('tools/list', {}), 5000, 'The old version').then((r) => r.tools.map((t) => t.name), () => null)
+    const added = had ? tools.map((t) => t.name).filter((n) => !had.includes(n)) : []
+    const before = currentVersion
+    current.retire()
+    current = next
+    currentStamp = now
+    currentVersion = init?.serverInfo?.version ?? null
+    note = `dsh-baton was updated from ${before} to ${currentVersion} without a restart; this call already used ${currentVersion}.` +
+      (added.length ? ` New in this version: ${added.join(', ')}. If this conversation does not show them, call them through dsh_call {name, arguments}.` : '')
+    if (lastTools !== null && JSON.stringify(tools) !== lastTools) {
+      lastTools = JSON.stringify(tools)
+      send({ jsonrpc: '2.0', method: 'notifications/tools/list_changed' })
+    }
+  } catch (e) {
+    next.proc.kill()
+    failedStamp = now
+    const version = now.split('@')[0]
+    note = `A new dsh-baton (${version}) is installed but could not be started (${e.message}); this call still used ${currentVersion}. Restart this client to load it, or reinstall.`
+  }
 }
 
-async function handle(req) {
-  switch (req.method) {
-    case 'initialize': {
-      const asked = req.params?.protocolVersion
-      clientName = req.params?.clientInfo?.name ?? null
-      return {
-        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}`,
-      }
+const appendNote = (result) => {
+  if (!note || !Array.isArray(result.content)) return result
+  const text = note
+  note = null
+  return { ...result, content: [...result.content, { type: 'text', text: `Note for the user: ${text}` }] }
+}
+
+async function route(line) {
+  let msg
+  try { msg = JSON.parse(line) } catch { msg = null }
+  const ok = msg && typeof msg === 'object' && !Array.isArray(msg) && typeof msg.method === 'string'
+  if (!ok) return (await ensureChild()).proc.stdin.write(line + '\n') // the child sends the error reply
+
+  if (msg.id === undefined) {
+    // A cancellation goes to the child running that call; other notifications to the current one.
+    if (msg.method === 'notifications/cancelled') {
+      for (const c of children) if (c.clientCalls.has(msg.params?.requestId)) return c.write(msg)
+      return
     }
-    case 'ping':
-      return {}
-    case 'tools/list':
-      return { tools: TOOLS.map(({ run, ...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 })
-      try {
-        // MCP progress: only when the client sent a progressToken with this call.
-        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) }]
-        // 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}` }) }
-        return { content }
-      } catch (e) {
-        return { content: [{ type: 'text', text: e.message }], isError: true }
-      }
+    return current?.write(msg)
+  }
+
+  let rewrite = null
+  if (msg.method === 'initialize') {
+    await ensureChild()
+    initParams = msg.params ?? {}
+    rewrite = (result) => {
+      currentVersion = result.serverInfo?.version ?? null
+      return { ...result, capabilities: { ...result.capabilities, tools: { ...result.capabilities?.tools, listChanged: true } } }
     }
-    default:
-      throw Object.assign(new Error(`Method not found: ${req.method}`), { code: -32601 })
+  } else if (msg.method === 'tools/list' || msg.method === 'tools/call') {
+    await reloadIfInstalled()
+    rewrite = msg.method === 'tools/list'
+      ? (result) => { lastTools = JSON.stringify(result.tools); return result }
+      : appendNote
   }
+  const child = await ensureChild()
+  child.clientCalls.set(msg.id, rewrite)
+  child.write(msg)
 }
 
+// Messages are passed on in the order they came, even while a new child starts.
+let queue = Promise.resolve()
 const rl = readline.createInterface({ input: process.stdin })
+rl.on('line', (line) => {
+  if (!line.trim()) return
+  queue = queue.then(() => route(line)).catch((e) => process.stderr.write(`dsh-baton: ${e.stack ?? e}\n`))
+})
 
-// Exit when the client goes away: stdin closes, or the parent process dies
-// and we get re-parented. Otherwise orphaned servers pile up.
-let inFlight = 0
+// Exit once the client is gone and every child has answered and stopped.
 let stdinClosed = false
-// Writes to a piped stdout are asynchronous: flush the last reply before exiting.
-const exitIfDone = () => { if (stdinClosed && inFlight === 0) process.stdout.write('', () => process.exit(0)) }
-rl.on('close', () => { stdinClosed = true; exitIfDone() })
+function exitIfDone() {
+  if (stdinClosed && children.size === 0) process.stdout.write('', () => process.exit(0))
+}
+rl.on('close', () => {
+  stdinClosed = true
+  queue.then(() => {
+    for (const c of children) c.retire()
+    exitIfDone()
+  })
+})
+// The parent process died and we were re-parented (or, on Windows, the parent is gone).
 const parentPid = process.ppid
-// Windows does not re-parent orphans (ppid stays the same), so there the parent is checked directly.
 const parentGone = () => {
   if (process.platform !== 'win32') return false
   try { process.kill(parentPid, 0); return false } catch (e) { return e.code !== 'EPERM' }
 }
-setInterval(() => { if (process.ppid !== parentPid || parentGone()) process.exit(0) }, 5000).unref()
-
-rl.on('line', async (line) => {
-  if (!line.trim()) return
-  let req
-  try { req = JSON.parse(line) } catch { return send({ jsonrpc: '2.0', id: null, error: { code: -32700, message: 'Parse error' } }) }
-  if (req === null || typeof req !== 'object' || Array.isArray(req) || typeof req.method !== 'string') {
-    return send({ jsonrpc: '2.0', id: req?.id ?? null, error: { code: -32600, message: 'Invalid Request' } })
+setInterval(() => {
+  if (process.ppid !== parentPid || parentGone()) {
+    for (const c of children) c.proc.kill()
+    process.exit(0)
   }
-  if (req.id === undefined) return // notification
-  inFlight++
-  try {
-    send({ jsonrpc: '2.0', id: req.id, result: await handle(req) })
-  } catch (e) {
-    send({ jsonrpc: '2.0', id: req.id, error: { code: e.code || -32603, message: e.message } })
-  } finally {
-    inFlight--
-    exitIfDone()
-  }
-})
+}, 5000).unref()