agent-loft 0.2.19 → 0.2.20

package/README.md

@@ -37,6 +37,7 @@ Logo 就是这个意思：一大两小几颗星（多个 agent）站在同一张
   - 侧栏分「最近」和「项目」两组：Web 会话按工作目录归类，飞书机器人各占一行并带飞书图标；分叉出来的对话挂在主对话下面，用虚线连起来；分组可折叠，宽度可拖动，双击会话重命名，名字太长时悬停滚动显示。
   - 侧栏底部显示 Claude / Codex 的订阅额度（5 小时 / 7 天窗口，悬停看重置时间）；空闲时按设置的间隔自动刷新（默认 10 分钟），跑完一轮后也会刷新。
 - **跨渠道同步**：飞书里的会话在 Web 上也能打开，接着聊。同一个授权请求同时出现在飞书卡片和网页上，哪边先点算哪边，另一边自动变成「已处理」。
+- **在飞书里接着 Web 会话**：飞书里发 `/web` 列出最近的 Web 会话，点「接上」后这个飞书聊天说的话、发的命令都进那条会话，它的回复、授权和提问也发到飞书，Web 上说的话同步过来；发 `/detach` 回到这个聊天自己的会话。也可以在 Web 侧栏右键会话 →「在飞书继续…」，选一个机器人聊过的飞书聊天直接接上（只有一个聊天时不用选）。Web 会话被删除时飞书那边自动退回来。
 - **设置都在网页上**：工作目录、各 agent 的默认模型和思考程度、Codex 沙箱、飞书机器人、配对批准、Claude 的「总是允许」名单、登录设备管理。
 
 ## 安装
@@ -85,7 +86,7 @@ agent-loft service install
 | `agent-loft service install \| uninstall \| restart \| status` | 开机自启 |
 | `agent-loft doctor` | 体检 |
 
