agent-loft 0.2.24 → 0.2.26

package/src/core/memory-mcp.ts

@@ -0,0 +1,37 @@
+// 怎么拉起记忆工具的 MCP 服务（mcp/memory-server.ts）：Claude 和 Codex 的配置共用这一份。
+import { createRequire } from "node:module";
+import { fileURLToPath } from "node:url";
+import { home } from "../home.js";
+
+/** MCP 服务名。Claude 里工具全名是 mcp__<名>__remember，Codex 里按它自己的规则拼 */
+export const MEMORY_MCP_NAME = "agent_loft_memory";
+
+const serverPath = fileURLToPath(new URL("../mcp/memory-server.ts", import.meta.url));
+
+/** tsx 的 ESM loader：源码是 TypeScript，子进程和主进程一样靠它直接跑 */
+const tsxLoader = (() => {
+  const require = createRequire(import.meta.url);
+  // tsx/esm 的导出只有 import 条件，require.resolve 解不到；从包目录拼出来
+  const pkg = require.resolve("tsx/package.json");
+  return new URL("./dist/esm/index.mjs", `file://${pkg}`).href;
+})();
+
+export type StdioSpawn = { command: string; args: string[]; env: Record<string, string> };
+
+/**
+ * via：日志里标一下是哪个 agent 在写（方便排查），不影响写给谁。
+ * search：给不给 search_past_chats；convKey：当前这条对话，搜索时跳过它（它本来就在上下文里）。
+ */
+export function memoryMcpSpawn(userId: string, via: string, opts: { search?: boolean; convKey?: string } = {}): StdioSpawn {
+  return {
+    command: process.execPath,
+    args: ["--import", tsxLoader, serverPath],
+    env: {
+      AGENT_LOFT_HOME: home,
+      AGENT_LOFT_MEMORY_USER: userId,
+      AGENT_LOFT_MEMORY_VIA: via,
+      ...(opts.search ? { AGENT_LOFT_MEMORY_SEARCH: "1" } : {}),
+      ...(opts.convKey ? { AGENT_LOFT_MEMORY_CONV: opts.convKey } : {}),
+    },
+  };
+}

package/src/core/memory.ts

