@sleep2agi/commhub-server 0.9.0-preview.66 → 0.9.0-preview.68

package/src/rest-explicit-columns-http.test.ts

@@ -31,7 +31,7 @@ const GOLDEN_RESPONSE_KEYS = {
   //    —— 理由见本文件顶部：从投影推导会让被删掉的列同时从响应和期望里消失，产生假绿。
   authMeNetwork: [
     "network_id", "network_name", "owner_id", "description", "settings",
-    "created_at", "updated_at", "visibility", "max_members", "member_role",
+    "created_at", "updated_at", "visibility", "max_members", "member_role", "agent_access",
   ],
   networkDetail: [
     "network_id", "network_name", "owner_id", "description", "settings",

package/src/restricted-files.ts

@@ -0,0 +1,73 @@
+// 多用户 Agent 权限 —— 受限成员与上传文件。
+// 文件按网络归属;受限成员(只看授权 Agent 的成员)在受限网络里不能凭 file_id 读网络里任意文件,
+// 也不能把自己看不见的 file_id 塞进发给授权 Agent 的任务(那等于借 Agent 的网络令牌去读)。
+import { existsSync, readFileSync } from "fs";
+import { db } from "./db.js";
+import { addOwnTrafficScope, type RestNetworkScope } from "./network-scope.js";
+import { FILE_ID_REGEX, indexEntryPath, validateIndexEntry } from "./uploads.js";
+
+/**
+ * 受限成员能不能看见这个文件:只认**对方(授权 Agent / 给他发私信的人)放进来**的附件 ——
+ *   user_inbox 里发给自己的私信附件;
+ *   授权 Agent 发给自己的任务 / inbox 行的 attachments;
+ *   自己发给授权 Agent 的任务上,Agent 回复写进的 reply_attachments。
+ * 自己随任务带出去的 attachments **不算**:否则把任意 file_id 塞进自己的任务就能「解锁」别人的文件。
+ */
+export function restrictedMemberSeesFile(userId: string, username: string, networkId: string, fileId: string): boolean {
+  if (!FILE_ID_REGEX.test(fileId)) return false;
+  const listed = (metaJson: string | null | undefined, key: "attachments" | "reply_attachments"): boolean => {
+    if (!metaJson) return false;
+    try {
+      const list = JSON.parse(metaJson)?.[key];
+      return Array.isArray(list) && list.some((a: any) => a && typeof a === "object" && a.file_id === fileId);
+    } catch { return false; }
+  };
+  // LIKE 只做预筛(file_id 只含 [A-Za-z0-9_-],`_` 转义后逐字匹配),真正的判定在 listed() 里按键解析。
+  const needle = `%"${fileId.replace(/_/g, "\\_")}"%`;
+  for (const row of db.all<{ meta_json: string | null }>(
+    "SELECT meta_json FROM user_inbox WHERE user_id = ?1 AND network_id = ?2 AND meta_json LIKE ?3 ESCAPE '\\' LIMIT 50",
+    userId, networkId, needle,
+  )) {
+    if (listed(row.meta_json, "attachments")) return true;
+  }
+  const scope: RestNetworkScope = { networkId, networkIds: null, agentRestriction: { userId, username, networkIds: [networkId] } };
+  const taskParams: unknown[] = [needle];
+  const taskSql = addOwnTrafficScope("SELECT from_name, to_name, meta_json FROM tasks WHERE meta_json LIKE ?1 ESCAPE '\\'", taskParams, scope, { from: "from_name", to: "to_name", fromNodeId: "from_node_id", toNodeId: "to_node_id" });
+  for (const row of db.all<{ from_name: string; to_name: string; meta_json: string | null }>(taskSql + " LIMIT 50", ...taskParams)) {
+    if (row.to_name === username && listed(row.meta_json, "attachments")) return true;
+    if (row.from_name === username && listed(row.meta_json, "reply_attachments")) return true;
+  }
+  const inboxParams: unknown[] = [needle];
+  const inboxSql = addOwnTrafficScope("SELECT session_name, meta_json FROM inbox WHERE meta_json LIKE ?1 ESCAPE '\\'", inboxParams, scope, { from: "from_session", to: "session_name" });
+  for (const row of db.all<{ session_name: string; meta_json: string | null }>(inboxSql + " LIMIT 50", ...inboxParams)) {
+    if (row.session_name === username && listed(row.meta_json, "attachments")) return true;
+  }
+  return false;
+}
+
+/** 受限成员能不能用这个文件(下载 / 当附件转给 Agent):自己传的,或 restrictedMemberSeesFile。 */
+export function restrictedMemberCanUseFile(userId: string, username: string, networkId: string, fileId: string): boolean {
+  if (!FILE_ID_REGEX.test(fileId)) return false;
+  const path = indexEntryPath(fileId);
+  if (!path || !existsSync(path)) return false;
+  let entry: any;
+  try { entry = JSON.parse(readFileSync(path, "utf8")); } catch { return false; }
+  if (!validateIndexEntry(entry) || entry.file_id !== fileId) return false;
+  if (entry.network_id !== networkId) return false;
+  if (entry.owner_id === userId) return true;
+  return restrictedMemberSeesFile(userId, username, networkId, fileId);
+}
+
+/**
+ * 受限成员发给 Agent 的任务 / 消息里的附件:每个 file_id 都必须是他自己能用的文件。
+ * 返回第一个不合格的 file_id(调用方回 403),全部合格返回 null。
+ */
+export function restrictedMemberAttachmentsDenied(userId: string, username: string, networkId: string, raw: unknown): string | null {
+  if (!Array.isArray(raw)) return null;
+  for (const item of raw) {
+    const fileId = item && typeof item === "object" ? (item as { file_id?: unknown }).file_id : undefined;
+    if (fileId === undefined) continue;
+    if (typeof fileId !== "string" || !restrictedMemberCanUseFile(userId, username, networkId, fileId)) return String(fileId);
+  }
+  return null;
+}

package/src/scheduled-doorbell-nodeless-session.test.ts

@@ -0,0 +1,130 @@
+import { afterAll, beforeEach, describe, expect, test } from "bun:test";
+import { db } from "./db.js";
+import { createSSEStream } from "./push.js";
+import { dispatchScheduledOccurrence } from "./scheduled-tasks.js";
+
+// A claude-code node's channel server reports status without node_id, so its
+// sessions row has node_id NULL. The scheduler used to look the session up by
+// node_id only, judged every occurrence "queued" and never rang the doorbell:
+// the task sat in the inbox until an unrelated push drained it (20–36 min in
+// production).
+
+const NET = "net_sched_doorbell_nodeless";
+const NODE = "n_sched_doorbell_cc";
+const ALIAS = "sched-doorbell-cc";
+
+function cleanup(): void {
+  for (const table of ["task_events", "inbox", "scheduled_task_runs", "scheduled_tasks", "tasks", "sessions", "nodes"]) {
+    try { db.run(`DELETE FROM ${table} WHERE network_id = ?1`, [NET]); } catch {}
+  }
+}
+
+function seedNode(): void {
+  db.run(
+    `INSERT INTO nodes (node_id, node_name, alias, runtime, network_id, lifecycle_state)
+     VALUES (?1, ?2, ?2, 'claude-code-cli', ?3, 'active')`,
+    [NODE, ALIAS, NET],
+  );
+}
+
+function seedSession(status: string, nodeId: string | null): void {
+  db.run(
+    `INSERT INTO sessions (resume_id, alias, status, node_id, network_id, agent, updated_at, last_seen_at)
+     VALUES (?1, ?2, ?3, ?4, ?5, 'claude-code', datetime('now'), datetime('now'))`,
+    [`cc-${crypto.randomUUID()}`, ALIAS, status, nodeId, NET],
+  );
+}
+
+function seedSchedule(): any {
+  const scheduleId = `sched_${crypto.randomUUID()}`;
+  db.run(
+    `INSERT INTO scheduled_tasks
+       (schedule_id, network_id, name, target_node_id, target_alias, task_content, priority,
+        schedule_type, schedule_json, timezone, status, next_run_at)
+     VALUES (?1, ?2, 'doorbell', ?3, ?4, 'scheduled doorbell task', 'normal', 'interval',
+             '{"type":"interval","every_seconds":3600}', 'UTC', 'active', datetime('now', '+1 hour'))`,
+    [scheduleId, NET, NODE, ALIAS],
+  );
+  return db.get("SELECT * FROM scheduled_tasks WHERE schedule_id = ?1", scheduleId);
+}
+
+/** Subscribe like the channel server does and collect decoded SSE frames. */
+function subscribe(): { frames: any[]; close: () => Promise<void> } {
+  const res = createSSEStream(ALIAS, NET);
+  const reader = res.body!.getReader();
+  const decoder = new TextDecoder();
+  const frames: any[] = [];
+  let buffer = "";
+  let open = true;
+  (async () => {
+    while (open) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      const blocks = buffer.split("\n\n");
+      buffer = blocks.pop() || "";
+      for (const block of blocks) {
+        const line = block.split("\n").find((l) => l.startsWith("data: "));
+        if (line) frames.push(JSON.parse(line.slice(6)));
+      }
+    }
+  })().catch(() => {});
+  return {
+    frames,
+    close: async () => {
+      open = false;
+      await reader.cancel().catch(() => {});
+    },
+  };
+}
+
+async function settle(): Promise<void> {
+  await new Promise((resolve) => setTimeout(resolve, 20));
+}
+
+beforeEach(() => {
+  cleanup();
+  seedNode();
+});
+
+afterAll(cleanup);
+
+describe("scheduler doorbell for sessions reported without node_id", () => {
+  test("idle node_id-less session is delivered and its subscriber receives new_task", async () => {
+    seedSession("idle", null);
+    const sub = subscribe();
+    try {
+      await settle();
+      const result = dispatchScheduledOccurrence(seedSchedule(), new Date().toISOString(), false);
+      await settle();
+      expect(result.status).toBe("delivered");
+      expect(db.get<{ status: string }>("SELECT status FROM scheduled_task_runs WHERE run_id = ?1", result.runId)?.status).toBe("delivered");
+      const wake = sub.frames.filter((f) => f.type === "new_task");
+      expect(wake).toHaveLength(1);
+      expect(wake[0].from).toBe("scheduler");
+      expect(wake[0].inbox_count).toBe(1);
+    } finally {
+      await sub.close();
+    }
+  });
+
+  test("a live subscriber counts even when the session row says offline", async () => {
+    seedSession("offline", null);
+    const sub = subscribe();
+    try {
+      await settle();
+      const result = dispatchScheduledOccurrence(seedSchedule(), new Date().toISOString(), false);
+      await settle();
+      expect(result.status).toBe("delivered");
+      expect(sub.frames.filter((f) => f.type === "new_task")).toHaveLength(1);
+    } finally {
+      await sub.close();
+    }
+  });
+
+  test("offline session with nobody listening stays queued", () => {
+    seedSession("offline", null);
+    const result = dispatchScheduledOccurrence(seedSchedule(), new Date().toISOString(), false);
+    expect(result.status).toBe("queued");
+  });
+});

package/src/scheduled-skip-blocking-task.test.ts

@@ -0,0 +1,120 @@
+import { afterAll, beforeEach, describe, expect, test } from "bun:test";
+import { db } from "./db.js";
+import { dispatchScheduledOccurrence, handleScheduledTaskRequest } from "./scheduled-tasks.js";
+
+// A skip used to record only error_code=previous_run_active. The owner saw
+// dozens of identical 「已跳过」 rows while the node sat idle, because the
+// open task had never reached it. The skip record now names the blocking task
+// and whether the node had picked it up.
+
+const NET = "net_sched_skip_blocking";
+const NODE = "n_sched_skip_blocking";
+const ALIAS = "sched-skip-blocking";
+
+function cleanup(): void {
+  for (const table of ["task_events", "inbox", "scheduled_task_runs", "scheduled_tasks", "tasks", "sessions", "nodes"]) {
+    try { db.run(`DELETE FROM ${table} WHERE network_id = ?1`, [NET]); } catch {}
+  }
+}
+
+function seedSchedule(): any {
+  const scheduleId = `sched_${crypto.randomUUID()}`;
+  db.run(
+    `INSERT INTO scheduled_tasks
+       (schedule_id, network_id, name, target_node_id, target_alias, task_content, priority,
+        schedule_type, schedule_json, timezone, status, next_run_at)
+     VALUES (?1, ?2, 'skip detail', ?3, ?4, 'scheduled task', 'normal', 'interval',
+             '{"type":"interval","every_seconds":60}', 'UTC', 'active', datetime('now', '+1 minute'))`,
+    [scheduleId, NET, NODE, ALIAS],
+  );
+  return db.get("SELECT * FROM scheduled_tasks WHERE schedule_id = ?1", scheduleId);
+}
+
+function run(runId: string): any {
+  return db.get(
+    "SELECT status, error_code, error_message, blocked_by_task_id, blocked_by_state FROM scheduled_task_runs WHERE run_id = ?1",
+    runId,
+  );
+}
+
+beforeEach(() => {
+  cleanup();
+  db.run(
+    `INSERT INTO nodes (node_id, node_name, alias, runtime, network_id, lifecycle_state)
+     VALUES (?1, ?2, ?2, 'codex-sdk', ?3, 'active')`,
+    [NODE, ALIAS, NET],
+  );
+  db.run(
+    `INSERT INTO sessions (resume_id, alias, status, node_id, network_id, updated_at, last_seen_at)
+     VALUES (?1, ?2, 'idle', ?3, ?4, datetime('now'), datetime('now'))`,
+    [`r_${crypto.randomUUID()}`, ALIAS, NODE, NET],
+  );
+});
+
+afterAll(cleanup);
+
+describe("skipped run names the task that blocked it", () => {
+  test("open task still unacked in the inbox → not_received", () => {
+    const schedule = seedSchedule();
+    const first = dispatchScheduledOccurrence(schedule, "2026-09-29T08:00:00.000Z", false);
+    expect(first.status).toBe("delivered");
+
+    const second = dispatchScheduledOccurrence(schedule, "2026-09-29T08:01:00.000Z", false);
+    expect(second.status).toBe("skipped");
+    const row = run(second.runId);
+    expect(row.error_code).toBe("previous_run_active");
+    expect(row.blocked_by_task_id).toBe(first.taskId);
+    expect(row.blocked_by_state).toBe("not_received");
+    expect(row.error_message).toContain(first.taskId!);
+    expect(row.error_message).toContain("not been received");
+  });
+
+  test("open task whose inbox row the node acked → in_progress", () => {
+    const schedule = seedSchedule();
+    const first = dispatchScheduledOccurrence(schedule, "2026-09-29T09:00:00.000Z", false);
+    db.run("UPDATE inbox SET acked = 1 WHERE task_id = ?1", [first.taskId]);
+
+    const second = dispatchScheduledOccurrence(schedule, "2026-09-29T09:01:00.000Z", false);
+    expect(second.status).toBe("skipped");
+    const row = run(second.runId);
+    expect(row.blocked_by_task_id).toBe(first.taskId);
+    expect(row.blocked_by_state).toBe("in_progress");
+    expect(row.error_message).toContain("still in progress");
+  });
+
+  test("task status running counts as received even without an acked inbox row", () => {
+    const schedule = seedSchedule();
+    const first = dispatchScheduledOccurrence(schedule, "2026-09-29T10:00:00.000Z", false);
+    db.run("UPDATE tasks SET status = 'running' WHERE task_id = ?1", [first.taskId]);
+
+    const second = dispatchScheduledOccurrence(schedule, "2026-09-29T10:01:00.000Z", false);
+    expect(run(second.runId).blocked_by_state).toBe("in_progress");
+  });
+
+  test("GET /runs exposes the blocking task and state", async () => {
+    const schedule = seedSchedule();
+    const first = dispatchScheduledOccurrence(schedule, "2026-09-29T12:00:00.000Z", false);
+    const second = dispatchScheduledOccurrence(schedule, "2026-09-29T12:01:00.000Z", false);
+    const url = new URL(`http://hub.test/api/scheduled-tasks/${schedule.schedule_id}/runs`);
+    const res = await handleScheduledTaskRequest({
+      req: new Request(url, { method: "GET" }),
+      url,
+      auth: { userId: "u_skip_detail", networkId: NET, username: "skip-detail" },
+      isAdmin: false,
+      isNodeToken: false,
+      scope: { networkId: NET, networkIds: [NET] },
+    });
+    const body = await res!.json() as any;
+    const skipped = body.runs.find((r: any) => r.run_id === second.runId);
+    expect(skipped.blocked_by_task_id).toBe(first.taskId);
+    expect(skipped.blocked_by_state).toBe("not_received");
+  });
+
+  test("a delivered run carries no blocking fields", () => {
+    const schedule = seedSchedule();
+    const first = dispatchScheduledOccurrence(schedule, "2026-09-29T11:00:00.000Z", false);
+    const row = run(first.runId);
+    expect(row.blocked_by_task_id).toBeNull();
+    expect(row.blocked_by_state).toBeNull();
+  });
+});

package/src/scheduled-tasks-http.test.ts

@@ -41,7 +41,8 @@ beforeAll(async () => {
   expect(viewer.ok).toBe(true);
   viewerToken = viewer.token!;
   const viewerId = db.get<{ user_id: string }>("SELECT user_id FROM users WHERE username = ?1", viewer.user!.username)!.user_id;
-  addNetworkMember(networkId, viewerId, "viewer", ownerId);
+  // 多用户 Agent 权限:新成员默认只看授权 Agent;本测试测的是「完全信任的成员」旧语义,显式 agent_access=all。
+  addNetworkMember(networkId, viewerId, "viewer", ownerId, { agentAccess: "all" });
   const ntok = createNetworkTokenForNode(ownerId, networkId, "scheduler-node");
   expect(ntok.ok).toBe(true);
   nodeToken = ntok.token!;
@@ -431,6 +432,96 @@ describe("Hub scheduled task API and dispatcher", () => {
     expect(["Concurrent editor A", "Concurrent editor B"]).toContain(latest.name);
   });
 
+  // Owner report 2026-09-29: editing a 2-minute schedule failed with
+  // revision_conflict whenever a run landed while the dialog was open, and the
+  // client dropped the draft. Runs are bookkeeping, not edits.
+  test("a scheduler run between GET and PATCH does not conflict with the edit", async () => {
+    const created = await api(ownerToken, "/api/scheduled-tasks", {
+      method: "POST",
+      body: JSON.stringify({ network_id: networkId, name: "Run-during-edit", target_node_id: nodeId, task: "before edit", timezone: "Asia/Shanghai", schedule: { type: "interval", every_seconds: 120 } }),
+    });
+    expect(created.status).toBe(201);
+    const id = created.body.schedule.schedule_id;
+    const path = `/api/scheduled-tasks/${id}?network_id=${encodeURIComponent(networkId)}`;
+    const opened = (await api(ownerToken, path)).body.schedule;
+
+    const firedAt = new Date(Date.now() - 1_000).toISOString();
+    db.run("UPDATE scheduled_tasks SET next_run_at = ?1 WHERE schedule_id = ?2", [firedAt, id]);
+    runDueScheduledTasks();
+    const afterRun = (await api(ownerToken, path)).body.schedule;
+    expect(db.get<{ n: number }>("SELECT COUNT(*) AS n FROM scheduled_task_runs WHERE schedule_id = ?1", id)!.n).toBe(1);
+    expect(afterRun.last_run_at).toBe(firedAt);
+    expect(new Date(afterRun.next_run_at).getTime()).toBeGreaterThan(Date.now());
+    expect(afterRun.revision).toBe(opened.revision);
+
+    const saved = await api(ownerToken, path, {
+      method: "PATCH",
+      body: JSON.stringify({ revision: opened.revision, task: "edited while it ran", name: opened.name, schedule: opened.schedule, timezone: opened.timezone }),
+    });
+    expect(saved.status).toBe(200);
+    expect(saved.body.schedule.task_content).toBe("edited while it ran");
+    expect(saved.body.schedule.revision).toBe(opened.revision + 1);
+    // Cadence edit-preservation must keep the scheduler's advanced slot, not
+    // resurrect the occurrence that already fired.
+    expect(saved.body.schedule.next_run_at).toBe(afterRun.next_run_at);
+
+    // A second device still holding the pre-edit revision is a true conflict.
+    const stale = await api(ownerToken, path, { method: "PATCH", body: JSON.stringify({ revision: opened.revision, task: "other device" }) });
+    expect(stale.status).toBe(409);
+    expect(stale.body.error).toBe("revision_conflict");
+    await api(ownerToken, `/api/scheduled-tasks/${id}/cancel?network_id=${encodeURIComponent(networkId)}`, { method: "POST", body: "{}" });
+  });
+
+  test("a run that lands while the PATCH body is in flight keeps the advanced next_run_at", async () => {
+    const created = await api(ownerToken, "/api/scheduled-tasks", {
+      method: "POST",
+      body: JSON.stringify({ network_id: networkId, name: "Run-during-body", target_node_id: nodeId, task: "before", timezone: "Asia/Shanghai", schedule: { type: "interval", every_seconds: 120 } }),
+    });
+    const id = created.body.schedule.schedule_id;
+    const path = `/api/scheduled-tasks/${id}?network_id=${encodeURIComponent(networkId)}`;
+    const firedAt = new Date(Date.now() - 1_000).toISOString();
+    db.run("UPDATE scheduled_tasks SET next_run_at = ?1 WHERE schedule_id = ?2", [firedAt, id]);
+    const opened = (await api(ownerToken, path)).body.schedule;
+
+    // The handler reads the row before awaiting the body. Hold the body open,
+    // run the scheduler, then release it — the PATCH now carries a stale
+    // row.next_run_at (the slot that just fired).
+    let release!: () => void;
+    const gate = new Promise<void>((r) => { release = r; });
+    const payload = new TextEncoder().encode(JSON.stringify({ revision: opened.revision, task: "edited mid-run" }));
+    const body = new ReadableStream({ async pull(c) { await gate; c.enqueue(payload); c.close(); } });
+    const pending = fetch(`${base}${path}`, { method: "PATCH", body, duplex: "half", headers: { Authorization: `Bearer ${ownerToken}`, "Content-Type": "application/json" } } as any);
+    await new Promise((r) => setTimeout(r, 100));
+    runDueScheduledTasks();
+    const advanced = db.get<{ next_run_at: string }>("SELECT next_run_at FROM scheduled_tasks WHERE schedule_id = ?1", id)!.next_run_at;
+    expect(advanced).not.toBe(firedAt);
+    release();
+    const res = await pending;
+    const saved = await res.json() as any;
+    expect(res.status).toBe(200);
+    expect(saved.schedule.task_content).toBe("edited mid-run");
+    expect(saved.schedule.next_run_at).toBe(advanced);
+    await api(ownerToken, `/api/scheduled-tasks/${id}/cancel?network_id=${encodeURIComponent(networkId)}`, { method: "POST", body: "{}" });
+  });
+
+  test("one-shot auto-complete is a user-visible status change and still bumps revision", async () => {
+    const created = await api(ownerToken, "/api/scheduled-tasks", {
+      method: "POST",
+      body: JSON.stringify({ network_id: networkId, name: "One-shot", target_node_id: nodeId, task: "once", timezone: "Asia/Shanghai", schedule: { type: "once", run_at: new Date(Date.now() + 3_600_000).toISOString() } }),
+    });
+    const id = created.body.schedule.schedule_id;
+    const path = `/api/scheduled-tasks/${id}?network_id=${encodeURIComponent(networkId)}`;
+    const opened = (await api(ownerToken, path)).body.schedule;
+    db.run("UPDATE scheduled_tasks SET next_run_at = ?1 WHERE schedule_id = ?2", [new Date(Date.now() - 1_000).toISOString(), id]);
+    runDueScheduledTasks();
+    const done = (await api(ownerToken, path)).body.schedule;
+    expect(done.status).toBe("completed");
+    expect(done.revision).toBe(opened.revision + 1);
+    const edit = await api(ownerToken, path, { method: "PATCH", body: JSON.stringify({ revision: opened.revision, task: "too late" }) });
+    expect(edit.status).toBe(409);
+    expect(edit.body.error).toBe("schedule_completed");
+  });
+
   test("optimistic revision, pause/resume, run-now and cancel preserve history", async () => {
     const latest = await api(ownerToken, `/api/scheduled-tasks/${scheduleId}?network_id=${encodeURIComponent(networkId)}`);
     revision = latest.body.schedule.revision;

package/src/scheduled-tasks.ts

@@ -1,7 +1,8 @@
 import { db, logTaskEvent } from "./db.js";
 import { assertNodeActive } from "./lifecycle-guard.js";
 import { addNetworkScope, canRestWriteNetwork, singleNetworkId, type RestNetworkScope } from "./network-scope.js";
-import { pushEvent, pushNetworkObserverEvent } from "./push.js";
+import { canMessageAgent } from "./agent-access.js";
+import { hasSubscribers, pushEvent, pushNetworkObserverEvent } from "./push.js";
 import { SCHEDULED_TASK_STORAGE_SELECT } from "./rest-projections.js";
 
 export type ScheduleSpec =
@@ -219,8 +220,15 @@ export function dispatchScheduledOccurrence(row: ScheduledRow, scheduledFor: str
 
     if (row.overlap_policy === "skip") {
       const placeholders = OPEN_TASK_STATUSES.map((_, i) => `?${i + 2}`).join(", ");
-      const open = db.get<{ task_id: string }>(
-        `SELECT r.task_id FROM scheduled_task_runs r
+      // received:节点那边有没有把这条任务取走过(inbox 行被 ack,或任务已进 acked/running)。
+      // 跳过记录带上它,客户端才分得清「节点还没收到」和「节点在处理」—— 前者是投递故障,
+      // 后者才是真的上一次还没做完。
+      const open = db.get<{ task_id: string; received: number }>(
+        `SELECT r.task_id,
+                CASE WHEN t.status IN ('acked', 'running')
+                       OR EXISTS (SELECT 1 FROM inbox i WHERE (i.task_id = r.task_id OR i.id = r.task_id) AND i.acked = 1)
+                     THEN 1 ELSE 0 END AS received
+         FROM scheduled_task_runs r
          JOIN tasks t ON t.task_id = r.task_id
          WHERE r.schedule_id = ?1 AND t.status IN (${placeholders})
          ORDER BY r.created_at DESC LIMIT 1`,
@@ -228,9 +236,18 @@ export function dispatchScheduledOccurrence(row: ScheduledRow, scheduledFor: str
       );
       if (open) {
         finalStatus = "skipped";
+        const blockedState = open.received ? "in_progress" : "not_received";
         db.run(
-          "UPDATE scheduled_task_runs SET status = 'skipped', error_code = 'previous_run_active', completed_at = datetime('now') WHERE run_id = ?1",
-          [runId],
+          `UPDATE scheduled_task_runs SET status = 'skipped', error_code = 'previous_run_active', error_message = ?2,
+             blocked_by_task_id = ?3, blocked_by_state = ?4, completed_at = datetime('now') WHERE run_id = ?1`,
+          [
+            runId,
+            blockedState === "not_received"
+              ? `previous run task ${open.task_id} has not been received by the node yet`
+              : `previous run task ${open.task_id} is still in progress on the node`,
+            open.task_id,
+            blockedState,
+          ],
         );
         if (advanceSchedule) advance(row, scheduledFor, advanceAfter);
         return;
@@ -250,6 +267,17 @@ export function dispatchScheduledOccurrence(row: ScheduledRow, scheduledFor: str
       if (advanceSchedule) advance(row, scheduledFor, advanceAfter);
       return;
     }
+    // 多用户 Agent 权限:排程是「建它的人」的委托。建的人后来被设成受限成员、而且没被授权
+    // 给目标 Agent 发任务时,不再代他派发(否则受限前建的排程会永远绕过授权)。
+    if (row.created_by && !canMessageAgent(row.created_by, row.network_id, { alias: node.alias, nodeId: node.node_id })) {
+      finalStatus = "failed";
+      db.run(
+        "UPDATE scheduled_task_runs SET status = 'failed', error_code = 'creator_access_revoked', error_message = 'The schedule creator is no longer allowed to message this agent', completed_at = datetime('now') WHERE run_id = ?1",
+        [runId],
+      );
+      if (advanceSchedule) advance(row, scheduledFor, advanceAfter);
+      return;
+    }
     const lifecycle = assertNodeActive(node.alias, row.network_id);
     if (!lifecycle.ok) {
       finalStatus = "failed";
@@ -262,11 +290,19 @@ export function dispatchScheduledOccurrence(row: ScheduledRow, scheduledFor: str
     }
 
     const taskId = crypto.randomUUID();
+    // claude-code 裸节点的 node-server 上报 report_status 不带 node_id,它的 sessions 行
+    // node_id 永远是 NULL —— 只按 node_id 找会话,这类节点每一次都判成 queued、门铃不响,
+    // 任务在 inbox 里等到别的消息顺带捎进去(生产上 20–36 分钟)。按 node_id 找不到时退回
+    // 同网同别名、node_id 为空的会话;SSE 订阅者注册表是「有没有人在听」的实测,也算数。
     const session = db.get<{ status: string | null }>(
       "SELECT status FROM sessions WHERE node_id = ?1 AND network_id = ?2 ORDER BY updated_at DESC LIMIT 1",
       row.target_node_id, row.network_id,
+    ) ?? db.get<{ status: string | null }>(
+      "SELECT status FROM sessions WHERE alias = ?1 AND network_id = ?2 AND node_id IS NULL ORDER BY updated_at DESC LIMIT 1",
+      node.alias, row.network_id,
     );
-    const deliveryState: "delivered" | "queued" = session && session.status !== "offline" ? "delivered" : "queued";
+    const deliveryState: "delivered" | "queued" =
+      (session && session.status !== "offline") || hasSubscribers(node.alias, row.network_id) ? "delivered" : "queued";
     const metaJson = JSON.stringify({
       scheduled_task_id: row.schedule_id,
       scheduled_run_id: runId,
@@ -310,6 +346,12 @@ export function dispatchScheduledOccurrence(row: ScheduledRow, scheduledFor: str
   return { runId, taskId: createdTaskId, status: finalStatus, event };
 }
 
+// `revision` is the optimistic-concurrency token for *user edits*. Run
+// bookkeeping (next_run_at/last_run_at) must not bump it: a 2-minute schedule
+// would otherwise turn every edit that spans a run into a 409 and the client
+// would drop the user's draft. Terminal completion still bumps, because it is
+// 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 {
   const spec = JSON.parse(row.schedule_json) as ScheduleSpec;
   const next = nextOccurrence(spec, row.timezone, after);
@@ -321,7 +363,7 @@ function advance(row: ScheduledRow, scheduledFor: string, after = new Date(), re
     );
   } else {
     db.run(
-      "UPDATE scheduled_tasks SET next_run_at = ?1, last_run_at = ?2, revision = revision + 1, updated_at = datetime('now') WHERE schedule_id = ?3",
+      "UPDATE scheduled_tasks SET next_run_at = ?1, last_run_at = ?2, updated_at = datetime('now') WHERE schedule_id = ?3",
       [iso(next), lastRunAt, row.schedule_id],
     );
   }
@@ -461,7 +503,7 @@ export async function handleScheduledTaskRequest(ctx: ScheduledRequestContext):
   if (sub === "runs" && req.method === "GET") {
     const limit = Math.max(1, Math.min(200, Number(url.searchParams.get("limit")) || 50));
     const runs = db.all(
-      "SELECT run_id, schedule_id, scheduled_for, task_id, status, error_code, error_message, created_at, completed_at FROM scheduled_task_runs WHERE schedule_id = ?1 AND network_id = ?2 ORDER BY created_at DESC LIMIT ?3",
+      "SELECT run_id, schedule_id, scheduled_for, task_id, status, error_code, error_message, blocked_by_task_id, blocked_by_state, created_at, completed_at FROM scheduled_task_runs WHERE schedule_id = ?1 AND network_id = ?2 ORDER BY created_at DESC LIMIT ?3",
       row.schedule_id, row.network_id, limit,
     );
     return Response.json({ ok: true, runs });
@@ -532,11 +574,16 @@ export async function handleScheduledTaskRequest(ctx: ScheduledRequestContext):
           ? 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 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 = ?10,
+         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],
+        [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],
       );
       if (updated.changes !== 1) return jsonError("revision_conflict", 409);
       return Response.json({ ok: true, schedule: decodeRow(db.get<ScheduledRow>(`SELECT ${SCHEDULED_TASK_STORAGE_SELECT} FROM scheduled_tasks WHERE schedule_id = ?1`, row.schedule_id)!) });