@zmainer/dsh-wx-bridge 1.0.16 → 1.1.0

package/README.md

@@ -5,6 +5,7 @@ DSH（DeepSeek Harness）插件：把**手机微信**接到本机 DSH，让微
 - **宿主半**：注册独立前缀路由 `/wxbridge/*`，托管桥进程（启动/停止/重启/体检），向设置页提供实时状态与**预设下拉**。
 - **客户端半**：设置 → **微信连接** 面板（React），显示桥的真实状态、启停按钮、扫码配对，以及**手机通道预设**选择。
 - **内核**：`lib/kernel/` 内置零依赖的 `bridge.mjs`（iLink 长轮询收发 + ACP 会话执行）与 `keeper.mjs`（存活自检 + 脱树重启）。路径、工作区、知识库、预设全部可配置，无硬编码。
+- **1.1.0 新增**：**微信内审批应答**（审批卡推到微信，回「批准 / 拒绝」即可）与**主动推送**（任何进程用一行命令把消息推到手机）。
 
 ## 执行路径（1.0 起：ACP 原生会话）
 
@@ -69,7 +70,13 @@ dsh plugin --profile <profile> add @zmainer/dsh-wx-bridge
   "vault": "<可选：Obsidian 知识库绝对路径>",
   "intervalMs": 300000,
   "staleMs": 300000,
