@zxh126/pi-qqbot 0.1.0 → 0.2.0

package/README.md

@@ -1,26 +1,38 @@
 # pi-qqbot
 
-把 [Pi](https://pi.dev) coding agent 接入 QQ 单聊的桥接插件：在 QQ 里和 AI 对话，驱动 pi 干活。
+Bridge the **[Pi](https://pi.dev) coding agent** into QQ private (C2C) chats: send a message from QQ and let the agent work on the machine where pi runs — with remote approval before it executes dangerous tools.
 
-> 单会话版：所有 QQ 用户共用同一个 pi 会话（v1 设计，多用户多会话后续用 SDK 方案实现）。
+**English** | [简体中文](README.zh-CN.md)
 
-## 功能
+> **Single-session design (v1):** every QQ user shares one pi session. Multi-user / multi-session support is planned on top of the pi SDK.
 
-- **对话驱动 pi**：QQ 单聊消息送入当前 pi 会话，AI 回复发回 QQ。
-- **QQ 远程审批**：pi 执行 `bash` / `powershell` 等命令类工具时，先在 QQ 里发「同意 N / 拒绝 N」请求，用户回复后放行/拦截。
-- **单实例锁**：多个 pi 实例只会有「宿主」连接 QQ，其余待命，宿主退出后自动接管。
-- **内置指令**：`/new` 重置、`/status` 状态、`/help` 帮助。
+## Features
 
-## 安装
+| Feature | Description |
+|---|---|
+| **Chat-driven agent** | QQ private messages are fed into the current pi session; the assistant's answer is sent back to QQ (long replies are split automatically). |
+| **Remote approval** | Before pi runs `bash` / `powershell` / `write` / `edit` — or any tool annotated `destructiveHint` — the bot asks in QQ first. |
+| **Session-scoped "always allow"** | Reply 「以后都同意」 and every approval request in the **current session** is auto-approved, including the one already waiting. |
+| **Single-instance lock** | Only one pi process hosts the QQ gateway; the others stand by and take over automatically when the host exits. |
+| **Built-in commands** | `/new`, `/status`, `/help`. |
 
-1. 把本目录放到 `~/.pi/agent/extensions/pi-qqbot/`（或作为 Pi Package：`pi install ./pi-qqbot`）。
-2. 安装依赖：`npm install`。
-3. 创建配置 `~/.pi/agent/pi-qqbot.json`：
+## Install
+
+```bash
+# from npm
+pi install npm:@zxh126/pi-qqbot
+
+# or from a local checkout (dependencies are needed here)
+npm install
+pi install ./pi-qqbot
+```
+
+Then create `~/.pi/agent/pi-qqbot.json`:
 
 ```json
 {
-  "appId": "你的AppID",
-  "appSecret": "你的AppSecret",
+  "appId": "YOUR_APP_ID",
+  "appSecret": "YOUR_APP_SECRET",
   "sandbox": true,
   "allowlist": [],
   "markdownReply": false,
@@ -32,57 +44,73 @@
 }
 ```
 
-| 字段 | 默认 | 说明 |
-|------|------|------|
-| `appId` / `appSecret` | 必填 | QQ 开放平台机器人凭据 |
-| `sandbox` | `false` | 未提审上线的 bot 用 `true`（沙箱环境） |
-| `allowlist` | `[]` | openid 白名单，空 = 不限制 |
-| `markdownReply` | `false` | QQ 单聊不支持 markdown，保持 `false` |
-| `streaming` | `false` | 预留，v1 未启用流式 |
-| `approve.tools` | `["bash","powershell","write","edit"]` | 需要 QQ 审批的工具名；另有 `destructiveHint` 注解的工具也会拦截 |
-| `approve.remember` | `true` | 会话内记住选择：同意/拒绝后同类工具不再询问 |
-
-也可用环境变量 `QQ_BOT_APPID` / `QQ_BOT_APPSECRET` 代替文件凭据。
-
-## 使用
-
-启动 pi 后，在 QQ 里给机器人发消息，pi 会处理并回复。内置指令：
+| Field | Default | Description |
+|---|---|---|
+| `appId` / `appSecret` | required | Credentials of your QQ Open Platform bot |
+| `sandbox` | `false` | Set `true` while the bot is not yet published (sandbox environment) |
+| `allowlist` | `[]` | openid allowlist; empty means no restriction |
+| `markdownReply` | `false` | QQ private chat does not support markdown, keep `false` |
+| `streaming` | `false` | Reserved, streaming is not enabled in v1 |
+| `approve.tools` | `["bash","powershell","write","edit"]` | Tools that require approval; tools annotated `destructiveHint` are always gated too |
+| `approve.remember` | `true` | Remember the decision per tool inside the session (no more prompts for that tool) |
 
-- `/new` — 重置会话（清空当前回复缓冲）
-- `/status` — 查看是否空闲
-- `/help` — 帮助
+Credentials can also come from the `QQ_BOT_APPID` / `QQ_BOT_APPSECRET` environment variables.
 
-## 单实例锁
+## Usage
 
-QQ 网关对同一 bot 只保留一个活跃连接。插件用 `proper-lockfile` 文件锁（`~/.pi/agent/pi-qqbot-<appId>.lock`）：
+Start pi, then message the bot in QQ; pi handles it and replies.
 
-- 抢到锁的实例 = 宿主，连接 QQ；
-- 其余实例待命，每 5 秒重试；
-- 宿主退出或崩溃（30 秒心跳超时）后，待命实例自动接管。
+| Command | Description |
+|---|---|
+| `/new` | Reset: clear the reply buffer, approval memory and session-wide auto-approve |
+| `/status` | Show busy/idle state, auto-approve state and pending approval count |
+| `/help` | Show help |
 
-## 远程审批
+Anything else is forwarded to pi as a user message.
 
-pi 执行 `bash` / `powershell` / `write` / `edit` 等工具时（或带 `destructiveHint` 注解的工具），会先在 QQ 里发审批请求：
+## Remote approval
 
-```
+```text
 [审批 #1] bash: rm -rf node_modules
 回复「同意 1」批准，「拒绝 1」拒绝，「停止」终止本轮。
+要本会话内全部放行，回复「以后都同意」（可用「取消自动同意」关闭）。
 ```
 
-- 回复「同意 N」/「拒绝 N」：放行/拦截对应工具调用；
-- 回复「停止」：终止所有待审批请求；
-- `approve.remember: true` 时，本次会话内同类工具记住选择，不再重复询问（`/new` 重置记忆）；
-- 超时（10 分钟）自动拒绝并通知。
+Reply vocabulary (approval keywords are Chinese, with English aliases):
+
+| Intent | Reply |
+|---|---|
+| Approve one request | `同意 1` / `allow 1` — a bare `同意` / `allow` applies to the oldest pending request |
+| Reject one request | `拒绝 1` / `deny 1` — a bare `拒绝` / `deny` applies to the oldest pending request |
+| Abort the pending requests | `停止` |
+| Allow everything in this session | `以后都同意`, `一直同意`, `全部放行`, `别再问了`, `always allow` |
+| Back to per-request approval | `取消自动同意`, `恢复审批`, `以后都不同意` |
+
+Semantics:
+
+- **Session scope only.** The auto-approve switch lives in memory and lasts until `/new`, a new pi session, or one of the "back to per-request approval" replies. Nothing is persisted, nothing survives a restart.
+- The switch is an **explicit user instruction**, so it is **not** affected by `approve.remember`.
+- `approve.remember: true` additionally remembers the decision **per tool** for the session: after approving `bash` once, later `bash` calls are not asked again (`/new` clears it).
+- Requests time out after **10 minutes** and are rejected with a notification. A timeout is **not** remembered as a rejection — the tool is asked again next time.
+- Approval text that arrives while no request is pending is forwarded to pi as a normal message.
+
+## Single-instance lock
+
+The QQ gateway keeps only one active connection per bot. The extension uses a `proper-lockfile` lock at `~/.pi/agent/pi-qqbot-<appId>.lock`:
+
+- the process that acquires the lock becomes the host and connects to QQ;
+- other processes stand by and retry every 5 seconds;
+- when the host exits or crashes (30 second heartbeat timeout), a standby process takes over.
 
-## 前置条件
+## Prerequisites
 
-1. 在 [QQ 开放平台](https://q.qq.com/) 创建机器人，拿到 **AppID** 与 **AppSecret**。
-2. 未上线阶段配置**沙箱单聊账号**，并把 `sandbox` 设为 `true`。
-3. 正式环境填写服务器公网出口 IP 白名单。
+1. Create a bot on the [QQ Open Platform](https://q.qq.com/) and copy its **AppID** / **AppSecret**.
+2. Before the bot is published, configure a **sandbox C2C account** and set `sandbox` to `true`.
+3. In production, add the server's public egress IP to the bot's allowlist.
 
-## 日志
+## Logs
 
-调试日志写入 `~/.pi/agent/pi-qqbot.log`。
+Debug logs are written to `~/.pi/agent/pi-qqbot.log`.
 
 ## License
 

package/README.zh-CN.md

@@ -0,0 +1,117 @@
+# pi-qqbot
+
+把 **[Pi](https://pi.dev) coding agent** 接入 QQ 单聊的桥接插件：在 QQ 里发一句话，让 AI 在运行 pi 的那台机器上干活 —— 执行危险工具前会先在 QQ 里向你申请审批。
+
+[English](README.md) | **简体中文**
+
+> **单会话设计（v1）**：所有 QQ 用户共用同一个 pi 会话。多用户/多会话后续基于 pi SDK 实现。
+
+## 功能
+
+| 功能 | 说明 |
+|---|---|
+| **对话驱动 agent** | QQ 单聊消息送入当前 pi 会话，AI 的回复发回 QQ（长文本自动分片）。 |
+| **远程审批** | pi 执行 `bash` / `powershell` / `write` / `edit`，或任何带 `destructiveHint` 注解的工具前，先在 QQ 里申请审批。 |
+| **会话级「以后都同意」** | 回复「以后都同意」，**当前会话**内所有审批请求直接放行，连已经挂起的那条也一起放行。 |
+| **单实例锁** | 只有一个 pi 进程作为宿主连接 QQ，其余待命，宿主退出后自动接管。 |
+| **内置指令** | `/new`、`/status`、`/help`。 |
+
+## 安装
+
+```bash
+# 从 npm 安装
+pi install npm:@zxh126/pi-qqbot
+
+# 或从本地目录安装（需要先装依赖）
+npm install
+pi install ./pi-qqbot
+```
+
+然后创建 `~/.pi/agent/pi-qqbot.json`：
+
+```json
+{
+  "appId": "你的AppID",
+  "appSecret": "你的AppSecret",
+  "sandbox": true,
+  "allowlist": [],
+  "markdownReply": false,
+  "streaming": false,
+  "approve": {
+    "tools": ["bash", "powershell", "write", "edit"],
+    "remember": true
+  }
+}
+```
+
+| 字段 | 默认 | 说明 |
+|---|---|---|
+| `appId` / `appSecret` | 必填 | QQ 开放平台机器人凭据 |
+| `sandbox` | `false` | 未提审上线的 bot 用 `true`（沙箱环境） |
+| `allowlist` | `[]` | openid 白名单，空 = 不限制 |
+| `markdownReply` | `false` | QQ 单聊不支持 markdown，保持 `false` |
+| `streaming` | `false` | 预留，v1 未启用流式 |
+| `approve.tools` | `["bash","powershell","write","edit"]` | 需要审批的工具名；带 `destructiveHint` 注解的工具同样会拦截 |
+| `approve.remember` | `true` | 会话内按工具记住决策（同类工具不再重复询问） |
+
+也可用环境变量 `QQ_BOT_APPID` / `QQ_BOT_APPSECRET` 代替文件里的凭据。
+
+## 使用
+
+启动 pi 后，在 QQ 里给机器人发消息，pi 会处理并回复。
+
+| 指令 | 说明 |
+|---|---|
+| `/new` | 重置：清空回复缓冲、审批记忆与自动同意开关 |
+| `/status` | 查看忙闲状态、自动同意状态、待审批数量 |
+| `/help` | 帮助 |
+
+其余文本都作为用户消息交给 pi。
+
+## 远程审批
+
+```text
+[审批 #1] bash: rm -rf node_modules
+回复「同意 1」批准，「拒绝 1」拒绝，「停止」终止本轮。
+要本会话内全部放行，回复「以后都同意」（可用「取消自动同意」关闭）。
+```
+
+回复用语（审批关键词以中文为主，也支持英文别名）：
+
+| 意图 | 回复 |
+|---|---|
+| 批准某条 | `同意 1` / `allow 1`；裸 `同意` / `allow` 作用于最早的一条待审批 |
+| 拒绝某条 | `拒绝 1` / `deny 1`；裸 `拒绝` / `deny` 作用于最早的一条待审批 |
+| 终止当前待审批 | `停止` |
+| 本会话全部放行 | `以后都同意`、`一直同意`、`全部放行`、`别再问了`、`always allow` |
+| 恢复逐条审批 | `取消自动同意`、`恢复审批`、`以后都不同意` |
+
+语义说明：
+
+- **仅当前会话有效**：自动同意开关只存在于内存，`/new`、pi 新会话，或回复「取消自动同意」类用语后立即失效；不写盘、不跨进程保留。
+- 该开关是**用户的显式指令**，**不受 `approve.remember` 配置限制**。
+- `approve.remember: true` 时会额外**按工具名**记住决策：同意过一次 `bash`，本会话后续 `bash` 不再询问（`/new` 清除）。
+- 审批请求 **10 分钟**超时后自动拒绝并通知；超时**不会**被记成“拒绝”，下次仍会询问。
+- 没有待审批请求时，这类文本会作为普通消息转交给 pi。
+
+## 单实例锁
+
+QQ 网关对同一 bot 只保留一个活跃连接。插件用 `proper-lockfile` 文件锁（`~/.pi/agent/pi-qqbot-<appId>.lock`）：
+
+- 抢到锁的进程 = 宿主，连接 QQ；
+- 其余进程待命，每 5 秒重试；
+- 宿主退出或崩溃（30 秒心跳超时）后，待命进程自动接管。
+
+## 前置条件
+
+1. 在 [QQ 开放平台](https://q.qq.com/) 创建机器人，拿到 **AppID** 与 **AppSecret**。
+2. 未上线阶段配置**沙箱单聊账号**，并把 `sandbox` 设为 `true`。
+3. 正式环境填写服务器公网出口 IP 白名单。
+
+## 日志
+
+调试日志写入 `~/.pi/agent/pi-qqbot.log`。
+
+## License
+
+MIT

package/approver.ts

@@ -3,8 +3,19 @@
  * - 每个待审批请求生成编号，发到 QQ，等用户回复「同意/拒绝 N」或「停止」。
  * - register 返回一个 Promise，QQ 回复后 resolve 决策。
  * - remember 记忆：会话内同意/拒绝某工具后，同类工具不再询问。
+ * - 自动同意（「以后都同意」）：会话级开关，开启后本会话内所有需审批的工具直接放行，
+ *   直到 /new、新会话或回复「取消自动同意」为止（不跨会话、不写盘）。
  */
-export type ApproveDecision = "allow" | "block" | "terminate";
+export type ApproveDecision = "allow" | "block" | "terminate" | "timeout";
+
+/** parseReply 的解析结果：前四种对应具体动作，always/revoke 操作会话级自动同意 */
+export type ParsedDecision = "allow" | "block" | "terminate" | "always" | "revoke";
+
+export interface ParsedReply {
+  decision: ParsedDecision;
+  /** 缺省表示「作用于最早的一条待审批」，没有待审批时按普通消息处理 */
+  seq?: number;
+}
 
 interface PendingApproval {
   summary: string;
@@ -12,12 +23,37 @@ interface PendingApproval {
   resolve: (decision: ApproveDecision) => void;
 }
 
+/** 「以后都同意」类表达 */
+const RE_ALWAYS =
+  /(以后|之后|今后|一直|全都|全部|都)\s*(同意|允许|批准|放行)|别再(问|烦|提示)|always\s*(allow|yes)/i;
+/** 「取消自动同意」类表达（含「以后都不同意」） */
+const RE_REVOKE =
+  /(取消|关闭|结束|停止)\s*自动同意|^恢复审批$|(以后|之后|今后|都|全部)\s*不(同意|允许|批准|放行)/;
+/** 「停止」终止本轮 */
+const RE_TERMINATE = /^停止$/;
+/** 带或不带编号的批准/拒绝 */
+const RE_DECIDE = /^(同意|批准|放行|允许|allow|拒绝|驳回|deny)\s*(\d+)?$/i;
+
 export class Approver {
   private pending = new Map<number, PendingApproval>();
   private rememberMap = new Map<string, ApproveDecision>();
   private nextSeq = 1;
+  private autoAllow = false;
+  private timeoutMs: number;
+
+  constructor(timeoutMs: number) {
+    this.timeoutMs = timeoutMs;
+  }
+
+  /** 会话级自动同意是否开启 */
+  get autoAllowed(): boolean {
+    return this.autoAllow;
+  }
 
-  constructor(private timeoutMs: number) {}
+  /** 待审批请求数量 */
+  get pendingCount(): number {
+    return this.pending.size;
+  }
 
   /** 会话内是否已记住某工具的决策 */
   isRemembered(toolName: string): ApproveDecision | undefined {
@@ -32,7 +68,7 @@ export class Approver {
     const done = new Promise<ApproveDecision>((resolve) => {
       const timer = setTimeout(() => {
         this.pending.delete(seq);
-        resolve("block");
+        resolve("timeout");
         onTimeout?.();
       }, this.timeoutMs);
       this.pending.set(seq, { summary, timer, resolve });
@@ -45,15 +81,29 @@ export class Approver {
     return [
       `[审批 #${seq}] ${item?.summary ?? ""}`,
       `回复「同意 ${seq}」批准，「拒绝 ${seq}」拒绝，「停止」终止本轮。`,
+      `要本会话内全部放行，回复「以后都同意」（可用「取消自动同意」关闭）。`,
     ].join("\n");
   }
 
-  parseReply(text: string): { decision: ApproveDecision; seq?: number } | null {
+  /** 最早（编号最小）的待审批请求 */
+  oldestSeq(): number | undefined {
+    let oldest: number | undefined;
+    for (const seq of this.pending.keys()) {
+      if (oldest === undefined || seq < oldest) oldest = seq;
+    }
+    return oldest;
+  }
+
+  parseReply(text: string): ParsedReply | null {
     const t = text.trim();
-    if (/^停止$/.test(t)) return { decision: "terminate" };
-    const m = /^(同意|拒绝)\s*(\d+)$/.exec(t);
+    if (!t) return null;
+    if (RE_REVOKE.test(t)) return { decision: "revoke" };
+    if (RE_ALWAYS.test(t)) return { decision: "always" };
+    if (RE_TERMINATE.test(t)) return { decision: "terminate" };
+    const m = RE_DECIDE.exec(t);
     if (!m) return null;
-    return { decision: m[1] === "同意" ? "allow" : "block", seq: Number(m[2]) };
+    const allow = /^(同意|批准|放行|允许|allow)$/i.test(m[1]);
+    return { decision: allow ? "allow" : "block", seq: m[2] ? Number(m[2]) : undefined };
   }
 
   confirm(seq: number, decision: ApproveDecision): boolean {
@@ -65,23 +115,39 @@ export class Approver {
     return true;
   }
 
+  /** 放行所有待审批请求（开启自动同意时用） */
+  allowAll(): number {
+    return this.resolveAll("allow");
+  }
+
   /** 终止所有待审批请求（「停止」） */
   terminateAll(): number {
-    let count = 0;
-    for (const [seq, item] of [...this.pending]) {
-      clearTimeout(item.timer);
-      this.pending.delete(seq);
-      item.resolve("terminate");
-      count++;
-    }
-    return count;
+    return this.resolveAll("terminate");
+  }
+
+  /** 开启/关闭会话级自动同意 */
+  setAutoAllow(on: boolean): void {
+    this.autoAllow = on;
   }
 
   remember(toolName: string, decision: ApproveDecision) {
     this.rememberMap.set(toolName, decision);
   }
 
+  /** 清空会话状态（remember 记忆 + 自动同意开关） */
   reset() {
     this.rememberMap.clear();
+    this.autoAllow = false;
+  }
+
+  private resolveAll(decision: ApproveDecision): number {
+    let count = 0;
+    for (const [seq, item] of [...this.pending]) {
+      clearTimeout(item.timer);
+      this.pending.delete(seq);
+      item.resolve(decision);
+      count++;
+    }
+    return count;
   }
 }

package/config.ts

@@ -4,7 +4,7 @@ import { CONFIG_PATH } from "./constants";
 export interface ApproveConfig {
   /** 需要 QQ 审批的工具名（如 bash/powershell/write/edit） */
   tools: string[];
-  /** 会话内记住选择：同意/拒绝后同类工具不再询问 */
+  /** 会话内记住选择：同意/拒绝后同类工具不再询问（「以后都同意」不受此开关限制） */
   remember: boolean;
 }
 

package/index.ts

@@ -80,6 +80,12 @@ export default function (pi: ExtensionAPI) {
     const needsApproval = cfg.approve.tools.includes(toolName) || destructive;
     if (!needsApproval) return; // 放行
 
+    // 会话级自动同意（用户回复过「以后都同意」）：本会话内直接放行，不落盘、不跨会话
+    if (state.approver.autoAllowed) {
+      log("[approve] 自动同意放行:", toolName);
+      return;
+    }
+
     // 会话内已记住的决策
     const remembered = cfg.approve.remember ? state.approver.isRemembered(toolName) : undefined;
     if (remembered === "allow") return; // 已记住放行
@@ -104,7 +110,12 @@ export default function (pi: ExtensionAPI) {
       log("[approve] 用户停止");
       return { block: true, terminate: true, reason: "QQ 用户停止" };
     }
-    // block
+    if (decision === "timeout") {
+      // 超时不写 remember：一次没回复不该永久封死该工具
+      log("[approve] 审批超时 #", seq);
+      return { block: true, reason: `QQ 审批超时（#${seq}）：${summary}` };
+    }
+    // block（用户显式拒绝）
     if (cfg.approve.remember) state.approver.remember(toolName, "block");
     log("[approve] 用户拒绝 #", seq);
     return { block: true, reason: `QQ 用户拒绝了 ${summary}` };
@@ -118,6 +129,8 @@ export default function (pi: ExtensionAPI) {
       return;
     }
     state.cfg = cfg;
+    // 新会话：清空 remember 记忆与自动同意开关（自动同意只在当前会话有效）
+    state.approver.reset();
     log("[setup] 配置已加载 sandbox=", cfg.sandbox);
 
     const restBase = cfg.sandbox ? REST_BASE_SANDBOX : REST_BASE_PROD;
@@ -195,17 +208,52 @@ async function handleMessage(
     if (parsed) {
       if (parsed.decision === "terminate") {
         const n = state.approver.terminateAll();
-        await replyTo(api, state, msg.openid, `已终止 ${n} 个待审批请求`);
+        state.approver.setAutoAllow(false);
+        await replyTo(api, state, msg.openid, `已终止 ${n} 个待审批请求，自动同意已关闭`);
         return;
       }
-      const ok = state.approver.confirm(parsed.seq!, parsed.decision);
-      await replyTo(
-        api,
-        state,
-        msg.openid,
-        ok ? (parsed.decision === "allow" ? `已批准 #${parsed.seq}` : `已拒绝 #${parsed.seq}`) : `#${parsed.seq} 不存在或已超时`,
-      );
-      return;
+      if (parsed.decision === "always") {
+        // 「以后都同意」= 本会话内全部放行：立刻开启开关并放行当前所有待审批
+        state.approver.setAutoAllow(true);
+        const n = state.approver.allowAll();
+        log("[approve] 开启会话级自动同意，放行", n, "个待审批");
+        await replyTo(
+          api,
+          state,
+          msg.openid,
+          [
+            `已开启自动同意：本会话内需审批的工具全部放行${n > 0 ? `，已放行 ${n} 个待审批请求` : ""}。`,
+            "回复「取消自动同意」或 /new 恢复逐条审批。",
+          ].join("\n"),
+        );
+        return;
+      }
+      if (parsed.decision === "revoke") {
+        const was = state.approver.autoAllowed;
+        state.approver.setAutoAllow(false);
+        log("[approve] 关闭自动同意 was=", was);
+        await replyTo(
+          api,
+          state,
+          msg.openid,
+          was ? "已关闭自动同意，恢复逐条审批。" : "当前没有开启自动同意，仍需逐条审批。",
+        );
+        return;
+      }
+      // allow / block：没写编号时作用于最早的一条待审批
+      const seq = parsed.seq ?? state.approver.oldestSeq();
+      if (seq !== undefined) {
+        const ok = state.approver.confirm(seq, parsed.decision);
+        const text = !ok
+          ? `#${seq} 不存在或已超时`
+          : parsed.decision === "allow"
+            ? `已批准 #${seq}`
+            : `已拒绝 #${seq}`;
+        await replyTo(api, state, msg.openid, text);
+        return;
+      }
+      // 没有待审批：这句「同意/拒绝」当普通消息交给 pi，继续往下走
+      log("[msg] 审批类文本但无待审批，按普通消息处理");
     }
 
     // 内置指令
@@ -220,13 +268,22 @@ async function handleMessage(
       return;
     }
     if (cmd === "status") {
-      await replyTo(api, state, msg.openid, `状态: ${state.busy ? "处理中" : "空闲"}`);
+      await replyTo(
+        api,
+        state,
+        msg.openid,
+        [
+          `状态: ${state.busy ? "处理中" : "空闲"}`,
+          `自动同意: ${state.approver.autoAllowed ? "已开启（本会话有效）" : "未开启"}`,
+          `待审批: ${state.approver.pendingCount}`,
+        ].join("\n"),
+      );
       return;
     }
     if (cmd === "new") {
       state.replyBuffer.reset();
       state.approver.reset();
-      await replyTo(api, state, msg.openid, "已重置，下一条消息开启新对话。");
+      await replyTo(api, state, msg.openid, "已重置（含审批记忆/自动同意），下一条消息开启新对话。");
       return;
     }
 

package/package.json

@@ -1,14 +1,22 @@
 {
   "name": "@zxh126/pi-qqbot",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "type": "module",
-  "description": "把 Pi coding agent 接入 QQ 单聊的桥接插件（单会话版）",
+  "description": "Bridge the Pi coding agent into QQ private chats, with remote tool-call approval",
   "license": "MIT",
-  "keywords": ["pi-package", "qq", "bot"],
+  "keywords": ["pi-package", "pi", "qq", "qqbot", "bot", "coding-agent", "approval"],
+  "repository": {
+    "type": "git",
+    "url": "git+https://gitee.com/zxh126/pi-qqbot.git"
+  },
+  "homepage": "https://gitee.com/zxh126/pi-qqbot#readme",
+  "bugs": {
+    "url": "https://gitee.com/zxh126/pi-qqbot/issues"
+  },
   "pi": {
     "extensions": ["./index.ts"]
   },
-  "files": ["*.ts", "qq", "util", "README.md", "LICENSE"],
+  "files": ["*.ts", "qq", "util", "README.md", "README.zh-CN.md", "LICENSE"],
   "dependencies": {
     "ws": "^8.18.0",
     "proper-lockfile": "^4.1.2"