agent-loft 0.2.30 → 0.2.32

package/README.md

@@ -58,6 +58,8 @@ 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 小时以内的启动后补跑一次。工具和记忆一样只给有主人的对话，飞书群聊里没有。
+- **技能（skills）**：侧栏「定时任务」下面的「技能」。技能就是 Claude Code / Codex 用的那种 SKILL.md（可以带脚本和资料），由 agent-loft 按人管理，两个 agent 都能用。**来源**：在页面上写、上传技能包（`.zip` / `.skill` / 单个 SKILL.md / 整个文件夹），或者在对话里让 agent「把刚才的做法存成技能」（agent 用 `create_skill` / `update_skill`，先弹授权卡）。**分享**：作者选谁看得到——仅自己 / 指定的人 / 所有人；看得到的人在「技能广场」里安装。装的是作者那一份本身，作者改了，装了的人下一条消息起就用上新的；作者取消分享或删掉，装了的人也就没了。管理员能下架别人分享出来的技能，看不到别人私有的。**使用**：工作模式下 agent 遇到对得上的事自己用；在输入框或定时任务的「要做的事」里打 `@` 选技能，点名这次用哪个（聊天模式下会把技能内容直接附上）；飞书里发 `/skills` 看能 @ 哪些。**变量**：技能可以声明要用的环境变量（接口地址、密钥），每个人填自己的值，只注入自己的会话；密钥再写上「只允许发往」的地址就成了**受保护的密钥**——不进环境变量，agent 看不到值，只能用 `skill_request` 工具让 agent-loft 代发请求（在地址、请求头、请求体里写 `{{变量名}}`），只发往你确认过的地址、不跟随跳转、响应里出现的值会被抹掉；作者后来改了地址，要你再确认一次才放行。**机器上原有的技能**（`~/.claude/skills`、`~/.agents/skills`、插件市场和 claude.ai 同步的）只给管理员：成员的会话里看不到、调不了（Claude 用技能白名单，`/技能名` 也会被拦下；Codex 关掉它自己的技能清单），管理员在技能页的「本机技能」里能看到。
 - **飞书账号绑定**：设置 → 账号 → 飞书账号 →「生成绑定码」，再在飞书私聊机器人发 `/bind 绑定码`（10 分钟内有效，群里发不算）。绑定后这个私聊就是你的个人会话：用你的记忆，`/sessions` 只列你的会话，`/web` 只能接上你自己的 Web 会话，管理员在 Web 上也看不到它。必须本人在两边各操作一次，管理员不能替人绑定（只能解除），否则就能借飞书读到别人的记忆。
 
 ## 安装
@@ -128,7 +130,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` `/chat` `/work` `/help`；只在飞书里有的：`/web` `/detach` `/bind <绑定码>`
+聊天里的命令（飞书和 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` `/skills` `/help`；只在飞书里有的：`/web` `/detach` `/bind <绑定码>`
 
 自定义命令：设置 → 命令 → 「添加命令」，填命令名、说明和一段提示词，之后发 `/命令名 参数` 就会把这段提示词发给 agent（提示词里的 `$ARGUMENTS` 换成参数，没写就把参数接在后面）。按 agent 分开存，可以编辑、删除，也会同步到飞书指令面板。
 
