agent-loft 0.2.30 → 0.2.31

package/README.md

@@ -58,6 +58,7 @@ Logo 就是这个意思：一大两小几颗星（多个 agent）站在同一张
 - **多用户**（信任型）：管理员在 设置 → 用户 里给别人建账号。每个人只看得到自己的对话、授权和通知，设置只有管理员能改，见下面「安全」。
 - **聊天模式 / 工作模式**：右上角的「💬 聊天 / 🛠 工作」，或者发 `/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 对话，以及绑定了飞书账号后和机器人的私聊；飞书群聊不用。别人（包括管理员）看不到你的记忆，管理员只能清空它；删用户时记忆一起删，不转给管理员。
+- **定时任务**：像 ChatGPT 的 Tasks，侧栏「最近」上面的「定时任务」。到点把一段提示词交给 agent，结果发回对话：一次 / 每天 / 工作日 / 每周 / 每月 / 每隔几小时 / 自定义 cron，按服务端时区，两次至少隔 15 分钟。**有需要才提醒**（默认）：agent 自己判断这次有没有要告诉你的事（比如「有新版本才告诉我」），没有就在回复第一行写 `[[静默]]`，推送、飞书都不发，对话里折叠成一行；没写暗号一律照常提醒。结果发到**专用对话**（任务自己的一条对话，第一次运行时新建、之后续用，可选聊天 / 工作模式和目录），或者**原来的对话**。也能直接在对话里说「每天早上 9 点帮我……」：agent 用 `create_task` / `update_task` / `delete_task` / `list_tasks` 工具管理，新建、修改、删除都会先弹授权卡让你确认（只有暂停不用；没有「总是允许」），任务自己运行的那一轮里不能再建、改、删任务。按人隔离：每人只看得到、改得了自己的任务（最多 30 个），删用户时一起删；到点再核对一次对话还是不是他的，对话被删或换了主人就暂停任务。到点对话在忙（正在回复或挂着授权）就等它，最多 30 分钟；服务停着时错过 2 小时以内的启动后补跑一次。工具和记忆一样只给有主人的对话，飞书群聊里没有。
 - **飞书账号绑定**：设置 → 账号 → 飞书账号 →「生成绑定码」，再在飞书私聊机器人发 `/bind 绑定码`（10 分钟内有效，群里发不算）。绑定后这个私聊就是你的个人会话：用你的记忆，`/sessions` 只列你的会话，`/web` 只能接上你自己的 Web 会话，管理员在 Web 上也看不到它。必须本人在两边各操作一次，管理员不能替人绑定（只能解除），否则就能借飞书读到别人的记忆。
 
 ## 安装
@@ -160,9 +161,13 @@ src/
     memory-curator.ts 录入聊天、回填已有对话、聊完后自动整理记忆
     feishu-links.ts 飞书账号 ↔ 用户的绑定和绑定码
     chat-mode.ts   聊天模式告诉 agent 的话（Claude 换系统提示，Codex 附在消息后面）
+    tasks.ts       定时任务的存储（按人隔离）；task-schedule.ts 频率和 cron；task-prompt.ts 每次运行附给 agent 的说明和静默暗号
+    task-runner.ts 定时任务的调度：到点核对主人和对话、送进对话、记下结果
+    tasks-bridge.ts 定时任务工具在主进程这头：核对签名、弹授权卡、增删改（tasks-mcp.ts 定怎么拉起）
     pairing.ts uploads.ts commands.ts …
   mcp/
     memory-server.ts 记忆工具（remember / forget / search_past_chats）的 stdio MCP 服务，两个 agent 共用
+    tasks-server.ts  定时任务工具的 stdio MCP 服务：只传话，经 unix socket 转给主进程
   agents/
     claude/        Claude Agent SDK 驱动
     codex/         codex app-server 驱动

package/package.json

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

package/src/agents/claude/driver.ts

@@ -13,6 +13,7 @@ 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";
+import { stripContext } from "../../core/chat-mode.js";
 import { config } from "../../core/config.js";
 import type {
   AgentDriver,
@@ -69,7 +70,7 @@ function readCommands(cwd: string): Promise<AgentCommand[]> {
 const SESSION_ID = /^[A-Za-z0-9_-]{8,64}$/;
 
 function titleOf(info: { customTitle?: string; summary?: string; firstPrompt?: string }): string {
-  const raw = (info.customTitle || info.summary || info.firstPrompt || "").replace(/\s+/g, " ").trim();
+  const raw = stripContext(info.customTitle || info.summary || info.firstPrompt || "").replace(/\s+/g, " ").trim();
   if (!raw) return "(无标题)";
   return raw.length > 60 ? `${raw.slice(0, 60)}…` : raw;
 }
@@ -157,7 +158,7 @@ export class ClaudeDriver implements AgentDriver {
         const texts = blocks.filter((b) => b.type === "text" && b.text).map((b) => b.text!);
         if (texts.length === 0) continue; // 纯 tool_result
         // 我们自己拼进去的附件清单：从正文里拆出来，单独作为附件给前端展示
-        const { text, attachments } = splitAttachmentNote(texts.join("\n"));
+        const { text, attachments } = splitAttachmentNote(stripContext(texts.join("\n")));
         if (!text && attachments.length === 0) continue;
         if (text.startsWith("<command-") || text.startsWith("<local-command")) continue;
         if (text.startsWith("<task-notification>")) {

package/src/agents/claude/session.ts

@@ -16,6 +16,7 @@ import {
 import { agentEnvironment } from "../../core/agent-env.js";
 import { chatSystemPrompt } from "../../core/chat-mode.js";
 import { MEMORY_MCP_NAME, memoryMcpSpawn } from "../../core/memory-mcp.js";
+import { TASKS_MCP_NAME, tasksMcpSpawn } from "../../core/tasks-mcp.js";
 import { describeAttachments, inlineTextBlocks, readTextAttachments } from "../../core/uploads.js";
 import type {
   AgentEvents,
@@ -127,6 +128,8 @@ function buildContent(input: UserInput, chat: boolean): string | ContentBlock[]
 
 /** 记忆工具在 Claude 里的全名 */
 const MEMORY_TOOLS = new Set(["remember", "forget", "search_past_chats"].map((t) => `mcp__${MEMORY_MCP_NAME}__${t}`));
+/** 定时任务工具：要用户确认的那几个由 agent-loft 自己弹卡（tasks-bridge.ts），这里不再问一遍 */
+const TASK_TOOLS = new Set(["list_tasks", "create_task", "update_task", "delete_task"].map((t) => `mcp__${TASKS_MCP_NAME}__${t}`));
 /** 聊天模式的全部工具：只能联网，碰不到本机 */
 const CHAT_TOOLS = ["WebSearch", "WebFetch"];
 
@@ -145,9 +148,12 @@ const CHAT_TOOLS = ["WebSearch", "WebFetch"];
  */
 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 } : {}) }) } }
-    : {};
+  const mcpServers: Record<string, McpServerConfig> = {
+    ...(memory
+      ? { [MEMORY_MCP_NAME]: { type: "stdio", ...memoryMcpSpawn(memory.userId, "claude", { search: !!memory.search, ...(memory.convKey ? { convKey: memory.convKey } : {}) }) } }
+      : {}),
+    ...(opts.tasks ? { [TASKS_MCP_NAME]: { type: "stdio", ...tasksMcpSpawn(opts.tasks.userId, opts.tasks.convKey, "claude") } } : {}),
+  };
   if (opts.mode === "chat") {
     return {
       systemPrompt: { type: "custom", prompt: chatSystemPrompt("WebSearch（搜索）和 WebFetch（读网页）", memory?.prompt), snapshot: false },
@@ -165,7 +171,7 @@ export function modeOptions(opts: SessionOptions): Partial<Options> {
   const append = [memory?.prompt, switched].filter(Boolean).join("\n\n");
   return {
     systemPrompt: { type: "preset", preset: "claude_code", ...(append ? { append } : {}), snapshot: false },
-    ...(memory ? { mcpServers } : {}),
+    ...(Object.keys(mcpServers).length ? { mcpServers } : {}),
   };
 }
 
@@ -351,6 +357,7 @@ export class ClaudeSession implements AgentSession {
     // 自家的记忆工具，以及聊天模式下的联网工具：不问。
     // 不用 allowedTools 放行 —— SDK 会对每个会话打一条「canUseTool 被绕过」的警告
     if (MEMORY_TOOLS.has(toolName) && this.opts.memory) return { behavior: "allow", updatedInput: input };
+    if (TASK_TOOLS.has(toolName) && this.opts.tasks) return { behavior: "allow", updatedInput: input };
     if (this.opts.mode === "chat" && CHAT_TOOLS.includes(toolName)) return { behavior: "allow", updatedInput: input };
 
     // 提问不是授权：它问的是「你选哪个」

package/src/agents/codex/session.ts

@@ -7,6 +7,7 @@ import { refusalFor, UnsupportedRequest } from "./refusals.js";
 import { config } from "../../core/config.js";
 import { contextBlock } from "../../core/chat-mode.js";
 import { MEMORY_MCP_NAME, memoryMcpSpawn } from "../../core/memory-mcp.js";
+import { TASK_TOOL_TIMEOUT_SEC, TASKS_MCP_NAME, tasksMcpSpawn } from "../../core/tasks-mcp.js";
 import { describeAttachments, inlineTextBlocks, readTextAttachments } from "../../core/uploads.js";
 import type {
   AgentEvents,
@@ -130,7 +131,7 @@ 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);
+    const names = Object.keys(res.config?.mcp_servers ?? {}).filter((n) => n !== MEMORY_MCP_NAME && n !== TASKS_MCP_NAME);
     userMcpCache = { names, at: Date.now() };
     return names;
   } catch (err) {
@@ -363,12 +364,17 @@ export class CodexSession implements AgentSession {
    */
   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 } : {}) }) } : {};
+    const tasks = this.opts.tasks;
+    const mcp = {
+      ...(memory ? { [`mcp_servers.${MEMORY_MCP_NAME}`]: memoryMcpSpawn(memory.userId, "codex", { search: !!memory.search, ...(memory.convKey ? { convKey: memory.convKey } : {}) }) } : {}),
+      // 新建 / 修改任务要等用户点授权卡，Codex 默认 60 秒就算工具超时
+      ...(tasks ? { [`mcp_servers.${TASKS_MCP_NAME}`]: { ...tasksMcpSpawn(tasks.userId, tasks.convKey, "codex"), tool_timeout_sec: TASK_TOOL_TIMEOUT_SEC } } : {}),
+    };
     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 } : {};
+    return Object.keys(mcp).length ? { config: mcp } : {};
   }
 
   /**

package/src/channels/feishu/bot.ts

@@ -492,22 +492,26 @@ export class FeishuBot {
         // 别处（Web、别的飞书聊天）说的话，同步一句过来，不然这边看着没头没尾
         const o = ev.origin;
         const here = o.channel === "feishu" && o.channelId === this.cfg.id && (!o.chatId || o.chatId === chatId);
-        if (!here) {
+        // 定时任务的提示词不同步过来：每次运行都发一条，飞书里就全是它了。结果出来时再带上任务名
+        if (!here && o.channel !== "task") {
           const files = ev.attachments.length ? `\n\n📎 ${ev.attachments.join("、")}` : "";
           const icon = o.channel === "web" ? "💻" : "💬";
           void this.client.sendCard(chatId, replyCard(`${icon} **${o.name ?? "Web"}**：${ev.text}${files}`));
         }
         return;
       }
+      // 定时任务这一轮不画过程卡：跑完之前不知道要不要提醒，卡片一发出去飞书就响了
       case "step":
-        this.stream(key, chatId).addStep(ev.text);
+        if (!hub.currentTaskTurn(key)) this.stream(key, chatId).addStep(ev.text);
         return;
       case "text":
-        this.stream(key, chatId).addText(ev.text);
+        if (!hub.currentTaskTurn(key)) this.stream(key, chatId).addText(ev.text);
         return;
       case "result": {
         const stream = this.stream(key, chatId);
-        stream.finish(ev.text, ev.footer);
+        if (ev.silent) stream.finish("", ev.footer, true);
+        else if (ev.task) stream.finish(`⏰ **${ev.task.title}**\n\n${ev.text}`, ev.footer);
+        else stream.finish(ev.text, ev.footer);
         void stream.drain().then(() => this.clearTyping(key));
         return;
       }

package/src/channels/feishu/turn-stream.ts

@@ -69,8 +69,9 @@ export class TurnStream {
   /**
    * 收尾：过程卡定格为完成态，然后把最终回复作为普通消息发出去。
    * 整轮没有过程时不会留下任何卡片 —— 简单问答就该只有一条回复。
+   * quiet：不发回复（定时任务判断这次不用提醒），只把过程卡定格。
    */
-  finish(finalText: string, footer?: string): void {
+  finish(finalText: string, footer?: string, quiet = false): void {
     this.enqueue(async () => {
       if (this.messageId) {
         await this.deps.updateCard(
@@ -79,7 +80,7 @@ export class TurnStream {
         );
       }
       const reply = finalText.trim() || this.text.trim();
-      if (reply) await this.deps.sendReply(reply);
+      if (reply && !quiet) await this.deps.sendReply(reply);
       this.reset();
     });
   }

package/src/channels/web/api.ts

@@ -62,6 +62,7 @@ import {
 } from "./auth.js";
 import { canSeeConv, pushOwnedBy, sessionVisibleTo } from "./access.js";
 import { clientIp, cookies, HttpError, isHttps, readBody, readJsonBody, SECURITY_HEADERS, sendJson } from "./http.js";
+import { handleTasksApi } from "./tasks-api.js";
 import { addSubscription, listSubscriptions, pushToAll, removeSubscription, removeSubscriptionsOf, vapidPublicKey } from "./push.js";
 
 export const COOKIE = "aim_session";
@@ -524,6 +525,9 @@ export async function handleApi(req: IncomingMessage, res: ServerResponse, url:
     return;
   }
 
+  // ----- 定时任务 -----
+  if (p.startsWith("/api/tasks") && (await handleTasksApi(req, res, p, user))) return;
+
   // ----- 目录选择器：列工作区内的子目录 -----
   if (p === "/api/dirs" && method === "GET") {
     const listing = listWorkspaceDirs(url.searchParams.get("path") ?? "");

package/src/channels/web/server.ts

@@ -13,6 +13,7 @@ import { parseCommand } from "../../core/commands.js";
 import { GLOBAL_ALWAYS_DENIED, hub, type EventEnvelope } from "../../core/hub.js";
 import { interactions, type Interaction } from "../../core/interactions.js";
 import { getConversation } from "../../core/store.js";
+import { taskEvents } from "../../core/tasks.js";
 import { RUNNING_VERSION } from "../../core/upgrade.js";
 import type { Settlement } from "../../core/types.js";
 import { getUser, isAdmin, legacyOwnerId, type User } from "../../core/users.js";
@@ -180,6 +181,11 @@ function broadcastInteraction(i: Interaction): void {
   for (const client of clients) if (canSeeKey(client.user, i.convKey)) send(client, { t: "ix", interaction: i });
 }
 
+/** 某人的定时任务变了（增删改、跑完一次）：只告诉他自己开着的页面，页面自己去重新拉 */
+function broadcastTasks(owner: string): void {
+  for (const client of clients) if (client.user.id === owner) send(client, { t: "tasks" });
+}
+
 // ---------- 系统通知（Web Push） ----------
 
 /** 有页面正在前台看着这条会话：人就在眼前，不用推 */
@@ -235,10 +241,14 @@ function pushEvent(env: EventEnvelope): void {
   const ev = env.ev;
   if (ev.type !== "result" && ev.type !== "error") return;
   if (!isWebConv(env.key)) return;
+  // 定时任务这次判断不用提醒
+  if (ev.type === "result" && ev.silent) return;
   const name = convName(env.key);
   const payload =
     ev.type === "result"
-      ? { title: `${name} · 回复完成`, body: plainPreview(ev.text) || "（没有文字回复）" }
+      ? ev.task
+        ? { title: `⏰ ${ev.task.title}`, body: plainPreview(ev.text) || "（没有文字回复）" }
+        : { title: `${name} · 回复完成`, body: plainPreview(ev.text) || "（没有文字回复）" }
       : { title: `${name} · 出错了`, body: plainPreview(ev.message) };
   notify(env.key, { ...payload, tag: `reply:${env.key}` });
 }
@@ -474,6 +484,7 @@ export async function startWeb(): Promise<void> {
   interactions.on("created", pushInteraction);
   interactions.on("updated", broadcastInteraction);
   interactions.on("settled", broadcastInteraction);
+  taskEvents.on("changed", broadcastTasks);
 
   await listen(server, host, port);
   console.log(`[web] 已监听 http://${host}:${port}`);
