@sleep2agi/commhub-server 0.9.0-preview.114 → 0.9.0-preview.116

package/src/node-alias-control.ts

@@ -0,0 +1,12 @@
+// C0/C1 controls plus Unicode's two dedicated line separators. The latter are
+// not General_Category=Cc, but they still split log/source-prefix lines.
+const CONTROL_CHARACTER = /[\p{Cc}\u2028\u2029]/u;
+
+export function aliasControlCharacter(alias: string): string | null {
+  return [...alias].find((char) => CONTROL_CHARACTER.test(char)) ?? null;
+}
+
+export function describeAliasControlCharacter(char: string): string {
+  const codePoint = char.codePointAt(0) ?? 0;
+  return `U+${codePoint.toString(16).toUpperCase().padStart(4, "0")}`;
+}

package/src/node-token-privilege-http.test.ts

@@ -129,6 +129,15 @@ describe("account and network management need a user token", () => {
     expect(mine.body.ok).toBe(true);
     expect((await call(ntok, "POST", "/api/node-rename/abort", { txn_id: mine.body.txn_id })).body.ok).toBe(true);
   });
+  test("rename rejects line breaks, tabs and other control characters before reserving an alias", async () => {
+    for (const newAlias of ["hidden\nnode", "hidden\tnode", "hidden\u001fnode", "hidden\u007fnode", "hidden\u2028node", "hidden\u2029node"]) {
+      const r = await call(ntok, "POST", "/api/node-rename/prepare", { network_id: NET, old_alias: "ntok-node", new_alias: newAlias });
+      expect(r.status).toBe(400);
+      expect(r.body).toMatchObject({ ok: false, error: "node_alias_invalid", code: "node_alias_invalid", reason: "control_character" });
+      expect(r.body.message).toContain("control character U+");
+    }
+    expect(db.get<{ n: number }>("SELECT COUNT(*) AS n FROM rename_txn WHERE network_id = ?1 AND status = 'prepared'", NET)?.n).toBe(0);
+  });
 });
 
 describe("/api/auth/me says what the credential is", () => {

package/src/rename.ts

@@ -18,6 +18,7 @@ import { getUserNetworkRole, getNetworkMembers } from "./auth";
 import { canSeeAgent, isAgentRestricted } from "./agent-access";
 import { pushEvent } from "./push";
 import { eventBus } from "./event_bus";
+import { aliasControlCharacter, describeAliasControlCharacter } from "./node-alias-control";
 
 export interface RenameResult {
   ok: boolean;
@@ -25,6 +26,9 @@ export interface RenameResult {
   error?: string;
   code?: string;
   suggested?: string;
+  reason?: string;
+  char?: string;
+  message?: string;
 }
 
 export interface CanonicalAlias {
@@ -111,6 +115,17 @@ export function prepareRename(
 ): RenameResult {
   if (!hasWriteAccess(userId, networkId)) return { ok: false, error: "no write access to this network" };
   if (!oldAlias || !newAlias) return { ok: false, error: "old and new alias required" };
+  const control = aliasControlCharacter(newAlias);
+  if (control !== null) {
+    return {
+      ok: false,
+      code: "node_alias_invalid",
+      error: "node_alias_invalid",
+      reason: "control_character",
+      char: control,
+      message: `alias cannot contain control character ${describeAliasControlCharacter(control)}`,
+    };
+  }
   if (oldAlias === newAlias) return { ok: false, error: "old and new alias are identical" };
 
   // old-alias must exist as a session in this network

package/src/requirements-comment-http.test.ts

@@ -58,6 +58,8 @@ beforeAll(async () => {
   const mk = async (username: string, role: string) => {
     expect((await rest(U.owner.token, "POST", "/api/admin/users", { username, password: PW, network_id: NET, role })).status).toBe(200);
     const login = await rest("", "POST", "/api/auth/login", { username, password: PW });
+    // #746 起新成员默认 scoped;这里的 member / viewer 模拟老成员('all'),scoped 那位下面再收窄。
+    expect((await rest(U.owner.token, "PUT", `/api/networks/${NET}/members/${login.body.user.user_id}/task-grants`, { task_access: "all" })).status).toBe(200);
     return { token: login.body.token as string, id: login.body.user.user_id as string };
   };
   const stamp = Date.now();

package/src/requirements-stats-http.test.ts

@@ -78,7 +78,7 @@ beforeAll(async () => {
   const stamp = Date.now();
   alice = await mk(`rs_alice_${stamp}`);
   carol = await mk(`rs_carol_${stamp}`);
-  // 新成员默认值 NEW_MEMBER_TASK_ACCESS 暂时是 'all',alice 要显式设成 scoped。
+  // #746 起新成员默认就是 scoped;这里仍显式设一次,不依赖默认值。
   expect((await send(admin.token, "PUT", `/api/networks/${NET}/members/${alice.id}/task-grants`, { task_access: "scoped" })).status).toBe(200);
   db.run("UPDATE network_members SET task_access = 'all' WHERE network_id = ?1 AND user_id = ?2", [NET, carol.id]);
 

package/src/requirements-status-participants-http.test.ts

@@ -59,6 +59,8 @@ beforeAll(async () => {
   expect((await rest(U.owner.token, "POST", "/api/admin/users", { username, password: PW, network_id: NET, role: "member" })).status).toBe(200);
   const login = await rest("", "POST", "/api/auth/login", { username, password: PW });
   U.member = { token: login.body.token, id: login.body.user.user_id };
+  // #746 起新成员默认 scoped;这里测的是 'all' 成员的 REST 键,显式放宽。
+  expect((await rest(U.owner.token, "PUT", `/api/networks/${NET}/members/${U.member.id}/task-grants`, { task_access: "all" })).status).toBe(200);
   for (const [k, alias] of [["nodeA", "示例-甲"], ["nodeB", "示例-乙"], ["nodeC", "示例-丙"]] as const) {
     const nodeId = `node_sp_${k}`;
     U[k] = { token: createNetworkTokenForNode(U.owner.id, NET, alias, nodeId).token!, id: nodeId };

package/src/schedule-agent-mcp-http.test.ts

@@ -108,6 +108,24 @@ describe("happy path from a node", () => {
     expect((await mcp(node.a.token, "schedule_run_now", { schedule_id: s.schedule_id })).error).toBe("schedule_cancelled");
   });
 
+  test("base_revision prevents a stale Agent update; omitting it keeps legacy last-write behavior", async () => {
+    const made = (await create("a")).schedule;
+    const baseRevision = made.revision;
+    const first = await mcp(node.a.token, "schedule_update", {
+      schedule_id: made.schedule_id, base_revision: baseRevision, name: "first writer",
+    });
+    expect(first).toMatchObject({ ok: true, schedule: { name: "first writer", revision: baseRevision + 1 } });
+
+    const stale = await mcp(node.a.token, "schedule_update", {
+      schedule_id: made.schedule_id, base_revision: baseRevision, name: "stale writer",
+    });
+    expect(stale).toEqual({ ok: false, error: "revision_conflict", current_revision: baseRevision + 1 });
+    expect((await mcp(node.a.token, "schedule_get", { schedule_id: made.schedule_id })).schedule.name).toBe("first writer");
+
+    const legacy = await mcp(node.a.token, "schedule_update", { schedule_id: made.schedule_id, name: "legacy writer" });
+    expect(legacy).toMatchObject({ ok: true, schedule: { name: "legacy writer", revision: baseRevision + 2 } });
+  });
+
   test("a schedule for another node the caller can send_task to; the target can read it but not change it", async () => {
     const c = await create("a", { target_node_id: node.b.id });
     expect(c.ok).toBe(true);

package/src/schedule-agent.ts

@@ -126,6 +126,9 @@ export function agentUpdateSchedule(id: NodeIdentity, canWrite: boolean, schedul
   if (gate) return gate;
   const row = ownRow(id, scheduleId);
   if (!isRow(row)) return row;
+  if (body.base_revision !== undefined && Number(body.base_revision) !== row.revision) {
+    return fail("revision_conflict", { current_revision: row.revision });
+  }
   const retarget = body.target_node_id !== undefined && body.target_node_id !== row.target_node_id;
   let target = { node_id: row.target_node_id, alias: row.target_alias };
   if (retarget) {

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

@@ -108,23 +108,27 @@ describe("scheduler doorbell for sessions reported without node_id", () => {
     }
   });
 
-  test("a live subscriber counts even when the session row says offline", async () => {
+  test("an offline session is skipped even if a stale subscriber is still connected", 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);
+      expect(result.status).toBe("skipped");
+      expect(db.get<{ error_code: string; task_id: string | null }>("SELECT error_code, task_id FROM scheduled_task_runs WHERE run_id = ?1", result.runId))
+        .toEqual({ error_code: "target_offline", task_id: null });
+      expect(sub.frames.filter((f) => f.type === "new_task")).toHaveLength(0);
     } finally {
       await sub.close();
     }
   });
 
-  test("offline session with nobody listening stays queued", () => {
+  test("offline session with nobody listening is skipped without a task", () => {
     seedSession("offline", null);
     const result = dispatchScheduledOccurrence(seedSchedule(), new Date().toISOString(), false);
-    expect(result.status).toBe("queued");
+    expect(result.status).toBe("skipped");
+    expect(db.get<{ error_code: string; task_id: string | null }>("SELECT error_code, task_id FROM scheduled_task_runs WHERE run_id = ?1", result.runId))
+      .toEqual({ error_code: "target_offline", task_id: null });
   });
 });

package/src/scheduled-offline.test.ts

@@ -0,0 +1,131 @@
+// Board #757 — an offline scheduled target produces an auditable skip, not a
+// doomed task; each offline episode warns its human/Agent creator once.
+// Run: COMMHUB_DB=/tmp/board757.db bun test src/scheduled-offline.test.ts
+// PG: registered in tests/test2123-hub-postgres-ladder/run.sh.
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { register } from "./auth.js";
+import { db } from "./db.js";
+import { dispatchScheduledOccurrence, getScheduleRow } from "./scheduled-tasks.js";
+import { SCHEDULE_TARGET_OFFLINE_NOTICE_KIND, scheduledTargetOffline } from "./scheduled-offline.js";
+
+const activeDbPath = process.env.COMMHUB_DB ?? (process.env.COMMHUB_TEST_PG_URL ? "postgres" : undefined);
+if (!activeDbPath) throw new Error("scheduled-offline requires COMMHUB_DB (or COMMHUB_TEST_PG_URL) before module import");
+
+const stamp = Date.now();
+const TARGET_ID = `n_offline_target_${stamp}`;
+const TARGET = `offline-target-${stamp}`;
+const CREATOR_ID = `n_offline_creator_${stamp}`;
+const CREATOR = `offline-creator-${stamp}`;
+let NET = "", USER = "", slot = 0;
+
+function seedSchedule(createdByNodeId: string | null = null): any {
+  const id = `sched_offline_${crypto.randomUUID()}`;
+  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, status, next_run_at)
+     VALUES (?1, ?2, ?3, ?4, '离线巡检', ?5, ?6, 'ping', 'normal', 'interval',
+             '{"type":"interval","every_seconds":60}', 'Asia/Shanghai', 'active', datetime('now', '+1 minute'))`,
+    [id, NET, USER, createdByNodeId, TARGET_ID, TARGET],
+  );
+  return getScheduleRow(id)!;
+}
+
+function fire(schedule: any) {
+  const at = new Date(Date.UTC(2026, 9, 8, 0, 0, 0) + (++slot) * 60_000).toISOString();
+  return dispatchScheduledOccurrence(schedule, at, false, new Date());
+}
+
+function setTarget(status: "idle" | "offline", minutesAgo = 0) {
+  const seen = new Date(Date.now() - minutesAgo * 60_000).toISOString().replace("T", " ").replace(/\.\d{3}Z$/, "");
+  db.run("UPDATE sessions SET status = ?1, updated_at = ?2, last_seen_at = ?2 WHERE node_id = ?3 AND network_id = ?4", [status, seen, TARGET_ID, NET]);
+}
+
+const taskCount = () => db.get<{ n: number }>("SELECT COUNT(*) AS n FROM tasks WHERE network_id = ?1 AND to_node_id = ?2", NET, TARGET_ID)!.n;
+const humanNotices = (scheduleId: string) => db.all<{ meta_json: string; content: string }>(
+  "SELECT meta_json, content FROM user_inbox WHERE network_id = ?1 AND user_id = ?2 AND kind = ?3 ORDER BY created_at, message_id",
+  NET, USER, SCHEDULE_TARGET_OFFLINE_NOTICE_KIND,
+).filter((row) => JSON.parse(row.meta_json).schedule_target_offline.schedule_id === scheduleId);
+const agentNotices = (scheduleId: string) => db.all<{ meta_json: string; content: string }>(
+  "SELECT meta_json, content FROM inbox WHERE network_id = ?1 AND node_id = ?2 AND from_session = 'hub' ORDER BY created_at, id",
+  NET, CREATOR_ID,
+).filter((row) => JSON.parse(row.meta_json).schedule_target_offline?.schedule_id === scheduleId);
+
+beforeAll(() => {
+  const owner = register(`offline_owner_${stamp}`, "OfflineOwner123!", undefined, "seed");
+  expect(owner.ok).toBe(true);
+  NET = owner.network_id!; USER = owner.user!.user_id;
+  db.run("INSERT INTO nodes (node_id, node_name, alias, runtime, network_id, owner_user_id) VALUES (?1, ?2, ?2, 'codex', ?3, ?4)", [TARGET_ID, TARGET, NET, USER]);
+  db.run("INSERT INTO nodes (node_id, node_name, alias, runtime, network_id, owner_user_id) VALUES (?1, ?2, ?2, 'codex', ?3, ?4)", [CREATOR_ID, CREATOR, NET, USER]);
+  db.run("INSERT INTO sessions (resume_id, alias, status, node_id, network_id, last_seen_at) VALUES (?1, ?2, 'idle', ?3, ?4, datetime('now'))", [`r_target_${stamp}`, TARGET, TARGET_ID, NET]);
+  db.run("INSERT INTO sessions (resume_id, alias, status, node_id, network_id, last_seen_at) VALUES (?1, ?2, 'idle', ?3, ?4, datetime('now'))", [`r_creator_${stamp}`, CREATOR, CREATOR_ID, NET]);
+});
+
+afterAll(() => {
+  db.run("DELETE FROM user_inbox WHERE network_id = ?1 AND kind = ?2", [NET, SCHEDULE_TARGET_OFFLINE_NOTICE_KIND]);
+});
+
+describe("#757 scheduled target offline", () => {
+  test("offline skips without a task, warns a human once, and online recovery dispatches normally", () => {
+    const schedule = seedSchedule();
+    const online = fire(schedule);
+    expect(online.status).toBe("delivered");
+    db.run("UPDATE tasks SET status = 'replied' WHERE task_id = ?1", [online.taskId]);
+
+    setTarget("offline");
+    const before = taskCount();
+    const first = fire(schedule), second = fire(schedule);
+    expect([first.status, second.status]).toEqual(["skipped", "skipped"]);
+    expect(taskCount()).toBe(before);
+    for (const run of [first, second]) {
+      expect(db.get("SELECT status, error_code, task_id FROM scheduled_task_runs WHERE run_id = ?1", run.runId))
+        .toEqual({ status: "skipped", error_code: "target_offline", task_id: null });
+    }
+    expect(humanNotices(schedule.schedule_id)).toHaveLength(1);
+    expect(humanNotices(schedule.schedule_id)[0].content).toContain("恢复在线后");
+
+    setTarget("idle");
+    const recovered = fire(schedule);
+    expect(recovered.status).toBe("delivered");
+    expect(recovered.taskId).toBeTruthy();
+    db.run("UPDATE tasks SET status = 'replied' WHERE task_id = ?1", [recovered.taskId]);
+
+    setTarget("offline");
+    expect(fire(schedule).status).toBe("skipped");
+    expect(humanNotices(schedule.schedule_id)).toHaveLength(2);
+  });
+
+  test("an Agent-created schedule warns the creator inbox, never the owner's user inbox", () => {
+    const schedule = seedSchedule(CREATOR_ID);
+    setTarget("offline");
+    expect(fire(schedule).status).toBe("skipped");
+    expect(fire(schedule).status).toBe("skipped");
+    expect(agentNotices(schedule.schedule_id)).toHaveLength(1);
+    expect(agentNotices(schedule.schedule_id)[0].content).toContain("不需要回复");
+    expect(humanNotices(schedule.schedule_id)).toHaveLength(0);
+  });
+
+  test("an idle session older than the existing five-minute cutoff is offline", () => {
+    const schedule = seedSchedule();
+    setTarget("idle", 6);
+    const before = taskCount();
+    const run = fire(schedule);
+    expect(run.status).toBe("skipped");
+    expect(taskCount()).toBe(before);
+    expect(db.get<{ error_code: string }>("SELECT error_code FROM scheduled_task_runs WHERE run_id = ?1", run.runId)?.error_code).toBe("target_offline");
+  });
+
+  test("recent SQLite and ISO timestamps all keep an idle target online", () => {
+    const now = Date.now();
+    const isoMs = new Date(now - 1_000).toISOString();
+    const values = [
+      isoMs.slice(0, 19).replace("T", " "),
+      `${isoMs.slice(0, 19)}Z`,
+      isoMs,
+    ];
+    for (const value of values) {
+      db.run("UPDATE sessions SET status = 'idle', last_seen_at = ?1 WHERE node_id = ?2 AND network_id = ?3", [value, TARGET_ID, NET]);
+      expect(scheduledTargetOffline(TARGET_ID, TARGET, NET, now)).toBe(false);
+    }
+  });
+});

package/src/scheduled-offline.ts

@@ -0,0 +1,66 @@
+import { sendAgentNotice } from "./agent-notice.js";
+import { db, uuidv4 } from "./db.js";
+import { parseDbTimestampMs } from "./db-timestamp.js";
+import { pendingInboxCount } from "./inbox-count.js";
+import { pushEvent } from "./push.js";
+
+export const SCHEDULE_TARGET_OFFLINE_NOTICE_KIND = "schedule_target_offline";
+const SESSION_STALE_MS = 5 * 60_000;
+
+type SessionRow = { status: string | null; updated_at: string | null; last_seen_at: string | null };
+
+/** Same status + five-minute timestamp rule as the existing task delivery resolver. */
+export function scheduledTargetOffline(nodeId: string, alias: string, networkId: string, nowMs = Date.now()): boolean {
+  const session = db.get<SessionRow>(
+    "SELECT status, updated_at, last_seen_at FROM sessions WHERE node_id = ?1 AND network_id = ?2 ORDER BY updated_at DESC LIMIT 1",
+    nodeId, networkId,
+  ) ?? db.get<SessionRow>(
+    "SELECT status, updated_at, last_seen_at FROM sessions WHERE alias = ?1 AND network_id = ?2 AND node_id IS NULL ORDER BY updated_at DESC LIMIT 1",
+    alias, networkId,
+  );
+  if (!session) return true;
+  const raw = session.last_seen_at || session.updated_at;
+  const seen = raw ? parseDbTimestampMs(raw) : 0;
+  return String(session.status || "").toLowerCase() === "offline" || !Number.isFinite(seen) || nowMs - seen > SESSION_STALE_MS;
+}
+
+export type OfflineNotice = {
+  scheduleId: string; scheduleName: string; networkId: string;
+  createdBy: string | null; createdByNodeId: string | null;
+  targetAlias: string;
+};
+
+function noticeText(n: OfflineNotice): string {
+  return `定时任务「${n.scheduleName}」的目标节点 ${n.targetAlias} 已离线，本轮已跳过且没有创建任务。节点恢复在线后，后续轮次会自动照常派发。`;
+}
+
+/** Post-commit delivery. The transaction has already claimed this offline episode. */
+export function sendOfflineNotice(n: OfflineNotice): string | null {
+  try {
+    const text = noticeText(n);
+    const meta = { schedule_target_offline: { schedule_id: n.scheduleId, target_alias: n.targetAlias, reason: "target_offline" } };
+    if (!n.createdByNodeId) {
+      if (!n.createdBy) return null;
+      return sendAgentNotice({
+        networkId: n.networkId, userId: n.createdBy, fromAlias: n.targetAlias,
+        kind: SCHEDULE_TARGET_OFFLINE_NOTICE_KIND, title: "定时任务目标节点离线", text,
+        severity: "warning", meta, idPrefix: "dm_sched_offline_",
+      });
+    }
+    const creator = db.get<{ alias: string | null }>(
+      "SELECT alias FROM nodes WHERE node_id = ?1 AND network_id = ?2", n.createdByNodeId, n.networkId,
+    );
+    if (!creator?.alias) return null;
+    const id = `sched_offline_${uuidv4()}`;
+    db.run(
+      `INSERT INTO inbox (id, session_name, node_id, type, priority, content, from_session, network_id, meta_json)
+       VALUES (?1, ?2, ?3, 'message', 'normal', ?4, 'hub', ?5, ?6)`,
+      [id, creator.alias, n.createdByNodeId, `[定时任务目标节点离线] ${text}\n(这是告警，不需要回复。)`, n.networkId, JSON.stringify(meta)],
+    );
+    pushEvent(creator.alias, { type: "new_message", inbox_count: pendingInboxCount(creator.alias, n.networkId), from: "hub", message_id: id }, n.networkId);
+    return id;
+  } catch (e: any) {
+    console.error(`[scheduled-tasks] offline notice failed schedule=${n.scheduleId}: ${e?.message || e}`);
+    return null;
+  }
+}

package/src/scheduled-tasks.ts

@@ -11,6 +11,7 @@ import { SCHEDULED_TASK_STORAGE_SELECT } from "./rest-projections.js";
 import { parseDbTimestampMs } from "./db-timestamp.js";
 import { blockerTimedOut, expireStuckBlocker, sendStuckNotice, skipsBlockedBy, stuckNoticeSkips, stuckTimeoutMs, type StuckNotice } from "./scheduled-stuck.js";
 import { evaluateScheduleFailures, failureSummary } from "./scheduled-failures.js";
+import { scheduledTargetOffline, sendOfflineNotice, type OfflineNotice } from "./scheduled-offline.js";
 
 export type ScheduleSpec =
   | { type: "once"; run_at: string }
@@ -366,6 +367,7 @@ export function dispatchScheduledOccurrence(row: ScheduledRow, scheduledFor: str
   let finalStatus = "failed";
   let createdTaskId: string | undefined;
   const notices: StuckNotice[] = [];
+  let offlineNotice: OfflineNotice | null = null;
   const timedOut: Array<{ taskId: string; fromStatus: string }> = [];
 
   db.transaction(() => {
@@ -377,6 +379,35 @@ export function dispatchScheduledOccurrence(row: ScheduledRow, scheduledFor: str
       [runId, row.schedule_id, row.network_id, scheduledFor],
     );
 
+    // 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.
+    const targetNode = db.get<{ node_id: string; alias: string | null }>(
+      "SELECT node_id, alias FROM nodes WHERE node_id = ?1 AND network_id = ?2",
+      row.target_node_id, row.network_id,
+    );
+    if (targetNode?.alias && scheduledTargetOffline(targetNode.node_id, targetNode.alias, row.network_id, advanceAfter.getTime())) {
+      finalStatus = "skipped";
+      db.run(
+        `UPDATE scheduled_task_runs SET status = 'skipped', error_code = 'target_offline',
+           error_message = 'The target node is offline; no task was created', completed_at = datetime('now') WHERE run_id = ?1`,
+        [runId],
+      );
+      const claimed = db.run(
+        "UPDATE scheduled_tasks SET offline_alert_at = ?1 WHERE schedule_id = ?2 AND offline_alert_at IS NULL",
+        [advanceAfter.toISOString(), row.schedule_id],
+      ).changes === 1;
+      if (claimed) offlineNotice = {
+        scheduleId: row.schedule_id, scheduleName: row.name, networkId: row.network_id,
+        createdBy: row.created_by, createdByNodeId: row.created_by_node_id,
+        targetAlias: targetNode.alias,
+      };
+      if (advanceSchedule) advance({ ...row, target_alias: targetNode.alias }, scheduledFor, advanceAfter);
+      return;
+    }
+    // Seeing the target online rearms exactly one warning for a future offline episode.
+    if (targetNode?.alias) db.run("UPDATE scheduled_tasks SET offline_alert_at = NULL WHERE schedule_id = ?1 AND offline_alert_at IS NOT NULL", [row.schedule_id]);
+
     if (row.overlap_policy === "skip") {
       const placeholders = OPEN_TASK_STATUSES.map((_, i) => `?${i + 2}`).join(", ");
       // received:节点那边有没有把这条任务取走过(inbox 行被 ack,或任务已进 acked/running)。
@@ -430,10 +461,7 @@ export function dispatchScheduledOccurrence(row: ScheduledRow, scheduledFor: str
       }
     }
 
-    const node = db.get<{ node_id: string; alias: string | null }>(
-      "SELECT node_id, alias FROM nodes WHERE node_id = ?1 AND network_id = ?2",
-      row.target_node_id, row.network_id,
-    );
+    const node = targetNode;
     if (!node?.alias) {
       finalStatus = "failed";
       db.run(
@@ -541,6 +569,7 @@ export function dispatchScheduledOccurrence(row: ScheduledRow, scheduledFor: str
   try {
     for (const t of timedOut) logTaskEvent(t.taskId, t.fromStatus, "expired", "hub-scheduler", `stuck timeout; schedule=${row.schedule_id} run=${runId}`);
     for (const n of notices) sendStuckNotice(n);
+    if (offlineNotice) sendOfflineNotice(offlineNotice);
     // #523 — a run that failed at dispatch counts toward the consecutive-failure alert (task failures arrive via db.ts).
     if (finalStatus === "failed") evaluateScheduleFailures(row.schedule_id, advanceAfter);
     if (createdTaskId) logTaskEvent(createdTaskId, null, "delivered", "hub-scheduler", `schedule=${row.schedule_id} run=${runId}`);

package/src/server.ts

@@ -4,6 +4,7 @@ import { markGzipReusable, maybeGzipResponse, trimLightTask } from "./http-gzip"
 import { ifNoneMatchHits, memoStatusBody } from "./status-read-cache";
 import { dispatchQueueInfo, queueDepthByNode, queueDepthKey } from "./task-queue-ahead.js";
 import { sessionTaskOnDispatch } from "./session-task-on-dispatch.js";
+import { AGENT_TEAM_SCOPE_DENIED, clearNodeFromAgentTeams, createAgentTeam, deleteAgentTeam, listAgentTeams, ownedScope, setNodeAgentTeam, updateAgentTeam } from "./agent-teams.js";
 import { TASK_CONTENT_MAX, sessionTaskPreview } from "./shared/task-content-limit.js";
 import { statusAliasResolverRead } from "./status-alias-resolver.js";
 import { readNodeHealth } from "./node-health-store.js";
@@ -28,12 +29,13 @@ import { assertNodeActive } from "./lifecycle-guard.js";
 import { pendingInboxCount } from "./inbox-count.js";
 import { notifyExpiredTasks, type ExpiredTaskRow } from "./task-expiry-notice.js";
 import { expireStaleOpenTasks } from "./task-stale-open.js";
+import { flagOrphanTasks } from "./task-orphan.js";
 import { addAgentNetworkScope, addHumanNetworkScope, addNetworkScope, addOwnTrafficScope, addAgentTimelineScope, canRestWriteNetwork, canRestWriteNetworkAsHuman, getUserNetworkIds, resolveRestNetworkScope, resolveRestWriteNetworkId, singleNetworkId, type RestNetworkScope } from "./network-scope.js";
 import { lifecycleProjections, lifecycleRequestResponse } from "./node-lifecycle-read.js";
 import { restrictedMemberSeesFile, restrictedMemberAttachmentsDenied } from "./restricted-files.js";
 import { dmParticipantSeesFile, listDmThread, listDmThreads, sendHumanDm } from "./human-dm.js";
 import { groupMemberSeesFile, groupUnreadFor, listGroupMessages, listGroupThreads, markGroupRead, memberGroup, sendGroupMessage } from "./group-messages.js";
-import { getTaskAccessMode, isTaskScoped, listProjectGrants, replaceTaskGrants, NEW_MEMBER_TASK_ACCESS } from "./task-access.js";
+import { getTaskAccessMode, isTaskScoped, listProjectGrants, replaceTaskGrants, newMemberTaskAccess } from "./task-access.js";
 import { canMessageAgent, isAgentRestricted, visibleAgents, listAgentGrants, listGroupGrants, getAgentAccessMode, replaceAgentGrants, restrictedNetworkIds, usernameIsAgentAlias, listAgentGroups, createAgentGroup, updateAgentGroup, replaceAgentGroupMembers, deleteAgentGroup, usersGrantedGroup } from "./agent-access.js";
 import { broadcastVerdict, dispatchVerdict, humanOnlyVerdict, NODE_PERMISSION_MODES, nodeDecide, nodeIdentity, nodePermissionDeniedBody, nodePermissionsFlag, streamVerdict, writeVerdict, type NodeIdentity, type NodePermissionMode, type Verdict } from "./node-permissions.js";
 import { validateAvatarUrl } from "./avatar-validate.js";
@@ -976,6 +978,18 @@ export function patrolExpiredTasks(): void {
   }
 }
 
+// #758 — acked/running tasks whose node went idle/offline after starting them
+// and never replied: one task.orphan_suspected event + one sender notice per
+// task (task-orphan.ts). Status untouched. Same 5-minute timer as the TTL patrol.
+export function patrolOrphanTasks(): void {
+  try {
+    const flagged = flagOrphanTasks();
+    if (flagged.length > 0) console.warn(`[patrol] flagged ${flagged.length} orphan-suspected task(s), notified ${flagged.filter((f) => f.notified).length}`);
+  } catch (e: any) {
+    console.error(`[patrol] orphan phase failed: ${e?.message || e}`);
+  }
+}
+
 function patrolDeliveredStaleTasks(): void {
   try {
     const result = recordDeliveredStaleEvents();
@@ -1860,6 +1874,48 @@ return Bun.serve({
       return withCors(req, Response.json({ ok: true, network_id: netId, user_id: targetUid, agent_access: result.agent_access, restricted: isAgentRestricted(targetUid, netId), grants: result.grants, group_grants: result.group_grants }));
     }
 
+    // ── Agent 团队(#764):Agent 自己的组织树,和人的部门树无关。读:网络任何成员 / 本网络的节点令牌 / Hub 管理员;
+    // 写:owner / admin / Hub 管理员全管;团队 owner_user_id 管自己的子树(规则在 agent-teams.ts);节点令牌只读。 ──
+    const teamMatch = url.pathname.match(/^\/api\/networks\/([^/]+)\/agent-teams(?:\/([^/]+))?$/);
+    const nodeTeamMatch = url.pathname.match(/^\/api\/networks\/([^/]+)\/nodes\/([^/]+)\/agent-team$/);
+    if (teamMatch || nodeTeamMatch) {
+      const token = requestToken(req, { allowQueryToken: false });
+      const resolved = token ? resolveToken(token) : null;
+      if (!resolved) return withCors(req, Response.json({ ok: false, error: "auth required" }, { status: 401 }));
+      const netId = decodeURIComponent((teamMatch ?? nodeTeamMatch)![1]);
+      const notMember = () => withCors(req, Response.json({ ok: false, error: "not a member of this network" }, { status: 403 }));
+      if (resolved.networkId && resolved.networkId !== netId) return notMember();
+      const hubAdmin = isHubAdminCredential(resolved);
+      const role = resolved.networkId ? null : getUserNetworkRole(resolved.user.user_id, netId);
+      if (!hubAdmin && !role && !resolved.networkId) return notMember();
+      if (!db.get("SELECT 1 AS x FROM networks WHERE network_id = ?1", netId)) return withCors(req, Response.json({ ok: false, error: "network_not_found" }, { status: 404 }));
+      const canManage = hubAdmin || (!resolved.networkId && (role === "owner" || role === "admin"));
+      // 只看授权 Agent 的成员:看不见的节点不出现在 members / lead 里(和 Agent 列表同一判据);写路径用同一个判据,看不见 = 404。
+      const seen = !hubAdmin && !resolved.networkId && isAgentRestricted(resolved.user.user_id, netId) ? visibleAgents(resolved.user.user_id, netId) : null;
+      const hidden = (n: { node_id: string; alias: string | null }) => !!seen && !seen.nodeIds.includes(n.node_id) && !(n.alias && seen.aliases.includes(n.alias));
+      if (teamMatch && !teamMatch[2] && req.method === "GET") {
+        return withCors(req, Response.json({ ok: true, network_id: netId, teams: listAgentTeams(netId, hidden) }));
+      }
+      const write = teamMatch ? (teamMatch[2] ? ["PATCH", "DELETE"] : ["POST"]) : ["PUT"];
+      if (!write.includes(req.method)) return withCors(req, Response.json({ ok: false, error: "method_not_allowed" }, { status: 405 }));
+      // null = 全管;节点令牌 / 普通成员 → 空集(任何写都 403);团队 owner → 自己的子树。
+      const scope = canManage ? null : resolved.networkId ? new Set<string>() : ownedScope(netId, resolved.user.user_id);
+      if (scope && scope.size === 0) return withCors(req, Response.json({ ok: false, error: AGENT_TEAM_SCOPE_DENIED }, { status: 403 }));
+      let body: Record<string, unknown> = {};
+      if (req.method !== "DELETE") {
+        try { const b = await req.json(); body = b && typeof b === "object" && !Array.isArray(b) ? b as Record<string, unknown> : {}; } catch { return withCors(req, Response.json({ ok: false, error: "invalid JSON" }, { status: 400 })); }
+      }
+      const teamId = teamMatch?.[2] ? decodeURIComponent(teamMatch[2]) : "";
+      const nodeId = nodeTeamMatch ? decodeURIComponent(nodeTeamMatch[2]) : undefined;
+      const r = nodeId !== undefined ? setNodeAgentTeam(netId, nodeId, scope, hidden, body.team_id)
+        : req.method === "POST" ? createAgentTeam(netId, resolved.user.user_id, scope, hidden, body)
+        : req.method === "PATCH" ? updateAgentTeam(netId, teamId, scope, hidden, body)
+        : deleteAgentTeam(netId, teamId, scope);
+      if (!r.ok) { const { ok: _ok, status, ...rest } = r; return withCors(req, Response.json({ ok: false, ...rest }, { status })); }
+      logAudit(resolved.user.user_id, resolved.user.username, `agent_team_${req.method.toLowerCase()}`, "network", netId, JSON.stringify({ team_id: teamId || undefined, node_id: nodeId, ...body }).slice(0, 2000), undefined, netId);
+      return withCors(req, Response.json(r, { status: req.method === "POST" ? 201 : 200 }));
+    }
+
     // ── 多用户:网络里的人类成员通讯录 —— 任何成员(含受限成员)都能看,只有身份字段 ──
     const humansMatch = url.pathname.match(/^\/api\/networks\/([^/]+)\/humans$/);
     if (humansMatch && req.method === "GET") {
@@ -2178,12 +2234,12 @@ return Bun.serve({
         if (body.agent_access !== undefined && body.agent_access !== "all" && body.agent_access !== "granted") {
           return withCors(req, Response.json({ ok: false, error: "invalid_agent_access" }, { status: 400 }));
         }
-        // task_access 缺省 NEW_MEMBER_TASK_ACCESS(RFC-038 §9.4);显式传 'all' / 'scoped' 覆盖。
+        // task_access 缺省 newMemberTaskAccess(role)(RFC-038 §9.4,#746 起 member/viewer 为 'scoped');显式传 'all' / 'scoped' 覆盖。
         if (body.task_access !== undefined && body.task_access !== "all" && body.task_access !== "scoped") {
           return withCors(req, Response.json({ ok: false, error: "invalid_task_access" }, { status: 400 }));
         }
         const result = addNetworkMember(netId, body.user_id, body.role || "member", resolved.user.user_id, { agentAccess: body.agent_access, taskAccess: body.task_access });
-        if (result.ok) logAudit(resolved.user.user_id, resolved.user.username, "member_added", "network", netId, `${body.user_id} as ${body.role || "member"} agent_access=${body.agent_access === "all" ? "all" : "granted"} task_access=${body.task_access ?? NEW_MEMBER_TASK_ACCESS}`, undefined, netId);
+        if (result.ok) logAudit(resolved.user.user_id, resolved.user.username, "member_added", "network", netId, `${body.user_id} as ${body.role || "member"} agent_access=${body.agent_access === "all" ? "all" : "granted"} task_access=${body.task_access ?? newMemberTaskAccess(body.role || "member")}`, undefined, netId);
         return withCors(req, Response.json(result, { status: result.ok ? 200 : 400 }));
       }
       if (req.method === "PUT" && targetUid) {
@@ -4183,6 +4239,7 @@ return Bun.serve({
 
       db.transaction(() => {
         db.run("DELETE FROM nodes WHERE node_id = ?1", [node.node_id]);
+        clearNodeFromAgentTeams(node.node_id); // #764
         if (node.alias) {
           db.run(
             "DELETE FROM sessions WHERE alias = ?1 AND (network_id = ?2 OR (CAST(?2 AS TEXT) IS NULL AND network_id IS NULL))",
@@ -5086,7 +5143,7 @@ export function startHub(opts?: { port?: number; hostname?: string }): ReturnTyp
   const deliveredStalePatrolMs = Number(process.env.COMMHUB_DELIVERED_STALE_PATROL_MS) > 0
     ? Number(process.env.COMMHUB_DELIVERED_STALE_PATROL_MS) : 5 * 1000;
   const rateLimitSweepTimer = setInterval(sweepStaleRateLimits, rateLimitSweepMs);
-  const taskPatrolTimer = setInterval(patrolExpiredTasks, taskPatrolMs);
+  const taskPatrolTimer = setInterval(() => { patrolExpiredTasks(); patrolOrphanTasks(); }, taskPatrolMs);
   patrolDeliveredStaleTasks();
   const deliveredStalePatrolTimer = setInterval(patrolDeliveredStaleTasks, deliveredStalePatrolMs);
   const scheduledTaskTimer = startScheduledTaskScheduler();