@@ -0,0 +1,311 @@
+// 记忆：agent 对「这个人」的长期了解，像 ChatGPT 的记忆那样。
+//
+// 每个用户一份，存在 data/memory/<用户 id>.json：
+//   - about：用户自己写的「关于我」；
+//   - items：一条条记住的事，用户在设置里加的，或者 agent 在对话里用 remember 工具记下的。
+// 开会话时拼成一段文字放进系统提示（见 memoryPrompt），Claude / Codex、Web / 飞书共用同一份。
+//
+// 归属跟着对话的主人走（见 memoryOwnerOf）：别人的对话里绝不注入你的记忆，也不往你的记忆里写。
+// 记忆隔离和多用户一样是「信任型」的：agent 都以同一个系统用户运行，工作模式下能读到这些文件。
+//
+// 不做内存缓存，每次都读文件：agent 的记忆工具跑在单独的进程里（见 mcp/memory-server.ts），
+// 两边都会写，读文件最简单也不会读到过期的内容。文件很小。
+import crypto from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+import { dataDir, readJson, writeJsonAtomic } from "../home.js";
+
+export type MemoryItem = {
+  id: string;
+  text: string;
+  createdAt: number;
+  updatedAt: number;
+  /** 谁记的：用户在设置里加的、agent 在对话里记的、聊完后自动整理出来的（见 memory-curator.ts） */
+  source: "user" | "agent" | "auto";
+};
+
+export type UserMemory = {
+  /** 关掉后不注入、不给记忆工具、不记聊天记录、不整理，已有的内容保留 */
+  enabled: boolean;
+  about: string;
+  items: MemoryItem[];
+  /** 什么时候、用谁整理记忆（见 memory-curator.ts） */
+  curate: CurateSettings;
+  /** 给 agent search_past_chats，能查以前的聊天 */
+  chatHistory: boolean;
+};
+
+/**
+ * 整理记忆的时机：
+ *   idle：每段对话停了 idleMinutes 分钟就整理这一段，改了什么在那条对话里说一声；
+ *   daily：每天 dailyHour 点（服务器所在时区）把当天聊过的合起来整理一次，省额度，也更容易合并重复；
+ *   manual：只在用户点「现在整理」时；
+ *   off：不整理，聊过的也不攒着。
+ */
+export type CurateWhen = "idle" | "daily" | "manual" | "off";
+
+export type CurateSettings = {
+  when: CurateWhen;
+  idleMinutes: number;
+  dailyHour: number;
+  /** auto：Claude 能用就用 Claude，否则 Codex */
+  agent: "auto" | "claude" | "codex";
+  /** 空 = 这个 agent 最省的默认（Claude 用 Haiku，Codex 用默认模型、思考程度 low） */
+  model: string;
+};
+
+export const DEFAULT_CURATE: CurateSettings = { when: "daily", idleMinutes: 30, dailyHour: 4, agent: "auto", model: "" };
+
+function cleanCurate(raw: Partial<CurateSettings> | undefined, base: CurateSettings): CurateSettings {
+  const r = raw ?? {};
+  const when = (["idle", "daily", "manual", "off"] as const).find((w) => w === r.when) ?? base.when;
+  const idle = Math.round(Number(r.idleMinutes ?? base.idleMinutes));
+  const hour = Math.round(Number(r.dailyHour ?? base.dailyHour));
+  const agent = (["auto", "claude", "codex"] as const).find((a) => a === r.agent) ?? base.agent;
+  const model = typeof r.model === "string" ? r.model.trim().slice(0, 100) : base.model;
+  return {
+    when,
+    idleMinutes: Number.isFinite(idle) ? Math.max(5, Math.min(24 * 60, idle)) : base.idleMinutes,
+    dailyHour: Number.isFinite(hour) ? Math.max(0, Math.min(23, hour)) : base.dailyHour,
+    agent,
+    // 自动选 agent 时模型跟着 agent 走，不能指定
+    model: agent === "auto" ? "" : model,
+  };
+}
+
+export const MEMORY_LIMITS = {
+  about: 2000,
+  item: 500,
+  items: 200,
+  /** 注入系统提示的记忆条目最多这么多字（新的优先），控制每轮的固定开销 */
+  promptItems: 4000,
+};
+
+const memoryDir = path.join(dataDir, "memory");
+
+/** 用户 id 只会是 users.ts 生成的那种；校验一下，免得拼出目录外的路径 */
+function fileOf(userId: string): string {
+  if (!/^[A-Za-z0-9_]{1,64}$/.test(userId)) throw new Error("用户 id 不合法");
+  return path.join(memoryDir, `${userId}.json`);
+}
+
+function empty(): UserMemory {
+  return { enabled: true, about: "", items: [], curate: { ...DEFAULT_CURATE }, chatHistory: true };
+}
+
+export function readMemory(userId: string): UserMemory {
+  const raw = readJson<Partial<UserMemory> & { autoExtract?: boolean }>(fileOf(userId), {});
+  const items = Array.isArray(raw.items)
+    ? raw.items.filter((i): i is MemoryItem => !!i && typeof i.id === "string" && typeof i.text === "string")
+    : [];
+  return {
+    enabled: raw.enabled !== false,
+    // 早先的版本只有一个「自动整理」开关：关着的就是不整理
+    curate: cleanCurate(raw.curate, raw.autoExtract === false ? { ...DEFAULT_CURATE, when: "off" } : DEFAULT_CURATE),
+    chatHistory: raw.chatHistory !== false,
+    about: typeof raw.about === "string" ? raw.about : "",
+    items: items.map((i) => ({
+      id: i.id,
+      text: i.text,
+      createdAt: Number(i.createdAt) || 0,
+      updatedAt: Number(i.updatedAt) || Number(i.createdAt) || 0,
+      source: i.source === "user" || i.source === "auto" ? i.source : "agent",
+    })),
+  };
+}
+
+function write(userId: string, memory: UserMemory): void {
+  fs.mkdirSync(memoryDir, { recursive: true, mode: 0o700 });
+  writeJsonAtomic(fileOf(userId), memory);
+}
+
+const sleepSync = (ms: number) => Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+
+/**
+ * 读—改—写之间加一把跨进程的锁：主进程（设置页、自动整理）和每个会话的记忆工具子进程都会写同一个文件，
+ * 不锁的话两边同时改，后写的那个会把先写的冲掉（新记的一条、刚保存的「关于我」悄悄没了）。
+ * 用 O_EXCL 建锁文件；持锁的进程被杀了留下的锁，5 秒后当作废。改动都是毫秒级的，等不到 3 秒就报错。
+ */
+function locked<T>(userId: string, fn: (memory: UserMemory) => T): T {
+  const lock = `${fileOf(userId)}.lock`;
+  fs.mkdirSync(memoryDir, { recursive: true, mode: 0o700 });
+  const deadline = Date.now() + 3000;
+  for (;;) {
+    try {
+      fs.writeFileSync(lock, String(process.pid), { flag: "wx", mode: 0o600 });
+      break;
+    } catch (err) {
+      if ((err as NodeJS.ErrnoException).code !== "EEXIST") throw err;
+      try {
+        if (Date.now() - fs.statSync(lock).mtimeMs > 5000) {
+          fs.rmSync(lock, { force: true });
+          continue;
+        }
+      } catch {
+        continue; // 刚好被释放了
+      }
+      if (Date.now() > deadline) throw new Error("记忆文件正被别处修改，稍后再试");
+      sleepSync(15);
+    }
+  }
+  try {
+    return fn(readMemory(userId));
+  } finally {
+    fs.rmSync(lock, { force: true });
+  }
+}
+
+function cleanText(text: unknown, max: number, what: string): string {
+  const t = typeof text === "string" ? text.trim() : "";
+  if (t.length > max) throw new Error(`${what}最多 ${max} 个字`);
+  return t;
+}
+
+const normalize = (t: string) => t.replace(/\s+/g, " ").trim().toLowerCase();
+
+function newItemId(): string {
+  return `m_${crypto.randomBytes(3).toString("hex")}`;
+}
+
+export function setMemoryOptions(
+  userId: string,
+  patch: { enabled?: boolean; about?: string; curate?: Partial<CurateSettings>; chatHistory?: boolean },
+): UserMemory {
+  // 先校验再上锁：内容不合规直接报错，不白占锁
+  const about = patch.about !== undefined ? cleanText(patch.about, MEMORY_LIMITS.about, "「关于我」") : undefined;
+  return locked(userId, (memory) => {
+    if (typeof patch.enabled === "boolean") memory.enabled = patch.enabled;
+    if (patch.curate) memory.curate = cleanCurate(patch.curate, memory.curate);
+    if (typeof patch.chatHistory === "boolean") memory.chatHistory = patch.chatHistory;
+    if (about !== undefined) memory.about = about;
+    write(userId, memory);
+    return memory;
+  });
+}
+
+export type AddResult = { item: MemoryItem; created: boolean; evicted?: MemoryItem };
+
+/**
+ * 记一条。内容一样的（忽略空白和大小写）不重复记，只更新时间（created: false）。
+ * 满了就挤掉最久没更新的那条不是用户自己加的（agent 记的、自动整理的），挤掉的那条在 evicted 里；
+ * 全是用户自己加的就报错。
+ */
+export function addMemoryEntry(userId: string, text: string, source: MemoryItem["source"]): AddResult {
+  const t = cleanText(text, MEMORY_LIMITS.item, "一条记忆");
+  if (!t) throw new Error("记忆内容不能为空");
+  return locked(userId, (memory) => {
+    const now = Date.now();
+    const same = memory.items.find((i) => normalize(i.text) === normalize(t));
+    if (same) {
+      same.updatedAt = now;
+      write(userId, memory);
+      return { item: same, created: false };
+    }
+    let evicted: MemoryItem | undefined;
+    if (memory.items.length >= MEMORY_LIMITS.items) {
+      evicted = memory.items.filter((i) => i.source !== "user").sort((a, b) => a.updatedAt - b.updatedAt)[0];
+      if (!evicted) throw new Error(`记忆已经有 ${MEMORY_LIMITS.items} 条了，先删掉一些`);
+      memory.items = memory.items.filter((i) => i !== evicted);
+    }
+    const item: MemoryItem = { id: newItemId(), text: t, createdAt: now, updatedAt: now, source };
+    memory.items.push(item);
+    write(userId, memory);
+    return { item, created: true, ...(evicted ? { evicted } : {}) };
+  });
+}
+
+/** 记一条，只要结果 */
+export function addMemoryItem(userId: string, text: string, source: MemoryItem["source"]): MemoryItem {
+  return addMemoryEntry(userId, text, source).item;
+}
+
+export function updateMemoryItem(userId: string, id: string, text: string): MemoryItem {
+  const t = cleanText(text, MEMORY_LIMITS.item, "一条记忆");
+  if (!t) throw new Error("记忆内容不能为空");
+  return locked(userId, (memory) => {
+    const item = memory.items.find((i) => i.id === id);
+    if (!item) throw new Error("这条记忆不存在");
+    item.text = t;
+    item.updatedAt = Date.now();
+    write(userId, memory);
+    return item;
+  });
+}
+
+/** 删一条。返回删掉的那条，没有就返回 undefined */
+export function removeMemoryItem(userId: string, id: string): MemoryItem | undefined {
+  return locked(userId, (memory) => {
+    const item = memory.items.find((i) => i.id === id);
+    if (!item) return undefined;
+    memory.items = memory.items.filter((i) => i !== item);
+    write(userId, memory);
+    return item;
+  });
+}
+
+/**
+ * 清空：「关于我」和所有条目都删掉，开关和整理设置保留 —— 关着记忆的人清空之后不能变成开着。
+ * 管理员清空成员的记忆也走这里。
+ */
+export function clearMemory(userId: string): void {
+  locked(userId, (memory) => write(userId, { ...memory, about: "", items: [] }));
+}
+
+/** 删用户时：整个文件删掉 */
+export function deleteMemory(userId: string): void {
+  fs.rmSync(fileOf(userId), { force: true });
+}
+
+// ---------- 注入系统提示 ----------
+
+/** 本地日期 YYYY-MM-DD（记忆条目、整理、搜索结果都用它） */
+export function localDate(ts: number): string {
+  const d = new Date(ts);
+  const pad = (n: number) => String(n).padStart(2, "0");
+  return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())}`;
+}
+
+/** 系统提示里怎么称呼记忆工具：两个 agent 给 MCP 工具起的全名不一样，只说短名 */
+export const MEMORY_TOOL_NAMES = { remember: "remember", forget: "forget", search: "search_past_chats" } as const;
+
+/**
+ * 拼进系统提示的一段文字。记忆关着就返回 undefined（也不该给记忆工具）。
+ * 条目按最近更新排，超出字数预算的旧条目不放进来（它们还在，只是这次没带上）。
+ */
+export function memoryPrompt(userId: string): string | undefined {
+  const memory = readMemory(userId);
+  if (!memory.enabled) return undefined;
+  const lines: string[] = [
+    "# 关于这位用户",
+    "",
+    "下面是你对这位用户的长期了解：有的是他自己写的，有的是之前的对话里记下的。自然地用上，让回答更贴合他；不要逐条复述，也不要每次都提「我记得」。和当前对话冲突时以当前对话为准。",
+  ];
+  if (memory.about.trim()) lines.push("", "## 他的自我介绍", "", memory.about.trim());
+  const sorted = [...memory.items].sort((a, b) => b.updatedAt - a.updatedAt);
+  const kept: MemoryItem[] = [];
+  let budget = MEMORY_LIMITS.promptItems;
+  for (const item of sorted) {
+    if (item.text.length > budget) break;
+    budget -= item.text.length;
+    kept.push(item);
+  }
+  if (kept.length > 0) {
+    lines.push("", "## 记住的事", "");
+    for (const item of kept) lines.push(`- [${item.id}] ${localDate(item.updatedAt)}：${item.text}`);
+    if (kept.length < sorted.length) lines.push(`- （还有 ${sorted.length - kept.length} 条较早的记忆这次没有带上）`);
+  }
+  lines.push(
+    "",
+    "## 记忆工具",
+    "",
+    `- 用户让你记住什么，或者你发现了以后长期有用的信息（身份、偏好、习惯、长期在做的事、做过的重要决定），用 ${MEMORY_TOOL_NAMES.remember} 记一条：一句话、写清主语和时间背景。记完在回复里顺口说一句「已记住：…」。`,
+    `- 记忆过时了、记错了，或者用户让你忘掉，用 ${MEMORY_TOOL_NAMES.forget}（给上面方括号里的 id）。更新一件事就先 forget 旧的再 remember 新的。`,
+    "- 不要记密码、密钥、验证码、证件号这类敏感信息，也不要记一次性的琐事和当前任务的细节。",
+    ...(memory.chatHistory
+      ? [
+          `- 用户提到以前聊过的事（「上次说的那个……」「我之前问过……」），或者你需要他以前说过的细节，用 ${MEMORY_TOOL_NAMES.search} 搜他以前的聊天（关键词搜索，换几个说法多搜几次）。`,
+        ]
+      : []),
+  );
+  return lines.join("\n");
+}

package/src/core/personal.ts

@@ -0,0 +1,44 @@
+// 「这条对话是谁的」在个人数据（记忆、飞书绑定）上的落点。
+import { deleteMemory, memoryPrompt, readMemory } from "./memory.js";
+import { purgeHistory } from "./chat-history.js";
+import { unlinkUser } from "./feishu-links.js";
+import type { Conversation } from "./store.js";
+import { getUser, legacyOwnerId } from "./users.js";
+
+/**
+ * 这条对话该用谁的记忆。比会话列表的归属规则（users.ts 的 ownedBy）更严：
+ *   - 有主人的，就是主人 —— 主人被删了、停用了，谁的都不用（不像会话那样转给管理员：
+ *     别人的个人档案混进管理员的记忆里，agent 会突然以为自己在跟另一个人说话）；
+ *   - 升级前就有的 Web 会话没记主人，算迁移出来的那个管理员的（和推送订阅同一个规则）；
+ *   - 飞书群聊、没绑定账号的飞书私聊：没有主人，不用记忆。群里不止一个人，没绑定的人身份不明。
+ */
+export function memoryOwnerOf(conv: Pick<Conversation, "owner" | "channel">): string | undefined {
+  if (conv.owner) {
+    const user = getUser(conv.owner);
+    return user && !user.disabled ? user.id : undefined;
+  }
+  return conv.channel === "web" ? legacyOwnerId() : undefined;
+}
+
+/** 开会话时交给 agent 的记忆（SessionOptions.memory）。没主人或者主人关了记忆就是 undefined */
+export function sessionMemory(
+  conv: Pick<Conversation, "owner" | "channel"> & { key?: string },
+): { userId: string; prompt: string; search?: boolean; convKey?: string } | undefined {
+  const userId = memoryOwnerOf(conv);
+  if (!userId) return undefined;
+  const prompt = memoryPrompt(userId);
+  if (!prompt) return undefined;
+  return {
+    userId,
+    prompt,
+    ...(readMemory(userId).chatHistory ? { search: true } : {}),
+    ...(conv.key ? { convKey: conv.key } : {}),
+  };
+}
+
+/** 删用户时一起删掉的个人数据：记忆、聊天记录索引和飞书绑定 */
+export function purgeUserData(userId: string): void {
+  deleteMemory(userId);
+  purgeHistory(userId);
+  unlinkUser(userId);
+}

package/src/core/scheduled.ts

@@ -0,0 +1,113 @@
+// 定时发送：额度用完了、要等刷新才能接着干活时，先把下一条消息排好，到点由服务端替用户发出去。
+//
+// 放在服务端而不是页面里：到点时浏览器可能早关了。落盘在 data/scheduled.json，重启后接着等；
+// 服务停着的那段时间里到点的，启动后立刻补发。只支持纯文字（附件是临时上传的，放不了那么久）。
+import crypto from "node:crypto";
+import path from "node:path";
+import { dataDir, readJson, writeJsonAtomic } from "../home.js";
+
+export type ScheduledMessage = {
+  id: string;
+  key: string;
+  text: string;
+  /** 什么时候发（毫秒时间戳） */
+  at: number;
+  createdAt: number;
+};
+
+/** 每条对话最多排几条 */
+export const SCHEDULED_MAX = 20;
+
+const storePath = path.join(dataDir, "scheduled.json");
+let cache: ScheduledMessage[] | null = null;
+let timer: NodeJS.Timeout | null = null;
+let fire: ((m: ScheduledMessage) => void) | null = null;
+
+function load(): ScheduledMessage[] {
+  cache ??= readJson<ScheduledMessage[]>(storePath, []).filter((m) => m && typeof m.text === "string" && Number.isFinite(m.at));
+  return cache;
+}
+
+function save(): void {
+  writeJsonAtomic(storePath, load());
+}
+
+export function listScheduled(key: string): ScheduledMessage[] {
+  return load()
+    .filter((m) => m.key === key)
+    .sort((a, b) => a.at - b.at);
+}
+
+export function addScheduled(key: string, text: string, at: number): ScheduledMessage {
+  if (!text.trim()) throw new Error("定时发送的内容不能为空");
+  if (!Number.isFinite(at)) throw new Error("时间不对");
+  if (listScheduled(key).length >= SCHEDULED_MAX) throw new Error(`这条对话最多排 ${SCHEDULED_MAX} 条定时消息`);
+  const item: ScheduledMessage = { id: crypto.randomBytes(6).toString("hex"), key, text, at, createdAt: Date.now() };
+  load().push(item);
+  save();
+  arm();
+  return item;
+}
+
+export function removeScheduled(key: string, id: string): boolean {
+  const list = load();
+  const i = list.findIndex((m) => m.id === id && m.key === key);
+  if (i < 0) return false;
+  list.splice(i, 1);
+  save();
+  arm();
+  return true;
+}
+
+/** 对话被删 / 换了主人之类：把它排着的全清掉 */
+export function clearScheduled(key: string): void {
+  const list = load();
+  const kept = list.filter((m) => m.key !== key);
+  if (kept.length === list.length) return;
+  cache = kept;
+  save();
+  arm();
+}
+
+/** 定时器只挂最近的那一条；setTimeout 最长约 24.8 天，更远的先睡到上限再重新算 */
+function arm(): void {
+  if (timer) clearTimeout(timer);
+  timer = null;
+  if (!fire) return;
+  const next = load().reduce<number | null>((min, m) => (min === null || m.at < min ? m.at : min), null);
+  if (next === null) return;
+  const delay = Math.min(Math.max(next - Date.now(), 0), 2 ** 31 - 1);
+  timer = setTimeout(tick, delay);
+  timer.unref();
+}
+
+function tick(): void {
+  timer = null;
+  const now = Date.now();
+  const list = load();
+  const due = list.filter((m) => m.at <= now).sort((a, b) => a.at - b.at);
+  if (due.length) {
+    cache = list.filter((m) => m.at > now);
+    save();
+    for (const m of due) {
+      try {
+        fire?.(m);
+      } catch (err) {
+        console.error(`[定时发送] ${m.key} 发送失败:`, err instanceof Error ? err.message : err);
+      }
+    }
+  }
+  arm();
+}
+
+/** 启动调度。onFire 负责真正把消息发出去（由 main.ts 接到 hub 上，这里不依赖 hub） */
+export function startScheduler(onFire: (m: ScheduledMessage) => void): void {
+  fire = onFire;
+  arm();
+}
+
+export function stopScheduler(): void {
+  fire = null;
+  if (timer) clearTimeout(timer);
+  timer = null;
+}

package/src/core/store.ts

@@ -19,6 +19,11 @@ export type AgentBinding = {
    * 拿到不同于它的新会话 id 后清掉。
    */
   forkFrom?: string;
+  /**
+   * 上次告诉这个 agent 会话的是哪种模式（没有 = 工作模式，agent 原装的样子）。和对话现在的模式不一样，
+   * 就要在下一条消息里说一声（Codex 换不了系统提示，见 core/chat-mode.ts）。
+   */
+  announcedMode?: "chat" | "work";
 };
 
 export type Conversation = {
@@ -48,10 +53,12 @@ export type Conversation = {
   /** 从哪条对话分叉出来的（对话 key），列表里据此显示关联 */
   forkOf?: string;
   /**
-   * 谁的对话（用户 id，见 core/users.ts）。Web 上新建 / 分叉时记下；
-   * 飞书会话和升级前就有的 Web 会话没有，归管理员。
+   * 谁的对话（用户 id，见 core/users.ts）。Web 上新建 / 分叉时记下；飞书私聊在发消息的人绑定了
+   * 账号时记下（见 core/feishu-links.ts）。飞书群聊、没绑定的私聊和升级前就有的 Web 会话没有，归管理员。
    */
   owner?: string;
+  /** chat：聊天模式（/chat）。没有就是工作模式。属于对话，跨 /new 和切 agent 保留 */
+  mode?: "chat";
 };
 
 type StoreShape = Record<string, Conversation>;

package/src/core/types.ts

@@ -172,8 +172,26 @@ export type SessionOptions = {
   uploadsDir: string;
   /** 工作目录内改文件不再询问（/autoedit）。Bash 等照常询问 */
   autoEdit?: boolean;
+  /**
+   * chat：聊天模式 —— 换成精简的系统提示，只留联网搜索，不加载技能 / MCP / 插件，不能执行命令、
+   * 不能读写本地文件，每轮的固定开销小得多。不给就是 work（agent 原装的样子）。
+   */
+  mode?: ConversationMode;
+  /** 这条对话主人的记忆：prompt 拼进系统提示，userId 交给记忆工具（记给谁由这里定死） */
+  memory?: {
+    userId: string;
+    prompt: string;
+    /** 给不给搜以前聊天的工具（用户在记忆设置里开着「参考以前的聊天」） */
+    search?: boolean;
+    /** 当前对话，搜索时跳过 */
+    convKey?: string;
+  };
+  /** 模式换过、这个 agent 会话还不知道：换不了系统提示的 agent（Codex）要在第一条消息里说一声 */
+  announceMode?: boolean;
 };
 
+export type ConversationMode = "chat" | "work";
+
 export interface AgentSession {
   readonly sessionId: string | undefined;
   send(input: UserInput): void;
@@ -227,4 +245,20 @@ export interface AgentDriver {
   /** 账号额度，侧栏显示用；读不到 / 没有订阅额度时返回 null */
   quota?(): Promise<QuotaInfo | null>;
   diagnose(err: unknown): Diagnosis;
+  /**
+   * 一次性的后台调用（聊完后整理记忆用）：不留会话记录、不用任何工具，按 schema 返回 JSON。
+   * 用最便宜的模型。不支持的 agent 不实现。
+   */
+  complete?(req: CompleteRequest): Promise<unknown>;
 }
+
+export type CompleteRequest = {
+  system: string;
+  prompt: string;
+  /** JSON Schema（顶层是 object，所有对象都 additionalProperties: false、字段全部 required —— 两家都能吃） */
+  schema: Record<string, unknown>;
+  /** 用哪个模型；不给就用这个 agent 最省的（Claude 用 Haiku，Codex 用默认模型、思考程度 low） */
+  model?: string;
+  /** 超时，毫秒 */
+  timeoutMs?: number;
+};

package/src/core/uploads.ts

@@ -242,10 +242,14 @@ export function uploadKeyOf(file: string): string | undefined {
   }
 }
 
-/** 附件清单的文字说明，两个 agent 都用它告诉模型文件在哪。 */
+/**
+ * 附件清单的文字说明，两个 agent 都用它告诉模型文件在哪。
+ * chat：聊天模式，agent 没有读文件的工具 —— 没能放进消息里的附件要说清楚读不了。
+ */
 export function describeAttachments(
   saved: SavedAttachment[],
   inlined: (a: SavedAttachment) => boolean,
+  chat = false,
 ): string {
   const counters: Partial<Record<AttachmentKind, number>> = {};
   const lines = saved.map((a) => {
@@ -253,9 +257,58 @@ export function describeAttachments(
     const details = [
       formatSize(a.size),
       ...(a.durationMs ? [`时长 ${Math.round(a.durationMs / 1000)} 秒`] : []),
-      ...(inlined(a) ? ["内容已附在本消息中"] : []),
+      ...(inlined(a) ? ["内容已附在本消息中"] : chat ? ["聊天模式下读不了这个文件"] : []),
     ];
     return `- ${KIND_LABEL[a.kind]}${n}：${a.path}（${details.join("，")}）`;
   });
-  return ["[用户发来了以下附件，已保存到本地，需要时可以直接读取或处理这些文件]", ...lines].join("\n");
+  const head = chat
+    ? "[用户发来了以下附件。现在是聊天模式，没有读文件的工具：读不了的附件请告诉用户发 /work 切到工作模式再处理]"
+    : "[用户发来了以下附件，已保存到本地，需要时可以直接读取或处理这些文件]";
+  return [head, ...lines].join("\n");
+}
+
+// ---------- 聊天模式：文本附件直接放进消息 ----------
+//
+// 聊天模式不给 agent 读本地文件的工具（它能联网，能读文件就能被网页里的提示注入骗着把文件内容带出去），
+// 所以文本类的附件由我们读出来，跟着消息一起发过去。
+
+const TEXT_EXT =
+  /\.(txt|md|markdown|csv|tsv|json|jsonl|log|ya?ml|toml|ini|conf|cfg|xml|html?|css|js|mjs|cjs|ts|tsx|jsx|py|rb|go|rs|java|kt|swift|c|h|cc|cpp|hpp|cs|php|sh|bash|zsh|ps1|sql|srt|vtt|tex)$/i;
+const INLINE_TEXT_MAX = 200 * 1024;
+
+/** 能直接放进消息的文本附件，读出内容；不是文本、太大、读不了（比如已被清理）的返回 undefined，不抛错 */
+export function readTextAttachment(a: SavedAttachment): string | undefined {
+  if (a.kind !== "file" || a.size > INLINE_TEXT_MAX) return undefined;
+  if (!a.mediaType?.startsWith("text/") && !TEXT_EXT.test(a.name)) return undefined;
+  let buf: Buffer;
+  try {
+    buf = fs.readFileSync(a.path);
+  } catch {
+    return undefined;
+  }
+  // 有 NUL 字节的多半是二进制，扩展名骗人
+  if (buf.includes(0)) return undefined;
+  return buf.toString("utf8");
+}
+
+/** 一条消息里所有能放进来的文本附件：路径 → 内容。每个文件只读一次 */
+export function readTextAttachments(saved: SavedAttachment[]): Map<string, string> {
+  const out = new Map<string, string>();
+  for (const a of saved) {
+    const content = readTextAttachment(a);
+    if (content !== undefined) out.set(a.path, content);
+  }
+  return out;
+}
+
+/** 文本附件的内容，接在附件清单后面。没有就返回空串 */
+export function inlineTextBlocks(saved: SavedAttachment[], texts: Map<string, string>): string {
+  const parts: string[] = [];
+  for (const a of saved) {
+    const content = texts.get(a.path);
+    if (content === undefined) continue;
+    const fence = content.includes("```") ? "~~~~" : "```";
+    parts.push(`附件「${a.name}」的内容：\n${fence}\n${content}\n${fence}`);
+  }
+  return parts.join("\n\n");
 }