deskbuddy 0.1.0 → 0.2.0-beta.1

package/dist/gate.cjs

@@ -0,0 +1,249 @@
+#!/usr/bin/env node
+'use strict'
+// 远程执行的「授权关卡」。daemon 起智能体时把它挂成 PreToolUse hook：
+//   node gate.cjs --run <runId>
+// 智能体每次要调工具都会先跑一次它。它只做一件事：把 hook 输入转给 daemon，
+// 把 daemon 的决定翻译成 hook 输出。分类、等待、和设备打交道全在 daemon 里。
+//
+// 🔴 铁律：**任何失败都 exit 2**。
+//    实测（2026-09-23，Qoder CN 1.1.61）：hook 崩溃、HTTP hook 连不上，智能体【照常执行】。
+//    Qoder 必须开 bypass_permissions 才能用，这时本脚本就是唯一的关卡 ——
+//    一个没接住的异常、一次 exit 0 的兜底，就等于把设备授权整个绕过去。
+//    exit 2 是四家公认的「阻止这次工具调用」，实测能拦住。
+//
+// 🔴 与 hook.cjs 相反，这里【不设超时】：用户可能过很久才在设备上按下允许，
+//    等待就是它的本职。超时由智能体那边的 hook timeout 兜（daemon 配 7 天）。
+//
+// 🔴 `--window` 模式（S10）的兜底方向**相反**：任何失败都 exit 0 且不输出。
+//    那是用户自己窗口里的 PermissionRequest hook，设备只是多一个答复的地方；不表态 = 授权框照常由人处理。
+//    PermissionRequest 下 exit 2 = 拒绝 —— 沿用上面的铁律，daemon 一挂，用户窗口里每个授权都会被自动拒掉。
+//
+// 只 require Node 内置模块，理由同 hook.cjs 顶部 ①。
+const fs = require('node:fs')
+const os = require('node:os')
+const path = require('node:path')
+const http = require('node:http')
+const { execFileSync } = require('node:child_process')
+
+const DECISIONS = new Set(['allow', 'deny', 'defer'])
+const WINDOW = process.argv.includes('--window')
+
+function fail(why) {
+  // 窗口模式：不表态，见顶部
+  if (WINDOW) process.exit(0)
+  try {
+    process.stderr.write(`DeskBuddy 授权关卡：${why}，已阻止这次操作\n`)
+  } catch (_) {
+    /* stderr 都写不了也必须继续走到 exit 2 */
+  }
+  process.exit(2)
+}
+
+function deskbuddyHome() {
+  return process.env.DESKBUDDY_HOME || path.join(os.homedir(), '.deskbuddy')
+}
+
+function argRun(argv) {
+  const i = argv.indexOf('--run')
+  const v = i >= 0 ? argv[i + 1] : ''
+  return typeof v === 'string' && /^[0-9a-zA-Z_-]{1,64}$/.test(v) ? v : ''
+}
+
+function readStdin() {
+  return new Promise((resolve, reject) => {
+    let buf = ''
+    process.stdin.setEncoding('utf8')
+    process.stdin.on('data', (c) => (buf += c))
+    process.stdin.on('end', () => resolve(buf))
+    process.stdin.on('error', reject)
+  })
+}
+
+function post(port, token, body) {
+  return new Promise((resolve, reject) => {
+    const req = http.request(
+      {
+        host: '127.0.0.1',
+        port,
+        method: 'POST',
+        path: '/gate',
+        headers: {
+          'content-type': 'application/json',
+          'content-length': Buffer.byteLength(body),
+          'x-gate-token': token,
+        },
+      },
+      (res) => {
+        let data = ''
+        res.setEncoding('utf8')
+        res.on('data', (c) => (data += c))
+        res.on('end', () => resolve({ status: res.statusCode, data }))
+        res.on('error', reject)
+      }
+    )
+    req.on('error', reject)
+    req.end(body)
+  })
+}
+
+/**
+ * 这个 hook 是不是由【交互窗口】里的 Claude Code 触发的。
+ * 🔴 实测（2026-09-24，2.1.259）：`claude -p` 碰到要授权的工具**也会**触发 PermissionRequest，
+ * 而 hook 输入里没有区分字段。不拦的话，用户脚本 / IDE 插件 / SDK 里的 claude 会被推到设备上一直挂着。
+ * 做法：沿父进程找到 claude，启动参数里有 -p / --print / stream-json 的一律当非交互。找不到也当非交互
+ */
+/** `--tool <name>`（二期 P8：窗口模式不只 Claude Code）。缺省 claude_code，兼容已装出去的 hook 命令 */
+function argTool(argv) {
+  const i = argv.indexOf('--tool')
+  const v = i >= 0 ? argv[i + 1] : ''
+  return typeof v === 'string' && /^[a-z_]{1,32}$/.test(v) ? v : 'claude_code'
+}
+
+/**
+ * 按智能体判断是不是交互窗口。
+ * - Qoder CN（2026-09-27 实测）：桌面端弹授权框时 hook 的父进程就是 `Qoder CN.app` 主进程；
+ *   daemon 起的远程任务走 worker（node），父进程链上没有它
+ * - Claude Code：见 isInteractiveClaude
+ */
+function isInteractiveAgent(tool) {
+  if (tool === 'qoder') return hasAncestor((comm) => comm.includes('/Qoder CN.app/'))
+  if (tool === 'claude_code') return isInteractiveClaude()
+  // opencode 的窗口确认由插件发起，插件已排除 `opencode run`（hook/opencode.mjs isHeadless）
+  if (tool === 'opencode') return true
+  return false
+}
+
+function hasAncestor(match) {
+  let pid = process.ppid
+  for (let i = 0; i < 8 && pid > 1; i++) {
+    let line
+    try {
+      line = execFileSync('ps', ['-o', 'ppid=,comm=', '-p', String(pid)], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] }).trim()
+    } catch (_) {
+      return false
+    }
+    const m = line.match(/^(\d+)\s+(.*)$/)
+    if (!m) return false
+    if (match(m[2])) return true
+    pid = Number(m[1])
+  }
+  return false
+}
+
+function isInteractiveClaude() {
+  let pid = process.ppid
+  for (let i = 0; i < 8 && pid > 1; i++) {
+    let line
+    try {
+      line = execFileSync('ps', ['-o', 'ppid=,comm=', '-p', String(pid)], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] }).trim()
+    } catch (_) {
+      return false
+    }
+    const m = line.match(/^(\d+)\s+(.*)$/)
+    if (!m) return false
+    if (path.basename(m[2]) === 'claude') {
+      let args = ''
+      try {
+        args = execFileSync('ps', ['-ww', '-o', 'args=', '-p', String(pid)], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] })
+      } catch (_) {
+        return false
+      }
+      const tokens = args.trim().split(/\s+/)
+      // 短参数可能合写（`-cp`）；args 里 argv[0] 之后才算参数
+      return !tokens.slice(1).some(
+        (t) => t === '--print' || /^-[a-zA-Z]*p[a-zA-Z]*$/.test(t) || t === 'stream-json' || t.startsWith('--output-format=stream')
+      )
+    }
+    pid = Number(m[1])
+  }
+  return false
+}
+
+/** 窗口模式：daemon 回 allow / deny 才表态，其余一律不输出、exit 0 */
+async function windowMain() {
+  // DESKBUDDY_GATE_ASSUME_INTERACTIVE 只给测试用：1 当交互、0 当非交互，其余真去查进程
+  const tool = argTool(process.argv)
+  const forced = process.env.DESKBUDDY_GATE_ASSUME_INTERACTIVE
+  if (forced === '0' || (forced !== '1' && !isInteractiveAgent(tool))) return fail()
+  const conf = JSON.parse(fs.readFileSync(path.join(deskbuddyHome(), 'gate.json'), 'utf8'))
+  if (!conf || !Number.isInteger(conf.port) || typeof conf.token !== 'string' || !conf.token) return fail()
+  const hook = JSON.parse(await readStdin())
+  const res = await post(conf.port, conf.token, JSON.stringify({ mode: 'window', tool, hook }))
+  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) || '用户在设备上拒绝了这一步' }
+  const body = { hookSpecificOutput: { hookEventName: 'PermissionRequest', decision } }
+  // 窗口里告诉人是在哪台设备上处理的
+  if (typeof out.notice === 'string' && out.notice) body.systemMessage = out.notice.slice(0, 300)
+  process.stdout.write(JSON.stringify(body), () => process.exit(0))
+}
+
+async function main() {
+  if (WINDOW) return windowMain()
+  const runId = argRun(process.argv)
+  if (!runId) return fail('缺少 --run')
+
+  let conf
+  try {
+    conf = JSON.parse(fs.readFileSync(path.join(deskbuddyHome(), 'gate.json'), 'utf8'))
+  } catch (_) {
+    return fail('找不到守护进程（gate.json 读不到）')
+  }
+  if (!conf || !Number.isInteger(conf.port) || typeof conf.token !== 'string' || !conf.token) {
+    return fail('gate.json 内容不对')
+  }
+
+  let hook
+  try {
+    hook = JSON.parse(await readStdin())
+  } catch (_) {
+    return fail('读不懂 hook 输入')
+  }
+
+  let res
+  try {
+    res = await post(conf.port, conf.token, JSON.stringify({ runId, hook }))
+  } catch (e) {
+    return fail(`连不上守护进程（${(e && e.code) || 'error'}）`)
+  }
+  if (res.status !== 200) return fail(`守护进程返回 ${res.status}`)
+
+  let out
+  try {
+    out = JSON.parse(res.data)
+  } catch (_) {
+    return fail('守护进程的回复读不懂')
+  }
+  if (!out || !DECISIONS.has(out.decision)) return fail('守护进程给了不认识的决定')
+
+  const reason = typeof out.reason === 'string' ? out.reason : ''
+
+  // 🔴 拒绝一律走 stderr + exit 2，不走 JSON（评审 S5）：exit 2 是四家公认的"拦下"，
+  //    而 JSON 那条路要是 stdout 没写完进程就退了，智能体拿到的是"exit 0 + 没有决定"，
+  //    Qoder 在 bypass 下会当成放行。拒绝的方向必须不依赖任何一次写入成功
+  if (out.decision === 'deny') {
+    process.stderr.write(`${reason || '用户在设备上拒绝了这一步'}\n`, () => process.exit(2))
+    return
+  }
+
+  const payload = JSON.stringify({
+    hookSpecificOutput: {
+      hookEventName: 'PreToolUse',
+      permissionDecision: out.decision,
+      permissionDecisionReason: reason,
+    },
+  })
+  // 等写完再退：管道写入是异步的，写一半就 exit 的话 allow / defer 会丢
+  process.stdout.write(payload, (err) => (err ? fail('写 hook 输出失败') : process.exit(0)))
+}
+
+// 兜住一切没想到的异常 —— 见顶部铁律
+process.on('uncaughtException', (e) => fail(`内部错误 ${(e && e.message) || e}`))
+process.on('unhandledRejection', (e) => fail(`内部错误 ${(e && e.message) || e}`))
+main().catch((e) => fail(`内部错误 ${(e && e.message) || e}`))

