@sleep2agi/commhub-server 0.9.0-preview.73 → 0.9.0-preview.75

package/src/route-timing.test.ts

@@ -0,0 +1,40 @@
+import { expect, test } from "bun:test";
+import { __resetRouteTimingForTest, recordRouteTiming, routeKey, routeStats, ROUTE_RING_SIZE } from "./route-timing";
+
+const u = (s: string) => new URL(`http://hub${s}`);
+
+test("routeKey collapses ids, aliases and file names, keeps payload-shaping params", () => {
+  expect(routeKey("GET", u("/api/requirements?network_id=net_1&limit=500"))).toBe("GET /api/requirements");
+  expect(routeKey("GET", u("/api/requirements?view=summary&network_id=n"))).toBe("GET /api/requirements?view=summary");
+  expect(routeKey("PATCH", u("/api/requirements/req_3f9a/checklist/c1"))).toBe("PATCH /api/requirements/:id/checklist/:id");
+  expect(routeKey("GET", u("/api/requirements/stats"))).toBe("GET /api/requirements/stats");
+  expect(routeKey("GET", u("/api/status?light=1"))).toBe("GET /api/status?light=1");
+  expect(routeKey("GET", u(`/api/nodes/${encodeURIComponent("通信牛")}/config`))).toBe("GET /api/nodes/:id/config");
+  expect(routeKey("GET", u("/api/messages?scope=user&limit=50"))).toBe("GET /api/messages?scope=user");
+});
+
+test("routeStats groups the window, sorts by total time, and the ring keeps only the newest samples", () => {
+  __resetRouteTimingForTest();
+  const now = 1_000_000;
+  const req = (path: string) => new Request(`http://hub${path}`);
+  const res = (status = 200, len?: number) => new Response("x", { status, headers: len === undefined ? {} : { "Content-Length": String(len) } });
+  const at = (ms: number) => performance.now() - ms;
+  recordRouteTiming(req("/api/requirements"), at(30), res(200, 1000), now);
+  recordRouteTiming(req("/api/requirements"), at(10), res(200, 500), now);
+  recordRouteTiming(req("/api/status?light=1"), at(5), res(503), now);
+  recordRouteTiming(req("/api/status?light=1"), at(100), res(), now - 10 * 60_000); // 窗口外
+  expect(recordRouteTiming(req("/ws"), 0, undefined, now)).toBeUndefined();
+  const stats = routeStats(60_000, now);
+  expect(stats.samples).toBe(3);
+  expect(stats.routes.map(r => r.route)).toEqual(["GET /api/requirements", "GET /api/status?light=1"]);
+  const r0 = stats.routes[0];
+  expect(r0.count).toBe(2);
+  expect(r0.bytes).toBe(1500);
+  expect(r0.max_ms).toBeGreaterThanOrEqual(29);
+  expect(r0.total_ms).toBeGreaterThanOrEqual(39);
+  expect(stats.routes[1].errors).toBe(1);
+  for (let i = 0; i < ROUTE_RING_SIZE + 10; i++) recordRouteTiming(req("/api/tasks"), at(1), res(), now);
+  const after = routeStats(60_000, now);
+  expect(after.samples).toBe(ROUTE_RING_SIZE);
+  expect(after.routes.map(r => r.route)).toEqual(["GET /api/tasks"]);
+});

package/src/route-timing.ts

