@zxh126/pi-qqbot 1.0.0 → 1.2.0

package/index.ts

@@ -7,6 +7,8 @@ import {
   PASSIVE_WINDOW_MS,
   APPROVAL_TIMEOUT_MS,
   LOCK_PATH,
+  DISPATCH_RETRY_MS,
+  CANCEL_SETTLE_GRACE_MS,
 } from "./constants";
 import { log } from "./logger";
 import { tryAcquireLock, startLockRetry } from "./lock";
@@ -14,7 +16,8 @@ import { AuthManager } from "./qq/auth";
 import { QQApi } from "./qq/api";
 import { createGatewayUrlFetcher, QQGateway, QQMessage } from "./qq/gateway";
 import { Approver } from "./approver";
-import { routeSlash, runBridge } from "./slash";
+import { parsePickIndex, pickerExpired, routeSlash, runBridge, type PickerState } from "./slash";
+import { agoLabel, MessageQueue, previewText, type QueuedJob } from "./queue";
 import { ReplyBuffer } from "./stream-buffer";
 import { splitText } from "./util/chunk";
 
@@ -33,14 +36,27 @@ interface State {
   ctx: ExtensionContext | null;
   /** 最近一条 QQ 消息的发送者：桥接命令用它回执 */
   lastOpenid: string | null;
+  /** 待选择列表（/tree、/fork、/resume 发出后的编号等待状态） */
+  picker: PickerState | null;
+  /** 发出列表的 QQ 用户：只有他能回编号 */
+  pickerOwner: string | null;
   /** /qq 桥接命令的回执通道（每次收到 QQ 消息时刷新） */
   bridgeReply: ((text: string) => void) | null;
   /** 本轮已被用户取消：settle 时丢弃半截回复 */
   cancelled: boolean;
+  /** 忙碌时收到的任务：当前任务 settle 后逐条执行 */
+  queue: MessageQueue;
+  /** 正在出队派发（防 settled / 重试竞态下重复派发） */
+  dispatching: boolean;
+  /** 当前派发的任务已经真的启动了 run（agent_start 过）：此时报错不重试，避免重复执行 */
+  runStarted: boolean;
+  /** /cancel 之后等 agent_settled 的兜底定时器 */
+  cancelTimer: ReturnType<typeof setTimeout> | null;
 }
 
