dsh-plugin-subagent-bridge 0.12.2 → 0.13.1

package/README.md

@@ -56,6 +56,55 @@ dsh_task({ prompt: "…", cwd: "/repo/clawer" })
 - 返回结果里带上 `workspace: { id, title, path }`，方便确认落在哪个项目；
 - 项目操作失败不影响派发本身（分组是外观，不因此让任务失败）。
 
+## 排队还是插话（`mode`）
+
+DSH 的「繁忙时的发送行为」只有两种，桥把它们原样交给调用方：
+
+| `mode` | DSH 里的名字 | 行为 |
+| --- | --- | --- |
+| `queue`（默认） | 排队发送 | 等当前回合跑完，再作为一个新回合处理 |
+| `steer` | 插话发送 | 并入当前回合，模型在下一步就能看到 |
+
+`dsh_task`、`dsh_spawn`、`dsh_followup` 都支持：
+
+```js
+dsh_followup({ worker: "w1", message: "接下来只改 src 下的文件", mode: "steer" })
+dsh_task({ sessionId: "session-…", prompt: "停一下，改成只跑单测", mode: "steer" })
+```
+
+两点实测结论：
+
+1. **`steer` 不打断正在执行的工具**。实测 worker 正在跑 `sleep 90`，`steer` 的消息投递进去了，但要等那次工具调用返回、模型走到下一步才被看到——整整 70 秒。真想立刻停，是 DSH 界面上另一个动作（取消），不是投递模式。
+2. **`steer` 不新开回合**（turn 编号不变），所以等待条件必须是「当前回合结束」。早期实现等的是「下一个回合」，答案都回来了、调用还在等，最后 120 秒超时。
+
+`dsh_task` 对正在运行的会话默认会拒绝，错误信息里会提示改用 `steer`。
+
+第三个细节是返回值：插话的回复和原任务在**同一个回合**里，所以不能简单取"这一轮最后一条 assistant 文本"——那可能是原任务后面的步骤。桥会在插话后定位到**自己那条 user/message**，只取它之后的 assistant 文本作为回答。
+
+## 创建项目（workspace）
+
+DSH 的侧边栏分组是"项目（workspace）"，和会话的工作目录是两回事：新建会话默认落在「未分组」，除非它所在的目录已经是一个项目。
+
+`dsh_task` / `dsh_spawn` 的 `workspace` 参数把这一步也接管了：
+
+```js
+// 目录不是项目 → 用它创建项目（标题取目录名），会话直接归到项目下
+dsh_task({ prompt: "…", cwd: "/repo/clawer", workspace: true })
+
+// 用指定标题创建
+dsh_spawn({ task_name: "w1", message: "…", cwd: "/repo/clawer", workspace: "Clawer" })
+
+// 不传 → 只复用已有项目；目录没有项目就保持未分组（和以前一样）
+dsh_task({ prompt: "…", cwd: "/repo/clawer" })
+```
+
+行为细节：
+
+- 目录不存在时先递归创建，再做项目登记（登记要求目录已存在）；
+- 目录已经是项目 → **直接复用，不改标题**（底层 `create` 对同一路径返回已有记录）；
+- 返回结果里带上 `workspace: { id, title, path }`，方便确认落在哪个项目；
+- 项目操作失败不影响派发本身（分组是外观，不因此让任务失败）。
+
 ## 排队还是立刻打断（`mode`）
 
 DSH 的 prompt 有两种投递模式，桥把它们交给调用方选：

package/index.js

