dsh-baton-host 0.6.4 → 0.6.5-next.2

package/README.md

@@ -32,14 +32,16 @@ That is the whole install: switched on, the plugin registers the dsh-baton MCP s
 
 装好就完成了：插件启用时会为 Claude Code 和 Codex 注册 dsh-baton MCP 服务器（`dsh-baton-mcp` 包，随插件一起安装），Harness 里会提示。新开的对话就有 `dsh_*` 工具。没能注册的话，运行 `npx -y dsh-baton-mcp setup`。详见 [dsh-baton](https://github.com/JialaoLiu/dsh-baton/blob/main/README.zh-CN.md#安装细节)。
 
-Update / 更新: uninstall, then add it again; the MCP server is updated with it / 先卸载再重新添加，MCP 服务器会一起更新.
+Codex needs nothing extra: from 0.6.4 it waits for a run in one `dsh_wait` call of up to 59 minutes, with no hook to trust. / Codex 不用额外设置：从 0.6.4 起一次 `dsh_wait` 最长等 59 分钟，不需要信任钩子。
+
+Update / 更新: uninstall, then add it again; the MCP server is updated with it. Right after a release, type the exact version, such as `dsh-baton-host@0.6.4`. / 先卸载再重新添加，MCP 服务器会一起更新；刚发版时请输入完整版本号，例如 `dsh-baton-host@0.6.4`。
 
 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/en/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">
+  <img src="https://raw.githubusercontent.com/JialaoLiu/dsh-baton/main/assets/readme/en/architecture.gif" 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 / 套接字协议
@@ -53,6 +55,7 @@ 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?` |
+| `models` | — |
 | `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?` |

package/lib/index.js

@@ -49,6 +49,8 @@ const probe = (sock) => new Promise((resolve) => {
 
 // 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).
+const isDirectory = (p) => { try { return fs.statSync(p).isDirectory() } catch { return false } }
+
 function normalizePath(p) {
   const abs = path.resolve(p.replace(/^~(?=$|[\\/])/, os.homedir()))
   try { return fs.realpathSync.native(abs) } catch { return abs }
@@ -149,6 +151,24 @@ export function apply(ctx) {
   const runs = new Map() // runId -> run
   let stopping = false // set when the plugin unloads: release every wait()
   const waiters = new Map() // runId -> Set<resolve>
+  // Followers of a session's Harness goal (see follow()): woken by what may end their wait.
+  const followers = new Map() // sessionId -> Set<wake>
+  const FOLLOW_EVENTS = new Set(['turn/start', 'turn/end', 'goal/change'])
+  // A moment's delay, so the event that woke a follower is in the log it reads.
+  // Each such event also counts up the session's generation (50 ms later, once the log has it), so
+  // a follow that was reading the log when it came reads again instead of sleeping past it.
+  const eventGen = new Map() // sessionId -> count
+  const wakeFollowers = (sessionId) => setTimeout(guard('wake followers', () => {
+    eventGen.set(sessionId, (eventGen.get(sessionId) ?? 0) + 1)
+    for (const wake of [...(followers.get(sessionId) ?? [])]) wake()
+  }), 50)
+  // Sessions whose agent waits for a person (agent/status waiting), and how often each began to.
+  const waitingSessions = new Set()
+  const uiEpisodes = new Map() // sessionId -> count
+  const waitingSince = new Map() // sessionId -> ms the current wait began
+  // Sessions a follow wait is on, until when: a question that comes between two calls of one
+  // follow (a client's chunks, its round trip) is still taken up for dsh_answer.
+  const followedUntil = new Map() // sessionId -> ms
 
   // --- run bookkeeping ------------------------------------------------------
 
@@ -286,6 +306,7 @@ export function apply(ctx) {
 
   ctx.on('session/event', guard('session/event', (session, event) => {
     const data = event.data ?? {}
+    if (FOLLOW_EVENTS.has(event.type)) wakeFollowers(session.id)
     // 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
@@ -321,7 +342,9 @@ export function apply(ctx) {
           pushEvent(r, { type: 'human_input', text })
         }
       }
-      if (data.source?.kind === 'user' && opensTurn && run?.mode !== 'steer') {
+      // A round a Harness goal starts by itself counts like a user-started turn: the run whose
+      // turn just ended keeps that turn's reply instead of running on with the goal.
+      if ((data.source?.kind === 'user' || data.source?.kind === 'goal') && 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
@@ -330,7 +353,7 @@ export function apply(ctx) {
         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' })
+            Object.assign(prev, { outputClosed: true, supersededBy: run?.id ?? (data.source.kind === 'goal' ? 'goal' : 'user') })
             closed = true
           }
         }
@@ -438,6 +461,9 @@ export function apply(ctx) {
 
   ctx.on('agent/status', guard('agent/status', ({ agent, status }) => {
     if (!agent) return
+    if (status === 'waiting') { if (!waitingSessions.has(agent.id)) { uiEpisodes.set(agent.id, (uiEpisodes.get(agent.id) ?? 0) + 1); waitingSince.set(agent.id, Date.now()) } waitingSessions.add(agent.id) }
+    else { waitingSessions.delete(agent.id); waitingSince.delete(agent.id) }
+    wakeFollowers(agent.id)
     const receivers = receiversFor(agent.id)
     if (status === 'running' && receivers.length) lastRunningAt.set(agent.id, Date.now())
     for (const run of outputReceiversFor(agent.id)) {
@@ -574,10 +600,13 @@ export function apply(ctx) {
   function onQuestion(request, next) {
     const sessionId = request?.agent?.id
     const asked = sessionId && Array.isArray(request.questions) ? outputReceiversFor(sessionId) : []
-    if (!asked.length) return next()
+    // Taken up too when someone follows the session's goal: the follow wait brings it back.
+    const followed = followers.has(sessionId) || (followedUntil.get(sessionId) ?? 0) > Date.now()
+    if (!asked.length && !(followed && Array.isArray(request.questions))) 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)
+    wakeFollowers(sessionId)
     for (const run of asked) {
       run.question = publicQuestion(entry)
       pushEvent(run, { type: 'question', question_id: entry.id, count: entry.items.length })
@@ -598,6 +627,7 @@ export function apply(ctx) {
     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)
+      wakeFollowers(sessionId)
       for (const run of asked) {
         if (run.question?.question_id !== entry.id) continue
         delete run.question
@@ -607,15 +637,22 @@ export function apply(ctx) {
     })
   }
 
-  // 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) {
+  // Answer the open question of a run's turn, or of a session a follow wait reported it for.
+  // answers: [{ id?, choose?: [number | label], text?, skip? }]; questions not answered yet
+  // stay open until every one has an answer.
+  function answerQuestion({ run_id, session_id, answers }) {
+    if (!run_id && !session_id) throw new Error('run_id or session_id is required')
+    const run = run_id ? getRun(run_id) : null
+    const entry = questions.get(run?.sessionId ?? session_id)
+    if (run && (!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 (!entry) {
+      if (waitingSessions.has(session_id)) throw new Error(`Session ${session_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(`Session ${session_id} has no open question to answer.`)
+    }
+    const shown = run ? publicRun(run, 0) : { session_id }
     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) {
@@ -639,10 +676,10 @@ export function apply(ctx) {
     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 }
+      return { ...shown, 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)) }
+    return { ...shown, submitted: true, answers: entry.items.map((q) => entry.answers.get(q.id)) }
   }
 
   ctx.on('user-questions/request', guardWaterfall(onQuestion), { global: true, prepend: true })