-聊天里的命令（飞书和 Web 通用；Web 输入框打 `/` 会弹出命令补全，飞书里打 `/` 会弹出机器人的指令面板（agent-loft 自动注册，约 5～8 分钟生效；只发一个 `/` 也会回一张可点击的命令卡片），顺序和显示项在 设置 → 命令 里调整）：`/new` `/fork` `/sessions [all]` `/resume <id>` `/model [名称]` `/effort <程度>` `/agent [名称]`（或者直接发 `/claude`、`/codex`）`/stop` `/cd <目录>` `/pwd` `/status` `/approve <id> allow-once|allow-always|allow-session|deny` `/help`
+聊天里的命令（飞书和 Web 通用；Web 输入框打 `/` 会弹出命令补全，飞书里打 `/` 会弹出机器人的指令面板（agent-loft 自动注册，约 5～8 分钟生效；只发一个 `/` 也会回一张可点击的命令卡片），顺序和显示项在 设置 → 命令 里调整）：`/new` `/fork` `/sessions [all]` `/resume <id>` `/model [名称]` `/effort <程度>` `/agent [名称]`（或者直接发 `/claude`、`/codex`）`/stop` `/cd <目录>` `/pwd` `/status` `/approve <id> allow-once|allow-always|allow-session|deny` `/help`；只在飞书里有的：`/web` `/detach`
 
 自定义命令：设置 → 命令 → 「添加命令」，填命令名、说明和一段提示词，之后发 `/命令名 参数` 就会把这段提示词发给 agent（提示词里的 `$ARGUMENTS` 换成参数，没写就把参数接在后面）。按 agent 分开存，可以编辑、删除，也会同步到飞书指令面板。
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-loft",
-  "version": "0.2.19",
+  "version": "0.2.20",
   "type": "module",
   "description": "多个 agent 的工作台：把本机 Claude Code / Codex 放到一处统一管理，用飞书和 Web 页面随时驱动——会话、审批、模型切换都共用",
   "keywords": [

package/src/channels/feishu/attach.ts

@@ -0,0 +1,48 @@
+// 飞书聊天「挂到」Web 会话上：挂上之后，这个飞书聊天说的话、发的命令都送进那条 Web 会话，
+// 那条会话的回复、授权、提问也画到这个飞书聊天里。发 /detach 回到聊天自己的会话。
+//
+// 只是一层路由，会话本身（agent 进程、历史、审批）一点不动。按飞书会话键记：
+//   feishu:<机器人id>:<chatId>[:<话题id>] → web:<…>
+// 一条 Web 会话可以同时被好几个飞书聊天挂着。要落盘：重启之后飞书那边还接着它聊。
+import path from "node:path";
+import { dataDir, readJson, writeJsonAtomic } from "../../home.js";
+
+type Shape = Record<string, { target: string; at: number }>;
+
+const storePath = path.join(dataDir, "feishu-attach.json");
+let cache: Shape | null = null;
+
+function load(): Shape {
+  cache ??= readJson<Shape>(storePath, {});
+  return cache;
+}
+
+function save(): void {
+  writeJsonAtomic(storePath, cache ?? {});
+}
+
+/** 这个飞书会话挂着的 Web 会话键 */
+export function attachedTarget(feishuKey: string): string | undefined {
+  return load()[feishuKey]?.target;
+}
+
+export function attach(feishuKey: string, target: string): void {
+  load()[feishuKey] = { target, at: Date.now() };
+  save();
+}
+
+/** 返回原来挂着的目标（没挂着返回 undefined） */
+export function detach(feishuKey: string): string | undefined {
+  const prev = load()[feishuKey]?.target;
+  if (prev === undefined) return undefined;
+  delete load()[feishuKey];
+  save();
+  return prev;
+}
+
+/** 挂在 target 上的所有飞书会话键（可选只要某个前缀的，也就是某个机器人的） */
+export function watchersOf(target: string, prefix = ""): string[] {
+  return Object.entries(load())
+    .filter(([k, v]) => v.target === target && k.startsWith(prefix))
+    .map(([k]) => k);
+}

package/src/channels/feishu/bot.ts

@@ -13,15 +13,17 @@ import { interactions, type Interaction } from "../../core/interactions.js";
 import { parseCommand } from "../../core/commands.js";
 import { Dedup } from "../../core/dedup.js";
 import { isPaired, requestPairing } from "../../core/pairing.js";
-import { getConversation, updateConversation } from "../../core/store.js";
+import { getConversation, listConversations, updateConversation } from "../../core/store.js";
 import { adoptFile, KIND_LABEL } from "../../core/uploads.js";
 import type { SavedAttachment } from "../../core/types.js";
 import { FeishuClient } from "./client.js";
 import { SlashSync } from "./slash-sync.js";
 import type { CommandEntry } from "../../core/command-catalog.js";
+import { attach, attachedTarget, detach, watchersOf } from "./attach.js";
 import {
   agentPickerCard,
   approvalCard,
+  attachedCard,
   commandListCard,
   modelPickerCard,
   progressCard,
@@ -29,6 +31,8 @@ import {
   replyCard,
   sessionListCard,
   settledCard,
+  webListCard,
+  type WebConvEntry,
 } from "./cards.js";
 import { decodeEnvelope, DECODE_FAILURE_TEXT, type CardCtx, type CardEnvelope } from "./envelope.js";
 import { parseMessage, unsupportedTypeLabel, type AttachmentRef } from "./message.js";
@@ -41,15 +45,27 @@ type CardResponse = {
 
 export type BotStatus = { state: string; since: number; error?: string };
 
+/** 只在飞书里认的命令：挂到 Web 会话上 / 退回来。整条消息只有命令才算 */
+function feishuCommandOf(text: string): "web" | "detach" | null {
+  const t = text.trim().replace(/^／/, "/").toLowerCase();
+  if (t === "/web") return "web";
+  if (t === "/detach") return "detach";
+  return null;
+}
+
+/** 一条会话画到某个飞书聊天里：流式卡片、操作人都按这一对记 */
+const pairKey = (key: string, chatId: string) => `${key}\n${chatId}`;
+
 export class FeishuBot {
   readonly client: FeishuClient;
   private ws: Lark.WSClient | null = null;
   private dedup = new Dedup();
+  /** (会话键, 聊天) → 这一轮的输出编排。一条 Web 会话可能同时画在好几个飞书聊天里 */
   private streams = new Map<string, TurnStream>();
   private typing = new Map<string, { messageId: string; reactionId: string }>();
-  /** 交互 id → 飞书卡片的 message_id */
-  private cards = new Map<string, string>();
-  /** 会话键 → 最后一个在飞书上说话的人。卡片默认只让他点 */
+  /** 交互 id → 发出去的飞书卡片（可能发在好几个聊天里） */
+  private cards = new Map<string, { chatId: string; messageId: string }[]>();
+  /** (会话键, 聊天) → 最后一个在这个聊天里说话的人。卡片默认只让他点 */
   private operators = new Map<string, string>();
   /** 附件要先下载才能送，紧跟着的文字不能抢在前面 —— 每条会话一条串行链 */
   private chains = new Map<string, Promise<void>>();
@@ -77,7 +93,7 @@ export class FeishuBot {
     const out: CommandEntry[] = [];
     for (const agent of agents) {
       if (!hub.driver(agent)) continue;
-      out.push(...(await hub.commandCatalog(agent, { allowedAgents: this.cfg.agents })));
+      out.push(...(await hub.commandCatalog(agent, { allowedAgents: this.cfg.agents, channel: "feishu" })));
     }
     return out;
   }
@@ -112,6 +128,159 @@ export class FeishuBot {
     return this.cfg.agents.filter((a) => enabled.has(a));
   }
 
+  /** 某条会话能切到哪些 agent：自己的会话按机器人的勾选；接着的 Web 会话和 Web 上一样，启用的都行 */
+  private allowedFor(key: string): string[] {
+    return this.mine(key) ? this.allowedAgents() : hub.enabledAgents().map((d) => d.id);
+  }
+
+  // ---------- 接着 Web 会话 ----------
+
+  /** 飞书会话键挂着的 Web 会话（还在、没被删的）；没挂着返回 undefined */
+  attachedWeb(feishuKey: string): string | undefined {
+    const target = attachedTarget(feishuKey);
+    if (!target) return undefined;
+    const conv = getConversation(target);
+    return conv && !conv.hidden ? target : undefined;
+  }
+
+  /** 这条会话的事件该画到哪些飞书聊天里：自己的那个聊天，加上挂着它的聊天 */
+  chatsOf(key: string): string[] {
+    const out = new Set<string>();
+    if (this.mine(key)) out.add(this.chatIdOf(key));
+    for (const k of watchersOf(key, this.prefix)) out.add(this.chatIdOf(k));
+    return [...out];
+  }
+
+  /** 这个聊天能不能操作这条会话（卡片按钮里带的会话键） */
+  private controls(key: string, chatId: string | undefined): boolean {
+    if (!chatId) return false;
+    if (this.mine(key)) return this.chatIdOf(key) === chatId;
+    return watchersOf(key, this.prefix).some((k) => this.chatIdOf(k) === chatId);
+  }
+
+  private webEntry(key: string): WebConvEntry | undefined {
+    const info = hub.info(key);
+    if (!info) return undefined;
+    return {
+      key,
+      title: info.title || "（未命名）",
+      agentLabel: hub.label(info.agent),
+      cwd: info.cwd,
+      busy: info.busy,
+      activeAt: info.activeAt,
+    };
+  }
+
+  /** 这个机器人聊过的飞书聊天 → 最近活跃时间 */
+  private chatActivity(): Map<string, number> {
+    const latest = new Map<string, number>();
+    for (const c of listConversations()) {
+      if (c.channel !== "feishu" || c.channelId !== this.cfg.id) continue;
+      const chatId = this.chatIdOf(c.key);
+      latest.set(chatId, Math.max(latest.get(chatId) ?? 0, c.activeAt));
+    }
+    return latest;
+  }
+
+  hasChat(chatId: string): boolean {
+    return this.chatActivity().has(chatId);
+  }
+
+  /** 这个机器人聊过的飞书聊天（Web 上选「在哪继续」用），按最近活跃排 */
+  async knownChats(): Promise<{ chatId: string; label: string; activeAt: number; attached?: string }[]> {
+    const chats = [...this.chatActivity()].sort((a, b) => b[1] - a[1]).slice(0, 20);
+    return Promise.all(
+      chats.map(async ([chatId, activeAt]) => {
+        const info = await this.client.chatInfo(chatId);
+        const label =
+          info?.mode === "p2p" ? "私聊" : info?.name ? info.name : `聊天 ${chatId.slice(-6)}`;
+        const attached = this.attachedWeb(this.keyOf(chatId));
+        return { chatId, label, activeAt, ...(attached ? { attached } : {}) };
+      }),
+    );
+  }
+
+  /**
+   * 把飞书会话 feishuKey 挂到 Web 会话 webKey 上，并在聊天里发一张「已接上」卡（带最近几句）。
+   * 返回给人看的结果；挂不上时抛错。
+   */
+  async attachTo(feishuKey: string, webKey: string, operatorOpenId?: string): Promise<string> {
+    const conv = getConversation(webKey);
+    if (!conv || conv.channel !== "web" || conv.hidden) throw new Error("这条 Web 会话已不存在");
+    const chatId = this.chatIdOf(feishuKey);
+    // 本聊天自己的会话也得有：之后 /detach 回来、侧栏里显示机器人都要它
+    const allowed = this.allowedAgents();
+    if (allowed.length > 0) {
+      hub.ensure({
+        key: feishuKey,
+        channel: "feishu",
+        channelId: this.cfg.id,
+        defaultAgent: allowed.includes(this.cfg.defaultAgent) ? this.cfg.defaultAgent : allowed[0]!,
+      });
+    }
+    const already = attachedTarget(feishuKey) === webKey;
+    attach(feishuKey, webKey);
+    if (operatorOpenId) this.operators.set(pairKey(webKey, chatId), operatorOpenId.trim().toLowerCase());
+    const entry = this.webEntry(webKey)!;
+    console.log(`${this.tag} ${feishuKey} 接上 Web 会话 ${webKey}`);
+    // 最近几句：读历史可能要一会儿，读不到也不影响接上
+    const history = await hub.history(webKey).catch(() => []);
+    const recent = history
+      .filter((m) => m.text.trim())
+      .slice(-4)
+      .map((m) => ({ role: m.role, text: m.text }));
+    await this.client.sendCard(
+      chatId,
+      attachedCard({ conv: entry, recent, sessionKey: feishuKey, ctx: this.cardCtx(feishuKey, chatId) }),
+    );
+    // 已经挂着的授权 / 提问：这个聊天也要能点
+    for (const i of interactions.listPending(webKey)) {
+      if (!this.cards.get(i.id)?.some((c) => c.chatId === chatId)) await this.showInteractionIn(i, chatId);
+    }
+    return already ? `已经接着「${entry.title}」了` : `已在飞书接上「${entry.title}」`;
+  }
+
+  /** 不再接着 Web 会话。返回给人看的结果 */
+  detachFrom(feishuKey: string): string {
+    const prev = detach(feishuKey);
+    if (!prev) return "这个聊天没有接着 Web 会话，本来就在用自己的会话。";
+    console.log(`${this.tag} ${feishuKey} 不再接着 Web 会话 ${prev}`);
+    const title = getConversation(prev)?.title;
+    return `已回到这个聊天自己的会话${title ? `，不再接着「${title}」` : ""}。之后发 \`/web\` 可以再接上。`;
+  }
+
+  /** 发 /web：列最近的 Web 会话 */
+  private async sendWebList(feishuKey: string, chatId: string): Promise<void> {
+    const current = this.attachedWeb(feishuKey);
+    const convs = hub
+      .list()
+      .filter((c) => c.channel === "web" && !c.hidden)
+      .slice(0, 10)
+      .map((c) => this.webEntry(c.key)!)
+      .filter(Boolean);
+    await this.client.sendCard(
+      chatId,
+      webListCard({
+        convs,
+        ...(current ? { current } : {}),
+        sessionKey: feishuKey,
+        ctx: this.cardCtx(feishuKey, chatId),
+      }),
+    );
+  }
+
+  /** 挂着的 Web 会话被删了 / 没了：自动退回来，告诉一声 */
+  private dropStale(feishuKey: string): boolean {
+    const target = attachedTarget(feishuKey);
+    if (!target || this.attachedWeb(feishuKey)) return false;
+    detach(feishuKey);
+    void this.client.sendCard(
+      this.chatIdOf(feishuKey),
+      replyCard("之前接着的 Web 会话已经被删除，已回到这个聊天自己的会话。"),
+    );
+    return true;
+  }
+
   isAuthorized(openId: string | undefined): boolean {
     if (!openId) return false;
     const id = openId.trim().toLowerCase();
@@ -123,14 +292,20 @@ export class FeishuBot {
   start(): void {
     this.stopped = false;
     const onEvent = (env: EventEnvelope) => {
-      if (this.mine(env.key)) this.render(env);
+      // 流式片段飞书不画（回复走整段），先挡掉，免得每个片段都去翻一遍挂载表
+      if (env.ev.type === "delta") return;
+      if (env.ev.type === "meta") {
+        for (const k of watchersOf(env.key, this.prefix)) this.dropStale(k);
+        return;
+      }
+      for (const chatId of this.chatsOf(env.key)) this.render(env, chatId);
     };
     hub.on("event", onEvent);
     this.offs.push(() => hub.off("event", onEvent));
 
-    const onCreated = (i: Interaction) => this.mine(i.convKey) && void this.showInteraction(i);
-    const onUpdated = (i: Interaction) => this.mine(i.convKey) && void this.refreshInteraction(i);
-    const onSettled = (i: Interaction) => this.mine(i.convKey) && void this.refreshInteraction(i);
+    const onCreated = (i: Interaction) => void this.showInteraction(i);
+    const onUpdated = (i: Interaction) => this.cards.has(i.id) && void this.refreshInteraction(i);
+    const onSettled = (i: Interaction) => this.cards.has(i.id) && void this.refreshInteraction(i);
     interactions.on("created", onCreated);
     interactions.on("updated", onUpdated);
     interactions.on("settled", onSettled);
@@ -250,10 +425,10 @@ export class FeishuBot {
 
   // ---------- 渲染 hub 事件 ----------
 
-  private stream(key: string): TurnStream {
-    let stream = this.streams.get(key);
+  private stream(key: string, chatId: string): TurnStream {
+    const id = pairKey(key, chatId);
+    let stream = this.streams.get(id);
     if (stream) return stream;
-    const chatId = this.chatIdOf(key);
     stream = new TurnStream({
       sendCard: (card) => this.client.sendCard(chatId, card),
       updateCard: (messageId, card) => this.client.updateCard(messageId, card),
@@ -261,35 +436,38 @@ export class FeishuBot {
       sendReply: (text) => this.client.sendCard(chatId, replyCard(text)),
       onError: (err) => console.error(`${this.tag} 卡片更新失败:`, err),
     });
-    this.streams.set(key, stream);
+    this.streams.set(id, stream);
     return stream;
   }
 
-  private render(env: EventEnvelope): void {
+  private render(env: EventEnvelope, chatId: string): void {
     const { key, ev } = env;
-    const chatId = this.chatIdOf(key);
     switch (ev.type) {
-      case "user":
-        // 别的渠道（Web）说的话，同步一句过来，不然飞书这边看着没头没尾
-        if (ev.origin.channel !== "feishu" || ev.origin.channelId !== this.cfg.id) {
+      case "user": {
+        // 别处（Web、别的飞书聊天）说的话，同步一句过来，不然这边看着没头没尾
+        const o = ev.origin;
+        const here = o.channel === "feishu" && o.channelId === this.cfg.id && (!o.chatId || o.chatId === chatId);
+        if (!here) {
           const files = ev.attachments.length ? `\n\n📎 ${ev.attachments.join("、")}` : "";
-          void this.client.sendCard(chatId, replyCard(`💻 **${ev.origin.name ?? "Web"}**：${ev.text}${files}`));
+          const icon = o.channel === "web" ? "💻" : "💬";
+          void this.client.sendCard(chatId, replyCard(`${icon} **${o.name ?? "Web"}**：${ev.text}${files}`));
         }
         return;
+      }
       case "step":
-        this.stream(key).addStep(ev.text);
+        this.stream(key, chatId).addStep(ev.text);
         return;
       case "text":
-        this.stream(key).addText(ev.text);
+        this.stream(key, chatId).addText(ev.text);
         return;
       case "result": {
-        const stream = this.stream(key);
+        const stream = this.stream(key, chatId);
         stream.finish(ev.text, ev.footer);
         void stream.drain().then(() => this.clearTyping(key));
         return;
       }
       case "error": {
-        const stream = this.stream(key);
+        const stream = this.stream(key, chatId);
         stream.finish("", "出错");
         void stream.drain().then(() => {
           this.clearTyping(key);
@@ -305,38 +483,45 @@ export class FeishuBot {
     }
   }
 
-  private cardCtx(key: string): CardCtx {
-    const operator = this.operators.get(key);
+  private cardCtx(key: string, chatId: string): CardCtx {
+    const operator = this.operators.get(pairKey(key, chatId));
     return {
       ...(operator ? { operatorOpenId: operator } : {}),
-      chatId: this.chatIdOf(key),
+      chatId,
       expiresAt: Date.now() + config().approvalTimeoutMs,
     };
   }
 
-  private interactionCard(i: Interaction, ctx?: CardCtx) {
+  private interactionCard(i: Interaction, chatId: string, ctx?: CardCtx) {
     if (i.settled) return settledCard(i);
-    const c = ctx ?? this.cardCtx(i.convKey);
+    const c = ctx ?? this.cardCtx(i.convKey, chatId);
     if (i.spec.kind === "approval") return approvalCard(i, c);
     return questionCard(i, c, hub.label(getConversation(i.convKey)?.agent ?? ""));
   }
 
   private async showInteraction(i: Interaction): Promise<void> {
-    const messageId = await this.client.sendCard(this.chatIdOf(i.convKey), this.interactionCard(i));
+    for (const chatId of this.chatsOf(i.convKey)) await this.showInteractionIn(i, chatId);
+  }
+
+  private async showInteractionIn(i: Interaction, chatId: string): Promise<void> {
+    const messageId = await this.client.sendCard(chatId, this.interactionCard(i, chatId));
     if (!messageId) return;
-    this.cards.set(i.id, messageId);
+    const list = this.cards.get(i.id) ?? [];
+    list.push({ chatId, messageId });
+    this.cards.set(i.id, list);
     // 发卡的空当里可能已经在 Web 上处理掉了
     const latest = interactions.get(i.id);
     if (latest?.settled) await this.refreshInteraction(latest);
   }
 
   private async refreshInteraction(i: Interaction): Promise<void> {
-    const messageId = this.cards.get(i.id);
-    if (!messageId) return;
+    const list = this.cards.get(i.id);
+    if (!list) return;
     if (i.settled) this.cards.delete(i.id);
-    await this.client.updateCard(messageId, this.interactionCard(i));
+    await Promise.all(list.map((c) => this.client.updateCard(c.messageId, this.interactionCard(i, c.chatId))));
   }
 
+
   // ---------- 正在输入 ----------
 
   private clearTyping(key: string): void {
@@ -400,24 +585,36 @@ export class FeishuBot {
       return;
     }
 
-    const key = this.keyOf(chatId, message.thread_id);
+    const ownKey = this.keyOf(chatId, message.thread_id);
     const conv = hub.ensure({
-      key,
+      key: ownKey,
       channel: "feishu",
       channelId: this.cfg.id,
       defaultAgent: allowed.includes(this.cfg.defaultAgent) ? this.cfg.defaultAgent : allowed[0]!,
     });
     // 配置改过（这个机器人不再能用当前 agent）：退回默认
     if (!allowed.includes(conv.agent)) {
-      updateConversation(key, { agent: allowed.includes(this.cfg.defaultAgent) ? this.cfg.defaultAgent : allowed[0]! });
+      updateConversation(ownKey, { agent: allowed.includes(this.cfg.defaultAgent) ? this.cfg.defaultAgent : allowed[0]! });
     }
-    this.operators.set(key, openId!.trim().toLowerCase());
+    const operator = openId!.trim().toLowerCase();
+    this.operators.set(pairKey(ownKey, chatId), operator);
+
+    const feishuCmd = attachments.length > 0 ? null : feishuCommandOf(text);
+    if (feishuCmd) {
+      await this.runFeishuCommand(feishuCmd, ownKey, chatId);
+      return;
+    }
+
+    // 挂着 Web 会话：说的话、命令都送进那条会话
+    this.dropStale(ownKey);
+    const key = this.attachedWeb(ownKey) ?? ownKey;
+    this.operators.set(pairKey(key, chatId), operator);
 
     const command = attachments.length > 0 ? ({ kind: "chat", text } as const) : parseCommand(text);
     if (command.kind !== "chat") {
       try {
-        const reply = await hub.command(key, command, { allowedAgents: allowed, by: "飞书命令" });
-        await this.renderReply(key, reply);
+        const reply = await hub.command(key, command, { allowedAgents: this.allowedFor(key), by: "飞书命令", channel: "feishu" });
+        await this.renderReply(key, chatId, reply);
       } catch (err) {
         await this.client.sendText(chatId, `出错了：${err instanceof Error ? err.message : String(err)}`);
       }
@@ -425,7 +622,7 @@ export class FeishuBot {
     }
 
     void this.markTyping(key, message.message_id);
-    const origin = { channel: "feishu", channelId: this.cfg.id, name: "飞书" };
+    const origin = { channel: "feishu", channelId: this.cfg.id, name: "飞书", chatId };
     // 收到消息这一刻的代次：下载附件期间点了 /stop、或者 /cd /new 换了会话，这条就作废
     const gen = hub.generation(key);
     this.enqueue(key, async () => {
@@ -476,9 +673,18 @@ export class FeishuBot {
     return { saved, failed };
   }
 
-  private async renderReply(key: string, reply: CommandReply): Promise<void> {
-    const chatId = this.chatIdOf(key);
-    const ctx = this.cardCtx(key);
+  /** /web、/detach：只认飞书会话自己的键，不管现在挂没挂着 */
+  private async runFeishuCommand(cmd: "web" | "detach", ownKey: string, chatId: string): Promise<void> {
+    try {
+      if (cmd === "web") await this.sendWebList(ownKey, chatId);
+      else await this.client.sendCard(chatId, replyCard(this.detachFrom(ownKey)));
+    } catch (err) {
+      await this.client.sendText(chatId, `出错了：${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+
+  private async renderReply(key: string, chatId: string, reply: CommandReply): Promise<void> {
+    const ctx = this.cardCtx(key, chatId);
     switch (reply.type) {
       case "text":
         await this.client.sendCard(chatId, replyCard(reply.text));
@@ -602,7 +808,7 @@ export class FeishuBot {
         }
         return {
           toast: { type: "info", content: "已勾选" },
-          card: { type: "raw", data: this.interactionCard(state.interaction) },
+          card: { type: "raw", data: this.interactionCard(state.interaction, chatId ?? "") },
         };
       }
       case "ask-submit": {
@@ -619,19 +825,39 @@ export class FeishuBot {
         return { toast: { type: "info", content: "已跳过" }, card: { type: "raw", data: settledCard(result) } };
       }
       case "resume":
-        this.background(envelope.k, () => hub.resume(envelope.k, envelope.s, envelope.c));
-        return { toast: { type: "info", content: "正在恢复该会话…" } };
+        return this.background(envelope.k, chatId, "正在恢复该会话…", () => hub.resume(envelope.k, envelope.s, envelope.c));
       case "model":
-        this.background(envelope.k, () => hub.setModel(envelope.k, envelope.m));
-        return { toast: { type: "success", content: `正在切换到 ${envelope.m}` } };
+        return this.background(envelope.k, chatId, `正在切换到 ${envelope.m}`, () => hub.setModel(envelope.k, envelope.m));
       case "effort":
-        this.background(envelope.k, () => hub.setEffort(envelope.k, envelope.f));
-        return { toast: { type: "success", content: `思考程度设为 ${envelope.f}` } };
+        return this.background(envelope.k, chatId, `思考程度设为 ${envelope.f}`, () => hub.setEffort(envelope.k, envelope.f));
       case "agent":
-        this.background(envelope.k, () => hub.setAgent(envelope.k, envelope.g, this.allowedAgents()));
-        return { toast: { type: "success", content: `正在切换到 ${hub.label(envelope.g)}` } };
+        return this.background(envelope.k, chatId, `正在切换到 ${hub.label(envelope.g)}`, () =>
+          hub.setAgent(envelope.k, envelope.g, this.allowedFor(envelope.k)),
+        );
       case "cmd":
-        return this.runCardCommand(envelope.k, `/${envelope.c}`);
+        return this.runCardCommand(envelope.k, chatId, operatorOpenId, `/${envelope.c}`);
+      case "attach": {
+        // k 必须是这个聊天自己的会话：卡片被转发到别处点，挂的也只能是那个聊天
+        if (!this.mine(envelope.k) || this.chatIdOf(envelope.k) !== chatId) {
+          return { toast: { type: "error", content: DECODE_FAILURE_TEXT.wrong_conversation } };
+        }
+        const conv = getConversation(envelope.w);
+        if (!conv || conv.channel !== "web" || conv.hidden) {
+          return { toast: { type: "error", content: "这条 Web 会话已不存在，请重新发 /web。" } };
+        }
+        void this.attachTo(envelope.k, envelope.w, operatorOpenId).catch((err) =>
+          this.client.sendText(chatId!, `出错了：${err instanceof Error ? err.message : String(err)}`),
+        );
+        return { toast: { type: "success", content: `正在接上「${conv.title ?? "Web 会话"}」` } };
+      }
+      case "detach": {
+        if (!this.mine(envelope.k) || this.chatIdOf(envelope.k) !== chatId) {
+          return { toast: { type: "error", content: DECODE_FAILURE_TEXT.wrong_conversation } };
+        }
+        const text = this.detachFrom(envelope.k);
+        void this.client.sendCard(chatId!, replyCard(text));
+        return { toast: { type: "success", content: "已回到本聊天" } };
+      }
     }
   }
 
@@ -639,31 +865,47 @@ export class FeishuBot {
    * 命令表上点「执行」：等同于用户自己发了这条命令。
    * agent-loft 的命令就地执行并回卡片；agent 原生命令（skills 等）当一条消息发给 agent。
    */
-  private runCardCommand(key: string, text: string): CardResponse {
-    if (!this.mine(key) || !getConversation(key)) {
+  private runCardCommand(key: string, chatId: string | undefined, operatorOpenId: string | undefined, text: string): CardResponse {
+    if (!this.controls(key, chatId) || !getConversation(key)) {
       return { toast: { type: "error", content: "这条会话已不存在，请重新发一次「/」。" } };
     }
+    const chat = chatId!;
+    // /web、/detach 作用在这个聊天自己的会话上：命令表可能是接着 Web 会话时发的，k 是 Web 会话
+    const feishuCmd = feishuCommandOf(text);
+    if (feishuCmd) {
+      const ownKey = this.mine(key) ? key : this.keyOf(chat);
+      void this.runFeishuCommand(feishuCmd, ownKey, chat);
+      return { toast: { type: "info", content: `正在执行 ${text}` } };
+    }
+    if (operatorOpenId) this.operators.set(pairKey(key, chat), operatorOpenId.trim().toLowerCase());
     const command = parseCommand(text);
     if (command.kind === "chat") {
-      const origin = { channel: "feishu", channelId: this.cfg.id, name: "飞书" };
+      const origin = { channel: "feishu", channelId: this.cfg.id, name: "飞书", chatId: chat };
       const gen = hub.generation(key);
       this.enqueue(key, async () => hub.send(key, { text, attachments: [] }, origin, gen));
       return { toast: { type: "success", content: `已发送 ${text}` } };
     }
-    const chatId = this.chatIdOf(key);
     void hub
-      .command(key, command, { allowedAgents: this.allowedAgents(), by: "飞书命令" })
-      .then((reply) => this.renderReply(key, reply))
-      .catch((err) => this.client.sendText(chatId, `出错了：${err instanceof Error ? err.message : String(err)}`));
+      .command(key, command, { allowedAgents: this.allowedFor(key), by: "飞书命令", channel: "feishu" })
+      .then((reply) => this.renderReply(key, chat, reply))
+      .catch((err) => this.client.sendText(chat, `出错了：${err instanceof Error ? err.message : String(err)}`));
     return { toast: { type: "info", content: `正在执行 ${text}` } };
   }
 
-  /** 卡片回调里耗时的操作：先应答，做完在会话里回一句。 */
-  private background(key: string, task: () => Promise<string>): void {
-    if (!this.mine(key) || !getConversation(key)) return;
-    const chatId = this.chatIdOf(key);
+  /** 卡片回调里耗时的操作：先应答，做完在点的那个聊天里回一句。 */
+  private background(
+    key: string,
+    chatId: string | undefined,
+    toast: string,
+    task: () => Promise<string>,
+  ): CardResponse {
+    if (!this.controls(key, chatId) || !getConversation(key)) {
+      return { toast: { type: "error", content: "这条会话已不存在，或者这个聊天已经不接着它了。" } };
+    }
+    const chat = chatId!;
     void task()
-      .then((text) => this.client.sendCard(chatId, replyCard(text)))
-      .catch((err) => this.client.sendText(chatId, `出错了：${err instanceof Error ? err.message : String(err)}`));
+      .then((text) => this.client.sendCard(chat, replyCard(text)))
+      .catch((err) => this.client.sendText(chat, `出错了：${err instanceof Error ? err.message : String(err)}`));
+    return { toast: { type: "info", content: toast } };
   }
 }

package/src/channels/feishu/cards.ts

@@ -363,3 +363,100 @@ export function relativeTime(ts: number, now = Date.now()): string {
   if (days < 30) return `${days} 天前`;
   return new Date(ts).toLocaleDateString("zh-CN");
 }
+
+// ---------- 接着 Web 会话 ----------
+
+export type WebConvEntry = {
+  key: string;
+  title: string;
+  agentLabel: string;
+  cwd: string;
+  busy: boolean;
+  activeAt: number;
+};
+
+/** /web：最近的 Web 会话，点「接上」后这个聊天就接着它聊 */
+export function webListCard(params: {
+  convs: WebConvEntry[];
+  /** 当前挂着的 Web 会话 */
+  current?: string;
+  /** 这个飞书聊天自己的会话键 */
+  sessionKey: string;
+  ctx: CardCtx;
+}) {
+  const elements: unknown[] = [
+    {
+      tag: "markdown",
+      content: params.current
+        ? "这个聊天正接着下面标 ✅ 的 Web 会话。点别的「接上」换一条，或者回到这个聊天自己的会话。"
+        : "点「接上」后，在这里说的话都发进那条 Web 会话，它的回复、授权和提问也会发到这里。发 `/detach` 回到这个聊天自己的会话。",
+    },
+  ];
+  if (params.current) {
+    elements.push(buttonRow([button("回到本聊天", { a: "detach", k: params.sessionKey }, params.ctx)]));
+  }
+  if (params.convs.length === 0) {
+    elements.push({ tag: "hr" }, { tag: "markdown", content: "还没有 Web 会话。" });
+  }
+  params.convs.forEach((c, index) => {
+    const isCurrent = c.key === params.current;
+    elements.push({ tag: "hr" });
+    elements.push({
+      tag: "column_set",
+      horizontal_spacing: "8px",
+      columns: [
+        {
+          tag: "column",
+          width: "weighted",
+          weight: 1,
+          vertical_align: "center",
+          elements: [
+            {
+              tag: "markdown",
+              content:
+                `**${index + 1}. ${clip(c.title, 60)}**${isCurrent ? "　✅ 当前" : ""}${c.busy ? "　⏳ 回复中" : ""}\n` +
+                `<font color='grey'>${c.agentLabel} · \`${c.cwd}\` · ${relativeTime(c.activeAt)}</font>`,
+            },
+          ],
+        },
+        {
+          tag: "column",
+          width: "auto",
+          vertical_align: "center",
+          elements: isCurrent ? [] : [button("接上", { a: "attach", w: c.key, k: params.sessionKey }, params.ctx)],
+        },
+      ],
+    });
+  });
+  return card(elements, { title: "Web 会话", template: "blue" });
+}
+
+/** 接上之后发一张：接的是哪条、最近聊到哪，以及回来的按钮 */
+export function attachedCard(params: {
+  conv: WebConvEntry;
+  recent: { role: "user" | "assistant"; text: string }[];
+  sessionKey: string;
+  ctx: CardCtx;
+}) {
+  const { conv } = params;
+  const elements: unknown[] = [
+    {
+      tag: "markdown",
+      content: `**${clip(conv.title, 80)}**\n<font color='grey'>${conv.agentLabel} · \`${conv.cwd}\`</font>`,
+    },
+  ];
+  if (params.recent.length > 0) {
+    const lines = params.recent.map((m) => {
+      const who = m.role === "user" ? "**你**" : `**${conv.agentLabel}**`;
+      return `${who}：${clip(m.text.trim(), 400)}`;
+    });
+    elements.push({ tag: "hr" }, { tag: "markdown", content: clip(`最近的对话：\n\n${lines.join("\n\n")}`, 3000) });
+  }
+  elements.push({ tag: "hr" });
+  elements.push({
+    tag: "markdown",
+    content: `${conv.busy ? "它正在回复，后面的进度会接着发到这里。\n" : ""}直接在这里说话就会发进这条会话；Web 上说的话也会同步过来。发 \`/detach\` 回到这个聊天自己的会话。`,
+  });
+  elements.push(buttonRow([button("回到本聊天", { a: "detach", k: params.sessionKey }, params.ctx)]));
+  return card(elements, { title: "已接上 Web 会话", template: "turquoise" });
+}

package/src/channels/feishu/client.ts

@@ -112,6 +112,28 @@ export class FeishuClient {
     }
   }
 
+  /**
+   * 群名 / 是不是私聊，Web 上选「在哪个飞书聊天继续」时显示用。
+   * 要 im:chat 读权限，没有就返回 undefined，调用方退回显示 chat_id。成功的结果缓存起来。
+   */
+  private chatInfoCache = new Map<string, { name?: string; mode?: string }>();
+  async chatInfo(chatId: string): Promise<{ name?: string; mode?: string } | undefined> {
+    const cached = this.chatInfoCache.get(chatId);
+    if (cached) return cached;
+    try {
+      const res = await this.lark.im.v1.chat.get({ path: { chat_id: chatId } });
+      if (res.code !== 0 || !res.data) return undefined;
+      const info = {
+        ...(res.data.name ? { name: res.data.name } : {}),
+        ...(res.data.chat_mode ? { mode: res.data.chat_mode } : {}),
+      };
+      rememberBounded(this.chatInfoCache, chatId, info, 200);
+      return info;
+    } catch {
+      return undefined;
+    }
+  }
+
   /** 飞书没有给机器人开放 typing 指示器，表情回复是最接近的替代。 */
   async addTypingReaction(messageId: string): Promise<string | undefined> {
     try {

package/src/channels/feishu/envelope.ts

@@ -23,7 +23,11 @@ export type EnvelopeAction =
   | { a: "agent"; g: string; k: string }
   | { a: "resume"; s: string; k: string; c?: string }
   /** 命令列表卡上的「执行」：c 是命令名，不带斜杠 */
-  | { a: "cmd"; c: string; k: string };
+  | { a: "cmd"; c: string; k: string }
+  /** 把飞书会话 k 挂到 Web 会话 w 上 */
+  | { a: "attach"; w: string; k: string }
+  /** 飞书会话 k 不再挂着 Web 会话 */
+  | { a: "detach"; k: string };
 
 export type CardEnvelope = EnvelopeAction & {
   oc: typeof ENVELOPE_VERSION;
@@ -103,6 +107,10 @@ function validAction(v: Record<string, unknown>): boolean {
     case "cmd":
       // 只放行命令名该有的字符（skill 名会带冒号），别让参数、换行之类混进来
       return str(v.c) && /^[\w:.-]+$/.test(v.c) && str(v.k);
+    case "attach":
+      return str(v.w) && v.w.startsWith("web:") && str(v.k);
+    case "detach":
+      return str(v.k);
     default:
       return false;
   }

package/src/channels/web/api.ts

@@ -518,6 +518,20 @@ export async function handleApi(req: IncomingMessage, res: ServerResponse, url:
       sendJson(res, 200, { info: hub.info(newKey) });
       return;
     }
+    if (sub === "feishu" && method === "POST") {
+      // 在飞书继续：把选中的飞书聊天挂到这条 Web 会话上
+      if (conv.channel !== "web" || conv.hidden) throw new HttpError(400, "只有 Web 会话能到飞书继续");
+      const body = await readJsonBody<{ botId?: string; chatId?: string }>(req);
+      const bot = feishuBots().find((b) => b.id === body.botId);
+      if (!bot) throw new HttpError(404, "这个飞书机器人没有在运行");
+      const chatId = String(body.chatId ?? "");
+      // 只能挂到这个机器人聊过的聊天上，不能拿它往任意 chat_id 发消息
+      if (!bot.hasChat(chatId)) {
+        throw new HttpError(404, "这个机器人没在那个聊天里说过话");
+      }
+      sendJson(res, 200, { text: await bot.attachTo(bot.keyOf(chatId), key) });
+      return;
+    }
     if (sub === "sessions" && method === "GET") {
       sendJson(res, 200, await hub.sessions(key, url.searchParams.get("all") === "1"));
       return;
@@ -652,6 +666,8 @@ export async function handleApi(req: IncomingMessage, res: ServerResponse, url:
       const commands = await hub.commandCatalog(m[1]!, {
         ...(conv ? { cwd: conv.cwd } : {}),
         allowedAgents: hub.enabledAgents().map((d) => d.id),
+        // 带 key 是输入框补全：只列 Web 能用的；不带是设置页排序，全列
+        ...(conv ? { channel: "web" } : {}),
       });
       sendJson(res, 200, { commands });
       return;
@@ -712,6 +728,14 @@ export async function handleApi(req: IncomingMessage, res: ServerResponse, url:
     sendJson(res, 200, { ok: true });
     return;
   }
+  if (p === "/api/feishu/targets" && method === "GET") {
+    // 「在飞书继续」能选的地方：每个运行中的机器人，以及它聊过的聊天
+    const bots = await Promise.all(
+      feishuBots().map(async (b) => ({ id: b.id, name: b.cfg.name, state: b.status.state, chats: await b.knownChats() })),
+    );
+    sendJson(res, 200, { bots });
+    return;
+  }
   if (p === "/api/feishu/status" && method === "GET") {
     sendJson(res, 200, feishuBots().map((b) => ({ id: b.id, name: b.cfg.name, ...b.status })));
     return;

package/src/core/command-catalog.ts

@@ -7,7 +7,14 @@
 // 顺序和隐藏按 agent 分开存在配置里（设置 → 命令），用户自己排。
 
 /** agent-loft 内置命令。name 不带斜杠；args 里尖括号是必填、方括号是可选 */
-export type BuiltinSpec = { name: string; args?: string; description: string; multiAgentOnly?: boolean };
+export type BuiltinSpec = {
+  name: string;
+  args?: string;
+  description: string;
+  multiAgentOnly?: boolean;
+  /** 只在飞书里有意义（挂到 Web 会话上 / 退回来），Web 的补全里不列 */
+  feishuOnly?: boolean;
+};
 
 export const BUILTIN_COMMANDS: BuiltinSpec[] = [
   { name: "new", args: "[模型]", description: "开一条新会话" },
@@ -24,6 +31,8 @@ export const BUILTIN_COMMANDS: BuiltinSpec[] = [
   { name: "cd", args: "<相对目录>", description: "切换工作目录（限 workspace 内）" },
   { name: "pwd", description: "显示当前工作目录" },
   { name: "autoedit", args: "[on|off]", description: "本对话自动允许改工作目录内的文件（Bash 仍询问）" },
+  { name: "web", description: "接上一条 Web 会话，在飞书里查看和回复", feishuOnly: true },
+  { name: "detach", description: "不再接着 Web 会话，回到这个聊天自己的会话", feishuOnly: true },
   { name: "approve", args: "<请求ID> allow-once|allow-always|allow-session|deny", description: "审批兜底（卡片失效时用）" },
   { name: "help", description: "显示帮助" },
 ];
@@ -129,11 +138,14 @@ export function buildCatalog(params: {
   allowedAgents: string[];
   native: AgentCommand[];
   prefs: CommandPrefs | undefined;
+  /** 给哪个渠道看：不是飞书就不列飞书专用的命令。不给就全列（设置页排序用） */
+  channel?: string;
 }): CommandEntry[] {
   const multi = params.allowedAgents.length > 1;
   const builtin: CommandEntry[] = BUILTIN_COMMANDS.filter(
     (c) =>
       (!c.multiAgentOnly || multi) &&
+      (!c.feishuOnly || params.channel === undefined || params.channel === "feishu") &&
       // /claude /codex 只在这个渠道能用对应 agent 时才有意义
       (!["claude", "codex"].includes(c.name) || params.allowedAgents.includes(c.name)),
   ).map((c) => ({

package/src/core/commands.ts

@@ -84,7 +84,7 @@ export function parseCommand(raw: string): ParsedCommand {
   }
 }
 
-export function helpText(agents: string[]): string {
+export function helpText(agents: string[], channel?: string): string {
   const multi = agents.length > 1;
   return [
     "直接说话即可，会自动接着上次的会话。闲置太久会自动开新会话。",
@@ -94,6 +94,7 @@ export function helpText(agents: string[]): string {
     "**命令**（需整条消息只有命令；只发一个 `/` 可以列出全部命令，包括 agent 自己的）",
     "",
     ...BUILTIN_COMMANDS.filter((c) => !c.multiAgentOnly || multi)
+      .filter((c) => !c.feishuOnly || channel === "feishu")
       .filter((c) => !["claude", "codex"].includes(c.name))
       .map((c) =>
         c.name === "agent"

package/src/core/hub.ts

@@ -50,6 +50,8 @@ export type Origin = {
   channelId: string;
   /** 显示用的人名 / 设备名 */
   name?: string;
+  /** 飞书：从哪个聊天说的（一条会话可能同时挂在好几个飞书聊天上，回显时要分清） */
+  chatId?: string;
 };
 
 export type ConvEvent =
@@ -1113,14 +1115,24 @@ class Hub extends EventEmitter<{ event: [EventEnvelope] }> {
   }
 
   /** 执行一条已解析的命令。chat 不在这里处理。 */
-  async command(key: string, cmd: ParsedCommand, ctx: { allowedAgents: string[]; by: string }): Promise<CommandReply> {
+  /** ctx.channel：命令是从哪个渠道发的（飞书聊天挂在 Web 会话上时，和会话自己的渠道不一样） */
+  async command(
+    key: string,
+    cmd: ParsedCommand,
+    ctx: { allowedAgents: string[]; by: string; channel?: string },
+  ): Promise<CommandReply> {
     const text = (t: string): CommandReply => ({ type: "text", text: t });
+    const channel = ctx.channel ?? getConversation(key)?.channel;
     switch (cmd.kind) {
       case "help":
-        return text(helpText(ctx.allowedAgents));
+        return text(helpText(ctx.allowedAgents, channel));
       case "commands": {
         const conv = getConversation(key)!;
-        const all = await this.commandCatalog(conv.agent, { cwd: conv.cwd, allowedAgents: ctx.allowedAgents });
+        const all = await this.commandCatalog(conv.agent, {
+          cwd: conv.cwd,
+          allowedAgents: ctx.allowedAgents,
+          ...(channel ? { channel } : {}),
+        });
         return { type: "commands", agent: conv.agent, commands: all.filter((c) => !c.hidden) };
       }
       case "pwd":
@@ -1180,7 +1192,7 @@ class Hub extends EventEmitter<{ event: [EventEnvelope] }> {
    */
   async commandCatalog(
     agent: string,
-    opts: { cwd?: string; allowedAgents: string[] },
+    opts: { cwd?: string; allowedAgents: string[]; channel?: string },
   ): Promise<CommandEntry[]> {
     const driver = this.enabledAgents().find((d) => d.id === agent);
     let native: AgentCommand[] = [];
@@ -1191,7 +1203,7 @@ class Hub extends EventEmitter<{ event: [EventEnvelope] }> {
       });
     }
     const prefs = (config().commands as Record<string, CommandPrefs | undefined>)[agent];
-    return buildCatalog({ allowedAgents: opts.allowedAgents, native, prefs });
+    return buildCatalog({ allowedAgents: opts.allowedAgents, native, prefs, ...(opts.channel ? { channel: opts.channel } : {}) });
   }
 
   async shutdown(): Promise<void> {

package/web/app.js

@@ -1428,10 +1428,64 @@ function openConvContextMenu(key, at) {
       },
     },
     { label: "重命名", onclick: () => renameConv(key) },
+    ...(c.channel === "web" && S.bots.length > 0 ? [{ label: "在飞书继续…", onclick: () => continueInFeishu(key) }] : []),
     ...(c.channel === "web" ? [{ label: "删除", danger: true, onclick: () => deleteConv(key) }] : []),
   ]);
 }
 
+/**
+ * 在飞书继续：选一个机器人聊过的飞书聊天，把它接到这条 Web 会话上。
+ * 之后在那个聊天里说话就进这条会话，回复、授权、提问也发过去；飞书里发 /detach 退回来。
+ * 只有一个聊天可选时直接接上，不弹窗。
+ */
+async function continueInFeishu(key) {
+  let data;
+  try {
+    data = await api("/api/feishu/targets");
+  } catch (err) {
+    return toast(err.message);
+  }
+  const targets = data.bots.flatMap((b) => b.chats.map((c) => ({ bot: b, chat: c })));
+  if (data.bots.length === 0) return toast("没有运行中的飞书机器人");
+  if (targets.length === 0) return toast("机器人还没有聊天：先在飞书里给它发一条消息，再回来推过去");
+  const go = async (t, close) => {
+    try {
+      const r = await api(`/api/conversations/${encodeURIComponent(key)}/feishu`, {
+        method: "POST",
+        body: { botId: t.bot.id, chatId: t.chat.chatId },
+      });
+      close?.();
+      toast(r.text);
+    } catch (err) {
+      toast(err.message);
+    }
+  };
+  if (targets.length === 1) return go(targets[0]);
+  const multiBot = data.bots.filter((b) => b.chats.length > 0).length > 1;
+  const body = h("div", { class: "modal-body" });
+  const close = modal({ title: "在飞书继续", body });
+  fill(
+    body,
+    h("div", { class: "muted" }, "选一个飞书聊天，之后在那里说话就会发进这条会话，回复和授权也会发过去。在飞书里发 /detach 回到那个聊天自己的会话。"),
+    ...targets.map((t) => {
+      const here = t.chat.attached === key;
+      const other = t.chat.attached && !here ? S.convs.get(t.chat.attached) : null;
+      const note = here ? "已接着这条" : other ? `正接着「${convTitle(other)}」，选它会换过来` : "";
+      return h(
+        "button",
+        { class: `list-item${here ? " on" : ""}`, onclick: () => go(t, close) },
+        h("span", { class: "brand-icon", html: ICON.feishu }),
+        h(
+          "div",
+          { class: "grow" },
+          h("div", { class: "t" }, multiBot ? `${t.bot.name} · ${t.chat.label}` : t.chat.label),
+          h("div", { class: "s" }, [`${relTime(t.chat.activeAt)}活跃`, t.bot.state !== "connected" ? "机器人未连上" : "", note].filter(Boolean).join(" · ")),
+        ),
+      );
+    }),
+  );
+}
+
 /** 飞书机器人的历史会话：这个机器人的所有聊天，按活跃时间排，点一下打开 */
 function openBotConversations(botId) {
   const bot = S.bots.find((b) => b.id === botId);
@@ -3519,7 +3573,7 @@ function modelPicker(agent, model, effort, defaultLabel) {
 }
 
 /** agent-loft 内置命令名（和服务端 BUILTIN_COMMANDS 一致），自定义命令不能用 */
-const BUILTIN_NAMES = ["new", "status", "stop", "model", "effort", "sessions", "resume", "fork", "agent", "claude", "codex", "cd", "pwd", "autoedit", "approve", "help"];
+const BUILTIN_NAMES = ["new", "status", "stop", "model", "effort", "sessions", "resume", "fork", "agent", "claude", "codex", "cd", "pwd", "autoedit", "web", "detach", "approve", "help"];
 
 /**
  * 添加 / 编辑一条自定义命令。onSave 返回 true 才关窗；失败（比如服务端校验没过）留着让用户改。