@@ -143,6 +145,7 @@ agent-loft service install
 - 暴露到公网时，只通过 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/skills/`：技能本体在 `files/<技能 id>/`，每个人装了哪些、变量的值在 `users/<用户 id>.json`（0600）。普通变量注入到会话环境里，agent 能读到；受保护的密钥 agent 看不到值，但和多用户一样不是安全边界——工作模式下 agent 能直接读这些文件。别人分享的技能会在你的会话里照着执行，装之前在技能页点开看一眼它要做什么、要哪些变量。
 - 记忆存在 `data/memory/<用户 id>.json`，聊天记录索引在 `data/history/<用户 id>.jsonl`。记给谁由 agent-loft 在拉起记忆工具时定死（工具参数里没有用户），模型想写别人的记忆也写不了；但和多用户一样不是安全边界：工作模式下 agent 能读到这些文件。聊天模式没有读写本机文件的工具，网页里的提示注入也骗不走本机文件。
 
 ## 结构
@@ -160,9 +163,16 @@ 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 定怎么拉起）；技能工具也走这条通道
+    skills.ts      技能的存储：可见性、安装、停用、变量和受保护密钥确认过的地址；zip.ts 解技能包
+    skill-runtime.ts 技能怎么交给 agent：Claude 的插件目录和成员白名单、Codex 的清单、@ 技能、机器上原有的技能
+    skills-bridge.ts 技能工具在主进程这头：建 / 改技能（弹授权卡）、skill_request 代发带密钥的请求
     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 转给主进程；AGENT_LOFT_TOOLSET=skills 时是技能工具
   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.32",
   "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,
@@ -30,7 +31,7 @@ import type {
 import { describeUsage, readUsage, toQuota } from "./account.js";
 import { cachedProbe, withProbe } from "./probe.js";
 import { diagnose } from "./errors.js";
-import { ClaudeSession, describeToolUse, summarize, toModelInfo } from "./session.js";
+import { claudeBuiltins, ClaudeSession, describeToolUse, summarize, toModelInfo } from "./session.js";
 
 /** 模型列表几乎不变，缓存 10 分钟；读失败抛给设置页，让它退回手填 */
 const readCatalog = cachedProbe(10 * 60_000, "模型列表", () => withProbe(async (q) => toModelInfo(await q.supportedModels())));
@@ -51,11 +52,15 @@ function readCommands(cwd: string): Promise<AgentCommand[]> {
       () =>
         withProbe(
           async (q) =>
-            (await q.supportedCommands()).map((c) => ({
-              name: c.name,
-              description: c.description,
-              ...(c.argumentHint ? { args: c.argumentHint } : {}),
-            })),
+            (await q.supportedCommands()).map((c) => {
+              if (c.builtin) claudeBuiltins.add(c.name);
+              return {
+                name: c.name,
+                description: c.description,
+                ...(c.argumentHint ? { args: c.argumentHint } : {}),
+                ...(c.builtin ? { builtin: true } : {}),
+              };
+            }),
           cwd,
         ),
       [] as AgentCommand[],
@@ -69,7 +74,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 +162,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,8 @@ 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 { SKILLS_MCP_NAME, skillsMcpSpawn, TASKS_MCP_NAME, tasksMcpSpawn } from "../../core/tasks-mcp.js";
+import { PLUGIN_NAME, projectCommandNames } from "../../core/skill-runtime.js";
 import { describeAttachments, inlineTextBlocks, readTextAttachments } from "../../core/uploads.js";
 import type {
   AgentEvents,
@@ -127,6 +129,15 @@ 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}`));
+/** 技能工具：建、改技能前由 agent-loft 自己弹卡（skills-bridge.ts） */
+const SKILL_TOOLS = new Set(["list_skills", "get_skill", "create_skill", "update_skill", "skill_request"].map((t) => `mcp__${SKILLS_MCP_NAME}__${t}`));
+/**
+ * Claude Code 自带的命令和技能名（supportedCommands 里标了 builtin 的），driver 读命令表时顺手记下。
+ * 成员会话的技能白名单要带上它们；还没读到过就先不带（只少了 /simplify 这类自带技能）。
+ */
+export const claudeBuiltins = new Set<string>();
 /** 聊天模式的全部工具：只能联网，碰不到本机 */
 const CHAT_TOOLS = ["WebSearch", "WebFetch"];
 
