dsh-baton-host 0.0.1 → 0.4.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 JialaoLiu
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,39 @@
 # dsh-baton-host
 
-This name is reserved for [dsh-baton](https://github.com/JialaoLiu/dsh-baton). The real release is coming soon.
+DeepSeek Harness plugin for [dsh-baton](https://github.com/JialaoLiu/dsh-baton#readme). It runs inside the Harness host (desktop app or `dsh web`) and serves a local, owner-only Unix socket (`~/.dsh-baton/host.sock`; a per-user named pipe on Windows, see [WINDOWS.md](https://github.com/JialaoLiu/dsh-baton/blob/main/WINDOWS.md)). Through it, an MCP client can list and create workspaces, create sessions, continue a specific session, and wait for its turn to finish. All of this goes through Harness's own session controller, so the messages show up live in the Harness UI.
+
+DeepSeek Harness 插件，配合 [dsh-baton](https://github.com/JialaoLiu/dsh-baton/blob/main/README.zh-CN.md) 使用。它运行在 Harness 内部，只开一个当前用户才能访问的本地套接字，让 MCP 客户端能新建工作区和对话、续接指定对话、等待任务完成。所有操作都走 Harness 官方会话服务，界面实时可见。
+
+## Install / 安装
+
+Harness → Plugins / 插件 → Add plugin / 添加插件 → registry Official npm registry → `dsh-baton-host` → Install / 安装 → Enable now / 立即启用
+
+Update / 更新: uninstall, then add it again / 先卸载再重新添加. Keep it on the same version as `dsh-baton-mcp` / 版本与 `dsh-baton-mcp` 保持一致.
+
+Then connect the MCP server / 然后接入 MCP 服务器: see [dsh-baton](https://github.com/JialaoLiu/dsh-baton#readme).
+
+## Socket protocol / 套接字协议
+
+Newline-delimited JSON: request `{"id", "method", "params"}`, reply `{"id", "result"}` or `{"id", "error"}`.
+
+| Method | Params |
+|---|---|
+| `ping` | — |
+| `workspaces` | — |
+| `create_workspace` | `path`, `title?`, `create_dir?` (default `true`) |
+| `list_sessions` | `cwd?`, `query?`, `limit?` |
+| `read_session` | `session_id`, `last?` |
+| `send` | `message`, and `session_id` or `cwd` or `workspace_id`; `mode?` (`followup` \| `steer`) |
+| `status` | `run_id`, `tail?` |
+| `wait` | `run_id`, `timeout_s?` |
+| `activity` | `session_id` |
+| `cancel` | `run_id` or `session_id` |
+| `rename_session` | `session_id`, `title` |
+| `rename_workspace` | `workspace_id` or `path`, `title` |
+| `list_runs` | `limit?` |
+
+`DSH_BATON_SOCKET` / `DSH_BATON_HOME` in the Harness process environment move the socket.
+
+## License
+
+MIT

package/cordis.patch.yml

@@ -0,0 +1,4 @@
+# dsh-baton-host bundle layer: mounts the single host plugin row.
+- insert:
+    - id: dsh-baton-host
+      name: dsh-baton-host

package/lib/client.js

@@ -0,0 +1,98 @@
+// dsh-baton-host, browser half: labels chat messages sent through dsh-baton with
+// their sender ("Sent by Claude from another chat"). The host half puts the sender
+// into the prompt's request id ("dsh-baton.<sender>.<uuid>"); the chat records it as
+// the user message's source.rpcId, so the label survives reloads with no extra state.
+//
+// It wraps the chat's own user-message renderer: the wrapper registers at a lower
+// slot priority (the lowest renders), draws the label, then renders the shipped
+// renderer unchanged. If the wrapper throws, the slot retires it and the shipped
+// renderer takes over again.
+//
+// Hand-written in the client module format (no build step): the host serves this
+// file as the package's "./client" export.
+window.__ModuleLoader__.load({
+  id: 'dsh-baton-host',
+  factory: (require) => {
+    const module = { exports: {} }
+    const { createElement: h } = require('react')
+
+    const SLOT = 'conversation.chat.node'
+    const KEYS = ['user', 'steering']
+    const PRIORITY = -100
+    const NS = 'dsh-baton'
+    // dsh-bridge: messages sent before the project was renamed.
+    const RPC_RE = /^dsh-(?:baton|bridge)\.([a-z0-9-]{1,32})\./
+    // Codex shows as ChatGPT, the way the ChatGPT app labels its own cross-chat messages.
+    const NAMES = { claude: 'Claude', codex: 'ChatGPT' }
+
+    const zh = { sentFrom: '由 {name} 从另一个聊天发送' }
+    const en = { sentFrom: 'Sent by {name} from another chat' }
+
+    function senderOf(node) {
+      const rpcId = node?.data?.source?.rpcId
+      const m = typeof rpcId === 'string' ? RPC_RE.exec(rpcId) : null
+      return m ? m[1] : null
+    }
+    const nameOf = (sender) => NAMES[sender] ?? sender.charAt(0).toUpperCase() + sender.slice(1)
+
+    // Sender marks, drawn in the label's text colour like ChatGPT's own "sent from another chat" line.
+    const MARKS = {
+      claude: { viewBox: '0 0 248 248', d: 'M52.4285 162.873L98.7844 136.879L99.5485 134.602L98.7844 133.334H96.4921L88.7237 132.862L62.2346 132.153L39.3113 131.207L17.0249 130.026L11.4214 128.844L6.2 121.873L6.7094 118.447L11.4214 115.257L18.171 115.847L33.0711 116.911L55.485 118.447L71.6586 119.392L95.728 121.873H99.5485L100.058 120.337L98.7844 119.392L97.7656 118.447L74.5877 102.732L49.4995 86.1905L36.3823 76.62L29.3779 71.7757L25.8121 67.2858L24.2839 57.3608L30.6515 50.2716L39.3113 50.8623L41.4763 51.4531L50.2636 58.1879L68.9842 72.7209L93.4357 90.6804L97.0015 93.6343L98.4374 92.6652L98.6571 91.9801L97.0015 89.2625L83.757 65.2772L69.621 40.8192L63.2534 30.6579L61.5978 24.632C60.9565 22.1032 60.579 20.0111 60.579 17.4246L67.8381 7.49965L71.9133 6.19995L81.7193 7.49965L85.7946 11.0443L91.9074 24.9865L101.714 46.8451L116.996 76.62L121.453 85.4816L123.873 93.6343L124.764 96.1155H126.292V94.6976L127.566 77.9197L129.858 57.3608L132.15 30.8942L132.915 23.4505L136.608 14.4708L143.994 9.62643L149.725 12.344L154.437 19.0788L153.8 23.4505L150.998 41.6463L145.522 70.1215L141.957 89.2625H143.994L146.414 86.7813L156.093 74.0206L172.266 53.698L179.398 45.6635L187.803 36.802L193.152 32.5484H203.34L210.726 43.6549L207.415 55.1159L196.972 68.3492L188.312 79.5739L175.896 96.2095L168.191 109.585L168.882 110.689L170.738 110.53L198.755 104.504L213.91 101.787L231.994 98.7149L240.144 102.496L241.036 106.395L237.852 114.311L218.495 119.037L195.826 123.645L162.07 131.592L161.696 131.893L162.137 132.547L177.36 133.925L183.855 134.279H199.774L229.447 136.524L237.215 141.605L241.8 147.867L241.036 152.711L229.065 158.737L213.019 154.956L175.45 145.977L162.587 142.787H160.805V143.85L171.502 154.366L191.242 172.089L215.82 195.011L217.094 200.682L213.91 205.172L210.599 204.699L188.949 188.394L180.544 181.069L161.696 165.118H160.422V166.772L164.752 173.152L187.803 207.771L188.949 218.405L187.294 221.832L181.308 223.959L174.813 222.777L161.187 203.754L147.305 182.486L136.098 163.345L134.745 164.2L128.075 235.42L125.019 239.082L117.887 241.8L111.902 237.31L108.718 229.984L111.902 215.452L115.722 196.547L118.779 181.541L121.58 162.873L123.291 156.636L123.14 156.219L121.773 156.449L107.699 175.752L86.304 204.699L69.3663 222.777L65.291 224.431L58.2867 220.768L58.9235 214.27L62.8713 208.48L86.304 178.705L100.44 160.155L109.551 149.507L109.462 147.967L108.959 147.924L46.6977 188.512L35.6182 189.93L30.7788 185.44L31.4156 178.115L33.7079 175.752L52.4285 162.873Z' },
+      codex: { viewBox: '0 0 24 24', d: 'M9.20509 8.76514V6.50548C9.20509 6.31517 9.27649 6.17237 9.44293 6.07733L13.9861 3.46091C14.6046 3.10416 15.342 2.93772 16.103 2.93772C18.9573 2.93772 20.7651 5.14986 20.7651 7.50457C20.7651 7.67101 20.7651 7.86132 20.7412 8.05164L16.0316 5.29243C15.7462 5.12599 15.4607 5.12599 15.1753 5.29243L9.20509 8.76514ZM19.8136 17.566V12.1665C19.8136 11.8334 19.6708 11.5955 19.3854 11.4291L13.4152 7.95637L15.3656 6.83836C15.5321 6.74332 15.6749 6.74332 15.8413 6.83836L20.3845 9.45477C21.6928 10.216 22.5728 11.8334 22.5728 13.4032C22.5728 15.2108 21.5025 16.8759 19.8136 17.5657V17.566ZM7.80173 12.8088L5.8513 11.6671C5.68486 11.5721 5.61346 11.4293 5.61346 11.239V6.00616C5.61346 3.46114 7.56389 1.53436 10.2042 1.53436C11.2033 1.53436 12.1307 1.86746 12.9159 2.46205L8.2301 5.17374C7.94475 5.34018 7.80196 5.57801 7.80196 5.91112V12.809L7.80173 12.8088ZM12 15.2349L9.20509 13.6651V10.3352L12 8.76537L14.7947 10.3352V13.6651L12 15.2349ZM13.7958 22.4659C12.7967 22.4659 11.8693 22.1328 11.0841 21.5382L15.7699 18.8265C16.0553 18.6601 16.198 18.4223 16.198 18.0892V11.1912L18.1723 12.3329C18.3388 12.4279 18.4102 12.5707 18.4102 12.7611V17.9939C18.4102 20.5389 16.4359 22.4657 13.7958 22.4657V22.4659ZM8.15848 17.1617L3.61528 14.5453C2.30696 13.784 1.42701 12.1667 1.42701 10.5969C1.42701 8.76537 2.52115 7.12417 4.20987 6.43431V11.8575C4.20987 12.1906 4.35266 12.4284 4.63802 12.5948L10.5846 16.0437L8.63415 17.1617C8.46771 17.2567 8.32492 17.2567 8.15848 17.1617ZM7.897 21.0626C5.20919 21.0626 3.23488 19.0407 3.23488 16.5432C3.23488 16.3529 3.25875 16.1626 3.2824 15.9723L7.96817 18.684C8.25352 18.8504 8.53911 18.8504 8.82447 18.684L14.7947 15.2351V17.4948C14.7947 17.6851 14.7233 17.8279 14.5568 17.9229L10.0136 20.5394C9.39518 20.8961 8.6578 21.0626 7.89677 21.0626H7.897ZM13.7958 23.8929C16.6739 23.8929 19.0762 21.8475 19.6235 19.1358C22.2874 18.4459 24 15.9484 24 13.4034C24 11.7383 23.2865 10.121 22.002 8.95546C22.121 8.45591 22.1924 7.95637 22.1924 7.45705C22.1924 4.05573 19.4331 1.51048 16.2458 1.51048C15.6037 1.51048 14.9852 1.60553 14.3668 1.81971C13.2963 0.773101 11.8215 0.107117 10.2042 0.107117C7.32606 0.107117 4.92383 2.15259 4.37653 4.86428C1.7126 5.55414 0 8.05164 0 10.5967C0 12.2617 0.713506 13.8791 1.99795 15.0446C1.87904 15.5441 1.80764 16.0437 1.80764 16.543C1.80764 19.9443 4.56685 22.4896 7.75421 22.4896C8.39632 22.4896 9.01478 22.3945 9.63324 22.1803C10.7035 23.2269 12.1783 23.8929 13.7958 23.8929Z' },
+    }
+
+    // Any other sender: a speech bubble with an arrow, "came in from another conversation".
+    function Icon({ sender }) {
+      const box = { width: 14, height: 14, 'aria-hidden': true, style: { flex: 'none' } }
+      const mark = MARKS[sender]
+      if (mark) return h('svg', { ...box, viewBox: mark.viewBox }, h('path', { d: mark.d, fill: 'currentColor' }))
+      return h('svg', { ...box, viewBox: '0 0 16 16', fill: 'none' },
+        h('path', { d: 'M2.5 3.5h11v7h-6l-3 2.5v-2.5h-2z', stroke: 'currentColor', strokeWidth: 1.2, strokeLinejoin: 'round' }),
+        h('path', { d: 'M6 7h4M8.5 5.5 10 7 8.5 8.5', stroke: 'currentColor', strokeWidth: 1.2, strokeLinecap: 'round', strokeLinejoin: 'round' }))
+    }
+
+    function Label({ sender, text }) {
+      return h('div', {
+        'data-dsh-baton-sender': '',
+        style: {
+          display: 'flex', alignItems: 'center', gap: 6, alignSelf: 'flex-end',
+          color: 'var(--dsw-alias-label-tertiary)',
+          fontSize: 'var(--dsh-content-font-size-secondary, 13px)', lineHeight: '20px',
+          marginBottom: 4, paddingRight: 4,
+        },
+      }, h(Icon, { sender }), h('span', null, text))
+    }
+
+    // The renderer this wrapper shadows: the best-ranked entry for the key that is not ours.
+    function shipped(ctx, key, own) {
+      return ctx.slots.entries(SLOT)
+        .filter((e) => e.options?.key === key && e.component !== own && typeof e.component !== 'string')
+        .sort((a, b) => (a.options?.priority ?? 0) - (b.options?.priority ?? 0))[0]?.component
+    }
+
+    function wrapperFor(ctx, key, t) {
+      function DshBatonUserMessage(props) {
+        const Inner = shipped(ctx, key, DshBatonUserMessage)
+        if (!Inner) return null
+        const sender = senderOf(props.node)
+        if (!sender) return h(Inner, props)
+        return h('div', { style: { display: 'flex', flexDirection: 'column' } },
+          h(Label, { sender, text: t('sentFrom', { name: nameOf(sender) }) }),
+          h(Inner, props))
+      }
+      return DshBatonUserMessage
+    }
+
+    module.exports.name = 'dsh-baton-host'
+    module.exports.inject = ['slots', 'locale']
+    module.exports.apply = function apply(ctx) {
+      ctx.effect(() => ctx.locale.register(NS, { zh, en }), 'dsh-baton: dictionaries')
+      const t = ctx.locale.bind(NS)
+      ctx.slots.inject(SLOT, function* () {
+        // locale 'chat': the shipped renderer reads its strings through the `t` it is handed.
+        for (const key of KEYS) yield ctx.slots.register({ name: SLOT, key, priority: PRIORITY, locale: 'chat' }, wrapperFor(ctx, key, t))
+      })
+    }
+    return module.exports
+  },
+})

package/lib/index.js

@@ -0,0 +1,661 @@
+// dsh-baton-host: a DeepSeek Harness plugin that runs inside the Harness host
+// (desktop app or `dsh web`) and serves a local control socket, so an outside
+// orchestrator can list sessions, continue a specific session, and learn when
+// its turn finishes. Everything goes through the host's own session controller,
+// so prompts show up live in the Harness UI exactly like typed messages.
+//
+// Plugin form: named exports only (name / inject / apply), no default export.
+import fs from 'node:fs'
+import net from 'node:net'
+import os from 'node:os'
+import path from 'node:path'
+import crypto from 'node:crypto'
+import { socketEndpoint, batonHome, socketPath as socketPathSetting } from './socket.js'
+
+export const name = 'dsh-baton-host'
+export const inject = ['sessionController', 'workspaceRegistry']
+
+const VERSION = JSON.parse(fs.readFileSync(new URL('../package.json', import.meta.url), 'utf8')).version
+const MAX_EVENTS = 200
+const MAX_RUNS = 100
+const QUIET_CONFIRM_MS = 2000
+const CANCEL_ATTEMPTS = 3
+const CANCEL_SETTLE_MS = 6000
+const ACTIVITY_MAX_ERRORS = 10
+const MAX_REQUEST_BYTES = 4 * 1024 * 1024
+const MAX_WAIT_S = 24 * 3600
+const MAX_HUMAN_INPUTS = 10
+const PERSIST_DELAY_MS = 1000
+// A relayed prompt's request id carries its sender ("dsh-baton.<sender>.<uuid>"), so the
+// client half (lib/client.js) can label the message in the chat without any extra state.
+const SENDER_RE = /^[a-z0-9-]{1,32}$/
+const requestIdFor = (sender) => (sender ? `dsh-baton.${sender}.${crypto.randomUUID()}` : crypto.randomUUID())
+
+
+const IS_WIN = process.platform === 'win32'
+
+// A Unix socket file on macOS / Linux, a per-user named pipe on Windows (see socket.js).
+function socketPath() {
+  return socketEndpoint(socketPathSetting())
+}
+
+const probe = (sock) => new Promise((resolve) => {
+  const conn = net.connect(sock)
+  conn.on('connect', () => { conn.destroy(); resolve(true) })
+  conn.on('error', () => resolve(false))
+})
+
+// Expand `~`, resolve, and follow symlinks when the path exists, so the same
+// folder always compares equal (on macOS /tmp is a link to /private/tmp).
+function normalizePath(p) {
+  const abs = path.resolve(p.replace(/^~(?=$|[\\/])/, os.homedir()))
+  try { return fs.realpathSync.native(abs) } catch { return abs }
+}
+
+// Prepare the socket path without touching anything that is not ours: only our
+// own directory gets 0700, only a stale socket is removed, and a live host that
+// already answers there is left alone.
+async function claimSocket(sock) {
+  // A named pipe has no file to own, chmod or clean up; it disappears with its
+  // server. Only refuse to start when another host already answers on it.
+  if (IS_WIN) {
+    if (await probe(sock)) throw new Error(`another dsh-baton-host already serves ${sock}; set DSH_BATON_SOCKET for a second host`)
+    return
+  }
+  const dir = path.dirname(sock)
+  const ours = dir === batonHome() || !fs.existsSync(dir)
+  fs.mkdirSync(dir, { recursive: true, mode: 0o700 })
+  if (ours) fs.chmodSync(dir, 0o700)
+  let st
+  try { st = fs.lstatSync(sock) } catch { return }
+  if (!st.isSocket()) throw new Error(`${sock} exists and is not a socket; point DSH_BATON_SOCKET somewhere else`)
+  const live = await probe(sock)
+  if (live) throw new Error(`another dsh-baton-host already serves ${sock}; set DSH_BATON_SOCKET for a second host`)
+  fs.unlinkSync(sock)
+}
+
+const parts = (content) => (Array.isArray(content) ? content.filter((c) => c && typeof c === 'object') : [])
+
+const textOf = (content) => parts(content).filter((c) => c.type === 'text').map((c) => c.text).join('\n')
+
+function toolCallsOf(content) {
+  return parts(content).filter((c) => c.type !== 'text' && c.type !== 'reasoning')
+    .map((c) => ({ kind: c.type, name: c.name ?? c.toolName, input: c.input ?? c.arguments }))
+}
+
+const iso = (t) => (typeof t === 'number' ? new Date(t).toISOString() : t ?? null)
+
+export function apply(ctx) {
+  // This code runs inside the Harness host process: an uncaught error here can
+  // take Harness down. Every event listener and timer goes through guard().
+  const guard = (label, fn) => (...args) => {
+    try {
+      const result = fn(...args)
+      if (result && typeof result.catch === 'function') result.catch((error) => logError(label, error))
+    } catch (error) {
+      logError(label, error)
+    }
+  }
+  const logError = (label, error) => {
+    try { ctx.logger?.error?.(`dsh-baton-host ${label}: ${error?.stack ?? error}`) } catch { /* logging must never throw */ }
+  }
+
+  const controller = ctx.sessionController
+  const registry = ctx.workspaceRegistry
+  const runs = new Map() // runId -> run
+  const waiters = new Map() // runId -> Set<resolve>
+
+  // --- run bookkeeping ------------------------------------------------------
+
+  const publicRun = (run, tail = 20) => ({
+    run_id: run.id, session_id: run.sessionId, state: run.state, started_at: run.startedAt, ended_at: run.endedAt,
+    message_preview: run.preview, final_text: run.finalText, turn_end: run.turnEnd, error: run.error,
+    ...(run.sender ? { sender: run.sender } : {}),
+    ...(run.waitingOn ? { waiting_on: run.waitingOn } : {}),
+    ...(run.supersededBy ? { superseded_by: run.supersededBy } : {}),
+    ...(run.humanInputs?.length ? { human_interjections: run.humanInputs } : {}),
+    ...(tail ? { recent_events: run.events.slice(-tail) } : {}),
+  })
+
+  const ACTIVE = ['queued', 'running', 'waiting']
+  const isActive = (run) => ACTIVE.includes(run.state)
+
+  function settle(run, state, extra = {}) {
+    if (!isActive(run)) return
+    Object.assign(run, extra, { state, endedAt: new Date().toISOString() })
+    for (const resolve of waiters.get(run.id) ?? []) resolve()
+    waiters.delete(run.id)
+    persist(run)
+    if (!activeRunsFor(run.sessionId).length) forgetSession(run.sessionId)
+  }
+
+  // Per-session bookkeeping only lives while the session has active runs, so a
+  // host that stays up for days does not accumulate state for idle sessions.
+  function forgetSession(sessionId) {
+    clearTimeout(quietTimers.get(sessionId))
+    quietTimers.delete(sessionId)
+    quietSinceBySession.delete(sessionId)
+    lastRunningAt.delete(sessionId)
+    activityErrors.delete(sessionId)
+  }
+
+  // Active relayed runs of one session, oldest first. Several can be active at
+  // once: a followup waits in Harness's queue behind the current turn, and a
+  // steer joins the turn that is already running.
+  const activeRunsFor = (sessionId) => [...runs.values()].filter((r) => r.sessionId === sessionId && isActive(r))
+  // Runs whose prompt has entered the conversation and that are not finished yet.
+  const receiversFor = (sessionId) => activeRunsFor(sessionId).filter((r) => r.sawPrompt)
+  // Of those, the runs the current turn's output belongs to. A run is closed for
+  // output once a newer user-started turn begins; it may still wait for its
+  // sub-agents or jobs before it completes.
+  const outputReceiversFor = (sessionId) => receiversFor(sessionId).filter((r) => !r.outputClosed)
+
+  function pushEvent(run, e) {
+    run.events.push(e)
+    if (run.events.length > MAX_EVENTS) run.events.splice(0, run.events.length - MAX_EVENTS)
+    persist(run)
+  }
+
+  // --- persistence: run records survive a Harness restart -----------------------
+  // One JSON file per run under <baton home>/host-runs, written at most once a
+  // second per change burst. Enabled only once this host owns the socket, so a
+  // second host never overwrites the first one's records.
+
+  const store = { dir: path.join(batonHome(), 'host-runs'), enabled: false, dirty: new Set(), timer: null }
+  const RUN_FILE = /^(hrun-[\w-]+)\.json$/
+
+  function persist(run) {
+    if (!store.enabled) return
+    store.dirty.add(run.id)
+    if (!store.timer) store.timer = setTimeout(guard('persist runs', flushRuns), PERSIST_DELAY_MS)
+  }
+
+  function writeRunFile(run) {
+    const file = path.join(store.dir, `${run.id}.json`)
+    const tmp = `${file}.tmp`
+    fs.writeFileSync(tmp, JSON.stringify(run), { mode: 0o600 })
+    fs.renameSync(tmp, file)
+  }
+
+  function flushRuns() {
+    clearTimeout(store.timer)
+    store.timer = null
+    for (const id of store.dirty) {
+      const run = runs.get(id)
+      try {
+        if (run) writeRunFile(run)
+        else fs.rmSync(path.join(store.dir, `${id}.json`), { force: true })
+      } catch (error) { logError('persist run', error) }
+    }
+    store.dirty.clear()
+  }
+
+  // Load earlier records. A run that was active when Harness went away cannot
+  // finish any more (Harness ends the turn on restart), so it is marked interrupted.
+  function enableStore() {
+    fs.mkdirSync(store.dir, { recursive: true, mode: 0o700 })
+    if (!IS_WIN) fs.chmodSync(store.dir, 0o700)
+    const loaded = []
+    for (const name of fs.readdirSync(store.dir)) {
+      const m = RUN_FILE.exec(name)
+      if (!m) { if (name.endsWith('.tmp')) fs.rmSync(path.join(store.dir, name), { force: true }); continue }
+      try {
+        const run = JSON.parse(fs.readFileSync(path.join(store.dir, name), 'utf8'))
+        if (run?.id === m[1]) loaded.push(run)
+      } catch { fs.rmSync(path.join(store.dir, name), { force: true }) }
+    }
+    loaded.sort((a, b) => String(a.startedAt).localeCompare(String(b.startedAt)))
+    for (const old of loaded.splice(0, Math.max(0, loaded.length - MAX_RUNS))) fs.rmSync(path.join(store.dir, `${old.id}.json`), { force: true })
+    store.enabled = true
+    for (const run of loaded) {
+      if (runs.has(run.id)) continue
+      run.events ??= []
+      runs.set(run.id, run)
+      if (isActive(run)) {
+        Object.assign(run, { state: 'interrupted', endedAt: new Date().toISOString(), error: 'Harness restarted while this run was active; its turn was stopped.' })
+        persist(run)
+      }
+    }
+  }
+
+  // Per-session turn state: whether the current turn has produced assistant
+  // output yet. A user message before any output opens the turn (a queued
+  // followup, or someone typing in the Harness UI); one after it is a steer.
+  const turns = new Map() // sessionId -> { hasOutput }
+
+  ctx.on('session/event', guard('session/event', (session, event) => {
+    const data = event.data ?? {}
+    // Turn state is kept only for a turn in progress and dropped at its end.
+    if (event.type === 'turn/start') turns.set(session.id, { hasOutput: false })
+    else if (event.type === 'assistant/message' && turns.has(session.id)) turns.get(session.id).hasOutput = true
+    const active = activeRunsFor(session.id)
+    if (event.type === 'turn/end' && !active.some((r) => r.sawPrompt)) turns.delete(session.id)
+    if (!active.length) return
+    if (event.type === 'user/message') {
+      const run = active.find((r) => r.requestId === data.source?.rpcId)
+      const opensTurn = !turns.get(session.id)?.hasOutput
+      // A user message no relayed run sent: someone typing in the Harness UI (or
+      // another client). Mid-turn it joins the work of the runs in progress, so
+      // they record it: their result then reflects that input too.
+      const fromBridge = run || [...runs.values()].some((r) => r.requestId === data.source?.rpcId)
+      if (data.source?.kind === 'user' && !fromBridge && !opensTurn) {
+        const text = textOf(data.content).slice(0, 500)
+        for (const r of outputReceiversFor(session.id)) {
+          r.humanInputs = [...(r.humanInputs ?? []), { time: iso(event.time) ?? new Date().toISOString(), text }].slice(-MAX_HUMAN_INPUTS)
+          pushEvent(r, { type: 'human_input', text })
+        }
+      }
+      if (data.source?.kind === 'user' && opensTurn && run?.mode !== 'steer') {
+        // A new user-started turn: runs whose own turn already ended keep their
+        // result instead of absorbing this turn's output, but still wait for any
+        // sub-agents or jobs they started. Turns woken by sub-agent results carry
+        // no user message, and a relayed steer joins the current work, so neither
+        // closes earlier runs.
+        let closed = false
+        for (const prev of active) {
+          if (prev !== run && prev.sawPrompt && prev.turnEnd && !prev.outputClosed) {
+            Object.assign(prev, { outputClosed: true, supersededBy: run?.id ?? 'user' })
+            closed = true
+          }
+        }
+        if (closed) scheduleQuietCheck(session.id, 0)
+      }
+      if (run) { Object.assign(run, { sawPrompt: true, state: 'running' }); persist(run) }
+      return
+    }
+    const receivers = outputReceiversFor(session.id)
+    if (!receivers.length) return
+    if (event.type === 'assistant/message') {
+      const content = data.message?.content
+      const text = textOf(content)
+      for (const run of receivers) {
+        for (const call of toolCallsOf(content)) pushEvent(run, { type: 'tool_call', ...call })
+        if (text) {
+          pushEvent(run, { type: 'text', text })
+          run.finalText = text
+        }
+      }
+    } else if (event.type === 'tool/result') {
+      for (const run of receivers) pushEvent(run, { type: 'tool_result', status: data.status ?? (data.error ? 'error' : 'completed') })
+    } else if (event.type === 'turn/end') {
+      // The turn that carried these prompts is over. A failed turn ends the run; a
+      // completed one ends it only once the session is quiet (no sub-agents or jobs
+      // left), because Harness wakes the agent again when those report back.
+      const reason = data.reason ?? null
+      for (const run of receivers) { run.turnEnd = reason; persist(run) }
+      if (reason?.kind && reason.kind !== 'completed') for (const run of receivers) settle(run, 'failed')
+      else scheduleQuietCheck(session.id, 1000)
+      turns.delete(session.id)
+    }
+  }))
+
+  // --- completion: wait until the session has no running turn, sub-agents or jobs
+
+  const quietTimers = new Map() // sessionId -> timeout
+  const quietSinceBySession = new Map() // sessionId -> ms when activity was first seen empty
+  const lastRunningAt = new Map() // sessionId -> ms of the last running status
+  const activityErrors = new Map() // sessionId -> consecutive activity read failures
+
+  function scheduleQuietCheck(sessionId, delayMs) {
+    clearTimeout(quietTimers.get(sessionId))
+    quietTimers.set(sessionId, setTimeout(guard('quiet check', () => checkQuiet(sessionId)), delayMs))
+  }
+
+  async function sessionActivity(sessionId) {
+    return ctx.waterfall('workspace/session-activity', { sessionId }, () => Promise.resolve([]))
+  }
+
+  async function checkQuiet(sessionId) {
+    quietTimers.delete(sessionId)
+    const receivers = receiversFor(sessionId)
+    if (!receivers.length) return
+    let items
+    try {
+      items = await sessionActivity(sessionId)
+      if (!Array.isArray(items)) throw new Error('session activity is not a list')
+      activityErrors.delete(sessionId)
+    } catch (error) {
+      // Unknown is not idle: keep waiting and retry; give up only after repeated failures.
+      const count = (activityErrors.get(sessionId) ?? 0) + 1
+      activityErrors.set(sessionId, count)
+      const message = `could not read session activity: ${error?.message ?? error}`
+      if (count >= ACTIVITY_MAX_ERRORS) {
+        activityErrors.delete(sessionId)
+        for (const run of receivers) settle(run, 'completed', { error: `${message} (gave up after ${count} tries; sub-agents may still be running)` })
+      } else {
+        for (const run of receivers) run.error = message
+        scheduleQuietCheck(sessionId, 3000)
+      }
+      return
+    }
+    const summary = (list) => list.map((g) => ({ kind: g.kind, count: g.items?.length ?? 0, labels: (g.items ?? []).map((i) => i.label ?? i.id) }))
+    // Closed runs: the running turn belongs to a newer run, so only their
+    // background work (sub-agents, jobs, reminders) keeps them open.
+    const background = items.filter((g) => g.kind !== 'turn')
+    for (const run of receivers.filter((r) => r.outputClosed)) {
+      if (background.length === 0) settle(run, 'completed', { waitingOn: null, error: null })
+      else { run.waitingOn = summary(background); persist(run) }
+    }
+    // A run whose own turn has not ended (and that has not seen the agent idle) is not done yet.
+    const open = receivers.filter((r) => !r.outputClosed && (r.turnEnd || r.idleSeen))
+    if (items.length === 0 && open.length) {
+      // After waiting on sub-agents or jobs, Harness wakes the agent for a final
+      // turn shortly after they finish. Confirm the quiet holds for a moment (no
+      // new running status) so that last turn is not missed.
+      const waited = open.some((r) => r.waitingOn)
+      const quietSince = quietSinceBySession.get(sessionId)
+      if (waited && (quietSince === undefined || (lastRunningAt.get(sessionId) ?? 0) > quietSince)) {
+        quietSinceBySession.set(sessionId, Date.now())
+        scheduleQuietCheck(sessionId, QUIET_CONFIRM_MS)
+        return
+      }
+      quietSinceBySession.delete(sessionId)
+      for (const run of open) settle(run, 'completed', { waitingOn: null, error: null })
+      return
+    }
+    quietSinceBySession.delete(sessionId)
+    for (const run of open) run.waitingOn = items.length ? summary(items) : run.waitingOn
+    if (receiversFor(sessionId).length) scheduleQuietCheck(sessionId, 3000)
+  }
+
+  ctx.effect(() => () => { for (const t of quietTimers.values()) clearTimeout(t) }, 'dsh-baton-host quiet timers')
+
+  ctx.on('agent/status', guard('agent/status', ({ agent, status }) => {
+    if (!agent) return
+    const receivers = receiversFor(agent.id)
+    if (status === 'running' && receivers.length) lastRunningAt.set(agent.id, Date.now())
+    for (const run of outputReceiversFor(agent.id)) {
+      if (status === 'running') run.state = 'running'
+      else if (status === 'waiting') run.state = 'waiting' // needs a person in the Harness UI (approval / question)
+      else if (status === 'error') settle(run, 'failed')
+      else if (status === 'idle') run.idleSeen = true
+    }
+    if (status === 'idle' && receivers.length) scheduleQuietCheck(agent.id, 0)
+  }))
+
+  ctx.on('agent/error', guard('agent/error', ({ agent, error }) => {
+    for (const run of agent ? outputReceiversFor(agent.id) : []) run.error = String(error?.message ?? error)
+  }))
+
+  // --- operations -----------------------------------------------------------
+
+  const signal = () => new AbortController().signal
+
+  function workspaces() {
+    return registry.list().map((w) => ({ id: w.id, path: w.path, title: w.title, session_count: w.sessionIds.length }))
+  }
+
+  // Register a folder as a sidebar workspace (idempotent: an already registered
+  // path returns its existing workspace). Creates the folder when asked.
+  async function createWorkspace({ path: dir, title, create_dir = true }) {
+    if (!dir) throw new Error('path is required')
+    if (create_dir) fs.mkdirSync(normalizePath(dir), { recursive: true })
+    const abs = normalizePath(dir)
+    const existed = await registry.resolveByPath(abs).catch(() => undefined)
+    const ws = existed ?? (await registry.create(abs, title))
+    return { id: ws.id, path: ws.path, title: ws.title, created: !existed }
+  }
+
+  // archivedSessionIds may be any iterable, so read it through a Set.
+  const isArchived = (sessionId) => new Set(registry.archivedSessionIds ?? []).has(sessionId)
+
+  async function listSessions({ cwd, query, limit = 20, include_subagents = false } = {}) {
+    const { items } = await controller.list({}, signal())
+    const want = cwd ? normalizePath(cwd) : null
+    const q = query?.toLowerCase()
+    const archived = new Set(registry.archivedSessionIds)
+    const out = []
+    for (const item of items) {
+      if (archived.has(item.sessionId)) continue
+      if (item.parentSessionId && !include_subagents) continue
+      const row = {
+        session_id: item.sessionId, cwd: item.cwd ?? null, title: item.title ?? item.projections?.values?.title ?? null,
+        updated_at: iso(item.updatedAt), running: !!item.running, blank: !!item.blank,
+        bridge_runs: activeRunsFor(item.sessionId).map((r) => r.id),
+      }
+      if (want && (!row.cwd || normalizePath(row.cwd) !== want)) continue
+      if (q && !`${row.title ?? ''} ${row.cwd ?? ''} ${row.session_id}`.toLowerCase().includes(q)) continue
+      out.push(row)
+      if (out.length >= limit) break
+    }
+    return out
+  }
+
+  async function readSession({ session_id, last = 10 }) {
+    const { meta, events } = await controller.inspect(session_id, signal())
+    const messages = []
+    let title = null
+    for (const e of events) {
+      if (e.type === 'session/title') title = e.data?.title ?? title
+      else if (e.type === 'user/message' && e.data?.source?.kind === 'user') {
+        messages.push({ role: 'user', time: iso(e.time), text: textOf(e.data.content) })
+      } else if (e.type === 'assistant/message') {
+        const content = e.data?.message?.content
+        const tools = toolCallsOf(content).map((t) => t.name ?? t.kind)
+        const text = textOf(content)
+        if (text || tools.length) messages.push({ role: 'assistant', time: iso(e.time), text, ...(tools.length ? { tools } : {}) })
+      }
+    }
+    return { session_id, ...(isArchived(session_id) ? { archived: true } : {}), cwd: meta?.cwd ?? null, title, total_messages: messages.length, messages: messages.slice(-last) }
+  }
+
+  async function send({ message, session_id, cwd, workspace_id, mode = 'followup', sender }) {
+    if (!message || !message.trim()) throw new Error('message is required')
+    if (sender != null && !SENDER_RE.test(sender)) throw new Error('sender must be 1-32 characters of a-z, 0-9 or -')
+    let sessionId = session_id
+    let workspace = null
+    // Harness never runs a prompt sent to an archived session: the run would stay queued forever.
+    if (sessionId && isArchived(sessionId)) {
+      throw new Error(`Session ${sessionId} is archived. Unarchive it in Harness, or start a new session with cwd or workspace_id.`)
+    }
+    if (!sessionId) {
+      if (!cwd && !workspace_id) throw new Error('A new session needs cwd or workspace_id. Pass session_id to continue an existing one.')
+      // A folder that is not a workspace yet is registered first, so the new session shows in the sidebar.
+      workspace = workspace_id ? { id: workspace_id } : await createWorkspace({ path: cwd, create_dir: false })
+      sessionId = (await controller.create({ workspaceId: workspace.id })).sessionId
+    }
+    const ahead = activeRunsFor(sessionId).map((r) => r.id)
+    const run = {
+      id: `hrun-${Date.now().toString(36)}-${crypto.randomBytes(3).toString('hex')}`,
+      sessionId, requestId: requestIdFor(sender), ...(sender ? { sender } : {}), mode, state: 'queued', sawPrompt: false,
+      startedAt: new Date().toISOString(), endedAt: null, preview: message.slice(0, 200),
+      events: [], finalText: null, turnEnd: null, error: null,
+    }
+    remember(run)
+    try {
+      await controller.prompt({ sessionId, requestId: run.requestId, content: [{ type: 'text', text: message }], mode }, signal())
+    } catch (error) {
+      settle(run, 'failed', { error: String(error?.message ?? error) })
+    }
+    return {
+      ...publicRun(run),
+      mode,
+      ...(ahead.length ? { other_active_runs: ahead } : {}),
+      ...(workspace ? { workspace } : {}),
+    }
+  }
+
+  // Keep at most MAX_RUNS records, dropping the oldest finished one; active runs are never evicted.
+  function remember(run) {
+    runs.set(run.id, run)
+    persist(run)
+    if (runs.size <= MAX_RUNS) return
+    for (const [id, r] of runs) {
+      if (!isActive(r)) { runs.delete(id); persist({ id }); return }
+    }
+  }
+
+  function getRun(runId) {
+    const run = runs.get(runId)
+    if (!run) throw new Error(`Unknown run: ${runId} (only the latest 100 runs are kept)`)
+    return run
+  }
+
+  async function wait({ run_id, timeout_s = 300 }) {
+    const run = getRun(run_id)
+    const seconds = Number.isFinite(Number(timeout_s)) ? Math.min(Math.max(Number(timeout_s), 0), MAX_WAIT_S) : 300
+    if (isActive(run)) {
+      await new Promise((resolve) => {
+        const set = waiters.get(run.id) ?? new Set()
+        waiters.set(run.id, set)
+        const done = () => {
+          clearTimeout(timer)
+          set.delete(done)
+          resolve()
+        }
+        const timer = setTimeout(done, seconds * 1000)
+        set.add(done)
+      })
+    }
+    const done = !isActive(run)
+    return { ...publicRun(run), ...(done ? {} : { timed_out: true }) }
+  }
+
+  // What a session is doing right now, as Harness reports it for archiving:
+  // its running turn, sub-agents (any depth), background jobs and reminders.
+  async function activity({ session_id }) {
+    if (!session_id) throw new Error('session_id is required')
+    const items = await sessionActivity(session_id)
+    return {
+      session_id,
+      ...(isArchived(session_id) ? { archived: true } : {}),
+      busy: items.length > 0,
+      activity: items,
+      bridge_runs: activeRunsFor(session_id).map((r) => ({ run_id: r.id, state: r.state, in_conversation: r.sawPrompt })),
+    }
+  }
+
+  // Stop everything a session is doing (its turn, sub-agents, jobs, reminders)
+  // through the same providers Harness uses when archiving, without archiving it.
+  async function cancel({ run_id, session_id }) {
+    const run = run_id ? getRun(run_id) : null
+    const sessionId = run?.sessionId ?? session_id
+    if (!sessionId) throw new Error('run_id or session_id is required')
+    // A stop that arrives while sub-agents are still starting can be lost: the turn
+    // carries on and starts them again. Re-issue it until the session is quiet.
+    let attempts = 0
+    let still
+    while (attempts < CANCEL_ATTEMPTS) {
+      attempts++
+      await registry.stopSessionActivity(sessionId)
+      for (const r of receiversFor(sessionId)) settle(r, 'cancelled')
+      const deadline = Date.now() + CANCEL_SETTLE_MS
+      do {
+        await new Promise((r) => setTimeout(r, 1000))
+        still = await activity({ session_id: sessionId })
+      } while (still.busy && Date.now() < deadline)
+      if (!still.busy) break
+    }
+    // The named run never reached the conversation (still queued, or sent to a session
+    // that will not run it): settle it too, so nothing waits on it forever.
+    if (run && isActive(run) && !run.sawPrompt) settle(run, 'cancelled')
+    return {
+      session_id: sessionId,
+      ...(run ? { run: publicRun(run, 0) } : {}),
+      attempts,
+      still_busy: still.busy,
+      activity: still.activity,
+      queued_runs: activeRunsFor(sessionId).filter((r) => !r.sawPrompt).map((r) => r.id),
+    }
+  }
+
+  async function renameSession({ session_id, title }) {
+    if (!session_id || !title?.trim()) throw new Error('session_id and title are required')
+    const result = await controller.rename({ sessionId: session_id, title: title.trim() })
+    return { session_id, title: result?.title ?? title.trim() }
+  }
+
+  async function renameWorkspace({ workspace_id, path: dir, title }) {
+    if (!title?.trim()) throw new Error('title is required')
+    const ws = workspace_id ? registry.get(workspace_id) : dir ? await registry.resolveByPath(normalizePath(dir)).catch(() => undefined) : undefined
+    if (!ws) throw new Error(`Workspace not found: ${workspace_id ?? dir}`)
+    await ws.setTitle(title.trim())
+    return { id: ws.id, path: ws.path, title: ws.title }
+  }
+
+  const methods = {
+    ping: () => ({ name, version: VERSION, pid: process.pid }),
+    workspaces,
+    create_workspace: createWorkspace,
+    list_sessions: listSessions,
+    read_session: readSession,
+    send,
+    status: ({ run_id, tail }) => publicRun(getRun(run_id), tail ?? 20),
+    wait,
+    cancel,
+    activity,
+    rename_session: renameSession,
+    rename_workspace: renameWorkspace,
+    list_runs: ({ limit = 10 } = {}) => [...runs.values()].reverse().slice(0, limit).map((r) => publicRun(r, 0)),
+  }
+
+  // --- local socket (owner-only) ---------------------------------------------
+
+  const connections = new Set()
+
+  function serve(conn) {
+    let buf = ''
+    connections.add(conn)
+    conn.on('close', () => connections.delete(conn))
+    conn.setEncoding('utf8')
+    conn.on('error', () => {})
+    conn.on('data', (chunk) => {
+      buf += chunk
+      if (buf.length > MAX_REQUEST_BYTES) {
+        conn.destroy()
+        return
+      }
+      let nl
+      while ((nl = buf.indexOf('\n')) !== -1) {
+        const line = buf.slice(0, nl)
+        buf = buf.slice(nl + 1)
+        if (line.trim()) handle(line)
+      }
+    })
+    async function handle(line) {
+      try { await answer(line) } catch (error) { logError('socket request', error) }
+    }
+    async function answer(line) {
+      let req
+      try { req = JSON.parse(line) } catch { return conn.write(JSON.stringify({ id: null, error: 'parse error' }) + '\n') }
+      try {
+        const fn = typeof req.method === 'string' && Object.hasOwn(methods, req.method) ? methods[req.method] : undefined
+        if (!fn) throw new Error(`Unknown method: ${req.method}`)
+        const result = await fn(req.params ?? {})
+        if (!conn.destroyed) conn.write(JSON.stringify({ id: req.id, result }) + '\n')
+      } catch (error) {
+        if (!conn.destroyed) conn.write(JSON.stringify({ id: req?.id ?? null, error: String(error?.message ?? error) }) + '\n')
+      }
+    }
+  }
+
+
+  ctx.effect(() => {
+    const sock = socketPath()
+    let server = null
+    let disposed = false
+    claimSocket(sock).then(() => {
+      if (disposed) return
+      try { enableStore() } catch (error) { logError('run store', error) }
+      server = net.createServer(serve)
+      server.on('error', (error) => ctx.logger?.error?.(`dsh-baton-host socket error: ${error.message}`))
+      server.listen(sock, () => {
+        if (!IS_WIN) try { fs.chmodSync(sock, 0o600) } catch { /* best effort */ }
+        ctx.logger?.info?.(`dsh-baton-host listening on ${sock}`)
+      })
+    }).catch((error) => ctx.logger?.error?.(`dsh-baton-host not started: ${error.message}`))
+    return () => {
+      disposed = true
+      if (store.enabled) { try { flushRuns() } catch (error) { logError('persist runs', error) } }
+      store.enabled = false
+      // Release callers blocked in wait() and close open connections, so an
+      // unloaded or reloaded plugin leaves no timers or sockets behind.
+      for (const set of waiters.values()) for (const done of [...set]) done()
+      waiters.clear()
+      for (const conn of connections) conn.destroy()
+      if (!server) return
+      server.close()
+      if (!IS_WIN) try { if (fs.lstatSync(sock).isSocket()) fs.unlinkSync(sock) } catch { /* gone */ }
+    }
+  }, 'dsh-baton-host socket')
+}

package/lib/socket.js

@@ -0,0 +1,55 @@
+// Shared by the host plugin and the MCP server / CLI (src/core.mjs imports it):
+// settings, the home folder, and where the control socket lives.
+//
+// The project was called dsh-bridge before it became dsh-baton. For one version the
+// old names keep working: DSH_BRIDGE_* settings (with a warning), an existing
+// ~/.dsh-bridge home, and the old pipe name on Windows, so an MCP server that is
+// already updated still reaches a host plugin that is not restarted yet.
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import crypto from 'node:crypto'
+
+const warned = new Set()
+
+// DSH_BATON_<name>, else the old DSH_BRIDGE_<name>.
+export function setting(name, env = process.env) {
+  if (env[`DSH_BATON_${name}`] !== undefined) return env[`DSH_BATON_${name}`]
+  const old = env[`DSH_BRIDGE_${name}`]
+  if (old !== undefined && env === process.env && !warned.has(name)) {
+    warned.add(name)
+    process.emitWarning(`DSH_BRIDGE_${name} is deprecated; rename it to DSH_BATON_${name}`)
+  }
+  return old
+}
+
+// ~/.dsh-baton, unless only an earlier ~/.dsh-bridge exists: then keep using that, so
+// run records and the socket stay where an installed host plugin expects them.
+export function batonHome(env = process.env, home = os.homedir()) {
+  const set = setting('HOME', env)
+  if (set) return set
+  const fresh = path.join(home, '.dsh-baton')
+  const old = path.join(home, '.dsh-bridge')
+  return !fs.existsSync(fresh) && fs.existsSync(old) ? old : fresh
+}
+
+const PIPE_PREFIX = /^\\\\[.?]\\pipe\\/i
+
+// A Unix socket file on macOS and Linux. Node cannot listen on a socket file on
+// Windows, so there the same path maps to a named pipe: \\.\pipe\dsh-baton-<hash of
+// the path>. The default path sits in the user's own home folder, so the pipe name is
+// per user. DSH_BATON_SOCKET may be either a path (mapped the same way) or a pipe name.
+export function socketEndpoint(p, platform = process.platform, prefix = 'dsh-baton') {
+  if (platform !== 'win32' || PIPE_PREFIX.test(p)) return p
+  const key = path.win32.resolve(p).toLowerCase()
+  return `\\\\.\\pipe\\${prefix}-${crypto.createHash('sha256').update(key).digest('hex').slice(0, 16)}`
+}
+
+export const socketPath = (env = process.env) => setting('SOCKET', env) || path.join(batonHome(env), 'host.sock')
+
+// Where a client looks for the host: the current endpoint, then the one a host
+// plugin from before the rename listens on (differs only on Windows).
+export function hostEndpoints(env = process.env, platform = process.platform) {
+  const p = socketPath(env)
+  return [...new Set([socketEndpoint(p, platform), socketEndpoint(p, platform, 'dsh-bridge')])]
+}

package/package.json

@@ -1,8 +1,60 @@
 {
   "name": "dsh-baton-host",
-  "version": "0.0.1",
-  "description": "Name reserved for dsh-baton: hand Claude Code and Codex work off to DeepSeek Harness. Real release coming soon.",
-  "repository": { "type": "git", "url": "git+https://github.com/JialaoLiu/dsh-baton.git" },
-  "homepage": "https://github.com/JialaoLiu/dsh-baton",
-  "license": "MIT"
+  "version": "0.4.0",
+  "description": "DeepSeek Harness plugin for dsh-baton: takes the baton from Claude Code or Codex 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",
+  "exports": {
+    ".": {
+      "default": "./lib/index.js"
+    },
+    "./client": {
+      "default": "./lib/client.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "lib",
+    "cordis.patch.yml",
+    "README.md",
+    "LICENSE"
+  ],
+  "license": "MIT",
+  "dsh": {
+    "manifestVersion": 1,
+    "engines": {
+      "dsh": ">=0.2.1-rc.2"
+    },
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    },
+    "client": {
+      "platform": "web",
+      "inject": [
+        "@deepseek-ai/dsh-client-locale",
+        "@deepseek-ai/dsh-client-ui-renderer",
+        "@deepseek-ai/dsh-client-ui-chat"
+      ]
+    }
+  },
+  "keywords": [
+    "deepseek-harness",
+    "dsh",
+    "dsh-plugin",
+    "mcp",
+    "relay",
+    "baton"
+  ],
+  "engines": {
+    "node": ">=22.15"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/JialaoLiu/dsh-baton.git",
+    "directory": "host"
+  },
+  "homepage": "https://github.com/JialaoLiu/dsh-baton#readme",
+  "scripts": {
+    "prepublishOnly": "node ../scripts/version.mjs"
+  }
 }