@sleep2agi/commhub-server 0.9.0-preview.101 → 0.9.0-preview.102

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sleep2agi/commhub-server",
-  "version": "0.9.0-preview.101",
+  "version": "0.9.0-preview.102",
   "description": "CommHub Server — AI Agent communication hub with MCP protocol, multi-network isolation, user auth, and MCP tools (17 collaboration-core + node/provider ops tools; authoritative list: docs-site/docs/api/mcp-tools.md).",
   "type": "module",
   "main": "src/index.ts",

package/src/agent-groups-perf.test.ts

@@ -4,8 +4,10 @@
 // 场景:NET 里 300 个节点;50 个组,每组 6 个节点(合起来覆盖全部 300 个)。
 //   baseline —— bob 直接授权这 300 个节点(没有组);
 //   groups   —— alice 授权这 50 个组(没有直接授权),可见集合与 bob 完全相同。
-// 两人看到的 Agent 一样多,差值就是「按组展开」本身的代价(交替量 15 轮,取每轮差值的中位数)。团队要求 ≈2 ms 以内(本机实测 −0.5~+1.9 ms);
+// 两人看到的 Agent 一样多,差值就是「按组展开」本身的代价。团队要求 ≈2 ms 以内(本机实测 −0.5~+1.9 ms);
 // 断言放宽到 max(5 ms, 基线的 15%)—— CI 容器比本机慢时两边一起变慢,绝对差也跟着放大。数字打印出来。
+// #517:差值怎么量见 lowDelta*() —— 交替且每轮翻转先后、样本 40 对、比两边的 p20(不是每轮差值的中位数)、
+// 一轮超标再重量最多 2 轮。界限本身(max(5 ms, 15%))没动。
 
 import { describe, expect, test, beforeAll, afterAll } from "bun:test";
 import { mkdtempSync, rmSync } from "fs";
@@ -30,10 +32,11 @@ const PER_GROUP = NODES / GROUPS;
 const BOUND_MS = 5;
 const bound = (base: number) => Math.max(BOUND_MS, base * 0.15);
 // CI 容器里一次 visibleAgents() 约 65 ms(本机约 28 ms):原来 40 次 × 两边再加预热,顶破了 bun 默认的 5 s 单测超时(#2131 CI 实测)。
-// 15 次取中位数足够稳;性能用例另给显式超时。
+// 性能用例另给显式超时(差值守卫最坏 3 轮 × 40 对,见 lowDelta)。
 const WARMUP = 3;
-const ITER = 15;
 const PERF_TIMEOUT_MS = 60_000;
+// #517 差值守卫:每轮 DELTA_PAIRS 对、比两边的 LOW_P 分位、超标再量最多 RETRIES 轮。
+const DELTA_PAIRS = 40, LOW_P = 0.2, RETRIES = 2;
 
 const json = (token: string) => ({ Authorization: `Bearer ${token}`, "Content-Type": "application/json" });
 async function send(token: string, method: string, path: string, payload?: unknown) {
@@ -56,15 +59,46 @@ function pairedDelta(a: () => void, b: () => void, n: number): { a: number; b: n
   }
   return { a: median(as), b: median(bs), delta: median(ds) };
 }