@@ -0,0 +1,70 @@
+// 每个路由的耗时环(2026-09-30):生产 hub 平均 ~24% CPU,但没有任何按路由的计时,也没有访问日志,
+// 说不清是谁在吃 CPU。这里在 fetch 入口记最近 ROUTE_RING_SIZE 个请求(路由形状、耗时、状态、字节),
+// GET /api/stats/routes(管理员 / master)按时间窗汇总。只在内存里,重启清空;不记 query 值、不记调用者。
+export const ROUTE_RING_SIZE = 4096;
+
+type Sample = { at: number; route: string; ms: number; status: number; bytes: number | null };
+const ring: Sample[] = [];
+let next = 0;
+
+/** 路由的形状:id / 别名 / 文件名这类段换成 :id,几个会改变载荷形状的参数保留(light / view / scope / changes)。 */
+const SHAPE_PARAMS = ["changes", "light", "scope", "view"];
+export function routeKey(method: string, url: URL): string {
+  const segments = url.pathname.split("/").map((seg, i) => {
+    if (i < 2 || !seg) return seg;
+    return /[0-9%]/.test(seg) || /[^\x20-\x7e]/.test(seg) || seg.length > 24 ? ":id" : seg;
+  });
+  const shape = SHAPE_PARAMS.filter(k => url.searchParams.has(k)).map(k => `${k}=${url.searchParams.get(k)}`).join("&");
+  return `${method} ${segments.join("/")}${shape ? `?${shape}` : ""}`;
+}
+
+/** 记一次请求;原样返回 res,方便套在 fetch 处理器的 return 上。WebSocket 升级(res 为空)不记。 */
+export function recordRouteTiming<T extends Response | undefined>(req: Request, started: number, res: T, now: number = Date.now()): T {
+  if (!res) return res;
+  let url: URL;
+  try { url = new URL(req.url); } catch { return res; }
+  const length = Number(res.headers.get("content-length"));
+  const sample: Sample = { at: now, route: routeKey(req.method, url), ms: performance.now() - started, status: res.status, bytes: Number.isFinite(length) && res.headers.has("content-length") ? length : null };
+  if (ring.length < ROUTE_RING_SIZE) ring.push(sample);
+  else ring[next] = sample;
+  next = (next + 1) % ROUTE_RING_SIZE;
+  return res;
+}
+
+export type RouteStat = { route: string; count: number; total_ms: number; avg_ms: number; p95_ms: number; max_ms: number; bytes: number; errors: number };
+
+/** 最近 windowMs 内的样本按路由汇总,按总耗时降序。 */
+export function routeStats(windowMs: number, now: number = Date.now()): { window_ms: number; samples: number; oldest_at: string | null; routes: RouteStat[] } {
+  const since = now - windowMs;
+  const groups = new Map<string, Sample[]>();
+  let oldest: number | null = null;
+  for (const s of ring) {
+    if (s.at < since) continue;
+    if (oldest === null || s.at < oldest) oldest = s.at;
+    let g = groups.get(s.route);
+    if (!g) groups.set(s.route, g = []);
+    g.push(s);
+  }
+  const round = (n: number) => Math.round(n * 10) / 10;
+  const routes = [...groups].map(([route, samples]): RouteStat => {
+    const ms = samples.map(s => s.ms).sort((a, b) => a - b);
+    const total = ms.reduce((a, b) => a + b, 0);
+    return {
+      route,
+      count: samples.length,
+      total_ms: round(total),
+      avg_ms: round(total / samples.length),
+      p95_ms: round(ms[Math.min(ms.length - 1, Math.floor(ms.length * 0.95))]),
+      max_ms: round(ms[ms.length - 1]),
+      bytes: samples.reduce((n, s) => n + (s.bytes ?? 0), 0),
+      errors: samples.filter(s => s.status >= 500).length,
+    };
+  }).sort((a, b) => b.total_ms - a.total_ms);
+  return { window_ms: windowMs, samples: routes.reduce((n, r) => n + r.count, 0), oldest_at: oldest === null ? null : new Date(oldest).toISOString(), routes };
+}
+
+/** Test-only. */
+export function __resetRouteTimingForTest(): void {
+  ring.length = 0;
+  next = 0;
+}

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

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

package/src/server.ts

