@whaletalk/dsh-codex-collab 0.1.6 → 0.1.7

package/README.md

@@ -218,8 +218,9 @@ dsh_task({ "instruction": "继续推进第 3 步…", "sessionId": "session-8d48
 # 新建子代理（默认行为）
 dsh-task --in "<指令>" --cwd "<目录>" [--lane backend] [--model fast|pro] [--commit]
 
-# 接进已有会话：先找，再派
+# 接进已有会话：先找（或先空跑验证），再派
 dsh-task --sessions "<标题关键词>"                    # 只读列候选，拿 sessionId
+dsh-task --dry-run --find "<标题关键词>"               # 只解析目标、回显命中，不投递任何消息
 dsh-task --in "<指令>" --session "<sessionId>" [--steer]
 dsh-task --in "<指令>" --find "<标题关键词>"           # 唯一命中才派；否则退出码 4
 
@@ -235,13 +236,21 @@ dsh-task --sessions "按文档启动OKX策略实验计划"
 # → {"items":[{"sessionId":"session-8d481ad9-…","snippet":"按文档启动OKX策略实验计划",
 #              "agentAvailable":true}],"total":1,"matchedBy":"list"}
 
+# 1b) 没命中时会给近似候选（按标题相似度 + 最近更新排序），换词重查或改用 sessionId——
+#     绝不要发一条消息去"试探命中"（它会落进对方会话并跑成回合，污染对话）
+dsh-task --dry-run --find "量化框架"
+# → {"resolved":false,"reason":"session-query-empty",
+#    "candidates":[{"sessionId":"1c0f99f8-…","snippet":"你是一个量化研究项目的技术","score":0.333}, …]}
+
 # 2) 接通（投递进那条会话；这一轮的助手回复作为汇报返回，只回报本轮新增文本）
 dsh-task --in "<继续推进的指令>" --session "session-8d481ad9-…"
 ```
 
 `matchedBy` 说明"找到"走了哪条路：`search` = 会话搜索索引；`list` = 索引被部署禁用时退回遍历列表 + 标题投影（都不激活 Agent）。
 
-失败一律返回稳定 `reason` 且**不创建任何会话/工作区**：`session-query-empty`（没命中）、`session-ambiguous`（多条命中，附 `candidates`）、`session-not-found`、`session-busy`、`session-writer-held`（会话被别的写入方占用）、`session-archived`、`session-not-accepted`、`session-timeout`、`session-cancel-refused`（取消会话目标默认被拒，需 `--force`）。
+**`delivered` 与排队语义**（重要）：`prompt` 一旦被目标会话接受，就表示消息**已经进了它的队列**，响应里会带 `delivered: true`；此后即便我们的观察超时（会话可能正跑一个很长的回合），也**不要重发**——重发会让同一份内容在用户会话里出现两次。`queue` 模式不再用 120s 判失败：没在 120s 内开跑只记一条 note 并继续等，最终由总预算（默认 1h）收口为 `session-timeout` + `delivered: true`。
+
+失败返回稳定 `reason` 且**不创建任何会话/工作区**：`session-query-empty`（没命中，附 `candidates`）、`session-ambiguous`（多条命中，附 `candidates`）、`session-not-found`、`session-busy`、`session-writer-held`（会话被别的写入方占用）、`session-archived`、`session-not-accepted`（仅当 prompt **未被接受**）、`session-timeout`、`session-cancel-refused`（取消会话目标默认被拒，需 `--force`）。
 
 ## 反向通道：让 DSH 调用 Codex
 

package/codex-plugin/plugins/dsh/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh",
-  "version": "0.1.6",
+  "version": "0.1.7",
   "description": "Codex 主导的双向编码协作插件：ChatGPT 把编码任务下发给本机 DeepSeek Harness 的持久编码子代理执行，DeepSeek 在共享工作目录 D:\\Harness 中写代码并实时回传进度与汇报，Codex 读文件验收、反馈修正，直到通过。",
   "author": {
     "name": "FuJackGao"

package/codex-plugin/plugins/dsh/skills/dsh-collab/SKILL.md

@@ -30,10 +30,17 @@ description: "与 DeepSeek Harness 编码协作。当用户要写代码、建项
 ## 找到已有会话（只读，不创建任何东西）
 
 ```bash
-dsh-task --sessions "<标题或内容关键词>"
+dsh-task --sessions "<标题或内容关键词>"          # 只读列出候选
+dsh-task --dry-run --find "<标题关键词>"          # 只解析目标、回显命中结果，不投递
 ```
 
-输出候选（`sessionId` + 片段）。**必须唯一命中**才能直接用；多条会返回 `candidates` 让你改用 `--session <id>`。退出码 `4` = 没命中或不唯一。
+输出候选（`sessionId` + 片段）。**必须唯一命中**才能直接用；多条会返回 `candidates` 让你改用 `--session <id>`。
+
+没命中时会额外给出 `candidates`（按标题相似度 + 最近更新排序）——**换词重查，或直接确认用户指的是哪一条**。
+
+> ⛔ **绝不投递任何消息来"验证命中"**（例如发一条「占位/测试/忽略本条」）。真实事故：调用方搜不到标题后发了条占位消息试探，它解析成了用户自己的会话，于是**作为一条真实用户消息落进对话并跑成回合**，会话里的 agent 还以为那是用户发的。验证命中只有两种合法手段：上面的 `--sessions` 和 `--dry-run`。
+>
+> ⛔ **看到 `delivered: true` 就不要重发**。它表示 prompt 已被那条会话接受、进了它的队列；我们只是没等到它开跑（会话可能正忙着一个很长的回合）。重发会让同一份内容在用户会话里出现两次。用 `--status <taskId>` 继续观察。
 
 ## 下发任务
 

package/codex-plugin/plugins/dsh/skills/dsh-collab/scripts/task.mjs

@@ -41,6 +41,7 @@ function parseArgs(argv) {
     else if (a === '--session') { out.sessionId = argv[++i] || '' }
     else if (a === '--find') { out.find = argv[++i] || '' }
     else if (a === '--steer') { out.steer = true }
+    else if (a === '--dry-run') { out.dryRun = true }
     else if (a === '--force') { out.force = true }
     else { rest.push(a) }
   }
@@ -175,22 +176,53 @@ async function main() {
     }
     console.log(JSON.stringify(res.json, null, 2))
     const items = Array.isArray(res.json.items) ? res.json.items : []
+    if (items.length === 0 && Array.isArray(res.json.candidates) && res.json.candidates.length > 0) {
+      console.error('未命中。候选（改用 --session <id>，或换个关键词）:')
+      for (const c of res.json.candidates) console.error('  ' + c.sessionId + '  ' + c.snippet + (c.score === undefined ? '' : '  score=' + c.score))
+      console.error('提示: 验证命中用 --dry-run，不要投递消息去试探。')
+    }
     finish(items.length > 0 ? 0 : 4)
   }
 
   const instruction = opts.instruction.trim()
+  const cwd = (opts.cwd || process.env.DSH_BRIDGE_CWD || '').trim()
+  const sessionId = (opts.sessionId || '').trim()
+  const find = (opts.find || '').trim()
+  const sessionTarget = sessionId !== '' ? { sessionId } : (find !== '' ? { sessionQuery: find } : null)
+
+  // --dry-run：只解析目标、回显命中结果，什么都不投递。验证"这条查询会命中哪条会话"就用它，
+  // 绝不要投递一条消息去试探（那会落进用户会话并跑成回合，污染对话）。
+  if (opts.dryRun) {
+    if (instruction === '' && sessionTarget === null && cwd === '') {
+      console.error('用法: node task.mjs --dry-run (--find "<标题关键词>" | --session <会话id> | --cwd <目录>)')
+      finish(2)
+    }
+    const res = await request('POST', GATEWAY + '/api/dsh-bridge/task', {
+      instruction: instruction === '' ? '(dry-run)' : instruction,
+      dryRun: true,
+      ...(sessionTarget === null ? (cwd ? { cwd } : {}) : sessionTarget),
+    })
+    console.log(JSON.stringify(res.json, null, 2))
+    if (res.json === null || typeof res.json !== 'object') finish(1)
+    if (res.json.resolved !== true) {
+      if (Array.isArray(res.json.candidates) && res.json.candidates.length > 0) {
+        console.error('未命中。候选（改用 --session <id>，或换个关键词）:')
+        for (const c of res.json.candidates) console.error('  ' + c.sessionId + '  ' + c.snippet + (c.score === undefined ? '' : '  score=' + c.score))
+      }
+      finish(4)
+    }
+    finish(0)
+  }
+
   if (!instruction) {
     console.error('用法: node task.mjs --in "<指令>" [--cwd 目录] [--lane 名] [--model fast|pro] [--commit] [--timeout 秒] [--no-wait]')
     console.error('      node task.mjs --in "<指令>" (--session <会话id> | --find "<标题关键词>") [--steer]   # 投递进已有会话')
     console.error('查找: node task.mjs --sessions "<标题关键词>"   # 只读列出候选, 拿 sessionId 再派活')
+    console.error('      node task.mjs --dry-run (--find "<关键词>" | --session <id>)   # 只解析目标, 不投递（验证命中用这个）')
     console.error('管理: node task.mjs --list | --status <taskId> | --cancel <taskId> [--force]')
     console.error('退出码: 0 成功 / 1 失败 / 2 用法 / 3 超时 / 4 会话未命中或不唯一 / 5 session 目标取消被拒')
     finish(2)
   }
-  const cwd = (opts.cwd || process.env.DSH_BRIDGE_CWD || '').trim()
-  const sessionId = (opts.sessionId || '').trim()
-  const find = (opts.find || '').trim()
-  const sessionTarget = sessionId !== '' ? { sessionId } : (find !== '' ? { sessionQuery: find } : null)
   if (sessionTarget !== null && (cwd !== '' || opts.commit)) {
     console.error('task.mjs: --session/--find 不能与 --cwd/--commit 同时使用（已有会话自带工作目录，本工具不替它提交）')
     finish(2)
@@ -246,6 +278,11 @@ async function main() {
       console.log(JSON.stringify({ phase: 'finished', ...status }))
       console.log('=== DeepSeek 汇报 ===')
       console.log(status.result || status.error || '(无内容)')
+      // delivered=true 表示 prompt 已被那条会话接受（进了它的队列）：即便我们等超时了，
+      // 消息也可能会跑，**不要重发**（重发会让同一份内容在用户会话里出现两次）。
+      if (status.status === 'error' && status.delivered === true) {
+        console.error('注意: 消息已投递进该会话的队列（delivered=true），只是我们没等到它开跑。不要重发；可用 --status ' + task.taskId + ' 继续观察。')
+      }
       if (status.status === 'done') {
         // session 目标的记忆就在那条会话里，不再往协作历史里塞一份。
         if (sessionTarget === null) {

package/harness/dsh-bridge.mjs

@@ -32,6 +32,7 @@ import {
   mapControllerError,
   sessionTitleOf,
   looksLikeDisabledSearch,
+  rankTitleCandidates,
   taskResponse,
 } from './session-target.mjs'
 
@@ -449,6 +450,33 @@ export async function apply(ctx) {
     }
   }
 
+  /**
+   * 查询没命中时给的"近似候选"：读 list（不激活 Agent、不开索引），按 bigram 相似度
+   * 与最近更新排序。存在的意义是**不给"探测"留动机**——真实事故里调用方搜不到标题后
+   * 发了一条占位消息去试探，那条消息落进用户会话并跑成回合。有了候选，只读就能改词重查。
+   */
+  const sessionNearMisses = async (query, limit = 5) => {
+    const controller = sessionControllerNow()
+    if (controller === undefined) return []
+    try {
+      const value = await controller.list({}, signalOf())
+      const items = value !== undefined && value !== null && Array.isArray(value.items) ? value.items : []
+      const summaries = []
+      for (const summary of items) {
+        if (summary === null || typeof summary !== 'object' || typeof summary.sessionId !== 'string') continue
+        summaries.push({
+          sessionId: summary.sessionId,
+          title: sessionTitleOf(summary),
+          updatedAt: typeof summary.updatedAt === 'number' ? summary.updatedAt : 0,
+        })
+      }
+      return rankTitleCandidates(query, summaries, limit)
+    } catch (e) {
+      console.error('[dsh-bridge] near-miss lookup failed:', errText(e).slice(0, 200))
+      return []
+    }
+  }
+
   /** 只读解析：query → search 选一；sessionId → 直接用。任何不确定性都返回 reason。 */
   const resolveSessionTarget = async (target) => {
     const controller = sessionControllerNow()
@@ -467,7 +495,13 @@ export async function apply(ctx) {
       }
     }
     const picked = selectSession(hits, target)
-    if (!picked.ok) return picked
+    if (!picked.ok) {
+      // 查询落空不是"死路"：附上近似候选，调用方只读就能改词重查（别再发消息探测）。
+      if (picked.reason === REASONS.QUERY_EMPTY) {
+        return { ...picked, candidates: await sessionNearMisses(target.query) }
+      }
+      return picked
+    }
     let result
     try {
       result = await controller.resolveAgent(picked.sessionId)
@@ -494,6 +528,7 @@ export async function apply(ctx) {
     if (fields.error !== undefined) task.error = fields.error
     if (fields.reason !== undefined) task.reason = fields.reason
     if (fields.stopReason !== undefined) task.stopReason = fields.stopReason
+    if (fields.delivered !== undefined) task.delivered = fields.delivered
     pushTask(task.taskId, status === 'done' ? 'result' : 'error', {
       ...(task.result === undefined ? {} : { text: task.result }),
       ...(task.error === undefined ? {} : { error: task.error }),
@@ -603,6 +638,8 @@ export async function apply(ctx) {
       sessionId: resolved.sessionId, taskId: task.taskId, deliver, baseline,
       total: '', sawRunning: false, activeSince: Date.now(), startedAt: Date.now(),
       settled: false, abort: undefined, watcher: 'pending',
+      // prompt 被接受 = 消息已进会话队列。此后就不该再把它当"没发出去"（见 sweepSessionTargets）。
+      delivered: false, queuedNoted: false,
     }
     sessionTargets.set(resolved.sessionId, record)
 
@@ -635,7 +672,9 @@ export async function apply(ctx) {
     }
 
     watchSessionTask(record)
-    pushTask(task.taskId, 'task-accepted', { target: { kind: 'session', sessionId: resolved.sessionId }, deliver, cwd: resolved.snippet })
+    record.delivered = true
+    task.delivered = true
+    pushTask(task.taskId, 'task-accepted', { target: { kind: 'session', sessionId: resolved.sessionId }, deliver, cwd: resolved.snippet, delivered: true })
     return { task, failed: null }
   }
 
@@ -770,16 +809,39 @@ export async function apply(ctx) {
           }
         } catch (e) { /* 读不到就下一轮再试 */ }
       }
+      // 派发超时只在"prompt 没被接受"时才算失败。
+      // queue 模式下 prompt 被接受就意味着消息已进队列，会在会话空闲时跑；此时报 error
+      // 是误报——实测会话正跑一个 38 分钟的回合，排队等待远超 120s 完全正常，而误报会
+      // 直接诱导调用方重发（真实事故：同一条汇报被投了两次）。所以这里只记一条 note，
+      // 继续等，由下面的总预算兜底。
       if (!record.sawRunning && now - record.startedAt > SESSION_DISPATCH_TIMEOUT_MS) {
-        settleSessionTask(record, 'error', { error: 'the session never started a turn after the prompt was accepted (it may still be queued)', reason: REASONS.NOT_ACCEPTED })
-        continue
+        if (record.delivered === true) {
+          if (record.queuedNoted !== true) {
+            record.queuedNoted = true
+            pushTask(record.taskId, 'note', {
+              note: 'QUEUED',
+              text: 'prompt 已被接受并进入该会话队列，等它空闲时会跑；不要重发',
+              target: { kind: 'session', sessionId: record.sessionId },
+              delivered: true,
+            })
+          }
+        } else {
+          settleSessionTask(record, 'error', { error: 'the session never accepted the prompt', reason: REASONS.NOT_ACCEPTED, delivered: false })
+          continue
+        }
       }
       if (record.sawRunning && record.activeSince > 0 && now - record.activeSince > SESSION_QUIET_TIMEOUT_MS) {
         finishSessionTask(record, 'quiet-timeout')
         continue
       }
       if (now - record.startedAt > SESSION_TOTAL_TIMEOUT_MS) {
-        settleSessionTask(record, 'error', { error: 'session task exceeded its total budget', reason: REASONS.TIMEOUT })
+        settleSessionTask(record, 'error', {
+          error: record.delivered === true
+            ? 'prompt 已投递进该会话队列，但预算内它始终没有开始这一轮（会话可能一直在忙，或未被激活）；不要重发，可用 status 继续观察'
+            : 'session task exceeded its total budget before the prompt was accepted',
+          reason: REASONS.TIMEOUT,
+          delivered: record.delivered === true,
+        })
       }
     }
   }
@@ -851,14 +913,55 @@ export async function apply(ctx) {
       const parsed = await readJsonBody(req, res)
       if (parsed === null) return
       const instruction = parsed !== null && typeof parsed === 'object' && typeof parsed.instruction === 'string' ? parsed.instruction : ''
-      if (instruction.trim() === '') { sendJson(res, 400, { error: 'missing instruction' }); return }
+      const dryRun = parsed !== null && typeof parsed === 'object' && parsed.dryRun === true
+      if (!dryRun && instruction.trim() === '') { sendJson(res, 400, { error: 'missing instruction' }); return }
       const classified = classifyTarget(parsed)
       if (!classified.ok) { sendJson(res, 400, { error: classified.message, reason: classified.reason }); return }
+      // dryRun：只解析目标、回显它，**不投递任何东西**。存在的意义是让"我这条查询会命中
+      // 哪条会话"能纯只读地问出来——真实事故里调用方就是因为没法先验证，才发了一条占位
+      // 消息去探测，结果污染了用户会话。
+      if (dryRun) {
+        if (classified.target.kind === 'session') {
+          const resolved = await resolveSessionTarget(classified.target)
+          if (!resolved.ok) {
+            sendJson(res, 200, {
+              dryRun: true,
+              resolved: false,
+              reason: resolved.reason,
+              error: resolved.message,
+              ...(Array.isArray(resolved.candidates) && resolved.candidates.length > 0 ? { candidates: resolved.candidates } : {}),
+            })
+            return
+          }
+          sendJson(res, 200, {
+            dryRun: true,
+            resolved: true,
+            wouldDispatch: true,
+            target: { kind: 'session', sessionId: resolved.sessionId, deliver: classified.deliver },
+            ...(resolved.snippet === undefined ? {} : { snippet: resolved.snippet }),
+            ...(resolved.matchedBy === undefined ? {} : { matchedBy: resolved.matchedBy }),
+            ...(resolved.candidates.length > 0 ? { candidates: resolved.candidates } : {}),
+            note: '只解析目标，未投递任何消息',
+          })
+          return
+        }
+        const cwd = normalizeCwd(classified.target.cwd)
+        const lane = normalizeLane(classified.target.lane)
+        sendJson(res, 200, {
+          dryRun: true,
+          resolved: true,
+          wouldDispatch: true,
+          target: { kind: 'worker', cwd, lane },
+          note: '只解析目标，未派活',
+        })
+        return
+      }
       const task = await enqueue(instruction, parsed.history, classified.target, parsed.model, 'task', classified.deliver, classified.notes)
       if (task.status === 'error') {
         sendJson(res, 400, {
           error: task.error,
           reason: task.reason,
+          ...(task.delivered === true ? { delivered: true } : {}),
           ...(Array.isArray(task.candidates) && task.candidates.length > 0 ? { candidates: task.candidates } : {}),
         })
         return
@@ -939,7 +1042,18 @@ export async function apply(ctx) {
             }
           }
         }
-        sendJson(res, 200, { items, hasMore: hits.length > items.length, total: hits.length, matchedBy: found.matchedBy })
+        // 没命中不是死路：给近似候选（同一批只读数据，按相似度 + 最近更新排序），
+        // 让调用方改词重查——而不是发一条消息去"探测命中"。
+        const candidates = hits.length === 0 ? await sessionNearMisses(query, limit) : []
+        sendJson(res, 200, {
+          items,
+          hasMore: hits.length > items.length,
+          total: hits.length,
+          matchedBy: found.matchedBy,
+          ...(candidates.length > 0
+            ? { candidates, reason: REASONS.QUERY_EMPTY, note: '标题/目录里都没有这个关键词；candidates 是按相似度与最近更新排的候选，改词重查或直接用 sessionId' }
+            : {}),
+        })
       } catch (e) {
         sendJson(res, 502, { error: errText(e), reason: mapControllerError(e) })
       }
@@ -1042,6 +1156,8 @@ export async function apply(ctx) {
           taskId: task.taskId, status: task.status, kind: task.kind, cwd: task.cwd, lane: task.lane,
           target: task.target, deliver: task.deliver, instruction: task.instruction.slice(0, 300),
           result: task.result, error: task.error, reason: task.reason, fallback: task.fallback,
+          // delivered=true 表示 prompt 已被会话接受（进了队列）——即便后面报错也不要重发。
+          ...(task.delivered === undefined ? {} : { delivered: task.delivered }),
           ...(task.matchedBy === undefined ? {} : { matchedBy: task.matchedBy }),
           ...(Array.isArray(task.candidates) && task.candidates.length > 0 ? { candidates: task.candidates } : {}),
           ...(record === undefined ? {} : { watcher: record.watcher, sawRunning: record.sawRunning }),
@@ -1143,24 +1259,48 @@ export async function apply(ctx) {
   // ---- 原生工具（宿主全局工具层）----
   ctx.effect(() => ctx.tools.register(defineTool({
     name: 'dsh_collab_send',
-    description: '向 Codex 协作频道发送一条编码指令。默认新建编码子代理在指定工作目录执行;给出 sessionId 或 sessionQuery 时改为投递进那一条已有会话(会话自带的对话与上下文)。指令用中文。',
+    description: '向 Codex 协作频道发送一条编码指令。默认新建编码子代理在指定工作目录执行;给出 sessionId 或 sessionQuery 时改为投递进那一条已有会话(会话自带的对话与上下文)。指令用中文。'
+      + '【硬规则】验证"这条查询会命中哪条会话"必须用 dryRun=true(只解析、不投递);**绝不投递任何消息去试探命中**——那会作为一条真实用户消息落进对方会话并跑成回合,污染对话。'
+      + '【硬规则】返回里 delivered=true 表示消息已被那条会话接受(进了它的队列),即便随后观察到超时或错误也**不要重发**,用 wait=false 记下 taskId 再查状态。'
+      + 'sessionQuery 落空时会返回 candidates(按标题相似度 + 最近更新排序),换词重查或改用 sessionId。',
     parameters: {
       instruction: { type: 'string', required: true, description: '要交给编码子代理执行的指令。' },
       cwd: { type: 'string', description: '工作目录(默认 ' + DEFAULT_WORKSPACE + ')。与 sessionId/sessionQuery 互斥。' },
       lane: { type: 'string', description: '并行通道名(默认 main,同目录不同 lane 并行)。' },
       model: { type: 'string', description: '模型别名: default | fast | pro。' },
       sessionId: { type: 'string', description: '已有会话 id:把指令投递进这条会话,而不是新建。' },
-      sessionQuery: { type: 'string', description: '按标题/内容搜索已有会话(唯一命中才生效,多条会返回候选)。' },
+      sessionQuery: { type: 'string', description: '按标题/内容搜索已有会话(唯一命中才生效,多条或落空会返回候选)。' },
       deliver: { type: 'string', description: "投递方式: queue(默认,排队) 或 steer(插入当前回合)。" },
+      dryRun: { type: 'boolean', description: '为 true 时只解析目标并回显(含 matchedBy 与候选),不投递任何消息——验证命中用它。' },
       wait: { type: 'boolean', description: '为 true 时等待结果(最长 15 分钟)。' },
     },
     output: { schema: { type: 'json' }, render: (_args, value) => [{ type: 'text', text: JSON.stringify(value, null, 2) }] },
     async execute(args) {
       const classified = classifyTarget(args)
       if (!classified.ok) return { ok: false, reason: classified.reason, error: classified.message }
+      // dryRun：只解析目标、回显，不投递。给调用方一条"先验证命中"的正路，免得它发消息试探。
+      if (args.dryRun === true) {
+        if (classified.target.kind === 'session') {
+          const resolved = await resolveSessionTarget(classified.target)
+          if (!resolved.ok) {
+            return { ok: false, dryRun: true, resolved: false, reason: resolved.reason, error: resolved.message, ...(resolved.candidates.length > 0 ? { candidates: resolved.candidates } : {}) }
+          }
+          return {
+            ok: true, dryRun: true, resolved: true,
+            target: { kind: 'session', sessionId: resolved.sessionId, deliver: classified.deliver },
+            ...(resolved.snippet === undefined ? {} : { snippet: resolved.snippet }),
+            ...(resolved.matchedBy === undefined ? {} : { matchedBy: resolved.matchedBy }),
+            ...(resolved.candidates.length > 0 ? { candidates: resolved.candidates } : {}),
+            note: '只解析目标，未投递任何消息',
+          }
+        }
+        const cwd = normalizeCwd(classified.target.cwd)
+        const lane = normalizeLane(classified.target.lane)
+        return { ok: true, dryRun: true, resolved: true, target: { kind: 'worker', cwd, lane }, note: '只解析目标，未派活' }
+      }
       const task = await enqueue(args.instruction, undefined, classified.target, args.model, 'task', classified.deliver, classified.notes)
       if (task.status === 'error') {
-        return { ok: false, taskId: task.taskId, reason: task.reason, error: task.error, ...(task.candidates === undefined ? {} : { candidates: task.candidates }) }
+        return { ok: false, taskId: task.taskId, reason: task.reason, error: task.error, ...(task.delivered === true ? { delivered: true } : {}), ...(task.candidates === undefined ? {} : { candidates: task.candidates }) }
       }
       const brief = { taskId: task.taskId, status: task.status, ...taskResponse(task) }
       if (args.wait !== true || timer === undefined) {
@@ -1171,7 +1311,7 @@ export async function apply(ctx) {
         if (Date.now() - t0 > 900000) return { ...brief, status: task.status, result: task.result, note: 'wait 超时' }
         await timer.timeout(2500)
       }
-      return { ...brief, status: task.status, result: task.result, error: task.error, reason: task.reason }
+      return { ...brief, status: task.status, result: task.result, error: task.error, reason: task.reason, ...(task.delivered === true ? { delivered: true, resend: false } : {}) }
     },
   })))
 

package/harness/session-target.mjs

@@ -232,6 +232,54 @@ export const looksLikeDisabledSearch = (error) => {
   return /search is disabled/i.test(text)
 }
 
+/** 去空白后的字符 bigram 集合（CJK 友好：不需要分词）。 */
+const bigramsOf = (value) => {
+  const text = typeof value === 'string' ? value.replace(/\s+/g, '') : ''
+  const out = new Set()
+  if (text.length === 1) out.add(text)
+  for (let i = 0; i + 1 < text.length; i++) out.add(text.slice(i, i + 2))
+  return out
+}
+
+/** 查询里的 bigram 有多少比例出现在标题里（0..1）。 */
+export const titleSimilarity = (query, title) => {
+  const q = bigramsOf(query)
+  const t = bigramsOf(title)
+  if (q.size === 0 || t.size === 0) return 0
+  let shared = 0
+  for (const gram of q) if (t.has(gram)) shared++
+  return shared / q.size
+}
+
+/**
+ * `session-query-empty` 时给出的"近似候选"。
+ *
+ * 起因是一个真实事故：调用方搜「量化框架」没命中，又**没有别的办法确认标题**，于是
+ * 发了一条占位消息去"探测命中"——那条消息落进了用户自己的会话并跑成回合，污染了
+ * 对话。修法是不给"探测"留动机：查询落空时直接回一批候选标题（同 bigram 相似度排
+ * 序，无相似度的按最近更新补位），调用方靠只读信息就能改词重查。
+ */
+export const rankTitleCandidates = (query, summaries, limit = 5) => {
+  const list = Array.isArray(summaries) ? summaries : []
+  const scored = []
+  for (const summary of list) {
+    if (summary === null || typeof summary !== 'object') continue
+    if (typeof summary.sessionId !== 'string' || summary.sessionId === '') continue
+    const title = typeof summary.title === 'string' && summary.title !== '' ? summary.title : ''
+    const updatedAt = typeof summary.updatedAt === 'number' ? summary.updatedAt : 0
+    scored.push({ sessionId: summary.sessionId, snippet: title, score: titleSimilarity(query, title), updatedAt })
+  }
+  const byRecency = (a, b) => b.updatedAt - a.updatedAt
+  const related = scored.filter((s) => s.score > 0).sort((a, b) => b.score - a.score || byRecency(a, b))
+  const rest = scored.filter((s) => s.score === 0).sort(byRecency)
+  const bound = Math.max(1, Math.min(Number(limit) || 5, MAX_CANDIDATES))
+  return [...related, ...rest].slice(0, bound).map((s) => ({
+    sessionId: s.sessionId,
+    snippet: s.snippet,
+    score: Math.round(s.score * 1000) / 1000,
+  }))
+}
+
 /** 任务在 HTTP 行上的回显：调用方一眼能看出这次是"新建"还是"接进哪个会话"。 */
 export const taskResponse = (task) => {
   const out = { taskId: task.taskId, status: task.status, kind: task.kind }
@@ -246,5 +294,10 @@ export const taskResponse = (task) => {
     out.target = { kind: 'worker', cwd: target.cwd, lane: target.lane }
   }
   if (Array.isArray(task.notes) && task.notes.length > 0) out.notes = task.notes
+  // delivered=true：prompt 已被目标会话接受（进了它的队列）。调用方据此知道
+  // "别重发"——即便随后我们的观察超时并报错，消息也可能正在队列里等着跑。
+  if (task.target !== undefined && task.target !== null && task.target.kind === 'session' && task.delivered === true) {
+    out.delivered = true
+  }
   return out
 }

package/mcp/dsh-mcp.mjs

@@ -6,7 +6,7 @@
 //      客户端（Secure MCP Tunnel / cloudflared）桥接给 ChatGPT 等远程产品。
 const GATEWAY = process.env.DSH_BRIDGE_URL || 'http://127.0.0.1:3080'
 const SERVER_NAME = 'dsh-bridge'
-const SERVER_VERSION = '0.1.6'
+const SERVER_VERSION = '0.1.7'
 const PROTOCOL_VERSION = '2024-11-05'
 
 const log = (...args) => console.error('[dsh-mcp]', ...args)
@@ -20,17 +20,20 @@ const tools = [
       '参数: instruction(必填,完整中文指令:目标/产出目录/验收标准/约束), cwd(工作目录,默认 D:\\Harness,通常传当前项目目录), ' +
       'lane(并行通道名,默认 main), model(fast=deepseek-v4-flash 快而省 / pro=deepseek-v4-pro 质量优先), ' +
       'sessionId(已有会话 id), sessionQuery(按标题/内容搜已有会话,需唯一命中,否则返回候选), deliver(queue=排队(默认) / steer=插入当前回合), ' +
-      'wait(默认 true,阻塞至任务完成并返回 DeepSeek 汇报), timeoutSec(默认 600,最长 900)。',
+      'dryRun(true 时只解析目标并回显, 不投递任何消息), ' +
+      'wait(默认 true,阻塞至任务完成并返回 DeepSeek 汇报), timeoutSec(默认 600,最长 900)。' +
+      '注意: 验证"这条查询会命中哪条会话"必须用 dryRun 或 dsh_sessions——**绝不要投递一条消息去试探**（那会污染用户会话）。',
     inputSchema: {
       type: 'object',
       properties: {
-        instruction: { type: 'string', description: '完整中文编码指令（目标、产出目录、验收标准、约束）。' },
+        instruction: { type: 'string', description: '完整中文编码指令（目标、产出目录、验收标准、约束）。dryRun 时可省略。' },
         cwd: { type: 'string', description: '工作目录（绝对路径）。默认 D:\\Harness。与 sessionId/sessionQuery 互斥。' },
         lane: { type: 'string', description: '并行通道名（默认 main）。' },
         model: { type: 'string', enum: ['fast', 'pro'], description: '模型别名：fast=deepseek-v4-flash，pro=deepseek-v4-pro。' },
         sessionId: { type: 'string', description: '已有会话 id：把指令投递进这条会话，而不是新建子代理。' },
-        sessionQuery: { type: 'string', description: '按标题或内容搜索已有会话；唯一命中才派发，多条会返回 candidates 让你改用 sessionId。' },
+        sessionQuery: { type: 'string', description: '按标题或内容搜索已有会话；唯一命中才派发，多条或落空会返回 candidates 让你改用 sessionId。' },
         deliver: { type: 'string', enum: ['queue', 'steer'], description: '投递方式：queue 排队（默认），steer 插入当前回合。' },
+        dryRun: { type: 'boolean', description: '只解析目标并回显（含命中路径 matchedBy 与候选），不投递任何消息。用来确认命中，替代"发消息探测"。' },
         wait: { type: 'boolean', description: '默认 true：阻塞直到任务完成并返回汇报。' },
         timeoutSec: { type: 'number', description: '最长等待秒数（默认 600，最大 900）。' },
       },
@@ -138,12 +141,19 @@ async function handleToolCall(name, args) {
       sessionId: args.sessionId,
       sessionQuery: args.sessionQuery,
       deliver: args.deliver,
+      dryRun: args.dryRun === true,
     })
+    // dryRun 只解析目标，不产生任务：原样回显给你看命中结果。
+    if (args.dryRun === true) return { ok: task.resolved === true, phase: 'dry-run', ...task }
     // 4xx 拒绝（缺目标 / 会话不存在 / 搜索结果不唯一 / 被写锁占用）不带 taskId，绝不静默新建。
     if (task.taskId === undefined) return { ok: false, phase: 'rejected', ...task }
     if (task.status === 'error') return { ok: false, ...task }
     if (args.wait === false) return { ok: true, phase: 'submitted', ...task }
     const done = await waitTask(task.taskId, args.timeoutSec || 600)
+    // 会话目标报错但 delivered=true：消息已在目标会话队列里，不要重发。
+    if (done.delivered === true && done.status === 'error') {
+      return { ok: false, phase: 'queued-then-failed', resend: false, ...done }
+    }
     return { ok: done.status === 'done', phase: 'finished', ...done }
   }
   if (name === 'dsh_sessions') {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@whaletalk/dsh-codex-collab",
-  "version": "0.1.6",
+  "version": "0.1.7",
   "description": "Codex × DeepSeek Harness 双向编码协作：Codex 主导派活与验收，DeepSeek Harness 编码子代理在共享工作目录执行并回传，独立评审子代理实际跑通构建/测试后出具报告。提供 DSH 宿主网关插件、零依赖 MCP 服务器与 Codex 技能三件套。",
   "license": "MIT",
   "type": "module",