-async function pairedDeltaAsync(a: () => Promise<void>, b: () => Promise<void>, n: number): Promise<{ a: number; b: number; delta: number }> {
-  for (let i = 0; i < WARMUP; i++) { await a(); await b(); }
-  const as: number[] = [], bs: number[] = [], ds: number[] = [];
-  for (let i = 0; i < n; i++) {
-    let t = performance.now(); await a(); const ta = performance.now() - t;
-    t = performance.now(); await b(); const tb = performance.now() - t;
-    as.push(ta); bs.push(tb); ds.push(tb - ta);
+const pct = (xs: number[], p: number) => { const s = [...xs].sort((a, b) => a - b); return s[Math.min(s.length - 1, Math.floor(p * s.length))]; };
+type LowDelta = { a: number; b: number; delta: number; aP50: number; bP50: number; ok: boolean };
+/**
+ * #517 —— 「组授权比直接授权多出多少」的稳健量法。旧做法(15 对、每轮固定先 A 后 B、取每轮差值中位数)在 test638
+ * 两份 aggregate 并发时红过(本地 2 核 + 忙循环邻居实测 paired-delta 7.34 ms > 5 ms,同一轮两边中位数差出 10 ms)——
+ * 量的是负载,不是组展开。现在:
+ *   - 每轮翻转先后(偶数轮 A→B,奇数轮 B→A),「第二个总吃前一个的 GC / 调度」这类顺序偏差两边对半分;
+ *   - 每边 DELTA_PAIRS 个样本,比两边各自的 LOW_P 分位:调度噪声只会加时间,低尾最接近真实成本;
+ *   - 一轮超标就整轮重量,最多 RETRIES 次;真回归(组路径每节点多查一次,#2133 那种 N+1)每一轮都超。
+ */
+function lowDelta(a: () => void, b: () => void, bound: (base: number) => number): LowDelta {
+  let r: LowDelta | null = null;
+  for (let attempt = 0; attempt <= RETRIES; attempt++) {
+    for (let i = 0; i < WARMUP; i++) { a(); b(); }
+    const as: number[] = [], bs: number[] = [];
+    for (let i = 0; i < DELTA_PAIRS; i++) {
+      const time = (f: () => void) => { const t = performance.now(); f(); return performance.now() - t; };
+      if (i % 2 === 0) { as.push(time(a)); bs.push(time(b)); } else { bs.push(time(b)); as.push(time(a)); }
+    }
+    const lowA = pct(as, LOW_P), lowB = pct(bs, LOW_P);
+    r = { a: lowA, b: lowB, delta: lowB - lowA, aP50: pct(as, 0.5), bP50: pct(bs, 0.5), ok: lowB - lowA <= bound(lowA) };
+    if (r.ok) return r;
   }
-  return { a: median(as), b: median(bs), delta: median(ds) };
+  return r!;
+}
+async function lowDeltaAsync(a: () => Promise<void>, b: () => Promise<void>, bound: (base: number) => number, label: string): Promise<LowDelta> {
+  let r: LowDelta | null = null;
+  for (let attempt = 0; attempt <= RETRIES; attempt++) {
+    for (let i = 0; i < WARMUP; i++) { await a(); await b(); }
+    const as: number[] = [], bs: number[] = [];
+    const time = async (f: () => Promise<void>) => { const t = performance.now(); await f(); return performance.now() - t; };
+    for (let i = 0; i < DELTA_PAIRS; i++) {
+      if (i % 2 === 0) { as.push(await time(a)); bs.push(await time(b)); } else { bs.push(await time(b)); as.push(await time(a)); }
+    }
+    const lowA = pct(as, LOW_P), lowB = pct(bs, LOW_P);
+    r = { a: lowA, b: lowB, delta: lowB - lowA, aP50: pct(as, 0.5), bP50: pct(bs, 0.5), ok: lowB - lowA <= bound(lowA) };
+    console.log(`[perf] ${label} pass ${attempt + 1}: p${LOW_P * 100} direct-300=${lowA.toFixed(2)}ms groups-50x6=${lowB.toFixed(2)}ms delta=${r.delta.toFixed(2)}ms bound=${bound(lowA).toFixed(2)}ms (p50 ${r.aP50.toFixed(2)} / ${r.bP50.toFixed(2)}) ${r.ok ? "ok" : "OVER"}`);
+    if (r.ok) return r;
+  }
+  return r!;
 }
 
 beforeAll(async () => {
@@ -123,8 +157,8 @@ describe("Agent 分组:性能守卫(50 组 × 300 节点)", () => {
   });
 
   test(`visibleAgents():组展开的额外开销 ≤ max(${BOUND_MS} ms, 基线 15%)(目标 ≈2 ms)`, () => {
-    const r = pairedDelta(() => { visibleAgents(bob.id, NET); }, () => { visibleAgents(alice.id, NET); }, ITER);
-    console.log(`[perf] visibleAgents median: direct-300=${r.a.toFixed(2)}ms groups-50x6=${r.b.toFixed(2)}ms paired-delta=${r.delta.toFixed(2)}ms bound=${bound(r.a).toFixed(2)}ms`);
+    const r = lowDelta(() => { visibleAgents(bob.id, NET); }, () => { visibleAgents(alice.id, NET); }, bound);
+    console.log(`[perf] visibleAgents p${LOW_P * 100}: direct-300=${r.a.toFixed(2)}ms groups-50x6=${r.b.toFixed(2)}ms delta=${r.delta.toFixed(2)}ms bound=${bound(r.a).toFixed(2)}ms (p50 ${r.aP50.toFixed(2)} / ${r.bP50.toFixed(2)})`);
     expect(r.delta).toBeLessThanOrEqual(bound(r.a));
   }, PERF_TIMEOUT_MS);
 
@@ -157,8 +191,7 @@ describe("Agent 分组:性能守卫(50 组 × 300 节点)", () => {
       const body = await r.json() as any;
       if ((body.sessions ?? []).length !== NODES) throw new Error(`expected ${NODES} sessions, got ${(body.sessions ?? []).length}`);
     };
-    const r = await pairedDeltaAsync(() => hit(bob.token), () => hit(alice.token), ITER);
-    console.log(`[perf] GET /api/status median: direct-300=${r.a.toFixed(2)}ms groups-50x6=${r.b.toFixed(2)}ms paired-delta=${r.delta.toFixed(2)}ms bound=${bound(r.a).toFixed(2)}ms`);
+    const r = await lowDeltaAsync(() => hit(bob.token), () => hit(alice.token), bound, "GET /api/status");
     expect(r.delta).toBeLessThanOrEqual(bound(r.a));
   }, PERF_TIMEOUT_MS);
 

package/src/report-status-handover-capabilities-http.test.ts

@@ -0,0 +1,124 @@
+// #550 — the sticky session capability flags (rules_file_capable / skills_capable /
+// files_capable / logs_capable) survive a session handover.
+//
+// report_status for an alias that already has a row under ANOTHER resume_id takes
+// the DELETE + INSERT handover path. That path carried registered_at and the
+// descriptive columns, but not the capability flags, so the new row started at
+// the column default 0 — although the flags are meant to be sticky (only ever set
+// to 1). Board #548: a production node's MCP channel reconnected under a new
+// resume_id and the rules-file / skills / files / logs doorbells went dark.
+//
+// Pinned through the real HTTP entrance (POST /mcp with the node's own token):
+//   1. flags set on resume A are still 1 after the same alias reports resume B
+//      without them — and after it switches back to A.
+//   2. only flags that were 1 are carried; a 0 is never promoted.
+//   3. a later report omitting the flags on the same resume_id still keeps them.
+//   4. a user token cannot report for the alias, so it cannot hand the flags to a
+//      session of its own.
+//
+// 跑法:cd server && COMMHUB_DB=/tmp/x.db bun test src/report-status-handover-capabilities-http.test.ts
+//       PG:COMMHUB_TEST_PG_URL=… COMMHUB_PG_EXPERIMENTAL=1(tests/test2123-hub-postgres-ladder 里注册)
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { mkdtempSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { createNetworkTokenForNode, register } from "./auth.js";
+import { db } from "./db.js";
+
+const dir = mkdtempSync(join(tmpdir(), "anet-handover-caps-"));
+const activeDbPath = process.env.COMMHUB_DB ?? (process.env.COMMHUB_TEST_PG_URL ? "postgres" : undefined);
+if (!activeDbPath) throw new Error("report-status-handover-capabilities requires COMMHUB_DB (or COMMHUB_TEST_PG_URL) before module import");
+
+const stamp = Date.now();
+let server: any;
+let base = "";
+let ownerToken = "", ownerId = "", NET = "";
+type Node = { alias: string; nodeId: string; token: string };
+const nodes: Record<string, Node> = {};
+
+async function tool(token: string, name: string, args: Record<string, unknown>) {
+  const res = await fetch(`${base}/mcp`, {
+    method: "POST",
+    headers: { Authorization: `Bearer ${token}`, "Content-Type": "application/json", Accept: "application/json, text/event-stream", "MCP-Protocol-Version": "2025-03-26" },
+    body: JSON.stringify({ jsonrpc: "2.0", id: 1, method: "tools/call", params: { name, arguments: args } }),
+  });
+  const raw = await res.text();
+  const data = raw.split("\n").filter((x) => x.startsWith("data:"));
+  const payload = data.length ? JSON.parse(data.at(-1)!.slice(5).trim()) : JSON.parse(raw);
+  const text = payload.result.content[0].text;
+  if (!text.startsWith("{")) throw new Error(`${name}: ${text}`);
+  return JSON.parse(text);
+}
+
+// resume_id is the sessions primary key — every alias below uses its own (cc-*-<nodeId>).
+const ALL_FLAGS = { rules_file_capable: true, skills_capable: true, files_capable: true, logs_capable: true };
+const report = (token: string, n: Node, resume: string, extra: Record<string, unknown> = {}) =>
+  tool(token, "report_status", { resume_id: resume, alias: n.alias, status: "idle", agent: "claude-code", network_id: NET, ...extra });
+
+type CapRow = { resume_id: string; rules_file_capable: number; skills_capable: number; files_capable: number; logs_capable: number };
+const capRows = (alias: string) =>
+  db.all<CapRow>(
+    "SELECT resume_id, rules_file_capable, skills_capable, files_capable, logs_capable FROM sessions WHERE alias = ?1 AND network_id = ?2",
+    alias, NET,
+  ).map((r) => ({
+    resume_id: r.resume_id,
+    rules_file_capable: Number(r.rules_file_capable), skills_capable: Number(r.skills_capable),
+    files_capable: Number(r.files_capable), logs_capable: Number(r.logs_capable),
+  }));
+
+beforeAll(async () => {
+  process.env.COMMHUB_UPLOADS_DIR = join(dir, "uploads");
+  process.env.HOST = "127.0.0.1";
+  const owner = register(`hcap_owner_${stamp}`, "HandoverCaps123!", undefined, "seed");
+  ownerToken = owner.token!; ownerId = owner.user!.user_id; NET = owner.network_id!;
+  for (const key of ["all", "some", "user"]) {
+    const alias = `hcap-${key}-${stamp}`;
+    const nodeId = `n_hcap_${key}_${stamp}`;
+    const minted = createNetworkTokenForNode(ownerId, NET, alias, nodeId);
+    expect(minted.ok).toBe(true);
+    nodes[key] = { alias, nodeId, token: minted.token! };
+  }
+  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 {}
+  try { rmSync(dir, { recursive: true, force: true }); } catch {}
+});
+
+describe("#550 sticky capability flags survive a resume_id handover", () => {
+  test("all four flags carry to the new resume_id, and back again", async () => {
+    const n = nodes.all!;
+    expect((await report(n.token, n, `cc-a-${n.nodeId}`, ALL_FLAGS)).ok).toBe(true);
+    expect(capRows(n.alias)).toEqual([{ resume_id: `cc-a-${n.nodeId}`, rules_file_capable: 1, skills_capable: 1, files_capable: 1, logs_capable: 1 }]);
+
+    // The channel reconnects under a new resume_id and reports WITHOUT the flags.
+    expect((await report(n.token, n, `cc-b-${n.nodeId}`)).ok).toBe(true);
+    expect(capRows(n.alias)).toEqual([{ resume_id: `cc-b-${n.nodeId}`, rules_file_capable: 1, skills_capable: 1, files_capable: 1, logs_capable: 1 }]);
+
+    // Same resume_id, flags omitted again (status-only report) — still sticky.
+    expect((await report(n.token, n, `cc-b-${n.nodeId}`)).ok).toBe(true);
+    expect(capRows(n.alias)[0]).toMatchObject({ rules_file_capable: 1, skills_capable: 1, files_capable: 1, logs_capable: 1 });
+
+    // Two reporters taking turns (agent-node + TUI MCP): switching back keeps them too.
+    expect((await report(n.token, n, `cc-a-${n.nodeId}`)).ok).toBe(true);
+    expect(capRows(n.alias)).toEqual([{ resume_id: `cc-a-${n.nodeId}`, rules_file_capable: 1, skills_capable: 1, files_capable: 1, logs_capable: 1 }]);
+  }, 20_000);
+
+  test("only flags that were 1 are carried — a 0 is never promoted", async () => {
+    const n = nodes.some!;
+    expect((await report(n.token, n, `cc-a-${n.nodeId}`, { rules_file_capable: true, logs_capable: true })).ok).toBe(true);
+    expect((await report(n.token, n, `cc-b-${n.nodeId}`)).ok).toBe(true);
+    expect(capRows(n.alias)).toEqual([{ resume_id: `cc-b-${n.nodeId}`, rules_file_capable: 1, skills_capable: 0, files_capable: 0, logs_capable: 1 }]);
+  }, 20_000);
+
+  test("a user token cannot report for the alias, so it cannot take over the flags", async () => {
+    const n = nodes.user!;
+    expect((await report(n.token, n, `cc-a-${n.nodeId}`, ALL_FLAGS)).ok).toBe(true);
+    const r = await report(ownerToken, n, `cc-hijack-${n.nodeId}`);
+    expect(r.ok).toBe(false);
+    expect(capRows(n.alias)).toEqual([{ resume_id: `cc-a-${n.nodeId}`, rules_file_capable: 1, skills_capable: 1, files_capable: 1, logs_capable: 1 }]);
+  }, 20_000);
+});

package/src/server.ts

@@ -83,6 +83,7 @@ import { SIDE_THREAD_FEATURE_FLAG, SideThreadCoordinator, SideThreadPortRegistry
 import { handleSideThreadHttpRequest } from "./side-thread-http.js";
 import { createProductionSideThreadTransport } from "./side-thread-production.js";
 import { parseHubTimestamp } from "./hub-timestamp";
+import { logTaskRejection } from "./task-rejection-log.js";
 
 const PORT = resolvePort(process.env.PORT);
 const HOST = process.env.HOST || "127.0.0.1";
@@ -3411,15 +3412,18 @@ return Bun.serve({
 
     // ── REST: send task ──
     if (url.pathname === "/api/task" && req.method === "POST") {
+      // #552 — every non-2xx below goes through reject() so it leaves one log line
+      // (status, error, user, requested alias/network/client_request_id; never token/text).
       let raw: unknown;
+      const reject = (res: Response) => logTaskRejection(res, restAuth?.username, raw);
       try {
         raw = await req.json();
       } catch {
-        return withCors(req, Response.json({ error: "invalid JSON" }, { status: 400 }));
+        return reject(withCors(req, Response.json({ error: "invalid JSON" }, { status: 400 })));
       }
       const parsed = TaskSchema.safeParse(raw);
       if (!parsed.success) {
-        return withCors(req, Response.json({ error: "invalid input", details: parsed.error.format() }, { status: 400 }));
+        return reject(withCors(req, Response.json({ error: "invalid input", details: parsed.error.format() }, { status: 400 })));
       }
       const body = parsed.data;
       let taskNetId: string | null = null;
@@ -3427,7 +3431,7 @@ return Bun.serve({
         taskNetId = restAuth.networkId;
       } else if (body.network_id) {
         if (restAuth && !isAdmin && !getUserNetworkRole(restAuth.userId, body.network_id)) {
-          return withCors(req, Response.json({ ok: false, error: "access denied to requested network" }, { status: 403 }));
+          return reject(withCors(req, Response.json({ ok: false, error: "access denied to requested network" }, { status: 403 })));
         }
         taskNetId = body.network_id;
       } else {
@@ -3436,34 +3440,34 @@ return Bun.serve({
           : null;
       }
       if (restAuth && !taskNetId) {
-        return withCors(req, Response.json({
+        return reject(withCors(req, Response.json({
           ok: false,
           error: "network_id_required",
           message: "network_id is required when the user token has zero or multiple network memberships",
-        }, { status: 400 }));
+        }, { status: 400 })));
       }
       // 多用户 Agent 权限:受限成员只能给授权且 can_message 的 Agent 发;
       // 目标不存在 / 没授权 / 只读授权 → 同一个 403,不留 alias 探测差异。发件人固定为自己的用户名。
       const restrictedSender = !!restAuth && !isAdmin && !restAuth.networkId && isAgentRestricted(restAuth.userId, taskNetId!);
       if (restrictedSender) {
         if (!canRestWriteNetworkAsHuman(restAuth, taskNetId, isAdmin)) {
-          return withCors(req, Response.json({ ok: false, error: "permission_denied" }, { status: 403 }));
+          return reject(withCors(req, Response.json({ ok: false, error: "permission_denied" }, { status: 403 })));
         }
         const restrictedTarget = resolveCanonicalAlias(taskNetId, body.alias).alias;
         const restrictedSession = db.get<{ node_id: string | null }>("SELECT node_id FROM sessions WHERE alias = ?1 AND network_id = ?2", restrictedTarget, taskNetId);
         if (!restrictedSession || !canMessageAgent(restAuth!.userId, taskNetId, { alias: restrictedTarget, nodeId: restrictedSession.node_id })) {
-          return withCors(req, Response.json({ ok: false, error: "agent_not_granted", message: "this agent has not been granted to you; ask a network admin" }, { status: 403 }));
+          return reject(withCors(req, Response.json({ ok: false, error: "agent_not_granted", message: "this agent has not been granted to you; ask a network admin" }, { status: 403 })));
         }
         if (typeof body.from === "string" && body.from.trim() && body.from.trim() !== restAuth!.username) {
-          return withCors(req, Response.json({ ok: false, error: "from_session_identity_mismatch", message: "restricted members always send as their own username" }, { status: 403 }));
+          return reject(withCors(req, Response.json({ ok: false, error: "from_session_identity_mismatch", message: "restricted members always send as their own username" }, { status: 403 })));
         }
         for (const raw of [(body as any).attachments, (body as any).meta?.attachments]) {
           if (restrictedMemberAttachmentsDenied(restAuth!.userId, restAuth!.username, taskNetId!, raw)) {
-            return withCors(req, Response.json({ ok: false, error: "attachment_not_accessible" }, { status: 403 }));
+            return reject(withCors(req, Response.json({ ok: false, error: "attachment_not_accessible" }, { status: 403 })));
           }
         }
       } else if (!canRestWriteNetwork(restAuth, taskNetId, isAdmin)) {
-        return withCors(req, Response.json({ ok: false, error: "permission_denied" }, { status: 403 }));
+        return reject(withCors(req, Response.json({ ok: false, error: "permission_denied" }, { status: 403 })));
       }
       const canonical = resolveCanonicalAlias(taskNetId, body.alias);
       const targetAlias = canonical.alias;
@@ -3471,17 +3475,17 @@ return Bun.serve({
         alias: targetAlias,
         nodeId: db.get<{ node_id: string | null }>("SELECT node_id FROM sessions WHERE alias = ?1 AND network_id = ?2", targetAlias, taskNetId)?.node_id ?? null,
       }));
-      if (nodeDenied) return nodeDenied;
+      if (nodeDenied) return reject(nodeDenied);
       const target = resolveRestDeliveryTarget(targetAlias, taskNetId);
       if (target.state === "not_found") {
-        return withCors(req, Response.json({
+        return reject(withCors(req, Response.json({
           ok: false,
           error: "alias_not_found",
           message: target.message,
           alias: targetAlias,
           queued: false,
           ...(canonical.renamed ? { renamed_from: body.alias, renamed_to: targetAlias } : {}),
-        }, { status: 404 }));
+        }, { status: 404 })));
       }
       // Identity binding, mirroring the MCP transport (tools.ts defaultFrom /
       // fromIdentityMismatchReply). Both transports resolve the same
@@ -3507,13 +3511,13 @@ return Bun.serve({
         requestedFrom: body.from,
       });
       if (!identity.ok) {
-        return withCors(req, Response.json({
+        return reject(withCors(req, Response.json({
           ok: false,
           error: identity.error,
           message: identity.message,
           token_alias: identity.tokenAlias,
           requested_from_session: identity.requestedFromSession,
-        }, { status: 403 }));
+        }, { status: 403 })));
       }
       const fromSession = identity.fromSession;
       const ttlSeconds = (body as any).ttl_seconds || 3600;
@@ -3528,7 +3532,7 @@ return Bun.serve({
       // size cap, etc.).
       const attachmentsResult = validateAttachments((body as any).attachments ?? (body as any).meta?.attachments);
       if (!attachmentsResult.ok) {
-        return withCors(req, Response.json({ ok: false, error: "bad_attachments", message: attachmentsResult.error }, { status: 400 }));
+        return reject(withCors(req, Response.json({ ok: false, error: "bad_attachments", message: attachmentsResult.error }, { status: 400 })));
       }
       const mergedMeta = attachmentsResult.attachments.length
         ? { ...((body as any).meta && typeof (body as any).meta === "object" ? (body as any).meta : {}), attachments: attachmentsResult.attachments }
@@ -3616,14 +3620,14 @@ return Bun.serve({
       {
         const lc = assertNodeActive(targetAlias, taskNetId ?? null);
         if (!lc.ok) {
-          return withCors(req, Response.json(lc, { status: 409 }));
+          return reject(withCors(req, Response.json(lc, { status: 409 })));
         }
       }
       // #460 — refuse dispatch to a node whose fresh health says a layer is down (409, same as the
       // lifecycle guard above). Unknown / stale health = allowed: old nodes keep working.
       {
         const hg = assertNodeHealthy(targetAlias, taskNetId ?? null, { force: body.force === true, forceAllowed: !restAuth?.networkId });
-        if (!hg.ok) return withCors(req, Response.json(hg, { status: 409 }));
+        if (!hg.ok) return reject(withCors(req, Response.json(hg, { status: 409 })));
       }
       // #500 step 2 — what is already queued on the target, read BEFORE this task is written (advice only, never blocks).
       const queueInfo = dispatchQueueInfo(targetAlias, taskNetId, target.session?.status, ttlSeconds);

package/src/task-queue-ahead-scale.test.ts

@@ -9,9 +9,9 @@
 //      the whole-table one is driven by the covering idx_tasks_created_queue (no task-row lookups), the alias list
 //      and the per-send count by idx_tasks_to_created;
 //   2. the cost, relative only (no absolute ms, so a slow runner can't fail it): the queue_depth statement is at most
-//      half the #2325 statement measured on the same DB in the same loop, and a full /api/status read (cache
-//      bypassed) with queue_depth is at most 50 % slower than the same read with it switched off (= the pre-#2325
-//      read), alternated request by request on the same server;
+//      half the #2325 statement measured on the same DB in the same loop; and, on the low percentile of alternated
+//      samples (#517), the statement costs at most half a full /api/status read (cache bypassed) without it, and that
+//      read with queue_depth is at most 50 % slower than with it switched off (= the pre-#2325 read);
 //   3. the counts are still right at that scale (stale `acked` rows are outside the 24 h window).
 //
 // 跑法:cd server && COMMHUB_DB=/tmp/x.db bun test src/task-queue-ahead-scale.test.ts
@@ -35,6 +35,8 @@ const RECENT = 1_900;         // created in the last 24 h
 const OPEN_EVERY = 30;        // 3 in every OPEN_EVERY recent tasks are still open (~190 of 1.9k; see the cost test)
 const HOT = "scale-node-7";   // most stuck rows land on this one (the per-send plan must not care)
 const N = 25;
+/** #517: A/B pairs per pass, the percentile compared, and how many extra passes a failing pass gets. */
+const AB_PAIRS = 60, LOW_P = 0.2, RETRIES = 2;
 /** The #2325 statement (bare columns): the in-test baseline the fixed query is measured against. */
 const SQL_2325 = `SELECT network_id, to_name, COUNT(*) AS n FROM tasks
   WHERE status IN ('created', 'delivered', 'acked', 'running') AND created_at >= datetime('now', '-86400 seconds')
@@ -170,34 +172,56 @@ describe.skipIf(PG)("#500 queue_depth at production scale (57k tasks, 31k stuck
       s0 = performance.now(); db.all(SQL_2325); const b = performance.now() - s0;
       if (i >= 3) { fixed.push(a); old.push(b); }
     }
-    // Full /api/status, cache bypassed, A/B request by request: queue_depth on vs off (off = the pre-#2325 read).
-    // Alternating (and flipping the order every iteration) keeps both arms in the same time window — the first
-    // version of this budget timed the statement and the read in separate loops and compared them, which a busy
-    // runner (test638 runs two aggregates at once) skews: CI saw 2.10 ms vs a 5.25 ms read and failed.
+    // Measured locally (this fixture, covering index): ≈ 0.15× (1.0 vs 6.5 ms); on the production copy 0.3 vs 55 ms.
+    const qP50 = pct(fixed, 0.5), oldP50 = pct(old, 0.5);
+    console.log(`[perf] queue_depth p50=${qP50.toFixed(2)}ms vs #2325 statement p50=${oldP50.toFixed(2)}ms`);
+    expect(qP50).toBeLessThanOrEqual(0.5 * oldP50);
+
+    // Second budget: queue_depth adds at most +50 % to a full /api/status read (cache bypassed) — the same read
+    // with it switched off is the pre-#2325 read. #517: the first version compared the p50 of `with` and `without`
+    // on a ~4 ms read and asserted the *difference*; under test638's concurrent aggregates a difference of two
+    // noisy p50s is mostly noise (CI #2355: statement 0.64 ms, yet with−without = 2.4 ms > 2.03 ms budget). Now:
+    //   - each pass alternates A/B request by request (order flipped every pair) and also times the bare
+    //     queue_depth statement between the reads, so all three series share one time window;
+    //   - it compares a low percentile (LOW_P) rather than the p50: scheduler noise only ever adds time, so the
+    //     lower tail is the closest a busy runner gets to the real cost;
+    //   - it asserts both what the comment claims — the statement's own cost ≤ 50 % of the read without it — and
+    //     the end-to-end with/without delta on the same low percentile;
+    //   - a failing pass is re-measured up to RETRIES more times; the real regression (the #2325 statement through
+    //     idx_tasks_status, 5–8× the fixed cost) fails every pass, noise does not.
     const cache = await import("./status-read-cache.js");
     cache.__setStatusCacheBypassForTest(true);
-    const on: number[] = [], off: number[] = [];
     const readOnce = async (depthOn: boolean) => {
       mod.__setQueueDepthOffForTest(!depthOn);
       const s0 = performance.now();
       await (await fetch(`${BASE}/api/status?network_id=${NET}`, { headers: { Authorization: `Bearer ${token}` } })).text();
       return performance.now() - s0;
     };
-    try {
-      for (let i = 0; i < 2 * N + 3; i++) {
+    const abPass = async () => {
+      const on: number[] = [], off: number[] = [], q: number[] = [];
+      for (let i = 0; i < AB_PAIRS + 3; i++) {
         const first = i % 2 === 0;
         const a = await readOnce(first), b = await readOnce(!first);
-        if (i >= 3) { (first ? on : off).push(a); (first ? off : on).push(b); }
+        mod.__setQueueDepthOffForTest(false);
+        const s0 = performance.now(); mod.queueDepthByNode(); const c = performance.now() - s0;
+        if (i >= 3) { (first ? on : off).push(a); (first ? off : on).push(b); q.push(c); }
+      }
+      const onLow = pct(on, LOW_P), offLow = pct(off, LOW_P), qLow = pct(q, LOW_P);
+      return { onLow, offLow, qLow, onP50: pct(on, 0.5), offP50: pct(off, 0.5),
+        okDirect: qLow <= 0.5 * offLow, okRead: onLow - offLow <= 0.5 * offLow };
+    };
+    let r: Awaited<ReturnType<typeof abPass>> | null = null;
+    try {
+      for (let attempt = 0; attempt <= RETRIES; attempt++) {
+        r = await abPass();
+        console.log(`[perf] pass ${attempt + 1}: p${LOW_P * 100} queue_depth=${r.qLow.toFixed(2)}ms; full /api/status (bypass) p${LOW_P * 100} with=${r.onLow.toFixed(2)}ms without=${r.offLow.toFixed(2)}ms (+${(100 * (r.onLow - r.offLow) / r.offLow).toFixed(0)}%); p50 with=${r.onP50.toFixed(2)}ms without=${r.offP50.toFixed(2)}ms; direct ${r.okDirect ? "ok" : "OVER"} read ${r.okRead ? "ok" : "OVER"}`);
+        if (r.okDirect && r.okRead) break;
       }
     } finally {
       mod.__setQueueDepthOffForTest(false);
       cache.__setStatusCacheBypassForTest(false);
     }
-    const qP50 = pct(fixed, 0.5), oldP50 = pct(old, 0.5), onP50 = pct(on, 0.5), offP50 = pct(off, 0.5);
-    console.log(`[perf] queue_depth p50=${qP50.toFixed(2)}ms vs #2325 statement p50=${oldP50.toFixed(2)}ms; full /api/status (bypass) p50 with=${onP50.toFixed(2)}ms without=${offP50.toFixed(2)}ms (+${(100 * (onP50 - offP50) / offP50).toFixed(0)}%) p90 with=${pct(on, 0.9).toFixed(2)}ms`);
-    // Measured locally (this fixture, covering index): ≈ 0.15× (1.0 vs 6.5 ms); on the production copy 0.3 vs 55 ms.
-    expect(qP50).toBeLessThanOrEqual(0.5 * oldP50);
-    // Why the budget is "vs the same read without queue_depth", and what it was measured at (2026-10-04):
+    // What the read budget was measured at (2026-10-04, p50s, before #517):
     //   production copy (VACUUM INTO of the live DB: 306 sessions, 57k tasks, 64 open in the last 24 h on 4 nodes),
     //   full /api/status p50, cache bypassed, 3 runs each —
     //     pre-#2325 10.5–11.3 ms · #2325 68–71 ms · first fix (idx_tasks_created + row lookups) 16.1–17.1 ms (+50 %,
@@ -205,7 +229,8 @@ describe.skipIf(PG)("#500 queue_depth at production scale (57k tasks, 31k stuck
     //   this fixture: +17–31 %. It is harsher than production: ~190 open tasks in the window spread over ~150 nodes
     //   (3× production's open count, ~38× its groups) and one-word session rows that make the rest of the read cheap.
     //   With the original 1-in-7 open share (813 open) it measured +55–62 % even with the covering index — the
-    //   GROUP BY over 300 groups, not the index. CI's 67 % (before the covering index) is consistent with that plus the separate-loop skew above.
-    expect(onP50 - offP50).toBeLessThanOrEqual(0.5 * offP50);
-  }, 60_000);
+    //   GROUP BY over 300 groups, not the index.
+    expect(r!.qLow).toBeLessThanOrEqual(0.5 * r!.offLow);
+    expect(r!.onLow - r!.offLow).toBeLessThanOrEqual(0.5 * r!.offLow);
+  }, 120_000);
 });

package/src/task-rejection-log-http.test.ts

@@ -0,0 +1,160 @@
+// #552 — every rejected REST POST /api/task leaves exactly one hub log line.
+//
+// Incident: a restricted member's app sends were refused and the hub log
+// showed nothing, so "never arrived" and "rejected" were indistinguishable.
+// Real Bun.serve on a private port + temp DB; console.log is captured around
+// each request. The line must carry status + error + user + requested
+// alias/network/client_request_id, and must NOT carry the bearer token or the
+// task text.
+
+import { describe, expect, test, beforeAll, afterAll } from "bun:test";
+import { mkdtempSync, rmSync } from "fs";
+import { join } from "path";
+import { tmpdir } from "os";
+import { register } from "./auth.js";
+import { db } from "./db.js";
+import { formatTaskRejection } from "./task-rejection-log.js";
+
+const DIR = mkdtempSync(join(tmpdir(), "anet-task-reject-log-"));
+let BASE = "";
+let hub: any = null;
+const PW = "RejectLogPassw0rd!x";
+let adminToken = "";
+let adminName = "";
+let NET = "";
+let aliceToken = "";
+const AGENT = { alias: "rejlog-agent", node: "node_rejlog" };
+const SECRET_TEXT = "TOP-SECRET-TASK-BODY-552";
+
+async function postTask(token: string | null, body: string): Promise<{ status: number; json: any; lines: string[] }> {
+  const lines: string[] = [];
+  const orig = console.log;
+  console.log = (...args: any[]) => { lines.push(args.map(String).join(" ")); };
+  try {
+    const headers: Record<string, string> = { "Content-Type": "application/json" };
+    if (token) headers.Authorization = `Bearer ${token}`;
+    const res = await fetch(`${BASE}/api/task`, { method: "POST", headers, body });
+    const text = await res.text();
+    let json: any = text;
+    try { json = JSON.parse(text); } catch {}
+    return { status: res.status, json, lines };
+  } finally {
+    console.log = orig;
+  }
+}
+const rejectedLines = (lines: string[]) => lines.filter(l => l.includes("→ /api/task →") && l.includes("REJECTED"));
+
+beforeAll(async () => {
+  process.env.COMMHUB_DB ||= join(DIR, "hub.db");
+  process.env.COMMHUB_UPLOADS_DIR = join(DIR, "uploads");
+  process.env.HOST = "127.0.0.1";
+
+  const admin = register(`rejlog_admin_${Date.now()}`, PW, undefined, "Admin");
+  expect(admin.ok).toBe(true);
+  adminToken = admin.token!;
+  adminName = admin.user!.username;
+  NET = admin.network_id!;
+  db.run("UPDATE users SET role = 'admin' WHERE user_id = ?1", [admin.user!.user_id]);
+  db.run(
+    `INSERT INTO nodes (node_id, node_name, alias, network_id, owner_user_id, updated_at) VALUES (?1, ?2, ?2, ?3, ?4, datetime('now'))`,
+    [AGENT.node, AGENT.alias, NET, admin.user!.user_id],
+  );
+  db.run(
+    `INSERT INTO sessions (resume_id, alias, node_id, status, network_id, updated_at, last_seen_at)
+     VALUES (?1, ?2, ?3, 'idle', ?4, datetime('now'), datetime('now'))`,
+    [`resume_${AGENT.node}`, AGENT.alias, AGENT.node, NET],
+  );
+
+  const mod: any = await import("./server.js");
+  hub = mod.bootServer({ port: 0, hostname: "127.0.0.1" });
+  BASE = `http://127.0.0.1:${hub.port}`;
+
+  // A restricted member (default agent_access='granted', zero grants) who also
+  // owns a personal network → two memberships, like the #552 app user.
+  const created = await fetch(`${BASE}/api/admin/users`, {
+    method: "POST",
+    headers: { Authorization: `Bearer ${adminToken}`, "Content-Type": "application/json" },
+    body: JSON.stringify({ username: "rejlog_alice", password: PW, network_id: NET, role: "member" }),
+  });
+  expect(created.status).toBe(200);
+  const login = await fetch(`${BASE}/api/auth/login`, {
+    method: "POST", headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ username: "rejlog_alice", password: PW }),
+  });
+  expect(login.status).toBe(200);
+  aliceToken = (await login.json() as any).token;
+}, 30_000);
+
+afterAll(() => {
+  try { hub?.stop?.(true); } catch {}
+  try { rmSync(DIR, { recursive: true, force: true }); } catch {}
+});
+
+function assertNoSecrets(line: string, token: string) {
+  expect(line).not.toContain(token);
+  expect(line).not.toContain(SECRET_TEXT);
+  expect(line).not.toContain("file_");
+}
+
+describe("#552 REST POST /api/task rejections are logged", () => {
+  test("alias_not_found (404): one line with status, error, user, alias, network, client_request_id", async () => {
+    const r = await postTask(adminToken, JSON.stringify({ alias: "no-such-agent", task: SECRET_TEXT, network_id: NET, meta: { client_request_id: "crid-552-a" } }));
+    expect(r.status).toBe(404);
+    expect(r.json.error).toBe("alias_not_found");
+    const lines = rejectedLines(r.lines);
+    expect(lines.length).toBe(1);
+    expect(lines[0]).toMatch(/^\[\d\d:\d\d:\d\d\] /);
+    expect(lines[0]).toContain(`${adminName} → /api/task → no-such-agent: REJECTED 404 alias_not_found`);
+    expect(lines[0]).toContain(`net=${NET}`);
+    expect(lines[0]).toContain("crid=crid-552-a");
+    assertNoSecrets(lines[0], adminToken);
+  });
+
+  test("network_id_required (400) for a member of two networks who omits network_id", async () => {
+    const r = await postTask(aliceToken, JSON.stringify({ alias: AGENT.alias, task: SECRET_TEXT }));
+    expect(r.status).toBe(400);
+    expect(r.json.error).toBe("network_id_required");
+    const lines = rejectedLines(r.lines);
+    expect(lines.length).toBe(1);
+    expect(lines[0]).toContain(`rejlog_alice → /api/task → ${AGENT.alias}: REJECTED 400 network_id_required (net=-)`);
+    assertNoSecrets(lines[0], aliceToken);
+  });
+
+  test("agent_not_granted (403) — the restricted-member case from #552", async () => {
+    const r = await postTask(aliceToken, JSON.stringify({ alias: AGENT.alias, task: SECRET_TEXT, network_id: NET, attachments: [{ file_id: "file_deadbeef" }] }));
+    expect(r.status).toBe(403);
+    expect(r.json.error).toBe("agent_not_granted");
+    const lines = rejectedLines(r.lines);
+    expect(lines.length).toBe(1);
+    expect(lines[0]).toContain(`rejlog_alice → /api/task → ${AGENT.alias}: REJECTED 403 agent_not_granted (net=${NET})`);
+    assertNoSecrets(lines[0], aliceToken);
+  });
+
+  test("invalid JSON (400) is logged with the user and '-' placeholders", async () => {
+    const r = await postTask(aliceToken, "{not json");
+    expect(r.status).toBe(400);
+    const lines = rejectedLines(r.lines);
+    expect(lines.length).toBe(1);
+    expect(lines[0]).toContain("rejlog_alice → /api/task → -: REJECTED 400 invalid JSON (net=-)");
+  });
+
+  test("a successful send logs no REJECTED line", async () => {
+    const r = await postTask(adminToken, JSON.stringify({ alias: AGENT.alias, task: "hello", network_id: NET }));
+    expect(r.status).toBe(200);
+    expect(rejectedLines(r.lines).length).toBe(0);
+  });
+});
+
+describe("formatTaskRejection", () => {
+  test("request-supplied values cannot inject extra log lines and are clipped", () => {
+    const line = formatTaskRejection({
+      status: 404, error: "alias_not_found", username: null,
+      body: { alias: "evil\n[00:00:00] admin → forged", network_id: "n".repeat(200), meta: { client_request_id: "x\r\ny" } },
+    });
+    expect(line).not.toContain("\n");
+    expect(line).not.toContain("\r");
+    expect(line).toContain("anon → /api/task → evil [00:00:00] admin → forged: REJECTED 404 alias_not_found");
+    expect(line).toContain(`net=${"n".repeat(64)}…`);
+    expect(line).toContain("crid=x y");
+  });
+});

package/src/task-rejection-log.ts

@@ -0,0 +1,49 @@
+// #552 — one log line for every non-2xx answer from REST POST /api/task.
+//
+// A restricted member's app sends were rejected and the hub log showed
+// nothing, so "the request never arrived" and "the hub refused it" looked
+// identical from the server side. Every rejection branch now goes through
+// logTaskRejection().
+//
+// What is logged is deliberately narrow: status, error code, the
+// authenticated username, and the *requested* alias / network_id /
+// client_request_id. Never the bearer token, the task text, or attachment
+// ids. Request-supplied values are clipped and stripped of control
+// characters so a client cannot forge extra log lines.
+
+function ts(): string {
+  return new Date().toTimeString().slice(0, 8);
+}
+
+function clip(value: unknown, max = 64): string {
+  if (typeof value !== "string" || !value) return "-";
+  const clean = value.replace(/[\u0000-\u001f\u007f\s]+/g, " ").trim();
+  if (!clean) return "-";
+  return clean.length > max ? `${clean.slice(0, max)}…` : clean;
+}
+
+export interface TaskRejectionContext {
+  status: number;
+  error: unknown;
+  username: string | null | undefined;
+  /** The raw request body (or null when it did not parse). Only alias, network_id and meta.client_request_id are read. */
+  body: unknown;
+}
+
+export function formatTaskRejection(ctx: TaskRejectionContext): string {
+  const b = ctx.body && typeof ctx.body === "object" ? (ctx.body as Record<string, any>) : {};
+  const meta = b.meta && typeof b.meta === "object" ? b.meta : {};
+  const crid = typeof meta.client_request_id === "string" ? ` crid=${clip(meta.client_request_id)}` : "";
+  return `[${ts()}] ${clip(ctx.username ?? "anon")} → /api/task → ${clip(b.alias)}: REJECTED ${ctx.status} ${clip(ctx.error)} (net=${clip(b.network_id)}${crid})`;
+}
+
+/** Logs one line for a non-2xx response and returns the response unchanged. */
+export async function logTaskRejection(res: Response, username: string | null | undefined, body: unknown): Promise<Response> {
+  if (res.status >= 200 && res.status < 300) return res;
+  let error: unknown = null;
+  try {
+    error = ((await res.clone().json()) as any)?.error;
+  } catch {}
+  console.log(formatTaskRejection({ status: res.status, error: error ?? "unknown", username: username || "anon", body }));
+  return res;
+}

package/src/tools.ts

@@ -1034,7 +1034,8 @@ export function registerTools(server: McpServer, clientIP?: string, enforceNetwo
           `SELECT tmux_name, server, ip, hostname, agent, project_dir, version, node_id, session_id, config_path,
                   channels, model, cpu_load_1min, cpu_cores, mem_total_gb, mem_used_gb, mem_avail_gb, disk_total_gb,
                   disk_used_gb, disk_avail_gb, process_rss_bytes, process_rss_mb, process_cpu_pct,
-                  process_uptime_seconds, process_in_flight_count, external_schedules, registered_at
+                  process_uptime_seconds, process_in_flight_count, external_schedules, registered_at,
+                  rules_file_capable, skills_capable, files_capable, logs_capable
              FROM sessions WHERE alias = ?1 AND resume_id != ?2 AND network_id = ?3
              ORDER BY updated_at DESC LIMIT 1`,
           effectiveAlias, resume_id, sessionNetId,
@@ -1104,6 +1105,26 @@ export function registerTools(server: McpServer, clientIP?: string, enforceNetwo
              handover.registered_at ?? null],
           );
         }
+        // #550 — the sticky capability flags survive a session handover. The
+        // DELETE+INSERT above starts the new resume_id row at the column default
+        // (0), so a node whose MCP channel reconnected under a new resume_id lost
+        // its rules-file / skills / files / logs doorbell until it next reported
+        // the flag (board #548). Carry each flag that was 1 on the replaced row —
+        // only-ever-set-to-1, and under the same binding as setting it: a node
+        // token bound to this alias. Fixed statement, every parameter used (PG).
+        if (handover && callerTokenIsNetwork && callerAlias && callerAlias === effectiveAlias) {
+          db.run(
+            `UPDATE sessions SET
+               rules_file_capable = CASE WHEN ?2 = 1 THEN 1 ELSE rules_file_capable END,
+               skills_capable = CASE WHEN ?3 = 1 THEN 1 ELSE skills_capable END,
+               files_capable = CASE WHEN ?4 = 1 THEN 1 ELSE files_capable END,
+               logs_capable = CASE WHEN ?5 = 1 THEN 1 ELSE logs_capable END
+             WHERE resume_id = ?1`,
+            [resume_id,
+             Number(handover.rules_file_capable) === 1 ? 1 : 0, Number(handover.skills_capable) === 1 ? 1 : 0,
+             Number(handover.files_capable) === 1 ? 1 : 0, Number(handover.logs_capable) === 1 ? 1 : 0],
+          );
+        }
         // app#225 follow-up — separate statement on purpose: the INSERT above is
         // byte-pinned by test698's mutation harness. Sticky: only ever set to 1,
         // and only by a node token bound to this alias (a user token or another