dsh-as-mcp-server 0.0.0-stage → 0.1.2

package/LICENSE

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

package/README.md

@@ -1,3 +1,94 @@
-# Temporary Holding Version
+# dsh-mcp-bridge
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+**Exposes DSH as an MCP server**, so any MCP client can watch what the agent is doing and steer it mid-flight.
+
+Two agents on one workspace normally means two agents overwriting each other. This bridge gives them a shared protocol instead: what the other side is thinking, what it's touching, who owns the floor, and a way to interrupt.
+
+## What the other client gets
+
+| Capability | Mechanism |
+|---|---|
+| **See the agent think** | LLM stream deltas → `notifications/dsh/thinking` (200 ms throttle) |
+| **See what it touches** | tool calls → `notifications/dsh/tool`; `write`/`edit` targets → `notifications/dsh/file` |
+| **Share intent** | `dsh_set_intent` / `dsh_get_intent`, auto-injected into DSH's system prompt every turn |
+| **One writer at a time** | `dsh_lock_acquire` / `dsh_lock_release` floor lock — while held, DSH's `write`/`edit`/`git` are **physically denied** |
+| **Interrupt the current turn** | `dsh_inject_alert` → injected through `agent/pre-step` into the running step |
+| **Delegate a review** | `dsh_review_request` → inbox on disk (`inbox/<id>.json`), result written back to `inbox/done/` |
+
+## The 8 MCP tools
+
+`dsh_get_status` · `dsh_get_intent` · `dsh_set_intent` · `dsh_lock_acquire` · `dsh_lock_release` · `dsh_lock_status` · `dsh_inject_alert` · `dsh_review_request`
+
+## Notifications (server → client, SSE)
+
+`notifications/dsh/status` · `thinking` · `tool` · `file` · `intent` · `lock` · `alert-queued` · `review`
+
+## Install
+
+```sh
+dsh plugin --profile web add dsh-as-mcp-server
+```
+
+Then **add the bridge to your MCP client** — any client speaking Streamable HTTP works (WorkBuddy, Claude Desktop with an MCP-HTTP adapter, Cursor, Cline, …):
+
+```jsonc
+{
+  "mcpServers": {
+    "dsh-bridge": {
+      "type": "streamableHttp",
+      "url": "http://127.0.0.1:51630/mcp",
+      "timeout": 60000
+    }
+  }
+}
+```
+
+Restart DSH. The log should show `[dsh-mcp-bridge] MCP server 就绪: http://127.0.0.1:51630/mcp`.
+
+## Self-test without installing
+
+```sh
+# terminal A — start a demo server on 51999
+node dsh/mcp.js 51999
+
+# terminal B — handshake, all 8 tools, floor lock, SSE stream
+node dsh/mcp-test.js http://127.0.0.1:51999/mcp
+```
+
+Expected: 13 checks pass, ending with `全部通过 ✅`.
+
+There is also a unit-level regression suite that runs with no server:
+
+```sh
+node dsh/bridge-regression.test.mjs   # 13 pass / 0 fail
+```
+
+## Configuration
+
+`~/.dsh-mcp-bridge/config.json` (all optional):
+
+```json
+{
+  "port": 51630,
+  "host": "127.0.0.1",
+  "token": "",
+  "lockTtlMs": 300000,
+  "denyTools": ["write", "edit", "git"],
+  "alertInjection": true,
+  "inboxRoot": ""
+}
+```
+
+`inboxRoot` defaults to `~/.dsh-mcp-bridge/inbox`.
+
+## Honest boundaries
+
+- **Loopback only by default.** Binds `127.0.0.1`; a `token` is supported but empty by default. Do not expose the port.
+- **The lock is enforced on the DSH side only.** While held, DSH's `write`/`edit`/`git` are denied at `tools/pre-execute`. The remote client is trusted to honour the lock by convention — this is a coordination primitive, not a security boundary between mutually hostile parties.
+- **Alert injection is best-effort.** It goes through `agent/pre-step`. If the current step cannot be injected, the alert stays queued and lands on the next step.
+- **One Server + transport per client.** That is an MCP SDK constraint; multiple clients (a recorder and an agent, say) each get their own. A reconnecting client must use a new `sessionId`.
+- **The thinking stream forwards text deltas only**, and tool arguments are truncated to their first 120 characters — this is a visibility channel, not a full transcript tap.
+
+## License
+
+MIT

package/cordis.patch.yml

@@ -0,0 +1,14 @@
+# dsh bundle layer: 把自己挂进配置树。
+# name 必须是本包的包名（package.json 里的 "name"），加载器据此解析模块。
+# config 是初始值；之后可用 ~/.dsh-mcp-bridge/config.json 覆盖，重启不丢。
+- insert:
+    - id: dsh-mcp-bridge
+      name: 'dsh-as-mcp-server'
+      config:
+        port: 51630         # MCP server 端口（避开 50551/51608/51615/62428）
+        host: '127.0.0.1'   # 只监听本机
+        token: ''           # 可选 Bearer token；空 = 本机免鉴权
+        lockTtlMs: 300000   # 地板锁默认有效期（毫秒），防死锁兜底
+        denyTools: ['write', 'edit', 'git']  # 持锁期间拒绝 DSH 的写入工具
+        alertInjection: true  # 提醒是否插进当前轮（false 则只进收件箱）
+        inboxRoot: ''       # 审查/提醒收件箱；空 = ~/.dsh-mcp-bridge/inbox

package/dsh/bridge-regression.test.mjs