@@ -503,6 +514,7 @@ export async function stopWeb(): Promise<void> {
   interactions.off("created", pushInteraction);
   interactions.off("updated", broadcastInteraction);
   interactions.off("settled", broadcastInteraction);
+  taskEvents.off("changed", broadcastTasks);
   if (heartbeat) clearInterval(heartbeat);
   for (const client of clients) client.ws.close(1001, "服务重启");
   clients.clear();

package/src/channels/web/tasks-api.ts

@@ -0,0 +1,94 @@
+// 定时任务页面的接口：/api/tasks。每个人只看得到、改得了自己的任务（别人的一律当不存在）。
+import type { IncomingMessage, ServerResponse } from "node:http";
+import { config, resolveWorkspacePath } from "../../core/config.js";
+import { hub } from "../../core/hub.js";
+import { memoryOwnerOf } from "../../core/personal.js";
+import { getConversation } from "../../core/store.js";
+import { forgetTask, isTaskRunning, runTaskNow } from "../../core/task-runner.js";
+import { serverTimeZone } from "../../core/task-schedule.js";
+import { createTask, deleteTask, getTask, listTasks, updateTask, viewOf, type Task, type TaskInput } from "../../core/tasks.js";
+import type { User } from "../../core/users.js";
+import { HttpError, readJsonBody, sendJson } from "./http.js";
+
+function view(task: Task) {
+  const key = task.target.key;
+  const conv = key ? getConversation(key) : undefined;
+  return {
+    ...viewOf(task),
+    running: isTaskRunning(task.id),
+    // 结果在哪条对话里看（专用对话第一次运行前还没有）
+    ...(conv && !conv.hidden ? { convKey: conv.key, convTitle: conv.title ?? "" } : {}),
+  };
+}
+
+/** 表单 / 请求里的字段先在这里核一遍：agent 要启用着、目录要在工作区里、对话要是自己的 */
+function checkInput(user: User, body: TaskInput): TaskInput {
+  const out: TaskInput = { ...body };
+  if (body.agent !== undefined) {
+    const agent = String(body.agent);
+    if (!hub.enabledAgents().some((d) => d.id === agent)) throw new HttpError(400, `${hub.label(agent)} 没有启用`);
+  }
+  if (typeof body.cwd === "string" && body.cwd.trim()) {
+    const cwd = resolveWorkspacePath(body.cwd.trim());
+    if (!cwd) throw new HttpError(400, `目录必须存在，且在 ${config().workspaceRoot} 之内`);
+    out.cwd = cwd === config().workspaceRoot ? "" : cwd;
+  }
+  const target = body.target as { kind?: string; key?: string } | undefined;
+  if (target?.kind === "conv") {
+    const conv = target.key ? getConversation(target.key) : undefined;
+    if (!conv || conv.hidden || memoryOwnerOf(conv) !== user.id) throw new HttpError(400, "回复到的那条对话不存在了，改成专用对话吧");
+  }
+  return out;
+}
+
+const bad = (err: unknown) => (err instanceof HttpError ? err : new HttpError(400, err instanceof Error ? err.message : String(err)));
+
+/** 处理了就返回 true */
+export async function handleTasksApi(req: IncomingMessage, res: ServerResponse, p: string, user: User): Promise<boolean> {
+  const method = req.method ?? "GET";
+  if (p === "/api/tasks" && method === "GET") {
+    sendJson(res, 200, { tasks: listTasks(user.id).map(view), tz: serverTimeZone(), now: Date.now() });
+    return true;
+  }
+  if (p === "/api/tasks" && method === "POST") {
+    const body = await readJsonBody<TaskInput>(req);
+    // 没选 agent（只启用了一个时表单里不显示）：用第一个启用着的，不能默认成一个可能没启用的
+    if (body.agent === undefined || body.agent === "") body.agent = hub.enabledAgents()[0]?.id;
+    let task: Task;
+    try {
+      task = createTask(user.id, checkInput(user, body), "user");
+    } catch (err) {
+      throw bad(err);
+    }
+    sendJson(res, 200, view(task));
+    return true;
+  }
+  const m = /^\/api\/tasks\/([^/]+)(?:\/(run))?$/.exec(p);
+  if (!m) return false;
+  const task = getTask(user.id, decodeURIComponent(m[1]!));
+  if (!task) throw new HttpError(404, "这个任务不存在");
+  if (m[2] === "run" && method === "POST") {
+    const error = runTaskNow(task);
+    if (error) throw new HttpError(409, error);
+    sendJson(res, 200, view(task));
+    return true;
+  }
+  if (!m[2] && method === "PATCH") {
+    const body = await readJsonBody<TaskInput>(req);
+    let updated: Task;
+    try {
+      updated = updateTask(user.id, task.id, checkInput(user, body));
+    } catch (err) {
+      throw bad(err);
+    }
+    sendJson(res, 200, view(updated));
+    return true;
+  }
+  if (!m[2] && method === "DELETE") {
+    deleteTask(user.id, task.id);
+    forgetTask(task);
+    sendJson(res, 200, { ok: true });
+    return true;
+  }
+  return false;
+}

package/src/core/chat-mode.ts

@@ -42,21 +42,21 @@ export function contextBlock(mode: "chat" | "work", memory: string | undefined,
     mode === "chat"
       ? ["当前是「聊天模式」，你作为用户的私人 AI 助手和他聊天：", ...chatRules(search)]
       : ["当前是「工作模式」：可以执行命令、读写文件，按平常的方式干活。之前如果说过「聊天模式下不能做」，那个限制已经解除。"];
-  return [
-    OPEN,
-    "（这段是 agent-loft 自动附上的背景，不是用户写的。照着做，但不要在回复里提到它。）",
-    "",
-    ...head,
-    ...(memory ? ["", memory] : []),
-    CLOSE,
-  ].join("\n");
+  return wrapContext([...head, ...(memory ? ["", memory] : [])]);
+}
+
+/** 包成 agent-loft 附上的背景：用户看不到（读历史、实时显示时都剥掉），agent 照着做 */
+export function wrapContext(lines: string[]): string {
+  return [OPEN, "（这段是 agent-loft 自动附上的背景，不是用户写的。照着做，但不要在回复里提到它。）", "", ...lines, CLOSE].join("\n");
 }
 
-/** 剥掉 contextBlock（读历史、列会话标题时用） */
+/** 剥掉 contextBlock（读历史、列会话标题时用）。一条消息里可能有好几段（定时任务的说明 + Codex 的模式说明） */
 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();
+  let out = text;
+  for (let start = out.indexOf(OPEN); start >= 0; start = out.indexOf(OPEN)) {
+    const end = out.indexOf(CLOSE, start);
+    const rest = end < 0 ? "" : out.slice(end + CLOSE.length);
+    out = `${out.slice(0, start)}${rest}`;
+  }
+  return out === text ? text : out.trim();
 }