-  "acp": { "preset": "<预设 id，留空跟随 DSH 默认预设>", "enabled": true, "permPolicy": "allow" }
+  "acp": {
+    "preset": "<预设 id，留空跟随 DSH 默认预设>",
+    "enabled": true,
+    "permPolicy": "ask",
+    "permPreset": "danger-full-access",
+    "approvalTimeoutMs": 120000
+  }
 }
 ```
 
@@ -87,7 +94,9 @@ dsh plugin --profile <profile> add @zmainer/dsh-wx-bridge
 | `acp.home` | ACP 子进程的 `DSH_HOME`（决定会话写进哪个仓库） | 宿主 home |
 | `acp.dshBin` | ACP 用的 dsh 入口（默认跟随宿主运行时，schema 才一致） | 自动 |
 | `acp.patch` | 覆盖叠层文件路径（预设档自动生成） | 插件内置 |
-| `acp.permPolicy` | 权限请求策略：`allow` / `reject` | allow |
+| `acp.permPolicy` | 审批策略：`ask`（默认，推到微信等回复）/ `allow`（自动批准）/ `reject`（一律拒绝） | ask |
+| `acp.permPreset` | 手机通道权限预设（写进 ACP 叠层）：`danger-full-access` / `workspace-write` / `read-only`。收紧后产生的审批会在微信里问你 | danger-full-access |
+| `acp.approvalTimeoutMs` | 审批卡等待时长（超时按拒绝） | 120000 |
 | `acp.patchAcp` | 是否允许给已装 `dsh-acp` 打预设补丁 | true |
 
 环境变量：`WXBRIDGE_DATA`、`BRIDGE_CWD`、`BRAIN_VAULT`、`DSH_BIN`、`BRIDGE_HOST_HOME`、`WXBRIDGE_ACP=off`；
@@ -110,17 +119,20 @@ dsh plugin --profile <profile> add @zmainer/dsh-wx-bridge
 | GET | `/wxbridge/presets` | **预设名册**（id/name/description）+ 当前选中值 |
 | POST | `/wxbridge/preset` | 写入预设选择（`{ "preset": "<id|空>" }`） |
 | POST | `/wxbridge/allowlist` | 写入准入模式（`{ "mode": "strict|auto|open", "restart": true }`） |
+| GET · POST | `/wxbridge/approval` | 读/写审批策略（`{ "mode": "ask|allow|reject" }`） |
+| POST | `/wxbridge/push` | **主动推送**：把一条消息排队给桥代发（`{ "text": "…", "to": "<可选 peerId>" }`） |
 | POST | `/wxbridge/start` · `/stop` · `/restart` · `/tick` | 桥生命周期（`tick` = 立即体检并按需自愈） |
 | POST | `/wxbridge/config` | 写配置文件（`dataDir`/`cwd`/`vault`/`intervalMs`/`staleMs`/`prompt`） |
 | POST | `/wxbridge/task` · `/scan` · `/attach` | 宿主内执行 / 会话归组 |
 
 ## 安全基线
 
-- **权限预设（1.0.7 起为 `danger-full-access`）**：手机端**没有可应答审批的界面**，
-  而 DSH 的审批在无应答者时 fail-closed → 任何需要审批的操作都会直接失败。
-  因此本插件把**手机通道**的权限预设放到最宽；**这等于把本机交给能驱动该机器人的人**——
-  所以准入默认是 `strict`（只有登记过的设备能驱动）。收紧办法：叠层里 `permission.defaultPreset` 改
-  `workspace-write` 或 `read-only`（后者只读）。
+- **权限预设（`acp.permPreset`，默认 `danger-full-access`）**：默认仍是最宽——手机任务常要跑 `mvn`、写
+  `~/.m2`、动工作区之外的文件，收紧到 `workspace-write` 会直接把这些操作拦掉。想要更安全就把 `acp.permPreset`
+  改成 `workspace-write` / `read-only`：**1.1.0 起审批会在微信里问你**（回「批准 / 拒绝」），不再"无应答直接失败"，
+  所以收紧是可行的取舍，而不是硬伤。
+- **审批默认 `ask`**：需要审批的操作会把卡片推到微信等回复；**120 秒未回按拒绝**（fail-closed），
+  也可发 `/审批 自动` 恢复"自动批准"、`/审批 拒绝` 变成一律拒绝。找不到归属联系人的审批一律拒绝。
 - **准入默认 `strict`**（TOFU 白名单 + 一次性登记 token）：未登记的发送者**不执行**，但只回一次可操作提示
   （10 分钟/人节流；提示里给出登记方式），并写审计日志。面板「准入模式」可切 `auto`（首次发言即登记）或
   `open`（不检查，不建议）——`auto` 的边界是「谁拿到了这个机器人」，机器人被拉进群/被加好友会连带放权。
@@ -132,6 +144,48 @@ dsh plugin --profile <profile> add @zmainer/dsh-wx-bridge
 
 > 数据经腾讯 iLink 通道，**不得用于涉密内容**。状态与凭据文件为明文，仅靠 ACL 保护。
 
+## 微信内审批应答（1.1.0）
+
+ACP 的 `session/request_permission` 请求**必须被应答**。早先版本只能按固定策略自动答（`allow`/`reject`），
+所以"手机端没法应答审批"就成了把通道权限放到 `danger-full-access` 的理由。现在桥把审批**推到你手机上**：
+
+```text
+【需要你批准】#3
+操作：Bash: 删除 build 目录
+选项：
+1) 允许一次
+2) 总是允许
+3) 拒绝
+回复：批准 / 拒绝（也可以回 1 / 2）
+120 秒内没回复＝按拒绝处理（需要审批的操作会失败；想让桥不再问，发 /审批 自动）。
+```
+
+- 回复支持：`批准` / `同意` / `允许` / `yes` / `1`，`拒绝` / `不同意` / `no` / `2`，以及 `#3 批准` 这种带编号的形式。
+- 桥会把你的答复映射回 ACP 的 `optionId`（允许类选项优先，挑不到就按拒绝）。
+- **超时、找不到归属联系人、或你回了别的内容** → 该项审批按**拒绝**处理（fail-closed，不静默放权）。
+- 同一时刻每个人只留一张卡：新卡到达会作废旧卡（避免"批准"批到过期的那张）。
+- 开关：`/审批` 看策略、`/审批 询问|自动|拒绝` 改；面板/HTTP 侧用 `POST /wxbridge/approval`。
+
+> 什么时候会真的看到审批卡？**当通道权限预设被收紧时**（`acp.permPreset=workspace-write`/`read-only`）。
+> 默认的 `danger-full-access` 不产生审批——想用这个能力，就把它改窄。
+
+## 主动推送（1.1.0）
+
+任何进程（手机通道里的 agent、桌面会话、定时任务）都能往微信推消息——**只写文件，不需要网络与鉴权**：
+
+```sh
+node "<dataDir>/wxpush.mjs" --text "跑完了：1442 条全部落库"
+node "<dataDir>/wxpush.mjs" --text "上午的任务失败在税局 504" --to <peerId>   # 指定收件人（可选）
+echo "来自管道的长文本" | node "<dataDir>/wxpush.mjs" --stdin
+```
+
+- 它在 `<dataDir>/outbox/` 丢一个 JSON；桥**每 5 秒取件**并代发（结果用文件位置表达：
+  成功移到 `outbox/sent/`，失败移到 `outbox/failed/` 并附原因）。
+- 收件人：显式 `--to` > 最近联系过的人；**只在已登记白名单里选**（推送不能绕过准入），无人可选即失败。
+- 「普通对话」档的提示词里已写明这条命令，所以你可以直接对手机说"干完给我发一条""每 10 分钟报个进度"。
+- 桌面/面板/其它插件也可以走宿主路由：`POST /wxbridge/push {"text": "…", "to": "…"}`。
+- 只支持文本推送（插件目前没有出站附件通道；要发文件请用会话里的 agent 直接操作）。
+
 ## 微信侧指令
 
 | 指令 | 说明 |
@@ -146,7 +200,10 @@ dsh plugin --profile <profile> add @zmainer/dsh-wx-bridge
 | `/status` | 桥状态、档位、原生会话 id、模型与强度 |
 | `/task` · `/cancel` | 任务与排队 / 取消运行中任务 |
 | `/files` | 看待用附件队列（默认 30 分钟有效）；`/files clear` 清空 |
-| `/help` `/ping` `/approve` `/reject` | 帮助 / 探活 / 审批记录 |
+| `/审批 [询问\|自动\|拒绝]` | 审批策略：默认**询问**（卡片推微信等你回）；`自动` 不打扰你；`拒绝` 一律失败 |
+| `/权限` | 看当前审批策略与通道权限预设 |
+| `/help` `/ping` | 帮助 / 探活 |
+| `/approve` · `/reject` | 命令别名：审批一律自动批准 / 一律拒绝（不等卡片） |
 
 **文件与图片（1.0.14）**：直接把文件或图片发给机器人 —— 微信的文件消息**带不了附言**（条目里就没有文字字段），
 所以流程是「先收下 → 反问你一句话 → 用你的第二句话触发任务」：
