deskbuddy 0.2.0-beta.10 → 0.2.0-beta.13

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', 'resume_ended', 'reply_idle_window']
+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',
@@ -88,6 +89,7 @@ const FALLBACK_REGISTRY = {
       // codex-thread-name 是机会主义的一级：session_index.jsonl 里的 thread_name
       // 只有 /rename 或 VS Code 扩展起过名的才有，多数是空的，取不到用首条指令
       titleSources: ['codex-thread-name', 'first-prompt', 'git-branch', 'project'],
+      turnEvents: ['UserPromptSubmit'],
       events: {
         UserPromptSubmit: 'watch',
         PreToolUse: 'watch',
@@ -103,6 +105,7 @@ const FALLBACK_REGISTRY = {
       // 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',
@@ -119,6 +122,7 @@ const FALLBACK_REGISTRY = {
       // 桌面端会话库里的标题（先是首条指令，后被换成 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',
@@ -133,6 +137,7 @@ const FALLBACK_REGISTRY = {
       format: 'cc-hook',
       processNames: ['Qoder'],
       titleSources: ['qoder-session-title', 'first-prompt', 'git-branch', 'project'],
+      turnEvents: ['UserPromptSubmit'],
       events: {
         UserPromptSubmit: 'watch',
         PreToolUse: 'watch',
@@ -147,6 +152,7 @@ const FALLBACK_REGISTRY = {
       processNames: ['opencode'],
       // opencode 自己生成的会话标题（插件从 session.updated 取，随事件传 oc_session_title），没有就用首条指令
       titleSources: ['oc-session-title', 'first-prompt', 'git-branch', 'project'],
+      turnEvents: ['UserPromptSubmit'],
       events: {
         UserPromptSubmit: 'watch',
         PreToolUse: 'watch',
@@ -226,6 +232,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
@@ -730,6 +752,8 @@ function writeEnded(s, now) {
     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
     const file = path.join(dir, sid + '.json')
     fs.writeFileSync(file + '.tmp', JSON.stringify(rec), { encoding: 'utf8', mode: 0o600 })
     fs.renameSync(file + '.tmp', file)
@@ -746,6 +770,19 @@ function writeEnded(s, now) {
   }
 }
 
+/** 已结束记录里留下的轮数（与 src/core/ended.ts 的 readEnded 同一有效期）；没有返回 undefined */
+function endedTurns(sessionId) {
+  const sid = String(sessionId || '')
+  if (!/^[A-Za-z0-9_-]{1,64}$/.test(sid)) return undefined
+  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)
+  } catch (e) {
+    return undefined
+  }
+}
+
 /** 会话结束：先写已结束记录，再删状态（删状态的地方都走这里，/clear 除外） */
 function retireState(s, now) {
   writeEnded(s, now)
@@ -800,6 +837,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
 }
@@ -828,17 +867,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() }
 }
 
@@ -1027,6 +1071,22 @@ function isInteractiveArgs(args) {
   )
 }
 
+/**
+ * 嵌入宿主（插件 / 桌面版 / 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 {
@@ -1037,23 +1097,34 @@ 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 {
-    const args = execFileSync('ps', ['-ww', '-o', 'args=', '-p', String(pid)], {
+    return execFileSync('ps', ['-ww', '-o', 'args=', '-p', String(pid)], {
       encoding: 'utf8',
       stdio: ['ignore', 'pipe', 'ignore'],
-    })
-    return args.trim() !== '' && isInteractiveArgs(args)
+    }).trim()
   } catch (e) {
-    return false
+    return ''
   }
 }
 
+/** 交互窗口 / 嵌入宿主两个判定共用一次命令行查询。🔴 取不到命令行两个都按 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 一致 */
@@ -1370,6 +1441,33 @@ function superseded(cur, 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
+}
+
 async function main(argv) {
   // 同一份 hook 被 Claude Code 与 Codex 复用，靠命令行参数区分是哪个工具
   const tool = (argv && argv[2]) || 'claude_code'
@@ -1454,17 +1552,26 @@ 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 isTurn = turnEvents(registry, tool).indexOf(event) >= 0
   // 首条指令（标题来源 first-prompt）：只记第一次
   const firstPrompt = (prev && prev.firstPrompt) || (event === 'UserPromptSubmit' ? cleanPrompt(payload.prompt) : '') || undefined
   if (superseded(prev, eventAt)) {
     // 被并发的更晚事件（多半是同一轮的 Stop）抢先写了：状态不覆盖，但首条指令要补上，不然标题就成了第二条指令
-    if (firstPrompt && !prev.firstPrompt) writeState(Object.assign({}, prev, { firstPrompt: firstPrompt }))
+    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 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,
@@ -1485,7 +1592,9 @@ async function main(argv) {
     pid: pid,
     pidName: pid ? (prevAlive && prev.pidName) || processName(pid) || undefined : undefined,
     // 二期 P1：窗口开着的会话，设备不能再往里下指令（两个进程会互相吞掉对话）。每个会话只判一次
-    interactive: windowId ? true : prevAlive && typeof prev.interactive === 'boolean' ? prev.interactive : detectInteractive(pid),
+    interactive: windowId ? 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,
@@ -1508,9 +1617,10 @@ async function main(argv) {
   // 并发的 UserPromptSubmit 已把 watch 写盘并上报了，Stop 若按 done→done 静默落盘，设备收到的最后一份就是 watch
   const latest = readState(sessionId)
   if (superseded(latest, eventAt)) {
-    if (next.firstPrompt && !latest.firstPrompt) writeState(Object.assign({}, latest, { firstPrompt: next.firstPrompt }))
+    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
@@ -1533,9 +1643,10 @@ async function main(argv) {
   // 取标题 / 查进程期间可能已有更晚发生的事件写完了：那份更新，这次既不落盘也不上报
   const last = readState(sessionId)
   if (superseded(last, eventAt)) {
-    if (next.firstPrompt && !last.firstPrompt) writeState(Object.assign({}, last, { firstPrompt: next.firstPrompt }))
+    if (patchSuperseded(last, next.firstPrompt, isTurn)) await reportIfAuthorized(tool, Date.now())
     return
   }
+  setTurns(next, last, prev, isTurn, sessionId)
   writeState(next)
 
   await reportIfAuthorized(tool, now)
@@ -1602,6 +1713,8 @@ module.exports = {
   APPENDED_SYNC_TOOLS,
   RUNNING_MESSAGE,
   isInteractiveArgs,
+  isEmbeddedArgs,
+  detectHost,
   recordDir,
   markClear,
   pairClear,
@@ -1616,6 +1729,11 @@ module.exports = {
   winSplitArgs,
   parseWinProcJson,
   CAPS,
+  turnEvents,
+  turnsOf,
+  setTurns,
+  patchSuperseded,
+  endedTurns,
   WINDOW_EVENTS,
   noteWindow,
   readWindow,

package/hook/opencode.d.mts

@@ -8,3 +8,4 @@ export function userText(output: unknown): string
 export function rememberTitle(titles: Map<string, string>, info: unknown): void
 export function make(opts?: { node?: string }): (ctx: unknown) => Promise<Record<string, unknown>>
 export function injectAppended(output: unknown, raw: string): string
+export function alwaysSuggestions(props: unknown): Array<Record<string, unknown>> | undefined

package/hook/opencode.mjs

@@ -107,6 +107,18 @@ export function askToCc(props) {
   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（用户原来在这些键上写的值已被覆盖，找不回来 —— 每一步都要过设备）
@@ -288,7 +300,8 @@ export function make(opts = {}) {
         await reply(sessionID, id, 'once')
         return
       }
-      const input = { hook_event_name: 'PermissionRequest', session_id: sessionID, cwd, ...cc }
+      const sugg = alwaysSuggestions(p)
+      const input = { hook_event_name: 'PermissionRequest', session_id: sessionID, cwd, ...cc, ...(sugg ? { permission_suggestions: sugg } : {}) }
       const { child, done } = startChild(node, GATE, ['--window', '--tool', TOOL], input)
       if (child) pending.set(id, child)
       const r = await done
@@ -304,7 +317,8 @@ export function make(opts = {}) {
       if (!d) return
       if (d.behavior === 'allow') {
         if (callID && call) approvedCalls.set(callID, Date.now())
-        await reply(sessionID, id, 'once')
+        // 设备上选了「允许并记住」：回 always，opencode 记住这次请求的 always 模式
+        await reply(sessionID, id, Array.isArray(d.updatedPermissions) && d.updatedPermissions.length > 0 ? 'always' : 'once')
       } else if (d.behavior === 'deny') {
         await reply(sessionID, id, 'reject')
       } else return

package/hook/wake.cjs

@@ -11,8 +11,10 @@
 //   ② 除了「认证过的 daemon 发来、且逐条 HMAC 校验通过的指令」这一种情况，一律 exit 0、绝不写 stderr：
 //      exit 2 会唤醒窗口，stderr 的内容会被模型当成用户输入执行。通道（Windows 命名管道 / tmp 下的 socket）
 //      别的进程也能连、能抢注，所以先双向认证（密钥 ~/.deskbuddy/wake/secret，daemon 每次启动重新生成）。
-//   ③ 非交互的 `claude -p` 里 asyncRewake 会被当成**同步** hook 执行（源码 `!isInteractive || hasStreamingInput`），
-//      等在那儿就把人家的 -p 卡住。只对交互 CLI / VS Code 插件 / 桌面版放行，认不出宿主一律立刻退出。
+//   ③ 非交互的 `claude -p` 和 `--input-format stream-json` 宿主（IDE 插件 / 桌面版）里 asyncRewake 会被当成**同步** hook
+//      执行（源码 `!isInteractive || hasStreamingInput`），等在那儿就把人家卡住：插件里 SessionStart 挂着不退，
+//      60 秒后报「Subprocess initialization did not complete」会话被杀（2026-10-02 Trae CN 内置 Claude Code 插件 2.1.281 必现）。
+//      只对交互 CLI 窗口放行，认不出宿主一律立刻退出。插件 / 桌面版的会话靠 daemon 后台续跑接设备回复。
 //   ④ 窗口关了（智能体进程没了）就退出：Claude Code 被强杀时不会替我们收尸。
 //
 // ⚠️ 通道地址 / 密钥 / HMAC / 标记 / transcript 分析与 src/core/wake.ts、src/daemon/wake.ts 同构，
@@ -193,8 +195,9 @@ function entrypointAllows(ep) {
 }
 
 /**
- * 宿主命令行判定（环境变量里没有入口时才用）：交互窗口可以；`--input-format stream-json` 是插件/桌面版那种异步宿主；
- * 带 -p / --print 的是一次性调用，asyncRewake 在那里是同步的，绝不能等。🔴 拿不到命令行 → false
+ * 宿主命令行判定（环境变量里没有入口时才用）：只有交互窗口可以。
+ * 带 -p / --print 的一次性调用、`--input-format stream-json` 的插件 / 桌面版宿主里 asyncRewake 都是同步的，绝不能等（见铁律③）。
+ * 🔴 拿不到命令行 → false
  */
 function canWake(args) {
   const all = String(args || '').trim()
@@ -202,7 +205,7 @@ function canWake(args) {
   const tokens = all.split(/\s+/).slice(1)
   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')) return true
+    if (t === '--input-format=stream-json' || (t === '--input-format' && tokens[i + 1] === 'stream-json')) return false
   }
   return !tokens.some((t) => t === '--print' || /^-[a-zA-Z]*p[a-zA-Z]*$/.test(t))
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "deskbuddy",
-  "version": "0.2.0-beta.10",
+  "version": "0.2.0-beta.13",
   "description": "把 Claude Code、Codex 等 AI 编码智能体每个会话窗口的状态，实时同步到桌面硬件屏幕",
   "keywords": [
     "ai",