agent-loft 0.2.29 → 0.2.31

package/src/core/hub.ts

@@ -46,6 +46,8 @@ import type {
 import { buildCatalog, expandCustomCommand, type AgentCommand, type CommandEntry, type CommandPrefs } from "./command-catalog.js";
 import { helpText, type ParsedCommand } from "./commands.js";
 import { listScheduled } from "./scheduled.js";
+import { stripContext } from "./chat-mode.js";
+import { isSilentReply } from "./task-prompt.js";
 
 // ---------- 事件 ----------
 
@@ -66,12 +68,22 @@ export type ConvEvent =
   | { type: "step"; kind: StepKind; text: string }
   | { type: "delta"; text: string }
   | { type: "text"; text: string }
-  | { type: "result"; text: string; footer: string; at: number; anchor?: string }
+  /**
+   * task：这一轮是定时任务发起的；silent：任务让 agent 自己判断要不要提醒，它判断这次不用 ——
+   * 推送、飞书都不发，网页上折叠显示
+   */
+  | { type: "result"; text: string; footer: string; at: number; anchor?: string; task?: { id: string; title: string }; silent?: true }
   | { type: "error"; message: string }
   | { type: "notice"; text: string }
   | { type: "state"; busy: boolean }
   | { type: "meta" };
 
+/** 定时任务发起的一轮（见 core/task-runner.ts） */
+export type TaskTurn = { taskId: string; runId: string; title: string; smart: boolean };
+
+/** 定时任务的一轮结束了 */
+export type TaskTurnEnd = TaskTurn & { key: string; status: "notified" | "silent" | "error" | "interrupted"; text: string };
+
 /** 一条输入是在哪个时刻收到的：停止代次 + 生命周期代次 */
 /**
  * 一条输入收到时的状态快照。
@@ -141,6 +153,8 @@ export type ConversationInfo = {
   personal?: boolean;
   /** 排着的定时消息（见 core/scheduled.ts），按发送时间先后 */
   scheduled?: { id: string; text: string; at: number }[];
+  /** 定时任务的专用对话 */
+  taskId?: string;
 };
 
 /** 普通成员点了会落盘的「总是允许」 */
@@ -162,9 +176,14 @@ function withTimeout<T>(p: Promise<T>, what: string, ms = QUERY_TIMEOUT_MS): Pro
 
 type Live = { id: number; agent: string; cwd: string; session: AgentSession };
 
