dsh-baton-host 0.5.7 → 0.5.8

package/README.md

@@ -1,11 +1,31 @@
+<p align="center">
+  <img src="https://raw.githubusercontent.com/JialaoLiu/dsh-baton/main/assets/readme/hero.gif" width="100%" alt="dsh-baton: pass the baton from Claude Code or Codex to DeepSeek Harness, watch it run live, and get it handed back when it's done">
+</p>
+
+<p align="center">
+  <a href="https://github.com/JialaoLiu/dsh-baton#readme">dsh-baton</a> · <a href="https://github.com/JialaoLiu/dsh-baton/blob/main/README.zh-CN.md">中文说明</a>
+</p>
+
+<p align="center">
+  macOS · Windows (<a href="https://github.com/JialaoLiu/dsh-baton/blob/main/WINDOWS.md">guide</a>) · no Node.js needed · zero dependencies · MIT
+</p>
+
 # dsh-baton-host
 
-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.
+The 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). 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 官方会话服务，界面实时可见。
 
+<p align="center">
+  <img src="https://raw.githubusercontent.com/JialaoLiu/dsh-baton/main/assets/readme/features.svg" width="100%" alt="Create workspaces and sessions, continue a session, run live in the Harness UI labelled with the sender, get woken when it is done, no extra API key, macOS and Windows with zero dependencies">
+</p>
+
 ## Install / 安装
 