@@ -0,0 +1,110 @@
+// dsh/bridge-regression.test.mjs —— 桥插件 2 个已知 bug 的回归测试
+//
+// 背景（复盘分锅 2026-08-22）：
+//   Bug A: systemPrompt 变量名 'MCP 客户端Intent' 违反 cordis 规则 /^[a-z][a-z0-9_]*$/（驼峰）
+//          → 插件加载抛错 → 51630 起不来（连接器崩）
+//   Bug B: llm/stream 监听器写成 async 函数，返回 Promise<AsyncGenerator>
+//          → DSH 内部 yield* 报 "(intermediate value) is not async iterable"（红字崩）
+//
+// 方法：mock ctx 跑真实 apply()（真实插件代码 + 真实 mcp.js/SDK，测试端口 51997）。
+//   正向断言修复后的行为；负向断言旧 bug 形态确实失败（留档）。
+// 运行：node dsh/bridge-regression.test.mjs   （退出码 0=全过）
+
+import { apply } from './index.js'
+
+const CORDIS_VAR_NAME_RULE = /^[a-z][a-z0-9_]*$/
+
+// ---- mock ctx：捕获事件监听与 systemPrompt 注册，并模拟 cordis 变量名校验 ----
+function makeMockCtx() {
+  const captured = { listeners: {}, variable: null }
+  const ctx = {
+    on(name, fn) { captured.listeners[name] = fn },
+    get(name) {
+      if (name === 'systemPrompt') {
+        return {
+          section: () => () => {},
+          variable: (vname, provider) => {
+            // 模拟 cordis 规则：非法名抛错（旧版 'MCP 客户端Intent' 会在这里炸）
+            if (!CORDIS_VAR_NAME_RULE.test(vname)) {
+              throw new Error(`invalid variable name "${vname}" (must match ${CORDIS_VAR_NAME_RULE})`)
+            }
+            captured.variable = { name: vname, provider }
+            return () => {}
+          },
+        }
+      }
+      return undefined
+    },
+    effect(fn) {
+      const disposer = fn()
+      return typeof disposer === 'function' ? disposer : () => {}
+    },
+  }
+  return { ctx, captured }
+}
+
+async function* chunksOf(...items) {
+  for (const it of items) yield it
+}
+
+let passed = 0
+let failed = 0
+function ok(name, cond, extra = '') {
+  if (cond) { passed++; console.log(`  ✅ ${name}${extra ? `（${extra}）` : ''}`) }
+  else { failed++; console.log(`  ❌ ${name}${extra ? `（${extra}）` : ''}`) }
+}
+
+// ---- 单实例：一次 apply（测试端口），全部断言共用同一插件实例 ----
+const { ctx, captured } = makeMockCtx()
+let applyThrew = null
+try {
+  apply(ctx, { port: 51997, host: '127.0.0.1' })
+} catch (e) {
+  applyThrew = e
+}
+
+console.log('=== T1: apply() 正常加载（Bug A 正向回归）===')
+ok('apply 未抛错（变量名已改 snake_case，加载不再崩）', applyThrew === null, applyThrew ? String(applyThrew) : '')
+ok('注册的变量名是 bridge_intent', captured.variable?.name === 'bridge_intent', captured.variable?.name)
+ok('变量名符合 cordis 规则', captured.variable ? CORDIS_VAR_NAME_RULE.test(captured.variable.name) : false)
+
+console.log('=== T2: 旧驼峰名确实违反规则（Bug A 负向留档）===')
+ok('"MCP 客户端Intent" 不匹配规则（当初崩溃的原因）', !CORDIS_VAR_NAME_RULE.test('MCP 客户端Intent'))
+ok('"bridge_intent" 匹配规则', CORDIS_VAR_NAME_RULE.test('bridge_intent'))
+
+console.log('=== T3: 意图 provider 不崩、无意图时返回 undefined ===')
+let value = 'UNSET'
+let providerThrew = null
+try { value = captured.variable.provider() } catch (e) { providerThrew = e }
+ok('provider 可调用且未抛错', providerThrew === null, providerThrew ? String(providerThrew) : '')
+ok('无意图时返回 undefined', value === undefined)
+
+console.log('=== T4: llm/stream 监听器返回可直接迭代的 async iterable（Bug B 正向回归）===')
+const listener = captured.listeners['llm/stream']
+ok('llm/stream 监听器已注册', typeof listener === 'function')
+if (typeof listener !== 'function') process.exit(1)
+const result = listener({}, () => Promise.resolve(chunksOf({ text: 'he' }, { text: 'llo' })))
+ok('返回值不是 Promise（旧 bug 形态）', !(result instanceof Promise))
+ok('返回值是 async iterable', result !== null && typeof result[Symbol.asyncIterator] === 'function')
+const out = []
+for await (const c of result) out.push(c)
+ok('for await 正常消费且 chunk 原样透传', out.length === 2 && out[0]?.text === 'he' && out[1]?.text === 'llo', `透传=${out.map((c) => c.text).join('')}`)
+
+console.log('=== T5: 旧 async 包装形态确实失败（Bug B 负向留档）===')
+const oldBuggy = async (_o, next) => {
+  const inner = await next()
+  return (async function* () { yield* inner })() // ← 旧代码：async 函数返回 Promise<AsyncGenerator>
+}
+const buggyResult = oldBuggy({}, () => Promise.resolve(chunksOf({ text: 'x' })))
+ok('旧形态返回的是 Promise（问题所在）', buggyResult instanceof Promise)
+let iterFailed = false
+try {
+  for await (const _ of buggyResult) { /* 预期抛错 */ }
+} catch {
+  iterFailed = true
+}
+ok('旧形态 for await 必然失败（yield* not async iterable）', iterFailed)
+
+console.log('\n========================================')
+console.log(`回归测试：${passed} 通过 · ${failed} 失败`)
+process.exit(failed === 0 ? 0 : 1)

package/dsh/index.js