-class Hub extends EventEmitter<{ event: [EventEnvelope] }> {
+class Hub extends EventEmitter<{ event: [EventEnvelope]; task: [TaskTurnEnd] }> {
   private drivers = new Map<string, AgentDriver>();
   private live = new Map<string, Live>();
+  /**
+   * 每条会话已经送进 agent、还没出结果的轮次，按先后排：定时任务发起的带着 TaskTurn，普通消息是 null。
+   * 和 inflight 一样一轮一项，出结果 / 出错 / 被丢弃时从头上取走。
+   */
+  private turnTags = new Map<string, (TaskTurn | null)[]>();
   private buffers = new Map<string, EventEnvelope[]>();
   private seq = 0;
   /** 每条会话还没收到结果的轮数，> 0 即忙 */
@@ -446,6 +465,7 @@ class Hub extends EventEmitter<{ event: [EventEnvelope] }> {
       ...(this.drivers.get(conv.agent)?.forkAt ? { canFork: true } : {}),
       mode: conv.mode ?? "work",
       ...(memoryOwnerOf(conv) ? { personal: true } : {}),
+      ...(conv.taskId ? { taskId: conv.taskId } : {}),
       ...(() => {
         const list = listScheduled(key);
         return list.length ? { scheduled: list.map(({ id, text, at }) => ({ id, text, at })) } : {};
@@ -498,6 +518,8 @@ class Hub extends EventEmitter<{ event: [EventEnvelope] }> {
     // 记忆在拉起会话这一刻读一次：会话里 agent 自己记下的，上下文里本来就有；
     // 用户在设置里改了，memoryChanged() 会让空闲的会话下次说话时带着新的重新拉起
     const memory = sessionMemory(conv);
+    // 定时任务工具：和记忆一样只给有主人的对话（飞书群聊里谁都能让机器人建任务，算不清是谁的）
+    const taskOwner = memoryOwnerOf(conv);
     const mode = conv.mode ?? "work";
     // 续着的会话上次被告知的模式和现在不一样（新会话没有历史，算原装的工作模式）
     const announceMode = (resumeId ? (binding.announcedMode ?? "work") : "work") !== mode;
@@ -520,6 +542,7 @@ class Hub extends EventEmitter<{ event: [EventEnvelope] }> {
         ...(conv.mode === "chat" ? { mode: "chat" as const } : {}),
         ...(memory ? { memory } : {}),
         ...(announceMode ? { announceMode: true } : {}),
+        ...(taskOwner ? { tasks: { userId: taskOwner, convKey: key } } : {}),
       },
       {
         onTurnStart: () => {
@@ -536,13 +559,18 @@ class Hub extends EventEmitter<{ event: [EventEnvelope] }> {
           if (result.costUsd !== undefined) parts.push(`约 $${result.costUsd.toFixed(4)}`);
           if (result.tokens !== undefined) parts.push(`${result.tokens} tokens`);
           const footer = parts.join("　");
+          const tag = this.takeTurnTag(key);
+          const silent = !!tag?.smart && isSilentReply(result.text);
           this.emitEvent(key, {
             type: "result",
             text: result.text,
             footer,
             at: Date.now(),
             ...(result.anchor ? { anchor: result.anchor } : {}),
+            ...(tag ? { task: { id: tag.taskId, title: tag.title } } : {}),
+            ...(silent ? { silent: true as const } : {}),
           });
+          if (tag) this.emit("task", { ...tag, key, status: silent ? "silent" : "notified", text: result.text });
           const conv = getConversation(key);
           recordFooter(holder.session?.sessionId ?? (conv ? agentBinding(conv, agent).sessionId : undefined), result.text, footer);
           this.setInflight(key, (this.inflight.get(key) ?? 1) - 1);
@@ -560,7 +588,12 @@ class Hub extends EventEmitter<{ event: [EventEnvelope] }> {
           console.error(`[${agent}] ${key} 出错:`, err instanceof Error ? err.message : err);
           // 这一轮已经结束了，挂着的审批没人会再等它
           interactions.cancelAll(key, "本轮出错结束");
-          if (Date.now() - (this.stoppedAt.get(key) ?? 0) < 15_000) {
+          const stopped = Date.now() - (this.stoppedAt.get(key) ?? 0) < 15_000;
+          const tag = this.takeTurnTag(key);
+          if (tag) {
+            this.emit("task", { ...tag, key, status: stopped ? "interrupted" : "error", text: stopped ? "被停止了" : diagnosis.chatMessage });
+          }
+          if (stopped) {
             // 用户自己点的停止：中断导致的「没能正常收尾」不是故障
             this.emitEvent(key, { type: "notice", text: "已中断。" });
           } else {
@@ -584,6 +617,11 @@ class Hub extends EventEmitter<{ event: [EventEnvelope] }> {
         },
         onDropped: (n) => {
           if (!alive() || n <= 0) return;
+          // 丢的是排在最后、还没开始的那 n 条（Codex 先报正在跑的那轮出错、再报丢弃，那时队头已经取走了）
+          const tags = this.turnTags.get(key) ?? [];
+          for (const tag of tags.splice(Math.max(0, tags.length - n), n)) {
+            if (tag) this.emit("task", { ...tag, key, status: "interrupted", text: "排队时被停止了" });
+          }
           this.setInflight(key, (this.inflight.get(key) ?? n) - n);
         },
         onSessionId: (sessionId) => {
@@ -656,6 +694,8 @@ class Hub extends EventEmitter<{ event: [EventEnvelope] }> {
     const existing = this.live.get(key);
     if (existing) this.rememberRuntime(key, existing);
     this.live.delete(key);
+    for (const tag of this.turnTags.get(key) ?? []) if (tag) this.emit("task", { ...tag, key, status: "interrupted", text: note });
+    this.turnTags.delete(key);
     this.setInflight(key, 0);
     if (!existing) return;
     // dispose 卡住（CLI 不响应）不能把这条会话的操作队列永远堵死
@@ -747,9 +787,10 @@ class Hub extends EventEmitter<{ event: [EventEnvelope] }> {
    * gen：这条消息是在哪个停止代次下收到的。渠道自己还要先做点异步的事（飞书下载附件）
    * 才调到这里时必须传：下载期间点了停止，这条消息就不该再发出去。
    */
-  send(key: string, input: UserInput, origin: Origin, gen?: InputGen): void {
+  send(key: string, input: UserInput, origin: Origin, gen?: InputGen, opts: { task?: TaskTurn } = {}): void {
     const conv = getConversation(key);
     if (!conv) throw new Error(`会话不存在：${key}`);
+    const task = opts.task;
     // 用户自定义命令（设置 → 命令）：展开成预设的提示词再发，界面上和 agent 收到的都是展开后的内容
     const custom = (config().commands as Record<string, CommandPrefs | undefined>)[conv.agent]?.custom;
     const expanded = expandCustomCommand(input.text, custom);
@@ -772,10 +813,14 @@ class Hub extends EventEmitter<{ event: [EventEnvelope] }> {
       return false;
     };
     // 最先检查：停止之前收到的旧消息，不能去回答停止之后新冒出来的提问
-    if (cancelled()) return;
+    if (cancelled()) {
+      if (task) this.emit("task", { ...task, key, status: "interrupted", text: "没有发出（停止了或者会话被切换了）" });
+      return;
+    }
     const shown = {
       type: "user" as const,
-      text: input.text,
+      // 附给 agent 的背景（定时任务的说明）不显示
+      text: stripContext(input.text),
       attachments: input.attachments.map((a) => `${KIND_LABEL[a.kind]} ${a.name}`),
       files: input.attachments.map(attachmentInfo),
       origin,
@@ -787,7 +832,8 @@ class Hub extends EventEmitter<{ event: [EventEnvelope] }> {
      * 没有切换生效过；expectId 给了的话，还必须正是收到时挂着的那一个（不能去回答后来才冒出的新提问）。
      */
     const tryAnswer = (expectId?: string): boolean => {
-      if (input.attachments.length > 0) return false;
+      // 定时任务的提示词不是给挂着的提问的回答
+      if (task || input.attachments.length > 0) return false;
       const asking = interactions.findQuestion(key);
       if (!asking || asking.owner === undefined || asking.owner !== this.liveSessionId(key)) return false;
       if (expectId !== undefined && asking.id !== expectId) return false;
@@ -807,28 +853,49 @@ class Hub extends EventEmitter<{ event: [EventEnvelope] }> {
     // 闲置过期要按这次说话之前的活跃时间判断，所以先记下、后 touch
     const lastActive = conv.activeAt;
     touchConversation(key);
-    if (!conv.title && conv.channel === "web" && input.text.trim()) {
+    if (!conv.title && conv.channel === "web" && shown.text.trim()) {
       // 先用首条消息占位，第一轮结束后换成 agent 自己生成的短标题（syncTitle）
-      updateConversation(key, { title: input.text.trim().replace(/\s+/g, " ").slice(0, 40), titleAuto: true });
+      updateConversation(key, { title: shown.text.trim().replace(/\s+/g, " ").slice(0, 40), titleAuto: true });
       this.emitEvent(key, { type: "meta" });
     }
     this.emitEvent(key, shown);
+    const gone = (text: string) => {
+      if (task) this.emit("task", { ...task, key, status: "interrupted", text });
+    };
     void this.serial(key, async () => {
-      if (cancelled()) return;
+      if (cancelled()) return gone("没有发出（停止了或者会话被切换了）");
       if (questionAtEntry && tryAnswer(questionAtEntry)) return;
-      // 收到之后发生过显式切换（恢复 / 分叉 / 新会话…）：用户已经明确指定了会话，不再按旧的闲置时间作废它
+      // 收到之后发生过显式切换（恢复 / 分叉 / 新会话…）：用户已经明确指定了会话，不再按旧的闲置时间作废它。
+      // 定时任务也不按闲置过期：每天跑一次的任务要接着上次的上下文
       const ttl = config().sessionTtlMs;
       const switchedAfterEntry = (this.lastSwitch.get(key)?.at ?? 0) >= g.at;
-      const expired = !switchedAfterEntry && ttl > 0 && Date.now() - lastActive > ttl;
+      const expired = !task && !switchedAfterEntry && ttl > 0 && Date.now() - lastActive > ttl;
       if (expired) {
         await this.expireNow(key);
         // 清理要等旧会话 dispose，期间可能又点了停止
         if (cancelled()) return;
       }
-      this.sendNow(key, input);
+      this.sendNow(key, input, task ?? null);
     });
   }
 
+  /** 刚点过停止（被打断的那一轮还可能晚到一个出错，见 onError 里的 stopped） */
+  recentlyStopped(key: string): boolean {
+    return Date.now() - (this.stoppedAt.get(key) ?? 0) < 15_000;
+  }
+
+  /** 这条会话里正在跑的那一轮是不是定时任务发起的 */
+  currentTaskTurn(key: string): TaskTurn | undefined {
+    return this.turnTags.get(key)?.[0] ?? undefined;
+  }
+
+  private takeTurnTag(key: string): TaskTurn | null {
+    const tags = this.turnTags.get(key);
+    const tag = tags?.shift() ?? null;
+    if (tags && tags.length === 0) this.turnTags.delete(key);
+    return tag;
+  }
+
   /** 闲置太久：不再续用上次的会话（活着的也丢掉），开新的 */
   private async expireNow(key: string): Promise<void> {
     const conv = getConversation(key);
@@ -842,20 +909,29 @@ class Hub extends EventEmitter<{ event: [EventEnvelope] }> {
     this.emitEvent(key, { type: "meta" });
   }
 
-  private sendNow(key: string, input: UserInput): void {
+  private sendNow(key: string, input: UserInput, tag: TaskTurn | null): void {
+    const fail = (err: unknown) => {
+      const message = err instanceof Error ? err.message : String(err);
+      this.emitEvent(key, { type: "error", message });
+      if (tag) this.emit("task", { ...tag, key, status: "error", text: message });
+    };
     let session: AgentSession;
     try {
       session = this.session(key);
     } catch (err) {
-      this.emitEvent(key, { type: "error", message: err instanceof Error ? err.message : String(err) });
+      fail(err);
       return;
     }
     this.setInflight(key, (this.inflight.get(key) ?? 0) + 1);
+    const tags = this.turnTags.get(key) ?? [];
+    tags.push(tag);
+    this.turnTags.set(key, tags);
     try {
       session.send(input);
     } catch (err) {
+      tags.pop();
       this.setInflight(key, (this.inflight.get(key) ?? 1) - 1);
-      this.emitEvent(key, { type: "error", message: err instanceof Error ? err.message : String(err) });
+      fail(err);
     }
   }
 
@@ -1125,6 +1201,9 @@ class Hub extends EventEmitter<{ event: [EventEnvelope] }> {
     this.stoppedAt.set(key, Date.now());
     interactions.cancelAll(key, "本轮已中断");
     await this.live.get(key)?.session.interrupt();
+    // 和 inflight 一起清零：被打断的那一轮不一定还会报结果，留着的话下一轮的结果会被当成定时任务的
+    for (const tag of this.turnTags.get(key) ?? []) if (tag) this.emit("task", { ...tag, key, status: "interrupted", text: "被停止了" });
+    this.turnTags.delete(key);
     this.setInflight(key, 0);
     return "已请求中断。";
   }

package/src/core/memory-mcp.ts

@@ -9,7 +9,7 @@ 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 = (() => {
+export const tsxLoader = (() => {
   const require = createRequire(import.meta.url);
   // tsx/esm 的导出只有 import 条件，require.resolve 解不到；从包目录拼出来
   const pkg = require.resolve("tsx/package.json");

package/src/core/personal.ts

@@ -2,6 +2,7 @@
 import { deleteMemory, memoryPrompt, readMemory } from "./memory.js";
 import { purgeHistory } from "./chat-history.js";
 import { unlinkUser } from "./feishu-links.js";
+import { deleteUserTasks } from "./tasks.js";
 import type { Conversation } from "./store.js";
 import { getUser, legacyOwnerId } from "./users.js";
 
@@ -36,9 +37,10 @@ export function sessionMemory(
   };
 }
 
-/** 删用户时一起删掉的个人数据：记忆、聊天记录索引和飞书绑定 */
+/** 删用户时一起删掉的个人数据：记忆、聊天记录索引、飞书绑定和定时任务 */
 export function purgeUserData(userId: string): void {
   deleteMemory(userId);
   purgeHistory(userId);
   unlinkUser(userId);
+  deleteUserTasks(userId);
 }

package/src/core/store.ts

@@ -59,6 +59,8 @@ export type Conversation = {
   owner?: string;
   /** chat：聊天模式（/chat）。没有就是工作模式。属于对话，跨 /new 和切 agent 保留 */
   mode?: "chat";
+  /** 定时任务的专用对话：是哪个任务的（见 core/tasks.ts）。任务删了就清掉 */
+  taskId?: string;
 };
 
 type StoreShape = Record<string, Conversation>;

package/src/core/task-prompt.ts

@@ -0,0 +1,38 @@
+// 定时任务每次运行时发给 agent 的话：用户写的提示词 + 一段 agent-loft 附上的说明（用户看不到）。
+//
+// 「只在需要时提醒」靠一个暗号：agent 判断这次没什么要说的，就在回复第一行只写 SILENT_MARK，
+// hub 看到它就把这一轮标成 silent，推送和飞书都不发。没写暗号一律当成要提醒 —— 宁可多提醒一次，
+// 也不能漏掉。
+import { wrapContext } from "./chat-mode.js";
+import { formatDateTime, serverTimeZone } from "./task-schedule.js";
+
+export const SILENT_MARK = "[[静默]]";
+
+export function isSilentReply(text: string): boolean {
+  return text.trimStart().startsWith(SILENT_MARK);
+}
+
+/** 去掉暗号，剩下的是 agent 顺手记的检查结果 */
+export function stripSilentMark(text: string): string {
+  return isSilentReply(text) ? text.trimStart().slice(SILENT_MARK.length).trim() : text;
+}
+
+export function taskMessage(
+  task: { title: string; prompt: string; notify: "smart" | "always" },
+  opts: { now?: number; manual?: boolean; version?: string } = {},
+): string {
+  const now = opts.now ?? Date.now();
+  const lines = [
+    `这条消息是定时任务「${task.title}」${opts.manual ? "（用户刚才手动点了「立即运行」）" : "到点自动发来的"}，现在是 ${formatDateTime(now)}（${serverTimeZone()}）。${opts.manual ? "" : "用户此刻多半不在屏幕前，不要向他提问、等他回答。"}`,
+    ...(opts.version ? [`agent-loft 服务端当前版本：${opts.version}。`] : []),
+    "按上面的要求做；这条对话里以前运行的结果可以拿来对比（比如「和上次比有没有变化」）。",
+  ];
+  if (task.notify === "smart") {
+    lines.push(
+      "",
+      `用户希望只在有需要时才被提醒：如果按上面的要求，这次没有需要告诉他的事（比如没有更新、没有变化、条件没满足），回复的第一行只写 ${SILENT_MARK}，后面用一两句话记下这次检查的结果（下次可以对比），他就不会收到通知。`,
+      `有需要告诉他的事时正常回复，开头直接说结论，不要写 ${SILENT_MARK}。`,
+    );
+  }
+  return `${task.prompt}\n\n${wrapContext(lines)}`;
+}

package/src/core/task-runner.ts

@@ -0,0 +1,232 @@
+// 定时任务的调度：每 30 秒看一眼哪些到点了，核对主人和对话，把提示词送进对话；一轮结束后记下结果。
+//
+// 到点时的核对（任何一条不满足都不跑）：
+//   - 主人还在、没被停用；
+//   - 回到的对话还在、没被删，而且还是他的（飞书私聊换绑了账号之类会让对话换主人）—— 不满足就暂停任务；
+//   - 对话没在忙、也没挂着授权 / 提问：忙的话等它（最多 WAIT_MAX_MS），不能插进别人正在进行的那一轮，
+//     更不能被当成对挂着的提问的回答。
+import crypto from "node:crypto";
+import { config, resolveWorkspacePath } from "./config.js";
+import { hub, type TaskTurnEnd } from "./hub.js";
+import { interactions } from "./interactions.js";
+import { memoryOwnerOf } from "./personal.js";
+import { getConversation, updateAgentBinding, updateConversation, type Conversation } from "./store.js";
+import { formatDateTime } from "./task-schedule.js";
+import { stripSilentMark, taskMessage } from "./task-prompt.js";
+import { advance, allTasks, finishRun, pauseTask, persistTask, pushRun, runId, type Task, type TaskRun } from "./tasks.js";
+import { RUNNING_VERSION } from "./upgrade.js";
+import { getUser } from "./users.js";
+
+const TICK_MS = 30_000;
+/** 服务停着的时候错过的：错过不到这么久的，启动后补跑一次；更早的记一笔「错过了」 */
+const CATCHUP_MS = 2 * 3600_000;
+/** 到点时对话在忙：最多等这么久，还忙就跳过这一次 */
+const WAIT_MAX_MS = 30 * 60_000;
+/** 送出去之后对话已经不忙了、却一直没等到结果（被别的操作吞掉了）：这么久之后按中断记 */
+const LOST_MS = 2 * 60_000;
+
+/** 到点了、在等对话空下来的 */
+const waiting = new Map<string, { since: number }>();
+/** 正在跑的：任务 id → 这次运行 */
+const running = new Map<string, { runId: string; key: string; at: number }>();
+let timer: NodeJS.Timeout | null = null;
+
+/** 这条对话现在归谁（和记忆同一个规则：飞书群聊、没绑定的私聊没有主人） */
+function ownerOf(conv: Conversation): string | undefined {
+  return memoryOwnerOf(conv);
+}
+
+function preview(text: string, max = 120): string {
+  const plain = text
+    .replace(/```[\s\S]*?```/g, " [代码] ")
+    .replace(/[`*_~#>|]/g, "")
+    .replace(/\s+/g, " ")
+    .trim();
+  return plain.length > max ? `${plain.slice(0, max - 1)}…` : plain;
+}
+
+type Resolved = { key: string } | { pause: string } | { error: string };
+
+/** 这次该发到哪条对话；专用对话还没有（或者被删了）就新建一条 */
+function resolveConv(task: Task): Resolved {
+  if (task.target.kind === "conv") {
+    const conv = getConversation(task.target.key);
+    if (!conv || conv.hidden) return { pause: "回复的那条对话已经被删除，任务已暂停。可以改成「专用对话」后再启用。" };
+    if (ownerOf(conv) !== task.owner) return { pause: "回复的那条对话已经不属于你了，任务已暂停。" };
+    return { key: conv.key };
+  }
+  const existing = task.target.key ? getConversation(task.target.key) : undefined;
+  if (existing && !existing.hidden && existing.taskId === task.id && ownerOf(existing) === task.owner) return { key: existing.key };
+
+  const enabled = hub.enabledAgents().map((d) => d.id);
+  if (!enabled.includes(task.agent)) return { error: `${hub.label(task.agent)} 没有启用` };
+  let cwd: string | null = null;
+  if (task.cwd) {
+    cwd = resolveWorkspacePath(task.cwd);
+    if (!cwd) return { error: `工作目录 ${task.cwd} 不存在了（或者不在工作区里），改一下任务的目录` };
+  }
+  const key = `web:${crypto.randomBytes(6).toString("hex")}`;
+  // 侧栏里专用对话前面有时钟图标（taskId），标题不用再加
+  hub.ensure({ key, channel: "web", channelId: "web", defaultAgent: task.agent, owner: task.owner, title: task.title.slice(0, 80) });
+  updateConversation(key, {
+    titleAuto: false,
+    taskId: task.id,
+    ...(task.mode === "chat" ? { mode: "chat" as const } : {}),
+    ...(cwd && cwd !== config().workspaceRoot ? { cwd, cwdExplicit: true } : {}),
+  });
+  if (task.model || task.effort) {
+    updateAgentBinding(key, task.agent, { ...(task.model ? { model: task.model } : {}), ...(task.effort ? { effort: task.effort } : {}) });
+  }
+  task.target = { kind: "dedicated", key };
+  persistTask(task);
+  hub.emitEvent(key, { type: "meta" });
+  return { key };
+}
+
+function record(task: Task, status: TaskRun["status"], note: string, now = Date.now()): void {
+  pushRun(task, { id: runId(), at: now, endedAt: now, status, note });
+}
+
+/**
+ * 试着跑一次。manual：用户点了「立即运行」—— 对话忙就直接报错，不排队。
+ * 返回给人看的错误；undefined 表示已经送出去了（或者在排队等）。
+ */
+function fire(task: Task, manual: boolean, now = Date.now()): string | undefined {
+  const user = getUser(task.owner);
+  if (!user || user.disabled) {
+    waiting.delete(task.id);
+    record(task, "skipped", "账号已停用", now);
+    return "账号已停用";
+  }
+  const where = resolveConv(task);
+  if ("pause" in where) {
+    waiting.delete(task.id);
+    pauseTask(task, where.pause, now);
+    return where.pause;
+  }
+  if ("error" in where) {
+    waiting.delete(task.id);
+    record(task, "error", where.error, now);
+    return where.error;
+  }
+  const key = where.key;
+  const conv = getConversation(key)!;
+  if (!hub.enabledAgents().some((d) => d.id === conv.agent)) {
+    waiting.delete(task.id);
+    record(task, "error", `${hub.label(conv.agent)} 没有启用`, now);
+    return `${hub.label(conv.agent)} 没有启用`;
+  }
+  // 刚点过停止的也当忙：被打断的那一轮可能还会晚到一个出错，别让它算到这次运行头上
+  if (hub.isBusy(key) || hub.recentlyStopped(key) || interactions.listPending(key).length > 0) {
+    if (manual) return "这条对话正在回复或者在等你处理授权，等它结束再试";
+    const since = waiting.get(task.id)?.since ?? now;
+    if (now - since > WAIT_MAX_MS) {
+      waiting.delete(task.id);
+      record(task, "skipped", `对话一直在忙（等了 ${WAIT_MAX_MS / 60_000} 分钟），跳过了这一次`, now);
+    } else {
+      waiting.set(task.id, { since });
+    }
+    return undefined;
+  }
+  waiting.delete(task.id);
+  const run = pushRun(task, { id: runId(), at: now, status: "running", convKey: key, ...(manual ? { note: "手动运行" } : {}) });
+  running.set(task.id, { runId: run.id, key, at: now });
+  console.log(`[定时任务] ${task.id}「${task.title}」${manual ? "手动运行" : "到点运行"}，发到 ${key}`);
+  hub.send(
+    key,
+    { text: taskMessage(task, { now, manual, version: RUNNING_VERSION }), attachments: [] },
+    { channel: "task", channelId: task.id, name: `定时任务「${task.title}」` },
+    undefined,
+    { task: { taskId: task.id, runId: run.id, title: task.title, smart: task.notify === "smart" } },
+  );
+  return undefined;
+}
+
+function onTurnEnd(e: TaskTurnEnd): void {
+  const cur = running.get(e.taskId);
+  if (cur?.runId === e.runId) running.delete(e.taskId);
+  const text = e.status === "notified" || e.status === "silent" ? preview(stripSilentMark(e.text)) : "";
+  finishRun(e.taskId, e.runId, {
+    status: e.status,
+    endedAt: Date.now(),
+    ...(text ? { preview: text } : {}),
+    ...(e.status === "error" || e.status === "interrupted" ? { note: preview(e.text) } : {}),
+  });
+}
+
+function tick(): void {
+  const now = Date.now();
+  for (const [taskId, cur] of running) {
+    // 送出去了，对话早就不忙了，却没等到结果：被吞掉了（比如期间切了会话），别让它永远「运行中」
+    if (now - cur.at > LOST_MS && !hub.isBusy(cur.key) && hub.currentTaskTurn(cur.key)?.runId !== cur.runId) {
+      running.delete(taskId);
+      finishRun(taskId, cur.runId, { status: "interrupted", endedAt: now, note: "没有拿到结果" });
+    }
+  }
+  for (const task of allTasks()) {
+    if (running.has(task.id)) continue;
+    if (waiting.has(task.id)) {
+      // 等着的时候被暂停了：这次就不跑了（「一次」的任务到点时已经自动停用，照样要跑完这一次）
+      if (!task.enabled && task.schedule.kind !== "once") waiting.delete(task.id);
+      else fire(task, false, now);
+      continue;
+    }
+    if (!task.enabled || task.nextRunAt === undefined || task.nextRunAt > now) continue;
+    // 先把下一次算好再跑：跑的过程中出了什么岔子，也不会在下一个 tick 又跑一遍
+    advance(task, now);
+    fire(task, false, now);
+  }
+}
+
+/** 网页上点「立即运行」 */
+export function runTaskNow(task: Task): string | undefined {
+  if (running.has(task.id)) return "这个任务正在运行";
+  return fire(task, true);
+}
+
+export function isTaskRunning(id: string): boolean {
+  return running.has(id) || waiting.has(id);
+}
+
+/** 任务删了：它的专用对话留着（里面有历史），只是不再是谁的专用对话 */
+export function forgetTask(task: Task): void {
+  waiting.delete(task.id);
+  running.delete(task.id);
+  if (task.target.kind === "dedicated" && task.target.key) {
+    const conv = getConversation(task.target.key);
+    if (conv?.taskId === task.id) {
+      updateConversation(conv.key, { taskId: undefined });
+      hub.emitEvent(conv.key, { type: "meta" });
+    }
+  }
+}
+
+export function startTaskRunner(): void {
+  if (timer) return;
+  const now = Date.now();
+  for (const task of allTasks()) {
+    // 上次进程退出时还在跑的：结果已经拿不到了
+    let dirty = false;
+    for (const run of task.runs) {
+      if (run.status !== "running") continue;
+      Object.assign(run, { status: "interrupted", endedAt: now, note: "服务重启，这次运行被打断了" });
+      dirty = true;
+    }
+    if (dirty) persistTask(task);
+    if (task.enabled && task.nextRunAt !== undefined && task.nextRunAt < now - CATCHUP_MS) {
+      record(task, "skipped", `服务没在运行，错过了 ${formatDateTime(task.nextRunAt)} 这一次`, now);
+      advance(task, now);
+    }
+  }
+  hub.on("task", onTurnEnd);
+  timer = setInterval(tick, TICK_MS);
+  timer.unref();
+  // 等 agent 起来了再补跑错过的
+  setTimeout(tick, 5_000).unref();
+}
+
+export function stopTaskRunner(): void {
+  if (timer) clearInterval(timer);
+  timer = null;
+  hub.off("task", onTurnEnd);
+}