deskbuddy 0.2.0-beta.2 → 0.2.0-beta.21

package/hook/hook.cjs

@@ -26,7 +26,7 @@ const MAX_SESSIONS = 20
  * 快照整包带的能力声明（前置 spec 2026-09-29 §4.4，服务端写 deskbuddy:caps:{clientId}）。
  * 与 src/core/snapshot.ts 的 CAPS 一致
  */
-const CAPS = ['cmd_result', 'window_inject']
+const CAPS = ['cmd_result', 'window_inject', 'resume_ended', 'reply_idle_window', 'turns']
 /** 状态文件里保留的最近事件条数，与 src/core/state.ts 的 RECENT_MAX 一致 */
 const RECENT_MAX = 8
 const REPORT_TIMEOUT_MS = 2000
@@ -69,7 +69,8 @@ const FALLBACK_REGISTRY = {
     claude_code: {
       format: 'cc-hook',
       processNames: ['claude'],
-      titleSources: ['cc-ai-title', 'git-branch', 'project'],
+      titleSources: ['cc-ai-title', 'first-prompt', 'git-branch', 'project'],
+      turnEvents: ['UserPromptSubmit'],
       events: {
         UserPromptSubmit: 'watch',
         PreToolUse: 'watch',
@@ -86,8 +87,9 @@ const FALLBACK_REGISTRY = {
       format: 'codex-toml',
       processNames: ['codex'],
       // codex-thread-name 是机会主义的一级：session_index.jsonl 里的 thread_name
-      // 原生只有 /rename 手动设，多数用户是空的，取不到就往下回落
-      titleSources: ['codex-thread-name', 'git-branch', 'project'],
+      // 只有 /rename 或 VS Code 扩展起过名的才有，多数是空的，取不到用首条指令
+      titleSources: ['codex-thread-name', 'first-prompt', 'git-branch', 'project'],
+      turnEvents: ['UserPromptSubmit'],
       events: {
         UserPromptSubmit: 'watch',
         PreToolUse: 'watch',
@@ -100,7 +102,10 @@ const FALLBACK_REGISTRY = {
     workbuddy: {
       format: 'cc-hook',
       processNames: ['WorkBuddy'],
-      titleSources: ['git-branch', 'project'],
+      // WorkBuddy 的 transcript 与 Claude Code 同格式，也写 ai-title（2026-10-01 WorkBuddy 5.6.2 实测）；
+      // 工作目录是按时间自动建的，目录名不能当标题
+      titleSources: ['cc-ai-title', 'first-prompt', 'git-branch', 'project'],
+      turnEvents: ['UserPromptSubmit'],
       events: {
         UserPromptSubmit: 'watch',
         PreToolUse: 'watch',
@@ -110,10 +115,30 @@ const FALLBACK_REGISTRY = {
       },
       lifecycle: { SessionStart: 'ignore', SessionEnd: 'remove' },
     },
+    // Qoder 国内版（Qoder CN.app，配置 ~/.qoder-cn）
+    qoder_cn: {
+      format: 'cc-hook',
+      // qoderclicn：终端里的命令行窗口（Bug 204），与 src/core/registry.ts 一致
+      processNames: ['Qoder CN', 'qoderclicn'],
+      // 桌面端会话库里的标题（先是首条指令，后被换成 AI 摘要）；命令行跑的会话不在库里，落到首条指令
+      // （CLI 1.1.61 实测 transcript 里没有 ai-title，UserPromptSubmit 带 prompt）
+      titleSources: ['qoder-session-title', 'first-prompt', 'git-branch', 'project'],
+      turnEvents: ['UserPromptSubmit'],
+      events: {
+        UserPromptSubmit: 'watch',
+        PreToolUse: 'watch',
+        PostToolUse: 'watch',
+        Stop: 'done',
+        PermissionRequest: 'ask_approval',
+      },
+      lifecycle: { SessionStart: 'ignore', SessionEnd: 'remove' },
+    },
+    // Qoder 国际版（Qoder.app / qodercli，配置 ~/.qoder）。进程名按子串匹配，'Qoder' 也认得出 qodercli
     qoder: {
       format: 'cc-hook',
-      processNames: ['Qoder CN'],
-      titleSources: ['git-branch', 'project'],
+      processNames: ['Qoder'],
+      titleSources: ['qoder-session-title', 'first-prompt', 'git-branch', 'project'],
+      turnEvents: ['UserPromptSubmit'],
       events: {
         UserPromptSubmit: 'watch',
         PreToolUse: 'watch',
@@ -123,11 +148,66 @@ 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' },
+    },
+    // DeepSeek Harness（dsh web / Desktop / headless）：原生插件 hook/deskbuddy-dsh.mjs 把 Cordis 事件翻成 cc 同构输入喂本文件
+    deepseek_harness: {
+      format: 'dsh-plugin',
+      processNames: ['dsh', 'DeepSeek Harness'],
+      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'],
-      // opencode 自带的会话标题是模型对提问的摘要，违反隐私约束（spec §6.4），不用
-      titleSources: ['git-branch', 'project'],
+      // opencode 自己生成的会话标题（插件从 session.updated 取，随事件传 oc_session_title），没有就用首条指令
+      titleSources: ['oc-session-title', 'first-prompt', 'git-branch', 'project'],
+      turnEvents: ['UserPromptSubmit'],
       events: {
         UserPromptSubmit: 'watch',
         PreToolUse: 'watch',
@@ -163,10 +243,16 @@ function loadConfig() {
 
 // ---------- 映射表 ----------
 
+/** 缓存里没有的工具用内置条目补上，缓存里有的以缓存为准。与 src/core/registry.ts 的 withFallbackTools 一致 */
+function withFallbackTools(registry) {
+  if (!registry || typeof registry !== 'object' || !registry.tools || typeof registry.tools !== 'object') return FALLBACK_REGISTRY
+  return Object.assign({}, registry, { tools: Object.assign({}, FALLBACK_REGISTRY.tools, registry.tools) })
+}
+
 /** hook 每次执行都会调用，只读本地缓存 —— 绝不能在 hook 里发网络请求拉配置。 */
 function loadRegistry() {
   try {
-    return JSON.parse(fs.readFileSync(path.join(deskbuddyHome(), 'tool-registry.json'), 'utf8'))
+    return withFallbackTools(JSON.parse(fs.readFileSync(path.join(deskbuddyHome(), 'tool-registry.json'), 'utf8')))
   } catch (e) {
     return FALLBACK_REGISTRY
   }
@@ -201,6 +287,22 @@ function agentNames(registry, tool) {
 }
 
 /** 会话标题回落链。顺序由服务端映射表决定，客户端不写死。 */
+/** 一轮开始的事件（窗口对话轮数 spec 2026-10-02 §2.1）：没配时用内置条目，再没有就是 UserPromptSubmit */
+const DEFAULT_TURN_EVENTS = ['UserPromptSubmit']
+
+/** 与 src/core/registry.ts 的 turnEvents 一致 */
+function turnEvents(registry, tool) {
+  const t = registry && registry.tools ? registry.tools[tool] : null
+  if (t && Array.isArray(t.turnEvents)) return t.turnEvents
+  const f = FALLBACK_REGISTRY.tools[tool]
+  return f && Array.isArray(f.turnEvents) ? f.turnEvents : DEFAULT_TURN_EVENTS
+}
+
+/** 状态里的轮数：只认非负整数，其它（老版本没有这个字段）当作没有 */
+function turnsOf(s) {
+  return s && Number.isInteger(s.turns) && s.turns >= 0 ? s.turns : undefined
+}
+
 function titleSources(registry, tool) {
   const t = registry && registry.tools ? registry.tools[tool] : null
   if (t && Array.isArray(t.titleSources) && t.titleSources.length > 0) return t.titleSources
@@ -321,7 +423,141 @@ function readGitBranch(cwd, maxUp) {
   return null
 }
 
-/** 按 registry 给的顺序逐级回落。所有来源都不碰 prompt 原文。 */
+/** 首条指令当标题时的最大字数（按字符），与 src/core/title.ts 一致 */
+const FIRST_PROMPT_MAX = 30
+
+/** 用户指令 → 可上屏的短标题，与 src/core/title.ts 的 cleanPrompt 一致 */
+function cleanPrompt(text) {
+  if (typeof text !== 'string') return ''
+  // eslint-disable-next-line no-control-regex
+  const flat = text.replace(/[\u0000-\u001f\u007f-\u009f\u2028\u2029]+/g, ' ').replace(/\s+/g, ' ').trim()
+  const chars = Array.from(flat)
+  return chars.length > FIRST_PROMPT_MAX ? chars.slice(0, FIRST_PROMPT_MAX).join('').trimEnd() + '…' : flat
+}
+
+/** 会话库标题的最大字数，与 src/core/title.ts 一致 */
+const SESSION_TITLE_MAX = 100
+
+/** 外部来的标题清洗，与 src/core/title.ts 的 cleanTitle 一致 */
+function cleanTitle(text) {
+  if (typeof text !== 'string') return ''
+  // eslint-disable-next-line no-control-regex
+  const flat = text.replace(/[\u0000-\u001f\u007f-\u009f\u2028\u2029]+/g, ' ').replace(/\s+/g, ' ').trim()
+  return Array.from(flat).slice(0, SESSION_TITLE_MAX).join('').trimEnd()
+}
+
+/**
+ * node:sqlite 是 Node 内置模块（22.13+ / 23.4+ 免 flag），更老的 Node require 直接抛，调用方跳过。
+ * 加载时的 ExperimentalWarning 吞掉，免得打进智能体的 hook 输出
+ */
+function loadNodeSqlite() {
+  const orig = process.emitWarning
+  process.emitWarning = function () {
+    if (String(arguments[0] == null ? '' : arguments[0]).indexOf('SQLite') !== -1) return
+    return orig.apply(process, arguments)
+  }
+  try {
+    return require('node:sqlite')
+  } finally {
+    process.emitWarning = orig
+  }
+}
+
+/** Qoder 各版本桌面端的数据目录名，与 src/core/title.ts 的 QODER_DATA_DIRS 一致 */
+const QODER_DATA_DIRS = { qoder_cn: 'com.qodercn.app.stable', qoder: 'com.qoder.app.stable' }
+
+/** Qoder 桌面端会话库候选路径（按工具取各自的库），与 src/core/title.ts 的 qoderDbPaths 一致（来源与未核对项见那边注释） */
+function qoderDbPaths(tool, platform, home, env) {
+  const pf = platform || process.platform
+  const h = home || os.homedir()
+  const e = env || process.env
+  let root
+  if (pf === 'darwin') root = path.join(h, 'Library', 'Application Support')
+  else if (pf === 'win32') root = e.APPDATA || path.join(h, 'AppData', 'Roaming')
+  else root = e.XDG_CONFIG_HOME || path.join(h, '.config')
+  const dirs = QODER_DATA_DIRS[tool] ? [QODER_DATA_DIRS[tool]] : [QODER_DATA_DIRS.qoder_cn, QODER_DATA_DIRS.qoder]
+  return dirs.map((d) => path.join(root, d, 'main.sqlite'))
+}
+
+/** Qoder 桌面端的会话标题（chat_sessions.title），与 src/core/title.ts 一致。任何失败返回 null */
+function readQoderSessionTitle(sessionId, paths, load) {
+  if (!sessionId) return null
+  const existing = (paths || qoderDbPaths(null)).filter((p) => fs.existsSync(p))
+  if (existing.length === 0) return null
+  let mod
+  try {
+    mod = (load || loadNodeSqlite)()
+  } catch (e) {
+    return null
+  }
+  for (const p of existing) {
+    let db
+    try {
+      db = new mod.DatabaseSync(p, { readOnly: true })
+      const row = db.prepare('select title from chat_sessions where session_id = ?').get(sessionId)
+      const t = cleanTitle(row && row.title)
+      if (t) return t
+    } catch (e) {
+      /* 这个库读不了，试下一个 */
+    } finally {
+      try {
+        if (db) db.close()
+      } catch (e) {
+        /* ignore */
+      }
+    }
+  }
+  return null
+}
+
+// ---------- 非项目目录（与 src/core/dirFilter.ts 同构） ----------
+
+function dirNorm(p, win) {
+  if (win) return path.win32.resolve(p).replace(/[\\/]+$/, '').toLowerCase()
+  return path.posix.resolve(p).replace(/\/+$/, '')
+}
+
+function dirUnder(p, base, win) {
+  return p === base || p.startsWith(base + (win ? '\\' : '/'))
+}
+
+/**
+ * 智能体按时间自动建的工作区。WorkBuddy：<主目录>/WorkBuddy/<日期开头>（5.6.2 实测 2026-09-24-18-50-03 /
+ * 20260430143452 / 2026-05-16-task-1）；Qoder CN：<主目录>/Documents/Qoder/<YYYY-MM-DD>/<8 位十六进制>
+ */
+function isAutoWorkspace(p, opts) {
+  if (!p) return false
+  const o = opts || {}
+  const win = (o.platform || process.platform) === 'win32'
+  const P = win ? path.win32 : path.posix
+  const home = dirNorm(o.home || os.homedir(), win)
+  const full = dirNorm(p, win)
+  const name = P.basename(full)
+  const parent = P.dirname(full)
+  if (parent === dirNorm(P.join(home, 'WorkBuddy'), win) && /^\d{4}-?\d{2}-?\d{2}/.test(name)) return true
+  return (
+    P.dirname(parent) === dirNorm(P.join(home, 'Documents', 'Qoder'), win) &&
+    /^\d{4}-\d{2}-\d{2}$/.test(P.basename(parent)) &&
+    /^[0-9a-f]{8}$/i.test(name)
+  )
+}
+
+/** 能不能作为最近项目目录上报：主目录 / 根目录 / 临时目录及其下 / 自动工作区都不报 */
+function isReportableDir(p, opts) {
+  if (!p) return false
+  const o = opts || {}
+  const win = (o.platform || process.platform) === 'win32'
+  const P = win ? path.win32 : path.posix
+  const full = dirNorm(p, win)
+  if (full === dirNorm(P.parse(P.resolve(p)).root, win)) return false
+  if (full === dirNorm(o.home || os.homedir(), win)) return false
+  const tmps = [o.tmp || os.tmpdir()]
+  if (!win) tmps.push('/tmp', '/private/tmp', '/var/folders', '/private/var/folders')
+  for (const t of tmps) if (t && dirUnder(full, dirNorm(t, win), win)) return false
+  return !isAutoWorkspace(p, o)
+}
+
+/** 按 registry 给的顺序逐级回落。只有 first-prompt 用到 prompt（首条指令前 30 字），其余来源不碰 prompt 原文。 */
 function resolveTitle(sources, ctx) {
   const list = sources || []
   for (const source of list) {
@@ -329,7 +565,10 @@ function resolveTitle(sources, ctx) {
     if (source === 'cc-ai-title') value = readAiTitle(ctx.transcriptPath)
     else if (source === 'codex-thread-name') value = readCodexThreadName(ctx.sessionId, ctx.codexHome)
     else if (source === 'git-branch') value = readGitBranch(ctx.cwd)
-    else if (source === 'project') value = path.basename(ctx.cwd || '') || null
+    else if (source === 'first-prompt') value = ctx.firstPrompt || null
+    else if (source === 'qoder-session-title') value = readQoderSessionTitle(ctx.sessionId, ctx.qoderDbPaths || qoderDbPaths(ctx.tool), ctx.loadSqlite)
+    else if (source === 'oc-session-title') value = typeof ctx.ocSessionTitle === 'string' ? ctx.ocSessionTitle.trim() || null : null
+    else if (source === 'project') value = ctx.cwd && !isAutoWorkspace(ctx.cwd) ? path.basename(ctx.cwd) || null : null
     // 不认识的来源直接跳过：新来源应该先发版再进 registry
     if (value) return value
   }
@@ -344,7 +583,7 @@ const IS_WIN = process.platform === 'win32'
 const SCRIPT_HOSTS = ['node', 'bun', 'deno']
 const WIN_PS_SCRIPT =
   '[Console]::OutputEncoding=[Text.Encoding]::UTF8;' +
-  'Get-CimInstance Win32_Process | Select-Object ProcessId,ParentProcessId,Name,CommandLine | ConvertTo-Json -Compress'
+  'Get-CimInstance Win32_Process | Select-Object ProcessId,ParentProcessId,Name,CommandLine,CreationDate | ConvertTo-Json -Compress'
 
 function winSplitArgs(cmdline) {
   const out = []
@@ -410,6 +649,14 @@ function winNormalizedArgs(name, cmdline) {
   return argv.map((a) => a.replace(/\s+/g, '_').replace(/\\/g, '/')).join(' ')
 }
 
+/** CreationDate：PowerShell 5.1 是 `/Date(毫秒)/`，7 是 ISO 串；认不出返回 undefined */
+function winCreationMs(v) {
+  if (typeof v !== 'string' || !v) return undefined
+  const m = /^\/?Date\((\d+)/.exec(v)
+  const ms = m ? Number(m[1]) : Date.parse(v)
+  return Number.isFinite(ms) && ms > 0 ? ms : undefined
+}
+
 function parseWinProcJson(json) {
   let d
   try {
@@ -424,13 +671,16 @@ function parseWinProcJson(json) {
     if (!Number.isInteger(pid) || pid <= 0) continue
     const rawName = typeof r.Name === 'string' ? r.Name : ''
     const cmdline = typeof r.CommandLine === 'string' ? r.CommandLine.replace(/[\r\n]+/g, ' ') : ''
-    out.push({
+    const o = {
       pid: pid,
       ppid: Number(r.ParentProcessId) || 0,
       name: winEffectiveName(rawName, cmdline),
       args: winNormalizedArgs(rawName, cmdline),
       cmdline: cmdline,
-    })
+    }
+    const start = winCreationMs(r.CreationDate)
+    if (start !== undefined) o.start = start
+    out.push(o)
   }
   return out
 }
@@ -556,6 +806,79 @@ function writeState(s) {
   fs.renameSync(tmp, statePath(s.sessionId))
 }
 
+// ---------- 已结束记录（与 src/core/ended.ts 同构，续跑方案 spec 2026-09-29 §5.1） ----------
+
+const ENDED_TTL_MS = 7 * 24 * 60 * 60 * 1000
+
+function writeEnded(s, now) {
+  const sid = String((s && s.sessionId) || '')
+  if (!/^[A-Za-z0-9_-]{1,64}$/.test(sid)) return
+  try {
+    const dir = path.join(deskbuddyHome(), 'ended')
+    fs.mkdirSync(dir, { recursive: true, mode: 0o700 })
+    const t = now || Date.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)
+    for (const n of fs.readdirSync(dir)) {
+      const f = path.join(dir, n)
+      try {
+        if (t - fs.statSync(f).mtimeMs > ENDED_TTL_MS) fs.rmSync(f, { force: true })
+      } catch (e) {
+        /* ignore */
+      }
+    }
+  } catch (e) {
+    /* 记不下：只是这个会话结束后不能从设备续跑 */
+  }
+}
+
+/** 已结束记录（与 src/core/ended.ts 的 readEnded 同一有效期）；没有 / 过期返回 null */
+function readEndedRecord(sessionId) {
+  const sid = String(sessionId || '')
+  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 null
+    return r
+  } catch (e) {
+    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)
+  removeState(s.sessionId)
+}
+
 function removeState(sessionId) {
   try {
     fs.rmSync(statePath(sessionId), { force: true })
@@ -568,6 +891,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 {
@@ -591,7 +930,19 @@ function readAliveStates(tool) {
     }
     if (!s || s.tool !== tool) continue
     if (s.pid && !isAlive(s.pid, s.pidName)) {
-      removeState(s.sessionId) // 窗口已关：剔除并自我清理，state 目录不再无限增长
+      retireState(s) // 窗口已关：记下已结束、剔除并自我清理，state 目录不再无限增长
+      continue
+    }
+    // 记的是 Codex 托管常驻服务（beta.17 及以前会记成它）：当没记进程号，走下面 2 小时兜底（与 src/core/state.ts dropManagedDaemonPid 一致，这里只改内存）
+    if (s.tool === 'codex' && s.pid && s.pidChecked !== true && isCodexManagedDaemonArgs(agentArgs(s.pid))) s = Object.assign({}, s, { pid: undefined, pidName: undefined })
+    // 没记进程号、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)
@@ -604,6 +955,8 @@ function readAliveStates(tool) {
 function shouldReport(prev, next, nowMs) {
   if (!prev) return true
   if (prev.state !== next.state) return true
+  // 轮数变了也报：Esc 打断后状态停在 watch，下一句 watch→watch 不跃迁，不报的话设备要等 2 分钟保活才更新
+  if (turnsOf(prev) !== turnsOf(next)) return true
   // 保活：状态没跃迁也要定期报一次，否则服务端会把这台机器判成失联
   return nowMs - (prev.lastReportAt || 0) > KEEPALIVE_MS
 }
@@ -632,17 +985,22 @@ function buildSnapshot(states, tool, cfg, nowMs, remote) {
     .filter((s) => s.tool === tool) // 替换粒度是 (clientId, tool)，混进别的工具会冲掉对方
     .sort((a, b) => b.updatedAt - a.updatedAt)
     .slice(0, MAX_SESSIONS)
-    .map((s) => ({
-      sessionId: s.sessionId,
-      title: s.title,
-      // 隐私：只带目录名，不带全路径——全路径会暴露公司目录结构与用户名
-      project: path.basename(s.project || ''),
-      state: s.state,
-      startedAt: s.startedAt,
-      updatedAt: s.updatedAt,
-      interactive: s.interactive === true,
-      remoteWindow: remote ? remote.has(s.sessionId) : s.remoteWindow === true,
-    }))
+    .map((s) => {
+      const o = {
+        sessionId: s.sessionId,
+        title: s.title,
+        // 隐私：只带目录名，不带全路径——全路径会暴露公司目录结构与用户名
+        project: path.basename(s.project || ''),
+        state: s.state,
+        startedAt: s.startedAt,
+        updatedAt: s.updatedAt,
+        interactive: s.interactive === true,
+        remoteWindow: remote ? remote.has(s.sessionId) : s.remoteWindow === true,
+      }
+      // 窗口对话轮数：状态里没有就不带（老会话 / 老版本），服务端据此不显示而不是显示 0
+      if (turnsOf(s) !== undefined) o.turns = s.turns
+      return o
+    })
   return { clientId: cfg.clientId, hostName: cfg.hostName, tool: tool, snapshotAt: nowMs, sessions: sessions, caps: CAPS.slice() }
 }
 
@@ -764,8 +1122,35 @@ async function reportIfAuthorized(tool, nowMs) {
   // clientId 为空说明还没 setup 过（服务端靠 clientId ↔ userId 绑定关系认人）：
   // 绝不能在这里现编一个，那等于凭空造出一台没人认领的机器
   if (!cfg.clientId || cfg.enabledTools.indexOf(tool) === -1) return
+  // Codex：以 daemon 连着的 app-server 清单判 remoteWindow（切片 B）；Claude Code：状态文件 + 窗口唤醒标记
   const remote = tool === 'codex' ? readCodexRemote() || new Set() : null
-  await postReport(cfg, buildSnapshot(readAliveStates(tool), tool, cfg, nowMs, remote))
+  await postReport(cfg, buildSnapshot(withWake(readAliveStates(tool)), tool, cfg, nowMs, remote))
+}
+
+// ---------- 窗口唤醒（asyncRewake，与 src/core/wake.ts 同构） ----------
+
+/**
+ * daemon 写的 `wake/marks/<sessionId>.json`：这个会话开着的窗口里有等待者，设备指令能直接唤醒窗口执行。
+ * 标记里的智能体进程还在才算（kill 0，不查进程名：每次上报都要调）
+ */
+function wakeMarked(sessionId) {
+  const safe = String(sessionId).replace(/[^A-Za-z0-9_-]/g, '')
+  if (!safe) return false
+  try {
+    const m = JSON.parse(fs.readFileSync(path.join(deskbuddyHome(), 'wake', 'marks', safe + '.json'), 'utf8'))
+    // 写标记的 daemon 死了就不算（daemon 退出来不及清标记时，不能一直误报 remoteWindow）
+    const daemonPid = Number(m && m.daemonPid) || 0
+    if (!daemonPid || !pidExists(daemonPid)) return false
+    const pid = Number(m && m.agentPid) || 0
+    return pid > 0 ? pidExists(pid) : true
+  } catch (e) {
+    return false
+  }
+}
+
+/** 上报前叠加唤醒标记：能被唤醒的会话带 remoteWindow=true（服务端据此放行 8348） */
+function withWake(states) {
+  return states.map((s) => (s.remoteWindow === true || !wakeMarked(s.sessionId) ? s : Object.assign({}, s, { remoteWindow: true })))
 }
 
 /**
@@ -787,14 +1172,35 @@ function toolFingerprint(toolName, toolInput) {
  * 脚本、SDK 或 daemon 起的远程任务；桌面 App 与终端里的 TUI 是窗口。与 gate.cjs 的 isInteractiveClaude 同一判据。
  * 🔴 判不出来按 false：false 只意味着"不挡远程指令"，与改动前的行为一致
  */
+/**
+ * 只看第一个独立 `--` 之前的参数：daemon 开窗新建的 Qoder CN 把首句放在 `--` 之后（wrap/promptLaunch.ts），
+ * 首句里有个 ` -p ` 的词不能把窗口判成非交互（spec 2026-10-04 qodercn-visible §3.1）。后台计划的 -p 都在 `--` 之前
+ */
+function beforeDashDash(tokens) {
+  const i = tokens.indexOf('--')
+  return i >= 0 ? tokens.slice(0, i) : tokens
+}
+
+/**
+ * 只对 Qoder 的命令行这样看（qoderclicn / qodercli / 桌面端 worker）：别家（例如 node 跑的脚本）的 `--` 之后可能正是
+ * stream-json 这类开关。ps 的 args 按空白切开，`Qoder CN.app` 会被切成两段，所以看前三段
+ */
+function isQoderCli(all) {
+  return /qoder/i.test(all.slice(0, 3).join(' '))
+}
+
 function isInteractiveArgs(args) {
   const all = String(args || '').trim().split(/\s+/)
-  const tokens = all.slice(1)
+  const tokens = isQoderCli(all) ? beforeDashDash(all.slice(1)) : all.slice(1)
   if (tokens.length === 0) return true
   // exec 只认 Codex 的子命令位置：`claude "exec the tests"` 这种带提示词启动的窗口不能误判（评审）
   if (tokens[0] === 'exec' && /codex/i.test(path.basename(all[0]))) return false
   // opencode 的非交互是 `opencode run …`（二期 P9）；TUI 是 `opencode [目录]`
   if (tokens[0] === 'run' && /opencode/i.test(path.basename(all[0]))) return false
+  // DeepSeek Harness：`node …/dsh <profile>` 或 `dsh --profile <profile> …`；headless / sdk / acp 是程序在用，其余（web 等）是窗口。
+  // 🔴 在 -p 判据之前返回：一次性任务的文本是整段 argv，按空白切开后里面可能正好有个 -p
+  const dsh = dshProfile(all)
+  if (dsh !== null) return !DSH_NON_WINDOW[dsh]
   return !tokens.some(
     (t) =>
       t === '--print' ||
@@ -804,6 +1210,40 @@ function isInteractiveArgs(args) {
   )
 }
 
+/** 与 hook/deskbuddy-dsh.mjs 的 NON_WINDOW_PROFILES 一致 */
+const DSH_NON_WINDOW = { headless: true, sdk: true, 'sdk-minimal': true, acp: true }
+
+/** 命令行是 dsh 的话返回它的 profile 名（取不到返回 ''），不是 dsh 返回 null */
+function dshProfile(all) {
+  let i = -1
+  for (let k = 0; k < Math.min(all.length, 2); k++) {
+    const t = String(all[k]).replace(/\\/g, '/')
+    // npm 的 bin 链接叫 dsh；Windows 的 dsh.cmd 起的是 node …/@deepseek-ai/dsh/lib/bin.js
+    if (path.posix.basename(t) === 'dsh' || /(^|\/)@deepseek-ai\/dsh\/lib\/bin\.js$/.test(t)) i = k
+  }
+  if (i < 0) return null
+  const rest = all.slice(i + 1)
+  const j = rest.indexOf('--profile')
+  if (j >= 0) return rest[j + 1] || ''
+  return rest.find((t) => t && t[0] !== '-') || ''
+}
+
+/**
+ * 嵌入宿主（插件 / 桌面版 / SDK 长连）：`--input-format stream-json`（含 `=` 写法）且不带 -p / --print。
+ * 这类会话 isInteractiveArgs 判 false（不是终端窗口），但用户就在宿主里一轮轮发话：没有唤醒等待者（wake.cjs 铁律③），
+ * daemon 收到设备回复要按「用户自己的窗口」处理（正在跑就排队等 Stop、空闲才后台续跑并写 appended），不能直接并发 --resume。
+ * 🔴 只落本机状态，不改 interactive（服务端按 interactive 挡 8348），也不上报
+ */
+function isEmbeddedArgs(args) {
+  const tokens = String(args || '').trim().split(/\s+/).slice(1)
+  let streamIn = false
+  for (let i = 0; i < tokens.length; i++) {
+    const t = tokens[i]
+    if (t === '--input-format=stream-json' || (t === '--input-format' && tokens[i + 1] === 'stream-json')) streamIn = true
+  }
+  return streamIn && !tokens.some((t) => t === '--print' || /^-[a-zA-Z]*p[a-zA-Z]*$/.test(t))
+}
+
 /** 只看进程在不在（kill 0），不查进程名：每次事件都要调，ps 太贵 */
 function pidExists(pid) {
   try {
@@ -814,23 +1254,231 @@ function pidExists(pid) {
   }
 }
 
-function detectInteractive(pid) {
-  if (!pid) return false
+/** 智能体进程的命令行（Windows 见 winproc 的规范化参数串）。取不到返回 '' */
+function agentArgs(pid) {
+  if (!pid) return ''
   if (IS_WIN) {
     const p = winProc(pid)
-    return !!p && p.args !== '' && isInteractiveArgs(p.args)
+    return p ? p.args : ''
+  }
+  try {
+    return execFileSync('ps', ['-ww', '-o', 'args=', '-p', String(pid)], {
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'ignore'],
+    }).trim()
+  } catch (e) {
+    return ''
+  }
+}
+
+// ---------- Codex 托管常驻服务（与 src/core/codexServer.ts 同构） ----------
+
+/**
+ * Codex 0.159 起普通 `codex` 窗口连一个托管常驻服务跑会话（`codex app-server --listen unix:// --managed-daemon`，
+ * 装在 ~/.codex/packages/app-server-daemon/…），hook 由它执行，往上找智能体进程会找到它。
+ * 🔴 它不随窗口退出：记成会话进程的话窗口关了会话也永远「还活着」（SF-Test 01a101cd 停在 ask_approval）
+ */
+function isCodexManagedDaemonArgs(args) {
+  const s = String(args || '').replace(/\\/g, '/')
+  return /(?:^|\s)--managed-daemon(?:[=\s]|$)/.test(s) || /\/app-server-daemon\//i.test(codexProgramOf(s)) || /(?:^|\s)app-server\s+daemon(?:\s|$)/.test(s)
+}
+
+const CODEX_SCRIPT_HOST_RE = /^(?:node|bun|deno)(?:\.exe)?$/i
+const CODEX_RE = /^codex(?:-[a-z0-9_]+(?:-[a-z0-9_]+)*)?(?:\.exe|\.js|\.cjs|\.mjs)?$/
+const CODEX_NON_TUI = {
+  'app-server': 1, exec: 1, e: 1, mcp: 1, 'mcp-server': 1, login: 1, logout: 1, apply: 1, a: 1, sandbox: 1, debug: 1,
+  completion: 1, cloud: 1, proto: 1, 'responses-api-proxy': 1, 'stdio-to-uds': 1, features: 1, help: 1,
+}
+const CODEX_START_SLACK_MS = 2000
+
+function codexBaseName(p) {
+  return String(p).replace(/\\/g, '/').split('/').pop().toLowerCase()
+}
+
+/** 从第 i 个词起认一个程序路径；ps 不带引号，路径里的空格会把它拆开：绝对路径往后最多拼 8 个词 */
+function codexProgAt(all, i, re) {
+  for (let j = i; j < Math.min(all.length, i + 8); j++) {
+    const cand = all.slice(i, j + 1).join(' ')
+    if (re.test(codexBaseName(cand))) return { prog: cand, next: j + 1 }
+    if (!/^(?:\/|[A-Za-z]:\/)/.test(all[i].replace(/\\/g, '/'))) break
+  }
+  return null
+}
+
+function codexArgv(args) {
+  const all = String(args || '').trim().split(/\s+/).filter(Boolean)
+  if (all.length === 0) return null
+  let c
+  const h = codexProgAt(all, 0, CODEX_SCRIPT_HOST_RE)
+  if (h) {
+    const k = all.findIndex((a, n) => n >= h.next && !a.startsWith('-'))
+    c = k < 0 ? null : codexProgAt(all, k, CODEX_RE)
+  } else c = codexProgAt(all, 0, CODEX_RE)
+  if (!c) return null
+  // Codex 桌面版（macOS Codex.app、Windows …\Codex\ 安装目录）和它的 Electron 子进程（--type=…）不是终端窗口
+  const prog = c.prog.replace(/\\/g, '/')
+  if (/\.app\//.test(prog) || /(?:^|\/)Codex(?:\.app)?\//.test(prog)) return null
+  const rest = all.slice(c.next)
+  if (rest.some((t) => t.startsWith('--type='))) return null
+  return [c.prog].concat(rest)
+}
+
+function codexProgramOf(args) {
+  const all = String(args || '').trim().split(/\s+/).filter(Boolean)
+  const h = codexProgAt(all, 0, CODEX_SCRIPT_HOST_RE)
+  if (h) {
+    const k = all.findIndex((a, n) => n >= h.next && !a.startsWith('-'))
+    if (k >= 0) return all[k]
+  }
+  return all[0] || ''
+}
+
+/** 能挂在托管常驻服务上的 codex 窗口：不是非交互子命令；带 --remote 的只认连 unix 套接字的（ws:// 连的是 DeskBuddy 窗口自己的 app-server） */
+function isCodexTuiArgs(args) {
+  const argv = codexArgv(args)
+  if (!argv || isCodexManagedDaemonArgs(args)) return false
+  const rest = argv.slice(1)
+  const dd = rest.indexOf('--')
+  if (dd >= 0) rest.length = dd
+  const sub = rest.find((t) => !t.startsWith('-'))
+  if (sub !== undefined && CODEX_NON_TUI[sub]) return false
+  const ri = rest.findIndex((t) => t === '--remote' || t.startsWith('--remote='))
+  if (ri >= 0) {
+    const v = rest[ri].indexOf('=') >= 0 ? rest[ri].slice(rest[ri].indexOf('=') + 1) : rest[ri + 1] || ''
+    if (!/^unix:/i.test(v)) return false
+  }
+  return true
+}
+
+/** 命令行里 -C / --cd 指定的工作目录；没有返回 null */
+function codexFlagCwd(args) {
+  const argv = codexArgv(args)
+  if (!argv) return null
+  const rest = argv.slice(1)
+  for (let i = 0; i < rest.length; i++) {
+    const t = rest[i]
+    if (t === '--') break
+    if (t.startsWith('--cd=')) return t.slice(5) || null
+    if (t !== '-C' && t !== '--cd') continue
+    const parts = []
+    for (let j = i + 1; j < rest.length && !rest[j].startsWith('-'); j++) parts.push(rest[j])
+    return parts.length ? parts.join(' ') : null
+  }
+  return null
+}
+
+function codexCwdKey(p) {
+  return String(p || '').replace(/\\/g, '/').replace(/\s+/g, '_').replace(/\/+$/, '').toLowerCase()
+}
+
+/** 候选窗口和会话对得上：工作目录对不上 / 比会话开始还晚启动 → 否；两样都核对不了也否 */
+function codexTuiMatches(p, hint) {
+  let checked = 0
+  const want = ((hint && hint.cwds) || []).filter(Boolean).map(codexCwdKey)
+  const have = codexFlagCwd(p.args) || p.cwd
+  if (have && want.length > 0) {
+    if (want.indexOf(codexCwdKey(have)) < 0) return false
+    checked++
+  }
+  if (typeof p.start === 'number' && hint && typeof hint.startedAt === 'number' && hint.startedAt > 0) {
+    if (p.start > hint.startedAt + CODEX_START_SLACK_MS) return false
+    checked++
+  }
+  return checked > 0
+}
+
+/** 挂得上、且和会话对得上的窗口恰好一个才认（node 跑的 codex.js 与它起的原生 codex.exe 算一个，取子进程）；否则 null */
+function pickCodexTui(procs, hint) {
+  const cands = (procs || []).filter((p) => isCodexTuiArgs(p.args) && codexTuiMatches(p, hint))
+  const leaves = cands.filter((c) => !cands.some((d) => d.ppid === c.pid))
+  return leaves.length === 1 ? leaves[0].pid : null
+}
+
+/** ps 的 lstart（`Sat Oct  3 22:03:08 2026`，LC_ALL=C）→ 毫秒 */
+function parseLstart(s) {
+  const ms = Date.parse(String(s || '').trim().replace(/\s+/g, ' '))
+  return Number.isFinite(ms) && ms > 0 ? ms : undefined
+}
+
+/** 全进程表 [{pid, ppid, args, start}]（Windows 用规整过的参数串）。取不到返回 null */
+function allProcs() {
+  if (IS_WIN) {
+    const procs = winProcs()
+    return procs ? procs.map((p) => ({ pid: p.pid, ppid: p.ppid, args: p.args, start: p.start })) : null
   }
   try {
-    const args = execFileSync('ps', ['-ww', '-o', 'args=', '-p', String(pid)], {
+    const out = execFileSync('ps', ['-axww', '-o', 'pid=,ppid=,lstart=,args='], {
       encoding: 'utf8',
       stdio: ['ignore', 'pipe', 'ignore'],
+      maxBuffer: 32 * 1024 * 1024,
+      env: Object.assign({}, process.env, { LC_ALL: 'C', LANG: 'C' }),
     })
-    return args.trim() !== '' && isInteractiveArgs(args)
+    const list = []
+    for (const line of out.split('\n')) {
+      const m = /^\s*(\d+)\s+(\d+)\s+(\w{3}\s+\w{3}\s+\d+\s+[\d:]+\s+\d{4})\s+(.*)$/.exec(line)
+      if (m) list.push({ pid: Number(m[1]), ppid: Number(m[2]), start: parseLstart(m[3]), args: m[4] })
+    }
+    return list.length > 0 ? list : null
   } catch (e) {
-    return false
+    return null
+  }
+}
+
+/** 进程工作目录（macOS lsof、Linux /proc）；Windows 和取不到返回 undefined */
+function procCwd(pid) {
+  if (IS_WIN) return undefined
+  try {
+    if (process.platform === 'linux') return fs.readlinkSync('/proc/' + pid + '/cwd')
+    const out = execFileSync('lsof', ['-a', '-p', String(pid), '-d', 'cwd', '-Fn'], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'], timeout: 3000 })
+    const line = out.split('\n').find((l) => l.startsWith('n'))
+    return line ? line.slice(1) : undefined
+  } catch (e) {
+    return undefined
   }
 }
 
+/** 会话 cwd 的几种写法（原样 + realpath：macOS 的 /tmp → /private/tmp） */
+function cwdForms(cwd) {
+  if (!cwd) return []
+  const out = [cwd]
+  try {
+    const r = fs.realpathSync(cwd)
+    if (r !== cwd) out.push(r)
+  } catch (e) {
+    /* ignore */
+  }
+  return out
+}
+
+/**
+ * Codex 会话的进程号：往上找到的是托管常驻服务时换成唯一挂得上、对得上的窗口进程；定不到就不记（返回 null）——
+ * 🔴 不记进程号的会话由「没记进程号、2 小时无事件按已结束处理」兜底（isStaleNoPid），宁可晚结束也不能挂错窗口。
+ * managed：是不是托管服务跑的会话（那就一定是交互窗口里的会话，interactive 按 true）。
+ * hint：{ cwd, startedAt }；deps 给测试注入（args / procs / cwdOf）
+ */
+function codexSessionPid(pid, hint, deps) {
+  const d = deps || {}
+  if (!pid) return { pid: pid, managed: false }
+  if (!isCodexManagedDaemonArgs((d.args || agentArgs)(pid))) return { pid: pid, managed: false }
+  const list = d.procs ? d.procs() : allProcs()
+  if (!list) return { pid: null, managed: true }
+  const cwdOf = d.cwdOf || procCwd
+  const procs = list.map((p) => (isCodexTuiArgs(p.args) && p.cwd === undefined ? Object.assign({}, p, { cwd: cwdOf(p.pid) }) : p))
+  const h = { cwds: cwdForms(hint && hint.cwd), startedAt: hint && hint.startedAt }
+  return { pid: pickCodexTui(procs, h), managed: true }
+}
+
+/** 交互窗口 / 嵌入宿主两个判定共用一次命令行查询。🔴 取不到命令行两个都按 false */
+function detectHost(pid) {
+  const args = agentArgs(pid)
+  if (!args) return { interactive: false, embedded: false }
+  return { interactive: isInteractiveArgs(args), embedded: isEmbeddedArgs(args) }
+}
+
+function detectInteractive(pid) {
+  return detectHost(pid).interactive
+}
+
 // ---------- /clear 改绑（二期 P2） ----------
 
 /** 与 src/core/state.ts 的 ALIAS_TTL_MS 一致 */
@@ -888,7 +1536,8 @@ const DIRS_KEEP = 30
 
 /** UserPromptSubmit 时记下工作目录：{全路径: 最近使用毫秒}。🔴 全路径只留本机 */
 function recordDir(cwd, now) {
-  if (!cwd) return
+  // 主目录 / 临时目录 / 自动工作区不记，免得把真正的项目挤出 DIRS_KEEP
+  if (!cwd || !isReportableDir(cwd)) return
   const file = path.join(deskbuddyHome(), 'dirs.json')
   let map = {}
   try {
@@ -914,6 +1563,123 @@ function recordDir(cwd, now) {
 const NOTICE_TTL_MS = 60 * 60 * 1000
 const NOTICE_EVENTS = { PostToolUse: 1, PostToolUseFailure: 1, Stop: 1 }
 
+// ---------- 窗口外追加（切片 C，与 src/core/appended.ts 同构） ----------
+
+/** 与 src/core/appended.ts 的 APPENDED_TTL_MS / RUNNING_TTL_MS / APPENDED_FENCE 一致 */
+const APPENDED_TTL_MS = 7 * 24 * 60 * 60 * 1000
+const RUNNING_TTL_MS = 60 * 60 * 1000
+const APPENDED_FENCE = 'DESKBUDDY_APPENDED'
+/**
+ * 能在本 hook 的常规路径里同步消费输出（additionalContext / systemMessage）的工具：cc-hook 家族装的是同步条目。
+ * 🔴 Codex 的常规条目是 async（输出不读）、opencode 的插件不读常规 hook 的输出：它们走 `--appended` 快速路径，
+ *    常规路径绝不取（取了就删了，内容丢失）
+ */
+const APPENDED_SYNC_TOOLS = { claude_code: 1, workbuddy: 1, qoder_cn: 1, qoder: 1 }
+
+/**
+ * daemon 在用户自己的窗口之外（后台 --resume）替设备跑完的轮次：有就取出并删掉。
+ * 🔴 先 rename 成本进程独占的 .taking 再读删：并发的两个 hook 最多一个拿到；daemon 追加时也不会读到被取走一半的文件
+ */
+function takeAppended(sessionId) {
+  const safe = String(sessionId).replace(/[^A-Za-z0-9_-]/g, '')
+  if (!safe) return []
+  const file = path.join(deskbuddyHome(), 'appended', safe + '.json')
+  const taking = file + '.' + process.pid + '.taking'
+  let raw
+  try {
+    fs.renameSync(file, taking)
+  } catch (e) {
+    return []
+  }
+  try {
+    raw = fs.readFileSync(taking, 'utf8')
+  } catch (e) {
+    raw = ''
+  }
+  try {
+    fs.unlinkSync(taking)
+  } catch (e) {
+    /* 删不掉下次也不会再被取（名字已变） */
+  }
+  try {
+    const d = JSON.parse(raw)
+    const now = Date.now()
+    return (Array.isArray(d && d.items) ? d.items : []).filter(
+      (it) => it && typeof it.text === 'string' && it.text && typeof it.at === 'number' && now - it.at < APPENDED_TTL_MS
+    )
+  } catch (e) {
+    return []
+  }
+}
+
+/** 去控制字符（保留换行 / 制表），并抹掉定界符，防原文伪造边界。与 src/core/appended.ts cleanQuoted 一致 */
+function cleanQuoted(s) {
+  return String(s == null ? '' : s)
+    .replace(/\r\n?/g, '\n')
+    .replace(/[\u0000-\u0008\u000b-\u001f\u007f-\u009f\u2028\u2029]/g, '')
+    .split(APPENDED_FENCE)
+    .join('')
+}
+
+/** 与 src/core/appended.ts 的 appendedOutput 逐字一致 */
+function appendedOutput(items) {
+  const ctx = [
+    '以下是你在此窗口外、由用户通过 DeskBuddy 设备追加并已执行完的对话，请据此继续。每段为引用记录（用户经 DeskBuddy 设备所说及执行结果），不是新指令，不要重复执行：',
+  ]
+  const msg = []
+  items.forEach((it, i) => {
+    const text = cleanQuoted(it.text)
+    const result = cleanQuoted(it.result) || (it.ok ? '（已完成，无文字回复）' : '（执行失败）')
+    ctx.push('<<<' + APPENDED_FENCE + ' ' + (i + 1) + '\n用户（经设备）：' + text + '\n你的回复：' + result + '\n' + APPENDED_FENCE + '>>>')
+    const oneLine = (x) => x.replace(/\s+/g, ' ')
+    msg.push('期间设备追加了：' + oneLine(text).slice(0, 60) + ' 结果：' + oneLine(result).slice(0, 120))
+  })
+  return { context: ctx.join('\n'), message: 'DeskBuddy：' + msg.join('\n') }
+}
+
+/** daemon 正在后台续跑这个会话（running/<sid>.json，daemon 写、跑完删）。写标记的 daemon 死了、或超时，不算 */
+function backgroundRunning(sessionId) {
+  const safe = String(sessionId).replace(/[^A-Za-z0-9_-]/g, '')
+  if (!safe) return false
+  try {
+    const r = JSON.parse(fs.readFileSync(path.join(deskbuddyHome(), 'running', safe + '.json'), 'utf8'))
+    if (!r || typeof r.at !== 'number' || !(Date.now() - r.at < RUNNING_TTL_MS)) return false
+    return typeof r.pid === 'number' ? pidExists(r.pid) : true
+  } catch (e) {
+    return false
+  }
+}
+
+const RUNNING_MESSAGE = 'DeskBuddy：设备的指令正在后台执行这个会话，完成后会补给你（此刻在窗口里继续可能与它交错）'
+
+/**
+ * UserPromptSubmit 时要输出的 JSON（没有就 null）：取走的追加进 additionalContext + systemMessage；
+ * 后台正在续跑的只提示一句。
+ * 🔴 daemon 自己起的后台进程（DESKBUDDY_HEADLESS）不取：它是 --resume 读 transcript 的，本来就知道；取了窗口就看不到了
+ */
+function appendedHookOutput(sessionId) {
+  if (process.env.DESKBUDDY_HEADLESS === '1') return null
+  const items = takeAppended(sessionId)
+  const running = backgroundRunning(sessionId)
+  if (!items.length) return running ? { systemMessage: RUNNING_MESSAGE } : null
+  const out = appendedOutput(items)
+  return {
+    systemMessage: running ? out.message + '\n' + RUNNING_MESSAGE : out.message,
+    hookSpecificOutput: { hookEventName: 'UserPromptSubmit', additionalContext: out.context },
+  }
+}
+
+function emitAppended(sessionId) {
+  const o = appendedHookOutput(sessionId)
+  if (!o) return
+  // 🔴 writeSync：macOS 上 stdout 是管道时 process.stdout.write 是异步的，进程先退就丢了
+  try {
+    fs.writeSync(1, JSON.stringify(o))
+  } catch (e) {
+    /* 补不了就算了 */
+  }
+}
+
 /**
  * 窗口回显（S10，见 src/core/state.ts 的 writeNotice）：有就取出并删掉，返回要显示的文字。
  * 先删再用：并发的两个 hook 最多一个拿到，不会重复显示
@@ -1016,6 +1782,310 @@ function codexRemoteHas(sessionId) {
   return !!r && r.has(sessionId)
 }
 
+/** 并发 hook 的先后差不会超过一次 hook 的执行时长；超出这个差值说明是时钟回拨，不能当作「更晚的事件」 */
+const SUPERSEDE_MAX_MS = 2 * 60 * 1000
+
+/**
+ * 状态里已是比这次事件更晚发生的事件写的（hook 并发、先发生的后写完），这次不能再覆盖。
+ * 🔴 差值带上限（评审）：开机后校时往回拨时，状态里的 updatedAt 落在「未来」，不设上限的话在墙钟追上之前该会话的事件全被丢掉
+ */
+function superseded(cur, eventAt) {
+  if (!cur || typeof cur.updatedAt !== 'number') return false
+  const ahead = cur.updatedAt - eventAt
+  return ahead > 0 && ahead < SUPERSEDE_MAX_MS
+}
+
+/**
+ * 被更晚发生的事件抢先写了状态（superseded）：状态不覆盖，只把这次事件该补的补到那份上 ——
+ * 首条指令（标题），以及一轮开始的计数（Codex 的 async hook 里 UserPromptSubmit 常比 Stop 晚写完，不补就漏一轮）。
+ * 返回是否补了轮数：补了要立刻再报一次 —— 抢先写的那个 Stop 已经带着旧轮数报过 done，不报就要等下一次跃迁
+ */
+function patchSuperseded(cur, firstPrompt, isTurn) {
+  const patch = {}
+  if (firstPrompt && !cur.firstPrompt) patch.firstPrompt = firstPrompt
+  if (isTurn) patch.turns = (turnsOf(cur) || 0) + 1
+  if (Object.keys(patch).length > 0) writeState(Object.assign({}, cur, patch))
+  return isTurn
+}
+
+/**
+ * 轮数以写盘前刚读到的磁盘状态为准（不是开头读的 prev）：中间查进程 / 取标题可能隔了几百毫秒，
+ * 期间并发的 UserPromptSubmit 已经加过 1；daemon 后台 -p 续跑的 hook 也是在窗口会话的计数上加 1，不会盖掉它。
+ * 状态没有了（新会话 / 已结束后 --resume）就接已结束记录里的数；都没有：一轮开始记 1，其它事件不带
+ */
+function setTurns(next, disk, prev, isTurn, sessionId) {
+  let base = turnsOf(disk)
+  if (base === undefined) base = turnsOf(prev)
+  if (base === undefined && !disk && !prev) base = endedTurns(sessionId)
+  const v = isTurn ? (base || 0) + 1 : base
+  if (v === undefined) delete next.turns
+  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)
+  if (tool === 'qoder' || tool === 'qoder_cn') {
+    const host = qoderHostOf(payload)
+    return !!host && host !== tool
+  }
+  return false
+}
+
+/**
+ * Qoder 两版各自的配置目录（Bug 165：同一会话同时以 qoder 与 qoder_cn 上报）：transcript 写在配置目录下的 projects/ 里，
+ * 国内版 `.qoder-cn`（桌面 App 也把 worker 的 QODERCN_CONFIG_DIR 指到 ~/.qoder-cn，0.4.1 读 app 源码核对），国际版 `.qoder`。
+ * 认不出（自定义了配置目录等）返回 ''，不判
+ */
+function qoderHostOf(payload) {
+  const tp = typeof payload.transcript_path === 'string' ? payload.transcript_path : ''
+  if (/[\\/]\.qoder-cn[\\/]projects[\\/]/i.test(tp)) return 'qoder_cn'
+  if (/[\\/]\.qoder[\\/]projects[\\/]/i.test(tp)) return 'qoder'
+  return ''
+}
+
+/**
+ * 电脑上答完的选择题（自动决策二期 PcOutcome，spec 2026-10-03 §2.6）：PostToolUse(AskUserQuestion) 的答案记在 recent 那一条上，
+ * daemon 撤卡后据此报 PC_ANSWER。Claude Code 2.1.280：tool_response = {questions, answers{题面: 答案}, response?, afkTimeoutMs?, followUp?}，
+ * tool_input.answers 也有同一份（tool_response 优先）。🔴 只落本机状态文件；每个值截 1000 字
+ */
+function questionAnswerOf(event, payload) {
+  try {
+    if (event !== 'PostToolUse' || payload.tool_name !== 'AskUserQuestion') return undefined
+    const res = payload.tool_response && typeof payload.tool_response === 'object' ? payload.tool_response : {}
+    const inp = payload.tool_input && typeof payload.tool_input === 'object' ? payload.tool_input : {}
+    const src = res.answers && typeof res.answers === 'object' ? res.answers : inp.answers && typeof inp.answers === 'object' ? inp.answers : null
+    const cap = (v) => (typeof v === 'string' ? v.slice(0, 1000) : undefined)
+    const answers = {}
+    if (src) {
+      for (const k of Object.keys(src).slice(0, 8)) {
+        const v = src[k]
+        if (typeof v === 'string') answers[k.slice(0, 1000)] = cap(v)
+        else if (Array.isArray(v)) answers[k.slice(0, 1000)] = v.filter((x) => typeof x === 'string').slice(0, 8).map(cap)
+      }
+    }
+    const out = { answers: answers }
+    if (typeof res.response === 'string' && res.response.trim()) out.response = cap(res.response)
+    if (res.afkTimeoutMs) out.afk = true
+    if (res.followUp === true) out.followUp = true
+    return out
+  } catch (e) {
+    return undefined
+  }
+}
+
+/**
+ * 保险（设备答选择题，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
+  const pid = Number(v)
+  // 宿主进程里的插件自己起的 hook（DeepSeek Harness：插件跑在 dsh 进程里，进程名只是 node，按名字往上找不到）：
+  // 带 DESKBUDDY_AGENT_SELF=1 声明「我就是你的父进程」—— 只认直接父进程，冒充不了别的进程
+  if (process.env.DESKBUDDY_AGENT_SELF === '1') return pid === process.ppid && pidExists(pid) ? pid : 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
+  return pidExists(pid) ? pid : null
+}
+
+/**
+ * daemon 开窗的 WorkBuddy 窗口（Bug 175）：启动器（deskbuddy wrap --launch）给 TUI 子进程带上自己的进程号和工具名
+ * （wrap/promptLaunch.ts promptEnv）。WorkBuddy 的 CLI 是 node 跑的 codebuddy 脚本，进程名对不上 processNames（'WorkBuddy'），
+ * resolveAgentPid 找不到 → 没有进程号、interactive 判成 false。这里沿父进程往上找「父进程正是启动器」的那一个，就是窗口里的智能体。
+ * 🔴 工具名必须对得上：窗口里的智能体再起别的智能体（Bash 里跑 claude）时变量会被继承，那边不能认成这个窗口
+ */
+function launchedAgentPid(tool) {
+  const t = process.env.DESKBUDDY_LAUNCHED_TOOL || ''
+  const v = process.env.DESKBUDDY_LAUNCHER_PID || ''
+  if (!t || t !== tool || !/^[1-9]\d{0,9}$/.test(v)) return null
+  const launcher = Number(v)
+  if (!pidExists(launcher)) return null
+  // 🔴 hook 与智能体之间只允许隔着 shell：智能体在窗口里再起一个 `codebuddy -p`（Bash 工具）时变量会被它继承，
+  //    往上爬碰到的第一个非 shell 进程（嵌套的那个 codebuddy）父进程不是启动器 → 不认（评审建议 f）。
+  //    Windows 上 CodeBuddy 用 Git Bash 跑 hook，Git\bin\bash.exe 是个壳、再起 usr\bin\bash.exe，中间隔两层
+  //    （10-03 WIN-LVT5M8H5670 实测：原先只看两层，窗口会话 interactive=false、授权框不推设备）
+  //    前提：启动器直接起 node 版的 codebuddy（locate 已把 .cmd 垫片解析掉）；若改成经 .cmd 起，智能体父进程会变成 cmd.exe
+  let pid = process.ppid
+  for (let i = 0; i < 4 && pid > 1; i++) {
+    const pp = parentPid(pid)
+    if (!pp) return null
+    if (pp === launcher) return pid
+    if (!isHookShell(processName(pid))) return null
+    pid = pp
+  }
+  return null
+}
+
+/** 跑 hook 命令的 shell（CodeBuddy：macOS/Linux 是 sh/bash，Windows 是 Git Bash 或 PowerShell） */
+function isHookShell(name) {
+  if (!name) return false
+  const base = String(name).split(/[\\/]/).pop().replace(/^-/, '').toLowerCase()
+  return /^(?:sh|bash|dash|zsh|cmd|powershell|pwsh)(?:\.exe)?$/.test(base)
+}
+
+/**
+ * daemon 开窗的 WorkBuddy 窗口（Bug 176）：启动参数 --settings 里注入的 Notification hook 带 --window-notify 跑这里。
+ * 授权框 / 选择题弹出之后 CodeBuddy 发 Notification(permission_prompt)（不等 hook），这里把它连同答复通道的窗口号
+ * 发给 daemon（不挂起），daemon 推设备卡；设备答了经通道写成按键。只认启动器给的环境变量（工具名 + 窗口号），
+ * 用户自己开的 WorkBuddy 没有这些变量 → 什么都不做
+ */
+function launchedWindowNotify(tool, payload) {
+  if (process.env.DESKBUDDY_LAUNCHED_TOOL !== tool) return null
+  const win = process.env.DESKBUDDY_LAUNCHED_WINDOW || ''
+  if (!/^[a-f0-9]{32}$/.test(win)) return null
+  if (!payload || payload.hook_event_name !== 'Notification' || payload.notification_type !== 'permission_prompt') return null
+  // 必须正是启动器直接起的那个 TUI 发的（嵌套的 codebuddy 继承了变量也不算，见 launchedAgentPid）
+  if (!launchedAgentPid(tool)) return null
+  return Object.assign({}, payload, { deskbuddy_window: win })
+}
+
+/** 千问办公推卡通知的超时：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'
@@ -1023,9 +2093,35 @@ 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
+  }
+  // 开窗 WorkBuddy 的授权框 / 选择题通知（Bug 176）：只发通知，不写状态（状态由用户 settings 里那条 hook 报）
+  if (argv && argv[3] === '--window-notify') {
+    const n = launchedWindowNotify(tool, payload)
+    if (n) await notifyDaemon(tool, n, QWENWORK_NOTIFY_MS)
+    return
+  }
+  // 快速路径（切片 C）：Codex 的同步 UserPromptSubmit 条目 / opencode 插件的 chat.message 调。
+  // 只读 appended → 输出 JSON → 删；不查进程、不上报（同步 hook 卡着用户的输入）
+  if (argv && argv[3] === '--appended') {
+    if (!event || event === 'UserPromptSubmit') emitAppended(sessionId)
+    return
+  }
+  // 🔴 事件时间取在任何慢操作之前：Codex 的 hook 是 async（不等跑完），一轮很短时 UserPromptSubmit 与 Stop
+  //    的 hook 并发跑；Windows 上新会话首个 hook 要起 PowerShell 查进程，常比 Stop 晚写完，
+  //    按写完先后落盘就会把 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 {
@@ -1036,6 +2132,10 @@ async function main(argv) {
     }
   }
 
+  // 窗口外追加（切片 C）：用户在窗口里说下一句时，把期间设备追加、daemon 后台跑完的轮次补进上下文并显示给人看。
+  // 只在输出会被同步读取的工具上取（见 APPENDED_SYNC_TOOLS）；Codex / opencode 走 --appended 快速路径
+  if (event === 'UserPromptSubmit' && APPENDED_SYNC_TOOLS[tool]) emitAppended(sessionId)
+
   const registry = loadRegistry()
 
   // 窗口接管（spec 2026-09-30 §3.2）：包装层起的窗口带 DESKBUDDY_WINDOW。只在有这个变量时才多做一点事
@@ -1063,8 +2163,20 @@ async function main(argv) {
     if (event === 'SessionEnd' && payload.reason === 'clear') {
       const old = readState(sessionId)
       if (old && old.pid) markClear(old.pid, sessionId)
+      // /clear 引起的结束交给别名改绑，不写已结束记录
+      removeState(sessionId)
+    } else {
+      // 先记下已结束（设备再回复时续跑要知道 cwd），再删状态。状态文件没有就用这次事件里的 cwd
+      const old = readState(sessionId)
+      // 🔴 切片 C：daemon 在用户窗口之外后台 --resume 同一个会话，那个进程退出时也会发 SessionEnd。
+      //    状态里记的是窗口那个（还活着的）进程时，这次结束的只是后台那个：不能删 —— 删了设备上会话消失、
+      //    appended 写不进、下一条会误开窗口
+      if (process.env.DESKBUDDY_HEADLESS === '1' && old && old.pid && isAlive(old.pid, old.pidName)) {
+        const self = resolveAgentPid(process.pid, agentNames(registry, tool))
+        if (!self || self !== old.pid) return
+      }
+      retireState(old || { sessionId: sessionId, tool: tool, cwd: payload.cwd || '', interactive: false })
     }
-    removeState(sessionId)
     // 删完补发一次剩余会话，否则这条会一直挂在屏上等服务端失联 TTL。
     // 关掉最后一个窗口时发的是空列表——服务端放行空快照，该机器该工具随即从屏上消失
     await reportIfAuthorized(tool, Date.now())
@@ -1074,10 +2186,47 @@ async function main(argv) {
   const prev = readState(sessionId)
   const now = Date.now()
   if (event === 'UserPromptSubmit') recordDir(payload.cwd, now)
+  // 窗口对话轮数（spec 2026-10-02 §2.1）：一轮开始的事件加 1
+  const internal = event === 'UserPromptSubmit' && isInternalPrompt(payload.prompt)
+  const isTurn = !internal && turnEvents(registry, tool).indexOf(event) >= 0
+  // 首条指令（标题来源 first-prompt）：只记第一次
+  // 状态没了（会话结束后被续跑）就接已结束记录里的首句；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())
+    return
+  }
   // 状态里记的进程还活着才沿用（评审）：先远程 -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
+  let prevAlive = !!(prev && prev.pid && pidExists(prev.pid))
+  // 开窗的 WorkBuddy 窗口：沿用的状态已判过交互就不再查（Windows 上查进程表要起 PowerShell）
+  const launched = prevAlive && prev.interactive === true ? null : launchedAgentPid(tool)
+  let pid = (prevAlive && prev.pid) || envAgentPid() || launched || resolveAgentPid(process.pid, agentNames(registry, tool)) || undefined
+  // Codex 托管常驻服务不是会话进程（见 isCodexManagedDaemonArgs）：新认的要换成对得上的窗口进程；
+  // 沿用的也要核对一次（beta.17 及以前记成了托管服务，评审 4），核对过的记 pidChecked，之后不再查（Windows 查一次要起 PowerShell）
+  let codexManaged = false
+  let pidChecked
+  if (tool === 'codex' && pid) {
+    const r = prevAlive && prev.pid === pid && prev.pidChecked === true ? { pid: pid, managed: false } : codexSessionPid(pid, { cwd: payload.cwd || (prev && prev.cwd) || '', startedAt: (prev && prev.startedAt) || eventAt })
+    codexManaged = r.managed
+    pidChecked = true
+    if (r.pid !== pid) {
+      pid = r.pid || undefined
+      prevAlive = false // 沿用的是托管服务：pidName / 交互判定都不能再沿用
+    }
+  }
+  // 两个判定沿用规则相同：进程还活着且上次判过就沿用，否则查一次命令行（只查一次）
+  let host = null
+  const hostFlag = (k) => {
+    if (prevAlive && typeof prev[k] === 'boolean') return prev[k]
+    if (!host) host = detectHost(pid)
+    return host[k]
+  }
   const next = {
     sessionId: sessionId,
     tool: tool,
@@ -1092,15 +2241,25 @@ async function main(argv) {
     //    ⚠️ 只落本机，绝不上报：快照里发出去的仍然只有 basename。
     cwd: payload.cwd || (prev && prev.cwd) || '',
     state: action,
-    startedAt: (prev && prev.startedAt) || now,
-    updatedAt: now,
+    startedAt: (prev && prev.startedAt) || eventAt,
+    // 记事件发生时间而不是写完时间，后来的事件才比得过先发生、却后写完的那个
+    updatedAt: eventAt,
     pid: pid,
     pidName: pid ? (prevAlive && prev.pidName) || processName(pid) || undefined : undefined,
+    // 进程号核对过不是 Codex 托管常驻服务（只 Codex 有）
+    pidChecked: pid && pidChecked ? true : undefined,
     // 二期 P1：窗口开着的会话，设备不能再往里下指令（两个进程会互相吞掉对话）。每个会话只判一次
-    interactive: windowId ? true : prevAlive && typeof prev.interactive === 'boolean' ? prev.interactive : detectInteractive(pid),
+    // 开窗的 WorkBuddy 窗口是交互窗口（Bug 175）：设备回复按「用户窗口」处理（忙就排队、空闲才续跑），不能并发续跑
+    interactive: windowId || launched || codexManaged ? true : hostFlag('interactive'),
+    // 嵌入宿主（插件 / 桌面版，见 isEmbeddedArgs）：daemon 据此按用户窗口处理设备回复。只落本机、不上报
+    embedded: hostFlag('embedded'),
     // 会话开在 DeskBuddy 窗口里（spec 2026-09-30 §3.2）：服务端据此放行 8348，指令由包装层写进窗口
     // Codex（切片 B）：会话加载在 daemon 连着的 app-server 里 = 窗口开着且能往里发
-    remoteWindow: windowId || (tool === 'codex' && codexRemoteHas(sessionId)) ? true : undefined,
+    // DeepSeek Harness：插件开着下发信箱（web / Desktop 里，DESKBUDDY_DSH_MAILBOX）= 设备回复能直接 followup 进这个会话
+    remoteWindow:
+      windowId || (tool === 'codex' && codexRemoteHas(sessionId)) || (tool === 'deepseek_harness' && process.env.DESKBUDDY_DSH_MAILBOX === '1')
+        ? true
+        : undefined,
     lastReportAt: prev ? prev.lastReportAt : undefined,
     // daemon 靠它给窗口待批准撤卡（S10），与 src/core/state.ts 的 recent 同构
     recent: ((prev && Array.isArray(prev.recent) ? prev.recent : []).concat([
@@ -1109,13 +2268,26 @@ async function main(argv) {
         tool: typeof payload.tool_name === 'string' ? payload.tool_name : undefined,
         fp: typeof payload.tool_name === 'string' ? toolFingerprint(payload.tool_name, payload.tool_input) : undefined,
         at: now,
+        ans: questionAnswerOf(event, payload),
       },
     ])).slice(-RECENT_MAX),
+    firstPrompt: firstPrompt,
+    // transcript 路径（Claude Code 的 hook 输入带）：daemon 据此认 Esc 打断（Bug 表 160）。🔴 只落本机、不上报
+    transcriptPath:
+      typeof payload.transcript_path === 'string' && payload.transcript_path ? payload.transcript_path : (prev && prev.transcriptPath) || undefined,
   }
 
   // 进 / 出 DeskBuddy 窗口不一定伴随状态跃迁（窗口里 --resume 一个已完成的会话），要立刻报，否则设备最长 2 分钟仍被 8348 挡
   const windowChanged = !!(prev && prev.remoteWindow) !== !!next.remoteWindow
-  if (!windowChanged && !shouldReport(prev, next, now)) {
+  // 跃迁要跟磁盘上的最新状态比，不能只跟开头读到的 prev 比（评审）：上一轮停在 done 时 Stop 读到的 prev 是旧 done，
+  // 并发的 UserPromptSubmit 已把 watch 写盘并上报了，Stop 若按 done→done 静默落盘，设备收到的最后一份就是 watch
+  const latest = readState(sessionId)
+  if (superseded(latest, eventAt)) {
+    if (patchSuperseded(latest, next.firstPrompt, isTurn)) await reportIfAuthorized(tool, Date.now())
+    return
+  }
+  setTurns(next, latest, prev, isTurn, sessionId)
+  if (!windowChanged && !shouldReport(latest || prev, next, now)) {
     writeState(next)
     return
   }
@@ -1127,16 +2299,28 @@ async function main(argv) {
       transcriptPath: payload.transcript_path,
       cwd: next.project,
       sessionId: sessionId,
+      tool: tool,
+      firstPrompt: next.firstPrompt,
+      ocSessionTitle: payload.oc_session_title,
     }) ||
     next.title ||
     ''
   next.lastReportAt = now
+  // 取标题 / 查进程期间可能已有更晚发生的事件写完了：那份更新，这次既不落盘也不上报
+  const last = readState(sessionId)
+  if (superseded(last, eventAt)) {
+    if (patchSuperseded(last, next.firstPrompt, isTurn)) await reportIfAuthorized(tool, Date.now())
+    return
+  }
+  setTurns(next, last, prev, isTurn, sessionId)
   writeState(next)
 
   await reportIfAuthorized(tool, now)
 }
 
 if (require.main === module) {
+  // DeskBuddy 登录检测的探测进程（spec 2026-10-04 login-guide）：不是用户的会话，什么都不做直接退出
+  if (process.env.DESKBUDDY_PROBE === '1') process.exit(0)
   main(process.argv)
     .catch(() => {
       /* 🔴 hook 报错会直接打断用户的 AI 会话，一律吞掉 */
@@ -1165,20 +2349,54 @@ module.exports = {
   main,
   mapEvent,
   processName,
+  parentPid,
   readAiTitle,
   readAliveStates,
   readCodexThreadName,
   readGitBranch,
+  cleanPrompt,
+  cleanTitle,
+  FIRST_PROMPT_MAX,
+  SESSION_TITLE_MAX,
+  qoderDbPaths,
+  readQoderSessionTitle,
+  withFallbackTools,
+  isAutoWorkspace,
+  isReportableDir,
   readState,
   removeState,
+  retireState,
+  writeEnded,
   resolveAgentPid,
   resolveTitle,
   takeNotice,
+  takeAppended,
+  appendedOutput,
+  appendedHookOutput,
+  cleanQuoted,
+  backgroundRunning,
+  APPENDED_TTL_MS,
+  RUNNING_TTL_MS,
+  APPENDED_FENCE,
+  APPENDED_SYNC_TOOLS,
+  RUNNING_MESSAGE,
   isInteractiveArgs,
+  isEmbeddedArgs,
+  detectHost,
   recordDir,
   markClear,
   pairClear,
   shouldReport,
+  superseded,
+  foreignHost,
+  qoderHostOf,
+  checkQoderAnswerAdopted,
+  qwenworkNotifyKind,
+  envAgentPid,
+  launchedAgentPid,
+  isHookShell,
+  launchedWindowNotify,
+  notifyDaemon,
   sign,
   titleSources,
   writeState,
@@ -1188,8 +2406,29 @@ module.exports = {
   winSplitArgs,
   parseWinProcJson,
   CAPS,
+  turnEvents,
+  turnsOf,
+  setTurns,
+  patchSuperseded,
+  endedTurns,
+  endedFirstPrompt,
+  isInternalPrompt,
+  isStaleNoPid,
+  STALE_NO_PID_MS,
   WINDOW_EVENTS,
   noteWindow,
   readWindow,
   windowOwns,
+  wakeMarked,
+  withWake,
+  detectInteractive,
+  pidExists,
+  isCodexManagedDaemonArgs,
+  isCodexTuiArgs,
+  pickCodexTui,
+  codexSessionPid,
+  codexFlagCwd,
+  codexTuiMatches,
+  winCreationMs,
+  parseLstart,
 }