agent-loft 0.2.23 → 0.2.25

package/README.md

@@ -46,7 +46,7 @@ Logo 就是这个意思：一大两小几颗星（多个 agent）站在同一张
   - 语音输入：用浏览器自带的语音识别（Chrome / Edge / Safari，需要 HTTPS）。
   - 新对话页：点大标题里的目录名，在目录树里逐层选工作目录；输入框上方选 agent，右下角选模型和思考程度。会话进行中用 `/agent` 切换 agent，模型和思考程度随时可换。
   - 输入框里的小圆环显示上下文窗口占用；模型按钮显示实际的模型和思考程度（如「Opus 5.5 high」）。
-  - 侧栏分「最近」和「项目」两组：Web 会话按工作目录归类，飞书机器人各占一行（右键看历史会话）；分叉出来的会话用虚线挂在原会话下面；会话标题由 agent 自动生成，双击重命名。
+  - 侧栏分「最近」和「项目」两组：Web 会话按工作目录归类（目录可以拖动排序，右键可置顶），飞书机器人各占一行（右键看历史会话）；分叉出来的会话用虚线挂在原会话下面；会话标题由 agent 自动生成，双击重命名。
   - 侧栏底部显示 Claude / Codex 的订阅额度（5 小时 / 7 天窗口，以及多久后重置）。
   - 「添加到主屏幕」后当 App 用；切到后台再回来会自动重连，补上错过的内容。
 - **系统通知**：Web 会话回复完成、出错、需要授权或提问时推送到手机 / 电脑（设置 → 通知 → 「在此设备开启通知」，可以发测试通知）。飞书会话由飞书提醒，正在前台看着的会话不推。需要 HTTPS 访问，iPhone 需 iOS 16.4+ 且从主屏幕图标打开。
@@ -54,6 +54,9 @@ Logo 就是这个意思：一大两小几颗星（多个 agent）站在同一张
 - **授权**：允许一次 / 本会话全部允许 / 总是允许（按钮上写明放行范围）/ 拒绝。`/autoedit on` 让 Claude Code 在这条会话里改工作目录内的文件不再询问（Bash 仍询问）。超时一律按拒绝处理。
 - **设置都在网页上**：工作目录、会话闲置过期时间、局域网访问和端口、各 agent 的默认模型和思考程度、可选模型、Codex 沙箱、飞书机器人、配对批准、Claude 的「总是允许」名单、通知设备、登录设备管理、用户管理、服务端升级。
 - **多用户**（信任型）：管理员在 设置 → 用户 里给别人建账号。每个人只看得到自己的对话、授权和通知，设置只有管理员能改，见下面「安全」。
+- **聊天模式 / 工作模式**：输入框右下角的「💬 聊天 / 🛠 工作」，或者发 `/chat`、`/work`，同一条对话随时切换、上下文接着。聊天模式换成精简的系统提示，只留联网搜索，不加载技能、MCP、插件，不执行命令、不读写本机文件（文本附件的内容直接放进消息），每轮的固定开销小得多：实测一句话 Claude 约 1.6 万 → 2 千 token，Codex 约 2 万 → 1.2 万（Codex 的基础指令改不了）。适合日常聊天、查资料；要动手干活时切回工作模式。切换后第一轮要重建提示缓存，会贵一些；在工作模式里读过的大段内容还留在历史里。
+- **记忆**：像 ChatGPT 的记忆，设置 → 记忆。「关于我」加上一条条记住的事，每次对话都带上；agent 在聊天里遇到长期有用的信息会自己用 `remember` 记一条（回复里会说），记错了用 `forget` 删。**自动整理**：把上次整理之后新说的话交给模型（不留会话记录的一次性调用），补充、更新或删掉过时的记忆，用户自己加的条目它不动。什么时候整理每个人自己定：每天一次（默认凌晨 4 点，把当天的对话合起来一次整理，最省）／每段对话聊完后（停多久可选，改了什么会在对话里说一声）／只在点「现在整理」时／不整理；用哪个 agent 的哪个模型也能选，默认 Claude Haiku，没有 Claude 就用 Codex 的默认模型、思考程度 low。**参考以前的聊天**：agent 遇到「上次说的那个……」会用 `search_past_chats` 搜你以前的对话（关键词搜索，只有你自己的、没被删掉的对话；第一次用时会把已有对话收录进来）。两项都能在设置里单独关。每个用户一份，Claude 和 Codex、Web 和飞书共用。只用在有主人的对话里：你的 Web 对话，以及绑定了飞书账号后和机器人的私聊；飞书群聊不用。别人（包括管理员）看不到你的记忆，管理员只能清空它；删用户时记忆一起删，不转给管理员。
+- **飞书账号绑定**：设置 → 账号 → 飞书账号 →「生成绑定码」，再在飞书私聊机器人发 `/bind 绑定码`（10 分钟内有效，群里发不算）。绑定后这个私聊就是你的个人会话：用你的记忆，`/sessions` 只列你的会话，`/web` 只能接上你自己的 Web 会话，管理员在 Web 上也看不到它。必须本人在两边各操作一次，管理员不能替人绑定（只能解除），否则就能借飞书读到别人的记忆。
 
 ## 安装
 
