@sleep2agi/commhub-server 0.9.0-preview.115 → 0.9.0-preview.117

package/src/agent-teams.ts

@@ -0,0 +1,244 @@
+// Agent 团队(看板 #764,父卡 #750):Agent(节点)自己的组织树,和人的部门树(network_departments)完全独立。
+//
+// 只增:两张新表。network_agent_teams = 团队(多层,同一上级下不重名);network_agent_team_members = 节点归哪个团队
+// (一个节点最多一个团队;行存在 = 在这个团队)。nodes / 部门表一概不动,已有接口的响应不变。
+//
+// 权限(每次请求按 owner_user_id 现算,不存展开结果):
+//   网络 owner / admin、Hub 管理员:全部;
+//   团队的 owner_user_id:管这个团队的子树 —— 改名 / 排序 / 设 lead、在子树里建子团队、在子树里挪动、把节点放进 / 移出子树;
+//     但不能改自己那个团队的 owner,也不能把它挪出去(这两样要求「上级也在我的范围里」);
+//   其他成员、节点令牌:只读。viewer 当 owner 也不获得写权限。
+// 读的时候 JOIN nodes:节点删了,它的归属 / lead 自然消失;删节点的两条路径另外调 clearNodeFromAgentTeams 真删行。
+
+import { db } from "./db.js";
+
+db.exec(`
+  CREATE TABLE IF NOT EXISTS network_agent_teams (
+    network_id    TEXT NOT NULL,
+    team_id       TEXT NOT NULL,
+    name          TEXT NOT NULL,
+    parent_id     TEXT,
+    lead_node_id  TEXT,
+    owner_user_id TEXT,
+    sort          INTEGER NOT NULL DEFAULT 0,
+    created_by    TEXT,
+    created_at    TEXT NOT NULL DEFAULT (datetime('now')),
+    updated_at    TEXT NOT NULL DEFAULT (datetime('now')),
+    PRIMARY KEY (network_id, team_id)
+  );
+  CREATE INDEX IF NOT EXISTS idx_network_agent_teams_parent ON network_agent_teams(network_id, parent_id);
+  CREATE TABLE IF NOT EXISTS network_agent_team_members (
+    network_id TEXT NOT NULL,
+    node_id    TEXT NOT NULL,
+    team_id    TEXT NOT NULL,
+    created_at TEXT NOT NULL DEFAULT (datetime('now')),
+    PRIMARY KEY (network_id, node_id)
+  );
+  CREATE INDEX IF NOT EXISTS idx_network_agent_team_members_team ON network_agent_team_members(network_id, team_id);
+`);
+
+export const AGENT_TEAM_SCOPE_DENIED = "agent_team_scope_denied";
+const MAX_DEPTH = 10;
+const MAX_TEAMS = 500;
+const NAME_MAX = 40;
+
+type Row = { team_id: string; name: string; parent_id: string | null; lead_node_id: string | null; owner_user_id: string | null; sort: number; created_at: string; updated_at: string };
+type Fail = { ok: false; status: number; error: string };
+const fail = (status: number, error: string): Fail => ({ ok: false, status, error });
+const nil = (v: unknown) => v === undefined || v === null || v === "";
+
+function rows(networkId: string): Row[] {
+  return db.all<Row>(
+    "SELECT team_id, name, parent_id, lead_node_id, owner_user_id, sort, created_at, updated_at FROM network_agent_teams WHERE network_id = ?1 ORDER BY sort, created_at, team_id",
+    networkId,
+  );
+}
+function one(networkId: string, id: unknown): Row | null {
+  if (typeof id !== "string") return null;
+  return rows(networkId).find((r) => r.team_id === id) ?? null;
+}
+function parentOf(networkId: string): Map<string, string | null> {
+  return new Map(rows(networkId).map((r) => [r.team_id, r.parent_id]));
+}
+/** id 和它的全部上级(从自己往上)。 */
+function chain(parent: Map<string, string | null>, id: string | null): string[] {
+  const out: string[] = [];
+  let cur = id;
+  while (cur && parent.has(cur) && !out.includes(cur)) { out.push(cur); cur = parent.get(cur) ?? null; }
+  return out;
+}
+function height(parent: Map<string, string | null>, id: string): number {
+  let h = 1;
+  for (const [c, p] of parent) if (p === id && c !== id) h = Math.max(h, 1 + height(parent, c));
+  return h;
+}
+const isMember = (networkId: string, userId: string) =>
+  !!db.get("SELECT user_id FROM network_members WHERE network_id = ?1 AND user_id = ?2", networkId, userId);
+type Hidden = (n: NodeRef) => boolean;
+/** 写路径用同一个可见性判据:不在本网络、或调用者看不见(只看授权 Agent)→ 一律当不存在(同一个 404,不能拿来探测)。 */
+function visibleNode(networkId: string, nodeId: unknown, hidden: Hidden): boolean {
+  if (typeof nodeId !== "string") return false;
+  const n = db.get<NodeRef>("SELECT node_id, alias, display_name FROM nodes WHERE network_id = ?1 AND node_id = ?2", networkId, nodeId);
+  return !!n && !hidden(n);
+}
+const publicTeam = (networkId: string, id: string, hidden: Hidden) => listAgentTeams(networkId, hidden).find((t) => t.id === id)!;
+const cleanName = (raw: unknown): string | null => {
+  if (typeof raw !== "string") return null;
+  const n = raw.trim();
+  return n && [...n].length <= NAME_MAX ? n : null;
+};
+function nameTaken(networkId: string, parentId: string | null, name: string, except?: string): boolean {
+  return rows(networkId).some((r) => r.parent_id === parentId && r.name === name && r.team_id !== except);
+}
+
+/** userId 能管的团队:他当 owner 的团队及全部下级(owner 不在本网络 / 是 viewer → 空)。 */
+export function ownedScope(networkId: string, userId: string): Set<string> {
+  const role = db.get<{ role: string | null }>("SELECT role FROM network_members WHERE network_id = ?1 AND user_id = ?2", networkId, userId)?.role;
+  const out = new Set<string>();
+  if (!role || role === "viewer") return out;
+  const all = rows(networkId);
+  const parent = new Map(all.map((r) => [r.team_id, r.parent_id]));
+  const owned = new Set(all.filter((r) => r.owner_user_id === userId).map((r) => r.team_id));
+  for (const r of all) if (chain(parent, r.team_id).some((id) => owned.has(id))) out.add(r.team_id);
+  return out;
+}
+
+type NodeRef = { node_id: string; alias: string | null; display_name: string | null };
+/** 整棵树 + 每个团队的成员 / lead / owner。hidden(node) = true 的节点不出现(只看授权 Agent 的成员)。 */
+export function listAgentTeams(networkId: string, hidden: Hidden) {
+  const nodes = new Map(db.all<NodeRef>("SELECT node_id, alias, display_name FROM nodes WHERE network_id = ?1", networkId).map((n) => [n.node_id, n]));
+  const people = new Map(db.all<{ user_id: string; username: string; display_name: string | null }>(
+    "SELECT u.user_id, u.username, u.display_name FROM network_members m JOIN users u ON u.user_id = m.user_id WHERE m.network_id = ?1", networkId,
+  ).map((u) => [u.user_id, !u.display_name || u.display_name === u.username ? "" : u.display_name])); // 同 requirements-people 的显示名规则
+  const seen = (id: string | null) => (id && nodes.has(id) && !hidden(nodes.get(id)!) ? nodes.get(id)! : null);
+  const members = new Map<string, NodeRef[]>();
+  for (const m of db.all<{ node_id: string; team_id: string }>("SELECT node_id, team_id FROM network_agent_team_members WHERE network_id = ?1 ORDER BY node_id", networkId)) {
+    const n = seen(m.node_id);
+    if (n) members.set(m.team_id, [...(members.get(m.team_id) ?? []), n]);
+  }
+  return rows(networkId).map((r) => ({
+    id: r.team_id, name: r.name, parent_id: r.parent_id, sort: r.sort,
+    lead: seen(r.lead_node_id),
+    owner: r.owner_user_id && people.has(r.owner_user_id) ? { user_id: r.owner_user_id, display_name: people.get(r.owner_user_id)! } : null,
+    members: members.get(r.team_id) ?? [],
+    created_at: r.created_at, updated_at: r.updated_at,
+  }));
+}
+
+/** #765: node-token identity only; no fallback to a human's department.
+ * Reuse the REST projection's network joins and display-name privacy rules.
+ */
+export function agentTeamWhoami(networkId: string, nodeId: string | null) {
+  if (!nodeId) return { ok: false, error: "node_identity_unbound" };
+  const teams = listAgentTeams(networkId, () => false);
+  const self = teams.find(t => t.members.some(n => n.node_id === nodeId));
+  if (!self) return { ok: true, source: "none", node_id: nodeId, team: null, ancestors: [], lead: null, owner: null, agents: [], truncated: false };
+  const byId = new Map(teams.map(t => [t.id, t]));
+  const seen = new Set([self.id]);
+  const ancestors: { id: string; name: string }[] = [];
+  for (let id = self.parent_id; id && !seen.has(id);) {
+    const parent = byId.get(id);
+    if (!parent) break;
+    seen.add(id);
+    ancestors.push({ id, name: parent.name });
+    id = parent.parent_id;
+  }
+  return { ok: true, source: "node", node_id: nodeId, team: { id: self.id, name: self.name }, ancestors,
+    lead: self.lead, owner: self.owner, agents: self.members.slice(0, 50), truncated: self.members.length > 50 };
+}
+
+/** scope = null 表示全管;否则是调用者能管的团队集合。 */
+export function createAgentTeam(networkId: string, actor: string, scope: Set<string> | null, hidden: Hidden, body: Record<string, unknown>) {
+  const name = cleanName(body.name);
+  if (!name) return fail(400, "invalid_team_name");
+  const parentId = nil(body.parent_id) ? null : body.parent_id;
+  if (parentId !== null && !one(networkId, parentId)) return fail(400, "parent_not_found");
+  if (scope && (parentId === null || !scope.has(parentId as string))) return fail(403, AGENT_TEAM_SCOPE_DENIED);
+  if (chain(parentOf(networkId), parentId as string | null).length + 1 > MAX_DEPTH) return fail(400, "team_too_deep");
+  if (nameTaken(networkId, parentId as string | null, name)) return fail(409, "team_name_taken");
+  if (rows(networkId).length >= MAX_TEAMS) return fail(400, "too_many_teams");
+  const id = `team_${crypto.randomUUID().replace(/-/g, "").slice(0, 16)}`;
+  const sort = rows(networkId).filter((r) => r.parent_id === parentId).length;
+  db.run("INSERT INTO network_agent_teams (network_id, team_id, name, parent_id, sort, created_by) VALUES (?1, ?2, ?3, ?4, ?5, ?6)", [networkId, id, name, parentId, sort, actor]);
+  return { ok: true as const, team: publicTeam(networkId, id, hidden) };
+}
+
+export function updateAgentTeam(networkId: string, id: string, scope: Set<string> | null, hidden: Hidden, body: Record<string, unknown>) {
+  const cur = one(networkId, id);
+  if (!cur) return fail(404, "team_not_found");
+  // 子树 owner:团队本身要在范围里;改 owner / 挪动还要求它的上级也在范围里(不能改自己那个团队的 owner、不能挪出去)。
+  if (scope && !scope.has(id)) return fail(403, AGENT_TEAM_SCOPE_DENIED);
+  const parentInScope = !scope || (cur.parent_id !== null && scope.has(cur.parent_id));
+  const next = { ...cur };
+  let touched = false;
+  if (body.name !== undefined) {
+    const n = cleanName(body.name);
+    if (!n) return fail(400, "invalid_team_name");
+    next.name = n; touched = true;
+  }
+  if (body.parent_id !== undefined) {
+    const p = nil(body.parent_id) ? null : body.parent_id;
+    if (p !== null && !one(networkId, p)) return fail(400, "parent_not_found");
+    if (scope && (!parentInScope || p === null || !scope.has(p as string))) return fail(403, AGENT_TEAM_SCOPE_DENIED);
+    const parent = parentOf(networkId);
+    if (p !== null && chain(parent, p as string).includes(id)) return fail(400, "team_cycle");
+    if (chain(parent, p as string | null).length + height(parent, id) > MAX_DEPTH) return fail(400, "team_too_deep");
+    next.parent_id = p as string | null; touched = true;
+  }
+  if (body.sort !== undefined) {
+    if (!Number.isInteger(body.sort)) return fail(400, "invalid_sort");
+    next.sort = body.sort as number; touched = true;
+  }
+  if (body.lead_node_id !== undefined) {
+    const l = nil(body.lead_node_id) ? null : body.lead_node_id;
+    if (l !== null && !visibleNode(networkId, l, hidden)) return fail(404, "node_not_found");
+    next.lead_node_id = l as string | null; touched = true;
+  }
+  if (body.owner_user_id !== undefined) {
+    const o = nil(body.owner_user_id) ? null : body.owner_user_id;
+    if (!parentInScope) return fail(403, AGENT_TEAM_SCOPE_DENIED); // 先判权限,再判成员:没权限的人不能借此探测谁是成员
+    if (o !== null && (typeof o !== "string" || !isMember(networkId, o))) return fail(400, "owner_not_member");
+    next.owner_user_id = o as string | null; touched = true;
+  }
+  if (!touched) return fail(400, "empty_patch");
+  if ((next.name !== cur.name || next.parent_id !== cur.parent_id) && nameTaken(networkId, next.parent_id, next.name, id)) return fail(409, "team_name_taken");
+  db.run(
+    "UPDATE network_agent_teams SET name = ?3, parent_id = ?4, sort = ?5, lead_node_id = ?6, owner_user_id = ?7, updated_at = datetime('now') WHERE network_id = ?1 AND team_id = ?2",
+    [networkId, id, next.name, next.parent_id, next.sort, next.lead_node_id, next.owner_user_id],
+  );
+  return { ok: true as const, team: publicTeam(networkId, id, hidden) };
+}
+
+/** 只删没有子团队的团队;成员归属同一事务清掉(节点变回未分配)。 */
+export function deleteAgentTeam(networkId: string, id: string, scope: Set<string> | null) {
+  const cur = one(networkId, id);
+  if (!cur) return fail(404, "team_not_found");
+  if (scope && (cur.parent_id === null || !scope.has(cur.parent_id))) return fail(403, AGENT_TEAM_SCOPE_DENIED);
+  const children = rows(networkId).filter((r) => r.parent_id === id).length;
+  if (children) return { ...fail(409, "team_has_children"), children };
+  db.transaction(() => {
+    db.run("DELETE FROM network_agent_teams WHERE network_id = ?1 AND team_id = ?2", [networkId, id]);
+    db.run("DELETE FROM network_agent_team_members WHERE network_id = ?1 AND team_id = ?2", [networkId, id]);
+  });
+  return { ok: true as const, deleted: id };
+}
+
+/** 节点归一个团队(null = 未分配)。子树 owner:目标团队、节点当前的团队(有的话)都要在范围里。 */
+export function setNodeAgentTeam(networkId: string, nodeId: string, scope: Set<string> | null, hidden: Hidden, teamId: unknown) {
+  if (!visibleNode(networkId, nodeId, hidden)) return fail(404, "node_not_found");
+  const target = nil(teamId) ? null : teamId;
+  if (target !== null && !one(networkId, target)) return fail(400, "team_not_found");
+  const current = db.get<{ team_id: string }>("SELECT team_id FROM network_agent_team_members WHERE network_id = ?1 AND node_id = ?2", networkId, nodeId)?.team_id ?? null;
+  if (scope && ((target === null && current === null) || (target !== null && !scope.has(target as string)) || (current !== null && !scope.has(current)))) return fail(403, AGENT_TEAM_SCOPE_DENIED);
+  db.transaction(() => {
+    db.run("DELETE FROM network_agent_team_members WHERE network_id = ?1 AND node_id = ?2", [networkId, nodeId]);
+    if (target !== null) db.run("INSERT INTO network_agent_team_members (network_id, node_id, team_id) VALUES (?1, ?2, ?3)", [networkId, nodeId, target]);
+  });
+  return { ok: true as const, node_id: nodeId, team_id: target as string | null };
+}
+
+/** 节点删除时调用:清掉它的团队归属,指向它的 lead 置空。 */
+export function clearNodeFromAgentTeams(nodeId: string): void {
+  db.run("DELETE FROM network_agent_team_members WHERE node_id = ?1", [nodeId]);
+  db.run("UPDATE network_agent_teams SET lead_node_id = NULL WHERE lead_node_id = ?1", [nodeId]);
+}