@@ -145,9 +156,17 @@ 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") },
+          [SKILLS_MCP_NAME]: { type: "stdio", ...skillsMcpSpawn(opts.tasks.userId, opts.tasks.convKey, "claude") },
+        }
+      : {}),
+  };
   if (opts.mode === "chat") {
     return {
       systemPrompt: { type: "custom", prompt: chatSystemPrompt("WebSearch（搜索）和 WebFetch（读网页）", memory?.prompt), snapshot: false },
@@ -162,13 +181,24 @@ export function modeOptions(opts: SessionOptions): Partial<Options> {
   const switched = opts.announceMode
     ? "这条对话刚从「聊天模式」切到「工作模式」：之前聊天模式下不能执行命令、不能读写文件的限制已经解除，现在可以正常干活。不用为之前说做不到而道歉。"
     : "";
-  const append = [memory?.prompt, switched].filter(Boolean).join("\n\n");
+  const skills = opts.skills;
+  const append = [memory?.prompt, skills?.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 } : {}),
+    ...(skills?.pluginDir ? { plugins: [{ type: "local" as const, path: skills.pluginDir, skipMcpDiscovery: true }] } : {}),
+    ...(skills && !skills.admin ? { skills: memberSkillAllowlist(skills, opts.cwd) } : {}),
   };
 }
 