package/dist/hook.cjs

@@ -22,6 +22,8 @@ const { execFileSync } = require('node:child_process')
 const DEFAULT_API_BASE = process.env.DESKBUDDY_API_BASE || 'https://api.shifengintelli.com'
 const KEEPALIVE_MS = 2 * 60 * 1000
 const MAX_SESSIONS = 20
+/** 状态文件里保留的最近事件条数，与 src/core/state.ts 的 RECENT_MAX 一致 */
+const RECENT_MAX = 8
 const REPORT_TIMEOUT_MS = 2000
 /** ServiceApi 版本，不是包路径里的 v2 */
 const GATEWAY_VERSION = '1.0'
@@ -63,7 +65,16 @@ const FALLBACK_REGISTRY = {
       format: 'cc-hook',
       processNames: ['claude'],
       titleSources: ['cc-ai-title', 'git-branch', 'project'],
-      events: { UserPromptSubmit: 'watch', PreToolUse: 'watch', PostToolUse: 'watch', Stop: 'done' },
+      events: {
+        UserPromptSubmit: 'watch',
+        PreToolUse: 'watch',
+        PostToolUse: 'watch',
+        // 工具跑失败时 Claude Code 发这个而不是 PostToolUse；窗口待批准撤卡也要认它
+        PostToolUseFailure: 'watch',
+        Stop: 'done',
+        // 窗口里弹授权框的那一刻就是待确认（S10），不等之后那条权限通知
+        PermissionRequest: 'ask_approval',
+      },
       lifecycle: { SessionStart: 'ignore', SessionEnd: 'remove' },
     },
     codex: {
@@ -81,6 +92,46 @@ const FALLBACK_REGISTRY = {
       },
       lifecycle: { SessionStart: 'ignore', SessionEnd: 'remove' },
     },