package/src/auth.ts

@@ -5,7 +5,7 @@ import { db, generateId, hashPassword, verifyPassword, hashToken, generateToken,
 import { WEAK_PASSWORDS } from "./password-dict.js";
 import { checkNodeTokenClaim, legacyNodeHolder } from "./node-token-ownership.js";
 import { NETWORK_REST_COLUMNS, NETWORK_REST_SELECT, sqlColumns } from "./rest-projections.js";
-import { deleteAgentGrants, isAgentRestricted } from "./agent-access.js"; import { deleteTaskGrantsForMember, NEW_MEMBER_TASK_ACCESS, type TaskAccessMode } from "./task-access.js"; // 一行两个 import:文档钉着 auth.ts 的行号
+import { deleteAgentGrants, isAgentRestricted } from "./agent-access.js"; import { deleteTaskGrantsForMember, newMemberTaskAccess, type TaskAccessMode } from "./task-access.js"; // 一行两个 import:文档钉着 auth.ts 的行号
 
 // Round-6 A1 hardening — dummy hash for username-enumeration timing
 // close. We compute ONE scrypt hash of a throwaway password and reuse
@@ -514,7 +514,7 @@ export function deleteNetwork(userId: string, networkId: string): { ok: boolean;
     // single-network user to "ambiguous" or auto-resolve writes INTO the
     // deleted network. Remove memberships with the network.
     db.run("DELETE FROM network_members WHERE network_id = ?1", [networkId]);
-    deleteNetworkAgentGroups(networkId); deleteDepartmentsForNetwork(networkId); // #2144, #419 (one line: docs pin auth.ts line numbers)
+    deleteNetworkAgentGroups(networkId); deleteDepartmentsForNetwork(networkId); for (const t of AGENT_TEAM_TABLES) if (tableExists(t)) db.run(`DELETE FROM ${t} WHERE network_id = ?1`, [networkId]); // #2144, #419, #764 (one line: docs pin auth.ts line numbers)
   });
   return { ok: true };
 }
