@sleep2agi/commhub-server 0.9.0-preview.93 → 0.9.0-preview.94

package/src/requirement-due-reminders-http.test.ts

@@ -0,0 +1,390 @@
+// #491 / #492 / #494 —— 任务到期提醒 + 列表到期筛选。HTTP 集成测试(真实 Bun.serve,私有端口,临时库)。
+// test2123 在真实 PostgreSQL 上原样再跑一遍(COMMHUB_TEST_PG_URL)。
+//
+// 假时钟:runDueReminders({ now }) 注入时刻;时区 = 默认 Asia/Shanghai。
+// 网络 NET(boss)。owen = 负责人;pat、pia = 参与人;节点 NODE = 负责 Agent。
+// 覆盖:三档各一次(收件人 = 负责人 + 参与人,发信别名 = 负责 Agent;节点收到一条 type=message 的消息,不是任务);
+//       同一时刻跑两次 / 同一天跑两次不重发;逾期按天再提醒一次;完成 / 归档 / 清空 due 立即停;due 往后挪重新上膛;
+//       时刻型 due;逾期上限;节点停了不发给节点;MCP / REST 的 overdue、due_within_days 筛选与严格参数。
+
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+const DIR = mkdtempSync(join(tmpdir(), "anet-due-rem-"));
+process.env.COMMHUB_DB ||= join(DIR, "hub.db");
+process.env.COMMHUB_UPLOADS_DIR = join(DIR, "uploads");
+process.env.HOST = "127.0.0.1";
+delete process.env.COMMHUB_DUE_REMINDER_TZ;
+delete process.env.COMMHUB_DUE_OVERDUE_MAX_DAYS;
+delete process.env.COMMHUB_DUE_REMINDER_NETWORKS;
+// 节点提醒默认关;这个文件的大部分用例要看节点那一路,先打开(「默认关」单独一个用例)。
+process.env.COMMHUB_DUE_REMINDER_NODES = "1";
+const PW = "DueRemindPassw0rd!x";
+
+type U = { token: string; id: string; username: string };
+let BASE = "";
+let hub: any = null;
+let NET = "";
+let db: any;
+let due: typeof import("./requirement-due-reminders.js");
+let boss: U, owen: U, pat: U, pia: U;
+const stamp = Date.now();
+const NODE_ID = `node_due_${stamp}`;
+const ALIAS = `due-agent-${stamp}`;
+
+// 2026-10-10 10:00 东八(02:00Z)
+const T0 = Date.UTC(2026, 9, 10, 2, 0, 0);
+const DAY = 86_400_000;
+
+type R = { status: number; body: any };
+async function send(token: string, method: string, path: string, payload?: unknown): Promise<R> {
+  const res = await fetch(`${BASE}${path}`, {
+    method,
+    headers: { Authorization: `Bearer ${token}`, "Content-Type": "application/json" },
+    body: payload === undefined ? undefined : JSON.stringify(payload),
+  });
+  const text = await res.text();
+  let body: any = null;
+  try { body = JSON.parse(text); } catch {}
+  return { status: res.status, body };
+}
+async function mcp(token: string, name: string, args: Record<string, unknown>): Promise<any> {
+  const res = await fetch(`${BASE}/mcp`, {
+    method: "POST",
+    headers: { Authorization: `Bearer ${token}`, "Content-Type": "application/json", Accept: "application/json, text/event-stream", "MCP-Protocol-Version": "2025-03-26" },
+    body: JSON.stringify({ jsonrpc: "2.0", id: 1, method: "tools/call", params: { name, arguments: args } }),
+  });
+  const raw = await res.text();
+  const lines = raw.split("\n").filter(x => x.startsWith("data:"));
+  const payload = lines.length ? JSON.parse(lines.at(-1)!.slice(5).trim()) : JSON.parse(raw);
+  if (payload.error) return { rpcError: payload.error };
+  const item = payload.result.content[0];
+  try { return JSON.parse(item.text); } catch { return { isError: payload.result.isError, text: item.text }; }
+}
+const userRef = (id: string) => ({ kind: "user", id });
+
+async function card(name: string, dueValue: string, extra: Record<string, unknown> = {}): Promise<string> {
+  const r = await send(boss.token, "POST", "/api/requirements", {
+    network_id: NET, name, due: dueValue, owner: userRef(owen.id), participants: [userRef(pat.id), userRef(pia.id), userRef(owen.id)],
+    agent_owner: { kind: "node", id: NODE_ID }, ...extra,
+  });
+  expect(r.status).toBe(201);
+  return r.body.requirement.id as string;
+}
+const patch = (id: string, body: Record<string, unknown>) => send(boss.token, "PATCH", `/api/requirements/${id}?network_id=${NET}`, body);
+
+/** 这张卡发给人的提醒:收件人 → [{content, from, kind}]。 */
+function userNotices(reqId: string): Record<string, Array<{ content: string; from: string; reminder: string }>> {
+  const rows = db.all("SELECT user_id, from_session, content, meta_json FROM user_inbox WHERE network_id = ?1 AND kind = 'task_due' ORDER BY created_at, message_id", NET) as any[];
+  const out: Record<string, any[]> = {};
+  for (const r of rows) {
+    const meta = JSON.parse(r.meta_json);
+    if (meta?.task_notice?.requirement_id !== reqId) continue;
+    (out[r.user_id] ||= []).push({ content: r.content, from: r.from_session, reminder: meta.task_notice.due_reminder });
+  }
+  return out;
+}
+function nodeMessages(reqId: string): Array<{ type: string; content: string; from: string }> {
+  return (db.all("SELECT type, content, from_session FROM inbox WHERE session_name = ?1 AND network_id = ?2 ORDER BY created_at", ALIAS, NET) as any[])
+    .filter(r => String(r.content).includes(reqId)).map(r => ({ type: r.type, content: r.content, from: r.from_session }));
+}
+const sentFor = (out: Array<{ requirement_id: string; kind: string }>, id: string) => out.filter(x => x.requirement_id === id).map(x => x.kind);
+
+beforeAll(async () => {
+  ({ db } = await import("./db.js"));
+  const { addNetworkMember, register } = await import("./auth.js");
+  const mk = (name: string): U => {
+    const r = register(`dr_${name}_${stamp}`, PW);
+    expect(r.ok).toBe(true);
+    return { token: r.token!, id: r.user!.user_id, username: r.user!.username };
+  };
+  const b = register(`dr_boss_${stamp}`, PW);
+  boss = { token: b.token!, id: b.user!.user_id, username: b.user!.username };
+  NET = b.network_id!;
+  owen = mk("owen"); pat = mk("pat"); pia = mk("pia");
+  // pat 是受限成员(看不见任何 Agent):他的提醒发信别名不能泄露负责 Agent → 「任务提醒」。
+  addNetworkMember(NET, owen.id, "member", boss.id, { taskAccess: "all", agentAccess: "all" });
+  addNetworkMember(NET, pia.id, "member", boss.id, { taskAccess: "all", agentAccess: "all" });
+  addNetworkMember(NET, pat.id, "member", boss.id, { taskAccess: "all" });
+  db.run("INSERT INTO nodes (node_id, node_name, alias, runtime, network_id) VALUES (?1, ?2, ?2, 'claude-code', ?3)", [NODE_ID, ALIAS, NET]);
+  db.run("INSERT INTO sessions (resume_id, alias, status, node_id, network_id) VALUES (?1, ?2, 'idle', ?3, ?4)", [`r_due_${stamp}`, ALIAS, NODE_ID, NET]);
+  due = await import("./requirement-due-reminders.js");
+  const mod: any = await import("./server.js");
+  hub = mod.bootServer({ port: 0, hostname: "127.0.0.1" });
+  BASE = `http://127.0.0.1:${hub.port}`;
+  // 基线:假装功能在 T0 之前 30 天就开着了(否则 T0 第一次扫描会把 NET 里所有逾期卡当「开通前就逾期」不发)。
+  due.runDueReminders({ now: T0 - 30 * DAY });
+}, 30_000);
+
+afterAll(() => {
+  try { hub?.stop?.(true); } catch {}
+  try { rmSync(DIR, { recursive: true, force: true }); } catch {}
+});
+
+describe("时区小工具", () => {
+  test("东八的今天 / 零点", () => {
+    expect(due.localDate(T0, "Asia/Shanghai")).toBe("2026-10-10");
+    expect(due.localDate(Date.UTC(2026, 9, 9, 16, 0), "Asia/Shanghai")).toBe("2026-10-10"); // 00:00 东八
+    expect(due.localDate(Date.UTC(2026, 9, 9, 15, 59), "Asia/Shanghai")).toBe("2026-10-09");
+    expect(new Date(due.localMidnightMs("2026-10-10", "Asia/Shanghai")).toISOString()).toBe("2026-10-09T16:00:00.000Z");
+    expect(new Date(due.localMidnightMs("2026-03-08", "America/New_York")).toISOString()).toBe("2026-03-08T05:00:00.000Z");
+    expect(due.addDays("2026-10-31", 1)).toBe("2026-11-01");
+    expect(due.dayDiff("2026-10-10", "2026-10-07")).toBe(3);
+  });
+  test("分档", () => {
+    const tz = "Asia/Shanghai";
+    expect(due.dueReminderFor("2026-10-11", T0, tz)?.kind).toBe("due_soon");
+    expect(due.dueReminderFor("2026-10-10", T0, tz)?.kind).toBe("due_today");
+    expect(due.dueReminderFor("2026-10-12", T0, tz)).toBeNull();
+    expect(due.dueReminderFor("2026-10-07", T0, tz)).toMatchObject({ kind: "overdue", overdueDays: 3, day: "2026-10-10" });
+    expect(due.dueReminderFor("2026-10-02", T0, tz)).toBeNull(); // 8 天 > 默认上限 7
+    expect(due.dueReminderFor("2026-10-10T08:00:00Z", T0, tz)?.kind).toBe("due_today"); // 16:00 东八,今天还没到
+    expect(due.dueReminderFor("2026-10-11T01:00:00Z", T0, tz)?.kind).toBe("due_soon"); // 明天 09:00,23 小时内
+    expect(due.dueReminderFor("2026-10-11T03:00:00Z", T0, tz)).toBeNull(); // 25 小时后
+    expect(due.dueReminderFor("2026-10-10T01:00:00Z", T0, tz)).toMatchObject({ kind: "overdue", overdueDays: 0 });
+  });
+});
+
+describe("提醒", () => {
+  test("即将到期:负责人 + 参与人各一条(发信 = 负责 Agent),节点收到一条不需回复的消息", async () => {
+    const id = await card("dr-明天", "2026-10-11");
+    const out = due.runDueReminders({ now: T0 });
+    expect(sentFor(out, id)).toEqual(["due_soon"]);
+    const n = userNotices(id);
+    expect(Object.keys(n).sort()).toEqual([owen.id, pat.id, pia.id].sort());
+    expect(n[pat.id][0].from).toBe(due.DUE_REMINDER_SENDER);
+    for (const uid of [owen.id, pat.id, pia.id]) {
+      expect(n[uid]).toHaveLength(1);
+      if (uid !== pat.id) expect(n[uid][0].from).toBe(ALIAS);
+      expect(n[uid][0].reminder).toBe("due_soon");
+      expect(n[uid][0].content).toContain("「dr-明天」即将到期");
+    }
+    expect(n[boss.id]).toBeUndefined(); // 创建者不是负责人 / 参与人:不提醒
+    const m = nodeMessages(id);
+    expect(m).toHaveLength(1);
+    expect(m[0].type).toBe("message");
+    expect(m[0].from).toBe(due.DUE_REMINDER_SENDER);
+    // 不是任务:tasks 表里没有这张卡的提醒
+    expect((db.all("SELECT task_id FROM tasks WHERE network_id = ?1 AND content LIKE ?2", NET, `%${id}%`) as any[]).length).toBe(0);
+  });
+
+  test("今天到期 + 同一时刻 / 同一天再跑不重发(去重表)", async () => {
+    const id = await card("dr-今天", "2026-10-10");
+    expect(sentFor(due.runDueReminders({ now: T0 }), id)).toEqual(["due_today"]);
+    expect(sentFor(due.runDueReminders({ now: T0 }), id)).toEqual([]);
+    expect(sentFor(due.runDueReminders({ now: T0 + 6 * 3600_000 }), id)).toEqual([]);
+    expect(userNotices(id)[owen.id]).toHaveLength(1);
+    expect(nodeMessages(id)).toHaveLength(1);
+    const rows = db.all("SELECT kind, due_on, day FROM requirement_due_reminders WHERE requirement_id = ?1", id) as any[];
+    expect(rows).toEqual([{ kind: "due_today", due_on: "2026-10-10", day: "2026-10-10" }]);
+  });
+
+  test("已逾期 N 天:每天最多一次,第二天再一次(N+1)", async () => {
+    const id = await card("dr-逾期", "2026-10-07");
+    expect(sentFor(due.runDueReminders({ now: T0 }), id)).toEqual(["overdue"]);
+    expect(sentFor(due.runDueReminders({ now: T0 + 3600_000 }), id)).toEqual([]);
+    expect(sentFor(due.runDueReminders({ now: T0 + DAY }), id)).toEqual(["overdue"]);
+    const texts = userNotices(id)[pat.id].map(x => x.content).sort();
+    expect(texts).toHaveLength(2);
+    expect(texts[0]).toContain("已逾期 3 天");
+    expect(texts[1]).toContain("已逾期 4 天");
+  });
+
+  test("完成 / 归档 / 清空 due → 立即停", async () => {
+    const done = await card("dr-完成", "2026-10-08");
+    const arch = await card("dr-归档", "2026-10-08");
+    const cleared = await card("dr-清空", "2026-10-08");
+    expect((await patch(done, { column: "done" })).status).toBe(200);
+    expect((await patch(arch, { archived: true })).status).toBe(200);
+    expect((await patch(cleared, { due: "" })).status).toBe(200);
+    const out = due.runDueReminders({ now: T0 });
+    for (const id of [done, arch, cleared]) {
+      expect(sentFor(out, id)).toEqual([]);
+      expect(userNotices(id)).toEqual({});
+    }
+  });
+
+  test("逾期提醒发过后改完成:第二天不再提醒", async () => {
+    const id = await card("dr-逾期后完成", "2026-10-09");
+    expect(sentFor(due.runDueReminders({ now: T0 }), id)).toEqual(["overdue"]);
+    expect((await patch(id, { column: "done" })).status).toBe(200);
+    expect(sentFor(due.runDueReminders({ now: T0 + DAY }), id)).toEqual([]);
+    expect(userNotices(id)[owen.id]).toHaveLength(1);
+  });
+
+  test("due 往后挪:旧档不再成立,新 due 重新上膛", async () => {
+    const id = await card("dr-挪", "2026-10-10");
+    expect(sentFor(due.runDueReminders({ now: T0 }), id)).toEqual(["due_today"]);
+    expect((await patch(id, { due: "2026-10-20" })).status).toBe(200);
+    expect(sentFor(due.runDueReminders({ now: T0 + 3600_000 }), id)).toEqual([]); // 太远:不发
+    expect((await patch(id, { due: "2026-10-11" })).status).toBe(200);
+    expect(sentFor(due.runDueReminders({ now: T0 + 2 * 3600_000 }), id)).toEqual(["due_soon"]);
+    expect(sentFor(due.runDueReminders({ now: T0 + DAY }), id)).toEqual(["due_today"]);
+  });
+
+  test("时刻型 due:今天稍后 = 今天到期;23 小时后 = 即将到期;已过 = 已过预计完成时间", async () => {
+    const later = await card("dr-时刻今天", "2026-10-10T16:00:00+08:00");
+    const soon = await card("dr-时刻明早", "2026-10-11T09:00:00+08:00");
+    const past = await card("dr-时刻已过", "2026-10-10T09:00:00+08:00");
+    const out = due.runDueReminders({ now: T0 });
+    expect(sentFor(out, later)).toEqual(["due_today"]);
+    expect(sentFor(out, soon)).toEqual(["due_soon"]);
+    expect(sentFor(out, past)).toEqual(["overdue"]);
+    expect(userNotices(later)[owen.id][0].content).toContain("2026-10-10 16:00");
+    expect(userNotices(past)[owen.id][0].content).toContain("已过预计完成时间");
+  });
+
+  test("逾期超过上限不提醒;上限可配", async () => {
+    const id = await card("dr-老卡", "2026-09-30");
+    expect(sentFor(due.runDueReminders({ now: T0 }), id)).toEqual([]);
+    process.env.COMMHUB_DUE_OVERDUE_MAX_DAYS = "30";
+    try { expect(sentFor(due.runDueReminders({ now: T0 }), id)).toEqual(["overdue"]); }
+    finally { delete process.env.COMMHUB_DUE_OVERDUE_MAX_DAYS; }
+  });
+
+  test("没有负责 Agent:发信 = 任务提醒;节点停了:节点不收,人照收", async () => {
+    const noAgent = await card("dr-无Agent", "2026-10-11", { agent_owner: null });
+    db.run("UPDATE nodes SET lifecycle_state = 'stopped' WHERE node_id = ?1", [NODE_ID]);
+    try {
+      const stopped = await card("dr-节点停", "2026-10-11");
+      const out = due.runDueReminders({ now: T0 + 3 * 3600_000 });
+      expect(out.find(x => x.requirement_id === noAgent)?.node).toBeNull();
+      expect(userNotices(noAgent)[owen.id][0].from).toBe(due.DUE_REMINDER_SENDER);
+      expect(out.find(x => x.requirement_id === stopped)?.node).toBeNull();
+      expect(nodeMessages(stopped)).toEqual([]);
+      expect(userNotices(stopped)[pia.id]).toHaveLength(1);
+    } finally {
+      db.run("UPDATE nodes SET lifecycle_state = 'active' WHERE node_id = ?1", [NODE_ID]);
+    }
+  });
+});
+
+describe("上线护栏", () => {
+  const mkNet = (tag: string) => {
+    const r = (globalThis as any).__register(`dr_${tag}_${stamp}`, PW);
+    return { token: r.token as string, id: r.user.user_id as string, net: r.network_id as string };
+  };
+  async function cardIn(o: { token: string; id: string; net: string }, name: string, dueValue: string, extra: Record<string, unknown> = {}) {
+    const r = await send(o.token, "POST", "/api/requirements", { network_id: o.net, name, due: dueValue, owner: userRef(o.id), ...extra });
+    expect(r.status).toBe(201);
+    return r.body.requirement.id as string;
+  }
+  beforeAll(async () => { (globalThis as any).__register = (await import("./auth.js")).register; });
+
+  test("网络白名单:设了只发白名单里的网络;不设 = 所有网络", async () => {
+    const other = mkNet("other");
+    due.runDueReminders({ now: T0 - 30 * DAY }); // other 的基线
+    const mine = await card("dr-白名单内", "2026-10-11");
+    const theirs = await cardIn(other, "dr-白名单外", "2026-10-11");
+    process.env.COMMHUB_DUE_REMINDER_NETWORKS = ` ${NET} , `;
+    try {
+      const out = due.runDueReminders({ now: T0 });
+      expect(sentFor(out, mine)).toEqual(["due_soon"]);
+      expect(sentFor(out, theirs)).toEqual([]);
+      expect(db.get("SELECT COUNT(*) AS n FROM requirement_due_reminders WHERE requirement_id = ?1", theirs).n).toBe(0);
+    } finally { delete process.env.COMMHUB_DUE_REMINDER_NETWORKS; }
+    expect(sentFor(due.runDueReminders({ now: T0 }), theirs)).toEqual(["due_soon"]);
+  });
+
+  test("节点提醒默认关:人照收,节点 inbox 没有", async () => {
+    delete process.env.COMMHUB_DUE_REMINDER_NODES;
+    try {
+      const id = await card("dr-节点默认关", "2026-10-11");
+      const out = due.runDueReminders({ now: T0 + 4 * 3600_000 });
+      expect(sentFor(out, id)).toEqual(["due_soon"]);
+      expect(out.find(x => x.requirement_id === id)?.node).toBeNull();
+      expect(nodeMessages(id)).toEqual([]);
+      expect(userNotices(id)[owen.id]).toHaveLength(1);
+    } finally { process.env.COMMHUB_DUE_REMINDER_NODES = "1"; }
+  });
+
+  test("开通时不补发:基线前就逾期的卡不发逾期提醒(第二天也不发);基线后才逾期的照发;今天 / 明天到期照发", async () => {
+    const fresh = mkNet("fresh");
+    const old = await cardIn(fresh, "dr-开通前逾期", "2026-10-07");
+    const oldTime = await cardIn(fresh, "dr-开通前逾期时刻", "2026-10-10T09:00:00+08:00");
+    const today = await cardIn(fresh, "dr-开通当天到期", "2026-10-10");
+    const tomorrow = await cardIn(fresh, "dr-开通次日到期", "2026-10-11");
+    // fresh 网络第一次被扫到 = T0(10:00 东八)
+    const first = due.runDueReminders({ now: T0 });
+    expect(sentFor(first, old)).toEqual([]);
+    expect(sentFor(first, oldTime)).toEqual([]);
+    expect(sentFor(first, today)).toEqual(["due_today"]);
+    const base = db.get("SELECT sent_at FROM requirement_due_reminders WHERE kind = 'baseline' AND network_id = ?1", fresh.net);
+    expect(base.sent_at).toBe(new Date(T0).toISOString());
+    // 第二天:旧卡仍不发;「开通当天到期」是在基线之后才逾期的 → 发「已逾期 1 天」;明天到期 → 今天到期
+    const next = due.runDueReminders({ now: T0 + DAY });
+    expect(sentFor(next, old)).toEqual([]);
+    expect(sentFor(next, oldTime)).toEqual([]);
+    expect(sentFor(next, today)).toEqual(["overdue"]);
+    expect(sentFor(next, tomorrow)).toEqual(["due_today"]);
+    // 基线行不被保留期清掉
+    due.runDueReminders({ now: T0 + 90 * DAY });
+    expect(db.get("SELECT COUNT(*) AS n FROM requirement_due_reminders WHERE kind = 'baseline' AND network_id = ?1", fresh.net).n).toBe(1);
+  });
+
+  test("白名单后加进来的网络:以加进来那一刻为基线,不补发", async () => {
+    const late = mkNet("late");
+    process.env.COMMHUB_DUE_REMINDER_NETWORKS = NET;
+    try {
+      const old = await cardIn(late, "dr-后加网络旧卡", "2026-10-08");
+      due.runDueReminders({ now: T0 });
+      expect(db.get("SELECT COUNT(*) AS n FROM requirement_due_reminders WHERE kind = 'baseline' AND network_id = ?1", late.net).n).toBe(0);
+      process.env.COMMHUB_DUE_REMINDER_NETWORKS = `${NET},${late.net}`;
+      expect(sentFor(due.runDueReminders({ now: T0 + 3600_000 }), old)).toEqual([]);
+    } finally { delete process.env.COMMHUB_DUE_REMINDER_NETWORKS; }
+  });
+});
+
+describe("#494 列表筛选", () => {
+  // 筛选用真时钟:due 按此刻算出来。
+  const tz = "Asia/Shanghai";
+  let today = "", ids: Record<string, string> = {};
+  beforeAll(async () => {
+    const now = Date.now();
+    today = due.localDate(now, tz);
+    ids.over = await card("df-逾期", due.addDays(today, -2));
+    ids.overTime = await card("df-逾期时刻", new Date(now - 3600_000).toISOString());
+    ids.today = await card("df-今天", today);
+    ids.in3 = await card("df-三天后", due.addDays(today, 3));
+    ids.in10 = await card("df-十天后", due.addDays(today, 10));
+    ids.doneOver = await card("df-完成逾期", due.addDays(today, -2), { column: "done" });
+    ids.none = await card("df-无due", "");
+  });
+  const names = (rows: any[]) => rows.map((r: any) => r.name).filter((n: string) => n.startsWith("df-")).sort();
+
+  test("MCP overdue=true:只要没完成且过期的(日期型 + 时刻型)", async () => {
+    const r = await mcp(owen.token, "requirements_list", { network_id: NET, overdue: true, limit: 200 });
+    expect(r.ok).toBe(true);
+    expect(names(r.requirements)).toEqual(["df-逾期", "df-逾期时刻"].sort());
+  });
+  test("MCP overdue=false:其余的", async () => {
+    const r = await mcp(owen.token, "requirements_list", { network_id: NET, overdue: false, limit: 500 });
+    expect(names(r.requirements)).toEqual(["df-三天后", "df-今天", "df-十天后", "df-完成逾期", "df-无due"].sort());
+  });
+  test("MCP due_within_days:0 = 今天;3 = 到三天后;不含逾期 / 完成 / 无 due", async () => {
+    expect(names((await mcp(owen.token, "requirements_list", { network_id: NET, due_within_days: 0, limit: 200 })).requirements)).toEqual(["df-今天"]);
+    expect(names((await mcp(owen.token, "requirements_list", { network_id: NET, due_within_days: 3, limit: 200 })).requirements)).toEqual(["df-三天后", "df-今天"].sort());
+  });
+  test("MCP 严格参数:负数 / 非整数 / 字符串被拒", async () => {
+    for (const bad of [{ due_within_days: -1 }, { due_within_days: 1.5 }, { overdue: "yes" }]) {
+      const r = await mcp(owen.token, "requirements_list", { network_id: NET, ...bad });
+      expect(r.ok).not.toBe(true);
+    }
+  });
+  test("REST 同一组参数;不合法 → 400 + field", async () => {
+    const ok = await send(owen.token, "GET", `/api/requirements?network_id=${NET}&overdue=1`);
+    expect(ok.status).toBe(200);
+    expect(names(ok.body.requirements)).toEqual(["df-逾期", "df-逾期时刻"].sort());
+    const w = await send(owen.token, "GET", `/api/requirements?network_id=${NET}&due_within_days=10`);
+    expect(names(w.body.requirements)).toEqual(["df-三天后", "df-今天", "df-十天后"].sort());
+    const bad = await send(owen.token, "GET", `/api/requirements?network_id=${NET}&overdue=maybe`);
+    expect(bad.status).toBe(400);
+    expect(bad.body.error).toBe("invalid_overdue");
+    expect(bad.body.field).toBe("overdue");
+    const bad2 = await send(owen.token, "GET", `/api/requirements?network_id=${NET}&due_within_days=999`);
+    expect(bad2.status).toBe(400);
+    expect(bad2.body.error).toBe("invalid_due_within_days");
+  });
+});