@@ -0,0 +1,304 @@
+// dsh-mcp-bridge —— DSH ↔ MCP 实时会诊桥（MCP server 版）
+//
+// 会诊室机制：
+//   思维流    llm/stream 瀑布 → notifications/dsh/thinking   （他实时看到你在想什么）
+//   动作流    tools/result 事件 → notifications/dsh/tool      （在做什么）
+//   文件流    write/edit 工具结果 → notifications/dsh/file    （在对什么进行改动）
+//   状态流    agent/status / agent/error → notifications/dsh/status
+//   共享意图  dsh_get_intent / dsh_set_intent；每轮 system prompt 自动注入 DSH 侧
+//   地板锁    dsh_lock_acquire / release；tools/pre-execute 门禁拒绝持锁方的写入工具
+//   中断提醒  dsh_inject_alert → agent/pre-step 瀑布插进当前轮消息流
+//   审查委托  dsh_review_request → 写入 MCP 客户端-bridge 收件箱（wb_inbox 可接），落盘后实时通知
+//
+// 可拆卸：所有监听 ctx.on、MCP server 生命周期由 ctx.effect 持有，卸载自动清理。
+// 不冲突：工具名 dsh_* 全局唯一；不替换任何既有能力。
+// 安全：默认只监听 127.0.0.1；token 可选；不执行外部传入的命令；锁有过期兜底。
+
+import { homedir } from 'node:os'
+import { join } from 'node:path'
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from 'node:fs'
+import { createMcpBridge, buildBridgeTools } from './mcp.js'
+
+export const name = 'dsh-mcp-bridge'
+export const inject = ['tools']
+
+const STORE_PATH = join(homedir(), '.dsh-mcp-bridge', 'config.json')
+
+function defaults() {
+  return {
+    port: 51630,
+    host: '127.0.0.1',
+    token: '',
+    lockTtlMs: 300000,
+    denyTools: ['write', 'edit', 'git'],
+    alertInjection: true,
+    inboxRoot: '',
+  }
+}
+
+function loadState(patchConfig) {
+  const state = Object.assign(defaults(), patchConfig || {})
+  try {
+    // 兼容编辑器写入的 UTF-8 BOM
+    const saved = JSON.parse(readFileSync(STORE_PATH, 'utf8').replace(/^\uFEFF/, ''))
+    if (saved && typeof saved === 'object') Object.assign(state, saved)
+  } catch {
+    // 无落盘覆盖
+  }
+  return state
+}
+
+function safeStr(v, max) {
+  return typeof v === 'string' ? v.slice(0, max) : ''
+}
+
+export function apply(ctx, config = {}) {
+  const state = loadState(config)
+  const inboxRoot = (state.inboxRoot && String(state.inboxRoot).trim()) || join(homedir(), '.dsh-mcp-bridge', 'inbox')
+
+  // ---- 共享状态（MCP 工具 + 事件共同读写） ----
+  const shared = {
+    status: 'idle',
+    current: '',
+    turn: 0,
+    lastTool: null,
+    problems: [],
+    intent: null,
+    lock: null,
+    alerts: [],
+    seq: 0,
+  }
+
+  let bridge = null
+  const notify = (method, params) => {
+    if (bridge) bridge.notify(method, params)
+  }
+
+  // ---- 收件箱写入（审查委托 / 提醒兜底） ----
+  const ensureInbox = () => mkdirSync(inboxRoot, { recursive: true })
+  const safeId = (s) => String(s).replace(/[^A-Za-z0-9._-]/g, '_')
+
+  const writeInboxAlert = (alert) => {
+    try {
+      ensureInbox()
+      // 按内容幂等：同 severity+message 只落盘一个文件，避免 UUID 每次都新导致收件箱堆积
+      const key = safeId(`${alert.severity}:${alert.message}`)
+      const path = join(inboxRoot, `alert-${key}.json`)
+      if (existsSync(path)) return
+      writeFileSync(path, `${JSON.stringify({
+        id: `alert-${key}`,
+        from: 'mcp-client',
+        type: 'alert',
+        title: `[${alert.severity}] ${alert.message}`,
+        createdAt: alert.at,
+        standards: ['阅读此提醒并酌情处理'],
+      }, null, 2)}\n`)
+    } catch (error) {
+      console.error(`[dsh-mcp-bridge] 提醒落盘失败: ${String(error?.message ?? error)}`)
+    }
+  }
+
+  const writeReviewManifest = (args) => {
+    const id = typeof args.id === 'string' && args.id.trim() ? safeId(args.id) : `review-${Date.now().toString(36)}`
+    const manifest = {
+      id,
+      from: 'mcp-client',
+      type: 'review',
+      title: safeStr(args.title, 300),
+      createdAt: new Date().toISOString(),
+    }
+    if (Array.isArray(args.targets)) manifest.targets = args.targets.map((t) => String(t)).slice(0, 50)
+    if (Array.isArray(args.standards)) manifest.standards = args.standards.map((s) => String(s)).slice(0, 20)
+    if (typeof args.testCmd === 'string' && args.testCmd.trim()) manifest.testCmd = args.testCmd.trim().slice(0, 500)
+    ensureInbox()
+    writeFileSync(join(inboxRoot, `${id}.json`), `${JSON.stringify(manifest, null, 2)}\n`)
+    // H6 修复：实时通知 MCP 客户端「有新审查任务」，无需轮询文件
+    notify('notifications/dsh/review', manifest)
+    return manifest
+  }
+
+  // ---- MCP 工具 ----
+  const tools = buildBridgeTools(shared, { notify, writeInboxAlert, writeReviewManifest }, { lockTtlMs: state.lockTtlMs })
+
+  // ---- 事件监听（全部防御式：异常不外抛，只取叶子字段） ----
+  ctx.on('agent/status', (payload) => {
+    try {
+      const p = payload || {}
+      if (typeof p.status === 'string') {
+        shared.status = p.status === 'running' ? 'working' : 'idle'
+        if (shared.status === 'idle') shared.current = ''
+        notify('notifications/dsh/status', {
+          status: shared.status, current: shared.current, turn: shared.turn,
+        })
+      }
+    } catch (error) {
+      console.error(`[dsh-mcp-bridge] agent/status: ${String(error?.message ?? error)}`)
+    }
+  })
+
+  ctx.on('agent/error', (payload) => {
+    try {
+      const p = payload || {}
+      shared.problems.unshift({
+        at: new Date().toISOString(),
+        message: `第 ${p.turn ?? '?'} 轮出错: ${safeStr(String(p.error ?? 'unknown'), 300)}`,
+      })
+      if (shared.problems.length > 20) shared.problems.length = 20
+      notify('notifications/dsh/status', {
+        status: shared.status, current: shared.current, turn: shared.turn,
+        problems: shared.problems.slice(-3),
+      })
+    } catch (error) {
+      console.error(`[dsh-mcp-bridge] agent/error: ${String(error?.message ?? error)}`)
+    }
+  })
+
+  ctx.on('tools/result', (exec, result) => {
+    try {
+      if (!exec || typeof exec.name !== 'string') return
+      const argHint = (() => {
+        try { return JSON.stringify(exec.arguments ?? null).slice(0, 120) } catch { return '' }
+      })()
+      shared.lastTool = { name: exec.name, argHint }
+      shared.turn += 1
+      const isError = !!(result && result.isError)
+      // 文件改动流：write/edit 这类工具结果即"正在改动的目标"
+      if (exec.name === 'write' || exec.name === 'edit') {
+        notify('notifications/dsh/file', { action: exec.name, argHint, at: new Date().toISOString() })
+      }
+      notify('notifications/dsh/tool', { name: exec.name, argHint, isError, turn: shared.turn })
+      if (isError) {
+        shared.problems.unshift({ at: new Date().toISOString(), message: `工具 ${exec.name} 失败` })
+        if (shared.problems.length > 20) shared.problems.length = 20
+      }
+    } catch (error) {
+      console.error(`[dsh-mcp-bridge] tools/result: ${String(error?.message ?? error)}`)
+    }
+  })
+
+  // 思维流：截获每个流式 chunk，节流转发（绝不阻塞/改写原流）
+  // 注意：llm/stream 事件的中间件必须直接返回 async iterable，不能是 async 函数返回 Promise<AsyncGenerator>，
+  // 否则 DSH 内部 yield* 会报 "(intermediate value) is not async iterable"。
+  ctx.on('llm/stream', (options, next) => {
+    return (async function* forwardStream() {
+      const inner = await next()
+      let buf = ''
+      let lastFlush = Date.now()
+      const flush = () => {
+        if (!buf) return
+        const text = buf
+        buf = ''
+        lastFlush = Date.now()
+        try { notify('notifications/dsh/thinking', { text, at: new Date().toISOString() }) } catch { /* 忽略 */ }
+      }
+      try {
+        for await (const chunk of inner) {
+          let t = ''
+          if (chunk && typeof chunk === 'object') {
+            if (typeof chunk.text === 'string') t = chunk.text
+            else if (typeof chunk.delta === 'string') t = chunk.delta
+            else if (typeof chunk.content === 'string') t = chunk.content
+            else if (chunk.content && Array.isArray(chunk.content)) {
+              t = chunk.content.map((b) => (b && typeof b.text === 'string' ? b.text : '')).join('')
+            }
+          } else if (typeof chunk === 'string') {
+            t = chunk
+          }
+          if (t) {
+            buf += t
+            if (Date.now() - lastFlush >= 200) flush()
+          }
+          yield chunk
+        }
+      } finally {
+        flush()
+      }
+    })()
+  })
+
+  // 地板锁门禁：MCP 客户端持锁期间，拒绝 DSH 的写入工具
+  const denySet = new Set(state.denyTools)
+  ctx.on('tools/pre-execute', async (exec, next) => {
+    try {
+      const locked = shared.lock !== null && shared.lock.expiresAt > Date.now()
+      if (locked && shared.lock.owner !== 'dsh' && exec && typeof exec.name === 'string' && denySet.has(exec.name)) {
+        return {
+          kind: 'deny',
+          reason: `工作区正被 ${shared.lock.owner} 锁定（地板锁），写入工具 ${exec.name} 被拒绝。请等锁释放，或请对方用 dsh_lock_release 释放。`,
+        }
+      }
+    } catch (error) {
+      console.error(`[dsh-mcp-bridge] tools/pre-execute: ${String(error?.message ?? error)}`)
+    }
+    return next()
+  })
+
+  // 中断提醒注入：MCP 客户端 的提醒在下一模型步进入当前轮
+  ctx.on('agent/pre-step', async (payload, next) => {
+    const decision = await next()
+    try {
+      if (decision && decision.kind === 'enter' && shared.alerts.length && Array.isArray(decision.messages)) {
+        const alert = shared.alerts.shift()
+        // 伪装成标准用户消息，避免前端渲染层对 source.kind!=='user' 的消息缺渲染分支而白屏
+        const msg = {
+          id: alert.id, // 直接用 UUID（绝对唯一），去掉 `||` 短路，避免回退到可碰撞的固定 id
+          role: 'user',
+          content: [{ type: 'text', text: `[${alert.severity}] MCP 客户端 实时提醒：${alert.message}` }],
+          source: { kind: 'user', plugin: 'dsh-mcp-bridge', clientTimeZone: 'Asia/Shanghai' },
+        }
+        return { ...decision, messages: [...decision.messages, msg] }
+      }
+    } catch (error) {
+      console.error(`[dsh-mcp-bridge] agent/pre-step: ${String(error?.message ?? error)}`)
+      if (shared.alerts.length) shared.alerts.unshift(shared.alerts.pop())
+    }
+    return decision
+  })
+
+  // ---- 启动 MCP server（effect 持有生命周期） ----
+  let closed = false
+  ctx.effect(() => {
+    createMcpBridge({ tools }, { port: state.port, host: state.host, token: state.token })
+      .then((b) => {
+        if (closed) {
+          b.close().catch(() => {})
+          return
+        }
+        bridge = b
+        console.log(`[dsh-mcp-bridge] MCP server 就绪: ${b.url}（在此接入 MCP 客户端）`)
+        notify('notifications/dsh/status', {
+          status: shared.status, current: '桥已就绪', turn: shared.turn, bridgeUrl: b.url,
+        })
+      })
+      .catch((error) => {
+        console.error(`[dsh-mcp-bridge] MCP server 启动失败: ${String(error?.message ?? error)}`)
+      })
+    return () => {
+      closed = true
+      const b = bridge
+      bridge = null
+      if (b) b.close().catch(() => {})
+    }
+  })
+
+  // ---- 引导段 + 共享意图注入（每轮 system prompt 自动带上，DSH 侧"听得见开会"） ----
+  const sp = ctx.get('systemPrompt')
+  if (sp !== undefined) {
+    ctx.effect(() => sp.section({
+      name: 'tool:dsh-mcp-bridge',
+      order: 103,
+      text: 'MCP 客户端正实时旁观你（MCP 桥）：思考/工具调用/文件改动都会流式可见。'
+        + '若 write/edit/git 被拒绝，说明 MCP 客户端正持地板锁操作工作区——等锁释放或请对方释放后再写。'
+        + 'MCP 客户端的实时提醒会以用户消息直接插进当前轮；审查委托走收件箱（wb_inbox 查收）。',
+    }))
+    // 共享意图注入：每轮 system prompt 自动带上 MCP 客户端 写入的意图（DSH 侧"听得见开会"）
+    ctx.effect(() => sp.variable('bridge_intent', () => {
+      try {
+        if (shared.intent && shared.intent.text) {
+          return `当前共享用户意图（MCP 会诊室）：${shared.intent.text}（by ${shared.intent.by}）`
+        }
+      } catch { /* 忽略 */ }
+      return undefined
+    }))
+  }
+}

