agent-loft 0.2.24 → 0.2.25

package/src/core/chat-history.ts

@@ -0,0 +1,250 @@
+// 聊天记录索引：给「参考以前的聊天」（search_past_chats）和「聊完自动整理记忆」用。
+//
+// 每个用户一份，data/history/<用户 id>.jsonl，一行一句（用户说的 / agent 的最终回复）。
+// 只收有主人的对话（见 personal.ts 的 memoryOwnerOf），按主人分开存 —— 搜索只在自己的里面搜。
+// 来源两个：
+//   - 实时：hub 的事件流（见 startHistoryCapture），从现在起说的话；
+//   - 回填：第一次用时把已有对话从 agent 的记录里读一遍（见 memory-curator.ts），只做一次。
+//
+// 为什么不用 SQLite 全文索引：FTS5 的 trigram 分词搜不到两个字的中文词（「豆豆」），
+// 个人的聊天量直接扫文件就够快（几万句也是毫秒级），也省得 MCP 子进程每次打实验性 API 的警告。
+import fs from "node:fs";
+import path from "node:path";
+import { dataDir, readJson, writeJsonAtomic } from "../home.js";
+
+export type HistoryRecord = {
+  /** 对话 key */
+  k: string;
+  /** agent */
+  a: string;
+  /** u：用户说的；a：agent 的回复 */
+  r: "u" | "a";
+  t: string;
+  ts: number;
+};
+
+export type CurationLog = {
+  at: number;
+  /** 整理了几段对话 */
+  conversations: number;
+  added: string[];
+  updated: string[];
+  removed: number;
+  /** 用的哪个 agent / 模型 */
+  by?: string;
+  error?: string;
+};
+
+export type Meta = {
+  /** 已有对话回填过了 */
+  backfilled?: boolean;
+  /** 每条对话整理记忆整理到了哪个时刻（这之后的话还没整理过） */
+  extracted: Record<string, number>;
+  /** 「每天一次」上次跑的是哪天（本地日期 YYYY-MM-DD） */
+  lastDaily?: string;
+  /** 上次整理的结果，设置页显示 */
+  lastCuration?: CurationLog;
+};
+
+const historyDir = path.join(dataDir, "history");
+/** 一句话最多存这么多字：长篇代码、整页网页没必要全存 */
+const TEXT_MAX = 4000;
+
+function base(userId: string): string {
+  if (!/^[A-Za-z0-9_]{1,64}$/.test(userId)) throw new Error("用户 id 不合法");
+  return path.join(historyDir, userId);
+}
+
+export function appendRecords(userId: string, records: HistoryRecord[]): void {
+  if (records.length === 0) return;
+  fs.mkdirSync(historyDir, { recursive: true, mode: 0o700 });
+  const lines = records.map((r) => JSON.stringify({ ...r, t: r.t.slice(0, TEXT_MAX) })).join("\n");
+  fs.appendFileSync(`${base(userId)}.jsonl`, `${lines}\n`, { mode: 0o600 });
+}
+
+export function readRecords(userId: string): HistoryRecord[] {
+  let raw: string;
+  try {
+    raw = fs.readFileSync(`${base(userId)}.jsonl`, "utf8");
+  } catch {
+    return [];
+  }
+  const out: HistoryRecord[] = [];
+  for (const line of raw.split("\n")) {
+    if (!line) continue;
+    try {
+      const r = JSON.parse(line) as HistoryRecord;
+      if (typeof r.k === "string" && typeof r.t === "string" && (r.r === "u" || r.r === "a")) out.push(r);
+    } catch {
+      // 写到一半被打断的行：跳过
+    }
+  }
+  return out;
+}
+
+export function readMeta(userId: string): Meta {
+  const m = readJson<Partial<Meta>>(`${base(userId)}.meta.json`, {});
+  return { ...m, extracted: m.extracted && typeof m.extracted === "object" ? m.extracted : {} };
+}
+
+export function patchMeta(userId: string, patch: Partial<Meta>): void {
+  writeMeta(userId, { ...readMeta(userId), ...patch });
+}
+
+export function writeMeta(userId: string, meta: Meta): void {
+  fs.mkdirSync(historyDir, { recursive: true, mode: 0o700 });
+  writeJsonAtomic(`${base(userId)}.meta.json`, meta);
+}
+
+export function markExtracted(userId: string, key: string, upTo: number): void {
+  const meta = readMeta(userId);
+  meta.extracted[key] = Math.max(meta.extracted[key] ?? 0, upTo);
+  writeMeta(userId, meta);
+}
+
+/** 删用户时：整个删掉 */
+export function purgeHistory(userId: string): void {
+  fs.rmSync(`${base(userId)}.jsonl`, { force: true });
+  fs.rmSync(`${base(userId)}.meta.json`, { force: true });
+}
+
+/**
+ * 还没整理过的对话：最后一句已经过去 idleMs 了（聊完了），而且在上次整理之后又说过话。
+ * 返回每条对话上次整理之后的那些句子。
+ */
+export function pendingConversations(
+  userId: string,
+  idleMs: number,
+  now = Date.now(),
+): { key: string; records: HistoryRecord[]; last: number }[] {
+  const meta = readMeta(userId);
+  const byKey = new Map<string, HistoryRecord[]>();
+  for (const r of readRecords(userId)) {
+    if (r.ts <= (meta.extracted[r.k] ?? 0)) continue;
+    let list = byKey.get(r.k);
+    if (!list) byKey.set(r.k, (list = []));
+    list.push(r);
+  }
+  const out: { key: string; records: HistoryRecord[]; last: number }[] = [];
+  for (const [key, records] of byKey) {
+    const last = Math.max(...records.map((r) => r.ts));
+    if (now - last >= idleMs) out.push({ key, records, last });
+  }
+  return out;
+}
+
+// ---------- 搜索 ----------
+
+/** 把查询拆成词：按空白和标点切开。中文不切词，长的中文词另外拆成两字一组做模糊匹配 */
+function terms(query: string): string[] {
+  return query
+    .toLowerCase()
+    .split(/[\s,，。.!！?？、;；:："'“”‘’()（）[\]【】<>《》/\\|]+/)
+    .map((t) => t.trim())
+    .filter(Boolean);
+}
+
+const isCjk = (s: string) => /[㐀-鿿]/.test(s);
+
+function bigrams(s: string): string[] {
+  const out: string[] = [];
+  for (let i = 0; i + 2 <= s.length; i++) out.push(s.slice(i, i + 2));
+  return out;
+}
+
+function occurrences(hay: string, needle: string, cap = 5): number {
+  let n = 0;
+  for (let i = hay.indexOf(needle); i >= 0 && n < cap; i = hay.indexOf(needle, i + needle.length)) n++;
+  return n;
+}
+
+/** 一句话和查询的相关程度，0 是不相关 */
+export function scoreText(text: string, query: string): number {
+  const hay = text.toLowerCase();
+  const ts = terms(query);
+  if (ts.length === 0) return 0;
+  let score = 0;
+  let hit = 0;
+  for (const term of ts) {
+    const n = occurrences(hay, term);
+    if (n > 0) {
+      hit++;
+      score += n * Math.min(term.length, 8);
+      continue;
+    }
+    // 长的中文没整个出现：看两字组合命中了多少（「软路由防污染」能搜到「软路由怎么防 DNS 污染」）
+    if (isCjk(term) && term.length >= 4) {
+      const grams = bigrams(term);
+      const found = grams.filter((g) => hay.includes(g)).length;
+      if (found / grams.length >= 0.5) {
+        hit += found / grams.length;
+        score += found;
+      }
+    }
+  }
+  if (score === 0) return 0;
+  // 所有词都命中的排前面
+  return score * (hit >= ts.length ? 2 : 1);
+}
+
+/** 截一段命中位置附近的文字 */
+function snippet(text: string, query: string, max: number): string {
+  const flat = text.replace(/\s+/g, " ").trim();
+  if (flat.length <= max) return flat;
+  const lower = flat.toLowerCase();
+  const first = terms(query)
+    .map((t) => lower.indexOf(t))
+    .filter((i) => i >= 0)
+    .sort((a, b) => a - b)[0];
+  const start = Math.max(0, Math.min((first ?? 0) - Math.floor(max / 3), flat.length - max));
+  return `${start > 0 ? "…" : ""}${flat.slice(start, start + max)}${start + max < flat.length ? "…" : ""}`;
+}
+
+export type SearchHit = { key: string; ts: number; user?: string; assistant?: string; score: number };
+
+/**
+ * 在这个用户的聊天记录里搜。结果是一问一答为单位，相关的在前（同样相关的新的在前）。
+ * skip：不要的对话（被删掉的、当前这条）。
+ */
+export function searchHistory(
+  userId: string,
+  query: string,
+  opts: { limit?: number; skip?: (key: string) => boolean; now?: number } = {},
+): SearchHit[] {
+  const records = readRecords(userId);
+  const now = opts.now ?? Date.now();
+  const scored: { i: number; score: number }[] = [];
+  records.forEach((r, i) => {
+    if (opts.skip?.(r.k)) return;
+    const s = scoreText(r.t, query);
+    if (s === 0) return;
+    // 新的稍微靠前：一个月内的最多加 30%
+    const age = Math.max(0, now - r.ts) / (30 * 86400_000);
+    scored.push({ i, score: s * (1 + 0.3 * Math.exp(-age)) });
+  });
+  scored.sort((a, b) => b.score - a.score || records[b.i]!.ts - records[a.i]!.ts);
+  const out: SearchHit[] = [];
+  const used = new Set<number>();
+  const limit = opts.limit ?? 6;
+  for (const { i, score } of scored) {
+    if (out.length >= limit) break;
+    if (used.has(i)) continue;
+    const r = records[i]!;
+    // 配上同一条对话里紧挨着的另一半：问配答，答配问
+    const pairIndex = r.r === "u" ? i + 1 : i - 1;
+    const pair = records[pairIndex];
+    const partner = pair && pair.k === r.k && pair.r !== r.r ? pair : undefined;
+    used.add(i);
+    if (partner) used.add(pairIndex);
+    const user = r.r === "u" ? r : partner;
+    const assistant = r.r === "a" ? r : partner;
+    out.push({
+      key: r.k,
+      ts: r.ts,
+      ...(user ? { user: snippet(user.t, query, 300) } : {}),
+      ...(assistant ? { assistant: snippet(assistant.t, query, 600) } : {}),
+      score,
+    });
+  }
+  return out;
+}

package/src/core/chat-mode.ts

@@ -0,0 +1,62 @@
+// 聊天模式要告诉 agent 的话，以及怎么告诉。
+//
+// 两个 agent 的「换系统提示」能力不一样（都实测过）：
+//   - Claude：系统提示每次拉起进程时整个给，换模式 = 带着新的系统提示 resume，干净利落。
+//     聊天模式就用 chatSystemPrompt 换掉 Claude Code 原装的那一大段（约 1.6 万 token）。
+//   - Codex：thread 的基础指令一旦设了就钉在 thread 上（resume 时不传就沿用，传 null 也一样），
+//     开发者指令只在 thread 开头写一次、resume 时给新的会被忽略。所以 Codex 不动它的指令，
+//     模式和记忆用 contextBlock 附在「这个会话进程的第一条消息」后面 —— 它按时间顺序进历史，
+//     模型以最新的为准。读历史、列会话时用 stripContext 把它剥掉。
+//
+// 日期写进去是因为模型不知道今天几号；它在一条会话里不变，不影响提示缓存。
+
+function today(): string {
+  const d = new Date();
+  const pad = (n: number) => String(n).padStart(2, "0");
+  const tz = Intl.DateTimeFormat().resolvedOptions().timeZone;
+  return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())}（${tz}）`;
+}
+
+/** search：这个 agent 里联网搜索 / 读网页的工具怎么称呼 */
+function chatRules(search: string): string[] {
+  return [
+    "- 用用户使用的语言回答，自然、直接、简洁；需要时用 Markdown 排版（列表、表格、代码块）。",
+    `- 涉及最新信息、新闻、价格、版本、事实核查时，先用${search}查，回答里附上来源链接；不要凭记忆编造。`,
+    "- 用户发来的图片、PDF 和文本文件内容会直接附在消息里。",
+    "- 现在是「聊天模式」：你不能执行命令，也不能读写这台机器上的文件。用户要你动手干活（写代码、改文件、跑命令、操作服务器）时，告诉他发 /work 切到工作模式，同一条对话会接着聊。",
+  ];
+}
+
+/** Claude 聊天模式的整段系统提示 */
+export function chatSystemPrompt(search: string, memory?: string): string {
+  const base = ["你是用户的私人 AI 助手，他通过 agent-loft 的网页或飞书和你聊天。", "", ...chatRules(search), "", `今天是 ${today()}。`].join("\n");
+  return memory ? `${base}\n\n${memory}` : base;
+}
+
+const OPEN = "<agent-loft-context>";
+const CLOSE = "</agent-loft-context>";
+
+/** Codex：附在会话进程第一条消息后面的背景（模式 + 记忆） */
+export function contextBlock(mode: "chat" | "work", memory: string | undefined, search: string): string {
+  const head =
+    mode === "chat"
+      ? ["当前是「聊天模式」，你作为用户的私人 AI 助手和他聊天：", ...chatRules(search)]
+      : ["当前是「工作模式」：可以执行命令、读写文件，按平常的方式干活。之前如果说过「聊天模式下不能做」，那个限制已经解除。"];
+  return [
+    OPEN,
+    "（这段是 agent-loft 自动附上的背景，不是用户写的。照着做，但不要在回复里提到它。）",
+    "",
+    ...head,
+    ...(memory ? ["", memory] : []),
+    CLOSE,
+  ].join("\n");
+}
+
+/** 剥掉 contextBlock（读历史、列会话标题时用） */
+export function stripContext(text: string): string {
+  const start = text.indexOf(OPEN);
+  if (start < 0) return text;
+  const end = text.indexOf(CLOSE, start);
+  const rest = end < 0 ? "" : text.slice(end + CLOSE.length);
+  return `${text.slice(0, start)}${rest}`.trim();
+}

package/src/core/command-catalog.ts

@@ -22,6 +22,8 @@ export const BUILTIN_COMMANDS: BuiltinSpec[] = [
   { name: "stop", description: "中断当前执行" },
   { name: "model", args: "[名称]", description: "切换模型（不带参数弹选择）" },
   { name: "effort", args: "[程度]", description: "切换思考程度" },
+  { name: "chat", description: "切到聊天模式：精简、只能联网搜索，每轮开销小很多" },
+  { name: "work", description: "切到工作模式：agent 原装的全部能力" },
   { name: "status", description: "查看当前会话、模型、目录、剩余额度" },
   { name: "sessions", args: "[all]", description: "列出历史会话，点按钮恢复；加 all 列所有目录" },
   { name: "resume", args: "<会话ID>", description: "恢复指定会话" },
@@ -34,6 +36,7 @@ export const BUILTIN_COMMANDS: BuiltinSpec[] = [
   { name: "codex", description: "切换到 Codex", multiAgentOnly: true },
   { name: "web", description: "接上一条 Web 会话，在飞书里查看和回复", feishuOnly: true },
   { name: "detach", description: "不再接着 Web 会话，回到这个聊天自己的会话", feishuOnly: true },
+  { name: "bind", args: "<绑定码>", description: "把这个飞书账号绑定到你的 agent-loft 用户（绑定码在 Web 的「设置 → 我的账号」里生成）", feishuOnly: true },
   { name: "help", description: "显示帮助" },
   { name: "approve", args: "<请求ID> allow-once|allow-always|allow-session|deny", description: "审批兜底（卡片失效时用）" },
 ];

package/src/core/commands.ts

@@ -18,6 +18,7 @@ export type ParsedCommand =
   | { kind: "status" }
   | { kind: "pwd" }
   | { kind: "autoedit"; on?: boolean }
+  | { kind: "mode"; mode: "chat" | "work" }
   | { kind: "help" }
   /** 只发了一个「/」：列出可用命令 */
   | { kind: "commands" }
@@ -69,6 +70,9 @@ export function parseCommand(raw: string): ParsedCommand {
       if (["off", "关", "0", "false"].includes(v)) return { kind: "autoedit", on: false };
       return { kind: "chat", text };
     }
+    case "chat":
+    case "work":
+      return arg ? { kind: "chat", text } : { kind: "mode", mode: head.toLowerCase() as "chat" | "work" };
     case "help":
       return { kind: "help" };
     case "approve": {

package/src/core/feishu-links.ts

@@ -0,0 +1,119 @@
+// 飞书账号 ↔ agent-loft 用户的绑定。
+//
+// 绑定之后，这个飞书账号和机器人的私聊就是这个用户的个人会话：归他所有（Web 上别人看不到），
+// 用他的记忆，/sessions 只列他的会话，/web 只能接上他自己的 Web 会话。
+// 群聊不受影响：群里不止一个人，照旧是管理员的地盘，也不用记忆。
+//
+// 绑定必须由用户本人完成：在 Web 上（已登录）生成绑定码，再用飞书在私聊里发 /bind 绑定码。
+// 两边都证明了身份，才算数。不提供「管理员直接指定」—— 那样管理员把自己的飞书绑到成员名下，
+// 就能在飞书里读到成员的记忆。管理员只能解除绑定（只会让人失去访问，不会多出访问）。
+//
+// open_id 是按飞书应用分的：同一个人在不同机器人上 open_id 不同，所以按 (机器人, open_id) 记。
+import crypto from "node:crypto";
+import path from "node:path";
+import { dataDir, readJson, writeJsonAtomic } from "../home.js";
+import { getUser, type User } from "./users.js";
+
+export type FeishuLink = { botId: string; openId: string; userId: string; boundAt: number };
+
+type Store = Record<string, Record<string, { userId: string; boundAt: number }>>;
+
+const storePath = path.join(dataDir, "feishu-links.json");
+
+function read(): Store {
+  return readJson<Store>(storePath, {});
+}
+
+const norm = (openId: string) => openId.trim().toLowerCase();
+
+/** 这个飞书账号绑定的用户（还在、没被停用的）。没绑定返回 undefined */
+export function linkedUser(botId: string, openId: string | undefined): User | undefined {
+  if (!openId) return undefined;
+  const userId = read()[botId]?.[norm(openId)]?.userId;
+  const user = getUser(userId);
+  return user && !user.disabled ? user : undefined;
+}
+
+export function listLinks(userId?: string): FeishuLink[] {
+  return Object.entries(read()).flatMap(([botId, links]) =>
+    Object.entries(links)
+      .filter(([, l]) => !userId || l.userId === userId)
+      .map(([openId, l]) => ({ botId, openId, userId: l.userId, boundAt: l.boundAt })),
+  );
+}
+
+/** 解除一个绑定。onlyUser 给了的话，只能解除属于他的 */
+export function unlink(botId: string, openId: string, onlyUser?: string): boolean {
+  const store = read();
+  const id = norm(openId);
+  const link = store[botId]?.[id];
+  if (!link || (onlyUser && link.userId !== onlyUser)) return false;
+  delete store[botId]![id];
+  if (Object.keys(store[botId]!).length === 0) delete store[botId];
+  writeJsonAtomic(storePath, store);
+  return true;
+}
+
+/** 解除这个用户的所有绑定（删用户、管理员解除时） */
+export function unlinkUser(userId: string): number {
+  const store = read();
+  let n = 0;
+  for (const [botId, links] of Object.entries(store)) {
+    for (const [openId, l] of Object.entries(links)) {
+      if (l.userId !== userId) continue;
+      delete links[openId];
+      n++;
+    }
+    if (Object.keys(links).length === 0) delete store[botId];
+  }
+  if (n > 0) writeJsonAtomic(storePath, store);
+  return n;
+}
+
+// ---------- 绑定码 ----------
+//
+// 只在内存里：十分钟有效，服务重启就作废（重新生成一个就行）。
+
+const CODE_ALPHABET = "ABCDEFGHJKLMNPQRSTUVWXYZ23456789";
+const CODE_TTL_MS = 10 * 60 * 1000;
+const codes = new Map<string, { userId: string; expiresAt: number }>();
+
+function sweep(now = Date.now()): void {
+  for (const [code, c] of codes) if (c.expiresAt <= now) codes.delete(code);
+}
+
+/** 给这个用户生成一个绑定码。之前没用掉的作废，同一时间每人只有一个 */
+export function createLinkCode(userId: string): { code: string; expiresAt: number } {
+  sweep();
+  for (const [code, c] of codes) if (c.userId === userId) codes.delete(code);
+  const code = Array.from(crypto.randomBytes(8), (b) => CODE_ALPHABET[b % CODE_ALPHABET.length]).join("");
+  const expiresAt = Date.now() + CODE_TTL_MS;
+  codes.set(code, { userId, expiresAt });
+  return { code, expiresAt };
+}
+
+/**
+ * 飞书里发了 /bind 绑定码：认领它，把 (机器人, open_id) 绑到生成这个码的用户上。
+ * 一个飞书账号只能绑一个用户，再绑就是换人（码证明了新主人的身份）。
+ */
+export function redeemLinkCode(code: string, botId: string, openId: string): User {
+  sweep();
+  const key = code.trim().toUpperCase();
+  const entry = codes.get(key);
+  if (!entry) throw new Error("绑定码不对或已过期。请在 Web 上（设置 → 我的账号）重新生成一个。");
+  const user = getUser(entry.userId);
+  if (!user || user.disabled) {
+    codes.delete(key);
+    throw new Error("生成这个绑定码的用户已经不存在或被停用了。");
+  }
+  codes.delete(key);
+  const store = read();
+  (store[botId] ??= {})[norm(openId)] = { userId: user.id, boundAt: Date.now() };
+  writeJsonAtomic(storePath, store);
+  return user;
+}
+
+/** 测试用 */
+export function resetLinkCodesForTest(): void {
+  codes.clear();
+}

package/src/core/hub.ts

@@ -25,11 +25,15 @@ import {
   type Conversation,
 } from "./store.js";
 import { attachmentInfo, clearUploads, ensureUploadsDir, KIND_LABEL } from "./uploads.js";
+import { memoryOwnerOf, sessionMemory } from "./personal.js";
+import { readMemory } from "./memory.js";
+import { getUser } from "./users.js";
 import type {
   AgentDriver,
   AttachmentInfo,
   AgentSession,
   ContextUsage,
+  ConversationMode,
   ApprovalDecision,
   HistoryMessage,
   InteractionSpec,
@@ -130,6 +134,10 @@ export type ConversationInfo = {
   forkOf?: string;
   /** 当前 agent 能不能从某条回复处分叉成新对话 */
   canFork?: boolean;
+  /** 聊天模式还是工作模式 */
+  mode: ConversationMode;
+  /** 这条对话有主人、会用上主人的记忆（主人自己关了记忆的话实际不会注入，见 personal.ts） */
+  personal?: boolean;
 };
 
 /** 普通成员点了会落盘的「总是允许」 */
@@ -433,6 +441,8 @@ class Hub extends EventEmitter<{ event: [EventEnvelope] }> {
       ...(conv.hidden ? { hidden: true } : {}),
       ...(conv.forkOf ? { forkOf: conv.forkOf } : {}),
       ...(this.drivers.get(conv.agent)?.forkAt ? { canFork: true } : {}),
+      mode: conv.mode ?? "work",
+      ...(memoryOwnerOf(conv) ? { personal: true } : {}),
     };
   }
 
@@ -478,6 +488,19 @@ class Hub extends EventEmitter<{ event: [EventEnvelope] }> {
     const holder: { session?: AgentSession } = {};
     const alive = () => this.live.get(key)?.session === holder.session;
 
+    // 记忆在拉起会话这一刻读一次：会话里 agent 自己记下的，上下文里本来就有；
+    // 用户在设置里改了，memoryChanged() 会让空闲的会话下次说话时带着新的重新拉起
+    const memory = sessionMemory(conv);
+    const mode = conv.mode ?? "work";
+    // 续着的会话上次被告知的模式和现在不一样（新会话没有历史，算原装的工作模式）
+    const announceMode = (resumeId ? (binding.announcedMode ?? "work") : "work") !== mode;
+    // 真开始一轮了才算告诉过它（/status 之类也会拉起会话，但什么都没发过去）
+    let announced = false;
+    const markAnnounced = () => {
+      if (announced) return;
+      announced = true;
+      updateAgentBinding(key, agent, { announcedMode: mode === "work" ? undefined : mode });
+    };
     const session = driver.createSession(
       {
         cwd: conv.cwd,
@@ -487,9 +510,16 @@ class Hub extends EventEmitter<{ event: [EventEnvelope] }> {
         ...(resumeId ? { resumeId } : {}),
         ...(fork ? { fork: true } : {}),
         ...(conv.autoEdit ? { autoEdit: true } : {}),
+        ...(conv.mode === "chat" ? { mode: "chat" as const } : {}),
+        ...(memory ? { memory } : {}),
+        ...(announceMode ? { announceMode: true } : {}),
       },
       {
-        onTurnStart: () => alive() && this.emitEvent(key, { type: "turn_start" }),
+        onTurnStart: () => {
+          if (!alive()) return;
+          markAnnounced();
+          this.emitEvent(key, { type: "turn_start" });
+        },
         onStep: (kind, text) => alive() && this.emitEvent(key, { type: "step", kind, text }),
         onTextDelta: (text) => alive() && this.emitEvent(key, { type: "delta", text }),
         onText: (text) => alive() && this.emitEvent(key, { type: "text", text }),
@@ -511,6 +541,7 @@ class Hub extends EventEmitter<{ event: [EventEnvelope] }> {
           this.setInflight(key, (this.inflight.get(key) ?? 1) - 1);
           this.refreshRuntimeOnce(key, liveId);
           this.syncTitle(key, agent);
+          this.dropIfStale(key);
         },
         onError: (err) => {
           if (!alive()) return;
@@ -529,6 +560,7 @@ class Hub extends EventEmitter<{ event: [EventEnvelope] }> {
             this.emitEvent(key, { type: "error", message: diagnosis.chatMessage });
           }
           this.setInflight(key, (this.inflight.get(key) ?? 1) - 1);
+          this.dropIfStale(key);
         },
         onContext: (ctx) => {
           if (!alive()) return;
@@ -979,6 +1011,91 @@ class Hub extends EventEmitter<{ event: [EventEnvelope] }> {
     return this.serial(key, () => this.setAutoEditNow(key, on));
   }
 
+  // ---------- 聊天 / 工作模式 ----------
+
+  /**
+   * /chat、/work。同一条对话、同一个 agent 会话接着聊：丢掉活着的进程，下一条消息带着新模式的
+   * 系统提示和工具 resume 回来（Claude、Codex 都实测过能接上上下文）。正在回复时不切：
+   * 丢进程会把这一轮打断。
+   */
+  private async setModeNow(key: string, mode: ConversationMode): Promise<string> {
+    const conv = getConversation(key)!;
+    if ((conv.mode ?? "work") === mode) {
+      return mode === "chat" ? "已经是💬 聊天模式了。发 /work 切到工作模式。" : "已经是🛠 工作模式了。发 /chat 切到聊天模式。";
+    }
+    if (this.isBusy(key)) return "正在回复，等这一轮结束（或者先 /stop）再切换模式。";
+    // 聊过的聊天对话切到工作模式：之后再回聊天模式就省不了了（Web 上点按钮时会先问，命令直接切，提醒一句）
+    const hadChat = mode === "work" && !!agentBinding(conv).sessionId;
+    await this.drop(key, "已切换模式");
+    updateConversation(key, { mode: mode === "chat" ? "chat" : undefined });
+    this.emitEvent(key, { type: "meta" });
+    return mode === "chat"
+      ? "已切到💬 聊天模式：精简的系统提示，只能联网搜索，不执行命令、不读写文件，每轮的开销小很多。上下文接着之前的。要动手干活时发 /work。"
+      : `已切到🛠 工作模式：${this.label(conv.agent)} 原装的全部能力（执行命令、改文件、技能、MCP）。上下文接着之前的。发 /chat 切回聊天模式。${
+          hadChat ? "\n\n提示：工作模式会在这条会话里留下一大段背景，之后再切回聊天模式就省不了多少了。干完活想回到省 token 的聊天，发 /new 开个新会话再发 /chat。" : ""
+        }`;
+  }
+
+  setMode(key: string, mode: ConversationMode): Promise<string> {
+    return this.serial(key, () => this.setModeNow(key, mode));
+  }
+
+  // ---------- 记忆变了 / 主人变了 ----------
+
+  /** 记忆过期了的会话进程（Live.id）：空闲下来就丢掉，下次说话带着新记忆重新拉起 */
+  private staleLive = new Set<number>();
+
+  private dropIfStale(key: string): void {
+    const live = this.live.get(key);
+    if (!live || !this.staleLive.has(live.id) || this.isBusy(key)) return;
+    this.staleLive.delete(live.id);
+    void this.serial(key, async () => {
+      // 排队期间可能已经换了进程、或者又开始说话了：那就留到下一轮结束
+      const now = this.live.get(key);
+      if (now?.id !== live.id) return;
+      if (this.isBusy(key)) {
+        this.staleLive.add(live.id);
+        return;
+      }
+      await this.drop(key, "记忆已更新");
+    });
+  }
+
+  /**
+   * 用户在设置里改了记忆（关于我、增删条目、开关）：他名下活着的会话都要换上新的。
+   * agent 自己用 remember / forget 改的不走这里 —— 那些本来就在上下文里，没必要重启进程、白白丢掉提示缓存。
+   */
+  memoryChanged(userId: string): void {
+    for (const [key, live] of this.live) {
+      const conv = getConversation(key);
+      if (!conv || memoryOwnerOf(conv) !== userId) continue;
+      this.staleLive.add(live.id);
+      this.dropIfStale(key);
+    }
+  }
+
+  /**
+   * 对话换主人（飞书私聊绑定 / 解绑 / 换绑账号时）。返回有没有变。
+   * 旧主人的 agent 会话不能交给新主人接着用（上下文里是旧主人的话和记忆），绑定清掉、下条消息开新的；
+   * 唯一的例外是从「没主（归管理员）」变成某个管理员自己：那些会话本来就是他能看的。
+   * 同步改记录（紧接着的消息要按新主人处理），丢进程排进串行队列。
+   */
+  reassignOwner(key: string, owner: string | undefined): boolean {
+    const conv = getConversation(key);
+    if (!conv || conv.owner === owner) return false;
+    const keep = !conv.owner && !!owner && getUser(owner)?.role === "admin";
+    const perAgent = keep
+      ? conv.perAgent
+      : Object.fromEntries(Object.entries(conv.perAgent).map(([a, b]) => [a, { ...b, sessionId: undefined, forkFrom: undefined }]));
+    updateConversation(key, { owner, perAgent });
+    void this.switchOp(key, async (op) => {
+      await this.drop(key, "对话换了主人");
+      this.markSwitched(key, op.seq);
+      this.emitEvent(key, { type: "meta" });
+    });
+    return true;
+  }
+
   /** 切 agent：各 agent 的会话各自保留，切回来接着聊。 */
   private async setAgentNow(key: string, agent: string, allowed: string[], op: SwitchOp): Promise<string> {
     const conv = getConversation(key)!;
@@ -1026,7 +1143,17 @@ class Hub extends EventEmitter<{ event: [EventEnvelope] }> {
     const driver = this.requireDriver(conv.agent);
     const runtime = await this.runtimeNow(key);
     const extra = await withTimeout(driver.statusLines(), "读取状态").catch(() => [] as string[]);
+    const memoryOwner = memoryOwnerOf(conv);
+    const memoryLine = !memoryOwner
+      ? conv.channel === "feishu"
+        ? "记忆：不用（群聊，或者没绑定账号的私聊）"
+        : "记忆：不用（这条对话没有主人）"
+      : readMemory(memoryOwner).enabled
+        ? `记忆：开（${getUser(memoryOwner)?.name ?? memoryOwner} 的）`
+        : "记忆：主人关掉了";
     return [
+      `模式：${conv.mode === "chat" ? "💬 聊天（/work 切到工作模式）" : "🛠 工作（/chat 切到聊天模式）"}`,
+      memoryLine,
       `Agent：${driver.label}`,
       `会话：${agentBinding(conv).sessionId ?? "(尚未建立)"}`,
       `目录：${conv.cwd}`,
@@ -1090,6 +1217,7 @@ class Hub extends EventEmitter<{ event: [EventEnvelope] }> {
       cwd: conv.cwd,
       ...(conv.cwdExplicit ? { cwdExplicit: true } : {}),
       ...(conv.autoEdit ? { autoEdit: true } : {}),
+      ...(conv.mode ? { mode: conv.mode } : {}),
       forkOf: key,
       perAgent: {
         [conv.agent]: {
@@ -1170,6 +1298,8 @@ class Hub extends EventEmitter<{ event: [EventEnvelope] }> {
         return text(getConversation(key)!.cwd);
       case "autoedit":
         return text(await this.setAutoEdit(key, cmd.on));
+      case "mode":
+        return text(await this.setMode(key, cmd.mode));
       case "status":
         return text(await this.status(key));
       case "cd":