Skip to content

🤖 Open-source, local-first alternative to Grok Bot, OpenAI dots and Claude Duet. Your own AI bots on any model: GPT, Claude, Gemini, Grok, DeepSeek, Kimi, GLM and 70+ more through one Modelflare key. Reach them in the app, WeChat or Feishu; they remember you, work in the background, run commands and use your computer. Pay per use.

Merge origin/master into feat/p3d-rules (server i18n)

Marla23d9902f1017
diff --cc src/agent/manager.ts
index 3766daa,6e7aca5..0d723b1
--- a/src/agent/manager.ts
+++ b/src/agent/manager.ts
@@@ -12,9 -12,8 +12,9 @@@ import type { MediaModel, MediaPlan, Me
import { APPROVAL_TTL_MS, ApprovalCenter, TASK_APPROVAL_TTL_MS, type QuestionItem } from "./approvals.js";
import { MemoryError, MemoryStore, type Scope } from "./memory.js";
import type { TaskHost, TaskService } from "../tasks/service.js";
+import { RULE_APPROVAL_TTL_MS } from "../tasks/rules.js";
import { DEFAULT_SETTINGS, type BotSettings, type MediaConfirm } from "./settings.js";
- import { t, tl } from "../i18n/index.js";
+ import { t, tl, t as tr } from "../i18n/index.js";
import {
HANDOFF_SYSTEM,
REVIEW_SYSTEM,
diff --cc src/app.ts
index 9bde72e,97a03b9..c95319e
--- a/src/app.ts
+++ b/src/app.ts
@@@ -44,9 -44,7 +44,9 @@@ import { MediaService, pickDefault } fr
import { COMPACT_ENDPOINT, serverCompactionEnabled, type CompactEndpoint } from "./agent/server-compaction.js";
import type { BotSettings } from "./agent/settings.js";
import { TaskService } from "./tasks/service.js";
+import { RuleEvents } from "./tasks/rule-events.js";
+import { lockDataDir, type DataDirLock } from "./store/lock.js";
- import { detached, setLangPref, t } from "./i18n/index.js";
+ import { detached, setLangPref, t, t as tr } from "./i18n/index.js";
import { Attention, approvalItems, deliveryItem, type AttentionItem } from "./tasks/attention.js";
const log = logger("app");
diff --cc src/i18n/messages/app.ts
index 9cd1953,de76876..e56fba6
--- a/src/i18n/messages/app.ts
+++ b/src/i18n/messages/app.ts
@@@ -20,9 -20,7 +20,10 @@@ export const zh =
media_quoted_video: "引用的视频",
media_voice: "[语音]",
media_not_downloaded: "{label}(未能下载:{error})",
+ weixinExpiredSubject: "微信登录已过期",
+ // 数据目录锁(store/lock.ts):同一个数据目录只能有一个宿主
+ data_dir_locked: "数据目录 {dir} 正被另一个 anymodel bot 进程使用({who})。先退出它,或者换一个数据目录(AMB_DATA_DIR)。",
+ data_dir_locked_remote: "{host} 上的 pid {pid}",
} satisfies Catalog;
export const en: Catalog<typeof zh> = {
@@@ -42,6 -40,5 +43,7 @@@
media_quoted_video: "Quoted video",
media_voice: "[Voice]",
media_not_downloaded: "{label} (couldn't download: {error})",
+ weixinExpiredSubject: "WeChat sign-in expired",
+ data_dir_locked: "Another anymodel bot process ({who}) is using the data directory {dir}. Quit it, or use another data directory (AMB_DATA_DIR).",
+ data_dir_locked_remote: "pid {pid} on {host}",
};
diff --cc src/i18n/messages/index.ts
index a689bf8,b33759b..2974ef3
--- a/src/i18n/messages/index.ts
+++ b/src/i18n/messages/index.ts
@@@ -13,6 -13,10 +13,11 @@@ import * as approvals from "./approvals
import * as media from "./media.js";
import * as cu from "./cu.js";
import * as pwsh from "./pwsh.js";
+ import * as activity from "./activity.js";
+ import * as tasks from "./tasks.js";
+ import * as access from "./access.js";
+ import * as delivery from "./delivery.js";
+ import * as cli from "./cli.js";
+import * as rules from "./rules.js";
- export const catalogs = { web, desktop, app, diag, modelflare, account, magpie, channel, runtime, agent, approvals, media, cu, pwsh, rules };
-export const catalogs = { web, desktop, app, diag, modelflare, account, magpie, channel, runtime, agent, approvals, media, cu, pwsh, activity, tasks, access, delivery, cli };
++export const catalogs = { web, desktop, app, diag, modelflare, account, magpie, channel, runtime, agent, approvals, media, cu, pwsh, activity, tasks, access, delivery, cli, rules };
diff --cc src/i18n/messages/rules.ts
index 3243792,0000000..b51e2e5
mode 100644,000000..100644
--- a/src/i18n/messages/rules.ts
+++ b/src/i18n/messages/rules.ts
@@@ -1,180 -1,0 +1,162 @@@
+// rules(3d):zh 与 en 的键必须一一对应(en 的类型由 zh 推出,少一个多一个都过不了类型检查)。
+// 用户看得到的规则文字:时间表的话、状态、运行记录的一行、「需要你」、推送的暂停那句、建规则时建议的回复、接口的报错。
+// 给模型看的(规则段、第一条输入、工具说明和工具返回里的指示)不在这里。
+import type { Catalog } from "../types.js";
+
+export const zh = {
+ // 时间表的话(tasks/schedule.ts describe)
+ daily: "每天 {time}",
+ weekdays: "每个工作日 {time}",
+ weekends: "每个周末 {time}",
+ weekly: "每{days} {time}",
+ daysSep: "、",
+ everyMin: { other: "每 {count} 分钟" },
+ everyHour: { other: "每 {count} 小时" },
+ once: "{date} {time}",
+ cron: "cron {cron}",
+ withZone: "{text}({tz})",
+ event: "事件 {source}",
+ // 状态(tasks/rules.ts ruleState)
+ statePaused: "已暂停",
+ stateOff: "已关闭",
+ stateDone: "已结束",
+ stateRemind: "提醒",
+ stateObserve: "观察中",
+ stateAct: "执行中",
- // 运行记录的一行(tasks/rules.ts runLine)
- queued: "排队中",
++ // 运行记录的一行(tasks/rules.ts runLine;排队中、已停止、预算用完用 tasks.* 的)
+ running: "正在运行",
+ skipped: "跳过:{why}",
+ failed: "失败:{why}",
+ interrupted: "中断:应用重启了",
- stopped: "已停止",
- budget: "预算用完",
+ reminded: "已提醒:“{text}”",
+ sent: "已发送:“{text}”",
+ pending: "待发送:“{text}”",
+ unsent: "未送达:“{text}”",
+ wouldSend: "本会发送:“{text}”",
+ wouldDo: "本会做:{text}",
+ wouldQuiet: "本会保持安静",
+ wouldQuietNote: "本会保持安静:{note}",
+ quiet: "保持安静",
+ quietNote: "保持安静:{note}",
+ needsApproval: "需要批准:{what}",
+ permReadOnly: "只读",
+ permWorkspace: "可写工作区",
- // 跳过、失败的原因(存的是代码,显示时再翻)
++ // 跳过、失败的原因(存的是代码,显示时再翻;没有给出结果、模型一直出错、代理没能启动 / 不可用用 tasks.* 的)
+ whyAppOff: "电脑没开",
+ whyBusy: "一直在忙",
+ whyOverlap: "上次还没跑完",
+ whyRestart: "应用重启了",
+ whyTimeout: "超时",
+ whyApprovalTimeout: "批准超时",
- whyNoReport: "没有给出结果",
- whyModelErrors: "模型一直出错",
- whyAgentFailed: "代理没能启动",
- whyAgentUnavailable: "代理不可用",
+ // 「需要你」
+ subject: "规则「{title}」",
+ failingPaused: { other: "连续失败 {count} 次,已暂停" },
+ failing: { other: "连续失败 {count} 次" },
+ // 推送:连续失败暂停了(执行中的规则)
+ pausedPush: "⚠️ 规则「{title}」连续失败 {count} 次,已暂停:{why}",
+ // 建规则时建议给用户的那句(经聊天代理转述)
+ createdReply: "已建好规则:{when} {title}。先观察几天,只记录不打扰你;在「任务」里可以改成执行。",
+ remindReply: "好,{when} 提醒你。",
+ weixinNote: "微信只在你 24 小时内发过消息时才能主动发给你;否则会在你下次发消息时一起送到,并显示在桌面端。",
- // /tasks、/stop 编号
++ // /tasks、/stop 编号(行的写法、提示语用 tasks.* 的)
+ listHead: "规则:",
- listLine: "{n}. {when} {title} · {state}",
- stopHint: "发 /stop 编号 可停止。",
+ turnedOff: "已关闭规则「{title}」。",
+ // 接口和编辑的报错
+ notFound: "规则不存在",
+ runNotFound: "没有这次运行",
+ badSchedule: "时间表不对",
+ badMode: "模式只能是关、观察或执行",
+ createFailed: "没能建好",
+ saveFailed: "没能保存",
+ nameEmpty: "名称不能为空",
+ wordsEmpty: "规则不能为空",
+ messageEmpty: "提醒的话不能为空",
+ noConversation: "没有这个会话",
+ eventNoSchedule: "这条规则由事件触发,没有时间表",
+ remindNoObserve: "提醒没有观察模式",
+ isOff: "规则关着",
+ isRunning: "正在运行",
+ // 时间表的报错(tasks/schedule.ts normalizeSchedule)
+ needTime: "缺少时间",
+ pastTime: "这个时间已经过了",
+ timeFormat: "时间要写成 08:00 这样",
+ pickDays: "选一天或几天",
+ minEvery: "间隔至少 {min} 分钟",
+ maxEvery: "间隔最长 7 天",
+ cronFields: "cron 要写 5 段:分 时 日 月 星期",
+ unknownSchedule: "不认识的时间表",
+} satisfies Catalog;
+
+export const en: Catalog<typeof zh> = {
+ daily: "Daily {time}",
+ weekdays: "Weekdays {time}",
+ weekends: "Weekends {time}",
+ weekly: "Every {days} {time}",
+ daysSep: ", ",
+ everyMin: { other: "Every {count} min" },
+ everyHour: { one: "Every hour", other: "Every {count} hours" },
+ once: "{date} {time}",
+ cron: "cron {cron}",
+ withZone: "{text} ({tz})",
+ event: "Event {source}",
+ statePaused: "Paused",
+ stateOff: "Off",
+ stateDone: "Done",
+ stateRemind: "Reminder",
+ stateObserve: "Observing",
+ stateAct: "Acting",
- queued: "Queued",
+ running: "Running",
+ skipped: "Skipped: {why}",
+ failed: "Failed: {why}",
+ interrupted: "Interrupted: the app restarted",
- stopped: "Stopped",
- budget: "Budget used up",
+ reminded: "Reminded: “{text}”",
+ sent: "Sent: “{text}”",
+ pending: "Waiting to send: “{text}”",
+ unsent: "Not delivered: “{text}”",
+ wouldSend: "Would send: “{text}”",
+ wouldDo: "Would do: {text}",
+ wouldQuiet: "Would stay quiet",
+ wouldQuietNote: "Would stay quiet: {note}",
+ quiet: "Stayed quiet",
+ quietNote: "Stayed quiet: {note}",
+ needsApproval: "Needs approval: {what}",
+ permReadOnly: "Read-only",
+ permWorkspace: "Can write the workspace",
+ whyAppOff: "the computer was off",
+ whyBusy: "no free slot",
+ whyOverlap: "the last run was still going",
+ whyRestart: "the app restarted",
+ whyTimeout: "timed out",
+ whyApprovalTimeout: "approval timed out",
- whyNoReport: "no result",
- whyModelErrors: "the model kept failing",
- whyAgentFailed: "the agent didn't start",
- whyAgentUnavailable: "the agent is unavailable",
+ subject: "Rule “{title}”",
+ failingPaused: { one: "Failed {count} time in a row, paused", other: "Failed {count} times in a row, paused" },
+ failing: { one: "Failed {count} time in a row", other: "Failed {count} times in a row" },
+ pausedPush: "⚠️ Rule “{title}” failed {count} times in a row and is paused: {why}",
+ createdReply: "Rule set: {title}, {when}. It watches quietly for a few days; switch it to act under Tasks.",
+ remindReply: "OK, reminder set for {when}.",
+ weixinNote: "WeChat lets the bot message you only within 24 hours of your last message. Otherwise it arrives with your next message and shows on the desktop.",
+ listHead: "Rules:",
- listLine: "{n}. {when} {title} · {state}",
- stopHint: "Send /stop <number> to stop one.",
+ turnedOff: "Rule “{title}” is off.",
+ notFound: "Rule not found",
+ runNotFound: "No such run",
+ badSchedule: "Invalid schedule",
+ badMode: "Mode must be off, observe or act",
+ createFailed: "Couldn't create the rule",
+ saveFailed: "Couldn't save",
+ nameEmpty: "Name can't be empty",
+ wordsEmpty: "The rule can't be empty",
+ messageEmpty: "The reminder text can't be empty",
+ noConversation: "No such conversation",
+ eventNoSchedule: "This rule runs on events and has no schedule",
+ remindNoObserve: "Reminders have no observe mode",
+ isOff: "The rule is off",
+ isRunning: "Already running",
+ needTime: "Pick a time",
+ pastTime: "That time has passed",
+ timeFormat: "Write the time like 08:00",
+ pickDays: "Pick one or more days",
+ minEvery: "The interval must be at least {min} minutes",
+ maxEvery: "The interval can be at most 7 days",
+ cronFields: "cron needs 5 fields: minute hour day month weekday",
+ unknownSchedule: "Unknown schedule",
+};
diff --cc src/tasks/attention.ts
index d4f0dd9,ff00179..0c5f0c0
--- a/src/tasks/attention.ts
+++ b/src/tasks/attention.ts
@@@ -185,8 -182,8 +185,8 @@@ export function approvalItems(store: St
kind: r.kind,
botId: r.botId,
botName: store.getBot(r.botId)?.name ?? r.botId,
- subject: task?.title ?? (rule ? t("rules.subject", { title: rule.title }) : (CHANNEL[channel] ?? "对话")),
- status: r.kind === "approval" ? "等你批准" : "等你回答",
- subject: task?.title ?? channelLabel(channel) ?? tr("tasks.chWeb"),
++ subject: task?.title ?? (rule ? tr("rules.subject", { title: rule.title }) : (channelLabel(channel) ?? tr("tasks.chWeb"))),
+ status: r.kind === "approval" ? tr("tasks.stageApproval") : tr("tasks.stageAnswer"),
line: line.length > 300 ? line.slice(0, 299) + "…" : line,
since: r.createdAt,
severity: "warn",
diff --cc src/tasks/rules.ts
index 075d365,0000000..12cfee0
mode 100644,000000..100644
--- a/src/tasks/rules.ts
+++ b/src/tasks/rules.ts
@@@ -1,221 -1,0 +1,225 @@@
+/**
+ * 规则(3d)的纯函数部分:状态、给人看的一行、每种模式的权限和去掉的工具。写库的是任务服务(service.ts,唯一的写入者)。
+ *
+ * 状态(第一条符合的为准):暂停了(连续失败 3 次)→ 已暂停;关了 → 已关闭;一次性的跑过了 → 已结束;提醒 → 提醒;
+ * 观察中(含改了原话后先观察的那一次)→ 观察中;其余 → 执行中。状态是"点 + 文字":红 = 暂停,绿 = 执行中、提醒,灰 = 观察、关闭、结束。
+ * 给人看的文字跟着语言(src/i18n 的 rules.*);跳过、失败的原因存成代码(RUN_ERROR),显示时再翻。
+ */
+import type { OutboxRow, RuleMode, RuleRow, RunRow } from "../store/db.js";
+import { lang as currentLang, tl, type Lang, type MessageKey } from "../i18n/index.js";
+import { describe } from "./schedule.js";
+
+/** 连续失败几次自动暂停 */
+export const RULE_FAILS_TO_PAUSE = 3;
+/** 连续失败几次出现在「需要你」里 */
+export const RULE_FAILS_TO_SHOW = 2;
+/** 观察几次好的之后提示改为执行 */
+export const RULE_HINT_AFTER = 3;
+/** 改了原话之后先观察几次(产品负责人:1 次) */
+export const RULE_OBSERVE_AFTER_EDIT = 1;
+/** 每个机器人最多几条规则 */
+export const MAX_RULES = 30;
+/** 一次运行最长多久(不算等批准的时间) */
+export const RULE_RUN_CAP_MS = 15 * 60_000;
+/** 执行时的审批在「需要你」里等多久,过了就拒绝、这次运行失败 */
+export const RULE_APPROVAL_TTL_MS = 3600_000;
+
+/**
+ * 规则会话去掉的工具(只去掉注册了的;插件按 tools.restrict 的规矩过滤)。观察:能改变什么的都去掉,记忆只留 recall;
+ * 执行:上限是可写工作区(决定 12),电脑操作和生图、生视频不给(设计第 7 节:除非规则上开了,3d 不做这个开关)。
+ */
+const COMMON_DENY = ["present", "ask_user_question", "task_start", "task_message", "task_list", "rule_create", "rule_update", "generate_image", "generate_video", "media_models", "media_docs"];
+export const RULE_DENY: Readonly<Record<"observe" | "act", string[]>> = {
+ observe: [...COMMON_DENY, "remember", "forget"],
+ act: COMMON_DENY,
+};
+/** 按前缀拒绝的工具(MCP 的电脑操作,名字随平台变化,没法列全) */
+export const RULE_DENY_PREFIX = ["mcp__computer-use__"];
+
+/** 这次运行用的模式:改了原话后先观察 observeLeft 次 */
+export function runMode(rule: Pick<RuleRow, "mode" | "observeLeft" | "kind">): "observe" | "act" {
+ if (rule.kind === "remind") return "act";
+ return rule.mode === "act" && rule.observeLeft <= 0 ? "act" : "observe";
+}
+
+/** DSH 的沙箱:观察只读;执行是机器人的预设和可写工作区里取小的(完全权限的机器人也一样,决定 12) */
+export function rulePermission(mode: "observe" | "act", botPreset: string): "read-only" | "workspace-write" {
+ return mode === "observe" || botPreset === "readonly" ? "read-only" : "workspace-write";
+}
+
+export interface RuleState {
+ key: "paused" | "off" | "done" | "remind" | "observe" | "act";
+ label: string;
+ /** 状态点:err 红、ok 绿、空 = 灰 */
+ dot: "" | "ok" | "err";
+}
+
+export function ruleState(rule: RuleRow, live = false, l: Lang = currentLang()): RuleState {
+ const s = (key: RuleState["key"], label: MessageKey, dot: RuleState["dot"]): RuleState => ({ key, label: tl(l, label), dot });
+ if (rule.pausedReason) return s("paused", "rules.statePaused", "err");
+ if (rule.mode === "off") return s("off", "rules.stateOff", "");
+ if (!live && !rule.nextRunAt && rule.trigger.kind === "schedule") return s("done", "rules.stateDone", "");
+ if (rule.kind === "remind") return s("remind", "rules.stateRemind", "ok");
+ if (runMode(rule) === "observe") return s("observe", "rules.stateObserve", "");
+ return s("act", "rules.stateAct", "ok");
+}
+
+/** 规则在界面上的样子 */
+export interface RuleView {
+ id: string;
+ botId: string;
+ conversationId: string;
+ channel: string;
+ title: string;
+ instruction: string;
+ message: string;
+ kind: RuleRow["kind"];
+ trigger: RuleRow["trigger"];
+ /** 时间表的话:每天 08:00;事件触发的是来源 */
+ when: string;
+ mode: RuleMode;
+ /** 改了原话后还要先观察几次 */
+ observeLeft: number;
+ state: RuleState;
+ nextRunAt: number;
+ /** 最近一次:时间、结果、一行 */
+ last?: { at: number; outcome: string; line: string };
+ /** 已观察 3 次(这一版)、可以改为执行 */
+ hint: boolean;
+ /** 这一版好好观察过几次 */
+ observed: number;
+ failures: number;
+ folder: string;
+ version: number;
+ createdAt: number;
+ updatedAt: number;
+ /** 正在跑(或排队)的那一次 */
+ live?: { runId: string; state: string; since: number };
+}
+
+export function whenOf(rule: Pick<RuleRow, "trigger">, withZone = false, l: Lang = currentLang()): string {
+ return rule.trigger.kind === "schedule" ? describe(rule.trigger.schedule, withZone, l) : tl(l, "rules.event", { source: rule.trigger.source });
+}
+
+/** 跳过、失败的原因:存进 runs.error 的代码(显示时按语言翻,见 errorText) */
+export const RUN_ERROR = {
+ appOff: "app_off",
+ busy: "busy",
+ overlap: "overlap",
+ restart: "restart",
+ timeout: "timeout",
+ approvalTimeout: "approval_timeout",
++ noReport: "no_report",
++ modelErrors: "model_errors",
++ agentFailed: "agent_failed",
++ agentUnavailable: "agent_unavailable",
+} as const;
+
- /** 原因 → 词条:规则自己的代码,和任务、规则共用的那套 run 写进去的说法(3a) */
++/** 原因 → 词条:规则自己的,和任务共用的那几种(tasks.*,和任务失败时的说法一样) */
+const WHY: Record<string, MessageKey> = {
+ app_off: "rules.whyAppOff",
+ busy: "rules.whyBusy",
+ overlap: "rules.whyOverlap",
+ restart: "rules.whyRestart",
+ timeout: "rules.whyTimeout",
+ approval_timeout: "rules.whyApprovalTimeout",
- 没有给出结果: "rules.whyNoReport",
- 模型一直出错: "rules.whyModelErrors",
- 代理没能启动: "rules.whyAgentFailed",
- 代理不可用: "rules.whyAgentUnavailable",
++ no_report: "tasks.noResult",
++ model_errors: "tasks.modelKeptFailing",
++ agent_failed: "tasks.agentDidntStart",
++ agent_unavailable: "tasks.agentUnavailable",
+};
+
+/** 存下来的原因给人看:认得的翻成当前语言,其余(模型自己说的)原样 */
+export function errorText(error: string, l: Lang = currentLang()): string {
+ const key = WHY[error];
+ return key ? tl(l, key) : error;
+}
+
+/** 观察时要批准、被自动拒绝的事:在 runs.would 里一行一个,带这个前缀(显示时翻成「需要批准:…」) */
+export const WOULD_APPROVAL = "approval: ";
+
+/** runs.would 给人看:需要批准的那几行按语言翻,模型写的原样 */
+export function wouldText(would: string, l: Lang = currentLang()): string {
+ return would
+ .split("\n")
+ .map((x) => (x.startsWith(WOULD_APPROVAL) ? tl(l, "rules.needsApproval", { what: x.slice(WOULD_APPROVAL.length) }) : x))
+ .join("\n");
+}
+
+/** DSH 的沙箱 → 给人看的权限 */
+export function permissionText(p: string, l: Lang = currentLang()): string {
+ return p === "read-only" ? tl(l, "rules.permReadOnly") : p === "workspace-write" ? tl(l, "rules.permWorkspace") : "";
+}
+
+const clip = (s: string, n: number) => (s.length > n ? s.slice(0, n - 1) + "…" : s);
+const oneLine = (s: string) => s.replace(/\s+/g, " ").trim();
+
+/** 出站队列里那一条的送达状态(合进摘要的看那一条)→ 已发送 / 待发送 / 未送达 */
+function sentKey(row: OutboxRow | undefined): "rules.sent" | "rules.unsent" | "rules.pending" {
+ if (!row || row.status === "sent" || row.status === "merged") return "rules.sent";
+ if (row.status === "held" || row.status === "gone" || row.attempts >= 3) return "rules.unsent";
+ return "rules.pending";
+}
+
+/**
+ * 运行记录的一行(设计第 6 节「Auditing a rule」):
+ * 观察:本会发送:“…” / 本会做:… / 本会保持安静;执行:已发送:“…”(待发送、未送达)/ 保持安静;提醒:已提醒:“…”;
+ * 失败:…;跳过:电脑没开;中断。
+ */
+export function runLine(run: RunRow, kind: RuleRow["kind"], carrier?: OutboxRow, l: Lang = currentLang()): string {
- if (run.state === "queued") return tl(l, "rules.queued");
++ if (run.state === "queued") return tl(l, "tasks.stageQueued");
+ if (run.state !== "ended") return tl(l, "rules.running");
+ const r = run.report;
+ const msg = oneLine(r?.message ?? "");
+ const note = oneLine(r?.summary.split("\n")[0] ?? "");
+ switch (run.outcome) {
+ case "skipped":
+ return tl(l, "rules.skipped", { why: errorText(run.error || RUN_ERROR.appOff, l) });
+ case "failed":
- return tl(l, "rules.failed", { why: clip(oneLine(r?.message || errorText(run.error || "没有给出结果", l)), 120) });
++ return tl(l, "rules.failed", { why: clip(oneLine(r?.message || errorText(run.error || RUN_ERROR.noReport, l)), 120) });
+ case "interrupted":
+ return tl(l, "rules.interrupted");
+ case "stopped":
- return tl(l, "rules.stopped");
++ return tl(l, "tasks.stageStopped");
+ case "budget":
- return tl(l, "rules.budget");
++ return tl(l, "tasks.stageBudget");
+ case "done":
+ break;
+ default:
+ return run.outcome;
+ }
+ const text = clip(msg, 120);
+ if (kind === "remind") {
+ const key = sentKey(carrier);
+ return tl(l, key === "rules.sent" ? "rules.reminded" : key, { text });
+ }
+ const would = oneLine(wouldText(run.would || r?.would || "", l));
+ if (run.mode === "observe") {
+ if (msg) return tl(l, "rules.wouldSend", { text });
+ if (would) return tl(l, "rules.wouldDo", { text: clip(would, 120) });
+ return note ? tl(l, "rules.wouldQuietNote", { note: clip(note, 60) }) : tl(l, "rules.wouldQuiet");
+ }
+ if (msg) return tl(l, sentKey(carrier), { text });
+ return note ? tl(l, "rules.quietNote", { note: clip(note, 60) }) : tl(l, "rules.quiet");
+}
+
+/** 运行记录里的一项(界面展开看报告、步骤、版本和权限) */
+export interface RuleRunView {
+ id: string;
+ at: number;
+ mode: string;
+ cause: string;
+ state: string;
+ outcome: string;
+ line: string;
+ summary: string;
+ message: string;
+ would: string;
+ error: string;
+ version: number;
+ /** 那次的权限:只读 / 可写工作区 */
+ permission: string;
+ steps: number;
+ startedAt: number;
+ endedAt: number;
+}
diff --cc src/tasks/service.ts
index fbcb088,3925afa..9867208
--- a/src/tasks/service.ts
+++ b/src/tasks/service.ts
@@@ -29,41 -25,14 +29,41 @@@ import { ActivityLog, type ActivitySte
import { ResumeFailed, deliverables } from "../agent/host.js";
import { answerLine, promptButtons, questionsOf, taskPromptText, type ApprovalCenter, type ApprovalEvent, type QuestionItem, type ReplyContext } from "../agent/approvals.js";
import { actionCardSpec } from "../channels/feishu/transport.js";
-import { NUDGE, attachmentsOf, rebrief, recoveryNote, retryNote, taskBrief } from "../agent/prompts/index.js";
+import { NUDGE, RULE_NUDGE, RULE_RERUN, RULE_RESULT_SYSTEM, attachmentsOf, rebrief, recoveryNote, retryNote, ruleBrief, ruleResultInput, ruleRules, taskBrief } from "../agent/prompts/index.js";
import type { BotSettings } from "../agent/settings.js";
-import type { ApprovalRow, Conversation, InputKind, RunCause, RunInputRow, RunOutcome, RunRow, Store, TaskReport, TaskRow } from "../store/db.js";
+import type { ApprovalRow, Conversation, InputKind, RuleKind, RuleMode, RuleRow, RuleTrigger, RunCause, RunInputRow, RunOutcome, RunRow, Store, TaskReport, TaskRow } from "../store/db.js";
import type { AttentionItem } from "./attention.js";
import { logger } from "../log.js";
+import { localParts, systemTimeZone } from "../core/quiet.js";
- import { t } from "../i18n/index.js";
import { DEFAULT_MAX_BACKGROUND, pickRuns, priorityOf } from "./slots.js";
import { taskStage, type Stage } from "./stage.js";
+import { MAX_GRACE_MS, graceOf, nextRun, latestRun, parseSchedule, type Schedule } from "./schedule.js";
+import { Scheduler } from "./scheduler.js";
+import { matchesFilter, type RuleEvent } from "./rule-events.js";
+import {
+ MAX_RULES,
+ RULE_APPROVAL_TTL_MS,
+ RULE_DENY,
+ RULE_DENY_PREFIX,
+ RULE_FAILS_TO_PAUSE,
+ RULE_FAILS_TO_SHOW,
+ RULE_HINT_AFTER,
+ RULE_OBSERVE_AFTER_EDIT,
+ RULE_RUN_CAP_MS,
+ RUN_ERROR,
+ WOULD_APPROVAL,
+ errorText,
+ permissionText,
+ ruleState,
+ rulePermission,
+ runLine,
+ runMode,
+ whenOf,
+ wouldText,
+ type RuleRunView,
+ type RuleView,
+} from "./rules.js";
+ import { t as tr } from "../i18n/index.js";
const log = logger("tasks");
@@@ -194,17 -148,8 +194,15 @@@ interface Live
}
const hex = (n: number) => crypto.randomBytes(n).toString("hex");
- /** 翻译(updateRule 里有叫 t 的局部变量) */
- const tr = t;
const clip = (s: string, n: number) => (s.length > n ? s.slice(0, n - 1) + "…" : s);
const oneLine = (s: string) => s.replace(/\s+/g, " ").trim();
+const pad2 = (n: number) => String(n).padStart(2, "0");
+/** 给模型看的时间:11月1日 08:00(规则的时区) */
+function stamp(ts: number, tz: string): string {
+ const p = localParts(ts, tz);
+ const m = Math.floor(p.minute);
+ return `${p.mo}月${p.d}日 ${pad2(Math.floor(m / 60))}:${pad2(m % 60)}`;
+}
/** 文件夹名里的 slug:标题里的字母数字(中文标题就是 task) */
export function slugOf(title: string): string {
@@@ -621,7 -540,7 +619,8 @@@ export class TaskService
l.timer.unref?.();
return;
}
- this.end(l, "failed", undefined, this.o.host.available ? "代理没能启动" : "代理不可用");
- this.end(l, "failed", undefined, this.o.host.available ? tr("tasks.agentDidntStart") : tr("tasks.agentUnavailable"));
++ if (l.ruleId) this.end(l, "failed", undefined, this.o.host.available ? RUN_ERROR.agentFailed : RUN_ERROR.agentUnavailable);
++ else this.end(l, "failed", undefined, this.o.host.available ? tr("tasks.agentDidntStart") : tr("tasks.agentUnavailable"));
return;
} finally {
l.starting = false;
@@@ -765,11 -672,11 +764,13 @@@
}
if (!l.nudged) {
l.nudged = true;
- void this.deliver_(l, [this.addInput(l.taskId, "nudge", NUDGE, false)]);
+ void this.deliver_(l, [this.inputFor(l, "nudge", l.ruleId ? RULE_NUDGE : NUDGE)]);
return;
}
- if (l.turnError) log.warn("task failed after retries", { task: l.taskId, message: l.turnError.slice(0, 300) });
- this.end(l, "failed", undefined, l.turnError ? tr("tasks.modelKeptFailing") : tr("tasks.noResult"));
+ if (l.turnError) log.warn("task failed after retries", { task: l.taskId || l.ruleId, message: l.turnError.slice(0, 300) });
- this.end(l, "failed", undefined, l.turnError ? "模型一直出错" : "没有给出结果");
++ // 规则的 run 存原因的代码(运行记录按看的人的语言翻),任务的照旧存说给用户的那句
++ if (l.ruleId) this.end(l, "failed", undefined, l.turnError ? RUN_ERROR.modelErrors : RUN_ERROR.noReport);
++ else this.end(l, "failed", undefined, l.turnError ? tr("tasks.modelKeptFailing") : tr("tasks.noResult"));
}
/** 结束 run:存下步骤、结果;done / failed 发回会话;空出名额 */
@@@ -1146,34 -1038,20 +1147,34 @@@
/** /tasks:这个会话的任务,带编号(/stop 编号 用同一个顺序) */
listText(conversationId: string): string {
const list = this.list({ conversationId, limit: 10, since: this.now() - 7 * 86400_000 });
- if (!list.length) return tr("tasks.none");
+ const rules = this.activeRules(conversationId);
- if (!list.length && !rules.length) return "没有后台任务。";
- const lines = list.map((t, i) => `${i + 1}. ${t.title} · ${t.stage.label}${t.latest ? `:${clip(t.latest, 40)}` : ""}`);
- // 规则接着编号(/stop 编号 关掉它)
- const ruleLines = rules.map((r, i) => t("rules.listLine", { n: list.length + i + 1, when: r.when, title: r.title, state: r.state.label }));
++ if (!list.length && !rules.length) return tr("tasks.none");
+ const lines = list.map((x, i) => `${i + 1}. ${x.title} · ${x.stage.label}${x.latest ? tr("tasks.latestSuffix", { text: clip(x.latest, 40) }) : ""}`);
- const working = list.findIndex((t) => t.stage.group === "working");
- return [tr("tasks.listHead"), ...lines, ...(working >= 0 ? [tr("tasks.stopHint")] : [])].join("\n");
++ // 规则接着编号(/stop 编号 关掉它),和任务同一种写法:标题 · 状态:时间表
++ const ruleLines = rules.map((r, i) => `${list.length + i + 1}. ${r.title} · ${r.state.label}${tr("tasks.latestSuffix", { text: r.when })}`);
+ const working = list.findIndex((x) => x.stage.group === "working");
- return [...(list.length ? ["后台任务:", ...lines] : []), ...(rules.length ? [t("rules.listHead"), ...ruleLines] : []), ...(working >= 0 || rules.length ? [t("rules.stopHint")] : [])].join("\n");
++ return [...(list.length ? [tr("tasks.listHead"), ...lines] : []), ...(rules.length ? [tr("rules.listHead"), ...ruleLines] : []), ...(working >= 0 || rules.length ? [tr("tasks.stopHint")] : [])].join("\n");
+ }
+
+ /** /tasks 里列出的规则:开着的(关了的、跑完了的一次性规则不列) */
+ private activeRules(conversationId: string): RuleView[] {
+ return this.listRules({ conversationId }).filter((r) => r.state.key !== "off" && r.state.key !== "done");
}
/** /stop 编号:立即记为停止(停会话在后台进行),返回给用户的话 */
stopByIndex(conversationId: string, n: number, by: string): string {
const list = this.list({ conversationId, limit: 10, since: this.now() - 7 * 86400_000 });
const t = list[n - 1];
+ const rule = t ? undefined : this.activeRules(conversationId)[n - 1 - list.length];
+ if (rule) {
+ this.updateRule(rule.id, { mode: "off" });
+ log.info("rule turned off from chat", { rule: rule.id, by });
+ return tr("rules.turnedOff", { title: rule.title });
+ }
- if (!t) return `没有第 ${n} 个后台任务,发 /tasks 查看。`;
- if (t.stage.group !== "working") return `「${t.title}」${t.stage.label}。`;
+ if (!t) return tr("tasks.noSuchIndex", { n });
+ if (t.stage.group !== "working") return tr("tasks.alreadyStage", { title: t.title, stage: t.stage.label });
void this.stopTask(t.id, by);
- return `已停止后台任务「${t.title}」。`;
+ return tr("tasks.stoppedTask", { title: t.title });
}
/** 这个会话有没有正在进行的任务(/stop 不带编号时提示) */
@@@ -1188,692 -1066,6 +1189,692 @@@
/* ignore */
}
}
+
+ // ---------- 规则(3d) ----------
+
+ private get timeZone(): string {
+ return this.o.timeZone ?? systemTimeZone();
+ }
+
+ /** 主模型:发到的那个会话的模型 → 机器人的默认 → 应用的默认(和任务一样) */
+ private mainModel(rule: RuleRow): string {
+ const conv = this.store.getConversation(rule.conversationId);
+ return conv?.model || this.store.getBot(rule.botId)?.defaultModel || this.o.defaultModel?.() || "";
+ }
+
+ /** 检查用的模型:机器人的小模型(没设就是主模型;产品负责人的决定 5) */
+ private checkModel(rule: RuleRow): string {
+ return this.o.host.settings(rule.botId).utilityModel || this.mainModel(rule);
+ }
+
+ /** 发到这个会话、会主动发消息的规则(执行中的检查和提醒,没暂停):给微信留配额、续期提醒里列出来 */
+ private pushingRules(conversationId: string): RuleRow[] {
+ return this.store
+ .listRules({ conversationId })
+ .filter((r) => r.mode !== "off" && !r.pausedReason && runMode(r) === "act" && (r.nextRunAt > 0 || r.trigger.kind === "event"));
+ }
+
+ /** 这条规则有没有还没结束的 run(排队、在跑、收尾) */
+ private ruleBusy(ruleId: string): boolean {
+ return this.store.listRuns({ ruleId, states: ["queued", "running", "settling"], limit: 1 }).length > 0;
+ }
+
+ /** 时间表的下一次(关着、暂停了、事件触发的没有) */
+ private nextFor(rule: Pick<RuleRow, "trigger" | "mode" | "pausedReason">, now: number): number {
+ if (rule.mode === "off" || rule.pausedReason || rule.trigger.kind !== "schedule") return 0;
+ return nextRun(rule.trigger.schedule, now) ?? 0;
+ }
+
+ private graceFor(rule: RuleRow, at: number): number {
+ return rule.trigger.kind === "schedule" ? graceOf(rule.trigger.schedule, at) : MAX_GRACE_MS;
+ }
+
+ /**
+ * 新规则(聊天代理的 rule_create、界面):检查从观察开始;固定提醒没什么要判断的,直接执行(决定 6),
+ * 不受免打扰限制(时间是用户定的)。时间表或事件触发二选一。
+ */
+ createRule(o: { botId: string; conversationId: string; title: string; instruction: string; kind?: RuleKind; message?: string; schedule?: Schedule; trigger?: RuleTrigger }): { rule?: RuleRow; error?: string } {
+ const conv = this.store.getConversation(o.conversationId);
+ if (!conv || conv.botId !== o.botId || !this.store.getBot(o.botId)) return { error: "conversation not found" };
+ const kind: RuleKind = o.kind === "remind" ? "remind" : "check";
+ const title = clip(oneLine(o.title), 40);
+ const message = clip(oneLine(o.message ?? ""), MESSAGE_MAX);
+ // 提醒:界面里只写那句话时,它也是原话
+ const instruction = (o.instruction.trim() || (kind === "remind" ? message : "")).slice(0, 2000);
+ if (!title) return { error: "title is required" };
+ if (!instruction) return { error: "instruction is required: the user's words" };
+ if (kind === "remind" && !message) return { error: "a reminder needs message: the exact line to send" };
+ const trigger: RuleTrigger | undefined = o.trigger ?? (o.schedule ? { kind: "schedule", schedule: o.schedule } : undefined);
+ if (!trigger || (trigger.kind === "event" && !trigger.source.trim())) return { error: "schedule is required" };
+ if (kind === "remind" && trigger.kind !== "schedule") return { error: "a reminder needs a schedule" };
+ if (this.store.listRules({ botId: o.botId }).length >= MAX_RULES) return { error: `This bot already has ${MAX_RULES} rules; delete one first.` };
+ const now = this.now();
+ const id = `rl_${hex(6)}`;
+ const mode: RuleMode = kind === "remind" ? "act" : "observe";
+ const rule = this.store.insertRule({
+ id,
+ botId: o.botId,
+ conversationId: conv.id,
+ title,
+ instruction,
+ message: kind === "remind" ? message : "",
+ kind,
+ trigger,
+ mode,
+ folder: `rules/${slugOf(title).replace(/^task$/, "rule")}-${id.slice(3, 9)}`,
+ nextRunAt: this.nextFor({ trigger, mode, pausedReason: "" }, now),
+ anytime: kind === "remind",
+ createdAt: now,
+ updatedAt: now,
+ });
+ log.info("rule created", { bot: o.botId, rule: id, kind, trigger: trigger.kind, conversationId: conv.id });
+ this.ruleChanged(id);
+ return { rule };
+ }
+
+ /**
+ * 改规则(界面、rule_update)。改原话:版本加 1;执行中的检查先观察 1 次再回到执行(决定 7)。只改时间表:模式不变。
+ * 改模式:重新开的清掉连续失败和暂停。正在跑的那次照它开始时的版本跑完。
+ */
+ updateRule(id: string, patch: { title?: string; instruction?: string; message?: string; schedule?: Schedule; mode?: RuleMode; conversationId?: string }): { rule?: RuleRow; error?: string } {
+ const rule = this.store.getRule(id);
+ if (!rule) return { error: "rule not found" };
+ const now = this.now();
+ const next: Partial<RuleRow> = { updatedAt: now };
+ if (patch.title !== undefined) {
+ const t = clip(oneLine(patch.title), 40);
+ if (!t) return { error: tr("rules.nameEmpty") };
+ next.title = t;
+ }
+ let reworded = false;
+ if (patch.instruction !== undefined) {
+ const t = patch.instruction.trim().slice(0, 2000);
+ if (!t) return { error: tr("rules.wordsEmpty") };
+ if (t !== rule.instruction) (next.instruction = t), (reworded = true);
+ }
+ if (patch.message !== undefined && rule.kind === "remind") {
+ const m = clip(oneLine(patch.message), MESSAGE_MAX);
+ if (!m) return { error: tr("rules.messageEmpty") };
+ if (m !== rule.message) (next.message = m), (reworded = true);
+ }
+ if (patch.conversationId !== undefined && patch.conversationId !== rule.conversationId) {
+ const c = this.store.getConversation(patch.conversationId);
+ if (!c || c.botId !== rule.botId) return { error: tr("rules.noConversation") };
+ next.conversationId = c.id;
+ }
+ let trigger = rule.trigger;
+ if (patch.schedule) {
+ if (rule.trigger.kind !== "schedule") return { error: tr("rules.eventNoSchedule") };
+ trigger = next.trigger = { kind: "schedule", schedule: patch.schedule };
+ }
+ let mode = rule.mode;
+ if (patch.mode !== undefined && patch.mode !== rule.mode) {
+ if (rule.kind === "remind" && patch.mode === "observe") return { error: tr("rules.remindNoObserve") };
+ mode = next.mode = patch.mode;
+ next.observeLeft = 0;
+ }
+ if (reworded) {
+ next.version = rule.version + 1;
+ if (rule.kind === "check" && mode === "act") next.observeLeft = RULE_OBSERVE_AFTER_EDIT;
+ }
+ // 重新开(关着、暂停了 → 开着):连续失败清零
+ const reopened = patch.mode !== undefined && mode !== "off" && (rule.mode === "off" || !!rule.pausedReason || patch.mode !== rule.mode);
+ if (reopened) (next.failures = 0), (next.pausedReason = "");
+ if (next.trigger || next.mode !== undefined || reopened) next.nextRunAt = this.nextFor({ trigger, mode, pausedReason: reopened ? "" : rule.pausedReason }, now);
+ this.store.updateRule(id, next);
+ log.info("rule updated", { rule: id, fields: Object.keys(next).filter((k) => k !== "updatedAt") });
+ this.ruleChanged(id);
+ return { rule: this.store.getRule(id) };
+ }
+
+ /** 暂停的规则重新开(「需要你」里的重试):清掉连续失败,接着按时间表跑,并马上跑一次 */
+ resumeRule(id: string): { error?: string } {
+ const rule = this.store.getRule(id);
+ if (!rule) return { error: "rule not found" };
+ if (rule.pausedReason || rule.failures) {
+ const mode = rule.mode === "off" ? (rule.kind === "remind" ? "act" : "observe") : rule.mode;
+ this.store.updateRule(id, { failures: 0, pausedReason: "", mode, nextRunAt: this.nextFor({ trigger: rule.trigger, mode, pausedReason: "" }, this.now()), updatedAt: this.now() });
+ }
+ return this.runRuleNow(id);
+ }
+
+ /** 立即运行(界面):按规则现在的模式跑一次(人要求的:排在前面) */
+ runRuleNow(id: string): { error?: string } {
+ const rule = this.store.getRule(id);
+ if (!rule) return { error: "rule not found" };
+ if (rule.mode === "off") return { error: tr("rules.isOff") };
+ if (this.ruleBusy(id)) return { error: tr("rules.isRunning") };
+ this.fireRule(rule, "manual", this.now());
+ this.pump();
+ return {};
+ }
+
+ /** 删掉规则:正在跑的那次停掉,等着的批准作废,运行记录一起删 */
+ async deleteRule(id: string): Promise<boolean> {
+ const rule = this.store.getRule(id);
+ if (!rule) return false;
+ for (const a of this.o.approvals?.pendingAll().filter((x) => x.ruleId === id) ?? []) this.o.approvals!.cancel(a.id, "deleted");
+ const l = [...this.live.values()].find((x) => x.ruleId === id);
+ if (l) this.forget(l);
+ this.store.deleteRule(id);
+ if (l) await this.o.host.stop(l.botId, l.sessionId).catch(() => undefined);
+ log.info("rule deleted", { rule: id });
+ this.ruleChanged(id);
+ this.pump();
+ return true;
+ }
+
+ private ruleChanged(id: string): void {
+ this.changed(id);
+ this.scheduler.wake();
+ }
+
+ /**
+ * 定时器到点(也在启动时、电脑醒来时):每条到点的规则把 next_run_at 往后挪,最近该跑的那次在宽限期内就跑一次,
+ * 更早错过的记一条「跳过:电脑没开」,从不补一串。上一次还没跑完的,这次跳过。
+ */
+ fireDue(now = this.now()): void {
+ if (!this.started || this.closing) return;
+ for (const rule of this.store.dueRules(now)) {
+ if (this.dropped.has(rule.botId) || rule.trigger.kind !== "schedule") continue;
+ const s = rule.trigger.schedule;
+ const due = rule.nextRunAt;
+ const last = latestRun(s, now, due) ?? due;
+ this.store.updateRule(rule.id, { nextRunAt: nextRun(s, now) ?? 0 });
+ if (now - last > graceOf(s, last)) {
+ this.skipRun(rule, due, RUN_ERROR.appOff);
+ continue;
+ }
+ if (last > due) this.skipRun(rule, due, RUN_ERROR.appOff);
+ this.fireRule(rule, "schedule", last);
+ }
+ this.pump();
+ }
+
+ /**
+ * 事件到了(RuleEvents.emit,见 rule-events.ts):来源相同、过滤条件对得上的开着的规则各开一个 run,和定时的走同一条路。
+ * 以后用户配置的 workload 在这里接进来。返回开了 run 的规则 id。
+ */
+ emitRuleEvent(source: string, event: RuleEvent): string[] {
+ if (!this.started || this.closing) return [];
+ const out: string[] = [];
+ const now = this.now();
+ for (const rule of this.store.listRules()) {
+ if (rule.trigger.kind !== "event" || rule.trigger.source !== source || rule.mode === "off" || rule.pausedReason || this.dropped.has(rule.botId)) continue;
+ if (!matchesFilter(rule.trigger.filter, event)) continue;
+ if (this.fireRule(rule, "event", now, { source, event })) out.push(rule.id);
+ }
+ if (out.length) {
+ log.info("rule event", { source, rules: out.length });
+ this.pump();
+ }
+ return out;
+ }
+
+ /**
+ * 开一次:提醒直接发那句话(不进模型、不占名额);检查排一个 run(新会话,第一条输入是规则、原话、最近 3 次的结果)。
+ * 上一次还没结束:到点的、事件来的这次跳过。
+ */
+ private fireRule(rule: RuleRow, cause: RunCause, at: number, event?: { source: string; event: RuleEvent }): RunRow | undefined {
+ if (this.ruleBusy(rule.id)) {
+ if (cause === "schedule" || cause === "event") this.skipRun(rule, at, RUN_ERROR.overlap);
+ return undefined;
+ }
+ if (rule.kind === "remind") return this.remind(rule, cause, at);
+ const mode = runMode(rule);
+ const id = `r_${hex(6)}`;
+ const run = this.store.insertRun({ id, botId: rule.botId, taskId: "", ruleId: rule.id, ruleVersion: rule.version, mode, sessionId: `rule-${rule.id}-${id.slice(2)}`, cause, queuedAt: at });
+ this.store.insertInput({ id: `i_${hex(6)}`, taskId: "", ruleId: rule.id, runId: id, kind: "schedule", text: this.ruleBriefFor(rule, mode, event), fromPerson: cause === "manual", createdAt: this.now() });
+ this.changed(rule.id);
+ return run;
+ }
+
+ /** 第一条输入:规则、用户原话、最近 3 次的结果(连续性靠它,每次是新会话)、事件、记忆快照、这次是观察还是执行 */
+ private ruleBriefFor(rule: RuleRow, mode: "observe" | "act", event?: { source: string; event: RuleEvent }): string {
+ const tz = rule.trigger.kind === "schedule" ? rule.trigger.schedule.tz : this.timeZone;
+ const recent = this.store
+ .ruleRuns(rule.id, { limit: 10 })
+ .filter((r) => r.state === "ended" && r.report)
+ .slice(0, 3)
+ .reverse()
+ .map((r) => {
+ const msg = oneLine(r.report!.message ?? "");
+ const head = r.outcome === "failed" ? "失败" : msg ? `${r.mode === "observe" ? "本会告诉用户" : "告诉了用户"}:${msg}` : "没有告诉用户";
+ return { at: stamp(r.queuedAt, tz), line: [head, oneLine(r.report!.summary)].filter(Boolean).join("。") };
+ });
+ const st = this.o.host.settings(rule.botId);
+ let payload = "";
+ try {
+ payload = event ? JSON.stringify(event.event) : "";
+ } catch {
+ payload = "{}";
+ }
+ return ruleBrief({
+ title: rule.title,
+ // 第一条输入是给模型的,和别的提示词一样固定用简体中文
+ when: whenOf(rule, false, "zh-CN"),
+ instruction: rule.instruction,
+ mode,
+ recent,
+ ...(event ? { event: { source: event.source, payload } } : {}),
+ memory: st.memory.enabled ? this.o.host.memoryPrefix(rule.botId, rule.conversationId) : undefined,
+ });
+ }
+
+ /** 固定提醒:到点把那句话发出去,记一条运行记录(不进模型) */
+ private remind(rule: RuleRow, cause: RunCause, at: number): RunRow {
+ const now = this.now();
+ const id = `r_${hex(6)}`;
+ this.store.insertEndedRun({ id, botId: rule.botId, ruleId: rule.id, ruleVersion: rule.version, mode: "act", cause, outcome: "done", error: "", queuedAt: at, endedAt: now });
+ this.store.updateRun(id, { startedAt: now, report: { state: "done", summary: "", message: rule.message, at: now } });
+ this.deliverRule(rule, id, "reminder", rule.message);
+ log.info("reminder sent", { rule: rule.id, run: id });
+ this.changed(rule.id);
+ return this.store.getRun(id)!;
+ }
+
+ /** 记一条跳过(电脑没开、一直在忙、上次还没跑完:why 是 RUN_ERROR 里的代码) */
+ private skipRun(rule: RuleRow, at: number, why: string): void {
+ this.store.insertEndedRun({ id: `r_${hex(6)}`, botId: rule.botId, ruleId: rule.id, ruleVersion: rule.version, mode: runMode(rule), cause: "schedule", outcome: "skipped", error: why, queuedAt: at, endedAt: this.now() });
+ log.info("rule run skipped", { rule: rule.id, at, why });
+ this.changed(rule.id);
+ }
+
+ /** 排着的规则 run 等名额超过宽限期:跳过(「一直在忙」);规则删了的作废。返回 true = 不用再排了 */
+ private skipStale(run: RunRow): boolean {
+ const rule = this.store.getRule(run.ruleId);
+ const now = this.now();
+ if (!rule) {
+ this.store.updateRun(run.id, { state: "ended", outcome: "stopped", endedAt: now });
+ return true;
+ }
+ if (now - run.queuedAt <= this.graceFor(rule, run.queuedAt)) return false;
+ this.store.updateRun(run.id, { state: "ended", outcome: "skipped", error: RUN_ERROR.busy, endedAt: now });
+ log.info("rule run skipped: no free slot within its grace period", { rule: rule.id, run: run.id });
+ this.changed(rule.id);
+ return true;
+ }
+
+ /** 开始规则的一个 run:新会话,工作目录是规则的文件夹,检查用小模型;观察只读,执行最多可写工作区 */
+ private async startRuleRun(run: RunRow): Promise<void> {
+ const rule = this.store.getRule(run.ruleId);
+ const now = this.now();
+ if (!rule) {
+ this.store.updateRun(run.id, { state: "ended", outcome: "stopped", endedAt: now });
+ return;
+ }
+ const mode = run.mode === "act" ? "act" : "observe";
+ const permission = rulePermission(mode, this.o.host.settings(rule.botId).permission);
+ this.store.updateRun(run.id, { state: "running", startedAt: now, permission });
+ const model = this.checkModel(rule);
+ const l: Live = {
+ runId: run.id,
+ taskId: "",
+ ruleId: rule.id,
+ mode,
+ folder: path.join(this.o.host.workspace(rule.botId), rule.folder),
+ model: model && this.o.route ? this.o.route(rule.botId, model) : model,
+ botId: rule.botId,
+ sessionId: run.sessionId,
+ activity: new ActivityLog(undefined, model),
+ busy: false,
+ starting: false,
+ checking: false,
+ settling: false,
+ nudged: false,
+ retries: 0,
+ seen: new Set(),
+ tokensIn: 0,
+ tokensOut: 0,
+ would: [],
+ };
+ this.live.set(run.id, l);
+ this.bySession.set(run.sessionId, l);
+ this.armCap(l, this.o.ruleRunCapMs ?? RULE_RUN_CAP_MS);
+ this.changed(rule.id);
+ const inputs = this.store.openRunInputs(run.id);
+ await this.deliver_(l, inputs.length ? inputs : [this.inputFor(l, "nudge", RULE_NUDGE)]);
+ }
+
+ /** 一次运行的时间上限:到了就停掉会话,这次算失败(在等批准时不算,批准最多等 1 小时) */
+ private armCap(l: Live, ms: number): void {
+ clearTimeout(l.capTimer);
+ l.capTimer = setTimeout(() => {
+ l.capTimer = undefined;
+ if (this.live.get(l.runId) !== l) return;
+ if (this.o.approvals?.pendingAll().some((a) => a.ruleId && a.runId === l.runId)) return this.armCap(l, 60_000);
+ log.warn("rule run hit its time cap; stopping it", { rule: l.ruleId, run: l.runId });
- l.activity.end(t("rules.whyTimeout"));
++ l.activity.end(tr("rules.whyTimeout"));
+ this.end(l, "failed", undefined, RUN_ERROR.timeout);
+ void this.o.host.stop(l.botId, l.sessionId).catch(() => undefined);
+ }, ms);
+ l.capTimer.unref?.();
+ }
+
+ /** 规则会话的 task_report:done(带 message = 要告诉用户的一句,不带 = 保持安静)、failed、progress;没有 needs_you */
+ private ruleReport(l: Live, b: any): { text?: string; error?: string } {
+ const state = String(b?.state ?? "");
+ if (state !== "progress" && state !== "done" && state !== "failed") return { error: "state must be progress, done or failed (a rule run cannot ask the user)" };
+ const message = typeof b?.message === "string" ? oneLine(b.message) : "";
+ const would = typeof b?.would === "string" ? clip(b.would.trim(), 1000) : "";
+ const report: TaskReport = {
+ state,
+ summary: clip(String(b?.summary ?? "").trim(), 2000),
+ ...(message ? { message: clip(message, MESSAGE_MAX) } : {}),
+ ...(would ? { would } : {}),
+ at: this.now(),
+ };
+ this.store.updateRun(l.runId, { report });
+ if (state !== "progress") l.final = report;
+ this.changed(l.ruleId);
+ if (state === "progress") return { text: "Progress recorded (it is not sent). Continue the check." };
+ if (state === "failed") return { text: "Recorded. End your turn now." };
+ if (!message) return { text: "Recorded: the user hears nothing this time. End your turn now." };
+ return { text: l.mode === "observe" ? "Recorded as what you would have said (observe mode: nothing is sent). End your turn now." : "Recorded. End your turn now: the app sends your message to the user." };
+ }
+
+ /** 结束规则的 run:存下步骤、报告、本会做的事;之后按结果更新规则(连续失败、先观察的次数)、送出那一句 */
+ private endRule(l: Live, outcome: RunOutcome, report?: TaskReport, error = ""): void {
+ this.forget(l);
+ const now = this.now();
+ const would = [report?.would ?? "", ...(l.would ?? []).map((d) => `${WOULD_APPROVAL}${d}`)].filter(Boolean).join("\n");
+ this.store.updateRun(l.runId, { state: "ended", outcome, report, would, error, endedAt: now, activity: JSON.stringify(l.activity.steps), tokensIn: l.tokensIn, tokensOut: l.tokensOut });
+ for (const a of this.o.approvals?.pendingAll().filter((x) => x.ruleId && x.runId === l.runId) ?? []) this.o.approvals!.cancel(a.id, "run ended");
+ const rule = this.store.getRule(l.ruleId);
+ if (rule) this.afterRuleRun(rule, l.runId, l.mode, outcome, report, error);
+ log.info("rule run ended", { rule: l.ruleId, run: l.runId, mode: l.mode, outcome, ...(error ? { error } : {}) });
+ this.changed(l.ruleId);
+ this.pump();
+ }
+
+ /**
+ * 一次运行之后:成功清零连续失败,改了原话后先观察的那一次跑完了就回到执行;有要说的那一句(观察时是「本会发送」)用主模型写,
+ * 执行时发出去。失败加 1,连续 3 次自动暂停:执行中的规则推一句 ⚠️,观察中的只在「需要你」里。
+ */
+ private afterRuleRun(rule: RuleRow, runId: string, mode: "observe" | "act", outcome: RunOutcome, report: TaskReport | undefined, error: string): void {
+ const run = this.store.getRun(runId);
+ if (outcome === "done") {
+ const patch: Partial<RuleRow> = { failures: 0 };
+ if (mode === "observe" && rule.mode === "act" && rule.observeLeft > 0 && run?.ruleVersion === rule.version) patch.observeLeft = rule.observeLeft - 1;
+ this.store.updateRule(rule.id, patch);
+ if (report?.message) void this.ruleResult(rule, runId, mode, report);
+ return;
+ }
+ if (outcome !== "failed") return;
+ const failures = rule.failures + 1;
+ if (failures < RULE_FAILS_TO_PAUSE) return void this.store.updateRule(rule.id, { failures });
+ this.store.updateRule(rule.id, { failures, pausedReason: "failures", nextRunAt: 0 });
+ log.warn("rule paused after failing in a row", { rule: rule.id, failures });
+ if (rule.mode === "act") {
+ // 后台推送:应用的语言
- const why = clip(oneLine(report?.message || errorText(error || "没有给出结果")), 200);
- this.deliverRule(rule, runId, "failure", t("rules.pausedPush", { title: rule.title, count: failures, why }));
++ const why = clip(oneLine(report?.message || errorText(error || RUN_ERROR.noReport)), 200);
++ this.deliverRule(rule, runId, "failure", tr("rules.pausedPush", { title: rule.title, count: failures, why }));
+ }
+ }
+
+ /** 那一句用主模型写(检查用的小模型只给草稿);执行时发出去。主模型不可用就用草稿 */
+ private async ruleResult(rule: RuleRow, runId: string, mode: "observe" | "act", report: TaskReport): Promise<void> {
+ let message = report.message ?? "";
+ const main = this.mainModel(rule);
+ if (this.o.complete && main && this.checkModel(rule) !== main) {
+ try {
+ const out = await this.o.complete(rule.botId, main, RULE_RESULT_SYSTEM, ruleResultInput({ instruction: rule.instruction, summary: report.summary, draft: message }));
+ const line = clip(oneLine(out).replace(/^["“「]+|["”」]+$/g, ""), MESSAGE_MAX);
+ if (line) message = line;
+ } catch (e) {
+ log.warn("writing the rule result with the main model failed; sending the draft", { rule: rule.id, message: (e as Error).message.slice(0, 200) });
+ }
+ if (message !== report.message) this.store.updateRun(runId, { report: { ...report, message } });
+ }
+ const fresh = this.store.getRule(rule.id);
+ if (mode === "act" && fresh) this.deliverRule(fresh, runId, "rule", message);
+ this.changed(rule.id);
+ }
+
+ /**
+ * 送出规则的那一句(命中、提醒、暂停):微信、飞书按主动消息的规则经出站队列(id 固定:rule:<规则>:<run>,同一 id 只发一次),
+ * 飞书直接发到会话;同时写进会话历史,给聊天代理留张便条。交过的 run 不再交。
+ */
+ private deliverRule(rule: RuleRow, runId: string, purpose: "rule" | "reminder" | "failure", text: string): void {
+ const run = this.store.getRun(runId);
+ if (!run || run.delivery) return;
+ const id = purpose === "failure" ? `rule:${rule.id}:paused:${runId}` : `rule:${rule.id}:${runId}`;
+ const conv = this.store.getConversation(rule.conversationId);
+ if (!conv) return void this.store.updateRun(runId, { delivery: `${id}:dropped` });
+ if ((conv.channel === "weixin" || conv.channel === "feishu") && this.o.delivery) {
+ this.o.delivery.push({
+ id,
+ botId: rule.botId,
+ channel: conv.channel,
+ peerId: conv.peerId,
+ purpose,
+ subject: rule.title,
+ text,
+ kind: conv.channel === "feishu" ? "notice" : "text",
+ anytime: rule.anytime,
+ ref: `rule:${rule.id}`,
+ });
+ }
+ this.store.addMessage(conv.id, "assistant", text);
+ this.store.updateRun(runId, { delivery: id });
+ this.note(conv.id, purpose === "failure" ? `[规则「${rule.title}」暂停了,已告诉用户] ${text}` : `[规则「${rule.title}」发给了用户] ${text}`);
+ log.info("rule message handed over", { rule: rule.id, run: runId, purpose, channel: conv.channel });
+ }
+
+ /** 启动:结束了、要发却还没交出去的(交之前应用退出了)补交;只看两天之内的 */
+ private redeliverRules(): void {
+ const since = this.now() - 2 * 86400_000;
+ for (const rule of this.store.listRules()) {
+ for (const r of this.store.ruleRuns(rule.id, { limit: 5 })) {
+ if (r.state !== "ended" || r.delivery || r.endedAt < since || r.outcome !== "done" || r.mode !== "act" || !r.report?.message) continue;
+ this.deliverRule(rule, r.id, rule.kind === "remind" ? "reminder" : "rule", r.report.message);
+ }
+ }
+ }
+
+ /**
+ * 重启时被打断的规则 run(已记为 interrupted):还在宽限期内、不是重跑过的,就用新会话再跑一次(照原样交第一条输入,
+ * 前面加一句说明);否则记为跳过(设计 3.restart 第 7 条)。
+ */
+ private recoverRule(run: RunRow): void {
+ const rule = this.store.getRule(run.ruleId);
+ if (!rule) return;
+ const fresh = this.now() - run.queuedAt <= this.graceFor(rule, run.queuedAt);
+ if (run.cause === "recover" || !fresh || rule.mode === "off" || rule.pausedReason || this.ruleBusy(rule.id)) {
+ this.store.updateRun(run.id, { outcome: "skipped", error: RUN_ERROR.restart });
+ this.changed(rule.id);
+ return;
+ }
+ const id = `r_${hex(6)}`;
+ const mode = run.mode === "act" ? "act" : "observe";
+ this.store.insertRun({ id, botId: rule.botId, taskId: "", ruleId: rule.id, ruleVersion: run.ruleVersion, mode, sessionId: `rule-${rule.id}-${id.slice(2)}`, cause: "recover", queuedAt: run.queuedAt });
+ const brief = this.store.runInputs(run.id).find((i) => i.kind === "schedule")?.text ?? this.ruleBriefFor(rule, mode);
+ this.store.insertInput({ id: `i_${hex(6)}`, taskId: "", ruleId: rule.id, runId: id, kind: "schedule", text: `${RULE_RERUN}\n\n${brief}`, fromPerson: false, createdAt: this.now() });
+ log.info("rule run interrupted by a restart; running it again", { rule: rule.id, run: run.id, rerun: id });
+ this.changed(rule.id);
+ }
+
+ /** 插件(/dsh/task-config):规则会话的配置——观察只读、去掉能改变什么的工具;执行最多可写工作区。宿主说了算 */
+ sessionConfig(b: any): { kind?: string; mode?: string; deny?: string[]; denyPrefix?: string[]; section?: string; permission?: string; error?: string } {
+ const l = this.bySession.get(String(b?.sessionId ?? ""));
+ if (!l?.ruleId) return { error: "not a rule session the app is running" };
+ return { kind: "rule", mode: l.mode, deny: RULE_DENY[l.mode], denyPrefix: RULE_DENY_PREFIX, section: ruleRules(l.mode), permission: rulePermission(l.mode, this.o.host.settings(l.botId).permission) };
+ }
+
+ /** 规则会话(或它的子代理)属于哪条规则、哪次运行、这次是观察还是执行(审批落到哪里、观察时自动拒绝) */
+ ruleOfSession(sessionId: string, root?: string): { ruleId: string; runId: string; conversationId: string; mode: "observe" | "act" } | undefined {
+ const l = this.bySession.get(sessionId) ?? (root ? this.bySession.get(root) : undefined);
+ if (!l?.ruleId) return undefined;
+ const rule = this.store.getRule(l.ruleId);
+ return rule ? { ruleId: rule.id, runId: l.runId, conversationId: rule.conversationId, mode: l.mode } : undefined;
+ }
+
+ /** 观察时要批准的事:自动拒绝,记成「需要批准:…」 */
+ wouldNeedApproval(runId: string, detail: string): void {
+ const l = this.live.get(runId);
+ if (!l?.ruleId) return;
+ (l.would ??= []).push(clip(oneLine(detail || "一个操作"), 200));
+ log.info("rule run in observe mode asked for approval; rejected and recorded", { rule: l.ruleId, run: runId });
+ }
+
+ /** 规则执行时的审批:有了决定刷新;1 小时没人管(过期)就拒绝,这次运行失败(设计第 7 节) */
+ private onRuleApproval(e: ApprovalEvent): void {
+ const row = e.row;
+ this.changed(row.ruleId);
+ if (e.type !== "decided" || row.status !== "expired" || row.decidedBy !== "timeout") return;
+ const l = this.live.get(row.runId);
+ if (!l) return;
+ void this.o.host.stop(l.botId, l.sessionId).catch(() => undefined);
+ this.end(l, "failed", undefined, RUN_ERROR.approvalTimeout);
+ }
+
+ // ---------- 规则:聊天代理的工具 ----------
+
+ /** rule_create:用户原话、一行时间表、检查还是提醒 */
+ private ruleCreateTool(conv: Conversation, a: Record<string, unknown>): { text?: string; error?: string } {
+ const s = parseSchedule(String(a.schedule ?? ""), this.timeZone, this.now());
+ if (!s.schedule) return { error: s.error };
+ const kind: RuleKind = a.kind === "remind" ? "remind" : "check";
+ const r = this.createRule({ botId: conv.botId, conversationId: conv.id, title: String(a.title ?? ""), instruction: String(a.instruction ?? ""), kind, message: String(a.message ?? ""), schedule: s.schedule });
+ if (!r.rule) return { error: r.error };
+ // 建议给用户的那几句按应用的语言(模型照着说,聊天的语言不同时它会自己换);其余是给模型的指示
+ const when = whenOf(r.rule);
- const wx = conv.channel === "weixin" ? ` This chat is WeChat, so also say: 「${t("rules.weixinNote")}」` : "";
- if (kind === "remind") return { text: `Created reminder ${r.rule.id}: ${when} the user gets 「${r.rule.message}」. Confirm in one sentence, e.g. 「${t("rules.remindReply", { when })}」${wx}` };
++ const wx = conv.channel === "weixin" ? ` This chat is WeChat, so also say: 「${tr("rules.weixinNote")}」` : "";
++ if (kind === "remind") return { text: `Created reminder ${r.rule.id}: ${when} the user gets 「${r.rule.message}」. Confirm in one sentence, e.g. 「${tr("rules.remindReply", { when })}」${wx}` };
+ return {
- text: `Created rule ${r.rule.id} 「${r.rule.title}」 (${when}) in observe mode: it only records what it would say until the user switches it to act. Tell the user in one sentence: 「${t("rules.createdReply", { when, title: r.rule.title })}」${wx}`,
++ text: `Created rule ${r.rule.id} 「${r.rule.title}」 (${when}) in observe mode: it only records what it would say until the user switches it to act. Tell the user in one sentence: 「${tr("rules.createdReply", { when, title: r.rule.title })}」${wx}`,
+ };
+ }
+
+ /** rule_update:改模式(执行 / 观察 / 关)、原话、时间表,或删掉 */
+ private async ruleUpdateTool(conv: Conversation, a: Record<string, unknown>): Promise<{ text?: string; error?: string }> {
+ const ref = String(a.rule ?? "").trim();
+ const list = this.store.listRules({ conversationId: conv.id });
+ const rule = list.find((r) => r.id === ref) ?? (ref ? list.find((r) => r.title.includes(ref) || ref.includes(r.title)) : undefined);
+ if (!rule) return { error: `No rule matches "${ref}". Call task_list to see them.` };
+ if (a.delete === true) {
+ await this.deleteRule(rule.id);
+ return { text: `Deleted rule 「${rule.title}」. Tell the user in one short sentence.` };
+ }
+ const patch: Parameters<TaskService["updateRule"]>[1] = {};
+ if (a.mode !== undefined) {
+ if (a.mode !== "observe" && a.mode !== "act" && a.mode !== "off") return { error: "mode must be observe, act or off" };
+ patch.mode = a.mode;
+ }
+ if (typeof a.instruction === "string" && a.instruction.trim()) patch[rule.kind === "remind" ? "message" : "instruction"] = a.instruction;
+ if (typeof a.schedule === "string" && a.schedule.trim()) {
+ const s = parseSchedule(a.schedule, rule.trigger.kind === "schedule" ? rule.trigger.schedule.tz : this.timeZone, this.now());
+ if (!s.schedule) return { error: s.error };
+ patch.schedule = s.schedule;
+ }
+ if (!Object.keys(patch).length) return { error: "Nothing to change: give mode, instruction, schedule or delete." };
+ const r = this.updateRule(rule.id, patch);
+ if (!r.rule) return { error: r.error };
+ const v = this.ruleView(r.rule);
+ const extra = r.rule.observeLeft > 0 && runMode(r.rule) === "observe" && r.rule.mode === "act" ? " The instruction changed, so its next run only observes; then it acts again." : "";
+ return { text: `Updated rule 「${v.title}」: ${v.when}, ${v.state.label}.${extra} Tell the user in one short sentence.` };
+ }
+
+ // ---------- 规则:查看 ----------
+
+ /** 出站队列里那一句现在怎样了(合进摘要的看那一条) */
+ private carrier(run: RunRow) {
+ return run.delivery && !run.delivery.endsWith(":dropped") ? this.store.carrierOutbox(run.delivery) : undefined;
+ }
+
+ ruleView(rule: RuleRow): RuleView {
+ const live = this.store.listRuns({ ruleId: rule.id, states: ["queued", "running", "settling"], limit: 1 })[0];
+ const last = this.store.ruleRuns(rule.id, { limit: 5 }).find((r) => r.state === "ended");
+ const observed = rule.kind === "check" ? this.store.ruleRuns(rule.id, { mode: "observe", outcome: "done", version: rule.version, limit: RULE_HINT_AFTER }).length : 0;
+ return {
+ id: rule.id,
+ botId: rule.botId,
+ conversationId: rule.conversationId,
+ channel: this.store.getConversation(rule.conversationId)?.channel ?? "",
+ title: rule.title,
+ instruction: rule.instruction,
+ message: rule.message,
+ kind: rule.kind,
+ trigger: rule.trigger,
+ when: whenOf(rule),
+ mode: rule.mode,
+ observeLeft: rule.observeLeft,
+ state: ruleState(rule, !!live),
+ nextRunAt: rule.nextRunAt,
+ ...(last ? { last: { at: last.queuedAt, outcome: last.outcome, line: runLine(last, rule.kind, this.carrier(last)) } } : {}),
+ hint: rule.kind === "check" && rule.mode === "observe" && !rule.pausedReason && observed >= RULE_HINT_AFTER,
+ observed,
+ failures: rule.failures,
+ folder: rule.folder,
+ version: rule.version,
+ createdAt: rule.createdAt,
+ updatedAt: rule.updatedAt,
+ ...(live ? { live: { runId: live.id, state: live.state, since: live.startedAt || live.queuedAt } } : {}),
+ };
+ }
+
+ listRules(o: { botId?: string; conversationId?: string } = {}): RuleView[] {
+ return this.store.listRules(o).map((r) => this.ruleView(r));
+ }
+
+ getRuleView(id: string): RuleView | undefined {
+ const r = this.store.getRule(id);
+ return r ? this.ruleView(r) : undefined;
+ }
+
+ /** 运行记录(新→旧,一次一行):时间、模式、结果、一行话;展开看报告、步骤、版本和权限 */
+ ruleLog(ruleId: string, o: { before?: number; limit?: number } = {}): RuleRunView[] {
+ const rule = this.store.getRule(ruleId);
+ if (!rule) return [];
+ return this.store.ruleRuns(ruleId, { before: o.before, limit: o.limit ?? 20 }).map((r) => ({
+ id: r.id,
+ at: r.queuedAt,
+ mode: r.mode,
+ cause: r.cause,
+ state: r.state,
+ outcome: r.outcome,
+ line: runLine(r, rule.kind, this.carrier(r)),
+ summary: r.report?.summary ?? "",
+ message: r.report?.message ?? "",
+ would: wouldText(r.would || r.report?.would || ""),
+ error: errorText(r.error),
+ version: r.ruleVersion,
+ permission: permissionText(r.permission),
+ steps: r.startedAt && r.outcome !== "skipped" ? this.activity(r.id).length : 0,
+ startedAt: r.startedAt,
+ endedAt: r.endedAt,
+ }));
+ }
+
+ /**
+ * 「需要你」里规则那一份:连续失败 3 次暂停了的(红),连续失败 2 次的(黄)。原因没了(重试成功、关掉、删掉)就消失。
+ * 规则执行时的审批由审批中心那一份给。
+ */
+ ruleAttention(): AttentionItem[] {
+ const out: AttentionItem[] = [];
+ for (const rule of this.store.listRules()) {
+ const paused = !!rule.pausedReason;
+ if (!paused && (rule.mode === "off" || rule.failures < RULE_FAILS_TO_SHOW)) continue;
+ const last = this.store.ruleRuns(rule.id, { limit: 1, outcome: "failed" })[0];
+ const conv = this.store.getConversation(rule.conversationId);
+ out.push({
+ id: `rule:${rule.id}`,
+ kind: "rule",
+ botId: rule.botId,
+ botName: this.store.getBot(rule.botId)?.name ?? rule.botId,
- subject: t("rules.subject", { title: rule.title }),
- status: t(paused ? "rules.failingPaused" : "rules.failing", { count: rule.failures }),
- line: last ? clip(oneLine(last.report?.message || errorText(last.error || "没有给出结果")), 200) : "",
++ subject: tr("rules.subject", { title: rule.title }),
++ status: tr(paused ? "rules.failingPaused" : "rules.failing", { count: rule.failures }),
++ line: last ? clip(oneLine(last.report?.message || errorText(last.error || RUN_ERROR.noReport)), 200) : "",
+ since: last?.endedAt || rule.updatedAt,
+ severity: paused ? "err" : "warn",
+ actions: ["retry"],
+ conversationId: rule.conversationId,
+ channel: conv?.channel ?? "",
+ ruleId: rule.id,
+ });
+ }
+ return out;
+ }
}
/** task_report 的 question:一句问题(字符串或 {question, options, multiSelect}),选项最多 6 个 */
diff --cc src/web/server.ts
index 8880bfd,57344b3..af8761f
--- a/src/web/server.ts
+++ b/src/web/server.ts
@@@ -21,10 -21,9 +21,10 @@@ import { normalizeSettings } from "../a
import { scopeLabel } from "../agent/memory.js";
import { pwshProbe, type PwshMode, type PwshStatus } from "../agent/pwsh.js";
import { peerName, shortPeer, whoText } from "../core/access.js";
-import type { AccessEntry } from "../store/db.js";
+import type { AccessEntry, RuleMode } from "../store/db.js";
+import { normalizeSchedule, type Schedule } from "../tasks/schedule.js";
import { GUIDE_STEPS, deriveGuide, isGuideStep, mergeGuide, normalizeGuide, type GuideState } from "../guide.js";
- import { normalizeLang, requestLang, setLangPref, t, type LangPref } from "../i18n/index.js";
+ import { normalizeLang, requestLang, setLangPref, t, type LangPref, t as tr } from "../i18n/index.js";
const log = logger("web");
const require = createRequire(import.meta.url);
@@@ -469,10 -468,9 +469,10 @@@ export async function startWebServer(ap
? app.agent.approvals.answer(item.approvalId!, { answers: b.answers.map((a: any) => ({ id: String(a.id), selected: (a.selected ?? []).map(String), ...(a.custom ? { custom: String(a.custom) } : {}) })) }, "web")
: app.agent.approvals.answerText(item.approvalId!, String(b.text ?? ""), "web");
} else if (item.kind === "delivery" && (action === "retry" || action === "dismiss")) ok = app.delivery.act(item.id, action);
+ else if (item.kind === "rule" && action === "retry") ok = !app.tasks.resumeRule(item.ruleId!).error;
else if (action === "retry") ok = !(await app.tasks.retry(item.taskId!)).error;
else if (action === "stop") ok = await app.tasks.stopTask(item.taskId!, "web");
- if (!ok) throw new HttpError(409, "没能完成,可能已经处理过了");
+ if (!ok) throw new HttpError(409, tr("web.couldntComplete"));
app.attention.kick();
return send(res, 200, { ok: true, items: app.attention.list() });
}
@@@ -502,71 -500,8 +502,71 @@@
}
if (seg.length === 3 && seg[2] === "stop" && m === "POST") {
const ok = await app.tasks.stopTask(task.id, "web");
- if (!ok) throw new HttpError(409, "任务已经停止了");
+ if (!ok) throw new HttpError(409, tr("web.taskAlreadyStopped"));
return send(res, 200, { task: app.tasks.get(task.id) });
+ }
+ throw new HttpError(404, "not found");
+ }
+ // —— 规则(3d):列表、新建、改(原话、时间表、模式、发到哪)、删、立即运行、运行记录与一次运行的步骤 ——
+ if (seg[0] === "rules") {
+ const scheduleOf = (raw: unknown, tz: string): Schedule => {
+ const r = normalizeSchedule(raw, tz, Date.now());
+ if (!r.schedule) throw new HttpError(400, r.error ?? t("rules.badSchedule"));
+ return r.schedule;
+ };
+ if (seg.length === 1 && m === "GET") {
+ return send(res, 200, { rules: app.tasks.listRules({ botId: url.searchParams.get("bot") || undefined, conversationId: url.searchParams.get("conversation") || undefined }) });
+ }
+ if (seg.length === 1 && m === "POST") {
+ const b = await readJson(req);
+ const r = app.tasks.createRule({
+ botId: String(b.botId ?? ""),
+ conversationId: String(b.conversationId ?? ""),
+ title: String(b.title ?? ""),
+ instruction: String(b.instruction ?? ""),
+ kind: b.kind === "remind" ? "remind" : "check",
+ message: String(b.message ?? ""),
+ schedule: scheduleOf(b.schedule, app.delivery.timeZone),
+ });
+ if (!r.rule) throw new HttpError(400, r.error ?? t("rules.createFailed"));
+ return send(res, 200, { rule: app.tasks.getRuleView(r.rule.id) });
+ }
+ const rule = seg[1] ? app.store.getRule(decodeURIComponent(seg[1])) : undefined;
+ if (!rule) throw new HttpError(404, t("rules.notFound"));
+ if (seg.length === 2 && m === "GET") return send(res, 200, { rule: app.tasks.getRuleView(rule.id) });
+ if (seg.length === 2 && m === "PUT") {
+ const b = await readJson(req);
+ const patch: Parameters<typeof app.tasks.updateRule>[1] = {};
+ if (b.title !== undefined) patch.title = String(b.title);
+ if (b.instruction !== undefined) patch.instruction = String(b.instruction);
+ if (b.message !== undefined) patch.message = String(b.message);
+ if (b.conversationId !== undefined) patch.conversationId = String(b.conversationId);
+ if (b.mode !== undefined) {
+ if (!["off", "observe", "act"].includes(b.mode)) throw new HttpError(400, t("rules.badMode"));
+ patch.mode = b.mode as RuleMode;
+ }
+ if (b.schedule !== undefined) patch.schedule = scheduleOf(b.schedule, rule.trigger.kind === "schedule" ? rule.trigger.schedule.tz : app.delivery.timeZone);
+ const r = app.tasks.updateRule(rule.id, patch);
+ if (!r.rule) throw new HttpError(400, r.error ?? t("rules.saveFailed"));
+ return send(res, 200, { rule: app.tasks.getRuleView(rule.id) });
+ }
+ if (seg.length === 2 && m === "DELETE") {
+ await app.tasks.deleteRule(rule.id);
+ return send(res, 200, { ok: true });
+ }
+ if (seg.length === 3 && seg[2] === "run" && m === "POST") {
+ const r = rule.pausedReason ? app.tasks.resumeRule(rule.id) : app.tasks.runRuleNow(rule.id);
+ if (r.error) throw new HttpError(409, r.error);
+ return send(res, 200, { rule: app.tasks.getRuleView(rule.id) });
+ }
+ if (seg.length === 3 && seg[2] === "runs" && m === "GET") {
+ const before = Number(url.searchParams.get("before")) || undefined;
+ return send(res, 200, { runs: app.tasks.ruleLog(rule.id, { before, limit: Math.min(100, Number(url.searchParams.get("limit")) || 20) }) });
+ }
+ if (seg.length === 5 && seg[2] === "runs" && seg[4] === "activity" && m === "GET") {
+ const run = app.store.getRun(decodeURIComponent(seg[3]));
+ if (!run || run.ruleId !== rule.id) throw new HttpError(404, t("rules.runNotFound"));
+ return send(res, 200, { steps: app.tasks.activity(run.id) });
}
throw new HttpError(404, "not found");
}
diff --cc test/rules.unit.test.ts
index 2b45c8b,0000000..6d9a654
mode 100644,000000..100644
--- a/test/rules.unit.test.ts
+++ b/test/rules.unit.test.ts
@@@ -1,849 -1,0 +1,854 @@@
+/**
+ * 规则(3d)的零件:时间表(解析、给人看的话、下一次 / 上一次、夏令时、宽限期、cron)、宿主的定时器、事件的过滤条件、数据目录锁,
+ * 以及 TaskService 对着一个假宿主和一个假时钟:从观察开始、观察只记「本会发送」、3 次好的观察后提示改为执行、执行时经出站队列发一句、
+ * 改了原话先观察 1 次再回到执行、连续失败 3 次自动暂停(执行的推一句,观察的只在「需要你」里)、错过的按宽限期补跑一次或记为跳过、
+ * 等名额超过宽限期跳过、固定提醒不进模型、重启后宽限期内重跑一次、运行记录、事件触发、时间上限、观察时的审批自动拒绝、
+ * 检查用小模型而那一句用主模型写、微信配额预留和续期提醒、/tasks 列出并关掉规则。
+ */
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { describe as describeSchedule, graceOf, latestRun, localTime, nextRun, normalizeSchedule, parseSchedule, type Schedule } from "../src/tasks/schedule.js";
+import { Scheduler } from "../src/tasks/scheduler.js";
+import { RuleEvents, matchesFilter } from "../src/tasks/rule-events.js";
+import { RULE_DENY, runLine } from "../src/tasks/rules.js";
+import { TaskService, type TaskHost, type TaskNotification } from "../src/tasks/service.js";
+import { setLangPref, t as tServer, withLang } from "../src/i18n/index.js";
+import { ApprovalCenter } from "../src/agent/approvals.js";
+import { DEFAULT_SETTINGS } from "../src/agent/settings.js";
+import { RULE_NUDGE, RULE_RERUN, RULE_RESULT_SYSTEM, ruleRules } from "../src/agent/prompts/index.js";
+import { Outbox } from "../src/core/outbox.js";
+import { Delivery } from "../src/core/delivery.js";
+import { Store, type RunRow } from "../src/store/db.js";
+import { DataDirLocked, LOCK_FILE, lockDataDir } from "../src/store/lock.js";
+
+const TZ = "Asia/Shanghai";
+const NY = "America/New_York";
+/** 上海时间 "2026-11-06T08:00" → 时间戳 */
+const at = (s: string) => Date.parse(`${s}${s.length === 16 ? ":00" : ""}+08:00`);
+const MIN = 60_000;
+const H = 3600_000;
+const flush = async (n = 6) => {
+ for (let i = 0; i < n; i++) await new Promise((r) => setImmediate(r));
+};
+
+describe("时间表:解析、给人看的话", () => {
+ const now = at("2026-11-02T10:00");
+ const p = (t: string) => parseSchedule(t, TZ, now);
+ it("聊天代理给的一行", () => {
+ expect(p("daily 08:00").schedule).toEqual({ kind: "daily", time: "08:00", tz: TZ });
+ expect(p("weekdays 8:00").schedule).toEqual({ kind: "daily", time: "08:00", days: [1, 2, 3, 4, 5], tz: TZ });
+ expect(p("weekly mon,thu 09:30").schedule).toEqual({ kind: "weekly", time: "09:30", days: [1, 4], tz: TZ });
+ expect(p("weekly 周一、周日 09:30").schedule).toMatchObject({ days: [0, 1] });
+ expect(p("every 30m").schedule).toEqual({ kind: "every", minutes: 30, from: now + MIN, tz: TZ });
+ expect(p("every 2 hours").schedule).toMatchObject({ kind: "every", minutes: 120 });
+ expect(p("once 2026-11-03 15:00").schedule).toEqual({ kind: "once", at: at("2026-11-03T15:00"), tz: TZ });
+ expect(p("cron 0 8 * * 1-5").schedule).toEqual({ kind: "cron", cron: "0 8 * * 1-5", tz: TZ });
+ });
+ it("说不清的给出能照着改的错误", () => {
+ expect(p("every 10m").error).toMatch(/at least 15 minutes/);
+ expect(p("once 2026-11-01 15:00").error).toMatch(/already passed/);
+ expect(p("cron 0 8 * *").error).toMatch(/5 fields/);
+ expect(p("每天早上").error).toMatch(/Use one of: once YYYY-MM-DD HH:MM \| daily HH:MM/);
+ expect(p("daily 25:00").error).toBeDefined();
+ expect(normalizeSchedule({ kind: "weekly", time: "08:00", days: [] }, TZ, now).error).toBe("选一天或几天");
+ });
+ it("给用户看:每天 08:00、每个工作日、每周一、周四、每 30 分钟、日期", () => {
+ const d = (t: string, z = false) => describeSchedule(p(t).schedule!, z);
+ expect(d("daily 08:00")).toBe("每天 08:00");
+ expect(d("weekdays 08:00", true)).toBe("每个工作日 08:00(Asia/Shanghai)");
+ expect(d("weekly sun,thu,mon 09:00")).toBe("每周一、周四、周日 09:00");
+ expect(d("every 30m")).toBe("每 30 分钟");
+ expect(d("every 2h")).toBe("每 2 小时");
+ expect(d("once 2026-11-03 15:00")).toBe("11月3日 15:00");
+ expect(d("cron 0 8 * * 1-5")).toBe("cron 0 8 * * 1-5");
+ });
+});
+
+describe("时间表:下一次、上一次、宽限期", () => {
+ const daily = (time: string, tz = TZ, days?: number[]): Schedule => ({ kind: "daily", time, tz, ...(days ? { days } : {}) });
+ it("每天 08:00:今天还没到就是今天,过了就是明天(不含当时)", () => {
+ expect(nextRun(daily("08:00"), at("2026-11-02T07:59"))).toBe(at("2026-11-02T08:00"));
+ expect(nextRun(daily("08:00"), at("2026-11-02T08:00"))).toBe(at("2026-11-03T08:00"));
+ expect(latestRun(daily("08:00"), at("2026-11-02T07:59"))).toBe(at("2026-11-01T08:00"));
+ expect(latestRun(daily("08:00"), at("2026-11-02T08:00"))).toBe(at("2026-11-02T08:00"));
+ expect(latestRun(daily("08:00"), at("2026-11-02T07:59"), at("2026-11-02T00:00"))).toBeUndefined();
+ });
+ it("工作日:周五晚上之后是周一", () => {
+ // 2026-11-06 是周五
+ expect(nextRun(daily("08:00", TZ, [1, 2, 3, 4, 5]), at("2026-11-06T09:00"))).toBe(at("2026-11-09T08:00"));
+ expect(nextRun({ kind: "weekly", time: "09:00", days: [4], tz: TZ }, at("2026-11-06T09:00"))).toBe(at("2026-11-12T09:00"));
+ });
+ it("夏令时(纽约):跳过的那一小时里的时刻顺延,重复的那一小时取第一次,钟面时间不变", () => {
+ // 3 月 8 日凌晨 2:00 → 3:00:02:30 不存在,顺延到 03:30(EDT)
+ expect(localTime(2026, 3, 8, 150, NY)).toBe(Date.parse("2026-03-08T03:30:00-04:00"));
+ expect(nextRun(daily("02:30", NY), Date.parse("2026-03-07T12:00:00-05:00"))).toBe(Date.parse("2026-03-08T03:30:00-04:00"));
+ expect(nextRun(daily("02:30", NY), Date.parse("2026-03-08T04:00:00-04:00"))).toBe(Date.parse("2026-03-09T02:30:00-04:00"));
+ // 11 月 1 日凌晨 2:00 → 1:00:01:30 有两次,取第一次(EDT),第二天照常
+ expect(nextRun(daily("01:30", NY), Date.parse("2026-10-31T12:00:00-04:00"))).toBe(Date.parse("2026-11-01T01:30:00-04:00"));
+ expect(nextRun(daily("01:30", NY), Date.parse("2026-11-01T01:30:00-04:00"))).toBe(Date.parse("2026-11-02T01:30:00-05:00"));
+ // 早上 8 点在切换前后都是 8 点(中间差 25 小时)
+ const a = nextRun(daily("08:00", NY), Date.parse("2026-10-31T09:00:00-04:00"))!;
+ expect(a).toBe(Date.parse("2026-11-01T08:00:00-05:00"));
+ expect(a - Date.parse("2026-10-31T08:00:00-04:00")).toBe(25 * H);
+ // every 按绝对时间:切换那晚照样每 60 分钟一次
+ const every: Schedule = { kind: "every", minutes: 60, from: Date.parse("2026-11-01T00:00:00-04:00"), tz: NY };
+ expect(nextRun(every, Date.parse("2026-11-01T01:30:00-04:00"))! - Date.parse("2026-11-01T01:30:00-04:00")).toBe(30 * MIN);
+ });
+ it("every:从起点一格一格往后排;上一次是起点之后最近的一格", () => {
+ const s: Schedule = { kind: "every", minutes: 15, from: at("2026-11-02T10:00"), tz: TZ };
+ expect(nextRun(s, at("2026-11-02T09:00"))).toBe(at("2026-11-02T10:00"));
+ expect(nextRun(s, at("2026-11-02T10:00"))).toBe(at("2026-11-02T10:15"));
+ expect(nextRun(s, at("2026-11-02T10:16"))).toBe(at("2026-11-02T10:30"));
+ expect(latestRun(s, at("2026-11-02T11:07"))).toBe(at("2026-11-02T11:00"));
+ expect(latestRun(s, at("2026-11-02T09:59"))).toBeUndefined();
+ });
+ it("cron:工作日 8 点;日和星期都限定时满足一个就行;每 10 分钟", () => {
+ expect(nextRun({ kind: "cron", cron: "0 8 * * 1-5", tz: TZ }, at("2026-11-06T09:00"))).toBe(at("2026-11-09T08:00"));
+ // 每月 1 号或者周一
+ const c: Schedule = { kind: "cron", cron: "30 9 1 * 1", tz: TZ };
+ expect(nextRun(c, at("2026-11-02T10:00"))).toBe(at("2026-11-09T09:30"));
+ expect(nextRun(c, at("2026-11-30T10:00"))).toBe(at("2026-12-01T09:30"));
+ expect(nextRun({ kind: "cron", cron: "*/10 * * * *", tz: TZ }, at("2026-11-02T10:03"))).toBe(at("2026-11-02T10:10"));
+ expect(latestRun({ kind: "cron", cron: "0 8 * * 1-5", tz: TZ }, at("2026-11-08T12:00"))).toBe(at("2026-11-06T08:00"));
+ });
+ it("once:到点之前有,之后没有", () => {
+ const s: Schedule = { kind: "once", at: at("2026-11-03T15:00"), tz: TZ };
+ expect(nextRun(s, at("2026-11-03T14:00"))).toBe(s.at);
+ expect(nextRun(s, s.at)).toBeUndefined();
+ expect(latestRun(s, at("2026-11-03T16:00"))).toBe(s.at);
+ });
+ it("宽限期:间隔的一半和 2 小时取小的", () => {
+ const ref = at("2026-11-02T10:00");
+ expect(graceOf(daily("08:00"), ref)).toBe(2 * H);
+ expect(graceOf({ kind: "every", minutes: 15, from: ref, tz: TZ }, ref)).toBe(7.5 * MIN);
+ expect(graceOf({ kind: "every", minutes: 60, from: ref, tz: TZ }, ref)).toBe(30 * MIN);
+ expect(graceOf({ kind: "cron", cron: "*/10 * * * *", tz: TZ }, ref)).toBe(5 * MIN);
+ expect(graceOf({ kind: "once", at: ref, tz: TZ }, ref)).toBe(2 * H);
+ });
+});
+
+describe("界面:规则的一行(健康时只有状态和下次)", () => {
+ it("第二行:观察中 · 下次 明天 08:00;正在运行;暂停了说连续失败几次;关了、跑完了只有状态;运行记录的时间", async () => {
+ (globalThis as any).window ??= { matchMedia: () => ({ matches: false, addEventListener() {}, removeEventListener() {} }), addEventListener() {}, removeEventListener() {} };
+ // @ts-expect-error 界面代码是不经构建的 JS
+ const { ruleSub, fmtRunAt, fmtNext } = await import("../ui/components/rules.js");
+ // @ts-expect-error 同上
+ const ui = await import("../ui/lib/i18n.js");
+ ui.setLangPref("zh-CN");
+ const now = new Date(2026, 10, 2, 7, 30).getTime();
+ const t = (d: number, h: number, m = 0) => new Date(2026, 10, 2 + d, h, m).getTime();
+ const r = (o: any) => ({ failures: 0, nextRunAt: t(1, 8), state: { key: "observe", label: "观察中" }, ...o });
+ expect(ruleSub(r({}), now)).toBe("观察中 · 下次 明天 08:00");
+ expect(ruleSub(r({ state: { key: "act", label: "执行中" }, nextRunAt: t(0, 15) }), now)).toBe("执行中 · 下次 今天 15:00");
+ expect(ruleSub(r({ live: { state: "running" } }), now)).toBe("观察中 · 正在运行");
+ expect(ruleSub(r({ state: { key: "paused", label: "已暂停" }, failures: 3, nextRunAt: 0 }), now)).toBe("已暂停 · 连续失败 3 次");
+ expect(ruleSub(r({ state: { key: "off", label: "已关闭" } }), now)).toBe("已关闭");
+ expect(ruleSub(r({ state: { key: "done", label: "已结束" }, nextRunAt: 0 }), now)).toBe("已结束");
+ expect([fmtRunAt(t(0, 8), now), fmtRunAt(t(-1, 8), now), fmtRunAt(t(-6, 8), now)]).toEqual(["今天 08:00", "昨天 08:00", "10/27 08:00"]);
+ // 2026-11-02 是周一
+ expect([fmtNext(t(3, 9), now), fmtNext(t(10, 9), now)]).toEqual(["周四 09:00", "11/12 09:00"]);
+ // 英文:状态文字是服务端按界面语言给的,这里只换了界面自己的那部分
+ ui.setLangPref("en");
+ expect(ruleSub(r({ state: { key: "observe", label: "Observing" } }), now)).toBe("Observing · Next: Tomorrow 08:00");
+ expect(ruleSub(r({ state: { key: "paused", label: "Paused" }, failures: 3, nextRunAt: 0 }), now)).toBe("Paused · failed 3 times in a row");
+ expect([fmtRunAt(t(-1, 8), now), fmtNext(t(3, 9), now)]).toEqual(["Yesterday 08:00", "Thu 09:00"]);
+ ui.setLangPref("zh-CN");
+ });
+});
+
+describe("宿主的定时器", () => {
+ it("开始时先看一遍,按最早的那个设定时器(最长睡 5 分钟);wake 马上再看", () => {
+ let now = 1_000_000;
+ let next = now + 30 * MIN;
+ const fired: number[] = [];
+ const s = new Scheduler({ next: () => next, fire: (t) => fired.push(t), now: () => now });
+ s.start();
+ expect(fired).toEqual([now]);
+ expect(s.wakeAt).toBe(now + 5 * MIN);
+ next = now + 2 * MIN;
+ now += MIN;
+ s.wake();
+ expect(fired).toHaveLength(2);
+ expect(s.wakeAt).toBe(now + MIN);
+ s.stop();
+ s.wake();
+ expect(fired).toHaveLength(2);
+ });
+});
+
+describe("事件的过滤条件", () => {
+ it("每个键都要相等(数组是其中之一,路径用点);没有条件都算", () => {
+ expect(matchesFilter(undefined, { a: 1 })).toBe(true);
+ expect(matchesFilter({ repo: "a/b" }, { repo: "a/b", n: 1 })).toBe(true);
+ expect(matchesFilter({ repo: "a/b" }, { repo: "a/c" })).toBe(false);
+ expect(matchesFilter({ action: ["opened", "reopened"] }, { action: "reopened" })).toBe(true);
+ expect(matchesFilter({ "issue.number": 12 }, { issue: { number: "12" } })).toBe(true);
+ expect(matchesFilter({ "issue.number": 12 }, { issue: {} })).toBe(false);
+ });
+});
+
+describe("数据目录锁", () => {
+ let dir: string;
+ beforeEach(() => (dir = fs.mkdtempSync(path.join(os.tmpdir(), "amb-lock-"))));
+ afterEach(() => fs.rmSync(dir, { recursive: true, force: true }));
+ it("另一个活着的进程拿着:拿不到;那个进程不在了:接管;放锁只放自己的", () => {
+ const file = path.join(dir, LOCK_FILE);
+ // 父进程(vitest 的)活着
+ fs.writeFileSync(file, JSON.stringify({ pid: process.ppid, host: os.hostname(), at: Date.now(), token: "x" }));
+ expect(() => lockDataDir(dir)).toThrow(DataDirLocked);
+ expect(() => lockDataDir(dir)).toThrow(/正被另一个 anymodel bot 进程使用/);
+ // 不在了(崩溃、kill -9)
+ fs.writeFileSync(file, JSON.stringify({ pid: 2 ** 22 + 12345, host: os.hostname(), at: Date.now(), token: "x" }));
+ const a = lockDataDir(dir);
+ expect(JSON.parse(fs.readFileSync(file, "utf8")).pid).toBe(process.pid);
+ // 同一进程里又开了一个 App(测试里重启):接过来;先开的那个放锁时不动后来的
+ const b = lockDataDir(dir);
+ a.release();
+ expect(fs.existsSync(file)).toBe(true);
+ b.release();
+ expect(fs.existsSync(file)).toBe(false);
+ });
+ it("另一台机器(两个容器挂同一个卷):看心跳,3 分钟没碰就接管", () => {
+ const file = path.join(dir, LOCK_FILE);
+ fs.writeFileSync(file, JSON.stringify({ pid: 1, host: "other-container", at: Date.now(), token: "x" }));
+ expect(() => lockDataDir(dir)).toThrow(/other-container 上的 pid 1/);
+ const old = new Date(Date.now() - 10 * MIN);
+ fs.writeFileSync(file, JSON.stringify({ pid: 1, host: "other-container", at: old.getTime(), token: "x" }));
+ fs.utimesSync(file, old, old);
+ lockDataDir(dir).release();
+ });
+ it("同一台机器、进程号还在但心跳停了(断电重启后进程号被别的程序占了):接管", () => {
+ const file = path.join(dir, LOCK_FILE);
+ const old = new Date(Date.now() - 10 * MIN);
+ // 父进程(vitest 的)活着,但锁文件 10 分钟没碰过
+ fs.writeFileSync(file, JSON.stringify({ pid: process.ppid, host: os.hostname(), at: old.getTime(), token: "x" }));
+ fs.utimesSync(file, old, old);
+ const l = lockDataDir(dir);
+ expect(JSON.parse(fs.readFileSync(file, "utf8")).pid).toBe(process.pid);
+ l.release();
+ });
+});
+
+/** 假的宿主:记下交给会话的输入和停止;安静与否按队列回答 */
+class FakeHost implements TaskHost {
+ available = true;
+ prompts: Array<{ botId: string; sessionId: string; folder: string; model: string; text: string; resume: boolean; id: string }> = [];
+ stops: string[] = [];
+ settingsValue = { ...DEFAULT_SETTINGS };
+ private n = 0;
+ constructor(readonly ws: string) {}
+ workspace() {
+ return this.ws;
+ }
+ settings() {
+ return this.settingsValue;
+ }
+ memoryPrefix() {
+ return "- 用户关心 X 的价格";
+ }
+ async prompt(botId: string, o: { sessionId: string; folder: string; model: string; text: string; resume: boolean }) {
+ const id = `msg-${++this.n}`;
+ this.prompts.push({ botId, ...o, id });
+ return id;
+ }
+ async steer() {
+ return false;
+ }
+ async stop(_botId: string, sessionId: string) {
+ this.stops.push(sessionId);
+ }
+ async quiet() {
+ return { quiet: true };
+ }
+}
+
+describe("规则(假宿主、假时钟)", () => {
+ let store: Store;
+ let host: FakeHost;
+ let outbox: Outbox;
+ let delivery: Delivery;
+ let approvals: ApprovalCenter;
+ let svc: TaskService;
+ let ws: string;
+ let now: number;
+ let writes: Array<{ model: string; system: string; user: string }>;
+ const CONV = "b:weixin:owner";
+ const WEB = "b:web:console";
+
+ const make = (o: { maxBackground?: number; cap?: number } = {}) =>
+ new TaskService({
+ store,
+ host,
+ delivery,
+ approvals,
+ defaultModel: () => "main-model",
+ retryDelaysMs: [5, 5, 5],
+ maxBackground: o.maxBackground ?? 4,
+ now: () => now,
+ timeZone: TZ,
+ ruleRunCapMs: o.cap,
+ complete: async (_botId, model, system, user) => {
+ writes.push({ model, system, user });
+ return "「X 降价了:现在 ¥199(昨天 ¥259)。」";
+ },
+ });
+ beforeEach(() => {
+ now = at("2026-11-02T07:00");
+ writes = [];
+ ws = fs.mkdtempSync(path.join(os.tmpdir(), "amb-rules-unit-"));
+ store = new Store(":memory:");
+ store.createBot({ id: "b", name: "小蓝", weixinEnabled: true });
+ store.ensureConversation("b", "weixin", "owner", "owner");
+ store.ensureConversation("b", "web", "console", "console");
+ host = new FakeHost(ws);
+ host.settingsValue = { ...DEFAULT_SETTINGS, utilityModel: "small-model" };
+ outbox = new Outbox(store, { now: () => now });
+ delivery = new Delivery({ store, outbox, now: () => now, timeZone: TZ });
+ approvals = new ApprovalCenter(store, { now: () => now });
+ svc = make();
+ svc.start();
+ });
+ afterEach(() => {
+ svc.stop();
+ store.close();
+ fs.rmSync(ws, { recursive: true, force: true });
+ });
+
+ const ev = (sessionId: string, type: string, data: any = {}): TaskNotification => ({ method: "session.event", params: { sessionId, event: { type, data, time: now } } });
+ const status = (sessionId: string, s: "running" | "idle"): TaskNotification => ({ method: "session.status", params: { sessionId, status: s } });
+ /** 最近一次交给规则会话的输入跑一轮;during 里报告 */
+ const turn = async (during?: (sessionId: string) => void) => {
+ const p = host.prompts.at(-1)!;
+ const sid = p.sessionId;
+ svc.onEvent("b", sid, status(sid, "running"));
+ svc.onEvent("b", sid, ev(sid, "turn/start", { turn: 1 }));
+ svc.onEvent("b", sid, ev(sid, "user/message", { id: p.id, role: "user", content: [{ type: "text", text: p.text }] }));
+ during?.(sid);
+ svc.onEvent("b", sid, ev(sid, "turn/end", { turn: 1, reason: { kind: "completed" } }));
+ svc.onEvent("b", sid, status(sid, "idle"));
+ await flush();
+ };
+ const report = (state: string, message = "", extra: Record<string, unknown> = {}) => (sid: string) => void expect(svc.report({ sessionId: sid, state, summary: "X 现在 ¥199", message, ...extra }).error).toBeUndefined();
+ /** 拨钟,到点的开 run */
+ const go = async (t: number) => {
+ now = t;
+ svc.fireDue(now);
+ await flush();
+ };
+ const create = async (schedule = "daily 08:00", extra: Record<string, unknown> = {}) => {
+ const r = await svc.chatTool({ botId: "b", sessionId: "chat-1", op: "rule_create", args: { title: "看 X 价格", instruction: "每天早上 8 点看看 X 的价格,低于 200 告诉我", schedule, ...extra } });
+ expect(r.error).toBeUndefined();
+ return { text: r.text!, rule: store.listRules({ botId: "b" }).at(-1)! };
+ };
+ const runsOf = (ruleId: string) => store.ruleRuns(ruleId, { limit: 100 }).reverse();
+ const pushes = () => store.listOutbox({ limit: 100 }).filter((r) => r.id.startsWith("rule:"));
+ /** 跑一天:到 08:00 开 run,跑一轮,报告 */
+ const day = async (date: string, during: (sid: string) => void) => {
+ await go(at(`${date}T08:00`));
+ await turn(during);
+ };
+
+ beforeEach(() => store.setAgentSession(CONV, "b", "chat-1"));
+
+ it("rule_create:从观察开始,用户原话原样存,自己的文件夹;回复里有设计里那句话,微信加上 24 小时那句", async () => {
+ const { text, rule } = await create();
+ expect(rule).toMatchObject({ kind: "check", mode: "observe", version: 1, conversationId: CONV, instruction: "每天早上 8 点看看 X 的价格,低于 200 告诉我", anytime: false });
+ expect(rule.id).toMatch(/^rl_[0-9a-f]{12}$/);
+ expect(rule.folder).toBe(`rules/x-${rule.id.slice(3, 9)}`);
+ expect(rule.trigger).toEqual({ kind: "schedule", schedule: { kind: "daily", time: "08:00", tz: TZ } });
+ expect(rule.nextRunAt).toBe(at("2026-11-02T08:00"));
+ expect(text).toContain("「已建好规则:每天 08:00 看 X 价格。先观察几天,只记录不打扰你;在「任务」里可以改成执行。」");
+ expect(text).toContain(tServer("rules.weixinNote"));
+ expect(svc.getRuleView(rule.id)).toMatchObject({ when: "每天 08:00", state: { key: "observe", label: "观察中", dot: "" }, hint: false });
+ // 时间表说不清:照着错误改
+ const bad = await svc.chatTool({ botId: "b", sessionId: "chat-1", op: "rule_create", args: { title: "t", instruction: "i", schedule: "每天" } });
+ expect(bad.error).toMatch(/Use one of/);
+ });
+
+ it("退出演示的单元版:观察 3 天(只记「本会发送」,什么都不推),提示改为执行;改了之后命中时推一句(主模型写的)", async () => {
+ const { rule } = await create();
+ // 第 1 天:到点开一个新会话,第一条输入是规则、原话、这次是观察;检查用小模型
+ await go(at("2026-11-02T08:00"));
+ const p1 = host.prompts.at(-1)!;
+ expect(p1.sessionId).toMatch(new RegExp(`^rule-${rule.id}-[0-9a-f]{12}$`));
+ expect(p1).toMatchObject({ resume: false, model: "small-model", folder: path.join(ws, rule.folder) });
+ expect(p1.text).toContain("[规则]\n看 X 价格(每天 08:00)");
+ expect(p1.text).toContain("[用户的原话]\n每天早上 8 点看看 X 的价格,低于 200 告诉我");
+ expect(p1.text).toContain("[这次]\n观察:只看不动,message 只记下来,不会发给用户。");
+ expect(p1.text).toContain("- 用户关心 X 的价格");
+ // 插件取配置:观察只读、去掉能改变什么的工具、规则段
+ expect(svc.sessionConfig({ sessionId: p1.sessionId })).toEqual({ kind: "rule", mode: "observe", deny: RULE_DENY.observe, denyPrefix: ["mcp__computer-use__"], section: ruleRules("observe"), permission: "read-only" });
+ expect(RULE_DENY.observe).toEqual(expect.arrayContaining(["remember", "forget", "generate_image", "present", "rule_create"]));
+ await turn((sid) => void expect(svc.report({ sessionId: sid, state: "done", summary: "X 现在 ¥259,高于 200", message: "" }).text).toMatch(/hears nothing/));
+ // 第 2 天:上一次的结果带进来(连续性靠它)
+ await go(at("2026-11-03T08:00"));
+ expect(host.prompts.at(-1)!.text).toContain("[最近几次的结果]\n- 11月2日 08:00:没有告诉用户。X 现在 ¥259,高于 200");
+ await turn((sid) => void expect(svc.report({ sessionId: sid, state: "done", summary: "X 现在 ¥199", message: "X 降到 199 了" }).text).toMatch(/observe mode: nothing is sent/));
+ // 第 3 天
+ await day("2026-11-04", report("done", "", { would: "在 X 的页面上点「降价提醒」" }));
+ // 观察什么都不推;只记下来
+ expect(pushes()).toEqual([]);
+ expect(store.listMessages(CONV)).toEqual([]);
+ const log = svc.ruleLog(rule.id);
+ expect(log.map((r) => [r.mode, r.outcome, r.line])).toEqual([
+ ["observe", "done", "本会做:在 X 的页面上点「降价提醒」"],
+ // 那一句用主模型写(检查用的是小模型)
+ ["observe", "done", "本会发送:“X 降价了:现在 ¥199(昨天 ¥259)。”"],
+ ["observe", "done", "本会保持安静:X 现在 ¥259,高于 200"],
+ ]);
+ expect(writes).toHaveLength(1);
+ expect(writes[0]).toMatchObject({ model: "main-model", system: RULE_RESULT_SYSTEM });
+ expect(writes[0].user).toContain("[草稿]\nX 降到 199 了");
+ expect(log[0]).toMatchObject({ version: 1, permission: "只读", cause: "schedule", at: at("2026-11-04T08:00") });
+ // 3 次好的观察:提示改为执行(不推)
+ expect(svc.getRuleView(rule.id)).toMatchObject({ hint: true, observed: 3, state: { key: "observe" } });
+ // 改为执行:下一次带着「执行」,权限是可写工作区,命中时推一句(id 固定)
+ svc.updateRule(rule.id, { mode: "act" });
+ expect(svc.getRuleView(rule.id)).toMatchObject({ hint: false, state: { key: "act", label: "执行中", dot: "ok" } });
+ await go(at("2026-11-05T08:00"));
+ expect(host.prompts.at(-1)!.text).toContain("[这次]\n执行:message 会发给用户。");
+ expect(svc.sessionConfig({ sessionId: host.prompts.at(-1)!.sessionId })).toMatchObject({ mode: "act", permission: "workspace-write", deny: RULE_DENY.act });
+ await turn(report("done", "X 降到 199 了"));
+ const run = runsOf(rule.id).at(-1)!;
+ expect(pushes().map((r) => [r.id, r.purpose, r.subject, r.body.text, r.ref])).toEqual([[`rule:${rule.id}:${run.id}`, "rule", "看 X 价格", "X 降价了:现在 ¥199(昨天 ¥259)。", `rule:${rule.id}`]]);
+ expect(store.listMessages(CONV).at(-1)!.content).toBe("X 降价了:现在 ¥199(昨天 ¥259)。");
+ expect(svc.ruleLog(rule.id)[0]).toMatchObject({ mode: "act", permission: "可写工作区", line: "待发送:“X 降价了:现在 ¥199(昨天 ¥259)。”" });
+ // 没命中:保持安静,不推
+ await day("2026-11-06", report("done"));
+ expect(pushes()).toHaveLength(1);
+ expect(svc.ruleLog(rule.id)[0].line).toBe("保持安静:X 现在 ¥199");
+ });
+
+ it("完全权限的机器人:执行时最多可写工作区;只读的机器人:执行也只读", async () => {
+ const { rule } = await create();
+ svc.updateRule(rule.id, { mode: "act" });
+ host.settingsValue = { ...host.settingsValue, permission: "full" };
+ await go(at("2026-11-02T08:00"));
+ expect(svc.sessionConfig({ sessionId: host.prompts.at(-1)!.sessionId }).permission).toBe("workspace-write");
+ await turn(report("done"));
+ host.settingsValue = { ...host.settingsValue, permission: "readonly" };
+ await go(at("2026-11-03T08:00"));
+ expect(svc.sessionConfig({ sessionId: host.prompts.at(-1)!.sessionId }).permission).toBe("read-only");
+ expect(svc.sessionConfig({ sessionId: "task-x" }).error).toBeDefined();
+ });
+
+ it("改原话:版本加 1,执行中的先观察 1 次再回到执行;只改时间表不动模式;正在跑的照原来的版本跑完", async () => {
+ const { rule } = await create();
+ svc.updateRule(rule.id, { mode: "act" });
+ await go(at("2026-11-02T08:00"));
+ // 跑的时候改了原话
+ svc.updateRule(rule.id, { instruction: "每天早上看看 X 的价格,低于 180 告诉我" });
+ expect(store.getRule(rule.id)).toMatchObject({ version: 2, observeLeft: 1, mode: "act" });
+ expect(svc.getRuleView(rule.id)!.state.key).toBe("observe");
+ await turn(report("done", "X 降到 199 了"));
+ // 那一次是第 1 版、执行的:照样发
+ expect(runsOf(rule.id).at(-1)).toMatchObject({ ruleVersion: 1, mode: "act" });
+ await flush();
+ expect(pushes()).toHaveLength(1);
+ expect(store.getRule(rule.id)!.observeLeft).toBe(1);
+ // 下一次:第 2 版、观察
+ await go(at("2026-11-03T08:00"));
+ expect(host.prompts.at(-1)!.text).toContain("低于 180");
+ expect(host.prompts.at(-1)!.text).toContain("[这次]\n观察");
+ await turn(report("done", "X 降到 170 了"));
+ await flush();
+ expect(pushes()).toHaveLength(1);
+ expect(store.getRule(rule.id)).toMatchObject({ observeLeft: 0, mode: "act" });
+ expect(svc.ruleLog(rule.id)[0]).toMatchObject({ mode: "observe", version: 2 });
+ // 再下一次:回到执行
+ await go(at("2026-11-04T08:00"));
+ expect(host.prompts.at(-1)!.text).toContain("[这次]\n执行");
+ await turn(report("done"));
+ // 只改时间表:模式不变,下一次按新时间
+ svc.updateRule(rule.id, { schedule: parseSchedule("daily 09:30", TZ, now).schedule! });
+ expect(store.getRule(rule.id)).toMatchObject({ mode: "act", observeLeft: 0, version: 2, nextRunAt: at("2026-11-04T09:30") });
+ });
+
+ it("连续失败 3 次自动暂停:执行中的推一句 ⚠️,「需要你」里一行(2 次时就有黄的);成功一次清零;重试重新开并马上跑", async () => {
+ const { rule } = await create();
+ svc.updateRule(rule.id, { mode: "act" });
+ await day("2026-11-02", report("failed", "X 的页面打不开"));
+ expect(store.getRule(rule.id)!.failures).toBe(1);
+ expect(svc.ruleAttention()).toEqual([]);
+ await day("2026-11-03", report("done"));
+ expect(store.getRule(rule.id)!.failures).toBe(0);
+ await day("2026-11-04", report("failed", "X 的页面打不开"));
+ await day("2026-11-05", report("failed", "X 的页面打不开"));
+ expect(svc.ruleAttention().map((a) => [a.kind, a.subject, a.status, a.severity, a.line])).toEqual([["rule", "规则「看 X 价格」", "连续失败 2 次", "warn", "X 的页面打不开"]]);
+ expect(pushes()).toEqual([]);
+ await day("2026-11-06", report("failed", "X 的页面打不开"));
+ expect(store.getRule(rule.id)).toMatchObject({ failures: 3, pausedReason: "failures", nextRunAt: 0 });
+ expect(svc.getRuleView(rule.id)!.state).toEqual({ key: "paused", label: "已暂停", dot: "err" });
+ const last = runsOf(rule.id).at(-1)!;
+ expect(pushes().map((r) => [r.id, r.purpose, r.body.text])).toEqual([[`rule:${rule.id}:paused:${last.id}`, "failure", "⚠️ 规则「看 X 价格」连续失败 3 次,已暂停:X 的页面打不开"]]);
+ expect(svc.ruleAttention()[0]).toMatchObject({ status: "连续失败 3 次,已暂停", severity: "err", actions: ["retry"], ruleId: rule.id });
+ // 暂停了就不再到点开 run
+ const n = host.prompts.length;
+ await go(at("2026-11-07T08:00"));
+ expect(host.prompts).toHaveLength(n);
+ // 重试:重新开、马上跑(人要求的)
+ expect(svc.resumeRule(rule.id)).toEqual({});
+ await flush();
+ expect(host.prompts).toHaveLength(n + 1);
+ expect(runsOf(rule.id).at(-1)).toMatchObject({ cause: "manual", mode: "act" });
+ expect(store.getRule(rule.id)).toMatchObject({ failures: 0, pausedReason: "", nextRunAt: at("2026-11-08T08:00") });
+ expect(svc.ruleAttention()).toEqual([]);
+ });
+
+ it("观察中的规则连续失败 3 次也暂停,但什么都不推,只在「需要你」里", async () => {
+ const { rule } = await create();
+ for (const d of ["2026-11-02", "2026-11-03", "2026-11-04"]) await day(d, report("failed", "打不开"));
+ expect(store.getRule(rule.id)!.pausedReason).toBe("failures");
+ expect(pushes()).toEqual([]);
+ expect(svc.ruleAttention()).toHaveLength(1);
+ });
+
+ it("错过的:宽限期(2 小时)内启动补跑一次(算那个时间的),更早的记一条「跳过:电脑没开」,从不补一串", async () => {
+ const { rule } = await create();
+ svc.stop();
+ // 应用 08:00 没开,09:30 开:补跑一次
+ now = at("2026-11-02T09:30");
+ svc = make();
+ svc.start();
+ await flush();
+ expect(runsOf(rule.id).map((r) => [r.cause, r.queuedAt, r.state])).toEqual([["schedule", at("2026-11-02T08:00"), "running"]]);
+ await turn(report("done"));
+ expect(store.getRule(rule.id)!.nextRunAt).toBe(at("2026-11-03T08:00"));
+ // 关了两天,11:00 开:错过的都太久了,只记一条跳过,不跑
+ svc.stop();
+ now = at("2026-11-05T11:00");
+ svc = make();
+ svc.start();
+ await flush();
+ expect(runsOf(rule.id).slice(1).map((r) => [r.outcome, r.error, r.queuedAt])).toEqual([["skipped", "app_off", at("2026-11-03T08:00")]]);
+ expect(svc.ruleLog(rule.id)[0].line).toBe("跳过:电脑没开");
+ expect(store.getRule(rule.id)!.nextRunAt).toBe(at("2026-11-06T08:00"));
+ // 每 15 分钟的:关了一小时,最近的那格在 7.5 分钟内 → 跳过一条、跑一次
+ const every = (await create("every 15m")).rule;
+ expect(every.nextRunAt).toBe(at("2026-11-05T11:01"));
+ svc.stop();
+ now = at("2026-11-05T12:20");
+ svc = make();
+ svc.start();
+ await flush();
+ expect(runsOf(every.id).map((r) => [r.outcome || r.state, r.queuedAt])).toEqual([
+ ["skipped", at("2026-11-05T11:01")],
+ ["running", at("2026-11-05T12:16")],
+ ]);
+ expect(store.getRule(every.id)!.nextRunAt).toBe(at("2026-11-05T12:31"));
+ });
+
+ it("名额一直被占着:等过了宽限期就跳过(「一直在忙」);上一次还没跑完,这次跳过", async () => {
+ svc.stop();
+ svc = make({ maxBackground: 0 });
+ svc.start();
+ const { rule } = await create();
+ await go(at("2026-11-02T08:00"));
+ expect(runsOf(rule.id).map((r) => r.state)).toEqual(["queued"]);
+ now = at("2026-11-02T10:01");
+ svc.pump();
+ expect(runsOf(rule.id).map((r) => [r.outcome, r.error])).toEqual([["skipped", "busy"]]);
+ expect(svc.ruleLog(rule.id)[0].line).toBe("跳过:一直在忙");
+ svc.stop();
+ svc = make();
+ svc.start();
+ await go(at("2026-11-03T08:00"));
+ // 跑了一整天还没完(没有时间上限的假设):第二天到点时跳过
+ await go(at("2026-11-04T08:00"));
+ expect(runsOf(rule.id).map((r) => [r.state, r.outcome, r.error]).slice(1)).toEqual([
+ ["running", "", ""],
+ ["ended", "skipped", "overlap"],
+ ]);
+ });
+
+ it("固定提醒:直接执行,到点只发那句话(不进模型、不占名额、不受免打扰限制),一次性的跑完就结束", async () => {
+ const r = await svc.chatTool({ botId: "b", sessionId: "chat-1", op: "rule_create", args: { title: "开会", instruction: "明天下午 3 点提醒我开会", schedule: "once 2026-11-03 15:00", kind: "remind", message: "该去开会了。" } });
+ expect(r.text).toContain("Created reminder");
+ expect(r.text).toContain("「好,11月3日 15:00 提醒你。」");
+ const rule = store.listRules({ botId: "b" })[0];
+ expect(rule).toMatchObject({ kind: "remind", mode: "act", anytime: true, message: "该去开会了。" });
+ expect(svc.getRuleView(rule.id)!.state).toMatchObject({ key: "remind", label: "提醒" });
+ await go(at("2026-11-03T15:00"));
+ expect(host.prompts).toEqual([]);
+ const [run] = runsOf(rule.id);
+ expect(run).toMatchObject({ state: "ended", outcome: "done", mode: "act" });
+ expect(pushes().map((x) => [x.id, x.purpose, x.body.text, x.body.anytime])).toEqual([[`rule:${rule.id}:${run.id}`, "reminder", "该去开会了。", true]]);
+ expect(svc.ruleLog(rule.id)[0].line).toBe("待发送:“该去开会了。”");
+ expect(store.getRule(rule.id)!.nextRunAt).toBe(0);
+ expect(svc.getRuleView(rule.id)!.state).toMatchObject({ key: "done", label: "已结束" });
+ // 提醒没有观察模式
+ expect(svc.updateRule(rule.id, { mode: "observe" }).error).toBe("提醒没有观察模式");
+ // 没给那句话
+ const bad = await svc.chatTool({ botId: "b", sessionId: "chat-1", op: "rule_create", args: { title: "x", instruction: "x", schedule: "daily 09:00", kind: "remind" } });
+ expect(bad.error).toMatch(/needs message/);
+ });
+
+ it("重启时被打断:宽限期内用新会话重跑一次(前面加一句说明),重跑的再被打断就跳过;超过宽限期的跳过", async () => {
+ const { rule } = await create();
+ await go(at("2026-11-02T08:00"));
+ const first = host.prompts.at(-1)!;
+ svc.stop();
+ now = at("2026-11-02T08:10");
+ svc = make();
+ svc.start();
+ await flush();
+ const runs = runsOf(rule.id);
+ expect(runs.map((r) => [r.cause, r.outcome || r.state])).toEqual([
+ ["schedule", "interrupted"],
+ ["recover", "running"],
+ ]);
+ const again = host.prompts.at(-1)!;
+ expect(again.sessionId).not.toBe(first.sessionId);
+ expect(again.text.startsWith(RULE_RERUN)).toBe(true);
+ expect(again.text).toContain(first.text);
+ // 重跑的又被打断:不再重跑
+ svc.stop();
+ svc = make();
+ svc.start();
+ await flush();
+ expect(runsOf(rule.id).map((r) => [r.cause, r.outcome])).toEqual([
+ ["schedule", "interrupted"],
+ ["recover", "skipped"],
+ ]);
+ expect(svc.ruleLog(rule.id)[0].line).toBe("跳过:应用重启了");
+ // 超过宽限期才重启:跳过
+ await go(at("2026-11-03T08:00"));
+ svc.stop();
+ now = at("2026-11-03T10:30");
+ svc = make();
+ svc.start();
+ await flush();
+ expect(runsOf(rule.id).at(-1)).toMatchObject({ cause: "schedule", outcome: "skipped", error: "restart" });
+ });
+
+ it("运行记录:新的在前,一次一行,可以往前翻;展开有报告、版本、权限;runLine 的几种说法", async () => {
+ const { rule } = await create("every 15m");
+ for (let i = 0; i < 4; i++) {
+ await go(store.getRule(rule.id)!.nextRunAt);
+ await turn(report("done"));
+ }
+ const all = svc.ruleLog(rule.id);
+ expect(all).toHaveLength(4);
+ expect(all.map((r) => r.at)).toEqual([...all.map((r) => r.at)].sort((a, b) => b - a));
+ const page = svc.ruleLog(rule.id, { before: all[1].at, limit: 10 });
+ expect(page.map((r) => r.id)).toEqual(all.slice(2).map((r) => r.id));
+ expect(all[0]).toMatchObject({ summary: "X 现在 ¥199", message: "", version: 1, permission: "只读", outcome: "done" });
+ const run = (o: Partial<RunRow>): RunRow => ({ id: "r", botId: "b", taskId: "", ruleId: "x", ruleVersion: 1, mode: "act", sessionId: "", cause: "schedule", state: "ended", outcome: "done", report: undefined, would: "", activity: "", tokensIn: 0, tokensOut: 0, costUsd: 0, error: "", delivery: "", permission: "", queuedAt: 0, startedAt: 0, endedAt: 0, ...o });
+ expect(runLine(run({ outcome: "failed", error: "timeout" }), "check")).toBe("失败:超时");
+ expect(runLine(run({ outcome: "interrupted" }), "check")).toBe("中断:应用重启了");
+ expect(runLine(run({ state: "queued" }), "check")).toBe("排队中");
+ expect(runLine(run({ state: "running" }), "check")).toBe("正在运行");
+ expect(runLine(run({ report: { state: "done", summary: "", message: "hi", at: 0 } }), "check", { status: "sent" } as any)).toBe("已发送:“hi”");
+ expect(runLine(run({ report: { state: "done", summary: "", message: "hi", at: 0 } }), "check", { status: "held", attempts: 0 } as any)).toBe("未送达:“hi”");
+ expect(runLine(run({ report: { state: "done", summary: "", message: "该开会了", at: 0 } }), "remind", { status: "sent" } as any)).toBe("已提醒:“该开会了”");
+ });
+
+ it("事件触发(扩展点):来源和过滤条件对得上的开着的规则各开一个 run,走同一条观察 / 执行的路;对不上、关着的不开", async () => {
+ const events = new RuleEvents(svc);
+ const r = svc.createRule({ botId: "b", conversationId: CONV, title: "仓库新 issue", instruction: "有新 issue 时看看要不要我处理", trigger: { kind: "event", source: "fake", filter: { repo: "me/app" } } });
+ const other = svc.createRule({ botId: "b", conversationId: CONV, title: "别的仓库", instruction: "x", trigger: { kind: "event", source: "fake", filter: { repo: "me/other" } } });
+ expect(r.rule).toMatchObject({ mode: "observe", nextRunAt: 0, trigger: { kind: "event", source: "fake" } });
+ expect(svc.getRuleView(r.rule!.id)).toMatchObject({ when: "事件 fake", state: { key: "observe" } });
+ expect(events.emit("fake", { repo: "me/app", title: "登录页打不开", number: 12 })).toEqual([r.rule!.id]);
+ await flush();
+ const p = host.prompts.at(-1)!;
+ expect(p.sessionId).toMatch(new RegExp(`^rule-${r.rule!.id}-`));
+ expect(p.text).toContain('[事件]\n来源:fake\n{"repo":"me/app","title":"登录页打不开","number":12}');
+ expect(runsOf(r.rule!.id)[0]).toMatchObject({ cause: "event", mode: "observe" });
+ await turn(report("done", "仓库有个新 issue #12:登录页打不开"));
+ expect(svc.ruleLog(r.rule!.id)[0].line).toBe("本会发送:“X 降价了:现在 ¥199(昨天 ¥259)。”");
+ expect(pushes()).toEqual([]);
+ // 对不上、关着的、别的来源
+ expect(events.emit("fake", { repo: "me/nothing" })).toEqual([]);
+ svc.updateRule(other.rule!.id, { mode: "off" });
+ expect(events.emit("fake", { repo: "me/other" })).toEqual([]);
+ expect(events.emit("github", { repo: "me/app" })).toEqual([]);
+ // 执行:命中推一句,id 一样固定
+ svc.updateRule(r.rule!.id, { mode: "act" });
+ expect(events.emit("fake", { repo: "me/app", title: "又一个" })).toEqual([r.rule!.id]);
+ await flush();
+ await turn(report("done", "又一个新 issue"));
+ expect(pushes().map((x) => x.purpose)).toEqual(["rule"]);
+ });
+
+ it("一次运行最长 15 分钟:到了就停掉会话、这次算失败(超时)", async () => {
+ svc.stop();
+ svc = make({ cap: 20 });
+ svc.start();
+ const { rule } = await create();
+ await go(at("2026-11-02T08:00"));
+ const sid = host.prompts.at(-1)!.sessionId;
+ await new Promise((r) => setTimeout(r, 60));
+ await flush();
+ expect(runsOf(rule.id)[0]).toMatchObject({ outcome: "failed", error: "timeout" });
+ expect(svc.ruleLog(rule.id)[0]).toMatchObject({ line: "失败:超时", error: "超时" });
+ expect(host.stops).toContain(sid);
+ expect(store.getRule(rule.id)!.failures).toBe(1);
+ });
+
+ it("没报告:提醒一次(规则的说法),还没有就失败;观察时要批准的自动拒绝、记成「需要批准」", async () => {
+ const { rule } = await create();
+ await go(at("2026-11-02T08:00"));
+ svc.wouldNeedApproval(runsOf(rule.id)[0].id, "curl -X POST https://x.example/alert");
+ await turn();
+ expect(host.prompts.at(-1)!.text).toBe(RULE_NUDGE);
+ await turn();
+ const [run] = runsOf(rule.id);
- expect(run).toMatchObject({ outcome: "failed", error: "没有给出结果", would: "approval: curl -X POST https://x.example/alert" });
++ expect(run).toMatchObject({ outcome: "failed", error: "no_report", would: "approval: curl -X POST https://x.example/alert" });
+ expect(svc.ruleLog(rule.id)[0]).toMatchObject({ line: "失败:没有给出结果", would: "需要批准:curl -X POST https://x.example/alert" });
+ // 不能问用户
+ await go(at("2026-11-03T08:00"));
+ expect(svc.report({ sessionId: host.prompts.at(-1)!.sessionId, state: "needs_you", summary: "" }).error).toMatch(/cannot ask the user/);
+ });
+
+ it("执行时的审批:在「需要你」里(规则名),不进聊天回合;1 小时没人管就拒绝、这次失败;ruleOfSession 认得子代理", async () => {
+ const { rule } = await create();
+ svc.updateRule(rule.id, { mode: "act" });
+ await go(at("2026-11-02T08:00"));
+ const sid = host.prompts.at(-1)!.sessionId;
+ const who = svc.ruleOfSession("sub-1", sid)!;
+ expect(who).toMatchObject({ ruleId: rule.id, conversationId: CONV, mode: "act" });
+ const row = approvals.create({ kind: "approval", botId: "b", conversationId: CONV, sessionId: sid, tool: "bash", detail: "npm publish", reason: "", ruleId: rule.id, runId: who.runId, ttlMs: 3600_000 });
+ expect(approvals.pendingChat(CONV)).toEqual([]);
+ expect(approvals.handleReply(CONV, "y", "weixin:owner")).toEqual({ handled: false });
+ now += 3600_001;
+ approvals.sweep();
+ await flush();
+ expect(store.getApproval(row.id)!.status).toBe("expired");
+ expect(runsOf(rule.id)[0]).toMatchObject({ outcome: "failed", error: "approval_timeout" });
+ expect(host.stops).toContain(sid);
+ });
+
+ it("微信:执行中的规则(含提醒)每条留 1 条配额,观察中的不留;续期提醒列出窗口关了以后要跑的", async () => {
+ const { rule } = await create();
+ expect(delivery.reserved("b", "weixin", "owner")).toBe(0);
+ svc.updateRule(rule.id, { mode: "act" });
+ expect(delivery.reserved("b", "weixin", "owner")).toBe(1);
+ await svc.chatTool({ botId: "b", sessionId: "chat-1", op: "rule_create", args: { title: "喝水", instruction: "每天下午三点提醒我喝水", schedule: "daily 15:00", kind: "remind", message: "喝水。" } });
+ expect(delivery.reserved("b", "weixin", "owner")).toBe(2);
+ const peer = { botId: "b", channel: "weixin", peerId: "owner", conversationId: CONV };
+ expect(delivery.upcoming(peer, at("2026-11-02T07:30")).map((u) => [u.label, u.at, u.kind])).toEqual([
+ ["看 X 价格", at("2026-11-02T08:00"), "rule"],
+ ["喝水", at("2026-11-02T15:00"), "reminder"],
+ ]);
+ expect(delivery.upcoming(peer, at("2026-11-02T09:00")).map((u) => u.label)).toEqual(["喝水"]);
+ svc.updateRule(rule.id, { mode: "observe" });
+ expect(delivery.reserved("b", "weixin", "owner")).toBe(1);
+ });
+
+ it("聊天代理:task_list 列出规则;rule_update 改模式、改原话、删掉;/tasks 列出规则,/stop 编号 关掉它", async () => {
+ const { rule } = await create();
+ const list = await svc.chatTool({ botId: "b", sessionId: "chat-1", op: "list", args: {} });
+ expect(list.text).toBe(`rule ${rule.id} 「看 X 价格」 每天 08:00 · 观察中`);
+ const up = await svc.chatTool({ botId: "b", sessionId: "chat-1", op: "rule_update", args: { rule: "X 价格", mode: "act" } });
+ expect(up.text).toMatch(/^Updated rule 「看 X 价格」: 每天 08:00, 执行中\./);
+ const re = await svc.chatTool({ botId: "b", sessionId: "chat-1", op: "rule_update", args: { rule: rule.id, instruction: "低于 150 告诉我" } });
+ expect(re.text).toContain("its next run only observes");
- expect(svc.listText(CONV)).toBe("规则:\n1. 每天 08:00 看 X 价格 · 观察中\n发 /stop 编号 可停止。");
++ expect(svc.listText(CONV)).toBe("规则:\n1. 看 X 价格 · 观察中:每天 08:00\n发 /stop 编号 可停止。");
+ expect(svc.stopByIndex(CONV, 1, "weixin:owner")).toBe("已关闭规则「看 X 价格」。");
+ expect(store.getRule(rule.id)!.mode).toBe("off");
+ expect(svc.listText(CONV)).toBe("没有后台任务。");
+ const del = await svc.chatTool({ botId: "b", sessionId: "chat-1", op: "rule_update", args: { rule: "X", delete: true } });
+ expect(del.text).toMatch(/^Deleted rule/);
+ expect(store.getRule(rule.id)).toBeUndefined();
+ expect((await svc.chatTool({ botId: "b", sessionId: "chat-1", op: "rule_update", args: { rule: "X", mode: "act" } })).error).toMatch(/No rule matches/);
+ });
+
+ it("没设小模型:检查和写那一句都用主模型,不再多调一次;网页会话:写进会话历史", async () => {
+ host.settingsValue = { ...DEFAULT_SETTINGS };
+ const r = svc.createRule({ botId: "b", conversationId: WEB, title: "看 X 价格", instruction: "看看 X", schedule: parseSchedule("daily 08:00", TZ, now).schedule });
+ svc.updateRule(r.rule!.id, { mode: "act" });
+ await go(at("2026-11-02T08:00"));
+ expect(host.prompts.at(-1)!.model).toBe("main-model");
+ await turn(report("done", "X 降到 199 了"));
+ await flush();
+ expect(writes).toEqual([]);
+ expect(pushes()).toEqual([]);
+ expect(store.listMessages(WEB).at(-1)!.content).toBe("X 降到 199 了");
+ expect(runsOf(r.rule!.id)[0].delivery).toBe(`rule:${r.rule!.id}:${runsOf(r.rule!.id)[0].id}`);
+ });
+
+ it("英文(界面请求、应用语言是英文时):时间表的话、状态、运行记录、「需要你」、暂停推送、建规则时建议的回复;给模型的第一条输入照旧是中文", async () => {
+ const d = (text: string) => describeSchedule(parseSchedule(text, TZ, now).schedule!, false, "en");
+ expect([d("daily 08:00"), d("weekdays 08:00"), d("weekly sun,thu,mon 09:00"), d("every 30m"), d("every 1h"), d("every 2h"), d("once 2026-11-03 15:00")]).toEqual([
+ "Daily 08:00",
+ "Weekdays 08:00",
+ "Every Mon, Thu, Sun 09:00",
+ "Every 30 min",
+ "Every hour",
+ "Every 2 hours",
+ "Nov 3 15:00",
+ ]);
+ expect(normalizeSchedule({ kind: "every", minutes: 5 }, TZ, now, "en").error).toBe("The interval must be at least 15 minutes");
+ const { rule } = await create();
+ svc.updateRule(rule.id, { mode: "act" });
+ await day("2026-11-02", report("done", "X 降到 199 了"));
+ await day("2026-11-03", report("done"));
+ withLang("en", () => {
+ expect(svc.getRuleView(rule.id)).toMatchObject({ when: "Daily 08:00", state: { key: "act", label: "Acting" } });
+ expect(svc.ruleLog(rule.id).map((r) => [r.line, r.permission])).toEqual([
+ ["Stayed quiet: X 现在 ¥199", "Can write the workspace"],
+ ["Waiting to send: “X 降价了:现在 ¥199(昨天 ¥259)。”", "Can write the workspace"],
+ ]);
+ });
+ // 应用语言是英文:推送的暂停那句、「需要你」、/tasks、建规则时建议的回复都是英文;给模型的第一条输入照旧
+ setLangPref("en");
+ try {
+ for (const date of ["2026-11-04", "2026-11-05", "2026-11-06"]) await day(date, report("failed", "", {}));
+ expect(pushes().find((r) => r.purpose === "failure")!.body.text).toBe("⚠️ Rule “看 X 价格” failed 3 times in a row and is paused: no result");
+ expect(svc.ruleAttention()[0]).toMatchObject({ subject: "Rule “看 X 价格”", status: "Failed 3 times in a row, paused", line: "no result" });
- expect(svc.listText(CONV)).toBe("Rules:\n1. Daily 08:00 看 X 价格 · Paused\nSend /stop <number> to stop one.");
- expect(host.prompts.at(-1)!.text).toContain("[规则]\n看 X 价格(每天 08:00)");
++ expect(svc.listText(CONV)).toBe("Rules:\n1. 看 X 价格 · Paused: Daily 08:00\nSend /stop <number> to stop one.");
++ // 有任务又有规则:同一种写法、同一种语言,规则接着任务编号
++ expect(svc.create({ botId: "b", conversationId: CONV, title: "GPU prices", brief: "compare" }).task).toBeDefined();
++ await flush();
++ expect(svc.listText(CONV)).toBe("Background tasks:\n1. GPU prices · In progress\nRules:\n2. 看 X 价格 · Paused: Daily 08:00\nSend /stop <number> to stop one.");
++ expect(svc.stopByIndex(CONV, 2, "weixin:owner")).toBe("Rule “看 X 价格” is off.");
++ expect(host.prompts.findLast((x) => x.sessionId.startsWith("rule-"))!.text).toContain("[规则]\n看 X 价格(每天 08:00)");
+ const made = await svc.chatTool({ botId: "b", sessionId: "chat-1", op: "rule_create", args: { title: "Weather", instruction: "check the rain every weekday", schedule: "weekdays 07:30" } });
+ expect(made.text).toContain("「Rule set: Weather, Weekdays 07:30. It watches quietly for a few days; switch it to act under Tasks.」");
+ expect(made.text).toContain("WeChat lets the bot message you only within 24 hours of your last message.");
+ expect(svc.updateRule(rule.id, { title: " " }).error).toBe("Name can't be empty");
+ } finally {
+ setLangPref("system");
+ }
+ });
+
+ it("模拟 48 小时:三条规则(每天、每 30 分钟、一次性提醒),中间应用关了 3 小时;次数、跳过、推送都对", async () => {
+ const daily = (await create("daily 08:00")).rule;
+ const half = (await create("every 30m")).rule;
+ await svc.chatTool({ botId: "b", sessionId: "chat-1", op: "rule_create", args: { title: "交房租", instruction: "明天中午提醒我交房租", schedule: "once 2026-11-03 12:00", kind: "remind", message: "该交房租了。" } });
+ svc.updateRule(daily.id, { mode: "act" });
+ const end = at("2026-11-04T07:00");
+ let off = false;
+ for (let t = now; t <= end; t += 5 * MIN) {
+ // 11 月 3 日 01:00–04:00 应用没开
+ const closed = t >= at("2026-11-03T01:00") && t < at("2026-11-03T04:00");
+ if (closed && !off) (svc.stop(), (off = true));
+ if (closed) continue;
+ if (off) {
+ now = t;
+ svc = make();
+ svc.start();
+ off = false;
+ await flush();
+ } else await go(t);
+ // 开了 run 的:这一轮就跑完(每次都没命中,每天的那条命中)
+ while (svc.background().b) {
+ const p = host.prompts.at(-1)!;
+ const isDaily = p.sessionId.startsWith(`rule-${daily.id}`);
+ await turn(report("done", isDaily ? "X 降到 199 了" : ""));
+ }
+ }
+ await flush();
+ const count = (id: string, outcome: string) => runsOf(id).filter((r) => r.outcome === outcome).length;
+ expect([count(daily.id, "done"), count(daily.id, "skipped")]).toEqual([2, 0]);
+ // 每 30 分钟:48 小时减去关着的 3 小时;重新打开时补跑一次、跳过一条
+ expect(count(half.id, "skipped")).toBe(1);
+ expect(count(half.id, "done")).toBeGreaterThanOrEqual(84);
+ expect(count(half.id, "done")).toBeLessThanOrEqual(90);
+ expect(pushes().map((r) => r.purpose).sort()).toEqual(["reminder", "rule", "rule"]);
+ expect(writes).toHaveLength(2);
+ });
+});