@@ -164,6 +221,16 @@ dsh plugin --profile <profile> add @zmainer/dsh-wx-bridge
 
 其余任意文本 → 交给 DSH 执行。
 
+## 兼容性
+
+| 维度 | 说明 |
+| --- | --- |
+| DSH / harness | 按官方插件协议安装（`dsh.bundle` 清单 + `dsh plugin add`）；内核只用 `dsh --profile acp` 与 `--profile headless` 两个内置 profile，**不绑定某个 harness 小版本**。预设功能依赖已装 `@deepseek-ai/dsh-acp` 支持 `Config.preset`——不支持/被覆盖时自动退回宿主组合（见「预设补丁」） |
+| Node | **`>=22.19.0`**（`package.json` 的 `engines`）：会话文件是**多帧 zstd**，逐帧解压用到 `node:zlib` 的 `zstdDecompressSync`。桌面端自带运行时（本机实测 v26）与系统 Node（本机 v22.19）都验证过 |
+| 操作系统 | **Windows 已实测**（进程树终止用 `taskkill /T /F`；运行时入口探测含 `%LOCALAPPDATA%\Programs\*` 扫描、PID 复用判断）。macOS / Linux **未实测**：内核是纯 Node，但上述几处是 Windows 实现，跨平台请先跑 `node lib/kernel/bridge.mjs --selftest-runtime` |
+| 依赖 | **零运行时依赖**（只用 Node 内建模块）；不依赖任何 `@deepseek-ai/*` 包（宿主能力通过 `ctx.inject` 取用，缺失即降级） |
+| 自测 | `--selftest-runtime`（运行时入口）/ `--selftest-approval`（审批卡与回复解析）/ `--selftest-outbox`（推送信箱）/ `--selftest-files` / `--selftest-inbound` / `--selftest-presets` |
+
 ## 常见问题 / Troubleshooting
 
 ### 插件管理里点「更新」报 `Cannot switch a non-link plugin directory`