@@ -720,6 +757,249 @@ 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) }
   }
 
+  // --- Harness goals --------------------------------------------------------------
+  // A session with a goal starts its next round by itself a few ms after a turn ends, until
+  // the goal is complete, paused or blocked, or its rounds run out. The goal's durable state is
+  // a session projection (values.goal). Whether this process will really go on with it
+  // (activation: armed, or disarmed, e.g. after a Harness restart until a person resumes it)
+  // is not in it: only Harness's goals service and its goal/activation-changed event say.
+
+  let goalsService = null
+  let agentsService = null
+  const activations = new Map() // sessionId -> 'armed' | 'disarmed', from goal/activation-changed
+  ctx.on('goal/activation-changed', guard('goal activation', ({ sessionId, goal } = {}) => {
+    if (!sessionId) return
+    if (goal?.activation) activations.set(sessionId, goal.activation)
+    else activations.delete(sessionId)
+    wakeFollowers(sessionId)
+  }))
+
+  // armed, disarmed, or null when this Harness does not say. A session not loaded (no live
+  // agent, as after a Harness restart until it is opened) runs nothing: disarmed.
+  function activationOf(sessionId, goalId) {
+    try {
+      if (agentsService && typeof goalsService?.get === 'function') {
+        const agent = agentsService.get(sessionId)
+        if (!agent) return 'disarmed'
+        const view = goalsService.get(agent)
+        if (view?.id === goalId && view.activation) return view.activation
+      }
+    } catch { /* not live here: the event is all there is */ }
+    return activations.get(sessionId) ?? null
+  }
+
+  const clipText = (s, n) => (typeof s === 'string' && s.length > n ? `${s.slice(0, n)}…` : s ?? null)
+
+  // The session's current goal, null (none, or this Harness has no goals), or undefined when
+  // the projection could not be read just now (not the same as no goal).
+  async function goalOf(sessionId) {
+    let current
+    if (typeof controller.projections !== 'function') return null
+    try {
+      const p = await controller.projections({ sessionId }, signal())
+      // The projection's wire view is the current goal itself (null when none); the stored
+      // state, as the projection cache keeps it, wraps it in { current, seenGoalIds, failure }.
+      const v = p?.values?.goal
+      current = v && typeof v === 'object' && 'current' in v ? v.current : v
+    } catch { return undefined }
+    const g = current?.goal
+    if (!g?.id) return null
+    const view = {
+      id: g.id, phase: g.phase, objective: clipText(g.objective, 300),
+      rounds_started: current.roundsStarted ?? 0, max_rounds: g.maxGoalRounds ?? null,
+      activation: activationOf(sessionId, g.id),
+      ...(g.blockedReason ? { blocked_reason: { code: g.blockedReason.code, message: g.blockedReason.message } } : {}),
+    }
+    // When it last changed, for follow() only (left out of results).
+    return Object.defineProperty(view, 'changedAt', { value: Number(current.updatedAt) || 0 })
+  }
+
+
+  // A session log's turns, oldest first: when each ended, its goal round (when a goal started
+  // it), its closing text and the tools it called.
+  function turnsOf(events) {
+    const ended = []
+    let cur = null
+    for (const e of events ?? []) {
+      if (e.type === 'turn/start') cur = { turn: e.data?.turn ?? ended.length + 1, round: null, text: null, tools: {}, started_at: Date.parse(iso(e.time)) || null }
+      else if (!cur) continue
+      else if (e.type === 'user/message' && e.data?.source?.kind === 'goal') cur.round = e.data.source.round ?? null
+      else if (e.type === 'assistant/message') {
+        const content = e.data?.message?.content
+        const text = textOf(content)
+        if (text) cur.text = text
+        for (const call of toolCallsOf(content)) { const n = call.name ?? call.kind; cur.tools[n] = (cur.tools[n] ?? 0) + 1 }
+      } else if (e.type === 'turn/end') {
+        ended.push({ ...cur, ended_at: iso(e.time) ?? new Date().toISOString(), end: e.data?.reason?.kind ?? null })
+        cur = null
+      }
+    }
+    return { ended, running: cur !== null, runningSince: cur?.started_at ?? null }
+  }
+
+  const MAX_ROUNDS_SHOWN = 100
+  const shownRound = (t) => ({
+    turn: t.turn, ...(t.round != null ? { goal_round: t.round } : {}), ended_at: t.ended_at,
+    ...(t.end && t.end !== 'completed' ? { ended_as: t.end } : {}),
+    final_text: clipText(t.text, 1500), ...(Object.keys(t.tools).length ? { tools: t.tools } : {}),
+  })
+  // An earlier round of a report, in one line: the latest round's reply usually sums up the
+  // goal so far, and a client reads any round in full with dsh_read_session.
+  const digestRound = (t) => ({
+    turn: t.turn, ...(t.round != null ? { goal_round: t.round } : {}),
+    ...(t.end && t.end !== 'completed' ? { ended_as: t.end } : {}),
+    summary: clipText(t.text?.replace(/\s+/g, ' ').trim() || null, 100), ...(Object.keys(t.tools).length ? { tools: t.tools } : {}),
+  })
+  // Every round since the last report: the latest in full, the ones before as digests (up to
+  // MAX_ROUNDS_SHOWN, then a count), so no round goes missing however long the wait was.
+  const shownRounds = (list) => {
+    const earlier = list.slice(0, -1)
+    const kept = earlier.slice(-(MAX_ROUNDS_SHOWN - 1))
+    return {
+      rounds: [...kept.map(digestRound), ...list.slice(-1).map(shownRound)],
+      ...(earlier.length > kept.length ? { earlier_rounds_not_shown: earlier.length - kept.length } : {}),
+    }
+  }
+
+  // Where a follow wait has got to: rounds already reported, and when it last reported.
+  const cursorOf = (mark) => `${mark.rounds}:${mark.at}`
+  function parseCursor(cursor) {
+    const m = /^(\d+):(\d+)$/.exec(String(cursor ?? ''))
+    return m ? { rounds: Number(m[1]), at: Number(m[2]) } : null
+  }
+  const GOAL_QUIET_MS = Number(process.env.DSH_BATON_GOAL_QUIET_MS) || 5 * 60_000
+  // How long a stopped goal waits for the round that stopped it to show its end in the log.
+  const GOAL_SETTLE_MS = Number(process.env.DSH_BATON_GOAL_SETTLE_MS) || 15_000
+  // The question or Harness UI wait a follower was already told about (one report per episode).
+  const noticed = new Map() // sessionId -> { key, at }
+  // A question still open is reported again to a call that comes back after this long (the
+  // report may never have reached anyone); a Harness UI wait once per episode.
+  const RENOTICE_MS = 60_000
+  // A waiting status with no question yet: the question usually follows within this time.
+  const QUESTION_GRACE_MS = 500
+
+  // Wait on a session's goal without sending anything. until "goal": until the goal stops
+  // (complete, paused, blocked, cleared). since_ms (without a cursor): count from then, e.g.
+  // a run's start, so its own round is in the report too. until "turn": at the first round end once every_s
+  // have passed since the last report, with every round since then. Both return at once when
+  // Harness needs a person, or the goal will not go on by itself (disarmed; when that cannot
+  // be read, no new round for GOAL_QUIET_MS). The cursor carries what was reported, so a
+  // next call, in either mode, neither repeats nor misses a round.
+  async function follow({ session_id, until = 'goal', cursor, since_ms, every_s = 600, timeout_s = 300 }) {
+    if (!session_id) throw new Error('session_id is required')
+    if (until !== 'goal' && until !== 'turn') throw new Error('until must be goal or turn')
+    if (typeof controller.projections !== 'function') throw new Error('This DeepSeek Harness version has no session projections, so its goals cannot be followed.')
+    const every = Math.max(1, Number(every_s) || 600) * 1000
+    const seconds = Number.isFinite(Number(timeout_s)) ? Math.min(Math.max(Number(timeout_s), 0), MAX_WAIT_S) : 300
+    const deadline = Date.now() + seconds * 1000
+    let mark = parseCursor(cursor)
+    const since = !mark && Number(since_ms) > 0 ? Number(since_ms) : null
+    let sawGoal = false
+    for (;;) {
+      // Followed from now on (a question that comes while the log is read is taken up), and
+      // the events so far, to tell whether one came during the read.
+      followedUntil.set(session_id, Date.now() + 60_000)
+      const gen = eventGen.get(session_id) ?? 0
+      const [goal, log] = await Promise.all([goalOf(session_id), controller.inspect(session_id, signal())])
+      const { ended, running, runningSince } = turnsOf(log?.events)
+      // A first call counts from the start of the round under way, so what it already wrote is
+      // reported; one that comes after the goal stopped, from the start of the last round.
+      mark ??= since
+        ? { rounds: ended.filter((t) => Date.parse(t.ended_at) < since).length, at: since }
+        : goal && goal.phase !== 'active' && !running && ended.length
+          ? { rounds: ended.length - 1, at: ended.at(-1).started_at ?? Date.parse(ended.at(-1).ended_at) }
+          : { rounds: ended.length, at: running && runningSince ? Math.min(runningSince, Date.now()) : Date.now() }
+      // The goal could not be read just now: decide nothing, look again shortly.
+      if (goal === undefined) {
+        if (stopping || Date.now() >= deadline) return { session_id, state: 'following', until, cwd: log?.meta?.cwd ?? null, since: iso(mark.at), rounds_since_report: ended.length - Math.min(mark.rounds, ended.length), timed_out: true, cursor: cursorOf(mark) }
+        await new Promise((r) => setTimeout(r, 2000))
+        continue
+      }
+      if (goal) sawGoal = true
+      const fresh = ended.slice(Math.min(mark.rounds, ended.length))
+      // A call that comes back in between (timed out, or Harness needs a person) names how many
+      // rounds wait, not their texts, and keeps the cursor: the rounds come once, in the report.
+      const out = (state, extra = {}) => {
+        const between = !!extra.timed_out || state === 'needs_input'
+        followedUntil.set(session_id, Date.now() + 60_000)
+        return {
+          session_id, state, until, goal, cwd: log?.meta?.cwd ?? null, since: iso(mark.at),
+          ...(between ? { rounds_since_report: fresh.length } : shownRounds(fresh)), ...extra,
+          cursor: between ? cursorOf(mark) : cursorOf({ rounds: ended.length, at: Date.now() }),
+        }
+      }
+      // A goal gone since a call that had one was cleared. Without one so far, the turn that
+      // sends "/goal …" creates it partway through: no_goal only once no turn is running.
+      const goalChanges = (log?.events ?? []).filter((e) => e.type === 'goal/change')
+      const hadGoal = sawGoal || ((!!cursor || !!since) && goalChanges.length > 0)
+      const endedBecause = !hadGoal ? null : !goal ? 'cleared' : goal.phase !== 'active' ? goal.phase : null
+      const lastEnd = ended.length ? Date.parse(ended.at(-1).ended_at) : 0
+      // From state the cursor carries, so the quiet also adds up across a client's short calls.
+      const quietSince = Math.max(lastEnd, mark.at)
+      // The round that stopped the goal (or used its last round) often still finishes its reply
+      // after that, and the log may not show that round running yet: settled once no round runs
+      // and one has ended since the goal changed, or GOAL_SETTLE_MS after the change.
+      // A cleared goal has no view left: when its last change was logged.
+      const changedAt = goal?.changedAt ?? (Date.parse(iso(goalChanges.at(-1)?.time)) || 0)
+      const settled = !running && (lastEnd >= changedAt || Date.now() - changedAt >= GOAL_SETTLE_MS)
+      const atLimit = !!(goal?.max_rounds && goal.rounds_started >= goal.max_rounds)
+      const question = questions.get(session_id)
+      const waitedFor = waitingSessions.has(session_id) ? Date.now() - (waitingSince.get(session_id) ?? 0) : null
+      if (!hadGoal) {
+        if (!running || stopping) return out('no_goal', { ended_because: null })
+      } else if (endedBecause) {
+        // Out of time before that round ends: a timed-out call, so the next one (same cursor)
+        // still waits for it; ending here would lose its reply.
+        if (settled || stopping) return out('goal_ended', { ended_because: endedBecause })
+      } else {
+        if (atLimit && settled) return out('goal_ended', { ended_because: 'round_limit' })
+        // A waiting status with no question yet is an approval in the Harness UI only once the
+        // question had time to come; an open question again to a call that comes back later.
+        const key = question ? `q:${question.id}` : waitedFor >= QUESTION_GRACE_MS ? `ui:${uiEpisodes.get(session_id)}` : null
+        const seen = noticed.get(session_id)
+        if (key && (seen?.key !== key || (question && Date.now() - seen.at >= RENOTICE_MS))) {
+          noticed.set(session_id, { key, at: Date.now() })
+          return out('needs_input', question ? { needs_input: 'answer', question: publicQuestion(question) } : { needs_input: 'harness-ui' })
+        }
+        if (goal.activation === 'disarmed') return out('needs_resume')
+        if (goal.activation == null && !running && Date.now() - quietSince >= GOAL_QUIET_MS) return out('goal_stalled')
+        if (until === 'turn' && fresh.length && (lastEnd >= mark.at + every || (Date.now() >= mark.at + every && !running))) return out('report')
+      }
+      if (stopping || Date.now() >= deadline) return out('following', { timed_out: true })
+      // Something happened while the log was read: read it again rather than sleep past it.
+      if ((eventGen.get(session_id) ?? 0) !== gen) continue
+      // Sleep until something happens, the next report is due, or the quiet runs out.
+      const due = [deadline, ...(until === 'turn' ? [mark.at + every] : []), ...(goal && goal.activation == null && !running ? [quietSince + GOAL_QUIET_MS] : []), ...((endedBecause || atLimit) && changedAt ? [changedAt + GOAL_SETTLE_MS] : []), ...(waitedFor != null && waitedFor < QUESTION_GRACE_MS ? [Date.now() - waitedFor + QUESTION_GRACE_MS] : [])]
+      const wakeAt = Math.max(Date.now() + 50, Math.min(...due.filter((t) => t > Date.now())))
+      await new Promise((resolve) => {
+        const set = followers.get(session_id) ?? new Set()
+        followers.set(session_id, set)
+        const done = () => {
+          clearTimeout(timer)
+          set.delete(done)
+          if (!set.size && followers.get(session_id) === set) followers.delete(session_id)
+          resolve()
+        }
+        const timer = setTimeout(done, wakeAt - Date.now())
+        set.add(done)
+      })
+    }
+  }
+
+  // A session at a glance, for a client that holds only its id: what it is doing, its goal
+  // and the reply of its last turn.
+  async function sessionStatus({ session_id }) {
+    const [act, goal, log] = await Promise.all([activity({ session_id }), goalOf(session_id), controller.inspect(session_id, signal()).catch(() => null)])
+    const { ended, running } = turnsOf(log?.events)
+    const question = questions.get(session_id)
+    return {
+      ...act, turn_running: running,
+      ...(goal ? { goal } : {}),
+      ...(question ? { needs_input: 'answer', question: publicQuestion(question) } : waitingSessions.has(session_id) ? { needs_input: 'harness-ui' } : {}),
+      ...(ended.length ? { last_turn: shownRound(ended.at(-1)) } : {}),
+    }
+  }
+
   // --- models -----------------------------------------------------------------
   // Harness's own catalog decides which names exist: "V4 Pro", "v4-pro" and "DeepSeek-V4-Pro"
   // all name the model whose id or name reads that way once case, spaces, hyphens,