@@ -89,6 +92,15 @@ agent-loft service install        # 注册为开机自启服务（systemd / laun
 
 桌面端只是个壳（代码在 `desktop/`），服务端照常用 npm 安装和升级。
 
+桌面端一键安装的服务端放在 `~/.local`，无需管理员权限，也不修改 npm 的全局配置。如果旧版桌面端安装时出现 `EACCES /usr/local/lib/node_modules/agent-loft`，可以先在终端执行：
+
+```bash
+npm install -g --prefix "$HOME/.local" agent-loft
+PATH="$HOME/.local/bin:$PATH" "$HOME/.local/bin/agent-loft" service install
+```
+
+第一条成功后再执行第二条，然后重新打开桌面端，选择连接本机服务端即可。需要 Node.js 22 以上。
+
 ### 从旧桥接器迁移
 
 ```bash
@@ -114,7 +126,7 @@ agent-loft service install
 
 `aloft` 是 `agent-loft` 的简写。
 
-聊天里的命令（飞书和 Web 通用；Web 输入框打 `/` 会弹出命令补全，飞书里打 `/` 会弹出机器人的指令面板（agent-loft 自动注册，约 5～8 分钟生效；只发一个 `/` 也会回一张可点击的命令卡片），顺序和显示项在 设置 → 命令 里调整）：`/new` `/fork` `/sessions [all]` `/resume <id>` `/model [名称]` `/effort <程度>` `/agent [名称]`（或者直接发 `/claude`、`/codex`）`/stop` `/cd <目录>` `/pwd` `/status` `/autoedit [on|off]` `/approve <id> allow-once|allow-always|allow-session|deny` `/help`；只在飞书里有的：`/web` `/detach`
+聊天里的命令（飞书和 Web 通用；Web 输入框打 `/` 会弹出命令补全，飞书里打 `/` 会弹出机器人的指令面板（agent-loft 自动注册，约 5～8 分钟生效；只发一个 `/` 也会回一张可点击的命令卡片），顺序和显示项在 设置 → 命令 里调整）：`/new` `/fork` `/sessions [all]` `/resume <id>` `/model [名称]` `/effort <程度>` `/agent [名称]`（或者直接发 `/claude`、`/codex`）`/stop` `/cd <目录>` `/pwd` `/status` `/autoedit [on|off]` `/approve <id> allow-once|allow-always|allow-session|deny` `/chat` `/work` `/help`；只在飞书里有的：`/web` `/detach` `/bind <绑定码>`
 
 自定义命令：设置 → 命令 → 「添加命令」，填命令名、说明和一段提示词，之后发 `/命令名 参数` 就会把这段提示词发给 agent（提示词里的 `$ARGUMENTS` 换成参数，没写就把参数接在后面）。按 agent 分开存，可以编辑、删除，也会同步到飞书指令面板。
 
@@ -123,12 +135,13 @@ agent-loft service install
 这个服务能让 agent 在你的机器上执行命令，等于一个远程 shell。
 
 - Web 登录密码用 scrypt 哈希保存。首次建管理员必须用启动日志里的一次性设置码，防止「谁先打开页面谁就成了主人」。
-- 多用户只隔开**界面上**的东西：会话列表、授权 / 提问卡、通知、`/sessions` 能列出和恢复的 agent 会话；设置、飞书机器人和飞书会话只给管理员；会落盘、对所有人生效的「总是允许」（Claude 的总是允许名单、Codex 的 execpolicy）只有管理员能点。**它不是安全边界**：所有 agent 都以同一个系统用户运行，任何用户都能让 agent 读到这台机器上的文件（别人的对话记录、配置里的密钥），用的也是同一个 Claude / Codex 订阅。只给信任的人开账号；要真正隔离，就每人用自己的系统用户各跑一份 agent-loft。
+- 多用户只隔开**界面上**的东西：会话列表、授权 / 提问卡、通知、记忆、`/sessions` 能列出和恢复的 agent 会话；设置、飞书机器人和飞书会话只给管理员（绑定了账号的飞书私聊除外，它归绑定的人）；会落盘、对所有人生效的「总是允许」（Claude 的总是允许名单、Codex 的 execpolicy）只有管理员能点。**它不是安全边界**：所有 agent 都以同一个系统用户运行，任何用户都能让 agent 读到这台机器上的文件（别人的对话记录、配置里的密钥），用的也是同一个 Claude / Codex 订阅。只给信任的人开账号；要真正隔离，就每人用自己的系统用户各跑一份 agent-loft。
 - 从老版本升级：原来的登录密码自动变成管理员 `admin`，已登录的设备不用重新登录。
 - 登录态通过 HttpOnly cookie 保存，服务端只存它的哈希。同一 IP 连续输错 5 次锁 15 分钟。所有写请求和 WebSocket 都校验 Origin。页面开启了严格的 CSP。
 - 暴露到公网时，只通过 HTTPS 反向代理（比如 Lucky）或 Cloudflare Tunnel 访问，并把不在本机的反代 IP 加进 `web.trustedProxies`（只有从这些地址来的连接才采信 `X-Forwarded-*`）。不要直接把 8800 端口映射出去。局域网访问可以在 设置 → 系统 → 网络访问 里关掉。
 - 审批超时一律按拒绝处理。Codex 默认沙箱为 `workspace-write`，不会因为 `~/.codex/config.toml` 里配了 `never` 或 `danger-full-access` 就绕过审批。
 - agent 子进程拿不到本服务自己的凭据（`FEISHU_*`、`AGENT_LOFT_*` 等环境变量会被剔除）。
+- 记忆存在 `data/memory/<用户 id>.json`，聊天记录索引在 `data/history/<用户 id>.jsonl`。记给谁由 agent-loft 在拉起记忆工具时定死（工具参数里没有用户），模型想写别人的记忆也写不了；但和多用户一样不是安全边界：工作模式下 agent 能读到这些文件。聊天模式没有读写本机文件的工具，网页里的提示注入也骗不走本机文件。
 
 ## 结构
 
@@ -140,7 +153,14 @@ src/
     store.ts       会话持久化（每个 agent 的会话 id 各自保存）
     config.ts      配置（Web 可改，改完热加载）
     users.ts       Web 登录用户和归属规则（谁能看到哪条会话）
+    memory.ts      记忆的存储和注入系统提示的那段文字；personal.ts 定记忆用谁的
+    chat-history.ts 聊天记录索引（每人一个 JSONL）和关键词搜索
+    memory-curator.ts 录入聊天、回填已有对话、聊完后自动整理记忆
+    feishu-links.ts 飞书账号 ↔ 用户的绑定和绑定码
+    chat-mode.ts   聊天模式告诉 agent 的话（Claude 换系统提示，Codex 附在消息后面）
     pairing.ts uploads.ts commands.ts …
+  mcp/
+    memory-server.ts 记忆工具（remember / forget / search_past_chats）的 stdio MCP 服务，两个 agent 共用
   agents/
     claude/        Claude Agent SDK 驱动
     codex/         codex app-server 驱动

package/package.json

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

package/src/agents/claude/driver.ts

@@ -7,7 +7,9 @@ import {
   getSessionInfo,
   getSessionMessages,
   listSessions,
+  query,
 } from "@anthropic-ai/claude-agent-sdk";
+import { agentEnvironment } from "../../core/agent-env.js";
 import os from "node:os";
 import type { AgentCommand } from "../../core/command-catalog.js";
 import { splitAttachmentNote } from "../../core/uploads.js";
@@ -16,6 +18,7 @@ import type {
   AgentDriver,
   AgentEvents,
   AgentSession,
+  CompleteRequest,
   HistoryMessage,
   InteractionHost,
   ModelInfo,
@@ -228,6 +231,44 @@ export class ClaudeDriver implements AgentDriver {
     return toQuota(await readUsage());
   }
 
+  /**
+   * 后台整理记忆：默认 Haiku（最便宜，用户可以在记忆设置里换）、不读本地设置、不给工具、不落会话记录（persistSession: false），
+   * 用结构化输出拿 JSON。跑在临时目录里，碰不到任何项目。
+   */
+  async complete(req: CompleteRequest): Promise<unknown> {
+    const abort = new AbortController();
+    const timer = setTimeout(() => abort.abort(), req.timeoutMs ?? 120_000);
+    try {
+      const q = query({
+        prompt: req.prompt,
+        options: {
+          cwd: os.tmpdir(),
+          env: agentEnvironment(),
+          model: req.model || "haiku",
+          systemPrompt: req.system,
+          tools: [],
+          settingSources: [],
+          strictMcpConfig: true,
+          mcpServers: {},
+          skills: [],
+          persistSession: false,
+          maxTurns: 3,
+          outputFormat: { type: "json_schema", schema: req.schema },
+          abortController: abort,
+          canUseTool: async () => ({ behavior: "deny", message: "后台整理不允许用工具" }),
+        },
+      });
+      for await (const m of q) {
+        if (m.type !== "result") continue;
+        if (m.subtype !== "success") throw new Error(`后台调用失败：${m.subtype}`);
+        return m.structured_output ?? JSON.parse(m.result);
+      }
+      throw new Error("后台调用没有结果");
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+
   diagnose(err: unknown) {
     return diagnose(err);
   }

package/src/agents/claude/session.ts

@@ -6,13 +6,17 @@
 import fs from "node:fs";
 import {
   query,
+  type McpServerConfig,
+  type Options,
   type PermissionResult,
   type Query,
   type SDKMessage,
   type SDKUserMessage,
 } from "@anthropic-ai/claude-agent-sdk";
 import { agentEnvironment } from "../../core/agent-env.js";
-import { describeAttachments } from "../../core/uploads.js";
+import { chatSystemPrompt } from "../../core/chat-mode.js";
+import { MEMORY_MCP_NAME, memoryMcpSpawn } from "../../core/memory-mcp.js";
+import { describeAttachments, inlineTextBlocks, readTextAttachments } from "../../core/uploads.js";
 import type {
   AgentEvents,
   AgentSession,
@@ -98,11 +102,17 @@ function canInline(a: SavedAttachment): boolean {
   return false;
 }
 
-/** 文字 + 附件清单，后面跟着能直接看的图片和 PDF。没有附件时就是原样的文字。 */
-function buildContent(input: UserInput): string | ContentBlock[] {
+/**
+ * 文字 + 附件清单，后面跟着能直接看的图片和 PDF。没有附件时就是原样的文字。
+ * chat：聊天模式没有读文件的工具，文本附件的内容也直接放进来。
+ */
+function buildContent(input: UserInput, chat: boolean): string | ContentBlock[] {
   if (input.attachments.length === 0) return input.text;
-  const note = describeAttachments(input.attachments, canInline);
-  const blocks: ContentBlock[] = [{ type: "text", text: input.text ? `${input.text}\n\n${note}` : note }];
+  const texts = chat ? readTextAttachments(input.attachments) : new Map<string, string>();
+  const inlined = (a: SavedAttachment) => canInline(a) || texts.has(a.path);
+  const note = describeAttachments(input.attachments, inlined, chat);
+  const head = [input.text, note, chat ? inlineTextBlocks(input.attachments, texts) : ""].filter(Boolean).join("\n\n");
+  const blocks: ContentBlock[] = [{ type: "text", text: head }];
   for (const a of input.attachments) {
     if (!canInline(a)) continue;
     const data = fs.readFileSync(a.path).toString("base64");
@@ -115,6 +125,50 @@ function buildContent(input: UserInput): string | ContentBlock[] {
   return blocks;
 }
 
+/** 记忆工具在 Claude 里的全名 */
+const MEMORY_TOOLS = new Set(["remember", "forget", "search_past_chats"].map((t) => `mcp__${MEMORY_MCP_NAME}__${t}`));
+/** 聊天模式的全部工具：只能联网，碰不到本机 */
+const CHAT_TOOLS = ["WebSearch", "WebFetch"];
+
+/**
+ * 按模式拼 query 的选项。
+ *
+ * 聊天模式：自己的短系统提示、只给联网的两个工具、不读本地设置（技能、插件、CLAUDE.md、MCP 都不加载）。
+ * 实测一句话的输入从约 1.6 万 token 降到约 2 千。
+ * 工作模式：Claude Code 原装，有记忆就追加在它的系统提示后面。
+ * 两种模式下记忆工具都以 MCP 子进程的方式挂上（strictMcpConfig 只认这里给的）。
+ *
+ * 系统提示一律 snapshot: false。SDK 默认会把会话第一次请求时的系统提示记进记录，之后 resume 时传的
+ * 新提示一概忽略（实测：先用聊天提示开的会话，换成工作模式的提示后还是按聊天提示回答）——
+ * 那样切模式、改了记忆都不生效。snapshot: false 每次现渲染，已经记录过的老会话也能换过来（实测）。
+ * 代价只是 Claude Code 升级后提示变了会让缓存失效一次。
+ */
+export function modeOptions(opts: SessionOptions): Partial<Options> {
+  const memory = opts.memory;
+  const mcpServers: Record<string, McpServerConfig> = memory
+    ? { [MEMORY_MCP_NAME]: { type: "stdio", ...memoryMcpSpawn(memory.userId, "claude", { search: !!memory.search, ...(memory.convKey ? { convKey: memory.convKey } : {}) }) } }
+    : {};
+  if (opts.mode === "chat") {
+    return {
+      systemPrompt: { type: "custom", prompt: chatSystemPrompt("WebSearch（搜索）和 WebFetch（读网页）", memory?.prompt), snapshot: false },
+      tools: CHAT_TOOLS,
+      settingSources: [],
+      strictMcpConfig: true,
+      skills: [],
+      mcpServers,
+    };
+  }
+  // 刚从聊天模式切回来：说一声，不然它会以为之前「不能执行命令」是自己说错了
+  const switched = opts.announceMode
+    ? "这条对话刚从「聊天模式」切到「工作模式」：之前聊天模式下不能执行命令、不能读写文件的限制已经解除，现在可以正常干活。不用为之前说做不到而道歉。"
+    : "";
+  const append = [memory?.prompt, switched].filter(Boolean).join("\n\n");
+  return {
+    systemPrompt: { type: "preset", preset: "claude_code", ...(append ? { append } : {}), snapshot: false },
+    ...(memory ? { mcpServers } : {}),
+  };
+}
+
 export class ClaudeSession implements AgentSession {
   private queue = new AsyncQueue<SDKUserMessage>();
   private q: Query | null = null;
@@ -176,7 +230,9 @@ export class ClaudeSession implements AgentSession {
         includePartialMessages: true,
         ...(this.opts.model ? { model: this.opts.model } : {}),
         ...(this.opts.effort ? { effort: this.opts.effort as never } : {}),
-        additionalDirectories: [this.opts.uploadsDir],
+        // 聊天模式不读本地文件，附件内容由 buildContent 直接放进消息
+        additionalDirectories: this.opts.mode === "chat" ? [] : [this.opts.uploadsDir],
+        ...modeOptions(this.opts),
         ...(resume ? { resume } : {}),
         ...(fork ? { forkSession: true } : {}),
         canUseTool: async (toolName, input) => this.canUseTool(toolName, input as Record<string, unknown>),
@@ -292,6 +348,11 @@ export class ClaudeSession implements AgentSession {
    * 对同一 request_id 必须幂等 —— reinitialize 之后 SDK 会重投同一个请求。
    */
   private async canUseTool(toolName: string, input: Record<string, unknown>): Promise<PermissionResult> {
+    // 自家的记忆工具，以及聊天模式下的联网工具：不问。
+    // 不用 allowedTools 放行 —— SDK 会对每个会话打一条「canUseTool 被绕过」的警告
+    if (MEMORY_TOOLS.has(toolName) && this.opts.memory) return { behavior: "allow", updatedInput: input };
+    if (this.opts.mode === "chat" && CHAT_TOOLS.includes(toolName)) return { behavior: "allow", updatedInput: input };
+
     // 提问不是授权：它问的是「你选哪个」
     if (toolName === "AskUserQuestion") {
       const answered = await this.askQuestion(input);
@@ -373,7 +434,7 @@ export class ClaudeSession implements AgentSession {
     // 这条要明确报错并让会话恢复可用，而不是挂在一个永远等不到结果的「忙」上
     let content: string | ContentBlock[];
     try {
-      content = buildContent(input);
+      content = buildContent(input, this.opts.mode === "chat");
     } catch (err) {
       const why = (err as NodeJS.ErrnoException).code === "ENOENT" ? "附件文件已不存在，请重新上传" : String(err);
       this.events.onError(new Error(`这条消息没能发出：${why}`));

package/src/agents/codex/driver.ts

@@ -4,13 +4,16 @@
 import { appServer } from "./app-server.js";
 import { describeRateLimits, readAccountKey, readRateLimits, toQuota } from "./account.js";
 import { diagnose } from "./errors.js";
-import { CodexSession, summarize } from "./session.js";
+import { CHAT_CONFIG, CodexSession, summarize, userMcpServers } from "./session.js";
+import os from "node:os";
 import { config, onConfigChange } from "../../core/config.js";
 import { splitAttachmentNote } from "../../core/uploads.js";
+import { stripContext } from "../../core/chat-mode.js";
 import type {
   AgentDriver,
   AgentEvents,
   AgentSession,
+  CompleteRequest,
   HistoryMessage,
   InteractionHost,
   ModelInfo,
@@ -24,7 +27,7 @@ import type { ModelListResponse, Thread, ThreadListResponse } from "./protocol.j
 function titleOf(thread: Thread): string {
   const name = thread.name?.trim();
   if (name) return name;
-  const preview = thread.preview?.replace(/\s+/g, " ").trim();
+  const preview = thread.preview && stripContext(thread.preview).replace(/\s+/g, " ").trim();
   if (!preview) return "(无标题)";
   return preview.length > 60 ? `${preview.slice(0, 60)}…` : preview;
 }
@@ -125,7 +128,7 @@ export class CodexDriver implements AgentDriver {
             .filter(Boolean)
             .join("\n");
           // 附件清单拆出来单独展示；没有清单的图片（别处发的）只能留个占位
-          const { text, attachments } = splitAttachmentNote(raw);
+          const { text, attachments } = splitAttachmentNote(stripContext(raw));
           const bareImages = attachments.length ? 0 : (item.content ?? []).filter((c) => c.type === "localImage").length;
           out.push({
             role: "user",
@@ -218,6 +221,55 @@ export class CodexDriver implements AgentDriver {
     return toQuota(limits, account);
   }
 
+  /**
+   * 后台整理记忆：临时 thread（ephemeral，不落记录、不进会话列表），工具、技能、MCP、联网全关，
+   * 只读沙箱，思考程度 low，用 outputSchema 拿 JSON。
+   */
+  async complete(req: CompleteRequest): Promise<unknown> {
+    const off = Object.fromEntries((await userMcpServers()).map((n) => [`mcp_servers.${n}.enabled`, false]));
+    const res = await appServer.call<{ thread: Thread }>("thread/start", {
+      cwd: os.tmpdir(),
+      ephemeral: true,
+      ...(req.model ? { model: req.model } : {}),
+      approvalPolicy: "never",
+      sandbox: "read-only",
+      baseInstructions: req.system,
+      config: { ...CHAT_CONFIG, ...off, web_search: "disabled" },
+    });
+    const threadId = res.thread.id;
+    let text = "";
+    let off2: (() => void) | undefined;
+    let timer: NodeJS.Timeout | undefined;
+    const done = new Promise<void>((resolve, reject) => {
+      timer = setTimeout(() => reject(new Error("后台调用超时")), req.timeoutMs ?? 120_000);
+      off2 = appServer.onNotification((method, params) => {
+        const p = params as { threadId?: string; item?: { type?: string; text?: string; phase?: string | null }; turn?: { status?: string; error?: { message?: string } } };
+        if (p?.threadId !== threadId) return;
+        if (method === "item/completed" && p.item?.type === "agentMessage" && p.item.phase !== "commentary") text = p.item.text ?? text;
+        if (method === "turn/completed") {
+          if (p.turn?.status === "failed") reject(new Error(p.turn.error?.message ?? "后台调用失败"));
+          else resolve();
+        }
+      });
+    });
+    // turn/start 自己就失败了的话没人等 done：别让它的超时变成未处理的拒绝
+    done.catch(() => {});
+    try {
+      await appServer.call("turn/start", {
+        threadId,
+        input: [{ type: "text", text: req.prompt, text_elements: [] }],
+        effort: "low",
+        outputSchema: req.schema,
+      });
+      await done;
+      return JSON.parse(text);
+    } finally {
+      clearTimeout(timer);
+      off2?.();
+      void appServer.call("thread/unsubscribe", { threadId }).catch(() => {});
+    }
+  }
+
   diagnose(err: unknown) {
     return diagnose(err);
   }

package/src/agents/codex/session.ts

@@ -5,7 +5,9 @@
 import { appServer } from "./app-server.js";
 import { refusalFor, UnsupportedRequest } from "./refusals.js";
 import { config } from "../../core/config.js";
-import { describeAttachments } from "../../core/uploads.js";
+import { contextBlock } from "../../core/chat-mode.js";
+import { MEMORY_MCP_NAME, memoryMcpSpawn } from "../../core/memory-mcp.js";
+import { describeAttachments, inlineTextBlocks, readTextAttachments } from "../../core/uploads.js";
 import type {
   AgentEvents,
   AgentSession,
@@ -14,6 +16,7 @@ import type {
   InteractionSpec,
   QuestionSpec,
   RuntimeInfo,
+  SavedAttachment,
   SessionOptions,
   Settlement,
   UserInput,
@@ -79,6 +82,63 @@ function sandboxPolicyFor(mode: string, cwd: string): unknown {
   };
 }
 
+// ---------- 聊天模式 ----------
+
+/**
+ * 聊天模式要关掉的东西（thread/start / resume 的 config 覆盖）。实测一句话的输入从约 2 万 token
+ * 降到约 1.1 万，大头是技能清单（约 2.5 万字符）和权限说明（约 1.1 万字符）。剩下的是 Codex 自己的基础指令
+ * （改不得，见 modeParams）和关不掉的工具定义。
+ * 不认识的 feature 名 Codex 会忽略；万一哪天哪个键让 thread 起不来，openOnce 会退回不带这些覆盖再试一次。
+ */
+export const CHAT_CONFIG: Record<string, unknown> = {
+  web_search: "live",
+  "skills.include_instructions": false,
+  include_permissions_instructions: false,
+  include_collaboration_mode_instructions: false,
+  include_apps_instructions: false,
+  include_apply_patch_tool: false,
+  ...Object.fromEntries(
+    [
+      "shell_tool",
+      "unified_exec",
+      "plugins",
+      "apps",
+      "browser_use",
+      "computer_use",
+      "multi_agent",
+      "image_generation",
+      "view_image",
+      "skill_search",
+      "tool_suggest",
+      "sleep_tool",
+      "hooks",
+      "goals",
+      "code_mode_host",
+      "worktrees",
+      "workspace_dependencies",
+      "in_app_browser",
+      "in_app_local_automation",
+      "realtime_conversation",
+    ].map((f) => [`features.${f}`, false]),
+  ),
+};
+
+/** 用户自己配的 MCP 服务（config.toml 里的 mcp_servers）。名字因人而异，只能读出来再逐个关 */
+let userMcpCache: { names: string[]; at: number } | null = null;
+
+export async function userMcpServers(): Promise<string[]> {
+  if (userMcpCache && Date.now() - userMcpCache.at < 60_000) return userMcpCache.names;
+  try {
+    const res = await appServer.call<{ config?: { mcp_servers?: Record<string, unknown> | null } }>("config/read", {});
+    const names = Object.keys(res.config?.mcp_servers ?? {}).filter((n) => n !== MEMORY_MCP_NAME);
+    userMcpCache = { names, at: Date.now() };
+    return names;
+  } catch (err) {
+    console.warn("[codex] 读取 MCP 配置失败，聊天模式下可能仍会加载用户的 MCP:", err instanceof Error ? err.message : err);
+    return [];
+  }
+}
+
 // ---------- 审批正文 ----------
 
 function describeCommand(params: CommandExecutionApprovalParams): string {
@@ -159,6 +219,13 @@ function parseQuestions(raw: unknown): ParsedQuestion[] | null {
 /** 会话已被丢弃，迟到的异步结果直接作废 */
 class DisposedError extends Error {}
 
+/** 聊天模式带着全套配置覆盖开 thread 失败了（见 openOnce 的退路） */
+class ChatConfigRejected extends Error {
+  constructor(readonly cause: unknown) {
+    super("聊天模式的配置覆盖被拒绝");
+  }
+}
+
 export class CodexSession implements AgentSession {
   private threadId: string | undefined;
   private turnId: string | undefined;
@@ -277,13 +344,64 @@ export class CodexSession implements AgentSession {
     return this.opening;
   }
 
+  private get chat(): boolean {
+    return this.opts.mode === "chat";
+  }
+
+  /** 沙箱：聊天模式一律只读（它本来就没有执行命令的工具，这是第二道保险） */
+  private get sandboxMode(): string {
+    return this.chat ? "read-only" : config().agents.codex.sandbox;
+  }
+
+  /**
+   * 按模式给 thread 的配置覆盖。thread/start、resume、fork 三条路都带上：配置是每次 resume 现给的，
+   * 换模式时旧会话先退订（dispose），再 resume 回来就换上了（实测）。
+   *
+   * 不动 baseInstructions / developerInstructions：Codex 把它们钉在 thread 上，切回工作模式时还原不了
+   * （见 core/chat-mode.ts）。模式和记忆走 contextBlock，附在第一条消息后面。
+   * minimal：上一次带全套覆盖没能起来，退回只挂记忆工具。
+   */
+  private async modeParams(minimal = false): Promise<Record<string, unknown>> {
+    const memory = this.opts.memory;
+    const mcp = memory ? { [`mcp_servers.${MEMORY_MCP_NAME}`]: memoryMcpSpawn(memory.userId, "codex", { search: !!memory.search, ...(memory.convKey ? { convKey: memory.convKey } : {}) }) } : {};
+    if (this.chat && !minimal) {
+      const off = Object.fromEntries((await userMcpServers()).map((n) => [`mcp_servers.${n}.enabled`, false]));
+      return { config: { ...CHAT_CONFIG, ...off, ...mcp } };
+    }
+    return memory ? { config: mcp } : {};
+  }
+
+  /**
+   * 这个会话进程还没告诉过 Codex 当前的模式和记忆：第一条消息后面附上 contextBlock。
+   * 进程一换（切模式、记忆改了、服务重启）就是新的 CodexSession，会再附一次最新的。
+   * 工作模式、没有记忆、模式也没换过：什么都不附，和原来一模一样。
+   */
+  private contextSent = false;
+
+  private get contextPending(): boolean {
+    return !this.contextSent && (this.chat || !!this.opts.memory || !!this.opts.announceMode);
+  }
+
   private async openOnce(): Promise<string> {
+    try {
+      return await this.openWith(false);
+    } catch (err) {
+      // 聊天模式的那串配置覆盖是按当前版本的 Codex 测出来的：万一哪个键不认导致起不来，退回最小覆盖
+      if (!(err instanceof ChatConfigRejected) || this.disposed) throw err;
+      console.warn("[codex] 聊天模式的配置覆盖没能生效，退回只换系统提示:", err.cause instanceof Error ? err.cause.message : err.cause);
+      return this.openWith(true);
+    }
+  }
+
+  private async openWith(minimal: boolean): Promise<string> {
     const shared = {
       cwd: this.opts.cwd,
       approvalPolicy: "on-request",
-      sandbox: config().agents.codex.sandbox,
+      sandbox: this.sandboxMode,
       ...(this.opts.model ? { model: this.opts.model } : {}),
+      ...(await this.modeParams(minimal)),
     };
+    if (this.disposed) throw new DisposedError();
     const resumeId = this.threadId ?? this.opts.resumeId;
     const fork = this.opts.fork && !this.forked;
     // 这个 thread 正在别的会话里跑：不接管。接管后它的后续输出和审批请求都按 threadId
@@ -303,6 +421,8 @@ export class CodexSession implements AgentSession {
       } else {
         res = await appServer.call<ThreadResponse>("thread/start", shared);
       }
+    } catch (err) {
+      throw this.chat && !minimal ? new ChatConfigRejected(err) : err;
     } finally {
       opening.delete(this);
     }
@@ -370,10 +490,15 @@ export class CodexSession implements AgentSession {
     this.turnId = undefined;
     this.stopRequested = false;
     const token = ++this.turnSeq;
-    const note = input.attachments.length
-      ? describeAttachments(input.attachments, (a) => a.kind === "image")
-      : "";
-    const text = note ? (input.text ? `${input.text}\n\n${note}` : note) : input.text;
+    // 聊天模式没有执行命令的工具，读不了文件：文本附件的内容直接放进消息
+    const chat = this.chat;
+    const textMap = chat ? readTextAttachments(input.attachments) : new Map<string, string>();
+    const inlined = (a: SavedAttachment) => a.kind === "image" || textMap.has(a.path);
+    const note = input.attachments.length ? describeAttachments(input.attachments, inlined, chat) : "";
+    const texts = chat ? inlineTextBlocks(input.attachments, textMap) : "";
+    // 放在最后：Codex 拿第一条消息的开头当会话预览，不能被这段背景占掉
+    const context = this.contextPending ? contextBlock(chat ? "chat" : "work", this.opts.memory?.prompt, "联网搜索") : "";
+    const text = [input.text, note, texts, context].filter(Boolean).join("\n\n");
     const images = input.attachments.filter((a) => a.kind === "image").map((a) => a.path);
     let startedOn: string | undefined;
     void this.open()
@@ -391,12 +516,14 @@ export class CodexSession implements AgentSession {
           approvalPolicy: "on-request",
           // 每一轮都按当前配置显式给沙箱：thread 是开着复用的，只在 thread/start 时给的话，
           // 设置里收紧了沙箱（比如改成只读），已有会话还会按旧权限干活
-          sandboxPolicy: sandboxPolicyFor(config().agents.codex.sandbox, this.opts.cwd),
+          sandboxPolicy: sandboxPolicyFor(this.sandboxMode, this.opts.cwd),
           ...(this.opts.model ? { model: this.opts.model } : {}),
           ...(this.opts.effort ? { effort: this.opts.effort } : {}),
         });
       })
       .then((res) => {
+        // 轮次开起来了，背景已经进了 thread 的历史；没开起来的话下一条消息再附一次
+        if (context) this.contextSent = true;
         const id = res?.turn?.id;
         if (!id) return;
         if (token === this.turnSeq) {