agent-loft 0.2.24 → 0.2.26

package/src/channels/feishu/bot.ts

@@ -14,7 +14,8 @@ import { parseCommand } from "../../core/commands.js";
 import { Dedup } from "../../core/dedup.js";
 import { isPaired, requestPairing } from "../../core/pairing.js";
 import { getConversation, listConversations, sessionOwner, updateConversation } from "../../core/store.js";
-import { adminVisible, hasMembers } from "../../core/users.js";
+import { adminVisible, getUser, hasMembers, ownedBy, type User } from "../../core/users.js";
+import { linkedUser, redeemLinkCode } from "../../core/feishu-links.js";
 import { adoptFile, KIND_LABEL } from "../../core/uploads.js";
 import type { SavedAttachment } from "../../core/types.js";
 import { FeishuClient } from "./client.js";
@@ -46,11 +47,16 @@ 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";
+type FeishuCommand = { kind: "web" } | { kind: "detach" } | { kind: "bind"; code: string };
+
+/** 只在飞书里认的命令：挂到 Web 会话上 / 退回来 / 绑定账号。整条消息只有命令才算 */
+function feishuCommandOf(text: string): FeishuCommand | null {
+  const t = text.trim().replace(/^／/, "/");
+  const lower = t.toLowerCase();
+  if (lower === "/web") return { kind: "web" };
+  if (lower === "/detach") return { kind: "detach" };
+  const bind = /^\/bind\s+([A-Za-z0-9]{4,16})$/i.exec(t);
+  if (bind) return { kind: "bind", code: bind[1]! };
   return null;
 }
 
@@ -134,6 +140,37 @@ export class FeishuBot {
     return this.mine(key) ? this.allowedAgents() : hub.enabledAgents().map((d) => d.id);
   }
 
+  // ---------- 这个聊天能碰哪些东西 ----------
+  //
+  // 飞书聊天自己的会话有主人（绑定了账号的私聊，见 core/feishu-links.ts）：按主人算，和他在 Web 上一样；
+  // 没主人（群聊、没绑定的私聊）：照旧是管理员的地盘。
+
+  /** 飞书会话键的主人（绑定了账号的私聊才有） */
+  private viewerOf(feishuKey: string): User | undefined {
+    const owner = getConversation(feishuKey)?.owner;
+    const user = getUser(owner);
+    return user && !user.disabled ? user : undefined;
+  }
+
+  /** feishuKey 这个聊天能不能碰主人是 owner 的东西（Web 会话、agent 会话） */
+  private canSee(feishuKey: string, owner: string | undefined): boolean {
+    const viewer = this.viewerOf(feishuKey);
+    return viewer ? ownedBy(viewer, owner) : adminVisible(owner);
+  }
+
+  /** 命令里要用的可见范围：/sessions 列哪些、/resume 能恢复哪些、/approve 能处理哪些 */
+  private commandScope(feishuKey: string) {
+    const viewer = this.viewerOf(feishuKey);
+    return {
+      ...(viewer
+        ? { sessionVisible: (id: string) => ownedBy(viewer, sessionOwner(id)) }
+        : hasMembers()
+          ? { sessionVisible: (id: string) => adminVisible(sessionOwner(id)) }
+          : {}),
+      convVisible: (k: string) => this.canSee(feishuKey, getConversation(k)?.owner),
+    };
+  }
+
   // ---------- 接着 Web 会话 ----------
 
   /** 飞书会话键挂着的 Web 会话（还在、没被删的）；没挂着返回 undefined */
@@ -141,13 +178,14 @@ export class FeishuBot {
     const target = attachedTarget(feishuKey);
     if (!target) return undefined;
     const conv = getConversation(target);
-    // 主人后来被降成了普通成员：这条会话不再是飞书能碰的，当它没了（下条消息时自动退回来）
-    return conv && !conv.hidden && adminVisible(conv.owner) ? target : undefined;
+    // 这个聊天不再能碰它了（主人被降成了普通成员、私聊换了主人）：当它没了（下条消息时自动退回来）
+    return conv && !conv.hidden && this.canSee(feishuKey, conv.owner) ? target : undefined;
   }
 