package/dsh/mcp-test.js

@@ -0,0 +1,146 @@
+// dsh/mcp-test.js —— 自测客户端：走完 MCP 握手 + 工具调用 + SSE 通知流
+// 用法：node dsh/mcp-test.js [baseUrl]   （默认 http://127.0.0.1:51999/mcp）
+
+const base = process.argv[2] || 'http://127.0.0.1:51999/mcp'
+
+let sessionId = null
+let failures = 0
+const ok = (label, cond, extra = '') => {
+  const mark = cond ? '✅' : '❌'
+  if (!cond) failures++
+  console.log(`${mark} ${label}${cond && extra ? `（${extra}）` : ''}`)
+}
+
+async function post(method, params, id) {
+  const body = { jsonrpc: '2.0', id: id ?? Date.now(), method }
+  if (params !== undefined) body.params = params
+  const res = await fetch(base, {
+    method: 'POST',
+    headers: {
+      'content-type': 'application/json',
+      accept: 'application/json, text/event-stream',
+      ...(sessionId ? { 'mcp-session-id': sessionId } : {}),
+    },
+    body: JSON.stringify(body),
+  })
+  const sid = res.headers.get('mcp-session-id')
+  if (sid) sessionId = sid
+  const text = await res.text()
+  if (res.status !== 200) throw new Error(`HTTP ${res.status}: ${text.slice(0, 300)}`)
+  const isSse = (res.headers.get('content-type') || '').includes('text/event-stream')
+  if (isSse) {
+    const m = text.match(/data:\s*(\{.*\})/s)
+    return m ? JSON.parse(m[1]) : null
+  }
+  return JSON.parse(text)
+}
+
+async function openStreamAndWait(expectMethod, timeoutMs) {
+  const ac = new AbortController()
+  const timer = setTimeout(() => ac.abort(), timeoutMs)
+  try {
+    const res = await fetch(base, {
+      method: 'GET',
+      headers: { accept: 'text/event-stream', ...(sessionId ? { 'mcp-session-id': sessionId } : {}) },
+      signal: ac.signal,
+    })
+    const reader = res.body.getReader()
+    const decoder = new TextDecoder()
+    let buf = ''
+    while (true) {
+      const { done, value } = await reader.read()
+      if (done) break
+      buf += decoder.decode(value, { stream: true })
+      const lines = buf.split('\n')
+      buf = lines.pop()
+      for (const line of lines) {
+        const m = line.match(/^data:\s*(\{.*\})/)
+        if (!m) continue
+        try {
+          const evt = JSON.parse(m[1])
+          if (evt.method === expectMethod) {
+            clearTimeout(timer)
+            ac.abort()
+            return evt
+          }
+        } catch { /* 忽略坏行 */ }
+      }
+    }
+    return null
+  } finally {
+    clearTimeout(timer)
+  }
+}
+
+async function main() {
+  // 1. 握手
+  const init = await post('initialize', {
+    protocolVersion: '2024-11-05',
+    capabilities: {},
+    clientInfo: { name: 'dsh-mcp-test', version: '1.0.0' },
+  })
+  ok('initialize', init && init.result && !!init.result.serverInfo, `server=${init.result?.serverInfo?.name}`)
+  await post('notifications/initialized')
+
+  // 2. 工具列表
+  const list = await post('tools/list')
+  const names = (list?.result?.tools || []).map((t) => t.name)
+  ok('tools/list 含全部 8 个工具', ['dsh_get_status','dsh_get_intent','dsh_set_intent','dsh_lock_acquire','dsh_lock_release','dsh_lock_status','dsh_inject_alert','dsh_review_request'].every((n) => names.includes(n)), names.join(','))
+
+  const call = async (name, args) => {
+    const r = await post('tools/call', { name, arguments: args || {} })
+    const text = r?.result?.content?.[0]?.text || ''
+    let parsed = null
+    try { parsed = JSON.parse(text) } catch { /* 非 JSON */ }
+    return { raw: r, text, parsed }
+  }
+
+  // 3. get_status
+  let c = await call('dsh_get_status')
+  ok('dsh_get_status', c.parsed && typeof c.parsed.status === 'string')
+
+  // 4. set_intent（触发通知）
+  c = await call('dsh_set_intent', { text: '测试共享意图：双方围绕 X 协作', by: 'test-client' })
+  ok('dsh_set_intent', c.parsed && c.parsed.ok === true && c.parsed.intent.text.includes('测试共享意图'))
+
+  // 5. get_intent
+  c = await call('dsh_get_intent')
+  ok('dsh_get_intent', c.parsed && c.parsed.intent && c.parsed.intent.by === 'test-client')
+
+  // 6. 地板锁：获取 → 状态 → 冲突拒绝 → 释放
+  c = await call('dsh_lock_acquire', { owner: 'mcp-client', ttlMs: 60000 })
+  ok('dsh_lock_acquire', c.parsed && c.parsed.ok === true && c.parsed.lock.owner === 'mcp-client')
+  c = await call('dsh_lock_acquire', { owner: 'other' })
+  ok('锁冲突被拒', c.parsed && c.parsed.ok === false)
+  c = await call('dsh_lock_status')
+  ok('dsh_lock_status 持锁', c.parsed && c.parsed.held === true)
+  c = await call('dsh_lock_release', { owner: 'mcp-client' })
+  ok('dsh_lock_release', c.parsed && c.parsed.ok === true)
+  c = await call('dsh_lock_status')
+  ok('释放后未持锁', c.parsed && c.parsed.held === false)
+
+  // 7. inject_alert
+  c = await call('dsh_inject_alert', { message: '测试实时提醒', severity: 'warning' })
+  ok('dsh_inject_alert', c.parsed && c.parsed.ok === true && c.parsed.queued >= 1)
+
+  // 8. review_request
+  c = await call('dsh_review_request', { title: '审查测试文件', targets: ['F:/test/a.js'], standards: ['无密钥'] })
+  ok('dsh_review_request', c.parsed && c.parsed.ok === true && !!c.parsed.manifest.id)
+
+  // 9. SSE 通知流：开流 → 并行触发 set_intent → 应收 notifications/dsh/intent
+  const trigger = (async () => {
+    await new Promise((r) => setTimeout(r, 200))
+    await call('dsh_set_intent', { text: 'SSE 测试意图' })
+  })()
+  const evt = await openStreamAndWait('notifications/dsh/intent', 5000)
+  await trigger
+  ok('SSE 通知流收到 notifications/dsh/intent', !!evt && !!evt.params && String(evt.params.text).includes('SSE 测试'))
+
+  console.log(failures === 0 ? '\n全部通过 ✅' : `\n${failures} 项失败 ❌`)
+  process.exit(failures === 0 ? 0 : 1)
+}
+
+main().catch((error) => {
+  console.error('测试失败:', error.message)
+  process.exit(1)
+})