@@ -117,9 +117,9 @@ const TOOLS = [
         },
         mode: {
           type: 'string',
-          enum: ['queue', 'steer', 'interrupt'],
+          enum: ['queue', 'steer'],
           description:
-            'delivery: "queue" (default) waits for the running turn to finish; "steer" inserts the message into that turn (its current step still completes); "interrupt" cancels the running turn first, then sends.',
+            'How a busy session receives this: "queue" (default) waits for the running turn to finish, "steer" inserts the message into that turn so the model sees it at the next step.',
         },
 
         reasoningEffort: {
@@ -160,9 +160,9 @@ const TOOLS = [
         },
         mode: {
           type: 'string',
-          enum: ['queue', 'steer', 'interrupt'],
+          enum: ['queue', 'steer'],
           description:
-            'delivery: "queue" (default) waits for the running turn to finish; "steer" inserts the message into that turn (its current step still completes); "interrupt" cancels the running turn first, then sends.',
+            'How a busy session receives this: "queue" (default) waits for the running turn to finish, "steer" inserts the message into that turn so the model sees it at the next step.',
         },
 
         reasoningEffort: { type: 'string', description: 'Reasoning level for `model`, when that model offers levels.' },
@@ -187,9 +187,9 @@ const TOOLS = [
         reasoningEffort: { type: 'string', description: 'Reasoning level for `model`, when that model offers levels.' },
         mode: {
           type: 'string',
-          enum: ['queue', 'steer', 'interrupt'],
+          enum: ['queue', 'steer'],
           description:
-            'delivery: "queue" (default) waits for the running turn to finish; "steer" inserts the message into that turn (its current step still completes); "interrupt" cancels the running turn first, then sends.',
+            'How a busy session receives this: "queue" (default) waits for the running turn to finish, "steer" inserts the message into that turn so the model sees it at the next step.',
         },
       },
       required: ['worker', 'message'],
@@ -278,6 +278,26 @@ const TOOLS = [
   },
 ]
 
+/**
+ * Sequence number of the first message the caller itself delivered after `sinceSeq`.
+ * With steer the reply shares the running turn, so "the last assistant text of the turn"
+ * can be a step of the original task; anchoring on our own message keeps it exact.
+ * @param ctx - Host context.
+ * @param sessionId - session to read.
+ * @param sinceSeq - sequence captured before the prompt was delivered.
+ * @returns the sequence, or the original value when nothing matches.
+ */
+function firstDeliveredMessageSeq(ctx, sessionId, sinceSeq) {
+  const session = ctx.get('sessions')?.get?.(sessionId)
+  if (session === undefined || session === null) return sinceSeq
+  for (const event of session.snapshotEvents()) {
+    if (Number(event.seq) <= sinceSeq) continue
+    if (event.type !== 'user/message') continue
+    return Number(event.seq)
+  }
+  return sinceSeq
+}
+
 /**
  * Start the bridge.
  * @param ctx - Host context.
@@ -610,7 +630,7 @@ async function callTool(id, params, api, signal) {
               from: args.from,
               cwd: args.cwd,
               workspace: args.workspace === true || (typeof args.workspace === 'string' && args.workspace !== '') ? args.workspace : undefined,
-              mode: args.mode === 'steer' || args.mode === 'interrupt' ? args.mode : undefined,
+              mode: args.mode === 'steer' ? 'steer' : undefined,
               model: typeof args.model === 'string' && args.model !== '' ? args.model : undefined,
               reasoningEffort:
                 typeof args.reasoningEffort === 'string' && args.reasoningEffort !== '' ? args.reasoningEffort : undefined,
@@ -627,7 +647,7 @@ async function callTool(id, params, api, signal) {
             await api.followup({
               worker,
               message,
-              mode: args.mode === 'steer' || args.mode === 'interrupt' ? args.mode : undefined,
+              mode: args.mode === 'steer' ? 'steer' : undefined,
               model: typeof args.model === 'string' && args.model !== '' ? args.model : undefined,
               reasoningEffort:
                 typeof args.reasoningEffort === 'string' && args.reasoningEffort !== '' ? args.reasoningEffort : undefined,
@@ -666,7 +686,7 @@ async function callTool(id, params, api, signal) {
               sessionId,
               agentPreset: typeof args.agentPreset === 'string' && args.agentPreset !== '' ? args.agentPreset : undefined,
               workspace: args.workspace === true || (typeof args.workspace === 'string' && args.workspace !== '') ? args.workspace : undefined,
-              mode: args.mode === 'steer' || args.mode === 'interrupt' ? args.mode : undefined,
+              mode: args.mode === 'steer' ? 'steer' : undefined,
               model: typeof args.model === 'string' && args.model !== '' ? args.model : undefined,
               reasoningEffort:
                 typeof args.reasoningEffort === 'string' && args.reasoningEffort !== '' ? args.reasoningEffort : undefined,
@@ -869,30 +889,16 @@ export function createApi(ctx, state, settings) {
         }
         if (typeof targetId !== 'string' || targetId === '') throw new Error('session controller did not return a session id')
         created = true
-      } else if (mode !== 'steer' && mode !== 'interrupt' && ctx.get('agents')?.get?.(targetId)?.status === 'running') {
+      } else if (mode !== 'steer' && ctx.get('agents')?.get?.(targetId)?.status === 'running') {
         /* Steering exists precisely to reach a running session; queueing into one would
          * silently wait for a turn this call is not tracking. */
