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

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);

package/src/scheduled-tasks.ts

@@ -1,3 +1,6 @@
+import { bindRequirementWake, parseRequirementWake, publicRequirementWake, requirementWakeHead, pollRequirementWakes, type RequirementWake } from "./scheduled-requirement-wake.js";
+import { scheduledOutcomeGuidance } from "./scheduled-outcome-guidance.js";
+import { parseBackoffPolicy, refreshScheduledBackoff } from "./scheduled-backoff.js";
 import { db, logTaskEvent } from "./db.js";
 import { sessionTaskOnDispatch } from "./session-task-on-dispatch.js";
 import { TASK_CONTENT_MAX, sessionTaskPreview } from "./shared/task-content-limit.js";
@@ -38,6 +41,13 @@ export type ScheduledRow = {
   status: "active" | "paused" | "completed" | "cancelled";
   next_run_at: string | null;
   last_run_at: string | null;
+  no_change_backoff: number;
+  backoff_streak: number;
+  backoff_effective_seconds: number | null;
+  backoff_last_run_id: string | null;
+  requirement_wake_json: string | null;
+  requirement_wake_cursor: number;
+  requirement_wake_last_event_id: number | null;
   revision: number;
   created_at: string;
   updated_at: string;
@@ -184,8 +194,15 @@ export function nextOccurrence(spec: ScheduleSpec, timezone: string, after: Date
 function decodeRow(row: ScheduledRow): Record<string, unknown> {
   let schedule: unknown = null;
   try { schedule = JSON.parse(row.schedule_json); } catch {}
-  const { created_by: _createdBy, created_by_node_id: _createdByNode, schedule_json: _scheduleJson, ...publicRow } = row;
-  return { ...publicRow, schedule };
+  const { created_by: _createdBy, created_by_node_id: _createdByNode, schedule_json: _scheduleJson,
+    no_change_backoff, backoff_streak, backoff_effective_seconds, backoff_last_run_id,
+    requirement_wake_json, requirement_wake_cursor, requirement_wake_last_event_id, ...publicRow } = row;
+  if (requirement_wake_json && schedule && typeof schedule === "object")
+    schedule = { ...schedule, requirement_wake: publicRequirementWake(requirement_wake_json) };
+  return { ...publicRow, schedule, ...(requirement_wake_json ? { requirement_wake_state:
+    { cursor: requirement_wake_cursor, last_event_id: requirement_wake_last_event_id } } : {}), ...(no_change_backoff === 1 ? { no_change_backoff: true,
+    backoff: { streak: backoff_streak, effective_seconds: backoff_effective_seconds
+      ?? (schedule as { every_seconds?: number } | null)?.every_seconds, last_run_id: backoff_last_run_id } } : {}) };
 }
 
 /** MCP (agent) shape: REST shape + which node created it (null = a person / old row). Never the user id. */
@@ -202,7 +219,7 @@ export class ScheduleInputError extends Error {
 }
 
 export type ValidatedScheduleCreate = {
-  name: string; content: string; priority: string; misfirePolicy: MisfirePolicy;
+  name: string; content: string; priority: string; misfirePolicy: MisfirePolicy; backoff: boolean; wake: RequirementWake | null;
   target: { node_id: string; alias: string }; spec: ScheduleSpec; timezone: string; next: Date;
 };
 
@@ -219,16 +236,20 @@ export function validateScheduleCreate(networkId: string, body: Record<string, u
   const { spec, timezone } = parseScheduleSpec(body.schedule, body.timezone);
   const next = nextOccurrence(spec, timezone, new Date());
   if (!next) throw new Error("schedule_has_no_future_occurrence");
-  return { name, content, priority, misfirePolicy, target, spec, timezone, next };
+  return { name, content, priority, misfirePolicy, target, spec, timezone, next,
+    backoff: parseBackoffPolicy(body.no_change_backoff, spec.type),
+    wake: parseRequirementWake((body.schedule as Record<string, unknown>).requirement_wake) };
 }
 
 export function insertSchedule(networkId: string, createdBy: string | null, createdByNodeId: string | null, v: ValidatedScheduleCreate): ScheduledRow {
   const scheduleId = `sched_${crypto.randomUUID()}`;
+  const wakeJson = bindRequirementWake({ network_id: networkId, created_by: createdBy,
+    created_by_node_id: createdByNodeId, target_node_id: v.target.node_id }, v.wake, v.backoff, v.spec.type, createdBy);
   db.run(
     `INSERT INTO scheduled_tasks
-     (schedule_id, network_id, created_by, created_by_node_id, name, target_node_id, target_alias, task_content, priority, schedule_type, schedule_json, timezone, overlap_policy, misfire_policy, next_run_at)
-     VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10, ?11, ?12, 'skip', ?13, ?14)`,
-    [scheduleId, networkId, createdBy, createdByNodeId, v.name, v.target.node_id, v.target.alias, v.content, v.priority, v.spec.type, JSON.stringify(v.spec), v.timezone, v.misfirePolicy, iso(v.next)],
+     (schedule_id, network_id, created_by, created_by_node_id, name, target_node_id, target_alias, task_content, priority, schedule_type, schedule_json, timezone, overlap_policy, misfire_policy, next_run_at, no_change_backoff, requirement_wake_json, requirement_wake_cursor)
+     VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10, ?11, ?12, 'skip', ?13, ?14, ?15, ?16, ?17)`,
+    [scheduleId, networkId, createdBy, createdByNodeId, v.name, v.target.node_id, v.target.alias, v.content, v.priority, v.spec.type, JSON.stringify(v.spec), v.timezone, v.misfirePolicy, iso(v.next), v.backoff ? 1 : 0, wakeJson, wakeJson ? requirementWakeHead(networkId) : 0],
   );
   return getScheduleRow(scheduleId)!;
 }
@@ -236,7 +257,7 @@ export function insertSchedule(networkId: string, createdBy: string | null, crea
 /** Idempotent cancel (shared by REST DELETE / POST cancel and MCP schedule_cancel). */
 export function cancelSchedule(row: ScheduledRow): void {
   if (row.status === "cancelled") return;
-  db.run("UPDATE scheduled_tasks SET status = 'cancelled', next_run_at = NULL, revision = revision + 1, updated_at = datetime('now') WHERE schedule_id = ?1", [row.schedule_id]);
+  db.run("UPDATE scheduled_tasks SET status = 'cancelled', next_run_at = NULL, backoff_streak = 0, backoff_effective_seconds = NULL, backoff_last_run_id = NULL, revision = revision + 1, updated_at = datetime('now') WHERE schedule_id = ?1", [row.schedule_id]);
 }
 
 export function scheduleRuns(row: ScheduledRow, limit: number): Record<string, unknown> {
@@ -244,7 +265,7 @@ export function scheduleRuns(row: ScheduledRow, limit: number): Record<string, u
     // #523 — a task that ended `failed` leaves run.error_message empty; its reason is the task's reply text.
     `SELECT r.run_id, r.schedule_id, r.scheduled_for, r.task_id, r.status, r.error_code,
             CASE WHEN r.error_message IS NULL AND r.status = 'failed' THEN SUBSTR(t.result, 1, 500) ELSE r.error_message END AS error_message,
-            r.blocked_by_task_id, r.blocked_by_state, r.created_at, r.completed_at
+            r.blocked_by_task_id, r.blocked_by_state, r.created_at, r.completed_at, r.work_outcome, r.schedule_revision, r.work_outcome_node_id
        FROM scheduled_task_runs r
        LEFT JOIN tasks t ON t.task_id = r.task_id AND t.network_id = r.network_id
       WHERE r.schedule_id = ?1 AND r.network_id = ?2 ORDER BY r.created_at DESC, r.scheduled_for DESC LIMIT ?3`,
@@ -254,7 +275,7 @@ export function scheduleRuns(row: ScheduledRow, limit: number): Record<string, u
 }
 
 /** Shared PATCH semantics (REST PATCH and MCP schedule_update). Throws ScheduleInputError. */
-export function patchSchedule(row: ScheduledRow, body: Record<string, unknown>): ScheduledRow {
+export function patchSchedule(row: ScheduledRow, body: Record<string, unknown>, actorUserId: string | null = null): ScheduledRow {
   // Cancellation/completion are terminal states. Editing must never become
   // an implicit resurrection path (including by supplying status=active).
   if (row.status === "cancelled") throw new ScheduleInputError("schedule_cancelled", 409);
@@ -281,24 +302,32 @@ export function patchSchedule(row: ScheduledRow, body: Record<string, unknown>):
     // with no next occurrence. The recompute uses the same DST-safe helper
     // as creation and dispatch advancement.
     const scheduleJson = JSON.stringify(parsed.spec);
+    const backoff = parseBackoffPolicy(body.no_change_backoff, parsed.spec.type, row.no_change_backoff === 1);
+    if (backoff && row.overlap_policy !== "skip") throw new Error("no_change_backoff_requires_skip_overlap");
+    const rawWake = (body.schedule as Record<string, unknown> | undefined)?.requirement_wake;
+    const wake = parseRequirementWake(rawWake, backoff ? row.requirement_wake_json : null);
+    const wakeJson = bindRequirementWake({ ...row, target_node_id: target.node_id }, wake, backoff, parsed.spec.type, actorUserId);
+    // Every edit creates a new reporting generation. Reset opted-in cadence
+    // too, so the visible state never describes an older target/revision.
     const schedulingChanged = scheduleJson !== row.schedule_json || parsed.timezone !== row.timezone;
+    const backoffGenerationReset = row.no_change_backoff === 1 || backoff;
     const resumed = row.status !== "active" && requestedStatus === "active";
     const next = requestedStatus !== "active"
       ? null
-      : schedulingChanged || resumed || !row.next_run_at
+      : schedulingChanged || backoffGenerationReset || resumed || !row.next_run_at
         ? nextOccurrence(parsed.spec, parsed.timezone, new Date())
         : new Date(row.next_run_at);
     if (requestedStatus === "active" && !next) throw new Error("schedule_has_no_future_occurrence");
     // Runs no longer bump revision, so the scheduler may have advanced
     // next_run_at after `row` was read. When cadence is preserved, keep the
     // stored value instead of writing back the already-fired occurrence.
-    const keepStoredNext = requestedStatus === "active" && !schedulingChanged && !resumed && !!row.next_run_at ? 1 : 0;
+    const keepStoredNext = requestedStatus === "active" && !schedulingChanged && !backoffGenerationReset && !resumed && !!row.next_run_at ? 1 : 0;
     const updated = db.run(
       `UPDATE scheduled_tasks SET name = ?1, target_node_id = ?2, target_alias = ?3, task_content = ?4,
        priority = ?5, schedule_type = ?6, schedule_json = ?7, timezone = ?8, status = ?9,
        next_run_at = CASE WHEN ?14 = 1 AND next_run_at IS NOT NULL THEN next_run_at ELSE ?10 END,
-       misfire_policy = ?11, revision = revision + 1, updated_at = datetime('now') WHERE schedule_id = ?12 AND revision = ?13`,
-      [name, target.node_id, target.alias, content, priority, parsed.spec.type, scheduleJson, parsed.timezone, requestedStatus, next ? iso(next) : null, misfirePolicy, row.schedule_id, row.revision, keepStoredNext],
+       misfire_policy = ?11, no_change_backoff = ?15, requirement_wake_json = ?16, requirement_wake_cursor = ?17, requirement_wake_last_event_id = NULL, backoff_streak = 0, backoff_effective_seconds = NULL, backoff_last_run_id = NULL, revision = revision + 1, updated_at = datetime('now') WHERE schedule_id = ?12 AND revision = ?13`,
+      [name, target.node_id, target.alias, content, priority, parsed.spec.type, scheduleJson, parsed.timezone, requestedStatus, next ? iso(next) : null, misfirePolicy, row.schedule_id, row.revision, keepStoredNext, backoff ? 1 : 0, wakeJson, wakeJson ? requirementWakeHead(row.network_id) : 0],
     );
     if (updated.changes !== 1) throw new ScheduleInputError("revision_conflict", 409);
     return getScheduleRow(row.schedule_id)!;
@@ -373,11 +402,29 @@ export function dispatchScheduledOccurrence(row: ScheduledRow, scheduledFor: str
     // UNIQUE(schedule_id, scheduled_for) is the cross-process claim. If two
     // Hub processes race, one INSERT wins and the other transaction aborts.
     db.run(
-      `INSERT INTO scheduled_task_runs (run_id, schedule_id, network_id, scheduled_for, status)
-       VALUES (?1, ?2, ?3, ?4, 'claiming')`,
-      [runId, row.schedule_id, row.network_id, scheduledFor],
+      `INSERT INTO scheduled_task_runs (run_id, schedule_id, network_id, scheduled_for, status, schedule_revision)
+       VALUES (?1, ?2, ?3, ?4, 'claiming', ?5)`,
+      [runId, row.schedule_id, row.network_id, scheduledFor, row.revision],
     );
 
+    const current = getScheduleRow(row.schedule_id);
+    if (!current || current.revision !== row.revision || current.status === "cancelled"
+      || (advanceSchedule && current.status !== "active")) throw new Error("schedule_changed");
+    row = current;
+    // Manual dispatch is an explicit wake. Its new generation fences all
+    // already-running reports, while a paused schedule remains paused.
+    if (!advanceSchedule && row.no_change_backoff === 1) {
+      const base = JSON.parse(row.schedule_json).every_seconds;
+      db.run(`UPDATE scheduled_tasks SET revision = revision + 1, backoff_streak = 0,
+        backoff_effective_seconds = NULL, backoff_last_run_id = NULL,
+        requirement_wake_cursor = ?4, requirement_wake_last_event_id = NULL,
+        next_run_at = CASE WHEN status = 'active' THEN ?1 ELSE next_run_at END,
+        updated_at = datetime('now') WHERE schedule_id = ?2 AND revision = ?3`,
+        [new Date(advanceAfter.getTime() + base * 1000).toISOString(), row.schedule_id, row.revision, requirementWakeHead(row.network_id)]);
+      row = getScheduleRow(row.schedule_id)!;
+    }
+    db.run("UPDATE scheduled_task_runs SET schedule_revision = ?1 WHERE run_id = ?2", [row.revision, runId]);
+
     // Board #757 — do not create a task that will merely expire while its
     // exact target session is offline. This branch deliberately precedes the
     // overlap check: target_offline is the actionable reason for this round.
@@ -537,9 +584,12 @@ export function dispatchScheduledOccurrence(row: ScheduledRow, scheduledFor: str
       auth_origin: "hub_scheduler",
       ...(row.created_by_node_id ? { scheduled_by_node_id: row.created_by_node_id, scheduled_by_alias: creatorNode?.alias ?? null } : {}),
     });
-    const taskContent = row.created_by_node_id
+    const originalContent = row.created_by_node_id
       ? `${agentSchedulePrefix(creatorNode?.alias ?? null, row.created_by_node_id)}${row.task_content}`
       : row.task_content;
+    const taskContent = originalContent + (row.no_change_backoff === 1
+      && row.schedule_type === "interval" && row.overlap_policy === "skip"
+      && db.transactionalFeaturesRefusal === null ? scheduledOutcomeGuidance(taskId) : "");
     db.run(
       `INSERT INTO inbox (id, task_id, session_name, node_id, type, priority, content, from_session, requires_response, network_id, meta_json)
        VALUES (?1, ?1, ?2, ?3, 'task', ?4, ?5, 'scheduler', 'reply', ?6, ?7)`,
@@ -589,8 +639,12 @@ export function dispatchScheduledOccurrence(row: ScheduledRow, scheduledFor: str
 // a status change the user sees and it is what stops an in-flight PATCH (whose
 // UPDATE is guarded by `AND revision = ?`) from reviving a finished one-shot.
 function advance(row: ScheduledRow, scheduledFor: string, after = new Date(), recordLastRun = true): void {
+  refreshScheduledBackoff(row.schedule_id, row.network_id, after);
+  const stored = getScheduleRow(row.schedule_id)!;
   const spec = JSON.parse(row.schedule_json) as ScheduleSpec;
-  const next = nextOccurrence(spec, row.timezone, after);
+  const effective = spec.type === "interval" && stored.no_change_backoff === 1
+    ? { ...spec, every_seconds: Math.max(spec.every_seconds, stored.backoff_effective_seconds ?? spec.every_seconds) } : spec;
+  const next = nextOccurrence(effective, row.timezone, after);
   const lastRunAt = recordLastRun ? scheduledFor : row.last_run_at;
   if (spec.type === "once" || !next) {
     db.run(
@@ -615,9 +669,9 @@ function skipScheduledMisfire(row: ScheduledRow, scheduledFor: string, now: Date
   db.transaction(() => {
     db.run(
       `INSERT INTO scheduled_task_runs
-       (run_id, schedule_id, network_id, scheduled_for, status, error_code, error_message, completed_at)
-       VALUES (?1, ?2, ?3, ?4, 'skipped', 'misfire_skipped', 'The occurrence was overdue and the schedule is configured to skip missed runs', datetime('now'))`,
-      [runId, row.schedule_id, row.network_id, scheduledFor],
+       (run_id, schedule_id, network_id, scheduled_for, status, error_code, error_message, completed_at, schedule_revision)
+       VALUES (?1, ?2, ?3, ?4, 'skipped', 'misfire_skipped', 'The occurrence was overdue and the schedule is configured to skip missed runs', datetime('now'), ?5)`,
+      [runId, row.schedule_id, row.network_id, scheduledFor, row.revision],
     );
     // A skipped occurrence is auditable but is not an execution: preserve
     // last_run_at while moving the schedule directly to its next future slot.
@@ -626,6 +680,7 @@ function skipScheduledMisfire(row: ScheduledRow, scheduledFor: string, now: Date
 }
 
 export function runDueScheduledTasks(now = new Date(), limit = 100): { processed: number; failed: number } {
+  pollRequirementWakes(now);
   const due = db.all<ScheduledRow>(
     `SELECT ${SCHEDULED_TASK_STORAGE_SELECT} FROM scheduled_tasks WHERE status = 'active' AND next_run_at IS NOT NULL AND next_run_at <= ?1 ORDER BY next_run_at LIMIT ?2`,
     iso(now), limit,
@@ -754,7 +809,7 @@ export async function handleScheduledTaskRequest(ctx: ScheduledRequestContext):
     let body: Record<string, unknown>;
     try { body = await bodyObject(req); } catch { return jsonError("invalid_json", 400); }
     try {
-      return Response.json({ ok: true, schedule: decodeRow(patchSchedule(row, body)) });
+      return Response.json({ ok: true, schedule: decodeRow(patchSchedule(row, body, ctx.auth?.userId ?? null)) });
     } catch (e: any) {
       if (e instanceof ScheduleInputError) return jsonError(e.code, e.status, e.extra);
       throw e;