package/dsh/mcp.js

@@ -0,0 +1,318 @@
+// dsh/mcp.js —— DSH ↔ MCP 实时会诊桥的 MCP server（Streamable HTTP，多会话：支持记录器 + MCP 客户端 并存）
+//
+// 对外暴露工具（MCP 客户端调）：
+//   dsh_get_status / dsh_get_intent / dsh_set_intent      —— 实时状态 + 共享用户意图（开会）
+//   dsh_lock_acquire / dsh_lock_release / dsh_lock_status —— 地板锁（单位时间只许一个智能体动工作区）
+//   dsh_inject_alert                                       —— 中断提醒（插进 DSH 正在进行的这一轮）
+//   dsh_review_request                                     —— 审查委托（写入收件箱，wb_inbox 可接）
+//
+// 事件通知（server → client，实时流）：
+//   notifications/dsh/status  notifications/dsh/tool  notifications/dsh/file
+//   notifications/dsh/thinking  notifications/dsh/intent  notifications/dsh/lock
+//   notifications/dsh/alert-queued  notifications/dsh/review
+//
+// 多会话实现要点（实测修复）：
+//   SDK 的 Server 只能 connect 一个 transport，且单个 StreamableHTTPServerTransport 只服务一个会话，
+//   所以「每会话独立 Server+transport」才支持多个客户端并存；notify 遍历所有会话广播。
+//   客户端重连必须换新 sessionId（旧 id 会 400 死循环）。
+//
+// 零第三方依赖：SDK 由插件 node_modules junction 提供；支持 node dsh/mcp.js [port] 独立自测。
+
+import { randomUUID } from 'node:crypto'
+import { createServer } from 'node:http'
+import { resolve } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { Server } from '@modelcontextprotocol/sdk/server/index.js'
+import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js'
+import {
+  ListToolsRequestSchema,
+  CallToolRequestSchema,
+  McpError,
+  ErrorCode,
+} from '@modelcontextprotocol/sdk/types.js'
+
+export function buildBridgeTools(shared, hooks, opts = {}) {
+  const lockTtlMs = Number.isFinite(opts.lockTtlMs) ? opts.lockTtlMs : 300000
+  const { notify, writeInboxAlert, writeReviewManifest } = hooks
+  const lockValid = () => shared.lock !== null && shared.lock.expiresAt > Date.now()
+  const getStatus = () => ({
+    status: shared.status,
+    current: shared.current,
+    turn: shared.turn,
+    lastTool: shared.lastTool,
+    problems: (shared.problems || []).slice(-10),
+    intent: shared.intent,
+    lock: lockValid() ? shared.lock : null,
+    alertQueue: (shared.alerts || []).length,
+  })
+  return {
+    dsh_get_status: {
+      name: 'dsh_get_status',
+      description: '读取 DSH 当前实时状态：status/current/turn/lastTool/problems/intent/lock/alertQueue',
+      properties: {},
+      required: [],
+      async execute() { return getStatus() },
+    },
+    dsh_get_intent: {
+      name: 'dsh_get_intent',
+      description: '读取共享用户意图（会议议程）：双方实时读到同一份 { text, by, at }',
+      properties: {},
+      required: [],
+      async execute() { return { intent: shared.intent } },
+    },
+    dsh_set_intent: {
+      name: 'dsh_set_intent',
+      description: '写入/更新共享用户意图（如「用户要 X，请双方围绕 X 配合」）。text 必填，by 标识写入方',
+      properties: {
+        text: { type: 'string', description: '意图内容（≤2000 字）' },
+        by: { type: 'string', description: '写入方标识，默认 MCP 客户端' },
+      },
+      required: ['text'],
+      async execute(args) {
+        shared.intent = {
+          text: String(args.text).slice(0, 2000),
+          by: typeof args.by === 'string' && args.by.trim() ? args.by.slice(0, 50) : 'mcp-client',
+          at: new Date().toISOString(),
+        }
+        notify('notifications/dsh/intent', shared.intent)
+        return { ok: true, intent: shared.intent }
+      },
+    },
+    dsh_lock_acquire: {
+      name: 'dsh_lock_acquire',
+      description: '获取地板锁：持锁期间 DSH 的写入工具（write/edit/git）会被拒绝，实现单位时间单智能体动工作区',
+      properties: {
+        owner: { type: 'string', description: '持锁方标识，如 MCP 客户端 或 dsh' },
+        ttlMs: { type: 'number', description: '锁有效期（毫秒），默认 300000' },
+      },
+      required: ['owner'],
+      async execute(args) {
+        // H4 修复：owner 消毒——缺省/空串直接报错，避免变成字符串 "undefined" 导致释放比对 mismatch
+        const ownerRaw = args && typeof args.owner === 'string' ? args.owner.trim() : ''
+        if (!ownerRaw) throw new Error('dsh_lock_acquire: owner 必填（如 MCP 客户端 或 dsh）')
+        const owner = ownerRaw.slice(0, 50)
+        if (lockValid() && shared.lock.owner !== owner) {
+          return { ok: false, reason: `工作区已被 ${shared.lock.owner} 锁定`, lock: shared.lock }
+        }
+        shared.lock = {
+          owner,
+          at: new Date().toISOString(),
+          expiresAt: Date.now() + (Number(args.ttlMs) > 0 ? Number(args.ttlMs) : lockTtlMs),
+        }
+        notify('notifications/dsh/lock', shared.lock)
+        return { ok: true, lock: shared.lock }
+      },
+    },
+    dsh_lock_release: {
+      name: 'dsh_lock_release',
+      description: '释放地板锁（仅持锁方自己可释放；锁有过期时间兜底）',
+      properties: {
+        owner: { type: 'string', description: '持锁方标识' },
+      },
+      required: ['owner'],
+      async execute(args) {
+        const ownerRaw = args && typeof args.owner === 'string' ? args.owner.trim() : ''
+        if (!ownerRaw) throw new Error('dsh_lock_release: owner 必填')
+        const owner = ownerRaw.slice(0, 50)
+        if (!lockValid()) return { ok: false, reason: '锁未被持有（可能已过期）' }
+        if (shared.lock.owner !== owner) {
+          return { ok: false, reason: `只有持锁方 ${shared.lock.owner} 能释放` }
+        }
+        shared.lock = null
+        notify('notifications/dsh/lock', null)
+        return { ok: true }
+      },
+    },
+    dsh_lock_status: {
+      name: 'dsh_lock_status',
+      description: '查看地板锁当前状态',
+      properties: {},
+      required: [],
+      async execute() { return { held: lockValid(), lock: shared.lock } },
+    },
+    dsh_inject_alert: {
+      name: 'dsh_inject_alert',
+      description: '向 DSH 当前正在进行的这一轮注入提醒（经 pre-step 瀑布插进消息流）。若注入被禁用则写入收件箱',
+      properties: {
+        message: { type: 'string', description: '提醒内容（≤1000 字）' },
+        severity: { type: 'string', enum: ['info', 'warning', 'error'], description: '级别，默认 info' },
+      },
+      required: ['message'],
+      async execute(args) {
+        const message = String(args.message).slice(0, 1000)
+        const severity = args.severity || 'info'
+        // 幂等：同 message+severity 已在未消费队列则跳过，避免同一提醒反复刷屏
+        // （呼应 8/22 复盘「不要重复投递同一 alert」）
+        const existing = shared.alerts.find((a) => a.message === message && a.severity === severity)
+        if (existing) {
+          notify('notifications/dsh/alert-queued', existing)
+          return { ok: true, alert: existing, queued: shared.alerts.length, deduplicated: true }
+        }
+        const alert = {
+          id: randomUUID(), // 全局唯一，跨重启不撞历史 id，根治 alert-1 撞车
+          message,
+          severity,
+          at: new Date().toISOString(),
+        }
+        shared.alerts.push(alert)
+        notify('notifications/dsh/alert-queued', alert)
+        if (typeof writeInboxAlert === 'function') writeInboxAlert(alert)
+        return { ok: true, alert, queued: shared.alerts.length }
+      },
+    },
+    dsh_review_request: {
+      name: 'dsh_review_request',
+      description: '委托审查：写入收件箱（inbox/<id>.json），DSH 的 wb_inbox 工具会在下一轮领走并按 standards 审查 targets，结果回写 inbox/done/',
+      properties: {
+        id: { type: 'string', description: '任务编号（可选，缺省自动生成）' },
+        title: { type: 'string', description: '审查标题（必填）' },
+        targets: { type: 'array', items: { type: 'string' }, description: '要审查的文件路径列表' },
+        standards: { type: 'array', items: { type: 'string' }, description: '审查标准列表' },
+        testCmd: { type: 'string', description: '建议测试命令（DSH 不替你执行）' },
+      },
+      required: ['title'],
+      async execute(args) {
+        const manifest = writeReviewManifest(args)
+        return { ok: true, manifest }
+      },
+    },
+  }
+}
+
+export async function createMcpBridge(handlers, opts = {}, onReady) {
+  const { port = 51630, host = '127.0.0.1', token = '' } = opts
+
+  const sessions = new Map() // sessionId -> { server, transport }
+
+  const buildServer = () => {
+    const server = new Server(
+      { name: 'dsh-mcp-bridge', version: '0.1.1' },
+      { capabilities: { tools: {} } },
+    )
+    server.setRequestHandler(ListToolsRequestSchema, async () => ({
+      tools: Object.values(handlers.tools).map((t) => ({
+        name: t.name,
+        description: t.description || '',
+        inputSchema: {
+          type: 'object',
+          properties: t.properties || {},
+          required: t.required || [],
+        },
+      })),
+    }))
+    server.setRequestHandler(CallToolRequestSchema, async (request) => {
+      const tool = handlers.tools[request.params.name]
+      if (!tool) throw new McpError(ErrorCode.MethodNotFound, `Unknown tool: ${request.params.name}`)
+      try {
+        const result = await tool.execute(request.params.arguments ?? {})
+        const text = typeof result === 'string' ? result : JSON.stringify(result, null, 2)
+        return { content: [{ type: 'text', text }] }
+      } catch (error) {
+        return {
+          content: [{ type: 'text', text: `错误: ${String(error?.message ?? error)}` }],
+          isError: true,
+        }
+      }
+    })
+    return server
+  }
+
+  const httpServer = createServer(async (req, res) => {
+    if (token) {
+      const auth = req.headers.authorization || ''
+      if (auth !== `Bearer ${token}`) {
+        res.writeHead(401, { 'content-type': 'application/json' })
+        res.end(JSON.stringify({ error: 'unauthorized' }))
+        return
+      }
+    }
+
+    const sessionId = req.headers['mcp-session-id']
+    const method = (req.method || '').toUpperCase()
+
+    // 已有会话 → 复用其 transport（POST/GET/DELETE 统一走这里）
+    if (sessionId && sessions.has(sessionId)) {
+      sessions.get(sessionId).transport.handleRequest(req, res).catch((error) => {
+        console.error(`[dsh-mcp-bridge] 请求处理失败: ${String(error?.message ?? error)}`)
+        if (!res.headersSent) {
+          res.writeHead(500, { 'content-type': 'text/plain' })
+          res.end('internal error')
+        }
+      })
+      return
+    }
+
+    // 新会话：仅允许通过 POST 的 initialize 建立 → 新建独立 Server + transport
+    if (!sessionId && method === 'POST') {
+      const server = buildServer()
+      const transport = new StreamableHTTPServerTransport({
+        sessionIdGenerator: () => randomUUID(),
+        onsessioninitialized: (sid) => sessions.set(sid, { server, transport }),
+      })
+      transport.onclose = () => { sessions.delete(transport.sessionId) }
+      await server.connect(transport)
+      transport.handleRequest(req, res).catch((error) => {
+        console.error(`[dsh-mcp-bridge] 新会话处理失败: ${String(error?.message ?? error)}`)
+        if (!res.headersSent) {
+          res.writeHead(500, { 'content-type': 'text/plain' })
+          res.end('internal error')
+        }
+      })
+      return
+    }
+
+    // 无会话且无 initialize → 拒绝
+    res.writeHead(400, { 'content-type': 'application/json' })
+    res.end(JSON.stringify({
+      jsonrpc: '2.0',
+      error: { code: -32000, message: 'Bad Request: unknown or missing Mcp-Session-Id' },
+      id: null,
+    }))
+  })
+
+  await new Promise((resolveListen, reject) => {
+    httpServer.once('error', reject)
+    httpServer.listen(port, host, resolveListen)
+  })
+
+  const bridge = {
+    url: `http://${host}:${port}/mcp`,
+    notify(method, params) {
+      for (const { server } of sessions.values()) {
+        try { server.notification({ method, params }) } catch { /* 该会话已无流时忽略 */ }
+      }
+    },
+    async close() {
+      for (const { transport } of sessions.values()) {
+        try { await transport.close() } catch { /* 已关闭 */ }
+      }
+      await new Promise((r) => httpServer.close(r))
+    },
+  }
+  if (typeof onReady === 'function') onReady(bridge)
+  return bridge
+}
+
+// ---- 独立自测模式：node dsh/mcp.js [port] ----
+const isCli = process.argv[1] && resolve(process.argv[1]) === fileURLToPath(import.meta.url)
+if (isCli) {
+  const port = Number(process.argv[2] || 51999)
+  const shared = {
+    status: 'working', current: '演示模式', turn: 0, lastTool: null,
+    problems: [], intent: null, lock: null, alerts: [], seq: 0,
+  }
+  let emit = () => {}
+  const tools = buildBridgeTools(shared, {
+    notify: (m, p) => emit(m, p),
+    writeInboxAlert: (alert) => { console.log(`[demo] 提醒入队: ${alert.message}`) },
+    writeReviewManifest: (args) => ({ ...args, id: args.id || 'demo-review', note: 'demo 模式不落盘' }),
+  })
+  createMcpBridge({ tools }, { port, host: '127.0.0.1' }, (b) => {
+    emit = b.notify
+    console.log(`[demo] MCP bridge 就绪: ${b.url}`)
+    console.log(`[demo] 用 node dsh/mcp-test.js ${b.url} 自测`)
+  }).catch((error) => {
+    console.error('启动失败:', error)
+    process.exit(1)
+  })
+}

