deskbuddy 0.2.0-beta.13 → 0.2.0-beta.14

package/dist/opencode.mjs

@@ -21,8 +21,13 @@
 // 🔴 窗口模式反过来：任何失败都不表态，授权框照常由人处理。
 
 import { spawn } from 'node:child_process'
+import { appendFileSync } from 'node:fs'
 import { dirname, join } from 'node:path'
 import { fileURLToPath } from 'node:url'
+import { alwaysSuggestions, askToCc, isPlainQuestion, questionToCc, rememberTitle, toCcTool } from './ocTranslate.mjs'
+
+// 翻译函数搬到了 ocTranslate.mjs（与 DumateWatch 共用），这里转出去保持原来的导出
+export { alwaysSuggestions, askToCc, isPlainQuestion, questionToCc, rememberTitle, toCcTool }
 
 const HERE = dirname(fileURLToPath(import.meta.url))
 const HOOK = join(HERE, 'hook.cjs')
@@ -62,63 +67,6 @@ export function isHeadless(argv = process.argv) {
   return (end >= 0 ? args.slice(0, end) : args).includes('run')
 }
 
-/** opencode 工具 → cc-hook 同构的 tool_name / tool_input（daemon 的 classify 按 Claude Code 的工具名判断） */
-export function toCcTool(tool, args) {
-  const a = args && typeof args === 'object' ? args : {}
-  const s = (v) => (typeof v === 'string' ? v : '')
-  switch (tool) {
-    case 'bash':
-      return { tool_name: 'Bash', tool_input: { command: s(a.command) } }
-    case 'read':
-      return { tool_name: 'Read', tool_input: { file_path: s(a.filePath) } }
-    case 'edit':
-      return { tool_name: 'Edit', tool_input: { file_path: s(a.filePath) } }
-    case 'write':
-      return { tool_name: 'Write', tool_input: { file_path: s(a.filePath) } }
-    case 'glob':
-      return { tool_name: 'Glob', tool_input: { pattern: s(a.pattern), path: s(a.path) } }
-    case 'grep':
-      return { tool_name: 'Grep', tool_input: { pattern: s(a.pattern), path: s(a.path) } }
-    case 'list':
-      return { tool_name: 'LS', tool_input: { path: s(a.path) } }
-    case 'webfetch':
-      return { tool_name: 'WebFetch', tool_input: { url: s(a.url) } }
-    case 'task':
-      return { tool_name: 'Task', tool_input: {} }
-    case 'todowrite':
-    case 'todoread':
-      return { tool_name: 'TodoWrite', tool_input: {} }
-    case 'patch':
-    case 'apply_patch':
-      return { tool_name: 'apply_patch', tool_input: { patch: s(a.patchText) || s(a.patch) || s(a.input) } }
-    default:
-      // 不认识的工具（MCP 等）原名原参数交出去：classify 对不认识的一律推设备
-      return { tool_name: String(tool || ''), tool_input: a }
-  }
-}
-
-/** permission.asked → PermissionRequest 的 tool_name / tool_input，给设备卡片生成摘要 */
-export function askToCc(props) {
-  const md = (props && props.metadata) || {}
-  if (typeof md.command === 'string' && md.command) return { tool_name: 'Bash', tool_input: { command: md.command } }
-  const file = md.filepath || md.filePath
-  if (typeof file === 'string' && file) return { tool_name: 'Edit', tool_input: { file_path: file } }
-  const patterns = Array.isArray(props && props.patterns) ? props.patterns.join(' ') : ''
-  return { tool_name: String((props && props.permission) || 'permission'), tool_input: { path: patterns } }
-}
-
-/**
- * 授权请求里 opencode 自己给的「以后都允许」模式（permission.asked 的 always，如 bash 的 `npm *`、edit 的 `*`）
- * → 一条 session 级 addRules 建议（与 Claude Code 的 permission_suggestions 同形），daemon 据此在设备上给「允许并记住」。
- * 设备选了记住，gate 输出带 updatedPermissions，插件回 always（opencode 在本次运行期间记住这些模式）。没有 always 返回 undefined
- */
-export function alwaysSuggestions(props) {
-  const perm = String((props && props.permission) || '').trim()
-  const always = props && Array.isArray(props.always) ? props.always.filter((x) => typeof x === 'string' && x.trim() !== '') : []
-  if (!perm || always.length === 0) return undefined
-  return [{ type: 'addRules', rules: always.map((x) => ({ toolName: perm, ruleContent: `${perm} ${x.trim()}` })), behavior: 'allow', destination: 'session' }]
-}
-
 /**
  * 远程模式：关卡改由 tool.execute.before 把，放开权限。🔴 必须原地改（整对象替换不生效，O8）。
  * - OC_GATED_KEYS 是 daemon 压成 deny 的，放成 allow（用户原来在这些键上写的值已被覆盖，找不回来 —— 每一步都要过设备）
@@ -184,17 +132,6 @@ export function injectAppended(output, raw) {
   return o && typeof o.systemMessage === 'string' ? o.systemMessage : ''
 }
 
-/** opencode 起标题前的占位名（1.18.32 isDefaultTitle：`New session - ` / `Child session - ` + ISO 时间），不当标题 */
-const OC_DEFAULT_TITLE_RE = /^(New session - |Child session - )\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/
-
-/** session.updated 的 info → 记下自动标题。子会话（subagent，带 parentID）、占位名不记 */
-export function rememberTitle(titles, info) {
-  if (!info || typeof info.id !== 'string' || !info.id || info.parentID) return
-  const t = typeof info.title === 'string' ? info.title.trim() : ''
-  if (!t || OC_DEFAULT_TITLE_RE.test(t)) return
-  titles.set(info.id, t.slice(0, 100))
-}
-
 /** 活着的子进程；opencode 退出时一并结束，不留孤儿 gate 挂着设备卡片（评审） */
 const LIVE = new Set()
 process.on('exit', () => {
@@ -238,7 +175,18 @@ function startChild(node, script, args, input, killMs = 0) {
 
 const runChild = (node, script, args, input, killMs) => startChild(node, script, args, input, killMs).done
 
+/**
+ * 跑在百度搭子（DuMate，内核是改名的 opencode：dumate-opencode）里。那边的会话由 daemon 的 DumateWatch 直连 HTTP 上报和推卡，
+ * 插件再报一遍就是 tool=opencode 的第二份会话 + 双卡（spec 2026-10-03 §3.2「防双卡」）
+ */
+export function isDumateHost(env = process.env, execPath = process.execPath) {
+  return !!(env && env.DUMATE_INAPP_KEY) || /dumate-opencode/i.test(String(execPath || ''))
+}
+
 export function make(opts = {}) {
+  if (isDumateHost(opts.env, opts.execPath)) return async function DeskBuddyOff() {
+    return {}
+  }
   return async function DeskBuddy(ctx) {
     const node = process.env.DESKBUDDY_NODE || opts.node || 'node'
     const client = ctx && ctx.client
@@ -325,6 +273,82 @@ export function make(opts = {}) {
       if (typeof out.systemMessage === 'string' && out.systemMessage) await toast(out.systemMessage)
     }
 
+    // ---- 选择题（question.asked）：推设备作答，答案经 /question/{id}/reply 回填；设备跳过 → reject ----
+    const pendingQ = new Map() // requestID → gate 子进程
+    const debugLog = (line) => {
+      try {
+        appendFileSync(join(HERE, 'hook-debug.log'), `${new Date().toISOString()} [opencode] ${line}\n`, 'utf8')
+      } catch (_) {
+        /* 记不下不影响 */
+      }
+    }
+    /** 返回是否成功（hey-api 客户端不抛错，失败在返回值的 error / response.status 里） */
+    const postRaw = async (url, path, body) => {
+      // 插件拿到的是 v1 SDK 客户端，没有 question 的方法：用它底下的 HTTP 客户端直接打（路径参数由客户端填）
+      const http = client && (client._client || client.client)
+      if (!http || typeof http.post !== 'function') {
+        debugLog(`回填选择题失败：客户端没有 post（${url}）`)
+        return false
+      }
+      try {
+        const r = await http.post({ url, path, ...(body ? { body, headers: { 'Content-Type': 'application/json' } } : {}) })
+        const status = r && r.response && typeof r.response.status === 'number' ? r.response.status : 0
+        if ((r && r.error) || status >= 400) {
+          debugLog(`回填选择题失败：${url} status=${status || '?'}`)
+          return false
+        }
+        return true
+      } catch (e) {
+        debugLog(`回填选择题出错：${url} ${(e && e.message) || e}`)
+        return false
+      }
+    }
+    const onQuestion = async (p) => {
+      const { id, sessionID } = p || {}
+      if (!id || !sessionID || runId || headless || !client) return
+      const call = p.tool && p.tool.callID ? calls.get(p.tool.callID) : null
+      if (!isPlainQuestion(p, call && call.tool)) return
+      const cc = questionToCc(p)
+      if (!cc) return
+      const input = { hook_event_name: 'PermissionRequest', session_id: sessionID, cwd, ...cc }
+      const { child, done } = startChild(node, GATE, ['--window', '--tool', TOOL], input)
+      if (child) pendingQ.set(id, child)
+      const r = await done
+      pendingQ.delete(id)
+      if (r.code !== 0 || !r.out) return
+      let out
+      try {
+        out = JSON.parse(r.out)
+      } catch (_) {
+        return
+      }
+      const d = out && out.hookSpecificOutput && out.hookSpecificOutput.decision
+      if (!d) return
+      let ok
+      if (d.behavior === 'allow' && Array.isArray(out.deskbuddyAnswers)) {
+        ok = await postRaw('/question/{requestID}/reply', { requestID: id }, { answers: out.deskbuddyAnswers })
+      } else if (d.behavior === 'deny') {
+        ok = await postRaw('/question/{requestID}/reject', { requestID: id })
+      } else return
+      if (!ok) {
+        await toast('设备答案未能回填，请在窗口作答')
+        return
+      }
+      if (typeof out.systemMessage === 'string' && out.systemMessage) await toast(out.systemMessage)
+    }
+    const onQuestionDone = (p) => {
+      // 人先在窗口里答了 / 拒了：结束 gate 子进程，daemon 随之撤掉设备上的卡片
+      const child = p && pendingQ.get(p.requestID)
+      if (child) {
+        pendingQ.delete(p.requestID)
+        try {
+          child.kill('SIGTERM')
+        } catch (_) {
+          /* 已经退了 */
+        }
+      }
+    }
+
     const onReplied = (p) => {
       // 人先在窗口里答了：结束 gate 子进程，daemon 随之撤掉设备上的卡片
       const child = p && pending.get(p.requestID)
@@ -362,7 +386,7 @@ export function make(opts = {}) {
 
       'tool.execute.before': async (input, output) => {
         const cc = toCcTool(input && input.tool, output && output.args)
-        if (input && input.callID) calls.set(input.callID, { cc, at: Date.now() })
+        if (input && input.callID) calls.set(input.callID, { cc, tool: input && input.tool, at: Date.now() })
         report('PreToolUse', input && input.sessionID, cc)
         if (!runId) return
         // 远程关卡：等设备。任何失败都拒（见顶部）
@@ -398,6 +422,13 @@ export function make(opts = {}) {
           case 'permission.replied':
             onReplied(p)
             break
+          case 'question.asked':
+            onQuestion(p).catch(() => {})
+            break
+          case 'question.replied':
+          case 'question.rejected':
+            onQuestionDone(p)
+            break
           case 'session.idle':
             report('Stop', p.sessionID)
             break

package/hook/gate.cjs

@@ -213,13 +213,16 @@ async function windowMain() {
   if (res.status !== 200) return fail()
   const out = JSON.parse(res.data)
   if (!out || (out.decision !== 'allow' && out.decision !== 'deny')) return fail()
-  const decision =
-    out.decision === 'allow'
-      ? Array.isArray(out.updatedPermissions) && out.updatedPermissions.length > 0
-        ? { behavior: 'allow', updatedPermissions: out.updatedPermissions }
-        : { behavior: 'allow' }
-      : { behavior: 'deny', message: (typeof out.reason === 'string' && out.reason) || '用户在设备上拒绝了这一步' }
+  let decision
+  if (out.decision === 'allow') {
+    decision = { behavior: 'allow' }
+    // 选择题作答（设备答选择题 spec §3.4）：daemon 用本地原始 tool_input 按下标拼好的，原样交回
+    if (out.updatedInput && typeof out.updatedInput === 'object' && !Array.isArray(out.updatedInput)) decision.updatedInput = out.updatedInput
+    if (Array.isArray(out.updatedPermissions) && out.updatedPermissions.length > 0) decision.updatedPermissions = out.updatedPermissions
+  } else decision = { behavior: 'deny', message: (typeof out.reason === 'string' && out.reason) || '用户在设备上拒绝了这一步' }
   const body = { hookSpecificOutput: { hookEventName: 'PermissionRequest', decision } }
+  // opencode 插件回填选择题要的是每题的 label 数组（它不认 updatedInput）；Claude 系不带，免得 hook 输出校验不认这个字段
+  if (tool === 'opencode' && out.decision === 'allow' && Array.isArray(out.answerLists)) body.deskbuddyAnswers = out.answerLists
   // 窗口里告诉人是在哪台设备上处理的
   if (typeof out.notice === 'string' && out.notice) body.systemMessage = out.notice.slice(0, 300)
   process.stdout.write(JSON.stringify(body), () => process.exit(0))
@@ -273,13 +276,18 @@ async function main() {
     return
   }
 
-  const payload = JSON.stringify({
-    hookSpecificOutput: {
-      hookEventName: 'PreToolUse',
-      permissionDecision: out.decision,
-      permissionDecisionReason: reason,
-    },
-  })
+  const spec = {
+    hookEventName: 'PreToolUse',
+    permissionDecision: out.decision,
+    permissionDecisionReason: reason,
+  }
+  // 远程选择题作答（WorkBuddy 的 codebuddy -p）：带上答案。codebuddy 的命令 hook 读 hookSpecificOutput.modifiedInput，
+  // 合并多个 hook 结果时读 updatedInput（Claude 兼容字段）—— 两个都带（codebuddy WorkBuddy 内置版源码核对）
+  if (out.decision === 'allow' && out.updatedInput && typeof out.updatedInput === 'object' && !Array.isArray(out.updatedInput)) {
+    spec.updatedInput = out.updatedInput
+    spec.modifiedInput = out.updatedInput
+  }
+  const payload = JSON.stringify({ hookSpecificOutput: spec })
   // 等写完再退：管道写入是异步的，写一半就 exit 的话 allow / defer 会丢
   process.stdout.write(payload, (err) => (err ? fail('写 hook 输出失败') : process.exit(0)))
 }

package/hook/hook-debug.log

@@ -0,0 +1,5 @@
+2026-10-02T13:19:27.363Z [opencode] 回填选择题失败：/question/{requestID}/reply status=404
+2026-10-02T14:34:18.393Z [opencode] 回填选择题失败：/question/{requestID}/reply status=404
+2026-10-03T02:01:37.783Z [opencode] 回填选择题失败：/question/{requestID}/reply status=404
+2026-10-03T02:16:17.435Z [opencode] 回填选择题失败：/question/{requestID}/reply status=404
+2026-10-03T02:19:56.607Z [opencode] 回填选择题失败：/question/{requestID}/reply status=404

package/hook/hook.cjs

@@ -147,6 +147,45 @@ const FALLBACK_REGISTRY = {
       },
       lifecycle: { SessionStart: 'ignore', SessionEnd: 'remove' },
     },
+    // 千问办公（QwenWorkCN.app，内核是 App 内置的 Qoder CN CLI，hooks 读 ~/.QwenWorkCN/settings.json）。
+    // PermissionRequest 不触发：授权框只来一条 Notification(permission_prompt)（spec 2026-10-03 §2.1）
+    qwenwork: {
+      format: 'cc-hook',
+      processNames: ['QwenWorkCN'],
+      // 工作目录是 ~/.qwenworkcn/workspace/<chatId>，目录名不能当标题
+      titleSources: ['first-prompt', 'project'],
+      turnEvents: ['UserPromptSubmit'],
+      events: {
+        UserPromptSubmit: 'watch',
+        PreToolUse: 'watch',
+        PostToolUse: 'watch',
+        Stop: 'done',
+      },
+      conditionalEvents: {
+        Notification: [
+          // 实测 message 是 "Tool Bash requires confirmation"（选择题是 "Tool AskUserQuestion requires confirmation"），与服务端注册表一致
+          { match: 'requires confirmation|permission|approve|需要确认|授权', state: 'ask_approval' },
+          { match: 'waiting for your input|idle|闲置', state: 'done' },
+        ],
+      },
+      lifecycle: { SessionStart: 'ignore', SessionEnd: 'remove' },
+    },
+    // 百度搭子（DuMate.app，内核是改名的 opencode：dumate-opencode serve）。不往 DuMate 里装任何东西：
+    // daemon 的 DumateWatch 直连它的 HTTP 接口，把事件翻成 cc 同构输入喂 hook.cjs（spec 2026-10-03 §3.2）
+    dumate: {
+      format: 'dumate-http',
+      processNames: ['dumate-opencode'],
+      titleSources: ['oc-session-title', 'first-prompt'],
+      turnEvents: ['UserPromptSubmit'],
+      events: {
+        UserPromptSubmit: 'watch',
+        PreToolUse: 'watch',
+        PostToolUse: 'watch',
+        Stop: 'done',
+        PermissionRequest: 'ask_approval',
+      },
+      lifecycle: { SessionEnd: 'remove' },
+    },
     opencode: {
       format: 'oc-plugin',
       processNames: ['opencode'],
@@ -754,6 +793,8 @@ function writeEnded(s, now) {
     const rec = { sessionId: sid, tool: s.tool || '', cwd: s.cwd || '', interactive: s.interactive === true, endedAt: t }
     // 轮数随记录留下：--resume 同一个会话时接着数（窗口对话轮数 spec §2.1）
     if (turnsOf(s) !== undefined) rec.turns = s.turns
+    // 首句也留下：会话结束后再被续跑（--resume）时，标题还用它，不被续跑那句话顶掉（Buglist 161）
+    if (typeof s.firstPrompt === 'string' && s.firstPrompt) rec.firstPrompt = s.firstPrompt
     const file = path.join(dir, sid + '.json')
     fs.writeFileSync(file + '.tmp', JSON.stringify(rec), { encoding: 'utf8', mode: 0o600 })
     fs.renameSync(file + '.tmp', file)
@@ -770,19 +811,41 @@ function writeEnded(s, now) {
   }
 }
 
-/** 已结束记录里留下的轮数（与 src/core/ended.ts 的 readEnded 同一有效期）；没有返回 undefined */
-function endedTurns(sessionId) {
+/** 已结束记录（与 src/core/ended.ts 的 readEnded 同一有效期）；没有 / 过期返回 null */
+function readEndedRecord(sessionId) {
   const sid = String(sessionId || '')
-  if (!/^[A-Za-z0-9_-]{1,64}$/.test(sid)) return undefined
+  if (!/^[A-Za-z0-9_-]{1,64}$/.test(sid)) return null
   try {
     const r = JSON.parse(fs.readFileSync(path.join(deskbuddyHome(), 'ended', sid + '.json'), 'utf8'))
-    if (!r || r.sessionId !== sid || typeof r.endedAt !== 'number' || Date.now() - r.endedAt > ENDED_TTL_MS) return undefined
-    return turnsOf(r)
+    if (!r || r.sessionId !== sid || typeof r.endedAt !== 'number' || Date.now() - r.endedAt > ENDED_TTL_MS) return null
+    return r
   } catch (e) {
-    return undefined
+    return null
   }
 }
 
+/** 已结束记录里留下的轮数；没有返回 undefined */
+function endedTurns(sessionId) {
+  return turnsOf(readEndedRecord(sessionId))
+}
+
+/** 已结束记录里留下的首句；没有返回 undefined */
+function endedFirstPrompt(sessionId) {
+  const r = readEndedRecord(sessionId)
+  return r && typeof r.firstPrompt === 'string' && r.firstPrompt ? r.firstPrompt : undefined
+}
+
+/**
+ * DeskBuddy 自己注入的话（daemon 续跑时发给智能体的「你在设备上已批准…」，与 src/daemon/index.ts 的 INTERNAL_PROMPT_MARK 一致）：
+ * 不是用户说的，不当会话首句（标题）、不算一轮（Buglist 161）。老 daemon（beta.14 及以前）发的没有标记，按固定开头认
+ */
+const INTERNAL_PROMPT_MARK = '[DeskBuddy]'
+function isInternalPrompt(text) {
+  if (typeof text !== 'string') return false
+  const t = text.trim()
+  return t.startsWith(INTERNAL_PROMPT_MARK) || t.startsWith('（你在设备上已批准：')
+}
+
 /** 会话结束：先写已结束记录，再删状态（删状态的地方都走这里，/clear 除外） */
 function retireState(s, now) {
   writeEnded(s, now)
@@ -801,6 +864,22 @@ function removeState(sessionId) {
  * 读取某工具下所有【进程还活着】的会话，顺手清理已死的。
  * SessionEnd 极不可靠（用户叉掉窗口时根本不触发），进程存活才是唯一硬信号。
  */
+/** 与 src/core/state.ts 的 STALE_NO_PID_MS / STALE_NO_PID_LOG / isStaleNoPid 一致 */
+const STALE_NO_PID_MS = 2 * 60 * 60 * 1000
+const STALE_NO_PID_LOG = '无进程号且 2 小时无事件，按已结束处理'
+function pendingApprovalSessions() {
+  try {
+    const recs = JSON.parse(fs.readFileSync(path.join(deskbuddyHome(), 'approvals.json'), 'utf8'))
+    return new Set(Array.isArray(recs) ? recs.filter((r) => r && r.status === 'pending' && typeof r.sessionId === 'string').map((r) => r.sessionId) : [])
+  } catch (e) {
+    return new Set()
+  }
+}
+function isStaleNoPid(s, now, pending) {
+  if (s.pid || (s.state !== 'watch' && s.state !== 'ask_approval') || !(now - s.updatedAt > STALE_NO_PID_MS)) return false
+  return !(pending || pendingApprovalSessions)().has(s.sessionId)
+}
+
 function readAliveStates(tool) {
   let files
   try {
@@ -827,6 +906,16 @@ function readAliveStates(tool) {
       retireState(s) // 窗口已关：记下已结束、剔除并自我清理，state 目录不再无限增长
       continue
     }
+    // 没记进程号、2 小时没新事件的「进行中」会话按已结束处理（与 src/core/state.ts isStaleNoPid 一致）
+    if (isStaleNoPid(s, Date.now())) {
+      try {
+        fs.appendFileSync(path.join(deskbuddyHome(), 'daemon.log'), `${new Date().toISOString()} 会话 ${String(s.sessionId).slice(0, 8)} ${STALE_NO_PID_LOG}\n`, 'utf8')
+      } catch (e) {
+        /* 记不下不影响 */
+      }
+      retireState(s)
+      continue
+    }
     alive.push(s)
   }
   return alive
@@ -1468,6 +1557,170 @@ function setTurns(next, disk, prev, isTurn, sessionId) {
   else next.turns = v
 }
 
+/**
+ * Codex 的 hook 输入长相：几乎每个事件都带 turn_id；transcript 在 ~/.codex/sessions/…/rollout-*.jsonl。
+ * 🔴 至少两个特征同时成立才算（评审）：单看一个可能误伤将来的 Claude Code（例如它也给更多事件加 turn_id）
+ */
+function looksLikeCodex(payload) {
+  const tp = typeof payload.transcript_path === 'string' ? payload.transcript_path : ''
+  let n = 0
+  if (typeof payload.turn_id === 'string' && payload.turn_id && payload.hook_event_name !== 'MessageDisplay') n++
+  if (/(^|[\\/])rollout-[^\\/]*\.jsonl$/i.test(tp)) n++
+  if (/[\\/]\.codex[\\/]sessions[\\/]/.test(tp)) n++
+  return n >= 2
+}
+
+/** 排查用：被 foreignHost 拦下时记一行到 ~/.deskbuddy/hook-debug.log（不写 stderr：有的宿主会把 hook 的 stderr 当输入）。不记任何文本 */
+function noteForeign(tool, payload) {
+  try {
+    const p = path.join(deskbuddyHome(), 'hook-debug.log')
+    fs.mkdirSync(deskbuddyHome(), { recursive: true })
+    try {
+      if (fs.statSync(p).size > 256 * 1024) fs.truncateSync(p, 0)
+    } catch (e) {
+      /* 还没有 */
+    }
+    const sid = String(payload.session_id || '').slice(0, 8)
+    const ev = String(payload.hook_event_name || '').slice(0, 40)
+    fs.appendFileSync(p, `${new Date().toISOString()} 宿主不是 ${tool}，忽略 event=${ev} session=${sid}\n`, 'utf8')
+  } catch (e) {
+    /* 记不下不影响 */
+  }
+}
+
+/** Claude Code 的 hook 输入长相：transcript 在 <配置目录>/projects/<目录名>/<会话号>.jsonl，没有 turn_id */
+function looksLikeClaude(payload) {
+  const tp = typeof payload.transcript_path === 'string' ? payload.transcript_path : ''
+  return !payload.turn_id && /[\\/]projects[\\/][^\\/]+[\\/][0-9a-f-]{36}\.jsonl$/i.test(tp)
+}
+
+/**
+ * 命令行上的工具标识与真正触发 hook 的宿主对不上（2026-10-02 现场）：同一台电脑 Codex 会话（UUIDv7）同时以 tool=claude_code
+ * 上报，设备上多出一张「进行中」卡挂了 20 分钟。新版 Codex 能从 Claude Code 导入配置（/import「import setup … from Claude Code」，
+ * 含 ~/.claude/settings.json 里的 hooks），导进去的是我们给 Claude 装的 `hook.cjs claude_code`，于是在 Codex 会话里也按 claude_code 报。
+ * 反过来 Claude 触发 codex 的条目同理。认出来就静默退出：那个会话由它自己工具的 hook 正常上报
+ */
+function foreignHost(tool, payload) {
+  if (!payload || typeof payload !== 'object') return false
+  if (tool === 'claude_code') return looksLikeCodex(payload)
+  if (tool === 'codex') return looksLikeClaude(payload)
+  return false
+}
+
+/**
+ * 保险（设备答选择题，Qoder 待实机确认，发版前联调必验）：设备在 Qoder 上答了选择题（回显是「已在…上回答」），
+ * 可这一步跑完的 PostToolUse(AskUserQuestion) 输入里却没有 answers —— 说明 Qoder 没采用 hook 回填的答案。
+ * 记一行到 daemon.log，方便联调时发现
+ */
+function checkQoderAnswerAdopted(tool, event, payload, notice) {
+  try {
+    if ((tool !== 'qoder_cn' && tool !== 'qoder') || event !== 'PostToolUse' || payload.tool_name !== 'AskUserQuestion') return
+    if (typeof notice !== 'string' || !/已在.*上回答/.test(notice)) return
+    const a = payload.tool_input && payload.tool_input.answers
+    if (a && typeof a === 'object' && Object.keys(a).length > 0) return
+    const line = `${new Date().toISOString()} Qoder 未采用设备答案（tool=${tool} session=${String(payload.session_id || '').slice(0, 8)}）\n`
+    fs.mkdirSync(deskbuddyHome(), { recursive: true })
+    fs.appendFileSync(path.join(deskbuddyHome(), 'daemon.log'), line, 'utf8')
+  } catch (e) {
+    /* 记不下不影响 */
+  }
+}
+
+/**
+ * daemon 代智能体起的 hook（百度搭子：DumateWatch 直连 HTTP，把事件喂给本文件）往上找不到智能体进程，
+ * daemon 用 DESKBUDDY_AGENT_PID 告诉我们是哪个（spec 2026-10-03 §3.2）。
+ * 🔴 只在父进程就是 daemon（gate.json 里记的 pid）时采纳：别的进程设这个变量不能冒充
+ */
+function envAgentPid() {
+  const v = process.env.DESKBUDDY_AGENT_PID || ''
+  if (!/^[1-9]\d{0,9}$/.test(v)) return null
+  let conf
+  try {
+    conf = JSON.parse(fs.readFileSync(path.join(deskbuddyHome(), 'gate.json'), 'utf8'))
+  } catch (e) {
+    return null
+  }
+  if (!conf || !Number.isInteger(conf.pid) || conf.pid !== process.ppid) return null
+  const pid = Number(v)
+  return pidExists(pid) ? pid : null
+}
+
+/** 千问办公推卡通知的超时：hook 卡着 PreToolUse，界面在它返回前不出题，必须短 */
+const QWENWORK_NOTIFY_MS = 800
+
+/**
+ * 千问办公（spec 2026-10-03 §3.1）：选择题 / 授权框要推设备时返回种类，否则 ''。
+ * 选择题是 PreToolUse(AskUserQuestion)；授权只有 Notification(permission_prompt)（PermissionRequest 不触发）
+ */
+function qwenworkNotifyKind(tool, event, payload) {
+  if (tool !== 'qwenwork' || !payload || typeof payload !== 'object') return ''
+  if (event === 'PreToolUse' && payload.tool_name === 'AskUserQuestion') return 'question'
+  if (event === 'Notification' && payload.notification_type === 'permission_prompt') return 'permission'
+  return ''
+}
+
+/**
+ * 告诉 daemon「有一道题 / 一个授权框」（POST /gate mode=notify），🔴 不等设备：daemon 收到立刻回 200，
+ * 设备答复由 daemon 经 App 内置 MCP 回填，界面照常弹。daemon 不在 / 超时 / 出错一律静默（resolve false）
+ */
+function notifyDaemon(tool, payload, timeoutMs) {
+  return new Promise((resolve) => {
+    let done = false
+    const finish = (v) => {
+      if (done) return
+      done = true
+      resolve(v)
+    }
+    let conf
+    try {
+      conf = JSON.parse(fs.readFileSync(path.join(deskbuddyHome(), 'gate.json'), 'utf8'))
+    } catch (e) {
+      return finish(false)
+    }
+    if (!conf || !Number.isInteger(conf.port) || typeof conf.token !== 'string') return finish(false)
+    let body
+    try {
+      body = JSON.stringify({ mode: 'notify', tool: tool, hook: payload })
+    } catch (e) {
+      return finish(false)
+    }
+    let req
+    try {
+      req = http.request(
+        {
+          host: '127.0.0.1',
+          port: conf.port,
+          path: '/gate',
+          method: 'POST',
+          headers: { 'content-type': 'application/json', 'content-length': Buffer.byteLength(body), 'x-gate-token': conf.token },
+        },
+        (res) => {
+          res.resume()
+          res.on('end', () => finish(res.statusCode === 200))
+          res.on('error', () => finish(false))
+        }
+      )
+    } catch (e) {
+      return finish(false)
+    }
+    const timer = setTimeout(() => {
+      try {
+        req.destroy()
+      } catch (e) {
+        /* 已经断了 */
+      }
+      finish(false)
+    }, timeoutMs)
+    if (timer.unref) timer.unref()
+    req.on('error', () => finish(false))
+    req.on('close', () => {
+      clearTimeout(timer)
+      finish(false)
+    })
+    req.end(body)
+  })
+}
+
 async function main(argv) {
   // 同一份 hook 被 Claude Code 与 Codex 复用，靠命令行参数区分是哪个工具
   const tool = (argv && argv[2]) || 'claude_code'
@@ -1475,6 +1728,11 @@ async function main(argv) {
   const event = payload.hook_event_name || ''
   const sessionId = payload.session_id || ''
   if (!sessionId) return
+  // 宿主对不上就当没来过：不写状态、不上报、不输出（见 foreignHost）
+  if (foreignHost(tool, payload)) {
+    noteForeign(tool, payload)
+    return
+  }
   // 快速路径（切片 C）：Codex 的同步 UserPromptSubmit 条目 / opencode 插件的 chat.message 调。
   // 只读 appended → 输出 JSON → 删；不查进程、不上报（同步 hook 卡着用户的输入）
   if (argv && argv[3] === '--appended') {
@@ -1486,8 +1744,13 @@ async function main(argv) {
   //    按写完先后落盘就会把 done 覆盖回 watch，屏上一直「进行中」直到窗口关掉（10-01 WIN-LVT5M8H5670 实测）
   const eventAt = Date.now()
 
+  // 千问办公：选择题 / 授权框推设备（不挂起，见 notifyDaemon）。状态照常往下走。
+  // 🔴 放在取 eventAt 之后：通知最多耗 800ms，不能把这次事件的时间往后推（并发的 Stop 会被它压掉）
+  if (qwenworkNotifyKind(tool, event, payload)) await notifyDaemon(tool, payload, QWENWORK_NOTIFY_MS)
+
   if (NOTICE_EVENTS[event]) {
     const notice = takeNotice(sessionId)
+    checkQoderAnswerAdopted(tool, event, payload, notice)
     // 🔴 writeSync：macOS 上 stdout 是管道时 process.stdout.write 是异步的，进程先退就丢了
     if (notice) {
       try {
@@ -1553,9 +1816,15 @@ async function main(argv) {
   const now = Date.now()
   if (event === 'UserPromptSubmit') recordDir(payload.cwd, now)
   // 窗口对话轮数（spec 2026-10-02 §2.1）：一轮开始的事件加 1
-  const isTurn = turnEvents(registry, tool).indexOf(event) >= 0
+  const internal = event === 'UserPromptSubmit' && isInternalPrompt(payload.prompt)
+  const isTurn = !internal && turnEvents(registry, tool).indexOf(event) >= 0
   // 首条指令（标题来源 first-prompt）：只记第一次
-  const firstPrompt = (prev && prev.firstPrompt) || (event === 'UserPromptSubmit' ? cleanPrompt(payload.prompt) : '') || undefined
+  // 状态没了（会话结束后被续跑）就接已结束记录里的首句；DeskBuddy 注入的话不算首句
+  const firstPrompt =
+    (prev && prev.firstPrompt) ||
+    (prev ? undefined : endedFirstPrompt(sessionId)) ||
+    (event === 'UserPromptSubmit' && !internal ? cleanPrompt(payload.prompt) : '') ||
+    undefined
   if (superseded(prev, eventAt)) {
     // 被并发的更晚事件（多半是同一轮的 Stop）抢先写了：状态不覆盖，但首条指令要补上，不然标题就成了第二条指令
     if (patchSuperseded(prev, firstPrompt, isTurn)) await reportIfAuthorized(tool, Date.now())
@@ -1564,7 +1833,7 @@ async function main(argv) {
   // 状态里记的进程还活着才沿用（评审）：先远程 -p 跑过、后又在窗口 resume 同一会话时，
   // 不能拿死掉的 -p 进程的 interactive=false 挡不住窗口
   const prevAlive = !!(prev && prev.pid && pidExists(prev.pid))
-  const pid = (prevAlive && prev.pid) || resolveAgentPid(process.pid, agentNames(registry, tool)) || undefined
+  const pid = (prevAlive && prev.pid) || envAgentPid() || resolveAgentPid(process.pid, agentNames(registry, tool)) || undefined
   // 两个判定沿用规则相同：进程还活着且上次判过就沿用，否则查一次命令行（只查一次）
   let host = null
   const hostFlag = (k) => {
@@ -1720,6 +1989,11 @@ module.exports = {
   pairClear,
   shouldReport,
   superseded,
+  foreignHost,
+  checkQoderAnswerAdopted,
+  qwenworkNotifyKind,
+  envAgentPid,
+  notifyDaemon,
   sign,
   titleSources,
   writeState,
@@ -1734,6 +2008,10 @@ module.exports = {
   setTurns,
   patchSuperseded,
   endedTurns,
+  endedFirstPrompt,
+  isInternalPrompt,
+  isStaleNoPid,
+  STALE_NO_PID_MS,
   WINDOW_EVENTS,
   noteWindow,
   readWindow,

package/hook/ocTranslate.d.mts

@@ -0,0 +1,7 @@
+// hook/ocTranslate.mjs 的类型声明（daemon 经 src/core/ocTranslate.ts 引用；插件本体是零依赖 JS）
+export function toCcTool(tool: unknown, args: unknown): { tool_name: string; tool_input: Record<string, unknown> }
+export function askToCc(props: unknown): { tool_name: string; tool_input: Record<string, unknown> }
+export function alwaysSuggestions(props: unknown): Array<Record<string, unknown>> | undefined
+export function isPlainQuestion(props: unknown, callTool: unknown): boolean
+export function questionToCc(props: unknown): { tool_name: string; tool_input: { questions: Array<Record<string, unknown>> } } | null
+export function rememberTitle(titles: Map<string, string>, info: unknown): void