@@ -885,6 +1165,15 @@ export function apply(ctx) {
       throw new Error(`Session ${sessionId} is archived. Unarchive it in Harness, or start a new session with cwd or workspace_id.`)
     }
     if (!sessionId && !cwd && !workspace_id) throw new Error('A new session needs cwd or workspace_id. Pass session_id to continue an existing one.')
+    // A missing folder is not created: a mistyped path, or a project on a drive that is not
+    // connected, would get an empty folder (under /Volumes, even). Checked before the registry,
+    // which answers a bare ENOENT, or nothing at all for a folder registered while it was there.
+    if (!sessionId) {
+      const dir = workspace_id ? registry.get?.(workspace_id)?.path : normalizePath(cwd)
+      if (dir && !isDirectory(dir)) {
+        throw new Error(`The folder ${dir}${workspace_id ? ` (workspace ${workspace_id})` : ''} does not exist, so no session was started and nothing was sent. Check the path (a project on an external drive needs that drive connected), or create the folder first.`)
+      }
+    }
     const plan = await planModel(sessionId, { model, reasoning_effort })
     const isNew = !sessionId
     if (isNew) {
@@ -969,7 +1258,18 @@ export function apply(ctx) {
       run.waitNoticed = true
       return { ...publicRun(run), needs_input: run.question ? 'answer' : 'harness-ui' }
     }
-    return { ...publicRun(run), ...(done ? {} : { timed_out: true }) }
+    return { ...publicRun(run), ...(done ? await goalField(run) : { timed_out: true }) }
+  }
+
+  // A run that completed in a session with a goal: the goal goes on after it.
+  // The session's goal, for whoever waited on a run: one that goes on after it, or one that
+  // stopped since the run began (its later rounds belong to the run's work: ended_since_run).
+  // A goal complete before the run is left out.
+  const goalField = async (run) => {
+    const goal = run.state === 'completed' ? await goalOf(run.sessionId) : null
+    if (!goal) return {}
+    const since = goal.phase !== 'active' && goal.changedAt >= (Date.parse(run.startedAt) || Infinity)
+    return goal.phase !== 'complete' || since ? { goal: since ? { ...goal, ended_since_run: true } : goal } : {}
   }
 
   // What a session is doing right now, as Harness reports it for archiving:
@@ -1045,7 +1345,12 @@ export function apply(ctx) {
     read_session: readSession,
     models,
     send,
-    status: ({ run_id, tail }) => publicRun(getRun(run_id), tail ?? 20),
+    status: async ({ run_id, session_id, tail }) => {
+      if (!run_id && session_id) return sessionStatus({ session_id })
+      const run = getRun(run_id)
+      return { ...publicRun(run, tail ?? 20), ...(isActive(run) ? {} : await goalField(run)) }
+    },
+    follow,
     wait,
     cancel,
     activity,
@@ -1132,6 +1437,14 @@ export function apply(ctx) {
       defaultModelService = child.agentDefaultModel
       child.effect(() => () => { if (defaultModelService === child.agentDefaultModel) defaultModelService = null }, 'dsh-baton-host default model')
     })
+    ctx.inject(['goals'], (child) => {
+      goalsService = child.goals
+      child.effect(() => () => { if (goalsService === child.goals) goalsService = null }, 'dsh-baton-host goals')
+    })
+    ctx.inject(['agents'], (child) => {
+      agentsService = child.agents
+      child.effect(() => () => { if (agentsService === child.agents) agentsService = null }, 'dsh-baton-host agents')
+    })
     ctx.inject(['webServer'], (web) => {
       web.effect(() => web.webServer.register({
         kind: 'exact',
@@ -1168,6 +1481,7 @@ export function apply(ctx) {
       // 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 set of followers.values()) for (const done of [...set]) done()
       for (const conn of connections) conn.destroy()
       if (!server) return
       server.close()

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-baton-host",
-  "version": "0.6.4",
+  "version": "0.6.5-next.2",
   "description": "DeepSeek Harness plugin for dsh-baton: hand coding tasks from Claude Code or Codex to DeepSeek Harness on your machine. Adding it is the whole install: it registers the dsh-baton MCP server for Claude Code and Codex, runs each task live in the Harness window, wakes the main agent when the run ends and hands back the changed files, the project's own test results and a requirement-by-requirement checklist.",
   "type": "module",
   "main": "lib/index.js",
@@ -20,7 +20,7 @@
     "LICENSE"
   ],
   "dependencies": {
-    "dsh-baton-mcp": "0.6.4"
+    "dsh-baton-mcp": "0.6.5-next.2"
   },
   "license": "MIT",
   "dsh": {