-        throw new Error('that session is running; pass mode:"steer" (insert into the turn) or mode:"interrupt" (cancel it first), or use dsh_dispatch plus dsh_read_result')
+        throw new Error('that session is running; pass mode:"steer" to insert into that turn, or use dsh_dispatch plus dsh_read_result')
       }
 
       const appliedModel = await applyModelSpec(ctx, targetId, model, reasoningEffort)
-      const deliveryMode = mode === 'steer' ? 'steer' : mode === 'interrupt' ? 'interrupt' : 'queue'
+      /* DSH delivers a prompt either queued behind the running turn or steered into it. */
+      const deliveryMode = mode === 'steer' ? 'steer' : 'queue'
       const turnBefore = lastTurn(ctx, targetId)
-
-      /* `steer` inserts the message into the running turn, but that turn still finishes its
-       * current step first — an in-flight tool call keeps running. `interrupt` is the hard
-       * stop: cancel the turn, then send, so the worker drops what it was doing. */
-      if (deliveryMode === 'interrupt' && ctx.get('agents')?.get?.(targetId)?.status === 'running') {
-        try {
-          await service.cancel({ sessionId: targetId })
-        } catch {
-          /* Cancelling is best effort: the send below still delivers the message. */
-        }
-        /* The abort closes the *current* turn, so accept that number: waiting for a
-         * strictly newer turn burned the whole grace period before every send. */
-        await waitForTurnEnd(ctx, targetId, Math.max(0, turnBefore - 1), 15000)
-      }
-
       /* A steered message is absorbed by the turn that is already running, so waiting for
        * a strictly newer turn would hang until the timeout even after the answer landed. */
       const waitAfter = deliveryMode === 'steer' ? Math.max(0, turnBefore - 1) : turnBefore