+    workbuddy: {
+      format: 'cc-hook',
+      processNames: ['WorkBuddy'],
+      titleSources: ['git-branch', 'project'],
+      events: {
+        UserPromptSubmit: 'watch',
+        PreToolUse: 'watch',
+        PostToolUse: 'watch',
+        Stop: 'done',
+        PermissionRequest: 'ask_approval',
+      },
+      lifecycle: { SessionStart: 'ignore', SessionEnd: 'remove' },
+    },
+    qoder: {
+      format: 'cc-hook',
+      processNames: ['Qoder CN'],
+      titleSources: ['git-branch', 'project'],
+      events: {
+        UserPromptSubmit: 'watch',
+        PreToolUse: 'watch',
+        PostToolUse: 'watch',
+        Stop: 'done',
+        PermissionRequest: 'ask_approval',
+      },
+      lifecycle: { SessionStart: 'ignore', SessionEnd: 'remove' },
+    },
+    opencode: {
+      format: 'oc-plugin',
+      processNames: ['opencode'],
+      // opencode 自带的会话标题是模型对提问的摘要，违反隐私约束（spec §6.4），不用
+      titleSources: ['git-branch', 'project'],
+      events: {
+        UserPromptSubmit: 'watch',
+        PreToolUse: 'watch',
+        PostToolUse: 'watch',
+        Stop: 'done',
+        PermissionRequest: 'ask_approval',
+      },
+      lifecycle: { SessionEnd: 'remove' },
+    },
   },
 }
 