package/package.json

@@ -1,6 +1,55 @@
 {
   "name": "dsh-as-mcp-server",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.2",
+  "description": "Exposes DSH as an MCP server over Streamable HTTP: streaming thinking/tool/file notifications, shared intent, a floor lock that physically denies DSH writes while held, mid-turn alert injection, and review delegation.",
+  "type": "module",
+  "main": "./dsh/index.js",
+  "keywords": [
+    "dsh",
+    "dsh-plugin",
+    "mcp",
+    "mcp-server",
+    "deepseek-harness",
+    "streamable-http",
+    "cordis"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/qian-dsh/dsh-as-mcp-server.git"
+  },
+  "homepage": "https://github.com/qian-dsh/dsh-as-mcp-server#readme",
+  "engines": {
+    "node": ">=22.19"
+  },
+  "files": [
+    "dsh",
+    "cordis.patch.yml",
+    "README.md",
+    "LICENSE"
+  ],
+  "exports": {
+    ".": "./dsh/index.js",
+    "./dsh": "./dsh/index.js",
+    "./package.json": "./package.json"
+  },
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    }
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.30.0"
+  },
+  "peerDependencies": {
+    "@deepseek-ai/cordis": "^4.0.1"
+  },
+  "peerDependenciesMeta": {
+    "@deepseek-ai/cordis": {
+      "optional": true
+    }
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/"
+  }
+}