@@ -900,7 +906,7 @@ export function createApi(ctx, state, settings) {
       const finished = waitForTurnEnd(ctx, targetId, waitAfter, seconds * 1000)
       const requestId = randomUUID()
       const accepted = await service.prompt(
-        { sessionId: targetId, requestId, mode: deliveryMode === 'steer' ? 'steer' : 'queue', content: [{ type: 'text', text: prompt }] },
+        { sessionId: targetId, requestId, mode: deliveryMode, content: [{ type: 'text', text: prompt }] },
         AbortSignal.timeout(30000),
       )
       state.dispatched.add(targetId)
@@ -922,7 +928,10 @@ export function createApi(ctx, state, settings) {
       }
 
       const end = await finished
-      const collected = finalAnswer(ctx, targetId, before, settings)
+      /* A steered reply lives inside the turn that was already running, so anchor the
+       * answer on the message we delivered instead of the turn's last assistant text. */
+      const answerFrom = deliveryMode === 'steer' ? firstDeliveredMessageSeq(ctx, targetId, before) : before
+      const collected = finalAnswer(ctx, targetId, answerFrom, settings)
       const turnReason = end?.reason?.kind ?? null
       const durationMs = Date.now() - started
       const status = end === undefined ? 'timeout' : turnReason === 'completed' ? 'completed' : `turn-${String(turnReason)}`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-plugin-subagent-bridge",
-  "version": "0.12.2",
+  "version": "0.13.1",
   "type": "module",
   "description": "Subagent bridge: lets Codex delegate a task to DeepSeek Harness the way it would spawn a subagent (one call, waits for the answer), plus a codex_dispatch tool for the reverse direction.",
   "keywords": [

package/skills/deepseek-worker/SKILL.md

@@ -224,34 +224,26 @@ dsh_followup({ "worker": "audit_api", "message": "把第 3 条展开，给出补
 
 `dsh_followup` 复用该 worker 的会话，比新开一个便宜。也可以用 `dsh_task({ "sessionId": …, "prompt": … })` 做同样的事（阻塞版）。
 
-## 改主意时：排队还是立刻打断
+## 改主意时：排队还是插话
 
-默认 `dsh_followup` / `dsh_task` 是**排队**：等 worker 当前这一轮跑完再处理。但有时候用户就是要它立刻停——改方向、别继续跑、先汇报。这时用 `mode`：
+默认是**排队发送**：等 worker 当前这一轮跑完，再作为新的一轮处理。DSH 的「繁忙时的发送行为」还提供**插话发送**，桥用 `mode` 暴露它：
 
 ```jsonc
-// 排进队列，等当前回合结束（默认）
+// 排队（默认）：等这一轮结束
 dsh_followup({ "worker": "w1", "message": "跑完顺手看一下测试覆盖率" })
 
-// 插进当前回合：当前那一步工具调用仍会跑完
-dsh_followup({ "worker": "w1", "message": "补充一句：只改 src 下的文件", "mode": "steer" })
-
-// 立刻打断：先取消当前回合，再发消息开新回合
-dsh_followup({ "worker": "w1", "message": "停，先汇报现在的结果", "mode": "interrupt" })
+// 插话：并入当前这一轮，模型下一步就能看到
+dsh_followup({ "worker": "w1", "message": "接下来只改 src 下的文件，别动 packages", "mode": "steer" })
 ```
 
 | `mode` | 行为 | 什么时候用 |
 | --- | --- | --- |
-| `queue`（默认） | 等这一轮结束 | 补充要求，不急着停 |
-| `steer` | 并入当前回合，**当前那一步还会跑完** | 想到补充，能等这一下 |
-| `interrupt` | 先 `cancel`，再发消息 | 真的要停 |
-
-实测差别（worker 正在跑 `sleep 120`）：
-
-- `steer` → 消息要等那一步工具调用结束才被看到，**70 秒**才回应；
-- `interrupt` → 先 aborted 当前回合，再开新回合，**10 秒左右**返回。
+| `queue`（默认） | 等这一轮结束，新开一轮 | 「顺便」「另外」 |
+| `steer` | 并入当前一轮，**turn 不重开** | 「接下来注意…」「只改某某」 |
 
-用户说「停下来」「别跑了」「先别管这个」时用 `interrupt`；说「顺便」「另外」时用默认 `queue` 就够了。`dsh_task` 对**正在运行**的会话默认会拒绝，拒绝信息里也会提示这两个选项。
+**`steer` 不会打断正在执行的工具**：worker 若正卡在 `sleep 90` 这类调用里，消息要等它返回到下一步才被看到（实测 70 秒）。要它立刻停，那是用户在 DSH 界面上按取消，不是这里的投递模式——不要用 `steer` 假装能"打断"。
 
+用户说「停下来/别做了」时，正确反应是：告诉用户这会让当前这轮中止，或者用 `dsh_wait` 等它自然结束——不要依赖 `mode` 去实现"立即停"。
 
 ## 查现在有哪些 worker