+/**
+ * 成员会话能用的技能：agent-loft 里启用的、Claude Code 自带的、项目目录里的。机器上另外装的
+ * （~/.claude/skills、插件市场、claude.ai 同步的）不在里面：模型看不到，Skill 工具也调不了。
+ */
+function memberSkillAllowlist(skills: NonNullable<SessionOptions["skills"]>, cwd: string): string[] {
+  return [...new Set([...skills.list.map((s) => `${PLUGIN_NAME}:${s.name}`), ...claudeBuiltins, ...projectCommandNames(cwd)])];
+}
+
 export class ClaudeSession implements AgentSession {
   private queue = new AsyncQueue<SDKUserMessage>();
   private q: Query | null = null;
@@ -222,7 +252,8 @@ export class ClaudeSession implements AgentSession {
       prompt: input.stream(),
       options: {
         cwd: this.opts.cwd,
-        env: agentEnvironment(),
+        // 技能变量只在工作模式注入：聊天模式没有执行命令的工具，用不上
+        env: { ...agentEnvironment(), ...(this.opts.mode === "chat" ? {} : (this.opts.skills?.env ?? {})) },
         // 只能是 default 或 acceptEdits：bypassPermissions 会让 canUseTool 变成死代码。
         // acceptEdits 只放行工作目录（含附件目录）内的改文件，其它照样走 canUseTool
         permissionMode: this.opts.autoEdit ? "acceptEdits" : "default",
@@ -351,6 +382,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) || SKILL_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,8 @@ 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 { SKILLS_MCP_NAME, skillsMcpSpawn, TASK_TOOL_TIMEOUT_SEC, TASKS_MCP_NAME, tasksMcpSpawn } from "../../core/tasks-mcp.js";
+import { codexSkillLines } from "../../core/skill-runtime.js";
 import { describeAttachments, inlineTextBlocks, readTextAttachments } from "../../core/uploads.js";
 import type {
   AgentEvents,
@@ -130,7 +132,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 && n !== SKILLS_MCP_NAME);
     userMcpCache = { names, at: Date.now() };
     return names;
   } catch (err) {
@@ -363,12 +365,37 @@ 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 },
+            [`mcp_servers.${SKILLS_MCP_NAME}`]: { ...skillsMcpSpawn(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 } : {};
+    const work = { ...mcp, ...(minimal ? {} : this.skillConfig()) };
+    return Object.keys(work).length ? { config: work } : {};
+  }
+
+  /**
+   * 工作模式的技能设置：变量逐个写进 shell_environment_policy.set（只作用于这个 thread 里跑的命令，
+   * 一个个键写不会冲掉用户 config.toml 里本来设的）；成员关掉 Codex 自己的技能清单 ——
+   * 那里面是机器上装的技能，只给管理员。成员的技能走 contextBlock 里的清单。
+   */
+  private skillConfig(): Record<string, unknown> {
+    const skills = this.opts.skills;
+    if (!skills) return {};
+    return {
+      ...Object.fromEntries(Object.entries(skills.env).map(([k, v]) => [`shell_environment_policy.set.${k}`, v])),
+      ...(skills.admin ? {} : { "skills.include_instructions": false, "features.skill_search": false }),
+    };
   }
 
   /**
@@ -379,7 +406,7 @@ export class CodexSession implements AgentSession {
   private contextSent = false;
 
   private get contextPending(): boolean {
-    return !this.contextSent && (this.chat || !!this.opts.memory || !!this.opts.announceMode);
+    return !this.contextSent && (this.chat || !!this.opts.memory || !!this.opts.announceMode || codexSkillLines(this.opts.skills).length > 0);
   }
 
   private async openOnce(): Promise<string> {
@@ -497,7 +524,7 @@ export class CodexSession implements AgentSession {
     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 context = this.contextPending ? contextBlock(chat ? "chat" : "work", this.opts.memory?.prompt, "联网搜索", codexSkillLines(this.opts.skills)) : "";
     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;

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,8 @@ 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 { handleSkillsApi } from "./skills-api.js";
 import { addSubscription, listSubscriptions, pushToAll, removeSubscription, removeSubscriptionsOf, vapidPublicKey } from "./push.js";
 
 export const COOKIE = "aim_session";
@@ -524,6 +526,10 @@ export async function handleApi(req: IncomingMessage, res: ServerResponse, url:
     return;
   }
 
+  // ----- 定时任务 -----
+  if (p.startsWith("/api/tasks") && (await handleTasksApi(req, res, p, user))) return;
+  if (p.startsWith("/api/skills") && (await handleSkillsApi(req, res, url, user))) return;
+
   // ----- 目录选择器：列工作区内的子目录 -----
   if (p === "/api/dirs" && method === "GET") {
     const listing = listWorkspaceDirs(url.searchParams.get("path") ?? "");
@@ -840,6 +846,8 @@ export async function handleApi(req: IncomingMessage, res: ServerResponse, url:
         allowedAgents: hub.enabledAgents().map((d) => d.id),
         // 带 key 是输入框补全：只列 Web 能用的；不带是设置页排序，全列
         ...(conv ? { channel: "web" } : {}),
+        // 成员看不到机器上装的技能
+        ...(admin ? {} : { member: true }),
       });
       sendJson(res, 200, { commands });
       return;

package/src/channels/web/http.ts

@@ -89,8 +89,8 @@ export async function readBody(req: IncomingMessage, limit: number): Promise<Buf
   return Buffer.concat(chunks);
 }
 
-export async function readJsonBody<T = Record<string, unknown>>(req: IncomingMessage): Promise<T> {
-  const raw = await readBody(req, 1024 * 1024);
+export async function readJsonBody<T = Record<string, unknown>>(req: IncomingMessage, limit = 1024 * 1024): Promise<T> {
+  const raw = await readBody(req, limit);
   if (raw.length === 0) return {} as T;
   try {
     return JSON.parse(raw.toString("utf8")) as T;

package/src/channels/web/server.ts

@@ -13,6 +13,8 @@ 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 { skillEvents } from "../../core/skills.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 +182,16 @@ 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" });
+}
+
+/** 技能变了：技能广场谁都可能在看，通知所有人重新拉（列表很小） */
+function broadcastSkills(): void {
+  for (const client of clients) send(client, { t: "skills" });
+}
+
 // ---------- 系统通知（Web Push） ----------
 
 /** 有页面正在前台看着这条会话：人就在眼前，不用推 */
@@ -235,10 +247,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 +490,8 @@ export async function startWeb(): Promise<void> {
   interactions.on("created", pushInteraction);
   interactions.on("updated", broadcastInteraction);
   interactions.on("settled", broadcastInteraction);
+  taskEvents.on("changed", broadcastTasks);
+  skillEvents.on("changed", broadcastSkills);
 
   await listen(server, host, port);
   console.log(`[web] 已监听 http://${host}:${port}`);
@@ -503,6 +521,8 @@ export async function stopWeb(): Promise<void> {
   interactions.off("created", pushInteraction);
   interactions.off("updated", broadcastInteraction);
   interactions.off("settled", broadcastInteraction);
+  taskEvents.off("changed", broadcastTasks);
+  skillEvents.off("changed", broadcastSkills);
   if (heartbeat) clearInterval(heartbeat);
   for (const client of clients) client.ws.close(1001, "服务重启");
   clients.clear();