-  /** 挂在 Web 会话 key 上的本机器人聊天。会话已经不归管理员了就一个都不算 */
+  /** 挂在 Web 会话 key 上的本机器人聊天（只算还能碰它的） */
   private watchers(key: string): string[] {
-    return adminVisible(getConversation(key)?.owner) ? watchersOf(key, this.prefix) : [];
+    const owner = getConversation(key)?.owner;
+    return watchersOf(key, this.prefix).filter((k) => this.canSee(k, owner));
   }
 
   /** 这条会话的事件该画到哪些飞书聊天里：自己的那个聊天，加上挂着它的聊天 */
@@ -213,8 +251,8 @@ export class FeishuBot {
    */
   async attachTo(feishuKey: string, webKey: string, operatorOpenId?: string): Promise<string> {
     const conv = getConversation(webKey);
-    // 飞书是管理员的地盘：普通成员的 Web 会话不能被接到飞书上
-    if (!conv || conv.channel !== "web" || conv.hidden || !adminVisible(conv.owner)) throw new Error("这条 Web 会话已不存在");
+    // 只能接上这个聊天的主人自己的 Web 会话（没主人的聊天：管理员能看的）
+    if (!conv || conv.channel !== "web" || conv.hidden || !this.canSee(feishuKey, conv.owner)) throw new Error("这条 Web 会话已不存在");
     const chatId = this.chatIdOf(feishuKey);
     // 本聊天自己的会话也得有：之后 /detach 回来、侧栏里显示机器人都要它
     const allowed = this.allowedAgents();
@@ -261,7 +299,7 @@ export class FeishuBot {
   private async sendWebList(feishuKey: string, chatId: string): Promise<void> {
     const current = this.attachedWeb(feishuKey);
     const convs = hub
-      .list((c) => c.channel === "web" && !c.hidden && adminVisible(c.owner))
+      .list((c) => c.channel === "web" && !c.hidden && this.canSee(feishuKey, c.owner))
       .slice(0, 10)
       .map((c) => this.webEntry(c.key)!)
       .filter(Boolean);
@@ -606,9 +644,17 @@ export class FeishuBot {
     const operator = openId!.trim().toLowerCase();
     this.operators.set(pairKey(ownKey, chatId), operator);
 
+    // 私聊的主人跟着发消息的人的绑定走：绑定了就是他的个人会话（用他的记忆），解绑了就回到管理员的地盘。
+    // 群聊不动：群里不止一个人
+    const p2p = message.chat_type === "p2p";
+    if (p2p && hub.reassignOwner(ownKey, linkedUser(this.cfg.id, operator)?.id)) {
+      const owner = this.viewerOf(ownKey);
+      console.log(`${this.tag} 私聊 ${ownKey} 的主人变为 ${owner?.name ?? "（无，归管理员）"}`);
+    }
+
     const feishuCmd = attachments.length > 0 ? null : feishuCommandOf(text);
     if (feishuCmd) {
-      await this.runFeishuCommand(feishuCmd, ownKey, chatId);
+      await this.runFeishuCommand(feishuCmd, ownKey, chatId, { openId: operator, p2p });
       return;
     }
 
@@ -624,9 +670,8 @@ export class FeishuBot {
           allowedAgents: this.allowedFor(key),
           by: "飞书命令",
           channel: "feishu",
-          // 普通成员在 Web 上开的 agent 会话、挂着的请求，飞书里都碰不到
-          ...(hasMembers() ? { sessionVisible: (id: string) => adminVisible(sessionOwner(id)) } : {}),
-          convVisible: (k) => adminVisible(getConversation(k)?.owner),
+          // 别人的 agent 会话、挂着的请求，这个聊天里都碰不到
+          ...this.commandScope(ownKey),
         });
         await this.renderReply(key, chatId, reply);
       } catch (err) {
@@ -687,16 +732,39 @@ export class FeishuBot {
     return { saved, failed };
   }
 
-  /** /web、/detach：只认飞书会话自己的键，不管现在挂没挂着 */
-  private async runFeishuCommand(cmd: "web" | "detach", ownKey: string, chatId: string): Promise<void> {
+  /** /web、/detach、/bind：只认飞书会话自己的键，不管现在挂没挂着 */
+  private async runFeishuCommand(
+    cmd: FeishuCommand,
+    ownKey: string,
+    chatId: string,
+    sender?: { openId: string; p2p: boolean },
+  ): Promise<void> {
     try {
-      if (cmd === "web") await this.sendWebList(ownKey, chatId);
-      else await this.client.sendCard(chatId, replyCard(this.detachFrom(ownKey)));
+      if (cmd.kind === "web") await this.sendWebList(ownKey, chatId);
+      else if (cmd.kind === "detach") await this.client.sendCard(chatId, replyCard(this.detachFrom(ownKey)));
+      else await this.client.sendCard(chatId, replyCard(this.bind(cmd.code, ownKey, sender)));
     } catch (err) {
       await this.client.sendText(chatId, `出错了：${err instanceof Error ? err.message : String(err)}`);
     }
   }
 
+  /** /bind 绑定码：把发消息的人的飞书账号绑到生成这个码的 agent-loft 用户上 */
+  private bind(code: string, ownKey: string, sender: { openId: string; p2p: boolean } | undefined): string {
+    if (!sender) return "请直接在聊天里发 `/bind 绑定码`。";
+    // 群里发的码别人也看得见，而且群聊本来就不归个人：只在私聊里绑
+    if (!sender.p2p) return "请在和我的私聊里发 `/bind 绑定码`（群里别人也看得到绑定码）。绑定码已经露出来了的话，到 Web 上重新生成一个。";
+    const user = redeemLinkCode(code, this.cfg.id, sender.openId);
+    hub.reassignOwner(ownKey, user.id);
+    console.log(`${this.tag} ${sender.openId} 绑定到用户 ${user.name}`);
+    return [
+      `已绑定到 agent-loft 用户 **${user.name}**。`,
+      "",
+      "从现在起这个私聊是你的个人会话：用你的记忆，`/sessions` 只列你的会话，`/web` 只能接上你自己的 Web 会话。群聊不受影响。",
+      "",
+      "在 Web 的「设置 → 我的账号」里可以随时解除绑定。",
+    ].join("\n");
+  }
+
   private async renderReply(key: string, chatId: string, reply: CommandReply): Promise<void> {
     const ctx = this.cardCtx(key, chatId);
     switch (reply.type) {
@@ -885,9 +953,9 @@ export class FeishuBot {
     }
     const chat = chatId!;
     // /web、/detach 作用在这个聊天自己的会话上：命令表可能是接着 Web 会话时发的，k 是 Web 会话
+    const ownKey = this.mine(key) ? key : this.keyOf(chat);
     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}` } };
     }
@@ -900,7 +968,7 @@ export class FeishuBot {
       return { toast: { type: "success", content: `已发送 ${text}` } };
     }
     void hub
-      .command(key, command, { allowedAgents: this.allowedFor(key), by: "飞书命令", channel: "feishu" })
+      .command(key, command, { allowedAgents: this.allowedFor(key), by: "飞书命令", channel: "feishu", ...this.commandScope(ownKey) })
       .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}` } };

package/src/channels/web/api.ts

@@ -8,7 +8,8 @@ import { cleanCustomCommands } from "../../core/command-catalog.js";
 import { hub } from "../../core/hub.js";
 import { interactions } from "../../core/interactions.js";
 import { approve, listApproved, listPending, revoke } from "../../core/pairing.js";
-import { getConversation, updateConversation } from "../../core/store.js";
+import { getConversation, listConversations, updateConversation } from "../../core/store.js";
+import { addScheduled, clearScheduled, removeScheduled } from "../../core/scheduled.js";
 import { resolveUploadFile, saveBuffer, sniff, uploadKeyOf } from "../../core/uploads.js";
 import {
   createUser,
@@ -23,6 +24,20 @@ import {
   type User,
 } from "../../core/users.js";
 import type { SavedAttachment } from "../../core/types.js";
+import {
+  addMemoryItem,
+  clearMemory,
+  MEMORY_LIMITS,
+  readMemory,
+  removeMemoryItem,
+  setMemoryOptions,
+  updateMemoryItem,
+  type CurateSettings,
+} from "../../core/memory.js";
+import { createLinkCode, listLinks, unlink, unlinkUser } from "../../core/feishu-links.js";
+import { purgeUserData } from "../../core/personal.js";
+import { purgeHistory, readMeta, readRecords, writeMeta } from "../../core/chat-history.js";
+import { curateNow, pendingCount } from "../../core/memory-curator.js";
 import { listAllowlist, setAllowlist } from "../../agents/claude/permissions.js";
 import { agentAvailability, agentHealth, invalidateHealth } from "../../agents/health.js";
 import { installCodex, upgrade, useInstalledCodex, versionInfo } from "../../core/upgrade.js";
@@ -329,6 +344,46 @@ function userOp<T>(fn: () => T): T {
   }
 }
 
+// ---------- 记忆、飞书绑定 ----------
+
+/** 飞书 open_id 只给人看个尾巴：认得出是哪个就够了 */
+function maskOpenId(openId: string): string {
+  return openId.length > 10 ? `${openId.slice(0, 3)}…${openId.slice(-6)}` : openId;
+}
+
+function feishuLinksOf(userId: string) {
+  const bots = config().feishu.bots;
+  return listLinks(userId).map((l) => ({
+    botId: l.botId,
+    botName: bots.find((b) => b.id === l.botId)?.name ?? "（已删除的机器人）",
+    openId: l.openId,
+    openIdShort: maskOpenId(l.openId),
+    boundAt: l.boundAt,
+  }));
+}
+
+/**
+ * 解除绑定后，那个人和机器人的私聊立刻不再是他的：交还给管理员的地盘，旧会话不带过去
+ * （见 hub.reassignOwner）。不等他下次发消息 —— 万一他再也不发，那条对话就一直挂在他名下。
+ */
+function releaseFeishuChats(userId: string, botId?: string): void {
+  for (const c of listConversations()) {
+    if (c.channel !== "feishu" || c.owner !== userId || (botId && c.channelId !== botId)) continue;
+    hub.reassignOwner(c.key, undefined);
+  }
+}
+
+function memoryOp<T>(userId: string, fn: () => T, affectsAgents = true): T {
+  try {
+    const result = fn();
+    // 用户在设置里改了记忆：他名下空闲的会话下次说话时换上新的（只改整理时机、用哪个模型的不用）
+    if (affectsAgents) hub.memoryChanged(userId);
+    return result;
+  } catch (err) {
+    throw new HttpError(400, err instanceof Error ? err.message : String(err));
+  }
+}
+
 // ---------- 路由 ----------
 
 function conversationOr404(key: string) {
@@ -481,7 +536,7 @@ export async function handleApi(req: IncomingMessage, res: ServerResponse, url:
     return;
   }
   if (p === "/api/conversations" && method === "POST") {
-    const body = await readJsonBody<{ agent?: string; cwd?: string }>(req);
+    const body = await readJsonBody<{ agent?: string; cwd?: string; mode?: string }>(req);
     const enabled = hub.enabledAgents().map((d) => d.id);
     const agent = body.agent && enabled.includes(body.agent) ? body.agent : enabled[0];
     if (!agent) throw new HttpError(400, "没有可用的 agent");
@@ -494,6 +549,8 @@ export async function handleApi(req: IncomingMessage, res: ServerResponse, url:
     const key = `web:${crypto.randomBytes(6).toString("hex")}`;
     hub.ensure({ key, channel: "web", channelId: "web", defaultAgent: agent, owner: user.id });
     if (cwd && cwd !== config().workspaceRoot) updateConversation(key, { cwd, cwdExplicit: true });
+    // 新对话页上选的模式
+    if (body.mode === "chat") updateConversation(key, { mode: "chat" });
     sendJson(res, 200, hub.info(key));
     return;
   }
@@ -521,10 +578,35 @@ export async function handleApi(req: IncomingMessage, res: ServerResponse, url:
       // 只是从列表里藏起来：agent 侧的会话记录还在，随时能从「历史会话」恢复
       await hub.drop(key, "会话已删除");
       updateConversation(key, { hidden: true });
+      clearScheduled(key);
       hub.emitEvent(key, { type: "meta" });
       sendJson(res, 200, { ok: true });
       return;
     }
+    // ----- 定时发送：列表随会话信息（info.scheduled）下发，这里只管增删 -----
+    if (sub === "scheduled" && method === "POST") {
+      const body = await readJsonBody<{ text?: string; at?: number }>(req);
+      const text = typeof body.text === "string" ? body.text : "";
+      const at = Number(body.at);
+      if (!text.trim()) throw new HttpError(400, "定时发送的内容不能为空");
+      if (!Number.isFinite(at) || at < Date.now() - 60_000) throw new HttpError(400, "发送时间要在现在之后");
+      if (at > Date.now() + 30 * 86400_000) throw new HttpError(400, "最多只能排到 30 天以后");
+      try {
+        addScheduled(key, text, at);
+      } catch (err) {
+        throw new HttpError(400, err instanceof Error ? err.message : String(err));
+      }
+      hub.emitEvent(key, { type: "meta" });
+      sendJson(res, 200, hub.info(key));
+      return;
+    }
+    if (sub === "scheduled" && method === "DELETE") {
+      const id = url.searchParams.get("id") ?? "";
+      if (!removeScheduled(key, id)) throw new HttpError(404, "这条定时消息已经发出或取消了");
+      hub.emitEvent(key, { type: "meta" });
+      sendJson(res, 200, hub.info(key));
+      return;
+    }
     if (sub === "history" && method === "GET") {
       // 读历史是异步的。要保证「历史快照 + 进行中这一轮的事件 + 之后的补发」首尾相接、
       // 不重不漏，只在两种情况下接受这次读到的快照：
@@ -651,6 +733,10 @@ export async function handleApi(req: IncomingMessage, res: ServerResponse, url:
         case "cd":
           text = await hub.cd(key, value);
           break;
+        case "mode":
+          if (value !== "chat" && value !== "work") throw new HttpError(400, "模式只能是 chat 或 work");
+          text = await hub.setMode(key, value);
+          break;
         default:
           throw new HttpError(400, "未知操作");
       }
@@ -775,15 +861,131 @@ export async function handleApi(req: IncomingMessage, res: ServerResponse, url:
     return;
   }
 
+  // ----- 我的记忆：每个人只能看、改自己的 -----
+  if (p === "/api/account/memory" && method === "GET") {
+    const meta = readMeta(user.id);
+    sendJson(res, 200, {
+      ...readMemory(user.id),
+      limits: MEMORY_LIMITS,
+      // 等着整理的对话有几段、上次整理的结果（设置页显示）
+      pending: pendingCount(user.id),
+      ...(meta.lastCuration ? { lastCuration: meta.lastCuration } : {}),
+    });
+    return;
+  }
+  if (p === "/api/account/memory/curate" && method === "POST") {
+    // 「现在整理」：聊完了的对话合起来整理一次。要等模型回来，可能要几十秒
+    const log = await curateNow(user.id);
+    sendJson(res, 200, log);
+    return;
+  }
+  if (p === "/api/account/memory" && method === "PUT") {
+    const body = await readJsonBody<{ enabled?: boolean; about?: string; curate?: Partial<CurateSettings>; chatHistory?: boolean }>(req);
+    sendJson(
+      res,
+      200,
+      memoryOp(user.id, () =>
+        setMemoryOptions(user.id, {
+          ...(typeof body.enabled === "boolean" ? { enabled: body.enabled } : {}),
+          ...(typeof body.about === "string" ? { about: body.about } : {}),
+          ...(body.curate && typeof body.curate === "object" ? { curate: body.curate } : {}),
+          ...(typeof body.chatHistory === "boolean" ? { chatHistory: body.chatHistory } : {}),
+        }),
+        typeof body.enabled === "boolean" || typeof body.about === "string" || typeof body.chatHistory === "boolean",
+      ),
+    );
+    return;
+  }
+  if (p === "/api/account/history" && method === "GET") {
+    // 只给数量：索引里有多少句、来自多少段对话
+    const records = readRecords(user.id);
+    sendJson(res, 200, { count: records.length, conversations: new Set(records.map((r) => r.k)).size });
+    return;
+  }
+  if (p === "/api/account/history" && method === "DELETE") {
+    // 清掉聊天记录索引。不再回填：清了就是不想让以前的聊天被搜到，只记以后的
+    purgeHistory(user.id);
+    writeMeta(user.id, { backfilled: true, extracted: {} });
+    sendJson(res, 200, { ok: true });
+    return;
+  }
+  if (p === "/api/account/memory" && method === "DELETE") {
+    memoryOp(user.id, () => clearMemory(user.id));
+    sendJson(res, 200, readMemory(user.id));
+    return;
+  }
+  if (p === "/api/account/memory/items" && method === "POST") {
+    const body = await readJsonBody<{ text?: string }>(req);
+    sendJson(res, 200, memoryOp(user.id, () => addMemoryItem(user.id, String(body.text ?? ""), "user")));
+    return;
+  }
+  {
+    const m = /^\/api\/account\/memory\/items\/(m_[a-f0-9]+)$/.exec(p);
+    if (m && method === "PATCH") {
+      const body = await readJsonBody<{ text?: string }>(req);
+      sendJson(res, 200, memoryOp(user.id, () => updateMemoryItem(user.id, m[1]!, String(body.text ?? ""))));
+      return;
+    }
+    if (m && method === "DELETE") {
+      sendJson(res, 200, { ok: !!memoryOp(user.id, () => removeMemoryItem(user.id, m[1]!)) });
+      return;
+    }
+  }
+
+  // ----- 我的飞书账号绑定 -----
+  if (p === "/api/account/feishu" && method === "GET") {
+    sendJson(res, 200, {
+      links: feishuLinksOf(user.id),
+      // 能私聊的机器人（发 /bind 用）。机器人的配置细节照旧只给管理员
+      bots: config().feishu.bots.filter((b) => b.enabled).map((b) => ({ id: b.id, name: b.name })),
+    });
+    return;
+  }
+  if (p === "/api/account/feishu/code" && method === "POST") {
+    sendJson(res, 200, createLinkCode(user.id));
+    return;
+  }
+  if (p === "/api/account/feishu" && method === "DELETE") {
+    const body = await readJsonBody<{ botId?: string; openId?: string }>(req);
+    const botId = String(body.botId ?? "");
+    const ok = unlink(botId, String(body.openId ?? ""), user.id);
+    if (ok) releaseFeishuChats(user.id, botId);
+    sendJson(res, 200, { ok, links: feishuLinksOf(user.id) });
+    return;
+  }
+
   // ----- 用户管理（管理员） -----
   if (p === "/api/users" && method === "GET") {
     const devices = listWebSessions();
     sendJson(res, 200, {
-      users: listUsers().map((u) => ({ ...u, devices: devices.filter((d) => d.userId === u.id).length })),
+      users: listUsers().map((u) => ({
+        ...u,
+        devices: devices.filter((d) => d.userId === u.id).length,
+        // 只给数量：管理员不能看成员的记忆和绑定的是哪个飞书账号
+        feishuLinks: listLinks(u.id).length,
+      })),
       me: user.id,
     });
     return;
   }
+  {
+    // 管理员能做的只有「清掉」：清空某人的记忆、解除某人的飞书绑定。看不到内容
+    const m = /^\/api\/users\/([A-Za-z0-9_]+)\/(memory|feishu)$/.exec(p);
+    if (m && method === "DELETE") {
+      const id = m[1]!;
+      if (!getUser(id)) throw new HttpError(404, "用户不存在");
+      if (m[2] === "memory") {
+        clearMemory(id);
+        hub.memoryChanged(id);
+        sendJson(res, 200, { ok: true });
+      } else {
+        const n = unlinkUser(id);
+        releaseFeishuChats(id);
+        sendJson(res, 200, { ok: true, removed: n });
+      }
+      return;
+    }
+  }
   if (p === "/api/users" && method === "POST") {
     const body = await readJsonBody<{ name?: string; password?: string; role?: Role }>(req);
     sendJson(
@@ -823,6 +1025,10 @@ export async function handleApi(req: IncomingMessage, res: ServerResponse, url:
       const removed = userOp(() => removeUser(id));
       removeSubscriptionsOf((owner) => (owner ?? legacy) === id);
       revokeUserSessions(id);
+      // 记忆和飞书绑定一起删：不像会话那样转给管理员（见 core/personal.ts）
+      releaseFeishuChats(id);
+      purgeUserData(id);
+      hub.memoryChanged(id);
       sendJson(res, 200, removed);
       return;
     }

package/src/cli/user.ts

@@ -11,6 +11,7 @@ import { loadConfig } from "../core/config.js";
 import { createUser, findUserByName, legacyOwnerId, listUsers, removeUser } from "../core/users.js";
 import { patchUser, revokeUserSessions } from "../channels/web/auth.js";
 import { removeSubscriptionsOf } from "../channels/web/push.js";
+import { purgeUserData } from "../core/personal.js";
 
 loadConfig();
 
@@ -90,6 +91,8 @@ switch (sub) {
     const legacy = legacyOwnerId();
     removeUser(user.id);
     removeSubscriptionsOf((owner) => (owner ?? legacy) === user.id);
+    // 记忆和飞书绑定一起删（飞书私聊下次有人说话时自动交还给管理员）
+    purgeUserData(user.id);
     revokeUserSessions(user.id);
     console.log(`已删除「${user.name}」。他的会话还在，归管理员。`);
     break;