@@ -15,7 +15,8 @@ import { assertNodeActive } from "./lifecycle-guard.js";
 import { pendingInboxCount } from "./inbox-count.js";
 import { addAgentNetworkScope, addHumanNetworkScope, addNetworkScope, addOwnTrafficScope, canRestWriteNetwork, canRestWriteNetworkAsHuman, getUserNetworkIds, resolveRestNetworkScope, resolveRestWriteNetworkId, singleNetworkId, type RestNetworkScope } from "./network-scope.js";
 import { restrictedMemberSeesFile, restrictedMemberAttachmentsDenied } from "./restricted-files.js";
-import { listDmThread, listDmThreads, sendHumanDm } from "./human-dm.js";
+import { dmParticipantSeesFile, listDmThread, listDmThreads, sendHumanDm } from "./human-dm.js";
+import { getTaskAccessMode, isTaskScoped, listProjectGrants, replaceTaskGrants, NEW_MEMBER_TASK_ACCESS } from "./task-access.js";
 import { canMessageAgent, isAgentRestricted, listAgentGrants, listGroupGrants, getAgentAccessMode, replaceAgentGrants, restrictedNetworkIds, usernameIsAgentAlias, listAgentGroups, createAgentGroup, updateAgentGroup, replaceAgentGroupMembers, deleteAgentGroup, usersGrantedGroup } from "./agent-access.js";
 import { validateAvatarUrl } from "./avatar-validate.js";
 import { narrowTags, parseStoredTags, validateScalarAttr } from "./node-attrs-validate.js";
@@ -41,6 +42,7 @@ import {
   stripHostLocalPathsForCrossHostSafe,
   validateAttachments,
   validateIndexEntry,
+  DM_FILE_SCOPE,
 } from "./uploads.js";
 import { mkdirSync, writeFileSync, readFileSync, readdirSync, existsSync, statSync, unlinkSync, renameSync } from "fs";
 import { dirname as pathDirname, join as pathJoin } from "path";
@@ -59,6 +61,7 @@ import { stampTaskAuthOrigin, type TaskAuthOrigin } from "./task-auth-origin.js"
 import { diagnoseTask } from "./task-diagnostic.js";
 import { assertScheduledTaskBackendSupported, handleScheduledTaskRequest, startScheduledTaskScheduler } from "./scheduled-tasks.js";
 import { handleRequirementsRequest } from "./requirements.js";
+import { recordRouteTiming, routeStats } from "./route-timing.js";
 import { handleExternalScheduleEditRequest } from "./external-schedule-edits.js";
 import { recordDeliveredStaleEvents } from "./task-lifecycle-watcher.js";
 import { SIDE_THREAD_FEATURE_FLAG, SideThreadCoordinator, SideThreadPortRegistry, SideThreadStore, type SideThreadActor, type SideThreadAttachmentRef, type SideThreadExecutionPort } from "./side-thread.js";