@@ -749,8 +749,8 @@ export function usernameCollidesWithAgent(networkId: string, userId: string): bo
 export function addNetworkMember(networkId: string, userId: string, role: string, invitedBy?: string, opts: { agentAccess?: "all" | "granted"; taskAccess?: TaskAccessMode } = {}): { ok: boolean; error?: string } {
   if (!MEMBER_ROLES.has(role)) return { ok: false, error: "invalid role" };
   const agentAccess = opts.agentAccess === "all" ? "all" : "granted";
-  // 任务范围:新成员默认 NEW_MEMBER_TASK_ACCESS(task-access.ts 一处定义)。
-  const taskAccess: TaskAccessMode = opts.taskAccess === "all" || opts.taskAccess === "scoped" ? opts.taskAccess : NEW_MEMBER_TASK_ACCESS;
+  // 任务范围:显式传值优先;否则 newMemberTaskAccess(role)(#746:member/viewer 'scoped',admin 'all')。
+  const taskAccess: TaskAccessMode = opts.taskAccess === "all" || opts.taskAccess === "scoped" ? opts.taskAccess : newMemberTaskAccess(role);
   if (!db.get("SELECT 1 FROM users WHERE user_id = ?1", userId)) return { ok: false, error: "user not found" };
   const existing = db.get<any>("SELECT 1 FROM network_members WHERE network_id = ?1 AND user_id = ?2", networkId, userId);
   if (existing) return { ok: false, error: "user already a member" };
@@ -816,7 +816,7 @@ export function joinByInvite(inviteCode: string, userId: string): { ok: boolean;
   if (usernameCollidesWithAgent(invite.network_id, userId)) return { ok: false, error: "username_collides_with_agent_alias" };
   // Add member + increment used count
   db.run("INSERT INTO network_members (network_id, user_id, role, invited_by, agent_access, task_access) VALUES (?1, ?2, ?3, ?4, 'granted', ?5)",
-    [invite.network_id, userId, invite.role, invite.created_by, NEW_MEMBER_TASK_ACCESS]);
+    [invite.network_id, userId, invite.role, invite.created_by, newMemberTaskAccess(invite.role)]);
   db.run("UPDATE network_invites SET used_count = used_count + 1 WHERE invite_code = ?1", [inviteCode]);
   // 受限成员不能持有网络令牌(resolveToken 会拒),别签一个用不了的。
   if (isAgentRestricted(userId, invite.network_id)) return { ok: true, network_id: invite.network_id, role: invite.role };
@@ -953,6 +953,7 @@ const NETWORK_CONTENT_CHECKS: Array<[label: string, sql: string]> = [
   ["pending_node_create_requests", "SELECT COUNT(*) AS cnt FROM node_create_requests WHERE network_id = ?1 AND status IN ('pending', 'delivered')"],
   ["pending_node_start_requests", "SELECT COUNT(*) AS cnt FROM node_start_requests WHERE network_id = ?1 AND status IN ('pending', 'delivered')"],
 ];
+const AGENT_TEAM_TABLES = ["network_agent_teams", "network_agent_team_members"]; // #764
 const NETWORK_CLEANUP_TABLES = [
   "network_members", "network_member_agent_grants", "network_invites", "api_tokens",
   "node_create_requests", "node_start_requests", "node_stop_requests", "node_rules_requests",
@@ -962,6 +963,8 @@ const NETWORK_CLEANUP_TABLES = [
   "network_tags",
   // 组织架构(board #419):部门是网络本身的元数据。
   "network_departments",
+  // Agent 团队(#764):Agent 自己的组织树,同样是网络元数据。
+  ...AGENT_TEAM_TABLES,
 ];
 
 function tableExists(name: string): boolean {

package/src/db.ts

@@ -1648,6 +1648,9 @@ try { db.exec("CREATE INDEX IF NOT EXISTS idx_scheduled_tasks_creator_node ON sc
 // success in between re-arms the alert.
 try { db.exec("ALTER TABLE scheduled_tasks ADD COLUMN failure_alert_at TEXT"); } catch {}
 try { db.exec("ALTER TABLE scheduled_tasks ADD COLUMN failure_alert_key TEXT"); } catch {}
+// Board #757 — one warning per continuous target-offline episode. The scheduler
+// clears this as soon as the target session is online again; older Hubs ignore it.
+try { db.exec("ALTER TABLE scheduled_tasks ADD COLUMN offline_alert_at TEXT"); } catch {}
 
 // RFC-036 / B4 — owner-authorized edits of node-host managed schedules.
 // This is intentionally separate from Hub scheduled_tasks: these rows are

package/src/department-heads-http.test.ts

@@ -55,7 +55,8 @@ beforeAll(async () => {
     expect((await send(U.owner.token, "POST", "/api/admin/users", { username, password: PW, network_id: NET, role })).status).toBe(200);
     const login = await send("", "POST", "/api/auth/login", { username, password: PW });
     U[k] = { token: login.body.token, id: login.body.user.user_id };
-    if (scoped && role !== "admin") expect((await send(U.owner.token, "PUT", `/api/networks/${NET}/members/${U[k].id}/task-grants`, { task_access: "scoped" })).status).toBe(200);
+    // #746 起新成员默认就是 scoped;allMember 显式放宽到 'all'(模拟升级前的老成员)。
+    if (role !== "admin") expect((await send(U.owner.token, "PUT", `/api/networks/${NET}/members/${U[k].id}/task-grants`, { task_access: scoped ? "scoped" : "all" })).status).toBe(200);
   };
   await add("admin", "admin");
   for (const k of ["head", "parentHead", "member", "be", "sales"]) await add(k, "member");

package/src/node-permissions.ts

@@ -257,7 +257,7 @@ export const NODE_TOOL_CLASS: Readonly<Record<string, ToolClass>> = {
   get_adopt_request: "always", ack_adopt_request: "always",
   send_desktop_message: "always", // 发给人的私信,不是派活
   // 读
-  get_all_status: "read", get_session_status: "read", get_task: "read", list_tasks: "read", get_completions: "read",
+  get_all_status: "read", get_session_status: "read", get_task: "read", list_tasks: "read", get_completions: "read", org_whoami: "read",
   list_skills: "read", get_skill: "read", list_host_supervisors: "read", list_network_secrets: "read", list_providers: "read",
   get_probe_results: "read", read_node_rules_file: "read", list_node_skills: "read", read_node_skill: "read", list_node_files: "read",
   read_node_file: "read", tail_node_logs: "read",

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/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;
+  }
+}