+<p align="center">
+  <img src="https://raw.githubusercontent.com/JialaoLiu/dsh-baton/main/assets/readme/install.svg" width="100%" alt="Step 1: in Harness open Plugins, Add plugin, enter dsh-baton-host, Install, Enable now; it registers dsh-baton for Claude Code and Codex. Step 2: in a new chat, ask for dsh_list_workspaces">
+</p>
+
 Harness → Plugins / 插件 → Add plugin / 添加插件 → `dsh-baton-host` → Install / 安装 → Enable now / 立即启用
 
 That is the whole install: switched on, the plugin registers the dsh-baton MCP server (the `dsh-baton-mcp` package, installed with it) for Claude Code and Codex, user-wide, and Harness says so. New conversations then have the `dsh_*` tools. If it could not register, run `npx -y dsh-baton-mcp setup`. Details: [dsh-baton](https://github.com/JialaoLiu/dsh-baton#install-details).
@@ -16,6 +36,12 @@ Update / 更新: uninstall, then add it again; the MCP server is updated with it
 
 Remove / 卸载: uninstall, then `npx -y dsh-baton-mcp setup --remove` / 卸载插件后运行 `npx -y dsh-baton-mcp setup --remove`.
 
+## How it works / 工作原理
+
+<p align="center">
+  <img src="https://raw.githubusercontent.com/JialaoLiu/dsh-baton/main/assets/readme/architecture.svg" width="100%" alt="MCP clients call dsh-baton-mcp over stdio; it reaches the dsh-baton-host plugin inside Harness through an owner-only local socket; the plugin drives Harness sessions live, with dsh headless as fallback">
+</p>
+
 ## Socket protocol / 套接字协议
 
 Newline-delimited JSON: request `{"id", "method", "params"}`, reply `{"id", "result"}` or `{"id", "error"}`.
@@ -27,14 +53,16 @@ Newline-delimited JSON: request `{"id", "method", "params"}`, reply `{"id", "res
 | `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`) |
+| `send` | `message`, and `session_id` or `cwd` or `workspace_id`; `mode?` (`followup` \| `steer`; left out, Harness's busy-send setting, else `followup`) |
 | `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?` |
+| `list_runs` | `session_id?`, `limit?` |
+| `answer` | `run_id`, `answers` (`[{ id?, choose?, text?, skip? }]`) |
+| `update_queued` | `run_id`, `action` (`edit` \| `remove` \| `steer`), `message?` (for `edit`) |
 
 `DSH_BATON_SOCKET` / `DSH_BATON_HOME` in the Harness process environment move the socket. `DSH_BATON_AUTO_REGISTER=0` turns off the MCP registration.
 

package/lib/index.js

@@ -122,9 +122,18 @@ export function apply(ctx) {
     try { ctx.logger?.error?.(`dsh-baton-host ${label}: ${error?.stack ?? error}`) } catch { /* logging must never throw */ }
   }
 
+  // A waterfall listener must never break Harness's chain: on any error of its own it
+  // hands the request on untouched.
+  const guardWaterfall = (fn) => function (request, next) {
+    try { return fn(request, next) } catch (error) { logError('waterfall', error); return next() }
+  }
+
   const controller = ctx.sessionController
   const registry = ctx.workspaceRegistry
+  // Harness's settings service, when this Harness has one: read for its busy-send setting.
+  let settings = null
   const runs = new Map() // runId -> run
+  let stopping = false // set when the plugin unloads: release every wait()
   const waiters = new Map() // runId -> Set<resolve>
 
   // --- run bookkeeping ------------------------------------------------------
@@ -136,12 +145,27 @@ export function apply(ctx) {
     ...(run.waitingOn ? { waiting_on: run.waitingOn } : {}),
     ...(run.supersededBy ? { superseded_by: run.supersededBy } : {}),
     ...(run.humanInputs?.length ? { human_interjections: run.humanInputs } : {}),
+    ...(run.question ? { question: run.question } : {}),
     ...(tail ? { recent_events: run.events.slice(-tail) } : {}),
   })
 
   const ACTIVE = ['queued', 'running', 'waiting']
   const isActive = (run) => ACTIVE.includes(run.state)
 
+  // Release callers blocked in wait() without ending the run (it needs a person now).
+  function wake(run) {
+    for (const resolve of [...(waiters.get(run.id) ?? [])]) resolve()
+  }
+
+  // The run now waits for a person. The next wait() returns at once with what is asked
+  // (once per episode: a second wait() blocks again until the run moves on).
+  function needsPerson(run, delayMs = 0) {
+    Object.assign(run, { state: 'waiting', waitNoticed: false })
+    persist(run)
+    if (delayMs) setTimeout(guard('waiting', () => wake(run)), delayMs)
+    else wake(run)
+  }
+
   function settle(run, state, extra = {}) {
     if (!isActive(run)) return
     Object.assign(run, extra, { state, endedAt: new Date().toISOString() })
@@ -250,9 +274,24 @@ export function apply(ctx) {
     // 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
+    // A run settled as removed from the queue whose message reaches the conversation
+    // after all (the removal check guessed wrong) is taken up again.
+    if (event.type === 'user/message') {
+      const lost = [...runs.values()].find((r) => r.removedFromQueue && r.state === 'cancelled' && r.sessionId === session.id && r.requestId === data.source?.rpcId)
+      if (lost) {
+        Object.assign(lost, { state: 'queued', removedFromQueue: false, error: null, endedAt: null })
+        pushEvent(lost, { type: 'queue_delivered' })
+      }
+    }
     const active = activeRunsFor(session.id)
     if (event.type === 'turn/end' && !active.some((r) => r.sawPrompt)) turns.delete(session.id)
     if (!active.length) return
+    // Something left Harness's queue: a queued run may have been removed (session stopped,
+    // or Remove in the Harness UI) rather than started. Checked once the dust settles.
+    if (event.type === 'agent/inbox/spliced' && data.removedCount > 0 && active.some((r) => !r.sawPrompt)) {
+      scheduleQueueCheck(session.id)
+      return
+    }
     if (event.type === 'user/message') {
       const run = active.find((r) => r.requestId === data.source?.rpcId)
       const opensTurn = !turns.get(session.id)?.hasOutput
@@ -388,7 +427,9 @@ export function apply(ctx) {
     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)
+      // Needs a person: a question (see user-questions/request) or an approval in the
+      // Harness UI. Waiters wake a moment later, so a question that comes with it is on the run.
+      else if (status === 'waiting') { if (run.state !== 'waiting') needsPerson(run, 500) }
       else if (status === 'error') settle(run, 'failed')
       else if (status === 'idle') run.idleSeen = true
     }
@@ -399,6 +440,208 @@ export function apply(ctx) {
     for (const run of agent ? outputReceiversFor(agent.id) : []) run.error = String(error?.message ?? error)
   }))
 
+  // --- Harness's queue (inbox) ------------------------------------------------
+  // A followup sent while the session is busy waits in Harness's inbox until the turn
+  // ends. Each pending message carries the request id it was sent with (source.rpcId),
+  // so a run finds its own message there.
+
+  const QUEUE_UNSUPPORTED = 'This DeepSeek Harness version cannot change queued messages: its session controller has no projections/updateQueue.'
+  const queueTimers = new Map() // sessionId -> timeout
+  const QUEUE_RECHECK_MS = Number(process.env.DSH_BATON_QUEUE_RECHECK_MS) || 2000
+
+  // Messages still pending in a session's inbox, or null when this Harness cannot say.
+  async function pendingMessages(sessionId) {
+    if (typeof controller.projections !== 'function') return null
+    const baseline = await controller.projections({ sessionId }, signal())
+    if (baseline === null) return [] // no such session: nothing is pending
+    const inbox = baseline?.values?.inbox
+    if (!inbox) return null
+    return [...(inbox['next-turn'] ?? []), ...(inbox['next-step'] ?? [])]
+  }
+
+  // Settle the runs whose message left the inbox without reaching the conversation:
+  // Harness drops the queue when a session is stopped, and the Harness UI can remove one.
+  // A message taken into the conversation also leaves the inbox, and its user/message
+  // event can trail behind (edited messages, a busy disk), so a run counts as removed
+  // only when it is still missing from both the inbox and the log a moment later.
+  async function reconcileQueue(sessionId) {
+    let gone = await missingFromQueue(sessionId, activeRunsFor(sessionId).filter((r) => r.admitted && !r.sawPrompt))
+    if (!gone.length) return []
+    await new Promise((resolve) => setTimeout(resolve, QUEUE_RECHECK_MS))
+    gone = await missingFromQueue(sessionId, gone.filter((r) => isActive(r) && !r.sawPrompt))
+    for (const run of gone) settle(run, 'cancelled', { error: 'Removed from the Harness queue before it ran.', removedFromQueue: true })
+    return gone.map((r) => r.id)
+  }
+
+  // Of these runs, the ones whose message is neither pending in the inbox nor in the
+  // session log. Nothing is missing when either cannot be read.
+  async function missingFromQueue(sessionId, waiting) {
+    if (!waiting.length) return []
+    const pending = await pendingMessages(sessionId)
+    if (pending === null) return []
+    const ids = new Set(pending.map((m) => m?.source?.rpcId))
+    const gone = waiting.filter((r) => !ids.has(r.requestId))
+    if (!gone.length) return []
+    const log = await controller.inspect(sessionId, signal()).catch(() => null)
+    if (!Array.isArray(log?.events)) return []
+    const delivered = new Set(log.events.filter((e) => e.type === 'user/message').map((e) => e.data?.source?.rpcId))
+    return gone.filter((r) => !delivered.has(r.requestId) && !r.sawPrompt)
+  }
+
+  function scheduleQueueCheck(sessionId) {
+    clearTimeout(queueTimers.get(sessionId))
+    queueTimers.set(sessionId, setTimeout(guard('queue check', () => { queueTimers.delete(sessionId); return reconcileQueue(sessionId) }), 1500))
+  }
+
+  ctx.effect(() => () => { for (const t of queueTimers.values()) clearTimeout(t) }, 'dsh-baton-host queue timers')
+
+  // Change a relayed message that is still waiting in Harness's queue: edit its text,
+  // remove it, or move it into the running turn as a steer.
+  async function updateQueued({ run_id, action, message }) {
+    if (!['edit', 'remove', 'steer'].includes(action)) throw new Error('action must be edit, remove or steer')
+    if (action === 'edit' && !message?.trim()) throw new Error('edit needs a non-empty message')
+    const run = getRun(run_id)
+    if (!isActive(run)) throw new Error(`Run ${run.id} is ${run.state}; only a queued run can be changed.`)
+    if (run.sawPrompt) throw new Error(`Run ${run.id} has already reached the conversation and can no longer be changed. Send a correction with dsh_send mode steer, or stop the session with dsh_cancel.`)
+    if (typeof controller.updateQueue !== 'function') throw new Error(QUEUE_UNSUPPORTED)
+    const pending = await pendingMessages(run.sessionId)
+    if (pending === null) throw new Error(QUEUE_UNSUPPORTED)
+    const item = pending.find((m) => m?.source?.rpcId === run.requestId)
+    const gone = `Run ${run.id} is no longer in the Harness queue: it has just started, or it was removed.`
+    if (!item) throw new Error(gone)
+    const change = action === 'edit' ? { kind: 'edit', content: [{ type: 'text', text: message }] } : { kind: action }
+    try {
+      await controller.updateQueue({ sessionId: run.sessionId, itemId: item.id, action: change })
+    } catch (error) {
+      if (error?.code === 'session/queue-item-not-found') throw new Error(gone)
+      if (error?.code === 'session/steer-unavailable') throw new Error(`The current turn of ${run.sessionId} no longer takes steering; the message stays queued.`)
+      throw error
+    }
+    if (action === 'edit') {
+      run.preview = message.slice(0, 200)
+      pushEvent(run, { type: 'queue_edit', text: message.slice(0, 500) })
+    } else if (action === 'steer') {
+      run.mode = 'steer'
+      pushEvent(run, { type: 'queue_steer' })
+    } else {
+      pushEvent(run, { type: 'queue_remove' })
+      settle(run, 'cancelled', { error: null })
+    }
+    return { ...publicRun(run, 0), action }
+  }
+
+  // --- questions (ask_user_question) ----------------------------------------
+  // Harness asks the user through the user-questions/request waterfall, whose answerer
+  // is the Harness UI. Listening first, the plugin puts the question on the runs of that
+  // turn (so wait() returns with it) and lets either side answer: the Harness UI, or
+  // dsh_answer through answerQuestion(). The first answer wins.
+
+  const questions = new Map() // sessionId -> open question
+  const RECOMMENDED = /\(recommended\)|（推荐）|\(推荐\)|推荐/i
+
+  function publicQuestion(entry) {
+    return {
+      question_id: entry.id,
+      count: entry.items.length,
+      questions: entry.items.map((q) => ({
+        id: q.id,
+        ...(q.header ? { header: q.header } : {}),
+        question: q.question,
+        ...(q.detail ? { detail: q.detail } : {}),
+        multi_select: !!q.multiSelect,
+        options: (q.options ?? []).map((o, i) => ({ number: i + 1, label: o.label, ...(o.description ? { description: o.description } : {}), ...(RECOMMENDED.test(o.label) ? { recommended: true } : {}) })),
+        free_text: true,
+        ...(entry.answers.has(q.id) ? { answered: true } : {}),
+      })),
+    }
+  }
+
+  function onQuestion(request, next) {
+    const sessionId = request?.agent?.id
+    const asked = sessionId && Array.isArray(request.questions) ? outputReceiversFor(sessionId) : []
+    if (!asked.length) return next()
+    const entry = { id: `q-${crypto.randomBytes(4).toString('hex')}`, sessionId, items: request.questions, answers: new Map(), runs: asked }
+    const ours = new Promise((resolve) => { entry.resolve = resolve })
+    questions.set(sessionId, entry)
+    for (const run of asked) {
+      run.question = publicQuestion(entry)
+      pushEvent(run, { type: 'question', question_id: entry.id, count: entry.items.length })
+      needsPerson(run)
+    }
+    // The Harness UI (next) gets its own signal: once dsh_answer wins, aborting it tells
+    // the window to drop its question card, which it otherwise keeps open.
+    const ui = new AbortController()
+    const harnessSignal = request.signal
+    request.signal = harnessSignal ? AbortSignal.any([harnessSignal, ui.signal]) : ui.signal
+    // With no Harness window to answer, only dsh_answer can: that is not a failure here.
+    const theirs = Promise.resolve().then(next).catch((error) => (error?.code === 'NO_PROVIDER' || ui.signal.aborted ? new Promise(() => {}) : Promise.reject(error)))
+    const aborted = new Promise((_, reject) => harnessSignal?.addEventListener('abort', () => reject(harnessSignal.reason), { once: true }))
+    const answered = (by) => (value) => {
+      for (const run of asked) pushEvent(run, { type: 'question_answered', question_id: entry.id, by })
+      return value
+    }
+    const fromBaton = ours.then((value) => { ui.abort(new Error('answered through dsh-baton')); return value })
+    return Promise.race([theirs.then(answered('harness')), fromBaton.then(answered('dsh-baton')), aborted]).finally(() => {
+      if (questions.get(sessionId) === entry) questions.delete(sessionId)
+      for (const run of asked) {
+        if (run.question?.question_id !== entry.id) continue
+        delete run.question
+        if (run.state === 'waiting') run.state = 'running'
+        persist(run)
+      }
+    })
+  }
+
+  // Answer the open question of a run's turn. answers: [{ id?, choose?: [number | label],
+  // text?, skip? }]; questions not answered yet stay open until every one has an answer.
+  function answerQuestion({ run_id, answers }) {
+    const run = getRun(run_id)
+    const entry = questions.get(run.sessionId)
+    if (!isActive(run) || !entry || run.question?.question_id !== entry.id) {
+      if (run.state === 'waiting') throw new Error(`Run ${run.id} is waiting for something in the Harness UI (an approval, for example) that cannot be answered from here; tell the user.`)
+      throw new Error(`Run ${run.id} is ${run.state} and has no open question to answer.`)
+    }
+    if (!Array.isArray(answers) || !answers.length) throw new Error('answers must list at least one answer')
+    const staged = new Map()
+    for (const a of answers) {
+      const q = a?.id != null ? entry.items.find((item) => item.id === a.id) : entry.items.length === 1 ? entry.items[0] : undefined
+      if (!q) throw new Error(a?.id != null ? `No question ${a.id}; the questions are ${entry.items.map((i) => i.id).join(', ')}` : 'id is required when there are several questions')
+      const options = q.options ?? []
+      const chosen = (a.choose ?? []).map((c) => {
+        const byNumber = typeof c === 'number' || /^\d+$/.test(String(c)) ? options[Number(c) - 1] : undefined
+        const option = byNumber ?? options.find((o) => o.label === c) ?? options.find((o) => o.label.toLowerCase().replace(RECOMMENDED, '').trim() === String(c).toLowerCase().replace(RECOMMENDED, '').trim())
+        if (!option) throw new Error(`Question ${q.id} has no option ${JSON.stringify(c)}; options: ${options.map((o, i) => `${i + 1}. ${o.label}`).join('; ')}`)
+        return option.label
+      })
+      const text = typeof a.text === 'string' && a.text.trim() ? a.text : undefined
+      if (a.skip && (chosen.length || text)) throw new Error(`Question ${q.id}: skip cannot come with choose or text`)
+      if (!a.skip && !chosen.length && !text) throw new Error(`Question ${q.id}: give choose, text or skip`)
+      if (!q.multiSelect && chosen.length > 1) throw new Error(`Question ${q.id} takes one option`)
+      // Single choice: typed text replaces the option (Harness's own rule).
+      staged.set(q.id, a.skip ? { id: q.id, selected: [] } : !q.multiSelect && text ? { id: q.id, selected: [], custom: text } : { id: q.id, selected: chosen, ...(text ? { custom: text } : {}) })
+    }
+    for (const [id, item] of staged) entry.answers.set(id, item)
+    const remaining = entry.items.filter((q) => !entry.answers.has(q.id)).map((q) => q.id)
+    if (remaining.length) {
+      for (const r of entry.runs) { if (r.question?.question_id === entry.id) { r.question = publicQuestion(entry); persist(r) } }
+      return { ...publicRun(run, 0), submitted: false, remaining }
+    }
+    entry.resolve({ answers: entry.items.map((q) => entry.answers.get(q.id)) })
+    return { ...publicRun(run, 0), submitted: true, answers: entry.items.map((q) => entry.answers.get(q.id)) }
+  }
+
+  ctx.on('user-questions/request', guardWaterfall(onQuestion), { global: true, prepend: true })
+
+  // Harness's own "busy send" setting (Settings → sending while busy: queue or steer),
+  // as a dsh-baton mode, or null when this Harness has no such setting to read.
+  function harnessBusyMode() {
+    try {
+      const form = settings?.describe?.()?.find?.((d) => d.ns === 'ui-conversation')
+      const value = form?.value?.busyEnter
+      return value === 'steer' ? 'steer' : value === 'queue' ? 'followup' : null
+    } catch { return null }
+  }
+
   // --- operations -----------------------------------------------------------
 
   const signal = () => new AbortController().signal
@@ -461,8 +704,13 @@ export function apply(ctx) {
     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 }) {
+  async function send({ message, session_id, cwd, workspace_id, mode: asked, sender }) {
     if (!message || !message.trim()) throw new Error('message is required')
+    if (asked != null && asked !== 'followup' && asked !== 'steer') throw new Error('mode must be followup or steer')
+    // Without a mode, a message to a busy session does what Harness's own busy-send setting says.
+    const fromHarness = asked == null ? harnessBusyMode() : null
+    const mode = asked ?? fromHarness ?? 'followup'
+    const modeSource = asked != null ? 'explicit' : fromHarness ? 'harness' : 'default'
     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
@@ -486,12 +734,14 @@ export function apply(ctx) {
     remember(run)
     try {
       await controller.prompt({ sessionId, requestId: run.requestId, content: [{ type: 'text', text: message }], mode }, signal())
+      run.admitted = true // in Harness's queue (or conversation) now
     } catch (error) {
       settle(run, 'failed', { error: String(error?.message ?? error) })
     }
     return {
       ...publicRun(run),
       mode,
+      mode_source: modeSource,
       ...(ahead.length ? { other_active_runs: ahead } : {}),
       ...(workspace ? { workspace } : {}),
     }
@@ -516,7 +766,10 @@ export function apply(ctx) {
   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)) {
+    const unseenWait = () => run.state === 'waiting' && !run.waitNoticed
+    const deadline = Date.now() + seconds * 1000
+    // A wake can also come for another reason (the delayed one for a waiting status): wait on.
+    while (isActive(run) && !unseenWait() && !stopping && Date.now() < deadline) {
       await new Promise((resolve) => {
         const set = waiters.get(run.id) ?? new Set()
         waiters.set(run.id, set)
@@ -525,11 +778,15 @@ export function apply(ctx) {
           set.delete(done)
           resolve()
         }
-        const timer = setTimeout(done, seconds * 1000)
+        const timer = setTimeout(done, deadline - Date.now())
         set.add(done)
       })
     }
     const done = !isActive(run)
+    if (!done && unseenWait()) {
+      run.waitNoticed = true
+      return { ...publicRun(run), needs_input: run.question ? 'answer' : 'harness-ui' }
+    }
     return { ...publicRun(run), ...(done ? {} : { timed_out: true }) }
   }
 
@@ -568,6 +825,8 @@ export function apply(ctx) {
       } while (still.busy && Date.now() < deadline)
       if (!still.busy) break
     }
+    // Stopping a session also empties Harness's queue: the runs waiting there are over.
+    const removed = await reconcileQueue(sessionId).catch((error) => { logError('queue check', error); return [] })
     // 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')
@@ -578,6 +837,7 @@ export function apply(ctx) {
       still_busy: still.busy,
       activity: still.activity,
       queued_runs: activeRunsFor(sessionId).filter((r) => !r.sawPrompt).map((r) => r.id),
+      ...(removed.length ? { removed_from_queue: removed } : {}),
     }
   }
 
@@ -608,7 +868,9 @@ export function apply(ctx) {
     activity,
     rename_session: renameSession,
     rename_workspace: renameWorkspace,
-    list_runs: ({ limit = 10 } = {}) => [...runs.values()].reverse().slice(0, limit).map((r) => publicRun(r, 0)),
+    list_runs: ({ limit = 10, session_id } = {}) => [...runs.values()].reverse().filter((r) => !session_id || r.sessionId === session_id).slice(0, limit).map((r) => publicRun(r, 0)),
+    update_queued: updateQueued,
+    answer: answerQuestion,
   }
 
   // --- local socket (owner-only) ---------------------------------------------
@@ -675,6 +937,10 @@ export function apply(ctx) {
     registration = { state: 'off' }
   }
   if (typeof ctx.inject === 'function') {
+    ctx.inject(['settings'], (child) => {
+      settings = child.settings
+      child.effect(() => () => { if (settings === child.settings) settings = null }, 'dsh-baton-host settings')
+    })
     ctx.inject(['webServer'], (web) => {
       web.effect(() => web.webServer.register({
         kind: 'exact',
@@ -706,6 +972,7 @@ export function apply(ctx) {
       disposed = true
       if (store.enabled) { try { flushRuns() } catch (error) { logError('persist runs', error) } }
       store.enabled = false
+      stopping = true
       // 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()

package/package.json

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