@@ -385,15 +388,16 @@ export function resolvePrincipal(req: Request, options: RequestTokenOptions = {}
 // these two fields lives here and nowhere else, so the authz rules can be
 // read as rules rather than as string-checks.
 export function normalizeEntry(
-  entry: { owner_id?: unknown; network_id?: unknown },
-): { ownerId: string | null; networkId: string | null } {
+  entry: { owner_id?: unknown; network_id?: unknown; scope?: unknown },
+): { ownerId: string | null; networkId: string | null; dmScoped?: true } {
   const ownerId = typeof entry.owner_id === "string" && entry.owner_id.length > 0
     ? entry.owner_id
     : null;
   const networkId = typeof entry.network_id === "string" && entry.network_id.length > 0
     ? entry.network_id
     : null;
-  return { ownerId, networkId };
+  // dmScoped 只在是私信文件时出现:其余条目的形状与之前逐字相同。
+  return { ownerId, networkId, ...(entry.scope === DM_FILE_SCOPE ? { dmScoped: true as const } : {}) };
 }
 
 // #495/#503 — shared authorization gate for /api/files/:file_id downloads.
@@ -414,6 +418,13 @@ export function normalizeEntry(
 //     a task but not open its attachment is a broken product).
 //   - entry.network_id absent (legacy / unattributed) → the pre-#503
 //     rules stand unchanged: owner match, or null owner_id + DEV_OPEN.
+//   - entry.dmScoped (uploaded with ?purpose=dm — its first use is a
+//     human DM) → only the uploader and the users on either side of a DM
+//     that carries it (human-dm.ts dmParticipantSeesFile). Other members of
+//     the network and node tokens (agents) are denied. admin-utok and the
+//     legacy master token still pass above, as for every other file.
+//     Files uploaded any other way never become DM-scoped, including when
+//     they are later forwarded into a DM.
 //   - Everything else → deny (404). New uploads in production always
 //     carry a truthy owner_id (requireAuth blocks the null-owner-
 //     producing path when DEV_OPEN=off and no legacy master token is
@@ -428,7 +439,7 @@ export function normalizeEntry(
 // 所有文件在同一 network → 无实际影响, 但语义变更须明写, 不能悄悄发生.
 export function authorizeFileDownload(
   principal: Principal,
-  entry: { ownerId: string | null; networkId: string | null },
+  entry: { ownerId: string | null; networkId: string | null; dmScoped?: boolean },
   fileId?: string,
 ): boolean {
   if (principal.kind === "legacy-master") return true;
@@ -436,8 +447,13 @@ export function authorizeFileDownload(
 
   if (entry.networkId !== null) {
     if (principal.kind === "anonymous" || principal.kind === "dev-open-anon") return false;
-    if (principal.kind === "ntok") return principal.boundNetworkId === entry.networkId;
+    if (principal.kind === "ntok") return principal.boundNetworkId === entry.networkId && !entry.dmScoped;
     if (!getUserNetworkRole(principal.userId, entry.networkId)) return false;
+    // 私信文件:只看是不是这段私信里的人,与受限 / 不受限无关。
+    if (entry.dmScoped) {
+      if (entry.ownerId !== null && entry.ownerId === principal.userId) return true;
+      return !!fileId && dmParticipantSeesFile(principal.userId, entry.networkId, fileId);
+    }
     // 多用户 Agent 权限:受限成员只能下载自己传的,或者出现在自己与授权 Agent 往来 / 自己收件箱里的文件。
     if (!isAgentRestricted(principal.userId, entry.networkId)) return true;
     if (entry.ownerId !== null && entry.ownerId === principal.userId) return true;
@@ -888,7 +904,8 @@ return Bun.serve({
 
   async fetch(req, server) {
     // 2026-09-16 —— 所有 JSON/文本响应在客户端要求时 gzip(见 http-gzip.ts);SSE/流式/二进制原样。
-    return maybeGzipResponse(req, explainExpiredSession(req, await (async (): Promise<Response | undefined> => {
+    // 2026-09-30 —— 每个请求的路由形状 + 耗时进内存环(route-timing.ts),GET /api/stats/routes 看谁在吃 CPU。
+    return recordRouteTiming(req, performance.now(), await maybeGzipResponse(req, explainExpiredSession(req, await (async (): Promise<Response | undefined> => {
     const url = new URL(req.url, `http://localhost:${PORT}`);
 
     // ── CORS preflight ──
@@ -1548,6 +1565,51 @@ return Bun.serve({
     // ── 多用户 Agent 权限:成员可访问的 Agent(owner/admin 管理) ──
     // GET  → { agent_access: 'all'|'granted', grants: [{node_id, alias, can_message}] }
     // PUT  { grants?: [{node_id | alias, can_message?}] | string[], agent_access?: 'all'|'granted' } → 整体替换
+    // ── 任务(需求卡)的人员权限(RFC-038 §9):成员能看 / 能改哪些卡。owner/admin/Hub 管理员管理 ──
+    // GET  → { task_access: 'all'|'scoped', restricted, project_grants: [{project_id, can_edit}] }
+    // PUT  { task_access?, project_grants?: [{project_id, can_edit?}] | string[] } → 不传的字段保持原样;传了整体替换
+    const taskGrantsMatch = url.pathname.match(/^\/api\/networks\/([^/]+)\/members\/([^/]+)\/task-grants$/);
+    if (taskGrantsMatch && (req.method === "GET" || req.method === "PUT")) {
+      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 }));
+      if (resolved.networkId) return withCors(req, Response.json({ ok: false, error: "user_token_required" }, { status: 403 }));
+      const netId = decodeURIComponent(taskGrantsMatch[1]);
+      const targetUid = decodeURIComponent(taskGrantsMatch[2]);
+      const hubAdmin = resolved.user.role === "admin";
+      const callerRole = getUserNetworkRole(resolved.user.user_id, netId);
+      if (!hubAdmin && callerRole !== "owner" && callerRole !== "admin") {
+        return withCors(req, Response.json({ ok: false, error: "owner/admin required" }, { status: 403 }));
+      }
+      const targetRole = getUserNetworkRole(targetUid, netId);
+      if (!targetRole) return withCors(req, Response.json({ ok: false, error: "member_not_found" }, { status: 404 }));
+      const view = () => ({
+        ok: true, network_id: netId, user_id: targetUid, role: targetRole,
+        task_access: getTaskAccessMode(netId, targetUid), restricted: isTaskScoped(targetUid, netId),
+        project_grants: listProjectGrants(netId, targetUid),
+      });
+      if (req.method === "GET") return withCors(req, Response.json(view()));
+      // 网络 admin 不能改 owner / 其他 admin(对他们本来也不生效)。
+      if (!hubAdmin && callerRole !== "owner" && (targetRole === "owner" || targetRole === "admin")) {
+        return withCors(req, Response.json({ ok: false, error: "owner required" }, { status: 403 }));
+      }
+      let body: any;
+      try { body = await req.json(); } catch { return withCors(req, Response.json({ ok: false, error: "invalid JSON" }, { status: 400 })); }
+      if (!body || typeof body !== "object" || Array.isArray(body)) return withCors(req, Response.json({ ok: false, error: "invalid JSON" }, { status: 400 }));
+      if (body.task_access === undefined && body.project_grants === undefined) {
+        return withCors(req, Response.json({ ok: false, error: "task_access or project_grants required" }, { status: 400 }));
+      }
+      const before = { task_access: getTaskAccessMode(netId, targetUid), project_grants: listProjectGrants(netId, targetUid) };
+      const result = replaceTaskGrants({ networkId: netId, userId: targetUid, taskAccess: body.task_access, projectGrants: body.project_grants, actorUserId: resolved.user.user_id });
+      if (!result.ok) {
+        return withCors(req, Response.json({ ok: false, error: result.error, ...(result.detail ? { detail: result.detail } : {}) }, { status: result.status }));
+      }
+      logAudit(resolved.user.user_id, resolved.user.username, "member_task_grants_changed", "network", netId,
+        JSON.stringify({ user_id: targetUid, before, after: { task_access: result.task_access, project_grants: result.project_grants } }).slice(0, 4000),
+        undefined, netId);
+      return withCors(req, Response.json(view()));
+    }
+
     const grantsMatch = url.pathname.match(/^\/api\/networks\/([^/]+)\/members\/([^/]+)\/agent-grants$/);
     if (grantsMatch && (req.method === "GET" || req.method === "PUT")) {
       const token = requestToken(req, { allowQueryToken: false });
@@ -1648,8 +1710,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 }));
         }
-        const result = addNetworkMember(netId, body.user_id, body.role || "member", resolved.user.user_id, { agentAccess: body.agent_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 缺省 NEW_MEMBER_TASK_ACCESS(RFC-038 §9.4);显式传 '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);
         return withCors(req, Response.json(result, { status: result.ok ? 200 : 400 }));
       }
       if (req.method === "PUT" && targetUid) {
@@ -1657,7 +1723,7 @@ return Bun.serve({
         const body = await req.json() as any;
         const result = updateMemberRole(netId, targetUid, body.role);
         if (result.ok) {
-          logAudit(resolved.user.user_id, resolved.user.username, "member_role_changed", "network", netId, `${targetUid} → ${body.role}`);
+          logAudit(resolved.user.user_id, resolved.user.username, "member_role_changed", "network", netId, `${targetUid} → ${body.role}`, undefined, netId);
           closeUserStreamsInNetwork(netId, targetUid);
         }
         return withCors(req, Response.json(result, { status: result.ok ? 200 : 400 }));
@@ -1666,7 +1732,7 @@ return Bun.serve({
         if (!["owner", "admin"].includes(callerRole)) return withCors(req, Response.json({ ok: false, error: "owner/admin required" }, { status: 403 }));
         const result = removeNetworkMember(netId, targetUid);
         if (result.ok) {
-          logAudit(resolved.user.user_id, resolved.user.username, "member_removed", "network", netId, targetUid);
+          logAudit(resolved.user.user_id, resolved.user.username, "member_removed", "network", netId, targetUid, undefined, netId);
           closeUserStreamsInNetwork(netId, targetUid);
         }
         return withCors(req, Response.json(result, { status: result.ok ? 200 : 400 }));
@@ -2062,6 +2128,16 @@ return Bun.serve({
     });
     if (requirementsResponse) return withCors(req, requirementsResponse);
 
+    // ── REST: per-route timing (ops-only, same gate as /api/stats/sse) ──
+    // ?minutes=N(默认 15,最多 1440):最近 N 分钟里每个路由的次数、总耗时、p95、最大、字节。
+    if (url.pathname === "/api/stats/routes" && req.method === "GET") {
+      if (restAuth && !isAdmin) {
+        return withCors(req, Response.json({ ok: false, error: "admin or master token required" }, { status: 403 }));
+      }
+      const minutes = Math.min(Math.max(Number(url.searchParams.get("minutes")) || 15, 1), 1440);
+      return withCors(req, Response.json({ ok: true, ...routeStats(minutes * 60_000) }));
+    }
+
     // ── #473 REST: SSE connection detail (ops-only) ──
     // The per-key breakdown /health used to expose anonymously: keys are
     // `{networkId}:{alias}` (+ `\0netobs:{networkId}` observer keys via
@@ -2454,6 +2530,12 @@ return Bun.serve({
       // uploaded and never gets their multipart envelope parsed.
       const principal = resolvePrincipal(req);
       const requestedNetId = url.searchParams.get("network_id");
+      // ?purpose=dm:这个文件是为一条人与人私信传的(见 UploadIndexEntry.scope)。缺省 = 旧行为。
+      // 拼错的值拒掉,不静默当成缺省 —— 否则私信图会不声不响地变成全网可见。
+      const purpose = url.searchParams.get("purpose");
+      if (purpose !== null && purpose !== DM_FILE_SCOPE) {
+        return earlyReject(Response.json({ ok: false, error: "bad_purpose", message: `purpose must be "${DM_FILE_SCOPE}" or absent` }, { status: 400 }));
+      }
       let uploadNetId: string | null = null;
 
       switch (principal.kind) {
@@ -2630,6 +2712,7 @@ return Bun.serve({
             owner_id: authCtx?.userId ?? null,
             // Key omitted (not null) when unattributed — see UploadIndexEntry.
             ...(uploadNetId ? { network_id: uploadNetId } : {}),
+            ...(purpose === DM_FILE_SCOPE ? { scope: DM_FILE_SCOPE } : {}),
             uploaded_at: new Date().toISOString(),
           }, null, 2));
         } else {
@@ -4164,7 +4247,7 @@ Security: ${SECURITY_LABEL}
 `,
       { status: 200, headers: { "Content-Type": "text/plain; charset=utf-8" } }   // #426
     ));
-    })()));
+    })())));
   },
 
   // ── WebSocket handler for tmux terminal streaming ──