@sleep2agi/commhub-server 0.9.0-preview.14 → 0.9.0-preview.140

package/src/scheduled-reply-unread-http.test.ts

@@ -0,0 +1,212 @@
+// 定时任务的回复要进建排程那个人的未读(Vincent 2026-09-30「定时任务触发的…那个红点它是不显示的」)。
+//
+// scheduler 派的任务 from_name='scheduler',回复以前按 from_name 落进 inbox(session_name='scheduler'):
+// app 会话里看得到(会话取自 tasks 表),但 unread_by_agent 只数 session_name=用户名 的行 ⇒ 永远没红点。
+// 这里走真 Hub(bootServer)+ 真节点令牌回复路径(send_reply,callerTokenIsNetwork=true)。
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { addNetworkMember, createNetworkTokenForNode, register } from "./auth.js";
+import { db } from "./db.js";
+import { runDueScheduledTasks } from "./scheduled-tasks.js";
+import { registerTools } from "./tools.js";
+
+const activeDbPath = process.env.COMMHUB_DB ?? (process.env.COMMHUB_TEST_PG_URL ? "postgres" : undefined);
+if (!activeDbPath) throw new Error("scheduled-reply-unread requires COMMHUB_DB (or COMMHUB_TEST_PG_URL) before module import");
+
+let server: any;
+let base = "";
+let ownerToken = "";
+let ownerName = "";
+let memberToken = "";
+let memberName = "";
+let networkId = "";
+let ownerId = "";
+const stamp = Date.now();
+const ALIAS = `sched-reply-node-${stamp}`;
+const nodeId = `n_sched_reply_${stamp}`;
+
+async function api(token: string, path: string, init?: RequestInit) {
+  const res = await fetch(`${base}${path}`, {
+    ...init,
+    headers: { Authorization: `Bearer ${token}`, "Content-Type": "application/json", ...(init?.headers || {}) },
+  });
+  return { status: res.status, body: await res.json() as any };
+}
+
+/** 节点令牌身份调 send_reply(与真节点的 commhub_reply 同一个 handler、同一组归属校验)。 */
+async function nodeReply(args: Record<string, unknown>): Promise<any> {
+  const mcp = new McpServer({ name: "sched-reply", version: "0" }) as any;
+  const handlers: Record<string, (a: any) => Promise<any>> = {};
+  const original = mcp.tool.bind(mcp);
+  mcp.tool = (name: string, ...rest: any[]) => {
+    const handler = rest.at(-1);
+    if (typeof handler === "function") handlers[name] = handler;
+    return original(name, ...rest);
+  };
+  registerTools(mcp, undefined, networkId, ownerId, ALIAS, true, null);
+  const out = await handlers.send_reply(args);
+  return JSON.parse(out.content[0].text);
+}
+
+async function unreadFor(token: string): Promise<Record<string, number>> {
+  const res = await api(token, "/api/messages?scope=user&limit=50");
+  expect(res.status).toBe(200);
+  return res.body.unread_by_agent ?? {};
+}
+
+async function ackAgent(token: string) {
+  const res = await api(token, "/api/messages/ack", { method: "POST", body: JSON.stringify({ agent: ALIAS }) });
+  expect(res.status).toBe(200);
+  return res.body;
+}
+
+/** 建一个排程、让它立刻到期、跑一次,返回它派出的 task_id。 */
+async function fireSchedule(token: string, name: string): Promise<{ scheduleId: string; taskId: string }> {
+  const created = await api(token, "/api/scheduled-tasks", {
+    method: "POST",
+    body: JSON.stringify({
+      network_id: networkId, name, target_node_id: nodeId, task: `${name} tick`,
+      timezone: "UTC", schedule: { type: "interval", every_seconds: 120 },
+    }),
+  });
+  expect(created.status).toBe(201);
+  const scheduleId = created.body.schedule.schedule_id as string;
+  // 别的排程不许在这次 sweep 里一起跑
+  db.run("UPDATE scheduled_tasks SET next_run_at = ?1 WHERE schedule_id != ?2", [new Date(Date.now() + 24 * 3600_000).toISOString(), scheduleId]);
+  db.run("UPDATE scheduled_tasks SET next_run_at = ?1 WHERE schedule_id = ?2", [new Date(Date.now() - 60_000).toISOString(), scheduleId]);
+  await runDueScheduledTasks();
+  const run = db.get<{ task_id: string | null }>(
+    "SELECT task_id FROM scheduled_task_runs WHERE schedule_id = ?1 ORDER BY scheduled_for DESC LIMIT 1", scheduleId,
+  );
+  expect(run?.task_id).toBeTruthy();
+  const task = db.get<{ from_name: string }>("SELECT from_name FROM tasks WHERE task_id = ?1", run!.task_id!);
+  expect(task?.from_name).toBe("scheduler");
+  return { scheduleId, taskId: run!.task_id! };
+}
+
+function replyRow(taskId: string) {
+  return db.get<{ session_name: string; from_session: string; acked: number }>(
+    "SELECT session_name, from_session, acked FROM inbox WHERE type = 'reply' AND in_reply_to = ?1", taskId,
+  );
+}
+
+beforeAll(async () => {
+  ownerName = `sched_reply_owner_${stamp}`;
+  const owner = register(ownerName, "SchedReplyOwner123!", undefined, "seed");
+  expect(owner.ok).toBe(true);
+  ownerToken = owner.token!;
+  networkId = owner.network_id!;
+  ownerId = db.get<{ owner_id: string }>("SELECT owner_id FROM networks WHERE network_id = ?1", networkId)!.owner_id;
+
+  memberName = `sched_reply_member_${stamp}`;
+  const member = register(memberName, "SchedReplyMember123!", undefined, "seed");
+  expect(member.ok).toBe(true);
+  memberToken = member.token!;
+  const memberId = db.get<{ user_id: string }>("SELECT user_id FROM users WHERE username = ?1", memberName)!.user_id;
+  expect(addNetworkMember(networkId, memberId, "member", ownerId, { agentAccess: "all" }).ok).toBe(true);
+
+  expect(createNetworkTokenForNode(ownerId, networkId, ALIAS).ok).toBe(true);
+  db.run(
+    "INSERT INTO nodes (node_id, node_name, alias, runtime, network_id) VALUES (?1, ?2, ?2, 'claude-code', ?3)",
+    [nodeId, ALIAS, networkId],
+  );
+  db.run(
+    "INSERT INTO sessions (resume_id, alias, status, node_id, network_id) VALUES (?1, ?2, 'idle', ?3, ?4)",
+    [`r_sched_reply_${stamp}`, ALIAS, nodeId, networkId],
+  );
+  const mod: any = await import("./server.js");
+  server = mod.bootServer({ port: 0, hostname: "127.0.0.1" });
+  base = `http://127.0.0.1:${server.port}`;
+}, 30_000);
+
+afterAll(() => {
+  try { server?.stop?.(true); } catch {}
+});
+
+describe("scheduled-task replies reach the schedule creator's unread", () => {
+  test("a direct reply still lands on the sender and counts once", async () => {
+    await ackAgent(ownerToken);
+    const sent = await api(ownerToken, "/api/task", { method: "POST", body: JSON.stringify({ network_id: networkId, alias: ALIAS, task: "direct hello" }) });
+    expect(sent.status).toBe(200);
+    const taskId = sent.body.task_id as string;
+    const reply = await nodeReply({ in_reply_to: taskId, text: "direct answer", status: "replied" });
+    expect(reply.ok).toBe(true);
+    expect(replyRow(taskId)?.session_name).toBe(ownerName);
+    expect((await unreadFor(ownerToken))[ALIAS]).toBe(1);
+    await ackAgent(ownerToken);
+    expect((await unreadFor(ownerToken))[ALIAS]).toBeUndefined();
+  });
+
+  test("a scheduled-task reply counts for the creator, and ack-by-agent clears it", async () => {
+    await ackAgent(ownerToken);
+    const { taskId } = await fireSchedule(ownerToken, "owner-every-2m");
+    // 节点不带 alias(SDK 运行时)——收件人由 in_reply_to 推出
+    const reply = await nodeReply({ in_reply_to: taskId, text: "tick answer", status: "replied" });
+    expect(reply.ok).toBe(true);
+    expect(replyRow(taskId)).toEqual({ session_name: ownerName, from_session: ALIAS, acked: 0 });
+    expect(db.get<{ status: string; result: string }>("SELECT status, result FROM tasks WHERE task_id = ?1", taskId))
+      .toEqual({ status: "replied", result: "tick answer" });
+    expect((await unreadFor(ownerToken))[ALIAS]).toBe(1);
+
+    const acked = await ackAgent(ownerToken);
+    expect(acked.acked_inbox).toBe(1);
+    expect((await unreadFor(ownerToken))[ALIAS]).toBeUndefined();
+    expect(replyRow(taskId)?.acked).toBe(1);
+  });
+
+  test("a node that names alias='scheduler' explicitly is routed the same way", async () => {
+    await ackAgent(ownerToken);
+    const { taskId } = await fireSchedule(ownerToken, "owner-explicit-alias");
+    const reply = await nodeReply({ alias: "scheduler", in_reply_to: taskId, text: "explicit answer", status: "replied" });
+    expect(reply.ok).toBe(true);
+    expect(replyRow(taskId)?.session_name).toBe(ownerName);
+    expect((await unreadFor(ownerToken))[ALIAS]).toBe(1);
+    await ackAgent(ownerToken);
+  });
+
+  test("another member of the network does not get the owner's scheduled reply, and gets their own", async () => {
+    await ackAgent(ownerToken);
+    await ackAgent(memberToken);
+    const ownerRun = await fireSchedule(ownerToken, "owner-only");
+    expect((await nodeReply({ in_reply_to: ownerRun.taskId, text: "for owner", status: "replied" })).ok).toBe(true);
+    expect((await unreadFor(memberToken))[ALIAS]).toBeUndefined();
+    expect((await unreadFor(ownerToken))[ALIAS]).toBe(1);
+
+    const memberRun = await fireSchedule(memberToken, "member-only");
+    expect((await nodeReply({ in_reply_to: memberRun.taskId, text: "for member", status: "replied" })).ok).toBe(true);
+    expect(replyRow(memberRun.taskId)?.session_name).toBe(memberName);
+    expect((await unreadFor(memberToken))[ALIAS]).toBe(1);
+    expect((await unreadFor(ownerToken))[ALIAS]).toBe(1);
+    await ackAgent(ownerToken);
+    await ackAgent(memberToken);
+  });
+
+  test("a schedule with no creator falls back to 'scheduler'", async () => {
+    await ackAgent(ownerToken);
+    const { scheduleId, taskId } = await fireSchedule(ownerToken, "creatorless");
+    db.run("UPDATE scheduled_tasks SET created_by = NULL WHERE schedule_id = ?1", [scheduleId]);
+    expect((await nodeReply({ in_reply_to: taskId, text: "nobody's", status: "replied" })).ok).toBe(true);
+    expect(replyRow(taskId)?.session_name).toBe("scheduler");
+    expect((await unreadFor(ownerToken))[ALIAS]).toBeUndefined();
+  });
+
+  test("a creator whose username is also a node alias falls back to 'scheduler' (the collision guard)", async () => {
+    await ackAgent(ownerToken);
+    const { taskId } = await fireSchedule(ownerToken, "colliding-creator");
+    const clashNodeId = `n_clash_${stamp}`;
+    db.run(
+      "INSERT INTO nodes (node_id, node_name, alias, runtime, network_id) VALUES (?1, ?2, ?2, 'claude-code', ?3)",
+      [clashNodeId, ownerName, networkId],
+    );
+    try {
+      expect((await nodeReply({ in_reply_to: taskId, text: "not a todo", status: "replied" })).ok).toBe(true);
+      // 那个同名节点收不到这条(它不是节点的待办),用户名也拿不到(inbox 半边整体跳过)
+      expect(replyRow(taskId)?.session_name).toBe("scheduler");
+      expect(db.get<{ n: number }>(
+        "SELECT COUNT(*) AS n FROM inbox WHERE session_name = ?1 AND in_reply_to = ?2", ownerName, taskId,
+      )?.n).toBe(0);
+    } finally {
+      db.run("DELETE FROM nodes WHERE node_id = ?1", [clashNodeId]);
+    }
+  });
+});