-export default function (pi: ExtensionAPI) {
-  const state: State = {
+/** 扩展运行所需的状态（导出只为测试用） */
+export function createInitialState(): State {
+  return {
     cfg: null,
     api: null,
     approver: new Approver(APPROVAL_TIMEOUT_MS),
@@ -53,14 +69,30 @@ export default function (pi: ExtensionAPI) {
     busy: false,
     ctx: null,
     lastOpenid: null,
+    picker: null,
+    pickerOwner: null,
     bridgeReply: null,
     cancelled: false,
+    queue: new MessageQueue(),
+    dispatching: false,
+    runStarted: false,
+    cancelTimer: null,
   };
+}
+
+export default function (
+  pi: ExtensionAPI,
+  /** 仅测试用：注入状态，让事件处理器与 handleMessage 共享同一份状态 */
+  options?: { state?: State },
+) {
+  const state: State = options?.state ?? createInitialState();
 
   // ---- 事件：run 开始，记住 ctx（取消指令要调用 ctx.abort()）----
   pi.on("agent_start", (_event, ctx) => {
     state.ctx = ctx;
     state.cancelled = false;
+    state.runStarted = true;
+    clearCancelTimer(state);
   });
 
   // ---- 事件：累积 assistant 文本 ----
@@ -71,8 +103,9 @@ export default function (pi: ExtensionAPI) {
     }
   });
 
-  // ---- 事件：run 结束，发回复 ----
+  // ---- 事件：run 结束，发回复，然后接着跑队列里的下一条 ----
   pi.on("agent_settled", async () => {
+    clearCancelTimer(state);
     const cancelled = state.cancelled;
     const text = state.replyBuffer.take();
     const openid = state.currentOpenid;
@@ -80,15 +113,17 @@ export default function (pi: ExtensionAPI) {
     state.busy = false;
     state.ctx = null;
     state.cancelled = false;
+    state.runStarted = false;
     if (cancelled) {
       log("[reply] 本轮已被取消，丢弃半截回复（长度", text.length, "）");
-      return;
-    }
-    if (!text || !openid || !state.api) return;
-    log("[reply] agent_settled，回复 openid=", openid, "text=", text.slice(0, 80));
-    for (const chunk of splitText(text)) {
-      await state.api.sendC2C(openid, chunk).catch((e) => log("[reply] 发送失败:", String(e)));
+    } else if (text && openid && state.api) {
+      log("[reply] agent_settled，回复 openid=", openid, "text=", text.slice(0, 80));
+      for (const chunk of splitText(text)) {
+        await state.api.sendC2C(openid, chunk).catch((e) => log("[reply] 发送失败:", String(e)));
+      }
     }
+    // 本轮结束：取队列里的下一条继续执行（不 await，避免卡住 settled 的派发阶段）
+    drainQueue(pi, state);
   });
 
   // ---- 事件：tool_call 审批 ----
@@ -157,7 +192,10 @@ export default function (pi: ExtensionAPI) {
     state.cfg = cfg;
     // 新会话：清空 remember 记忆与自动同意开关（自动同意只在当前会话有效）
     state.approver.reset();
-    log("[setup] 配置已加载 sandbox=", cfg.sandbox);
+    // 队列上限来自配置；新会话不继承上一个会话遗留的待执行任务
+    state.queue.setLimit(cfg.queue.max);
+    state.queue.clear();
+    log("[setup] 配置已加载 sandbox=", cfg.sandbox, "queue.max=", cfg.queue.max);
 
     const restBase = cfg.sandbox ? REST_BASE_SANDBOX : REST_BASE_PROD;
     const auth = new AuthManager(cfg.appId, cfg.appSecret);
@@ -198,6 +236,9 @@ export default function (pi: ExtensionAPI) {
   // ---- 事件：session_shutdown 清理 ----
   pi.on("session_shutdown", async () => {
     log("[shutdown] 清理资源");
+    clearCancelTimer(state);
+    const dropped = state.queue.clear();
+    if (dropped.length > 0) log("[shutdown] 丢弃队列任务", dropped.length, "条");
     if (state.stopRetry) state.stopRetry();
     state.gateway?.stop();
     if (state.releaseLock) {
@@ -225,7 +266,7 @@ export default function (pi: ExtensionAPI) {
       const rest = (space === -1 ? "" : trimmed.slice(space + 1)).trim();
       const reply = (text: string) => state.bridgeReply?.(text);
       try {
-        await runBridge(sub, rest, ctx, pi, reply);
+        await runBridge(sub, rest, ctx, pi, reply, state);
       } catch (e) {
         log("[/qq] 桥接失败:", String(e));
         reply(`/${sub} 执行失败：${String(e).slice(0, 200)}`);
@@ -242,49 +283,220 @@ function isCancelIntent(text: string): boolean {
   return RE_CANCEL.test(text.trim());
 }
 
+/** 派发失败时最多重试几次（通常是 pi 上一轮还没收尾） */
+const MAX_DISPATCH_ATTEMPTS = 3;
+
+function clearCancelTimer(state: State) {
+  if (state.cancelTimer) {
+    clearTimeout(state.cancelTimer);
+    state.cancelTimer = null;
+  }
+}
+
+/**
+ * 对外看是“忙”：有任务在跑、正在派发，或者队列里还有任务等着（比如派发失败后的重试窗口）。
+ * 这三种情况新消息都应该进队列，而不是插队直接开新一轮。
+ */
+function isBusy(state: State): boolean {
+  return state.busy || state.dispatching || state.queue.size > 0;
+}
+
+/**
+ * /cancel 之后 abort() 是异步的：正常路径靠 agent_settled 释放 busy 并继续队列；
+ * 万一 abort 没能触发 settled（比如那一轮正好已经结束），宽限期后强制解锁。
+ */
+function armCancelWatchdog(pi: ExtensionAPI, state: State) {
+  clearCancelTimer(state);
+  const timer = setTimeout(() => {
+    state.cancelTimer = null;
+    if (!state.cancelled) return;
+    log("[cancel] abort 后", CANCEL_SETTLE_GRACE_MS, "ms 内没有 agent_settled，强制释放 busy");
+    state.cancelled = false;
+    state.busy = false;
+    state.ctx = null;
+    state.currentOpenid = null;
+    state.replyBuffer.reset();
+    drainQueue(pi, state);
+  }, CANCEL_SETTLE_GRACE_MS);
+  (timer as any).unref?.();
+  state.cancelTimer = timer;
+}
+
+/**
+ * 把一条任务交给 pi，并把它标记为「当前任务」。
+ * 不 await sendUserMessage：它返回的 promise 要等整轮跑完，await 会卡住调用方
+ * （agent_settled 里派发时更是不允许）。错误交给 onDispatchError 重试/回执。
+ */
+function startJob(pi: ExtensionAPI, state: State, job: QueuedJob) {
+  state.currentOpenid = job.openid;
+  state.lastOpenid = job.openid;
+  state.pickerOwner = job.openid;
+  state.bridgeReply = (text: string) => {
+    void replyTo(state.api!, state, job.openid, text);
+  };
+  state.busy = true;
+  state.cancelled = false;
+  state.runStarted = false;
+  state.replyBuffer.reset();
+  clearCancelTimer(state);
+  log(
+    "[msg] 送入 pi:",
+    job.id > 0 ? `队列 #${job.id}` : "直接",
+    "openid=",
+    job.openid,
+    "text=",
+    job.text.slice(0, 60),
+  );
+  try {
+    void Promise.resolve(
+      pi.sendUserMessage(job.text, { expandPromptTemplates: true, deliverAs: "followUp" }),
+    ).catch((error) => onDispatchError(pi, state, job, error));
+  } catch (error) {
+    onDispatchError(pi, state, job, error);
+  }
+}
+
+/** 派发失败：先重试（放回队首），多次失败就把错误回给发送者并继续队列 */
+function onDispatchError(pi: ExtensionAPI, state: State, job: QueuedJob, error: unknown) {
+  const message = String((error as any)?.message ?? error).slice(0, 200);
+  log("[msg] 派发失败:", message);
+  if (state.runStarted) {
+    // run 已经启动了：这次报错属于这一轮自己的问题，收尾交给 agent_settled，不能重试
+    log("[msg] 本轮已启动过 agent，不重试，等 agent_settled 收尾");
+    return;
+  }
+  state.busy = false;
+  state.currentOpenid = null;
+  job.attempts += 1;
+  if (job.attempts < MAX_DISPATCH_ATTEMPTS) {
+    state.queue.unshift(job);
+    log("[msg]", DISPATCH_RETRY_MS, "ms 后重试（第", job.attempts, "次）");
+    const timer = setTimeout(() => drainQueue(pi, state), DISPATCH_RETRY_MS);
+    (timer as any).unref?.();
+    return;
+  }
+  const api = state.api;
+  if (api) void replyTo(api, state, job.openid, `这条消息执行失败：${message}`);
+  drainQueue(pi, state);
+}
+
+/** 当前任务结束后，取队列里的下一条开始执行（空闲时才会真的派发） */
+function drainQueue(pi: ExtensionAPI, state: State) {
+  if (state.busy || state.dispatching) return;
+  const job = state.queue.shift();
+  if (!job) return;
+  state.dispatching = true;
+  try {
+    log("[queue] 出队 #", job.id, "剩余", state.queue.size, "条", "text=", job.text.slice(0, 60));
+    const api = state.api;
+    if (api && state.cfg?.queue.ack !== false) {
+      const rest = state.queue.size > 0 ? `（后面还有 ${state.queue.size} 条）` : "";
+      void replyTo(api, state, job.openid, `开始执行队列 #${job.id}${rest}`);
+    }
+    startJob(pi, state, job);
+  } finally {
+    state.dispatching = false;
+  }
+}
+
+/** 入队（忙碌时的统一入口）：回执排队位置 */
+async function enqueueJob(
+  api: QQApi,
+  state: State,
+  openid: string,
+  text: string,
+): Promise<boolean> {
+  const result = state.queue.push(openid, text);
+  if (!result.ok) {
+    log("[queue] 队列已满（上限", state.queue.max, "），拒绝入队");
+    if (state.queue.max === 0) {
+      await replyTo(api, state, openid, "上一条消息还在处理中，请稍候…（队列已关闭：queue.max=0）");
+      return false;
+    }
+    await replyTo(
+      api,
+      state,
+      openid,
+      `队列已满（上限 ${state.queue.max} 条），这条没排上。发 /queue 查看队列，或 /cancel 清空后重发。`,
+    );
+    return false;
+  }
+  log("[queue] 入队 #", result.job.id, "size=", state.queue.size, "ahead=", result.ahead);
+  await replyTo(
+    api,
+    state,
+    openid,
+    `已排队 #${result.job.id}${result.ahead > 0 ? `（前面还有 ${result.ahead} 条）` : ""}，当前任务结束后自动执行。发 /queue 查看队列，/cancel 可中止当前任务并清空队列。`,
+  );
+  return true;
+}
+
+function formatQueue(state: State): string {
+  const lines = [`当前任务：${state.busy ? "处理中（发 /cancel 可中断）" : "空闲"}`];
+  const jobs = state.queue.list();
+  if (jobs.length === 0) {
+    lines.push("队列：空");
+    return lines.join("\n");
+  }
+  lines.push(`队列：${jobs.length} 条（上限 ${state.queue.max}）`);
+  jobs.slice(0, 10).forEach((job, index) => {
+    lines.push(`  ${index + 1}. #${job.id} · ${agoLabel(job.enqueuedAt)} · ${previewText(job.text)}`);
+  });
+  if (jobs.length > 10) lines.push(`  … 还有 ${jobs.length - 10} 条`);
+  lines.push("发 /queue clear 清空，/queue drop <编号> 删除一条。");
+  return lines.join("\n");
+}
+
 /**
- * 用户发来取消指令：终止待审批、abort 当前 run、丢弃半截回复，然后回执。
+ * 用户发来取消指令：终止待审批、清空队列、abort 当前 run、丢弃半截回复，然后回执。
+ * 取消本身永不入队（“取消除外”），立即生效。
  * （「取消自动同意」/「关闭自动同意」不属于取消指令，仍走审批分支。）
  */
 async function handleCancel(
+  pi: ExtensionAPI,
   state: State,
   api: QQApi,
   openid: string,
 ): Promise<void> {
   const terminated = state.approver.terminateAll();
+  const dropped = state.queue.clear();
   const running = state.busy || Boolean(state.ctx?.signal);
-
   if (!running) {
+    const parts: string[] = [];
+    if (terminated > 0) parts.push(`已终止 ${terminated} 个待审批请求`);
+    if (dropped.length > 0) parts.push(`已清空队列（${dropped.length} 条）`);
     await replyTo(
       api,
       state,
       openid,
-      terminated > 0
-        ? `已终止 ${terminated} 个待审批请求，当前没有正在运行的任务。`
+      parts.length > 0
+        ? `${parts.join("，")}，当前没有正在运行的任务。`
         : "当前没有正在运行的任务。",
     );
     return;
   }
 
   state.cancelled = true;
-  state.busy = false;
   state.replyBuffer.reset();
   state.currentOpenid = null; // 被中止的 run 不再往 QQ 发半截回复
   const ctx = state.ctx;
   state.ctx = null;
   try {
     ctx?.abort();
-    log("[cancel] 已请求中止当前 run，终止待审批", terminated, "个");
+    log("[cancel] 已请求中止当前 run，终止待审批", terminated, "个，清空队列", dropped.length, "条");
   } catch (e) {
     log("[cancel] abort 失败:", String(e));
   }
+  // busy 保持 true 直到 agent_settled：期间新消息会排队，不会和正在收尾的 run 撞车
+  armCancelWatchdog(pi, state);
+  const notice: string[] = [];
+  if (terminated > 0) notice.push(`并终止了 ${terminated} 个待审批请求`);
+  if (dropped.length > 0) notice.push(`队列中的 ${dropped.length} 条已清空`);
   await replyTo(
     api,
     state,
     openid,
-    terminated > 0
-      ? `已取消当前任务，并终止了 ${terminated} 个待审批请求。可以发送新消息继续。`
-      : "已取消当前任务。可以发送新消息继续。",
+    `已取消当前任务${notice.length > 0 ? `，${notice.join("，")}` : ""}。可以发送新消息继续。`,
   );
 }
 
@@ -304,23 +516,75 @@ export async function handleMessage(
     }
     state.passiveRefs.set(msg.openid, { msgId: msg.msgId, receivedAt: Date.now() });
 
-    // 取消指令优先于审批解析：「取消」不该被当成审批动作
+    // 待选择的编号回复（/tree、/fork、/resume 之后）
+    if (state.picker) {
+      if (pickerExpired(state.picker)) {
+        state.picker = null;
+      } else if (state.picker.openid === msg.openid) {
+        const index = parsePickIndex(msg.content);
+        if (index !== null) {
+          if (state.busy) {
+            await replyTo(api, state, msg.openid, "当前有任务在跑，先发 /cancel 取消，再回编号。");
+            return;
+          }
+          if (index > state.picker.items.length) {
+            await replyTo(api, state, msg.openid, `编号 ${index} 超出范围（1-${state.picker.items.length}）。`);
+            return;
+          }
+          state.pickerOwner = msg.openid;
+          state.bridgeReply = (text: string) => {
+            void replyTo(api, state, msg.openid, text);
+          };
+          log("[cmd] 选择编号", index, "kind=", state.picker.kind);
+          pi.sendUserMessage(`/qq pick ${index}`, { expandPromptTemplates: true });
+          return;
+        }
+        if (/^(取消|算了|cancel)$/i.test(msg.content.trim())) {
+          state.picker = null;
+          await replyTo(api, state, msg.openid, "已放弃选择。");
+          return;
+        }
+      }
+    }
+
+    // 取消指令优先于审批解析：「取消」不该被当成审批动作；取消也永不入队
     if (isCancelIntent(msg.content)) {
-      await handleCancel(state, api, msg.openid);
+      await handleCancel(pi, state, api, msg.openid);
       return;
     }
 
     // 斜杠命令路由：pi 扩展命令 → 可接管的内置命令 → 仅主机可用的内置命令 → 普通文字
     state.lastOpenid = msg.openid;
+    state.pickerOwner = msg.openid;
     state.bridgeReply = (text: string) => {
       void replyTo(api, state, msg.openid, text);
     };
     const routed = await routeSlash(
       {
-        listPiCommands: () => (pi.getCommands?.() ?? []) as { name: string }[],
-        dispatch: (text: string) => pi.sendUserMessage(text, { expandPromptTemplates: true }),
+        listPiCommands: () => (pi.getCommands?.() ?? []) as { name: string; source?: string }[],
+        dispatch: (text, options) => {
+          // 提示模板 / /skill: 会开启一轮 agent run：和普通对话一样串行到队列
+          if (options?.runsTurn) {
+            if (!isBusy(state)) {
+              startJob(pi, state, state.queue.mint(msg.openid, text));
+              return "dispatched";
+            }
+            const queued = state.queue.push(msg.openid, text);
+            if (!queued.ok) {
+              log("[queue] 队列已满，命令未排队:", text.slice(0, 60));
+              return "rejected";
+            }
+            log("[queue] 命令入队 #", queued.job.id, text.slice(0, 60));
+            return "queued";
+          }
+          // 扩展命令 / 桥接命令（/qq …）不开 run，pi 允许流式期间执行，直接派发
+          void Promise.resolve(pi.sendUserMessage(text, { expandPromptTemplates: true })).catch(
+            (e) => log("[cmd] 派发失败:", String(e)),
+          );
+          return "dispatched";
+        },
         reply: (text: string) => replyTo(api, state, msg.openid, text),
-        busy: state.busy,
+        busy: isBusy(state),
         cfg: cfg.commands,
         log,
       },
@@ -383,60 +647,60 @@ export async function handleMessage(
 
     // 内置指令
     const cmd = parseCommand(msg.content);
-    if (cmd === "help") {
+    if (cmd?.name === "help") {
       await replyTo(
         api,
         state,
         msg.openid,
         [
           "pi-qqbot 指令:",
-          "/status — 查看状态（忙闲 / 自动同意 / 待审批）",
+          "/status — 查看状态（忙闲 / 队列 / 自动同意 / 待审批）",
+          "/queue — 查看队列；/queue clear 清空；/queue drop <编号> 删一条",
           "/reset — 清空回复缓冲、审批记忆与自动同意（不换会话；换会话发 /new）",
-          "/cancel（或「取消」「停止」）— 中断正在运行的任务",
+          "/cancel（或「取消」「停止」）— 中断正在运行的任务并清空队列",
           "/help — 帮助",
           "pi 的命令优先：/reload /new /compact /session /name /model /thinking，以及扩展命令、模板与 /skill:xxx。",
+          "忙碌时发来的普通消息（含模板/skill 命令）会排队，当前任务结束后自动执行。",
           "其余文本交给 pi 当作对话处理。",
         ].join("\n"),
       );
       return;
     }
-    if (cmd === "status") {
+    if (cmd?.name === "status") {
       await replyTo(
         api,
         state,
         msg.openid,
         [
-          `状态: ${state.busy ? "处理中（发送 /cancel 可中断）" : "空闲"}`,
+          `状态: ${state.busy ? "处理中（发送 /cancel 可中断）" : state.queue.size > 0 ? "空闲，但有排队任务待派发" : "空闲"}`,
+          `队列: ${state.queue.size} 条待执行${state.queue.size > 0 ? "（发 /queue 查看）" : ""}`,
           `自动同意: ${state.approver.autoAllowed ? "已开启（本会话有效）" : "未开启"}`,
           `待审批: ${state.approver.pendingCount}`,
         ].join("\n"),
       );
       return;
     }
-    if (cmd === "reset") {
+    if (cmd?.name === "queue") {
+      await handleQueueCommand(api, state, msg.openid, cmd.args);
+      return;
+    }
+    if (cmd?.name === "reset") {
       state.replyBuffer.reset();
       state.approver.reset();
       await replyTo(api, state, msg.openid, "已重置（回复缓冲/审批记忆/自动同意）。要开新会话请发 /new。");
       return;
     }
 
-    // 忙检查：单会话串行处理
-    if (state.busy) {
-      await replyTo(api, state, msg.openid, "上一条消息还在处理中，请稍候…");
+    // 忙检查：单会话串行处理——忙碌时入队，当前任务结束后自动继续
+    if (isBusy(state)) {
+      await enqueueJob(api, state, msg.openid, msg.content);
       return;
     }
 
     // ack
     await replyTo(api, state, msg.openid, "收到，正在处理");
 
-    state.currentOpenid = msg.openid;
-    state.busy = true;
-    state.cancelled = false;
-    state.replyBuffer.reset();
-
-    // 交给 pi 处理
-    pi.sendUserMessage(msg.content, { deliverAs: "followUp" });
-    log("[msg] 已送入 pi:", msg.content.slice(0, 60));
+    startJob(pi, state, state.queue.mint(msg.openid, msg.content));
   } catch (e) {
     log("[msg] 处理失败:", String(e));
     await replyTo(api, state, msg.openid, `处理失败: ${String(e).slice(0, 200)}`).catch(() => {});
@@ -462,11 +726,53 @@ async function replyTo(
   }
 }
 
-function parseCommand(text: string): "reset" | "status" | "help" | null {
+function parseCommand(text: string): { name: "reset" | "status" | "help" | "queue"; args: string } | null {
   // 注意：/new 现在属于 pi 的内置命令（由 slash 路由接管，真的开新会话），
   // 本地的「清缓冲/清审批记忆」改名为 /reset。
-  const m = /^\/(reset|status|help)\s*$/i.exec(text.trim());
-  return m ? (m[1].toLowerCase() as "reset" | "status" | "help") : null;
+  const m = /^\/(reset|status|help|queue|q)(?:\s+([\s\S]*))?$/i.exec(text.trim());
+  if (!m) return null;
+  const raw = m[1].toLowerCase();
+  return {
+    name: (raw === "q" ? "queue" : raw) as "reset" | "status" | "help" | "queue",
+    args: (m[2] ?? "").trim(),
+  };
+}
+
+/** /queue [clear|drop <编号>] */
+async function handleQueueCommand(api: QQApi, state: State, openid: string, args: string) {
+  const parts = args.split(/\s+/).filter(Boolean);
+  const sub = parts[0]?.toLowerCase() ?? "";
+
+  if (!sub) {
+    await replyTo(api, state, openid, formatQueue(state));
+    return;
+  }
+  if (/^(clear|reset|清空)$/i.test(sub)) {
+    const dropped = state.queue.clear();
+    await replyTo(
+      api,
+      state,
+      openid,
+      dropped.length > 0 ? `已清空队列（${dropped.length} 条）。` : "队列本来就是空的。",
+    );
+    return;
+  }
+  if (/^(drop|del|rm|删除|删|去掉)$/i.test(sub)) {
+    const id = Number.parseInt(parts[1] ?? "", 10);
+    if (!Number.isFinite(id)) {
+      await replyTo(api, state, openid, "用法：/queue drop <编号>（编号见 /queue）");
+      return;
+    }
+    const removed = state.queue.remove(id);
+    await replyTo(
+      api,
+      state,
+      openid,
+      removed ? `已从队列删除 #${id}：${previewText(removed.text)}` : `队列里没有 #${id}，发 /queue 查看。`,
+    );
+    return;
+  }
+  await replyTo(api, state, openid, "用法：/queue 查看 / /queue clear 清空 / /queue drop <编号> 删一条");
 }
 
 /** 从 tool_call 事件提取可读摘要，让用户在 QQ 里看清要执行什么 */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zxh126/pi-qqbot",
-  "version": "1.0.0",
+  "version": "1.2.0",
   "type": "module",
   "description": "Bridge the Pi coding agent into QQ private chats, with remote tool-call approval",
   "license": "MIT",
@@ -26,6 +26,9 @@
       "./index.ts"
     ]
   },
+  "scripts": {
+    "test": "node test/queue.test.mjs"
+  },
   "files": [
     "*.ts",
     "qq",