opencode-feishu-plugin 0.2.10 → 0.2.12

package/README.en.md

@@ -22,22 +22,29 @@ Connect [OpenCode](https://opencode.ai) to Feishu/Lark: **one Feishu topic = one
 | 📊 **Real-time visible** | "Thinking" receipt → live tool-call cards → streaming text updates; footer shows the current model |
 | ⏹ **Controllable** | Every reply card has a "force stop" button; a watchdog auto-interrupts stuck sessions; native queue with `/steer` `/now` to cut in |
 | 📎 **Images / files** | Images and files sent in Feishu are downloaded and attached to the session, so vision/file-capable models can see and read them |
+| 🖱 **Main-window menu** | Two fixed quick buttons above the chat input — "New session" and "Session list" (bot custom menu) — one tap to fire them |
 | 🚫 **No ports** | Full long-connection; no inbound port needed on the server |
 
 ## 1. Feishu app setup (~3 minutes)
 
 1. Open the [Feishu Open Platform](https://open.feishu.cn/app) → **Create an enterprise self-built app**.
 2. **Add app capability → Bot**.
-3. **Permission management** — enable these two minimal scopes:
+3. **Permission management → API permissions**: enable these two **required** scopes first:
    - `im:message.p2p_msg:readonly` — read messages users send to the bot in p2p chat
    - `im:message:send_as_bot` — send messages as the app (also used to update cards)
 
-   To **receive images / files** (downloaded and attached to sessions), add one more:
-   - `im:message:readonly` — fetch message resources (required to download images / files)
+   **To receive images / files, add one more** (skip if you don't need it):
+   - `im:message:readonly` — fetch message resources (**required** to download images / files)
+
+   > ⚠️ Without `im:message:readonly`: images/files are **not downloaded** — the message still reaches the AI, but with placeholder text ("…download failed…"). After enabling it, **re-create and publish an app version** for it to take effect.
 4. **Events & Callbacks → Event configuration**: subscription method **"Use long connection to receive events"** (do **not** pick Webhook), add event `im.message.receive_v1`.
 5. **Events & Callbacks → Callback configuration**: same long-connection method, add callback `card.action.trigger` (zero permission requirement).
-6. **Version management & release**: availability = **only yourself**, create a version and **publish**. ⚠️ Without publishing the app stays in "development" state and the long connection cannot connect — the bot will never respond.
-7. Note down the **App ID** (`cli_…`) and **App Secret**.
+6. **Bot menu (optional, recommended)**: **App capabilities → Bot → Bot custom menu** — enable the menu, pick the **floating menu** style, and add two items (any name/icon, **action = push event**):
+   - "➕ New session" → `event_key` = `new`
+   - "📋 Session list" → `event_key` = `sessions`
+   Then add the event `application.bot.menu_v6` under **Event configuration** (zero permission requirement). Result: two quick buttons above the chat input that act like sending `/new` / `/sessions`.
+7. **Version management & release**: availability = **only yourself**, create a version and **publish**. ⚠️ Without publishing the app stays in "development" state and the long connection cannot connect — the bot will never respond.
+8. Note down the **App ID** (`cli_…`) and **App Secret**.
 
 > **Why no group permission?** This plugin is a "single-user remote control". Without group permission the bot **physically cannot receive group messages** — the single-user boundary is guaranteed by the platform scope layer, not only by code.
 
@@ -104,6 +111,22 @@ The main chat **only manages**; plain text never enters any session.
 
 ![Create-session form card: directory, model, permission](image/new.png)  ![Session list card: paginate, enter/reopen, create](image/sessions.png)
 
+### Bot menu (quick buttons above the input box)
+
+![Configure the bot custom menu in the developer console (floating menu): the phone preview shows "new" / "sessions" pinned above the input box; the right panel is the item config (action = push event)](image/btns.png)
+
+After configuring the menu (setup step 6), two quick buttons stay pinned **above the chat input** in the bot window:
+
+| Button | Equivalent command | Effect |
+|---|---|---|
+| `new` | `/new` | Opens the create-session form card |
+| `sessions` | `/sessions` | Opens the session list card |
+
+- Menu `event_key`s must be **`new` / `sessions`** (the literal `/new`, `/sessions` also accepted);
+- Clicks arrive over the long connection (`application.bot.menu_v6`, zero permission requirement); the plugin synthesizes an **equivalent command message** — allowlist, dedup and command matrix behave exactly like typed commands; unknown keys are ignored silently;
+- After changing the menu, **re-publish the app version** (per the console: takes effect within ~5 minutes after publishing);
+- Message the bot at least once before using the menu (the plugin remembers the p2p chat from messages; any normal usage satisfies this).
+
 ### Inside a topic (work)
 
 A topic = a session; sending plain text is giving the AI a command.
@@ -150,7 +173,7 @@ When the agent asks via `question` or other form tools, the form becomes a Feish
 | `logLevel` | `debug`\|`info`\|`warn`\|`error` | `info` | Log level |
 | `logFile` | string \| boolean | — | `true` = write `<configDir>/plugins/feishu.log`; recommended in server mode |
 | `approvalTtlMs` | number | `600000` | Approval token / card validity |
-| `staleExecutionMs` | number | `300000` | Watchdog threshold (1–60 min) |
+| `staleExecutionMs` | number | `300000` | Watchdog threshold (0–60 min; **0 = disabled**; sessions waiting on a form / pending approval are never killed) |
 | `gatewayLocation` | string | — | Only start the gateway at this location (or its subdirectories); empty = any location |
 
 Full config (including `cardMaxTables`, `topicStatus*`, `resumeSummary*`, `keepalive*`, `gatewayMatchGraceMs`) → [docs/advanced.en.md](./docs/advanced.en.md#full-configuration).
@@ -160,11 +183,12 @@ Full config (including `cardMaxTables`, `topicStatus*`, `resumeSummary*`, `keepa
 | Symptom | Fix |
 |---|---|
 | No response to messages | ① Is the app **published** and does availability include you? ② Is the subscription **long connection** (not Webhook)? ③ Is `im:message.p2p_msg:readonly` enabled? |
+| Images / files not received (placeholder / "download failed") | Enable `im:message:readonly` (Permission management → API permissions, search "fetch message resources") → **re-create and publish an app version**; check the `feishu.log` "附件下载失败" entry for the exact reason |
 | `feishu.json` changes don't apply | Check the path, then `opencode reload` |
 | Plugin not loaded at all | npm: confirm the package name is in the `plugins` array; directory: confirm `plugins/<name>/index.js` exists |
 | No approval cards | That session wasn't started from Feishu (no mapping); by design the plugin doesn't take it over |
 | Button click says invalid credential | Token expired (10 min default) or clicker not in allowlist |
-| Session seems stuck, messages only queue | Watchdog auto-interrupts after 5 min; or tap "⏹ force stop" / send `/stop` |
+| Session seems stuck, messages only queue | Watchdog auto-interrupts after 5 min (never while a form / approval is pending; `staleExecutionMs: 0` disables it); or tap "⏹ force stop" / send `/stop` |
 | Bot goes silent after ~1h idle | opencode recycles idle locations; built-in keepalive restores automatically, see [docs/advanced.en.md](./docs/advanced.en.md#location-keep-alive) |
 | Can't see plugin logs | stderr is discarded in server mode; set `logFile: true` |
 | Multiple long connections / duplicate replies | Set `gatewayLocation` to a common working directory, see [docs/advanced.en.md](./docs/advanced.en.md#multiple-instances-and-gateway-election) |

package/README.md

@@ -22,22 +22,29 @@
 | 📊 **实时可见** | 「思考中」回执 → 工具调用实时上卡 → 文本流式更新，页脚显示当前模型 |
 | ⏹ **可控可停** | 每张回复卡带「强制停止」；看门狗自动中断卡死会话；忙时原生排队，`/steer` `/now` 可插队 |
 | 📎 **图片 / 文件** | 飞书里的图片 / 文件自动下载并挂进会话，支持视觉 / 文件的模型直接看图、读文件 |
+| 🖱 **主窗口菜单** | 机器人输入框上固定「新建会话」「会话列表」快捷按钮（机器人自定义菜单），一点即用 |
 | 🚫 **无端口** | 全程长连接，服务器无需开放任何入站端口 |
 
 ## 一、飞书后台配置（约 3 分钟）
 
 1. 打开 [飞书开放平台](https://open.feishu.cn/app) → **创建企业自建应用**。
 2. **添加应用能力 → 机器人**。
-3. **权限管理**，开通这两个最小 scope：
+3. **权限管理 → API 权限**：先开这两个**必开** scope：
    - `im:message.p2p_msg:readonly` —— 读取用户发给机器人的单聊消息
    - `im:message:send_as_bot` —— 以应用身份发消息（也用于更新卡片）
 
-   如需**接收图片 / 文件**（下载后挂进会话），再加开一个：
-   - `im:message:readonly` —— 获取消息中的资源文件（图片 / 文件下载的必要条件）
+   **接收图片 / 文件需要再加开一个**（不需要该功能可跳过）：
+   - `im:message:readonly` —— 获取消息中的资源文件（图片 / 文件下载的**必要条件**）
+
+   > ⚠️ 未开通 `im:message:readonly` 时：图片/文件**不会被下载**，消息照常送达 AI，但只带占位文本（"…下载失败：…"）。开通后要**重新创建版本并发布**才生效。
 4. **事件与回调 → 事件配置**：订阅方式选**「使用长连接接收事件」**（不要选 Webhook），添加事件 `im.message.receive_v1`。
 5. **事件与回调 → 回调配置**：订阅方式同样选**长连接**，添加回调 `card.action.trigger`（零权限要求）。
-6. **版本管理与发布**：可用范围 = **仅本人**，创建版本并**发布**。⚠️ 不发布就是开发态，长连接连不上，机器人不会有任何反应。
-7. 记下 **App ID**（`cli_…`）与 **App Secret**。
+6. **机器人菜单（可选，推荐）**：**应用能力 → 机器人 → 机器人自定义菜单** 开启菜单，展示形式选**悬浮菜单**，添加两个菜单项（名称/图标随意，**响应动作=推送事件**）：
+   - 「➕ 新建会话」→ 事件 Key = `new`
+   - 「📋 会话列表」→ 事件 Key = `sessions`
+   再到 **事件配置** 添加事件 `application.bot.menu_v6`（零权限要求）。效果：机器人输入框上多两个快捷按钮，点一下等于发 `/new` / `/sessions`。
+7. **版本管理与发布**：可用范围 = **仅本人**，创建版本并**发布**。⚠️ 不发布就是开发态，长连接连不上，机器人不会有任何反应。
+8. 记下 **App ID**（`cli_…`）与 **App Secret**。
 
 > **为什么不申请群权限？** 本插件是"一个人的遥控台"。不申请群权限，机器人**物理上收不到群消息**，单人边界由平台 scope 层保证，而不是只靠代码判断。
 
@@ -104,6 +111,22 @@ tail -f ~/.config/opencode/plugins/feishu.log   # 应看到「飞书长连接已
 
 ![建会话表单卡：目录、模型、权限一次填完](image/new.png)  ![会话列表卡片：翻页、进入/再开、新建](image/sessions.png)
 
+### 机器人菜单（输入框快捷按钮）
+
+![开发者后台配置机器人自定义菜单（悬浮菜单）：手机端预览里输入框上方固定 new / sessions 两个按钮，右侧为菜单项配置（响应动作=推送事件）](image/btns.png)
+
+按「一、飞书后台配置」第 6 步配好菜单后，机器人聊天窗口的**输入框上方**会常驻两个快捷按钮：
+
+| 按钮 | 等价命令 | 效果 |
+|---|---|---|
+| `new` | `/new` | 弹出建会话表单卡 |
+| `sessions` | `/sessions` | 弹出会话列表卡 |
+
+- 菜单项的事件 Key 需配置为 **`new` / `sessions`**（也兼容直接把 `/new`、`/sessions` 填成 Key）；
+- 点击事件走长连接（`application.bot.menu_v6`，零权限要求），插件把它合成一条**等价命令消息**处理——白名单、去重、命令矩阵与手输完全一致；未知 Key 静默忽略；
+- 菜单配置修改后需**重新发布版本**（官方说明：发版成功后约 5 分钟内生效）；
+- 首次使用菜单前，先给机器人发过至少一条消息（插件据消息记住单聊会话；正常使用必然满足）。
+
 ### 话题内（干活）
 
 一个话题 = 一个会话，发普通文本就是给 AI 下指令。
@@ -150,7 +173,7 @@ agent 反问时表单会变成飞书卡片，**点按钮或在话题里直接发
 | `logLevel` | `debug`\|`info`\|`warn`\|`error` | `info` | 日志级别 |
 | `logFile` | string \| boolean | — | `true` = 写 `<configDir>/plugins/feishu.log`，服务模式建议开启 |
 | `approvalTtlMs` | number | `600000` | 审批 token / 卡片有效期 |
-| `staleExecutionMs` | number | `300000` | 看门狗阈值（1–60 分钟） |
+| `staleExecutionMs` | number | `300000` | 看门狗阈值（0–60 分钟；**0 = 关闭看门狗**；待答表单 / 未决审批期间不判卡死） |
 | `gatewayLocation` | string | — | 只在该 location（及其子目录）启动网关；留空 = 任意 location 生效 |
 
 完整配置（含 `cardMaxTables`、`topicStatus*`、`resumeSummary*`、`keepalive*`、`gatewayMatchGraceMs` 等进阶项）见 [docs/advanced.md](./docs/advanced.md#完整配置项)。
@@ -160,11 +183,12 @@ agent 反问时表单会变成飞书卡片，**点按钮或在话题里直接发
 | 现象 | 处理 |
 |---|---|
 | 发消息没反应 | ① 应用是否**已发布**、可用范围是否勾了你；② 订阅是否选了**长连接**（不是 Webhook）；③ 是否开通 `im:message.p2p_msg:readonly` |
+| 图片 / 文件收不到（只显示占位 / “下载失败”） | 开通 `im:message:readonly`（权限管理 → API 权限，搜“获取消息中的资源文件”）→ **重新创建版本并发布**；具体失败原因看 `feishu.log` 的「附件下载失败」 |
 | 改了 `feishu.json` 不生效 | 确认路径，然后 `opencode reload` |
 | 插件完全没被加载 | npm 方式确认包名在 `plugins` 数组；目录方式确认 `plugins/<名>/index.js` 存在 |
 | 审批卡收不到 | 该会话不是从飞书发起的（无映射），插件按设计不接管 |
 | 点按钮提示凭证无效 | token 过期（默认 10 分钟）或点击者不在白名单 |
-| 会话像卡死、只排队 | 看门狗默认 5 分钟后自动中断；也可点「⏹ 强制停止」或发 `/stop` |
+| 会话像卡死、只排队 | 看门狗默认 5 分钟后自动中断（**待答表单 / 未决审批期间不中断**；`staleExecutionMs: 0` 可关闭）；也可点「⏹ 强制停止」或发 `/stop` |
 | 空闲约 1 小时后失联 | opencode 会回收空闲 location；内置保活默认开启会自动恢复，见 [docs/advanced.md](./docs/advanced.md#位置保活) |
 | 看不到插件日志 | 服务模式下 stderr 被丢弃，设 `logFile: true` |
 | 多个长连接 / 重复回复 | 设置 `gatewayLocation` 为常用工作目录，见 [docs/advanced.md](./docs/advanced.md#多实例与网关选举) |

package/dist/index.js

@@ -144008,7 +144008,7 @@ function resolveConfig2(raw, env = process.env, deps = {}) {
   const topicGuidance = asBoolean(merged.topicGuidance, true);
   const throttle2 = clamp4(asNumber(merged.streamThrottleMs, 400), 400, 6e4);
   const approvalTtlMs = clamp4(asNumber(merged.approvalTtlMs, 10 * 60 * 1e3), 3e4, 24 * 60 * 60 * 1e3);
-  const staleExecutionMs = clamp4(asNumber(merged.staleExecutionMs, 5 * 60 * 1e3), 6e4, 60 * 60 * 1e3);
+  const staleExecutionMs = clamp4(asNumber(merged.staleExecutionMs, 5 * 60 * 1e3), 0, 60 * 60 * 1e3);
   const maxResourcesShown = clamp4(asNumber(merged.maxResourcesShown, 8), 1, 50);
   const allowedRootsRaw = asStringArray(merged.allowedRoots);
   const allowedRootsCandidates = (allowedRootsRaw.length > 0 ? allowedRootsRaw : [...DEFAULT_ALLOWED_ROOTS]).filter(isAbsolute);
@@ -144507,6 +144507,18 @@ var TtlMap = class {
     }
     this.data.delete(key);
   }
+  /** 遍历未过期条目（惰性清理已过期项；用于按会话反查 pending 状态）。 */
+  entries() {
+    const out = [];
+    for (const [key, hit] of this.data) {
+      if (hit.expiresAt <= this.now()) {
+        this.delete(key);
+        continue;
+      }
+      out.push([key, hit.value]);
+    }
+    return out;
+  }
   clear() {
     for (const timer of this.timers.values()) clearTimeout(timer);
     this.timers.clear();
@@ -144767,6 +144779,17 @@ function parseIncomingMessage(data) {
     ...str(message.parent_id) ? { parentId: str(message.parent_id) } : {}
   };
 }
+function parseBotMenuEvent(data) {
+  if (!isRecord2(data)) return void 0;
+  const header = isRecord2(data.header) ? data.header : {};
+  const event = isRecord2(data.event) ? data.event : data;
+  const operator = isRecord2(event.operator) ? event.operator : {};
+  const operatorId = isRecord2(operator.operator_id) ? operator.operator_id : {};
+  const operatorOpenId = str(operatorId.open_id);
+  const eventKey = str(event.event_key);
+  if (!operatorOpenId || !eventKey) return void 0;
+  return { eventId: str(header.event_id) || str(data.event_id), eventKey, operatorOpenId };
+}
 function parseCardAction(data) {
   if (!isRecord2(data)) return void 0;
   const context3 = isRecord2(data.context) ? data.context : {};
@@ -144826,7 +144849,17 @@ function describeCardActionEvent(data) {
 // src/feishu/gateway.ts
 function startGateway(options2) {
   const { log: log2 } = options2;
-  const dispatcher = new EventDispatcher({}).register({
+  const larkLogger = (tag2) => ({
+    error: (...msg) => log2.error(tag2, { msg: safeArgs(msg) }),
+    warn: (...msg) => log2.warn(tag2, { msg: safeArgs(msg) }),
+    info: (...msg) => log2.debug(tag2, { msg: safeArgs(msg) }),
+    debug: (...msg) => log2.debug(tag2, { msg: safeArgs(msg) }),
+    trace: (...msg) => log2.debug(tag2, { msg: safeArgs(msg) })
+  });
+  const dispatcher = new EventDispatcher({
+    loggerLevel: options2.logLevel === "debug" ? LoggerLevel.debug : LoggerLevel.info,
+    logger: larkLogger("lark.dispatcher")
+  }).register({
     "im.message.receive_v1": (data) => {
       try {
         const message = parseIncomingMessage(data);
@@ -144858,6 +144891,27 @@ function startGateway(options2) {
         log2.error("\u5361\u7247\u56DE\u8C03\u5904\u7406\u5F02\u5E38", { error: errorMessage(err2) });
         return { toast: { type: "error", content: "\u5904\u7406\u5931\u8D25\uFF0C\u8BF7\u91CD\u8BD5" } };
       }
+    },
+    "application.bot.menu_v6": (data) => {
+      try {
+        const click = parseBotMenuEvent(data);
+        if (!click) {
+          log2.debug("\u83DC\u5355\u4E8B\u4EF6\u89E3\u6790\u5931\u8D25", {
+            shape: typeof data === "object" && data !== null ? Object.keys(data).slice(0, 20) : typeof data
+          });
+          return;
+        }
+        log2.debug("\u6536\u5230\u673A\u5668\u4EBA\u83DC\u5355\u70B9\u51FB", {
+          eventKey: click.eventKey,
+          operator: maskId(click.operatorOpenId)
+        });
+        if (!options2.onBotMenu) return;
+        void Promise.resolve(options2.onBotMenu(click)).catch((err2) => {
+          log2.error("\u83DC\u5355\u70B9\u51FB\u5904\u7406\u5931\u8D25", { eventKey: click.eventKey, error: errorMessage(err2) });
+        });
+      } catch (err2) {
+        log2.error("\u83DC\u5355 handler \u5F02\u5E38", { error: errorMessage(err2) });
+      }
     }
   });
   const loggerLevel = options2.logLevel === "debug" ? LoggerLevel.debug : LoggerLevel.warn;
@@ -144866,13 +144920,7 @@ function startGateway(options2) {
     appSecret: options2.appSecret,
     domain: options2.domain === "lark" ? Domain.Lark : Domain.Feishu,
     loggerLevel,
-    logger: {
-      error: (...msg) => log2.error("lark.ws", { msg: safeArgs(msg) }),
-      warn: (...msg) => log2.warn("lark.ws", { msg: safeArgs(msg) }),
-      info: (...msg) => log2.debug("lark.ws", { msg: safeArgs(msg) }),
-      debug: (...msg) => log2.debug("lark.ws", { msg: safeArgs(msg) }),
-      trace: (...msg) => log2.debug("lark.ws", { msg: safeArgs(msg) })
-    }
+    logger: larkLogger("lark.ws")
   });
   void wsClient.start({ eventDispatcher: dispatcher }).catch((err2) => {
     log2.error("\u98DE\u4E66\u957F\u8FDE\u63A5\u542F\u52A8\u5931\u8D25", { error: errorMessage(err2) });
@@ -145904,14 +145952,17 @@ var ExecutionTracker = class {
   /**
    * 返回「正在跑但超过 maxIdleMs 无任何活动」的 sessionID，并将其从运行态移除。
    * 用于插件层看门狗：事件丢失或交互工具（question/permission）永久挂起时兜底放开排队。
+   *
+   * `shouldSkip` 返回 true 的会话视为**合法等待**（如待答表单 / 未决审批）：
+   * 既不返回、也不移出运行态（避免在等待期被误杀，也避免丢追踪导致后续排队判定失真）。
    */
-  stale(maxIdleMs, now3 = Date.now()) {
+  stale(maxIdleMs, now3 = Date.now(), shouldSkip) {
     const out = [];
     for (const [sessionID, at] of this.running) {
-      if (now3 - at >= maxIdleMs) {
-        this.running.delete(sessionID);
-        out.push(sessionID);
-      }
+      if (now3 - at < maxIdleMs) continue;
+      if (shouldSkip?.(sessionID)) continue;
+      this.running.delete(sessionID);
+      out.push(sessionID);
     }
     return out;
   }
@@ -145919,6 +145970,41 @@ var ExecutionTracker = class {
     this.running.clear();
   }
 };
+var SessionParentLinks = class {
+  constructor(maxEntries = 2e3) {
+    this.maxEntries = maxEntries;
+  }
+  maxEntries;
+  parents = /* @__PURE__ */ new Map();
+  /** 登记/清理某会话的父链接（无 parentID = 顶级会话，清掉旧链接）。 */
+  remember(sessionID, parentID) {
+    if (!sessionID) return;
+    if (!parentID) {
+      this.parents.delete(sessionID);
+      return;
+    }
+    this.parents.delete(sessionID);
+    this.parents.set(sessionID, parentID);
+    while (this.parents.size > this.maxEntries) {
+      const oldest = this.parents.keys().next().value;
+      if (oldest === void 0) break;
+      this.parents.delete(oldest);
+    }
+  }
+  parentOf(sessionID) {
+    return this.parents.get(sessionID);
+  }
+  /** 沿父链逐级回调（含自身；防环 + 深度上限）。 */
+  walk(sessionID, visit) {
+    let current = sessionID;
+    const seen = /* @__PURE__ */ new Set();
+    for (let depth = 0; current && depth < 16 && !seen.has(current); depth += 1) {
+      seen.add(current);
+      visit(current);
+      current = this.parents.get(current);
+    }
+  }
+};
 
 // src/utils/throttle.ts
 function createThrottler(options2) {
@@ -146699,12 +146785,13 @@ function createRunController(deps) {
     hasActive(sessionID) {
       return sessions.get(sessionID)?.active !== void 0;
     },
-    staleQueued(maxIdleMs, now3 = Date.now()) {
+    staleQueued(maxIdleMs, now3 = Date.now(), shouldSkip) {
       const out = [];
       for (const [sessionID, runs] of sessions) {
         if (runs.active) continue;
         const first = runs.queued[0];
         if (!first || now3 - first.queuedAt < maxIdleMs) continue;
+        if (shouldSkip?.(sessionID)) continue;
         if (notifiedQueued.has(sessionID)) continue;
         notifiedQueued.add(sessionID);
         out.push(sessionID);
@@ -147215,6 +147302,13 @@ var FormRelay = class {
     this.forms.delete(id2);
     void this.finish(pending, "cancelled");
   }
+  /** 是否有尚未提交/取消的待答表单（看门狗判活：等表单属合法等待，不应判 stale）。 */
+  hasPendingFor(sessionID) {
+    for (const [, pending] of this.forms.entries()) {
+      if (pending.sessionID === sessionID && !pending.settled) return true;
+    }
+    return false;
+  }
   dispose() {
     this.disposed = true;
     this.forms.clear();
@@ -148978,6 +149072,13 @@ var ApprovalManager = class {
       parsed.decision === "reject" ? "\u5DF2\u62D2\u7EDD" : "\u5DF2\u5141\u8BB8"
     );
   }
+  /** 该会话是否有未决审批（看门狗判活：等审批属合法等待，不应判 stale）。 */
+  hasPendingFor(sessionID) {
+    for (const [, card] of this.cards.entries()) {
+      if (!card.resolved && card.input.sessionID === sessionID) return true;
+    }
+    return false;
+  }
   dispose() {
     this.seenRequests.clear();
     this.cards.clear();
@@ -150731,6 +150832,14 @@ async function routeEvent(event, deps) {
   const touched = event.data?.sessionID;
   if (typeof touched === "string") deps.touch(touched);
   switch (event.type) {
+    case "session.created": {
+      const data = event.data;
+      const childId = typeof data.sessionID === "string" && data.sessionID ? data.sessionID : typeof data.id === "string" && data.id ? data.id : "";
+      if (!childId) break;
+      const parent = typeof data.parentID === "string" && data.parentID ? data.parentID : typeof data.parentId === "string" && data.parentId ? data.parentId : void 0;
+      deps.onSessionCreated?.(childId, parent);
+      break;
+    }
     case "permission.asked":
       void deps.onPermissionAsked(event.data).catch((err2) => deps.log.warn("\u5904\u7406 permission.asked \u5931\u8D25", { error: errorMessage(err2) }));
       break;
@@ -151520,6 +151629,7 @@ async function start(ctx, config, log2, logSink) {
   await owner.load().catch((err2) => log2.warn("owner \u8BFB\u53D6\u5931\u8D25", { error: errorMessage(err2) }));
   const dedup = new MessageDedup(storage, log2);
   const executions = new ExecutionTracker();
+  const sessionLinks = new SessionParentLinks();
   const runs = createRunController({
     sender,
     log: log2,
@@ -151893,6 +152003,7 @@ async function start(ctx, config, log2, logSink) {
       log2.debug("\u5FFD\u7565\u975E\u767D\u540D\u5355\u7528\u6237", { sender: maskId(message.senderOpenId) });
       return;
     }
+    void rememberMenuChat(message.senderOpenId, message.chatId);
     if (!message.text) return;
     if (!await dedup.claim(message.messageId)) {
       log2.debug("\u5FFD\u7565\u91CD\u590D\u6D88\u606F", { messageId: message.messageId });
@@ -151955,6 +152066,66 @@ async function start(ctx, config, log2, logSink) {
     log2.info("\u8BDD\u9898\u65B0\u5EFA opencode \u4F1A\u8BDD", { sessionID: created.id, threadId: message.threadId, chatId: message.chatId });
     await runInSession(message, created.id, message.messageId);
   }
+  const MENU_COMMANDS = {
+    new: { cmd: "/new", label: "\u65B0\u5EFA\u4F1A\u8BDD" },
+    sessions: { cmd: "/sessions", label: "\u4F1A\u8BDD\u5217\u8868" },
+    // 容忍把命令原文直接当 event_key 配置。
+    "/new": { cmd: "/new", label: "\u65B0\u5EFA\u4F1A\u8BDD" },
+    "/sessions": { cmd: "/sessions", label: "\u4F1A\u8BDD\u5217\u8868" }
+  };
+  const menuChatCache = /* @__PURE__ */ new Map();
+  const menuChatKey = (openId) => `feishu:v2:menu-chat:${openId}`;
+  async function rememberMenuChat(openId, chatId) {
+    if (!openId || !chatId || menuChatCache.get(openId) === chatId) return;
+    menuChatCache.set(openId, chatId);
+    try {
+      await ctx.storage.set(menuChatKey(openId), chatId);
+    } catch (err2) {
+      log2.debug("\u83DC\u5355 chatId \u6301\u4E45\u5316\u5931\u8D25", { error: errorMessage(err2) });
+    }
+  }
+  async function resolveMenuChat(openId) {
+    const cached3 = menuChatCache.get(openId);
+    if (cached3) return cached3;
+    try {
+      const stored = await ctx.storage.get(menuChatKey(openId));
+      if (typeof stored === "string" && stored) {
+        menuChatCache.set(openId, stored);
+        return stored;
+      }
+    } catch {
+    }
+    return void 0;
+  }
+  async function handleBotMenu(click) {
+    if (!await owner.admit(click.operatorOpenId)) {
+      log2.debug("\u5FFD\u7565\u975E\u767D\u540D\u5355\u7528\u6237\u7684\u83DC\u5355\u70B9\u51FB", { operator: maskId(click.operatorOpenId) });
+      return;
+    }
+    const entry = MENU_COMMANDS[click.eventKey.trim()];
+    if (!entry) {
+      log2.debug("\u672A\u77E5\u83DC\u5355 event_key\uFF0C\u5FFD\u7565", { eventKey: click.eventKey });
+      return;
+    }
+    const chatId = await resolveMenuChat(click.operatorOpenId);
+    if (!chatId) {
+      log2.warn("\u83DC\u5355\u70B9\u51FB\u7F3A\u5C11\u5355\u804A\u4E0A\u4E0B\u6587\uFF1A\u8BF7\u5148\u7ED9\u673A\u5668\u4EBA\u53D1\u4E00\u6761\u6D88\u606F\u540E\u518D\u4F7F\u7528\u83DC\u5355", {
+        eventKey: click.eventKey
+      });
+      return;
+    }
+    const synthetic = {
+      eventId: click.eventId,
+      messageId: `menu_${click.eventId || Date.now()}`,
+      chatId,
+      chatType: "p2p",
+      messageType: "text",
+      text: entry.cmd,
+      senderOpenId: click.operatorOpenId
+    };
+    log2.info("\u673A\u5668\u4EBA\u83DC\u5355\u70B9\u51FB \u2192 \u6267\u884C\u547D\u4EE4", { eventKey: click.eventKey, cmd: entry.cmd, label: entry.label });
+    await handleMessage(synthetic);
+  }
   async function runInActiveSession(message) {
     let active = await sessionMap.getActive(message.chatId);
     if (!active) {
@@ -152023,6 +152194,7 @@ ${downloadedAttachmentPrompt(message.attachment, outcome)}`;
     log: log2,
     logLevel: config.logLevel,
     onMessage: (message) => handleMessage(message),
+    onBotMenu: (click) => handleBotMenu(click),
     onCardAction: (action) => routeCardAction(action, {
       log: log2,
       handleForm: (a) => formRelay.handleCardAction(a),
@@ -152063,9 +152235,13 @@ ${downloadedAttachmentPrompt(message.attachment, outcome)}`;
   })();
   const eventDeps = {
     log: log2,
-    touch: (sessionID) => executions.touch(sessionID),
+    touch: (sessionID) => sessionLinks.walk(sessionID, (id2) => executions.touch(id2)),
     markStarted: (sessionID) => executions.markStarted(sessionID),
     markEnded: (sessionID) => executions.markEnded(sessionID),
+    onSessionCreated: (sessionID, parentID) => {
+      sessionLinks.remember(sessionID, parentID);
+      log2.debug("session.created \u7236\u5B50\u767B\u8BB0", { sessionID, parentID: parentID ?? null });
+    },
     applyRun: (sessionID, event) => runs.apply(sessionID, event),
     onPermissionAsked: (data) => approvals.onAsked(data),
     onPermissionReplied: (data) => approvals.onReplied(data),
@@ -152088,13 +152264,16 @@ ${downloadedAttachmentPrompt(message.attachment, outcome)}`;
     }
     await sender.sendText(link2.chatId, text);
   }
-  const stopWatchdog = startWatchdog({
+  const hasPendingInteraction = (sessionID) => approvals.hasPendingFor(sessionID) || formRelay.hasPendingFor(sessionID);
+  const stopWatchdog = config.staleExecutionMs > 0 ? startWatchdog({
     log: log2,
     staleExecutionMs: config.staleExecutionMs,
-    staleExecutions: () => executions.stale(config.staleExecutionMs),
-    staleQueued: () => runs.staleQueued(config.staleExecutionMs),
+    staleExecutions: () => executions.stale(config.staleExecutionMs, Date.now(), hasPendingInteraction),
+    staleQueued: () => runs.staleQueued(config.staleExecutionMs, Date.now(), hasPendingInteraction),
     recover: (sessionID, reason) => recovery.recover(sessionID, reason)
-  });
+  }) : () => {
+    log2.info("\u770B\u95E8\u72D7\u5DF2\u5173\u95ED\uFF08staleExecutionMs=0\uFF09");
+  };
   async function notifyStuck(sessionID, reason, ok) {
     const link2 = await sessionMap.resolveBySession(sessionID);
     if (!link2) return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-feishu-plugin",
-  "version": "0.2.10",
+  "version": "0.2.12",
   "description": "Feishu/Lark plugin for OpenCode V2 — single-user topics as sessions, in-card permission approvals, streaming cards. Minimal permissions, no public endpoint.",
   "type": "module",
   "main": "index.js",