package/src/scheduled-requirement-wake-http.test.ts

@@ -0,0 +1,264 @@
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { createNetworkTokenForNode, register } from "./auth.js";
+import { db, syncScheduledRunForTask } from "./db.js";
+import { consumeRequirementWake, pollRequirementWakes } from "./scheduled-requirement-wake.js";
+import { refreshScheduledBackoff } from "./scheduled-backoff.js";
+import { getScheduleRow, dispatchScheduledOccurrence, runDueScheduledTasks } from "./scheduled-tasks.js";
+
+if (!process.env.COMMHUB_DB) throw new Error("test1279 requires an explicit disposable SQLite COMMHUB_DB");
+let server: any, base = "", network = "", ownerToken = "", ownerId = "";
+const stamp = Date.now(), nodes: Record<string, { id: string; alias: string; token: string; tokenId: string }> = {};
+async function rest(token: string, method: string, path: string, body?: unknown) {
+  const r = await fetch(base + path, { method, headers: { Authorization: `Bearer ${token}`,
+    "Content-Type": "application/json" }, body: body === undefined ? undefined : JSON.stringify(body) });
+  return { status: r.status, body: await r.json() as any };
+}
+async function mcp(token: string, name: string, args: Record<string, unknown>) {
+  const r = await fetch(base + "/mcp", { method: "POST", headers: { Authorization: `Bearer ${token}`,
+    "Content-Type": "application/json", Accept: "application/json, text/event-stream" },
+    body: JSON.stringify({ jsonrpc: "2.0", id: 1, method: "tools/call", params: { name, arguments: args } }) });
+  const raw = await r.text(), line = raw.split("\n").find(x => x.startsWith("data: "));
+  const envelope = JSON.parse(line ? line.slice(6) : raw);
+  try { return JSON.parse(envelope.result.content[0].text); }
+  catch { return { ok: false, transportError: true }; }
+}
+const readRun = (taskId: string) => db.get<any>(
+  "SELECT run_id, schedule_id, status, work_outcome, work_outcome_node_id, schedule_revision FROM scheduled_task_runs WHERE task_id = ?1 AND network_id = ?2", taskId, network)!;
+const readTask = (taskId: string) => db.get<any>("SELECT status, result FROM tasks WHERE task_id = ?1", taskId)!;
+const countReplies = (taskId: string) => db.get<{ n: number }>("SELECT COUNT(*) AS n FROM inbox WHERE in_reply_to = ?1 AND type = 'reply'", taskId)!.n;
+async function fire(enabled = true, interval = 120) {
+  const created = await rest(ownerToken, "POST", "/api/scheduled-tasks", { network_id: network,
+    name: `test1279-${crypto.randomUUID()}`, target_node_id: nodes.a.id, task: "fixture1278 work",
+    schedule: { type: "interval", every_seconds: interval, ...(enabled ? { requirement_wake: { tag: "ANet" } } : {}) }, timezone: "UTC", no_change_backoff: enabled });
+  expect(created.status).toBe(201);
+  const scheduleId = created.body.schedule.schedule_id;
+  db.run("UPDATE scheduled_tasks SET next_run_at = ?1 WHERE schedule_id != ?2", [new Date(Date.now() + 86400_000).toISOString(), scheduleId]);
+  db.run("UPDATE scheduled_tasks SET next_run_at = ?1 WHERE schedule_id = ?2", [new Date(Date.now() - 1000).toISOString(), scheduleId]);
+  await runDueScheduledTasks();
+  const run = db.get<any>("SELECT task_id FROM scheduled_task_runs WHERE schedule_id = ?1", scheduleId)!;
+  expect(run.task_id).toBeTruthy();
+  return { taskId: run.task_id as string, scheduleId };
+}
+const reply = (taskId: string, meta?: unknown, status = "replied", token = nodes.a.token, extra = {}) =>
+  mcp(token, "send_reply", { in_reply_to: taskId, text: "本轮无新增", status, ...(meta === undefined ? {} : { meta }), ...extra });
+const cadence = (id: string) => db.get<any>("SELECT next_run_at, last_run_at, revision, schedule_json, target_node_id FROM scheduled_tasks WHERE schedule_id = ?1", id)!;
+
+beforeAll(async () => {
+  const owner = register(`work_owner_${stamp}`, "Fixture1274Only!x"); ownerToken = owner.token!;
+  network = owner.network_id!; ownerId = owner.user!.user_id;
+  for (const key of ["a", "b"]) {
+    const id = `n_work_${key}_${stamp}`, alias = `work-${key}-${stamp}`;
+    const token = createNetworkTokenForNode(ownerId, network, alias, id); expect(token.ok).toBe(true);
+    nodes[key] = { id, alias, token: token.token!, tokenId: token.token_id! };
+    db.run("INSERT INTO sessions (resume_id, alias, status, node_id, network_id) VALUES (?1, ?2, 'idle', ?3, ?4)", [`r_${id}`, alias, id, network]);
+  }
+  const mod = await import("./server.js"); server = mod.bootServer({ port: 0, hostname: "127.0.0.1" });
+  base = `http://127.0.0.1:${server.port}`;
+}, 30_000);
+afterAll(() => server?.stop?.(true));
+
+
+const state = (id: string) => db.get<any>("SELECT no_change_backoff, backoff_streak, backoff_effective_seconds, backoff_last_run_id, next_run_at, revision, schedule_json, status, requirement_wake_json, requirement_wake_cursor, requirement_wake_last_event_id FROM scheduled_tasks WHERE schedule_id = ?1", id)!;
+let occurrence = 0;
+async function nextRun(id: string) {
+  // Isolated fixture accelerates the clock, without touching live schedules.
+  const date = new Date(Date.now() + (++occurrence) * 1000).toISOString();
+  const out = dispatchScheduledOccurrence(getScheduleRow(id)!, date, true);
+  expect(out.taskId).toBeTruthy(); return out.taskId!;
+}
+async function empties(id: string, n: number) {
+  for (let i = 0; i < n; i++) expect((await reply(await nextRun(id), { scheduled_work_outcome: "no_changes" })).ok).toBe(true);
+}
+async function atThree() {
+  const x = await fire(); expect((await reply(x.taskId, { scheduled_work_outcome: "no_changes" })).ok).toBe(true);
+  await empties(x.scheduleId, 2); return x;
+}
+
+async function card(body: Record<string, unknown> = {}, token = ownerToken) {
+  const c = await rest(token, "POST", "/api/requirements", { network_id: network, name: "domain1279", tags: ["ANet", "知识库"], ...body });
+  expect(c.status).toBe(201); return c.body.requirement;
+}
+async function column(id: string, status: string, token = ownerToken) {
+  const c = await rest(token, "PATCH", `/api/requirements/${id}`, { column: status }); expect(c.status).toBe(200);
+}
+function poll(id: string) { return consumeRequirementWake(id, network); }
+describe("#1279 authoritative scoped requirement-event wake over HTTP/MCP", () => {
+  test("new matching work restores base with a durable cursor and fences old completion", async () => {
+    const { scheduleId } = await atThree(), before = state(scheduleId), old = await nextRun(scheduleId);
+    const c = await card(); expect(poll(scheduleId)).toBe(true);
+    const after = state(scheduleId); expect(after).toMatchObject({ backoff_streak: 0, backoff_effective_seconds: null, revision: before.revision + 1, schedule_json: before.schedule_json });
+    expect(after.requirement_wake_cursor).toBeGreaterThan(before.requirement_wake_cursor);
+    expect(after.requirement_wake_last_event_id).toBeTruthy();
+    expect(Date.parse(after.next_run_at) - Date.now()).toBeLessThanOrEqual(120_000);
+    expect((await reply(old, { scheduled_work_outcome: "no_changes" })).ok).toBe(true);
+    expect(state(scheduleId).backoff_streak).toBe(0); expect(state(scheduleId).revision).toBe(after.revision);
+    expect(poll(scheduleId)).toBe(false); expect(state(scheduleId)).toEqual(after);
+    const wire = await rest(ownerToken, "GET", `/api/scheduled-tasks/${scheduleId}`);
+    expect(wire.body.schedule.schedule.requirement_wake).toEqual({ tag: "ANet", project_id: null });
+    expect(JSON.stringify(wire.body.schedule)).not.toContain(ownerId);
+    expect(c.id).toBeTruthy();
+  });
+  test("a matching event is consumed within normal reply before the old empty signal can delay cadence", async () => {
+    const { scheduleId } = await atThree(), task = await nextRun(scheduleId), revision = state(scheduleId).revision;
+    await card(); expect((await reply(task, { scheduled_work_outcome: "no_changes" })).ok).toBe(true);
+    expect(state(scheduleId)).toMatchObject({ backoff_streak: 0, backoff_effective_seconds: null, revision: revision + 1 });
+  });
+  test("existing scheduler tick scans delayed plans even before their next due", async () => {
+    const { scheduleId } = await atThree(), before = state(scheduleId); await card();
+    runDueScheduledTasks(); expect(state(scheduleId).revision).toBe(before.revision + 1);
+    expect(state(scheduleId).backoff_streak).toBe(0);
+  });
+  test("old events and duplicate consumption do not replay after enable or process reopen", async () => {
+    await card(); const { scheduleId } = await atThree(), before = state(scheduleId); expect(poll(scheduleId)).toBe(false);
+    const child = Bun.spawn([process.execPath, "-e", `import {consumeRequirementWake} from './server/src/scheduled-requirement-wake.ts'; console.log(JSON.stringify({wake:consumeRequirementWake(${JSON.stringify(scheduleId)},${JSON.stringify(network)})}));`], { cwd: process.cwd(), stdout: "pipe", stderr: "pipe", env: process.env });
+    const output = await new Response(child.stdout).text(); expect(await child.exited).toBe(0);
+    expect(JSON.parse(output.trim().split("\n").at(-1)!)).toEqual({ wake: false }); expect(state(scheduleId)).toEqual(before);
+  });
+  test("status transitions wake while comments/checklists/no-op edits do not", async () => {
+    const c = await card({ checklist: [{ id: "one", text: "unit", done: false }] });
+    const { scheduleId } = await atThree(), before = state(scheduleId);
+    expect((await mcp(ownerToken, "requirements_comment", { id: c.id, network_id: network, text: "routine checkpoint" })).ok).toBe(true);
+    expect((await mcp(ownerToken, "requirements_checklist_toggle", { id: c.id, network_id: network, item_id: "one", done: true })).ok).toBe(true);
+    await column(c.id, "pool"); expect(poll(scheduleId)).toBe(false);
+    expect(state(scheduleId).revision).toBe(before.revision); expect(state(scheduleId).backoff_streak).toBe(3);
+    await column(c.id, "doing"); expect(poll(scheduleId)).toBe(true);
+  });
+  test("self node writes and iteration archives do not wake; knowledge-tagged real work can wake", async () => {
+    const { scheduleId } = await atThree(), before = state(scheduleId);
+    expect((await mcp(nodes.a.token, "requirements_create", { name: "self source", tags: ["ANet"], network_id: network })).ok).toBe(true);
+    await card({ external_ref: "iteration:fixture1279" }); expect(poll(scheduleId)).toBe(false);
+    expect(state(scheduleId).revision).toBe(before.revision);
+    await card(); expect(poll(scheduleId)).toBe(true);
+  });
+  test("other-node real work wakes and unrelated tags or networks do not", async () => {
+    const { scheduleId } = await atThree(), before = state(scheduleId);
+    await card({ tags: ["unrelated"] }); expect(poll(scheduleId)).toBe(false);
+    const foreign = register(`foreign1279_${crypto.randomUUID()}`, "Fixture1279Only!x");
+    expect((await rest(foreign.token!, "POST", "/api/requirements", { network_id: foreign.network_id!, name: "foreign", tags: ["ANet"] })).status).toBe(201);
+    expect(poll(scheduleId)).toBe(false); expect(state(scheduleId).revision).toBe(before.revision);
+    expect((await mcp(nodes.b.token, "requirements_create", { name: "other real work", tags: ["ANet"], network_id: network })).ok).toBe(true);
+    expect(poll(scheduleId)).toBe(true);
+  });
+  test("creator MCP config roundtrip retains watch through batch/metadata edits; another node cannot edit it", async () => {
+    const created = await mcp(nodes.a.token, "schedule_create", { name: "agent wake1279", task: "fixture", no_change_backoff: true, schedule: { type: "interval", every_seconds: 120, requirement_wake: { tag: "ANet" } } });
+    expect(created.ok).toBe(true); const id = created.schedule.schedule_id;
+    expect(created.schedule.schedule.requirement_wake.tag).toBe("ANet");
+    expect((await mcp(nodes.b.token, "schedule_update", { schedule_id: id, schedule: { type: "interval", every_seconds: 180, requirement_wake: null } })).ok).toBe(false);
+    expect((await mcp(nodes.a.token, "schedule_batch_interval", { schedule_ids: [id], every_seconds: 180 })).ok).toBe(true);
+    expect(state(id).requirement_wake_json).toBeTruthy();
+    expect((await mcp(nodes.a.token, "schedule_update", { schedule_id: id, name: "metadata" })).ok).toBe(true);
+    expect(state(id).requirement_wake_json).toBeTruthy();
+    expect((await mcp(nodes.a.token, "schedule_update", { schedule_id: id, no_change_backoff: false })).ok).toBe(true);
+    expect(state(id).requirement_wake_json).toBeNull();
+  });
+  test("paused/cancelled plans do not wake; resume rebases the cursor rather than replaying hidden time", async () => {
+    const { scheduleId } = await atThree();
+    expect((await rest(ownerToken, "PATCH", `/api/scheduled-tasks/${scheduleId}`, { revision: state(scheduleId).revision, status: "paused" })).status).toBe(200);
+    const before = state(scheduleId); await card(); expect(poll(scheduleId)).toBe(false); expect(state(scheduleId)).toEqual(before);
+    expect((await rest(ownerToken, "PATCH", `/api/scheduled-tasks/${scheduleId}`, { revision: state(scheduleId).revision, status: "active" })).status).toBe(200);
+    expect(poll(scheduleId)).toBe(false); expect(state(scheduleId).backoff_streak).toBe(0);
+    expect((await rest(ownerToken, "DELETE", `/api/scheduled-tasks/${scheduleId}`)).status).toBe(200);
+    const canceled = state(scheduleId); await card(); expect(poll(scheduleId)).toBe(false); expect(state(scheduleId)).toEqual(canceled);
+  });
+  test("current restricted target visibility is enforced even in permission log mode, grants never replay skipped history", async () => {
+    const { scheduleId } = await atThree(), before = state(scheduleId);
+    db.run("UPDATE nodes SET permission_mode = 'restricted' WHERE node_id = ?1", nodes.a.id);
+    try { await card(); expect(poll(scheduleId)).toBe(false); expect(state(scheduleId).revision).toBe(before.revision); }
+    finally { db.run("UPDATE nodes SET permission_mode = 'normal' WHERE node_id = ?1", nodes.a.id); }
+    expect(poll(scheduleId)).toBe(false);
+    await card(); expect(poll(scheduleId)).toBe(true);
+  });
+  test("creator membership loss, read-only target and owner replacement suppress wake and consume without replay", async () => {
+    for (const change of ["membership", "readonly", "owner"]) {
+      const { scheduleId } = await atThree(), before = state(scheduleId);
+      if (change === "membership") db.run("DELETE FROM network_members WHERE network_id = ?1 AND user_id = ?2", [network, ownerId]);
+      if (change === "readonly") db.run("UPDATE nodes SET permission_mode = 'readonly' WHERE node_id = ?1", nodes.a.id);
+      if (change === "owner") db.run("UPDATE nodes SET owner_user_id = NULL WHERE node_id = ?1", nodes.a.id);
+      // Fixture-only trusted event insertion after revocation; public mutation
+      // itself may now refuse, and must not be weakened for this scenario.
+      const c = db.get<any>("SELECT requirement_id,seq,title FROM requirements WHERE network_id = ?1 LIMIT 1", network)!;
+      db.run("INSERT INTO requirement_events(network_id,requirement_id,seq,title,actor_json,kind,field,old_json,new_json,created_at) VALUES(?1,?2,?3,?4,?5,'changed','column','\"pool\"','\"doing\"',datetime('now'))", [network,c.requirement_id,c.seq,c.title,JSON.stringify({kind:"user",id:ownerId})]);
+      try { expect(poll(scheduleId)).toBe(false); expect(state(scheduleId).revision).toBe(before.revision); }
+      finally {
+        if (change === "membership") db.run("INSERT INTO network_members(network_id,user_id,role,task_access) VALUES(?1,?2,'owner','all')", [network,ownerId]);
+        if (change === "readonly") db.run("UPDATE nodes SET permission_mode = 'normal' WHERE node_id = ?1", nodes.a.id);
+        if (change === "owner") db.run("UPDATE nodes SET owner_user_id = ?1 WHERE node_id = ?2", [ownerId,nodes.a.id]);
+      }
+      expect(poll(scheduleId)).toBe(false); expect(state(scheduleId).revision).toBe(before.revision);
+    }
+  });
+  test("cursor write fault rolls back wake and the normal reply together; retry consumes exactly once", async () => {
+    const { scheduleId } = await atThree(), task = await nextRun(scheduleId); await card(); const before = state(scheduleId);
+    db.exec(`CREATE TRIGGER test1279_fault BEFORE UPDATE OF requirement_wake_cursor ON scheduled_tasks WHEN NEW.schedule_id='${scheduleId}' BEGIN SELECT RAISE(ABORT,'test1279_fault'); END`);
+    try { expect((await reply(task, { scheduled_work_outcome: "no_changes" })).ok).not.toBe(true); }
+    finally { db.exec("DROP TRIGGER test1279_fault"); }
+    expect(state(scheduleId)).toEqual(before); expect(readTask(task).status).toBe("delivered");
+    expect(readRun(task).work_outcome).toBeNull(); expect(countReplies(task)).toBe(0);
+    expect((await reply(task, { scheduled_work_outcome: "no_changes" })).ok).toBe(true);
+    expect(state(scheduleId).revision).toBe(before.revision + 1); expect(poll(scheduleId)).toBe(false);
+  });
+  test("invalid/empty/forged authority filters refuse without creating a plan; explicit null disables", async () => {
+    for (const policy of [true, {}, {tag:""}, {tag:"ANet", creator_user_id:ownerId}]) {
+      const out = await rest(ownerToken, "POST", "/api/scheduled-tasks", { network_id:network, name:"invalid1279",target_node_id:nodes.a.id,task:"fixture",no_change_backoff:true,schedule:{type:"interval",every_seconds:120,requirement_wake:policy} }); expect(out.status).toBe(400);
+    }
+    const {scheduleId}=await atThree();
+    expect((await rest(ownerToken,"PATCH",`/api/scheduled-tasks/${scheduleId}`,{revision:state(scheduleId).revision,schedule:{type:"interval",every_seconds:120,requirement_wake:null}})).status).toBe(200);
+    await card();expect(poll(scheduleId)).toBe(false);expect(state(scheduleId).requirement_wake_json).toBeNull();
+  });
+  test("project filter and current target project grants limit wake, revoked grants never replay", async () => {
+    const p1 = await rest(ownerToken,"POST","/api/requirements/projects",{network_id:network,name:"project1279"}); expect(p1.status).toBe(201); const project=p1.body.project.id;
+    const {scheduleId}=await atThree();
+    const scoped=register(`scoped1279_${crypto.randomUUID()}`,"Fixture1279Only!x"), uid=scoped.user!.user_id;
+    db.run("INSERT INTO network_members(network_id,user_id,role,task_access) VALUES(?1,?2,'member','scoped')",[network,uid]);
+    db.run("UPDATE nodes SET owner_user_id = ?1 WHERE node_id = ?2",[uid,nodes.a.id]);
+    try {
+      const edit=await rest(ownerToken,"PATCH",`/api/scheduled-tasks/${scheduleId}`,{revision:state(scheduleId).revision,schedule:{type:"interval",every_seconds:120,requirement_wake:{project_id:project,tag:"ANet"}}}); expect(edit.status).toBe(200);
+      const base=state(scheduleId);
+      await card({project_id:project}); expect(poll(scheduleId)).toBe(false); expect(state(scheduleId).revision).toBe(base.revision);
+      expect((await rest(ownerToken,"PUT",`/api/networks/${network}/members/${uid}/task-grants`,{task_access:"scoped",project_grants:[{project_id:project}]})).status).toBe(200);
+      expect(poll(scheduleId)).toBe(false); // no replay after gaining access
+      await card(); expect(poll(scheduleId)).toBe(false); // tag alone is insufficient
+      await card({project_id:project}); expect(poll(scheduleId)).toBe(true);
+      expect((await rest(ownerToken,"PUT",`/api/networks/${network}/members/${uid}/task-grants`,{task_access:"scoped",project_grants:[]})).status).toBe(200);
+      const before=state(scheduleId); await card({project_id:project}); expect(poll(scheduleId)).toBe(false); expect(state(scheduleId).revision).toBe(before.revision);
+    } finally { db.run("UPDATE nodes SET owner_user_id = ?1 WHERE node_id = ?2",[ownerId,nodes.a.id]); }
+  });
+  test("a scoped editor cannot borrow the original creator's event visibility", async () => {
+    const {scheduleId}=await atThree();
+    const scoped=register(`editor1279_${crypto.randomUUID()}`,"Fixture1279Only!x"), uid=scoped.user!.user_id;
+    db.run("INSERT INTO network_members(network_id,user_id,role,task_access) VALUES(?1,?2,'member','scoped')",[network,uid]);
+    const edit=await rest(scoped.token!,"PATCH",`/api/scheduled-tasks/${scheduleId}`,{revision:state(scheduleId).revision,schedule:{type:"interval",every_seconds:120,requirement_wake:{tag:"ANet"}}}); expect(edit.status).toBe(200);
+    const before=state(scheduleId); await card(); expect(poll(scheduleId)).toBe(false); expect(state(scheduleId).revision).toBe(before.revision);
+    await card({participants:[{kind:"user",id:uid}]}); expect(poll(scheduleId)).toBe(true);
+    const project=await rest(ownerToken,"POST","/api/requirements/projects",{network_id:network,name:"hidden1279"}); expect(project.status).toBe(201);
+    expect((await rest(scoped.token!,"PATCH",`/api/scheduled-tasks/${scheduleId}`,{revision:state(scheduleId).revision,schedule:{type:"interval",every_seconds:120,requirement_wake:{project_id:project.body.project.id}}})).status).toBe(400);
+  });
+  test("manual wake rebases pending events so a stale event cannot reset again",async()=>{
+    const {scheduleId}=await atThree();await card();const before=state(scheduleId);
+    const out=await rest(ownerToken,"POST",`/api/scheduled-tasks/${scheduleId}/run-now`);expect(out.status).toBe(202);
+    expect(state(scheduleId).revision).toBe(before.revision+1);expect(poll(scheduleId)).toBe(false);
+  });
+  test("bounded cursor pages do not lose a later matching event",async()=>{
+    const c=await card(),{scheduleId}=await atThree(),revision=state(scheduleId).revision;
+    db.transaction(()=>{for(let i=0;i<270;i++)db.run("INSERT INTO requirement_events(network_id,requirement_id,actor_json,kind,new_json,created_at) VALUES(?1,?2,?3,'comment','{}',datetime('now'))",[network,c.id,JSON.stringify({kind:"user",id:ownerId})]);});
+    await card();expect(poll(scheduleId)).toBe(false);expect(state(scheduleId).revision).toBe(revision);
+    expect(poll(scheduleId)).toBe(true);expect(state(scheduleId).revision).toBe(revision+1);expect(poll(scheduleId)).toBe(false);
+  });
+  test("two independent SQLite processes consume the event once and persist one generation",async()=>{
+    const {scheduleId}=await atThree();await card();const before=state(scheduleId), gate=`/tmp/wake1279-${crypto.randomUUID()}`;
+    const code=`import {consumeRequirementWake} from './server/src/scheduled-requirement-wake.ts'; import {existsSync} from 'node:fs'; console.log('READY'); while(!existsSync(${JSON.stringify(gate)}))await Bun.sleep(10); for(let i=0;;i++){try{console.log(JSON.stringify({wake:consumeRequirementWake(${JSON.stringify(scheduleId)},${JSON.stringify(network)})})); break;}catch(e){if(i>=4||!String(e).includes('locked'))throw e;await Bun.sleep(20);}}`;
+    const workers=[] as any[];
+    // Initialize each adapter before releasing both against the same DB;
+    // schema startup is not the race under qualification.
+    for(let i=0;i<2;i++){
+      const child=Bun.spawn([process.execPath,"-e",code],{cwd:process.cwd(),stdout:"pipe",stderr:"pipe",env:process.env});
+      const reader=child.stdout.getReader();let start="";
+      for(;;){const part=await reader.read();if(part.done)throw new Error('worker exited before ready');start+=new TextDecoder().decode(part.value);if(start.includes('READY'))break;}
+      workers.push({child,reader,start});
+    }
+    await Bun.write(gate,"go");const results=[];
+    for(const w of workers){let output=w.start;for(;;){const part=await w.reader.read();if(part.done)break;output+=new TextDecoder().decode(part.value);}expect(await w.child.exited).toBe(0);results.push(JSON.parse(output.trim().split("\n").at(-1)!).wake);}
+    expect(results.sort()).toEqual([false,true]);expect(state(scheduleId).revision).toBe(before.revision+1);expect(poll(scheduleId)).toBe(false);
+  });
+
+});