@@ -199,6 +266,17 @@ ode_modules\@zmainer\dsh-wx-bridge` → 改名成 `...dsh-wx-bridge.bak` 更稳
 
 ## 最近变更
 
+- **1.1.0**：**微信内审批应答 + 主动推送**（两条都是用户要求）——
+  ① **审批**：ACP 的 `session/request_permission` 不再由桥按固定策略静默回答，而是把卡片推到微信
+  （选项带编号），回「批准 / 拒绝 / 1 / 2」即映射成 ACP 的 `optionId` 回去；**超时 120 秒按拒绝**
+  （fail-closed），找不到归属联系人同样按拒绝；同一人同时只留一张卡。策略 `ask`（新默认）/`allow`/`reject`
+  可用 `/审批` 或 `POST /wxbridge/approval` 切换。因此 `danger-full-access` 不再是"手机端无法应答审批"的
+  唯一出路：把 `acp.permPreset` 收紧到 `workspace-write` 后，越界的操作会先在微信里问你。
+  ② **主动推送**：`<dataDir>/wxpush.mjs`（桥每次启动刷新一份）把一条消息写进 `outbox/`，桥每 5 秒取件代发，
+  结果落 `outbox/sent` / `outbox/failed`；收件人只在已登记白名单里选（推送不绕过准入）。
+  「普通对话」档的提示词里写明了这条命令，agent 可自行"干完提醒你"；宿主侧另有 `POST /wxbridge/push`。
+  ③ 工程：新增纯函数层 `approval-reply.mjs` / `outbox.mjs` + `--selftest-approval` / `--selftest-outbox`
+  两个离线自测（各 13 / 6 条断言），package.json 补 `repository`（npm 与仓库的自动关联需要它）。
 - **1.0.15**：**准入默认改回 `strict`（与 README 一致）**，并把选择权交给用户——
   起因是 awesome-dsh-plugin 的收录评审指出的一个真实矛盾：代码默认 `ALLOWLIST=auto`（**任何能给机器人发消息的人
   首次发言即自动登记**）叠加手机通道的 `danger-full-access`（**不经审批**），等价于"任何能给它发消息的人

package/lib/client.js

@@ -122,6 +122,8 @@ window.__ModuleLoader__.load({
       const [presets, setPresets] = R.useState([])
       const [presetSel, setPresetSel] = R.useState('')
       const [allowlist, setAllowlist] = R.useState('strict')
+      const [approval, setApproval] = R.useState('ask')
+      const [pushText, setPushText] = R.useState('')
       const [presetState, setPresetState] = R.useState(null)
       useWxStyle()
     
@@ -151,9 +153,43 @@ window.__ModuleLoader__.load({
           .then((r) => r.json())
           .then((d) => { if (alive) setPair(d) })
           .catch(() => {})
+        fetch('/wxbridge/approval', { cache: 'no-store' })
+          .then((r) => r.json())
+          .then((d) => { if (alive && d && typeof d.approval === 'string') setApproval(d.approval) })
+          .catch(() => {})
         return () => { alive = false }
       }, [])
     
+      const saveApproval = async (mode) => {
+        setBusy('approval')
+        try {
+          const r = await fetch('/wxbridge/approval', {
+            method: 'POST', headers: { 'content-type': 'application/json' },
+            body: JSON.stringify({ mode }),
+          })
+          const d = await r.json()
+          if (typeof d.approval === 'string') setApproval(d.approval)
+          setNote(d.ok
+            ? ('审批策略已切到 ' + mode + '：' + (d.note || ''))
+            : ('切换失败：' + (d.error || '未知错误')))
+        } catch (e) { setNote('切换失败：' + String(e && e.message ? e.message : e)) } finally { setBusy('') }
+      }
+    
+      const sendPush = async () => {
+        const text = String(pushText || '').trim()
+        if (!text) { setNote('先写一条要推送的内容。'); return }
+        setBusy('push')
+        try {
+          const r = await fetch('/wxbridge/push', {
+            method: 'POST', headers: { 'content-type': 'application/json' },
+            body: JSON.stringify({ text }),
+          })
+          const d = await r.json()
+          setNote(d.ok ? ('已排队推送：' + (d.note || '')) : ('推送失败：' + (d.error || '未知错误')))
+          if (d.ok) setPushText('')
+        } catch (e) { setNote('推送失败：' + String(e && e.message ? e.message : e)) } finally { setBusy('') }
+      }
+    
       const loadPresets = () => fetch('/wxbridge/presets', { cache: 'no-store' })
         .then((r) => r.json())
         .then((d) => { setPresetState(d); setPresets(d.presets || []); setPresetSel(typeof d.selected === 'string' ? d.selected : '') })
@@ -451,6 +487,51 @@ window.__ModuleLoader__.load({
             R.createElement('span', { style: dim }, '当前：' + allowlist + '（改完会写入 config.json 并重启桥，立即生效）')),
         ),
     
+        R.createElement('div', { style: { marginTop: '14px', paddingTop: '12px', borderTop: subtle } },
+          R.createElement('div', { style: { display: 'flex', alignItems: 'center', gap: '6px', marginBottom: '6px' } },
+            wxBubbles(16, WX, skin.dark ? '#0d1220' : '#ffffff', 'transparent'),
+            R.createElement('span', { style: { fontSize: '13px', fontWeight: 600 } }, '审批策略'),
+            R.createElement('span', { style: { fontSize: '11px', color: dim.color } }, '（需要审批的操作怎么答）')),
+          R.createElement('select', {
+            value: approval, onChange: (e) => setApproval(e.target.value),
+            style: { ...skin.control, width: '100%', boxSizing: 'border-box', padding: '7px 10px', borderRadius: '8px', fontSize: '12px' },
+          }, [
+            R.createElement('option', { key: 'ask', value: 'ask', style: skin.option }, 'ask（默认）· 把审批卡推到微信，等你回「批准 / 拒绝」，120 秒未回按拒绝'),
+            R.createElement('option', { key: 'allow', value: 'allow', style: skin.option }, 'allow · 自动批准，不打扰你（旧行为）'),
+            R.createElement('option', { key: 'reject', value: 'reject', style: skin.option }, 'reject · 一律拒绝（需要审批的操作会失败）'),
+          ]),
+          R.createElement('div', { style: { marginTop: '8px', display: 'flex', alignItems: 'center' } },
+            R.createElement('button', {
+              className: 'wxbridge-btn', onClick: () => saveApproval(approval), disabled: !!busy,
+              style: {
+                marginRight: '10px', padding: '6px 14px', borderRadius: '999px', fontSize: '12px', fontWeight: 500,
+                cursor: busy ? 'default' : 'pointer', border: '1px solid ' + WX, background: WX, color: '#fff',
+              },
+            }, busy === 'approval' ? '处理中…' : '保存审批策略'),
+            R.createElement('span', { style: dim },
+              '当前：' + approval + '（保存在 config.json 的 acp.permPolicy；改了立即生效，不必重启）' +
+              (approval === 'ask' ? ' · 只有把通道权限预设收紧（acp.permPreset）才会真的产生审批卡' : ''))),
+        ),
+        R.createElement('div', { style: { marginTop: '14px', paddingTop: '12px', borderTop: subtle } },
+          R.createElement('div', { style: { display: 'flex', alignItems: 'center', gap: '6px', marginBottom: '6px' } },
+            wxBubbles(16, WX, skin.dark ? '#0d1220' : '#ffffff', 'transparent'),
+            R.createElement('span', { style: { fontSize: '13px', fontWeight: 600 } }, '主动推送'),
+            R.createElement('span', { style: { fontSize: '11px', color: dim.color } }, '（试一下能不能推到你手机）')),
+          R.createElement('input', {
+            value: pushText, onChange: (e) => setPushText(e.target.value), placeholder: '要推到微信的一句话（例如：测试推送）',
+            style: { ...skin.control, width: '100%', boxSizing: 'border-box', padding: '7px 10px', borderRadius: '8px', fontSize: '12px' },
+          }),
+          R.createElement('div', { style: { marginTop: '8px', display: 'flex', alignItems: 'center' } },
+            R.createElement('button', {
+              className: 'wxbridge-btn', onClick: () => sendPush(), disabled: !!busy,
+              style: {
+                marginRight: '10px', padding: '6px 14px', borderRadius: '999px', fontSize: '12px', fontWeight: 500,
+                cursor: busy ? 'default' : 'pointer', border: '1px solid ' + WX, background: WX, color: '#fff',
+              },
+            }, busy === 'push' ? '发送中…' : '发一条测试推送'),
+            R.createElement('span', { style: dim }, '桥每 5 秒取件；结果在数据目录的 outbox/sent、outbox/failed')),
+        ),
+    
         note ? R.createElement('pre', { style: { margin: '10px 0 0 0', padding: '9px 11px', borderRadius: '10px', background: mutedBg, border: subtle, fontSize: '11px', overflow: 'auto', maxHeight: '160px' } }, note) : null,
     
         // ── 操作日志 ───────────────────────────────────────────────────

package/lib/index.js

@@ -700,6 +700,45 @@ export function apply(ctx, config) {
             writeFileSync(f, JSON.stringify(keep, null, 2))
             return send(res, { ok: true, written: f, applied: keep, note: '提示词下次任务即生效；其余项重启宿主后生效' })
           }
+          if (p === '/push' && req.method === 'POST') {
+            // 主动推送：往桥的 outbox 丢一条（桥每 5 秒代发）。桌面会话 / 面板 / 其它插件都能调。
+            const body = await readBody(req)
+            const text = String((body && (body.text || body.message)) || '').trim()
+            if (!text) return send(res, { ok: false, error: 'text 不能为空' }, 400)
+            const dir = keeper ? keeper.dataDir : ''
+            if (!dir) return send(res, { ok: false, error: '桥的数据目录未知（桥没在运行？）' }, 503)
+            try {
+              const outbox = join(dir, 'outbox')
+              mkdirSync(outbox, { recursive: true })
+              const file = join(outbox, Date.now() + '-' + Math.random().toString(16).slice(2, 10) + '.json')
+              writeFileSync(file, JSON.stringify({
+                text: text.slice(0, 4000),
+                to: String((body && body.to) || '').trim(),
+                at: new Date().toISOString(),
+                source: 'host-route',
+              }, null, 2))
+              pushAction({ action: 'push', ok: true, detail: text.slice(0, 40) })
+              return send(res, { ok: true, file, note: '已排队；桥最多 5 秒内发出（结果看 outbox/sent 或 failed）' })
+            } catch (e) { return send(res, { ok: false, error: String(e?.message ?? e) }, 500) }
+          }
+          if (p === '/approval') {
+            const f = configPath()
+            const keep = readJsonFile(f)
+            const cur = String((keep.acp && keep.acp.permPolicy) || '').toLowerCase() || 'ask'
+            if (req.method !== 'POST') return send(res, { ok: true, approval: cur, configFile: f, modes: ['ask', 'allow', 'reject'] })
+            // 审批策略：ask（推到微信等回复）/ allow（自动批准）/ reject（一律拒绝）
+            const body = await readBody(req)
+            const mode = String((body && body.mode) || '').toLowerCase()
+            if (!['ask', 'allow', 'reject'].includes(mode)) return send(res, { ok: false, error: 'mode must be ask | allow | reject' }, 400)
+            keep.acp = Object.assign({}, (keep.acp && typeof keep.acp === 'object') ? keep.acp : {}, { permPolicy: mode })
+            mkdirSync(dirname(f), { recursive: true })
+            writeFileSync(f, JSON.stringify(keep, null, 2))
+            pushAction({ action: 'approval', ok: true, detail: mode })
+            let restarted = 0
+            if (body && body.restart && keeper) { try { restarted = keeper.startBridge('approval-change') || 0 } catch (e) { ctx.logger?.warn?.('wxbridge: 重启失败 ' + String(e?.message ?? e)) } }
+            return send(res, { ok: true, approval: mode, configFile: f, restarted,
+              note: restarted ? '已写入配置并重启桥，立即生效' : '已写入配置；桥每条任务重读配置，手机发 /审批 也能立即改' })
+          }
           if (p === '/allowlist' && req.method === 'POST') {
             // 准入模式：strict（默认，只认已登记）/ auto（首次发言即登记）/ open（不检查）
             const body = await readBody(req)

package/lib/kernel/acp-overlay-chat.yml

@@ -1,26 +1,27 @@
-# wxbridge ACP 叠加层 · **对话模式**（手机默认档）
-# 与 acp-overlay.yml 的差别：收窄注入面，避免「随口一句话」被当成第二大脑任务落盘。
-#   1) 仍停用 dsh-computer-use（否则 profile 整树加载失败，原因见 acp-overlay.yml）；
-#   2) 停用技能目录（skill-filesystem 提供 ~/.ohdsh/skills，tool-skill 提供加载工具）——
-#      手机提示里不再出现 second-brain-distill 这类"沉淀知识"的技能；
-#   3) 覆盖 system-prompt 人格为「对话助手」：从本会话上下文回答，不主动读写文件/知识库。
-# 需要真正的第二大脑行为时，手机发 `/brain on` 切到第二大脑模式（另一份叠加层）。
-- id: dsh-computer-use
-  disabled: true
-
-# 手机通道**不需要审批**：手机端没有可应答审批的界面（ACP 只应答带 callId 的工具审批，
-# 沙箱升级类审批会转给桌面端弹窗 → 手机无从应答 → fail-closed 执行失败）。
-# 所以这里把权限预设放到最宽。改窄：改成 read-only / workspace-write 即可。
-- id: permission
-  config:
-    defaultPreset: danger-full-access
-- id: skill-filesystem
-  disabled: true
-- id: tool-skill
-  disabled: true
-- id: system-prompt
-  config:
-    persona: >-
-      你是「手机微信通道」里的对话助手，用中文简洁回答。直接用当前会话已有的上下文回答，
-      不要为了"记住"去读写工作区文件或知识库；只有当用户明确要求（例如"记到库里""归档""落盘"）
-      时才动文件。
+# wxbridge ACP 叠加层 · **对话模式**（手机默认档）
+# 与 acp-overlay.yml 的差别：收窄注入面，避免「随口一句话」被当成第二大脑任务落盘。
+#   1) 仍停用 dsh-computer-use（否则 profile 整树加载失败，原因见 acp-overlay.yml）；
+#   2) 停用技能目录（skill-filesystem 提供 ~/.ohdsh/skills，tool-skill 提供加载工具）——
+#      手机提示里不再出现 second-brain-distill 这类"沉淀知识"的技能；
+#   3) 覆盖 system-prompt 人格为「对话助手」：从本会话上下文回答，不主动读写文件/知识库。
+# 需要真正的第二大脑行为时，手机发 `/brain on` 切到第二大脑模式（另一份叠加层）。
+- id: dsh-computer-use
+  disabled: true
+
+# 通道权限预设（config.acp.permPreset，默认 danger-full-access）：
+# 收紧到 workspace-write / read-only 后，需要审批的操作会把审批卡推到微信——
+# 回「批准 / 拒绝」（或 1 / 2）即可，120 秒未回按拒绝处理（fail-closed）。
+# 默认留在最宽，是因为 ~/.m2 之类的写操作会被 workspace-write 拦掉（maven 编译直接失败）。
+- id: permission
+  config:
+    defaultPreset: danger-full-access
+- id: skill-filesystem
+  disabled: true
+- id: tool-skill
+  disabled: true
+- id: system-prompt
+  config:
+    persona: >-
+      你是「手机微信通道」里的对话助手，用中文简洁回答。直接用当前会话已有的上下文回答，
+      不要为了"记住"去读写工作区文件或知识库；只有当用户明确要求（例如"记到库里""归档""落盘"）
+      时才动文件。

package/lib/kernel/acp-overlay.yml

@@ -1,22 +1,23 @@
-# wxbridge ACP 叠加层（保持最小：只做已实证必要的一件事）
-# 让 `dsh --profile acp` 在**宿主 home**（~/.ohdsh）里能起得来：
-#   ~/.ohdsh/cordis.patch.yml（根用户补丁层）引用 dsh-computer-use，该包只装在
-#   profiles/desktop/node_modules 里 → 新建的 profiles/acp 解析不到 → 整树加载失败
-#   （症状：initialize 正常、session/new 报 "the ACP bridge has been disposed"）。
-#   ACP 是手机用的自动化通道，不需要桌面专属的 computer-use 插件。
-#   注：停用一个不存在的 id 是无害空操作，因此本文件可无条件带上。
-- id: dsh-computer-use
-  disabled: true
-
-# 手机通道**不需要审批**：手机端没有可应答审批的界面（ACP 只应答带 callId 的工具审批，
-# 沙箱升级类审批会转给桌面端弹窗 → 手机无从应答 → fail-closed 执行失败）。
-# 所以这里把权限预设放到最宽。改窄：改成 read-only / workspace-write 即可。
-- id: permission
-  config:
-    defaultPreset: danger-full-access
-#
-# 备注（2026-09-21 实测，别重复踩）：**模型目录不随行配置走**。
-#   本文件曾试在两处放 llm-deepseek 目录（改行 config；停用 base 行 + 换行 id 插副本），
-#   配置树（--dump-config）里都生效了，但 `session/new` 返回的目录**始终不变** ——
-#   运行时的模型目录来自 settings（`llm-deepseek` / `llm-pi-ai` 段）而非行 config。
-#   所以「让手机清单 = 桌面端清单」这件事，只能改 settings，改不成（见 L1 §9.6）。
+# wxbridge ACP 叠加层（保持最小：只做已实证必要的一件事）
+# 让 `dsh --profile acp` 在**宿主 home**（~/.ohdsh）里能起得来：
+#   ~/.ohdsh/cordis.patch.yml（根用户补丁层）引用 dsh-computer-use，该包只装在
+#   profiles/desktop/node_modules 里 → 新建的 profiles/acp 解析不到 → 整树加载失败
+#   （症状：initialize 正常、session/new 报 "the ACP bridge has been disposed"）。
+#   ACP 是手机用的自动化通道，不需要桌面专属的 computer-use 插件。
+#   注：停用一个不存在的 id 是无害空操作，因此本文件可无条件带上。
+- id: dsh-computer-use
+  disabled: true
+
+# 通道权限预设（config.acp.permPreset，默认 danger-full-access）：
+# 收紧到 workspace-write / read-only 后，需要审批的操作会把审批卡推到微信——
+# 回「批准 / 拒绝」（或 1 / 2）即可，120 秒未回按拒绝处理（fail-closed）。
+# 默认留在最宽，是因为 ~/.m2 之类的写操作会被 workspace-write 拦掉（maven 编译直接失败）。
+- id: permission
+  config:
+    defaultPreset: danger-full-access
+#
+# 备注（2026-09-21 实测，别重复踩）：**模型目录不随行配置走**。
+#   本文件曾试在两处放 llm-deepseek 目录（改行 config；停用 base 行 + 换行 id 插副本），
+#   配置树（--dump-config）里都生效了，但 `session/new` 返回的目录**始终不变** ——
+#   运行时的模型目录来自 settings（`llm-deepseek` / `llm-pi-ai` 段）而非行 config。
+#   所以「让手机清单 = 桌面端清单」这件事，只能改 settings，改不成（见 L1 §9.6）。

package/lib/kernel/acp.mjs

@@ -28,7 +28,11 @@ export class AcpHost {
    * @param {string} [o.home]     子进程 DSH_HOME（决定会话写进哪个仓库）
    * @param {string} [o.cwd]      子进程工作目录（默认进程 cwd）
    * @param {string} [o.patch]    --patch 叠加层文件（如停用宿主专属插件）
-   * @param {string} [o.permPolicy] 权限策略：'allow'（默认）| 'reject'
+   * @param {'ask'|'allow'|'reject'} [o.permPolicy] 权限策略：
+   *        'ask'（默认）把审批请求交给 onPermission 去问人；'allow'/'reject' 自动应答（旧行为）
+   * @param {(req:{sessionId:string, toolCall:object, options:Array, seq:number})=>Promise<string|null>} [o.onPermission]
+   *        返回要选的 optionId；返回 null/抛错 → 按 permFallback 应答
+   * @param {'allow'|'reject'} [o.permFallback] 问不到人时的兜底（默认 reject，fail-closed）
    * @param {number} [o.promptTimeoutMs]
    * @param {(m:string, e?:object)=>void} [o.log]
    */
@@ -38,7 +42,10 @@ export class AcpHost {
     this.home = o.home || ''
     this.cwd = o.cwd || process.cwd()
     this.patch = o.patch || ''
-    this.permPolicy = o.permPolicy === 'reject' ? 'reject' : 'allow'
+    this.permPolicy = ['ask', 'allow', 'reject'].includes(o.permPolicy) ? o.permPolicy : 'ask'
+    this.onPermission = typeof o.onPermission === 'function' ? o.onPermission : null
+    this.permFallback = o.permFallback === 'allow' ? 'allow' : 'reject'
+    this.permSeq = 0
     this.promptTimeoutMs = Number(o.promptTimeoutMs || 300000)
     this.log = o.log || (() => {})
     this.child = null
@@ -133,11 +140,35 @@ export class AcpHost {
       return
     }
     if (f.method === 'session/request_permission') {
-      const opts = f.params?.options ?? []
-      const pick = this.permPolicy === 'allow'
-        ? opts.find((o) => /allow/.test(String(o.kind))) || opts.find((o) => /allow/.test(String(o.optionId)))
-        : opts.find((o) => /reject/.test(String(o.kind))) || opts.find((o) => /reject/.test(String(o.optionId)))
-      this.log('acp-permission', { tool: f.params?.toolCall?.title, policy: this.permPolicy, picked: pick?.optionId ?? null })
+      const params = f.params ?? {}
+      const opts = Array.isArray(params.options) ? params.options : []
+      const seq = ++this.permSeq
+      const pickByPolicy = (policy) => policy === 'reject'
+        ? (opts.find((o) => /reject/.test(String(o.kind))) || opts.find((o) => /reject/.test(String(o.optionId))))
+        : (opts.find((o) => /allow/.test(String(o.kind))) || opts.find((o) => /allow/.test(String(o.optionId))))
+      if (this.permPolicy === 'ask' && this.onPermission) {
+        // 问人：**不能阻塞读循环**（同一进程还要收 session/update 与别的请求），所以异步应答。
+        const ask = this.onPermission
+        ;(async () => {
+          let picked = null
+          let how = 'ask'
+          try {
+            const optionId = await ask({ sessionId: params.sessionId, toolCall: params.toolCall ?? {}, options: opts, seq })
+            picked = optionId ? (opts.find((o) => String(o.optionId) === String(optionId)) || { optionId }) : null
+          } catch (e) {
+            this.log('acp-permission-ask-failed', { seq, error: String(e?.message ?? e) })
+          }
+          if (!picked) {
+            how = 'fallback:' + this.permFallback
+            picked = pickByPolicy(this.permFallback === 'allow' ? 'allow' : 'reject')
+          }
+          this.log('acp-permission', { seq, tool: params.toolCall?.title, policy: 'ask', how, picked: picked?.optionId ?? null })
+          this._raw({ jsonrpc: '2.0', id: f.id, result: picked ? { outcome: { outcome: 'selected', optionId: picked.optionId } } : { outcome: { outcome: 'cancelled' } } })
+        })()
+        return
+      }
+      const pick = pickByPolicy(this.permPolicy)
+      this.log('acp-permission', { seq, tool: params.toolCall?.title, policy: this.permPolicy, picked: pick?.optionId ?? null })
       this._raw({ jsonrpc: '2.0', id: f.id, result: pick ? { outcome: { outcome: 'selected', optionId: pick.optionId } } : { outcome: { outcome: 'cancelled' } } })
       return
     }

package/lib/kernel/approval-reply.mjs

@@ -0,0 +1,86 @@
+/**
+ * approval-reply.mjs — 审批卡与「微信里的回复」之间的纯函数层（无 IO，可离线自测）
+ *
+ * 为什么单独一层：审批的解析/选择/文案都必须可离线验证（桥本身的启动路径会连 iLink、拉子进程，
+ * 单测没法用）。协议事实：ACP 的 `session/request_permission` 请求**必须应答**，
+ * 参数里给的是若干 option（各带 optionId / kind / name），客户端要挑一个回去。
+ */
+
+/** 同意 / 拒绝（对外只有这两个语义，选项到 optionId 的映射由 pickOptionByDecision 决定）。 */
+export const DECISION_ALLOW = 'allow'
+export const DECISION_REJECT = 'reject'
+
+// 先判拒绝词：'不同意' 里含 '同意'、'不许' 里含 '许'，顺序反了会把拒绝读成同意。
+const REJECT_WORDS = ['拒绝', '不同意', '驳回', '不许', '不行', '不准', 'deny', 'reject', 'no']
+const ALLOW_WORDS = ['批准', '同意', '允许', '准许', '通过', '可以', 'approve', 'allow', 'yes', 'ok']
+
+/**
+ * 解析用户回复：支持「批准 / 拒绝 / 同意 / 不同意 / yes / no」与「#3 批准」「3 拒绝」「2」。
+ * @returns {{decision: 'allow'|'reject'|null, index: number|null, keyword: string}}
+ */
+export function parseApprovalReply(raw) {
+  const text = String(raw ?? '').trim()
+  if (!text) return { decision: null, index: null, keyword: '' }
+  const nums = text.match(/\d{1,2}/g) || []
+  const index = nums.length ? Number(nums[0]) : null
+  const lower = text.toLowerCase()
+  const hit = (words) => words.find((w) => lower.includes(w)) || ''
+  const rej = hit(REJECT_WORDS)
+  const alw = rej ? '' : hit(ALLOW_WORDS)
+  let decision = rej ? DECISION_REJECT : (alw ? DECISION_ALLOW : null)
+  // 只回数字：1=批准、2=拒绝（与卡片里「1) 允许 2) 拒绝」的编号一致）
+  if (!decision && index !== null) decision = index === 1 ? DECISION_ALLOW : (index === 2 ? DECISION_REJECT : null)
+  return { decision, index, keyword: rej || alw }
+}
+
+const optionText = (o) => [o?.optionId, o?.kind, o?.name, o?.title].map((v) => String(v ?? '')).join(' ').toLowerCase()
+const looksReject = (o) => /reject|deny|refuse|abort|cancel|no\b/.test(optionText(o))
+
+/** 选项的可读标签（卡片里显示编号用）。 */
+export function optionLabel(o, i) {
+  const name = String(o?.name || o?.title || '').trim()
+  if (name) return name
+  const kind = String(o?.kind || '').trim()
+  if (kind) return kind
+  return '选项 ' + ((i ?? 0) + 1)
+}
+
+/**
+ * 决策 → 具体 optionId。挑不到时返回 null（调用方按「取消应答」处理，即 fail-closed）。
+ */
+export function pickOptionByDecision(options, decision) {
+  const list = Array.isArray(options) ? options : []
+  if (!list.length) return null
+  if (decision === DECISION_ALLOW) {
+    const allow = list.find((o) => /allow|approve|accept|permit|once|yes/.test(optionText(o)) && !looksReject(o))
+    return allow || list.find((o) => !looksReject(o)) || null
+  }
+  if (decision === DECISION_REJECT) {
+    return list.find(looksReject) || null
+  }
+  return null
+}
+
+/** 微信侧审批卡（纯文本；微信只能收文本）。 */
+export function formatApprovalCard(o = {}) {
+  const n = Number(o.n || 1)
+  const tool = String(o.tool || '工具调用').replace(/\s+/g, ' ').slice(0, 180)
+  const sec = Math.max(5, Number(o.timeoutSec || 120))
+  const options = Array.isArray(o.options) ? o.options : []
+  const rows = options.slice(0, 4).map((it, i) => (i + 1) + ') ' + optionLabel(it, i))
+  return [
+    '【需要你批准】#' + n,
+    '操作：' + tool,
+  ].concat(rows.length ? ['选项：'].concat(rows) : [])
+    .concat([
+      '回复：批准 / 拒绝（也可以回 1 / 2）',
+      sec + ' 秒内没回复＝按拒绝处理（需要审批的操作会失败；想让桥不再问，发 /审批 自动）。',
+    ]).join('\n')
+}
+
+/** 决策确认语（回执给用户，让他知道刚才那句被当成了什么）。 */
+export function decisionAck(decision, note) {
+  if (decision === DECISION_ALLOW) return '✅ 已批准' + (note ? '（' + note + '）' : '') + '，继续执行。'
+  if (decision === DECISION_REJECT) return '🚫 已拒绝' + (note ? '（' + note + '）' : '') + '，这一项不会执行。'
+  return '（审批应答已作废：' + (note || '无待批事项') + '）'
+}