@@ -429,6 +480,7 @@ function buildSnapshot(states, tool, cfg, nowMs) {
       state: s.state,
       startedAt: s.startedAt,
       updatedAt: s.updatedAt,
+      interactive: s.interactive === true,
     }))
   return { clientId: cfg.clientId, hostName: cfg.hostName, tool: tool, snapshotAt: nowMs, sessions: sessions }
 }
@@ -554,6 +606,172 @@ async function reportIfAuthorized(tool, nowMs) {
   await postReport(cfg, buildSnapshot(readAliveStates(tool), tool, cfg, nowMs))
 }
 
+/**
+ * 工具调用指纹前 16 位，与 src/daemon/gate/approvals.ts 的 fingerprint 同算法。
+ * daemon 靠它认出"跑完的正是设备上等着的那一步"，并行的同名工具不会误撤卡（S10 评审 #2）
+ */
+function toolFingerprint(toolName, toolInput) {
+  let input = ''
+  try {
+    input = JSON.stringify(toolInput === undefined ? null : toolInput)
+  } catch (e) {
+    input = String(toolInput)
+  }
+  return crypto.createHash('sha256').update(toolName).update('\0').update(input).digest('hex').slice(0, 16)
+}
+
+/**
+ * 这个智能体进程是不是【交互窗口】（二期 P1）。参数里有 -p / --print / stream-json / exec 的是
+ * 脚本、SDK 或 daemon 起的远程任务；桌面 App 与终端里的 TUI 是窗口。与 gate.cjs 的 isInteractiveClaude 同一判据。
+ * 🔴 判不出来按 false：false 只意味着"不挡远程指令"，与改动前的行为一致
+ */
+function isInteractiveArgs(args) {
+  const all = String(args || '').trim().split(/\s+/)
+  const tokens = 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
+  return !tokens.some(
+    (t) =>
+      t === '--print' ||
+      t === 'stream-json' ||
+      t.startsWith('--output-format=stream') ||
+      /^-[a-zA-Z]*p[a-zA-Z]*$/.test(t)
+  )
+}
+
+/** 只看进程在不在（kill 0），不查进程名：每次事件都要调，ps 太贵 */
+function pidExists(pid) {
+  try {
+    process.kill(pid, 0)
+    return true
+  } catch (e) {
+    return false
+  }
+}
+
+function detectInteractive(pid) {
+  if (!pid) return false
+  try {
+    const args = execFileSync('ps', ['-ww', '-o', 'args=', '-p', String(pid)], {
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'ignore'],
+    })
+    return args.trim() !== '' && isInteractiveArgs(args)
+  } catch (e) {
+    return false
+  }
+}
+
+// ---------- /clear 改绑（二期 P2） ----------
+
+/** 与 src/core/state.ts 的 ALIAS_TTL_MS 一致 */
+const ALIAS_TTL_MS = 7 * 24 * 60 * 60 * 1000
+/** SessionEnd(clear) 到 SessionStart(clear) 之间允许的间隔 */
+const CLEAR_PAIR_MS = 60 * 1000
+
+function clearMarkPath(pid) {
+  return path.join(deskbuddyHome(), 'clear', String(pid) + '.json')
+}
+
+/** SessionEnd(reason=clear)：按智能体进程号记下旧会话，等同一进程的 SessionStart(source=clear) 来配对 */
+function markClear(pid, oldSessionId) {
+  try {
+    fs.mkdirSync(path.join(deskbuddyHome(), 'clear'), { recursive: true })
+    fs.writeFileSync(clearMarkPath(pid), JSON.stringify({ old: oldSessionId, at: Date.now() }), 'utf8')
+  } catch (e) {
+    /* 改绑是锦上添花，失败就退回"旧会话失效" */
+  }
+}
+
+/** SessionStart(source=clear)：配对成功就写别名 旧 → 新 */
+function pairClear(pid, newSessionId) {
+  let mark
+  try {
+    mark = JSON.parse(fs.readFileSync(clearMarkPath(pid), 'utf8'))
+    fs.unlinkSync(clearMarkPath(pid))
+  } catch (e) {
+    return
+  }
+  if (!mark || typeof mark.old !== 'string' || !mark.old || mark.old === newSessionId) return
+  if (!(Date.now() - mark.at < CLEAR_PAIR_MS)) return
+  const file = path.join(deskbuddyHome(), 'alias.json')
+  let map = {}
+  try {
+    map = JSON.parse(fs.readFileSync(file, 'utf8')) || {}
+  } catch (e) {
+    map = {}
+  }
+  const now = Date.now()
+  for (const k of Object.keys(map)) {
+    if (!(map[k] && now - map[k].at < ALIAS_TTL_MS)) delete map[k]
+  }
+  map[mark.old] = { to: newSessionId, at: now }
+  try {
+    fs.writeFileSync(file + '.tmp', JSON.stringify(map), 'utf8')
+    fs.renameSync(file + '.tmp', file)
+  } catch (e) {
+    /* 同上 */
+  }
+}
+
+/** 最近目录最多记多少条（二期 P6，与 src/core/dirs.ts 同构；上报只取前 10） */
+const DIRS_KEEP = 30
+
+/** UserPromptSubmit 时记下工作目录：{全路径: 最近使用毫秒}。🔴 全路径只留本机 */
+function recordDir(cwd, now) {
+  if (!cwd) return
+  const file = path.join(deskbuddyHome(), 'dirs.json')
+  let map = {}
+  try {
+    map = JSON.parse(fs.readFileSync(file, 'utf8')) || {}
+  } catch (e) {
+    map = {}
+  }
+  map[cwd] = now
+  const kept = Object.entries(map)
+    .filter((e) => typeof e[1] === 'number')
+    .sort((a, b) => b[1] - a[1])
+    .slice(0, DIRS_KEEP)
+  try {
+    fs.mkdirSync(deskbuddyHome(), { recursive: true })
+    fs.writeFileSync(file + '.tmp', JSON.stringify(Object.fromEntries(kept)), 'utf8')
+    fs.renameSync(file + '.tmp', file)
+  } catch (e) {
+    /* 记不下只影响设备上的目录列表 */
+  }
+}
+
+/** 与 src/core/state.ts 的 NOTICE_TTL_MS 一致 */
+const NOTICE_TTL_MS = 60 * 60 * 1000
+const NOTICE_EVENTS = { PostToolUse: 1, PostToolUseFailure: 1, Stop: 1 }
+
+/**
+ * 窗口回显（S10，见 src/core/state.ts 的 writeNotice）：有就取出并删掉，返回要显示的文字。
+ * 先删再用：并发的两个 hook 最多一个拿到，不会重复显示
+ */
+function takeNotice(sessionId) {
+  const safe = String(sessionId).replace(/[^A-Za-z0-9_-]/g, '')
+  if (!safe) return ''
+  const file = path.join(deskbuddyHome(), 'notice', safe + '.json')
+  let raw
+  try {
+    raw = fs.readFileSync(file, 'utf8')
+    fs.unlinkSync(file)
+  } catch (e) {
+    return ''
+  }
+  try {
+    const n = JSON.parse(raw)
+    if (typeof n.text !== 'string' || !n.text || !(Date.now() - n.at < NOTICE_TTL_MS)) return ''
+    return n.text.slice(0, 300)
+  } catch (e) {
+    return ''
+  }
+}
+
 async function main(argv) {
   // 同一份 hook 被 Claude Code 与 Codex 复用，靠命令行参数区分是哪个工具
   const tool = (argv && argv[2]) || 'claude_code'
@@ -562,10 +780,33 @@ async function main(argv) {
   const sessionId = payload.session_id || ''
   if (!sessionId) return
 
+  if (NOTICE_EVENTS[event]) {
+    const notice = takeNotice(sessionId)
+    // 🔴 writeSync：macOS 上 stdout 是管道时 process.stdout.write 是异步的，进程先退就丢了
+    if (notice) {
+      try {
+        fs.writeSync(1, JSON.stringify({ systemMessage: notice }))
+      } catch (e) {
+        /* 显示不了就算了 */
+      }
+    }
+  }
+
   const registry = loadRegistry()
+
+  // /clear 改绑（二期 P2）：SessionStart 在映射表里是 ignore，要在那之前处理
+  if (event === 'SessionStart' && payload.source === 'clear') {
+    const pid = resolveAgentPid(process.pid, agentNames(registry, tool))
+    if (pid) pairClear(pid, sessionId)
+  }
+
   const action = mapEvent(registry, tool, event, payload)
   if (action === 'ignore') return
   if (action === 'remove') {
+    if (event === 'SessionEnd' && payload.reason === 'clear') {
+      const old = readState(sessionId)
+      if (old && old.pid) markClear(old.pid, sessionId)
+    }
     removeState(sessionId)
     // 删完补发一次剩余会话，否则这条会一直挂在屏上等服务端失联 TTL。
     // 关掉最后一个窗口时发的是空列表——服务端放行空快照，该机器该工具随即从屏上消失
@@ -575,19 +816,41 @@ async function main(argv) {
 
   const prev = readState(sessionId)
   const now = Date.now()
-  const pid = (prev && prev.pid) || resolveAgentPid(process.pid, agentNames(registry, tool)) || undefined
+  if (event === 'UserPromptSubmit') recordDir(payload.cwd, now)
+  // 状态里记的进程还活着才沿用（评审）：先远程 -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 next = {
     sessionId: sessionId,
     tool: tool,
     // 标题要读文件，只在真正上报时才取（见下面）；这里先沿用上一次的
     title: (prev && prev.title) || '',
     project: payload.cwd || (prev && prev.project) || '',
+    // 🔴 和 project 装的是同一个值，不是冗余：project 这个名字读起来就像「只该存目录名」
+    //    （上报侧确实只发 basename，见 snapshot.ts），早晚有人去「修」它。而远程指令靠
+    //    工作目录定位在哪执行 —— 实测 claude --resume 从任何目录都找得到会话，但 agent 的
+    //    工作目录跟着【启动目录】走：目录错了不报任何错，它会拿着对的对话去改错目录里的文件。
+    //    所以单独立一个名字说得清的字段，把这条契约钉死。
+    //    ⚠️ 只落本机，绝不上报：快照里发出去的仍然只有 basename。
+    cwd: payload.cwd || (prev && prev.cwd) || '',
     state: action,
     startedAt: (prev && prev.startedAt) || now,
     updatedAt: now,
     pid: pid,
-    pidName: pid ? (prev && prev.pidName) || processName(pid) || undefined : undefined,
+    pidName: pid ? (prevAlive && prev.pidName) || processName(pid) || undefined : undefined,
+    // 二期 P1：窗口开着的会话，设备不能再往里下指令（两个进程会互相吞掉对话）。每个会话只判一次
+    interactive: prevAlive && typeof prev.interactive === 'boolean' ? prev.interactive : detectInteractive(pid),
     lastReportAt: prev ? prev.lastReportAt : undefined,
+    // daemon 靠它给窗口待批准撤卡（S10），与 src/core/state.ts 的 recent 同构
+    recent: ((prev && Array.isArray(prev.recent) ? prev.recent : []).concat([
+      {
+        e: event,
+        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,
+      },
+    ])).slice(-RECENT_MAX),
   }
 
   if (!shouldReport(prev, next, now)) {
@@ -647,6 +910,11 @@ module.exports = {
   removeState,
   resolveAgentPid,
   resolveTitle,
+  takeNotice,
+  isInteractiveArgs,
+  recordDir,
+  markClear,
+  pairClear,
   shouldReport,
   sign,
   titleSources,