package/src/scheduled-requirement-wake.ts

@@ -0,0 +1,125 @@
+import { db } from "./db.js";
+import { ensureRequirementEvents } from "./requirement-events.js";
+import { canSeeTask, canUseProject, type TaskCaller } from "./task-access.js";
+import { setRequirementWakeHook } from "./scheduled-backoff.js";
+import { parseHubTimestamp } from "./hub-timestamp.js";
+
+ensureRequirementEvents(db);
+export type RequirementWake = { project_id: string | null; tag: string | null };
+type StoredWake = RequirementWake & { creator_user_id: string; target_owner_user_id: string; configured_by_user_id: string };
+type Plan = { schedule_id?: string; network_id: string; created_by: string | null;
+  created_by_node_id: string | null; target_node_id: string };
+
+/** No implicit broad access when identity/membership is gone. Read current
+ * node mode and owner, rather than a token alias or a cached permission flag. */
+function principal(userId: string | null, network: string, nodeId?: string | null): TaskCaller {
+  let only = false;
+  if (nodeId) {
+    const node = db.get<any>("SELECT owner_user_id, permission_mode FROM nodes WHERE node_id = ?1 AND network_id = ?2", nodeId, network);
+    if (!node || node.permission_mode === "readonly") return null;
+    userId = node.owner_user_id; only = node.permission_mode === "restricted";
+  }
+  if (!userId || !db.get("SELECT 1 FROM network_members m JOIN users u ON u.user_id = m.user_id WHERE m.user_id = ?1 AND m.network_id = ?2 AND m.role != 'viewer'", userId, network)) return null;
+  return { userId, ...(nodeId ? { node: { id: nodeId, only } } : {}) };
+}
+function audience(row: Plan) {
+  return { creator: principal(row.created_by, row.network_id, row.created_by_node_id),
+    target: principal(null, row.network_id, row.target_node_id) };
+}
+export function parseRequirementWake(raw: unknown, fallback: string | null = null): RequirementWake | null {
+  if (raw === undefined) return fallback ? publicRequirementWake(fallback) : null;
+  if (raw === null) return null;
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) throw new Error("invalid_requirement_wake");
+  const p = raw as Record<string, unknown>;
+  if (Object.keys(p).some(k => k !== "project_id" && k !== "tag")) throw new Error("invalid_requirement_wake");
+  const project = p.project_id ?? null, tag = p.tag ?? null;
+  if (project !== null && (typeof project !== "string" || !project || project.length > 200)
+    || tag !== null && (typeof tag !== "string" || !tag.trim() || tag.length > 20)
+    || project === null && tag === null) throw new Error("invalid_requirement_wake");
+  return { project_id: project as string | null, tag: tag as string | null };
+}
+export function publicRequirementWake(json: string): RequirementWake {
+  const p = JSON.parse(json); return { project_id: p.project_id, tag: p.tag };
+}
+export function requirementWakeHead(network: string): number {
+  return Number(db.get<any>("SELECT COALESCE(MAX(id), 0) AS id FROM requirement_events WHERE network_id = ?1", network)!.id);
+}
+/** Called by the existing authorized creator/editor paths. No production
+ * plans are opted in by migration. The config records the creator authority. */
+export function bindRequirementWake(row: Plan, policy: RequirementWake | null, enabled: boolean, type: string, configuratorUserId: string | null): string | null {
+  if (!policy) return null;
+  if (!enabled || type !== "interval") throw new Error("requirement_wake_requires_backoff_interval");
+  const a = audience(row), configurator = principal(configuratorUserId, row.network_id);
+  if (!a.creator || !a.target || !configurator) throw new Error("requirement_wake_identity_unresolved");
+  if (policy.project_id && (!db.get("SELECT 1 FROM requirement_projects WHERE project_id = ?1 AND network_id = ?2", policy.project_id, row.network_id)
+    || !canUseProject(a.creator, row.network_id, policy.project_id) || !canUseProject(configurator, row.network_id, policy.project_id))) throw new Error("requirement_wake_scope_not_visible");
+  return JSON.stringify({ ...policy, creator_user_id: a.creator.userId, target_owner_user_id: a.target.userId, configured_by_user_id: configurator.userId } satisfies StoredWake);
+}
+
+/** One cursor and generation update, atomic with the calling reply/dispatch
+ * transaction. Any write fault propagates; no consume-then-forget window. */
+export function consumeRequirementWake(id: string, network: string, now = new Date()): boolean {
+  if (db.transactionalFeaturesRefusal !== null) return false;
+  return db.transaction(() => {
+    const row = db.get<any>(`SELECT schedule_id, network_id, created_by, created_by_node_id, target_node_id,
+      status, revision, schedule_json, no_change_backoff, requirement_wake_json, requirement_wake_cursor,
+      next_run_at FROM scheduled_tasks WHERE schedule_id = ?1 AND network_id = ?2`, id, network);
+    if (!row || row.status !== "active" || row.no_change_backoff !== 1 || !row.requirement_wake_json) return false;
+    const spec = JSON.parse(row.schedule_json); if (spec.type !== "interval") return false;
+    const policy: StoredWake = JSON.parse(row.requirement_wake_json), a = audience(row);
+    const configurator = principal(policy.configured_by_user_id, network);
+    const allowed = configurator && a.creator && a.target && a.creator.userId === policy.creator_user_id
+      && a.target.userId === policy.target_owner_user_id;
+    // Cursor is advanced even for invisible/irrelevant events, so a later
+    // permission grant cannot replay history hidden at the consumption time.
+    const events = db.all<any>(`SELECT id, requirement_id, actor_json, kind, field, old_json, new_json
+      FROM requirement_events WHERE network_id = ?1 AND id > ?2 ORDER BY id LIMIT 256`, network, row.requirement_wake_cursor);
+    if (!events.length) return false;
+    let matching: number | null = null;
+    for (const event of events) {
+      if (!allowed || !(event.kind === "created" || event.kind === "changed" && event.field === "column")) continue;
+      let actor: any; try { actor = JSON.parse(event.actor_json); } catch { continue; }
+      if (!actor || !["user", "node"].includes(actor.kind) || typeof actor.id !== "string") continue;
+      if (actor.kind === "node" && [row.target_node_id, row.created_by_node_id].includes(actor.id)) continue;
+      if (event.kind === "changed") {
+        const states = ["pool", "doing", "done", "abandoned"];
+        let before: unknown, after: unknown;
+        try { before = JSON.parse(event.old_json); after = JSON.parse(event.new_json); } catch { continue; }
+        if (!states.includes(before as string) || !states.includes(after as string) || before === after) continue;
+      }
+      const card = db.get<any>(`SELECT network_id, project_id, tags_json, external_ref, archived, owner_json,
+        participants_json, created_by, created_by_json, agent_owner_json, parent_id
+        FROM requirements WHERE requirement_id = ?1 AND network_id = ?2`, event.requirement_id, network);
+      if (!card || card.archived || card.external_ref?.startsWith("iteration:")) continue;
+      if (policy.project_id && card.project_id !== policy.project_id) continue;
+      if (policy.tag) { let tags: unknown; try { tags = JSON.parse(card.tags_json); } catch { continue; }
+        if (!Array.isArray(tags) || !tags.includes(policy.tag)) continue; }
+      if (!canSeeTask(a.creator!, card) || !canSeeTask(a.target!, card) || !canSeeTask(configurator!, card)) continue;
+      matching = Number(event.id);
+    }
+    const cursor = Number(events.at(-1)!.id);
+    const due = parseHubTimestamp(row.next_run_at);
+    if (matching && row.next_run_at && due === null) throw new Error("requirement_wake_invalid_due_time");
+    const next = matching && row.next_run_at
+      ? new Date(Math.min(due!, now.getTime() + spec.every_seconds * 1000)).toISOString() : row.next_run_at;
+    const result = db.run(`UPDATE scheduled_tasks SET requirement_wake_cursor = ?1,
+      requirement_wake_last_event_id = CASE WHEN ?2 IS NOT NULL THEN ?2 ELSE requirement_wake_last_event_id END,
+      backoff_streak = CASE WHEN ?2 IS NOT NULL THEN 0 ELSE backoff_streak END,
+      backoff_effective_seconds = CASE WHEN ?2 IS NOT NULL THEN NULL ELSE backoff_effective_seconds END,
+      backoff_last_run_id = CASE WHEN ?2 IS NOT NULL THEN NULL ELSE backoff_last_run_id END,
+      revision = revision + CASE WHEN ?2 IS NOT NULL THEN 1 ELSE 0 END, next_run_at = ?3,
+      updated_at = CASE WHEN ?2 IS NOT NULL THEN datetime('now') ELSE updated_at END
+      WHERE schedule_id = ?4 AND network_id = ?5 AND revision = ?6 AND requirement_wake_cursor = ?7
+      AND status = 'active' AND no_change_backoff = 1`, [cursor, matching, next, id, network, row.revision, row.requirement_wake_cursor]);
+    if (result.changes !== 1) throw new Error("requirement_wake_atomic_write_failed");
+    return matching !== null;
+  });
+}
+/** Existing scheduler tick also scans opt-in plans whose next due is delayed. */
+export function pollRequirementWakes(now = new Date()): void {
+  if (db.transactionalFeaturesRefusal !== null) return;
+  const rows = db.all<any>(`SELECT schedule_id, network_id FROM scheduled_tasks
+    WHERE status = 'active' AND no_change_backoff = 1 AND requirement_wake_json IS NOT NULL`);
+  for (const row of rows) consumeRequirementWake(row.schedule_id, row.network_id, now);
+}
+setRequirementWakeHook(consumeRequirementWake);