@sleep2agi/commhub-server 0.9.0-preview.139 → 0.9.0-preview.140

package/src/hub-catalog-read-http.test.ts

@@ -0,0 +1,187 @@
+// #1473 (#909) — the Hub's Skills / secrets / Provider catalogs had MCP tools
+// but no HTTP read surface, so the desktop client shipped a fixture page
+// (agent-network-app/src/hub-scope-demo.ts: "Hub 这些写接口还没接通 ... 不发请求").
+//
+// These three endpoints are read-only and user-token only. The load-bearing
+// properties are:
+//   * a NODE token cannot enumerate the network's catalogs;
+//   * a plain member of another network cannot read this network's catalogs;
+//   * pending SkillHub submissions stay invisible unless the caller reviews;
+//   * NO secret value ever appears in a response body (asserted with a
+//     sentinel that would be trivially visible if a value were serialized).
+//
+// The sentinel test is deliberately byte-level on the raw response text: a
+// future field like `value_preview` would pass a JSON-shape assertion while
+// still leaking the secret.
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+const PRIVATE_DB_DIR = mkdtempSync(join(tmpdir(), "anet-hub-catalog-"));
+process.env.COMMHUB_DB ||= join(PRIVATE_DB_DIR, "hub.db");
+// The vault encrypts on write; set the master key before db.ts/vault.ts load.
+process.env.ANET_HUB_SECRET_VAULT_KEY ||= "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff";
+
+let server: ReturnType<typeof Bun.serve>;
+let base = "";
+let ownerToken = "", strangerToken = "", nodeToken = "";
+let ownerNet = "", strangerNet = "", ownerUserId = "";
+const SECRET_NAME = "PROVIDER_SENTINEL_KEY";
+const SECRET_VALUE = "sentinel-value-DO-NOT-LEAK-4f9a2c";
+
+const get = async (path: string, token: string) => {
+  const r = await fetch(`${base}${path}`, { headers: { Authorization: `Bearer ${token}` } });
+  const text = await r.text();
+  let body: any = null;
+  try { body = JSON.parse(text); } catch { body = null; }
+  return { status: r.status, body, text };
+};
+
+beforeAll(async () => {
+  const { db } = await import("./db.js");
+  const { register, createNetworkTokenForNode } = await import("./auth.js");
+  const { vaultUpsert } = await import("./vault.js");
+  const stamp = Date.now();
+
+  const owner = register(`hc_owner_${stamp}`, "HcOwner-Strong-1!");
+  const stranger = register(`hc_stranger_${stamp}`, "HcStranger-Strong-1!");
+  expect(owner.ok && stranger.ok).toBe(true);
+  ownerToken = owner.token!;
+  strangerToken = stranger.token!;
+  ownerNet = owner.network_id!;
+  strangerNet = stranger.network_id!;
+  ownerUserId = db.get<{ user_id: string }>("SELECT user_id FROM users WHERE username = ?1", `hc_owner_${stamp}`)!.user_id;
+
+  // A node token in the SAME network: it must still be refused, because a node
+  // is not a person and may not enumerate catalogs.
+  const nodeTok = createNetworkTokenForNode(ownerUserId, ownerNet, "hc-node", "n_hc_test");
+  expect(nodeTok.ok).toBe(true);
+  nodeToken = nodeTok.token!;
+
+  // Published + pending skills in the owner's network.
+  const skill = (id: string, status: string, slug: string) => db.run(
+    `INSERT INTO skillhub_skills (skill_id, network_id, slug, name, description, content, content_hash, version, status, source_type, source_alias, created_at, updated_at)
+     VALUES (?1, ?2, ?3, ?3, 'd', '# SKILL body', 'hash-' || ?1, '1.0.0', ?4, 'node', 'hc-node', datetime('now'), datetime('now'))`,
+    [id, ownerNet, slug, status],
+  );
+  skill("skill_hc_pub", "published", "hc-published");
+  skill("skill_hc_pending", "pending", "hc-pending");
+
+  // The sentinel secret. Names may be shown; values never.
+  vaultUpsert(ownerNet, SECRET_NAME, SECRET_VALUE);
+
+  db.run(
+    `INSERT INTO hub_provider_configs (network_id, provider_id, revision, config_json, secret_key_ref, updated_at)
+     VALUES (?1, 'hc-provider', 3, ?2, ?3, ?4)`,
+    [ownerNet, JSON.stringify({ id: "hc-provider", label: "HC Provider", enabled: true, protocol: "openai-responses", baseUrl: "https://example.test/v1", models: ["m1"] }), "HC_PROVIDER_KEY", Date.now()],
+  );
+
+  const mod = await import("./server.js");
+  server = mod.bootServer({ port: 0, hostname: "127.0.0.1" });
+  base = `http://127.0.0.1:${server.port}`;
+});
+
+afterAll(() => {
+  try { server?.stop(true); } catch {}
+  try { rmSync(PRIVATE_DB_DIR, { recursive: true, force: true }); } catch {}
+});
+
+describe("GET /api/skills", () => {
+  test("owner sees published skills and no content body", async () => {
+    const r = await get(`/api/skills?network_id=${ownerNet}`, ownerToken);
+    expect(r.status).toBe(200);
+    expect(r.body.ok).toBe(true);
+    expect(r.body.reviewer).toBe(true);
+    expect(r.body.network_id).toBe(ownerNet);
+    const slugs = r.body.skills.map((s: any) => s.slug);
+    expect(slugs).toContain("hc-published");
+    // Pending is opt-in even for a reviewer.
+    expect(slugs).not.toContain("hc-pending");
+    // The list is metadata only — a body field would mean SKILL.md text leaked.
+    for (const s of r.body.skills) expect(s.content).toBeUndefined();
+  });
+
+  test("reviewer may ask for pending submissions", async () => {
+    const r = await get(`/api/skills?network_id=${ownerNet}&include_pending=1`, ownerToken);
+    expect(r.status).toBe(200);
+    const slugs = r.body.skills.map((s: any) => s.slug);
+    expect(slugs).toContain("hc-pending");
+  });
+
+  test("a member of another network is refused", async () => {
+    const r = await get(`/api/skills?network_id=${ownerNet}`, strangerToken);
+    expect(r.status).toBe(403);
+    // Cross-network access is refused by REST scope resolution BEFORE the role
+    // check runs, so the error names the scope gate. Either way: 403, no data.
+    expect(String(r.body.error)).toMatch(/access denied|permission_denied/);
+  });
+
+  test("a node token is refused even inside its own network", async () => {
+    const r = await get(`/api/skills?network_id=${ownerNet}`, nodeToken);
+    expect(r.status).toBe(403);
+    expect(r.body.error).toBe("user_token_required");
+  });
+
+  test("include_pending is ignored for a non-reviewer of that network", async () => {
+    // The stranger's own network has no skills; the point is that asking for
+    // pending must not widen what they can see when they ask about their own.
+    const r = await get(`/api/skills?network_id=${strangerNet}&include_pending=1`, strangerToken);
+    expect(r.status).toBe(200);
+    expect(r.body.reviewer).toBe(true); // they own their own network
+    expect(r.body.skills).toEqual([]);
+  });
+});
+
+describe("GET /api/secrets", () => {
+  test("returns key names and timestamps, never the value", async () => {
+    const r = await get(`/api/secrets?network_id=${ownerNet}`, ownerToken);
+    expect(r.status).toBe(200);
+    const names = r.body.keys.map((k: any) => k.key);
+    expect(names).toContain(SECRET_NAME);
+    // <-- The load-bearing assertion: raw body text must not contain the value.
+    expect(r.text).not.toContain(SECRET_VALUE);
+    expect(r.text).not.toContain("ciphertext");
+    expect(r.text).not.toContain("iv");
+    expect(r.text).not.toContain("tag");
+  });
+
+  test("a member of another network is refused and learns no key names", async () => {
+    const r = await get(`/api/secrets?network_id=${ownerNet}`, strangerToken);
+    expect(r.status).toBe(403);
+    expect(r.text).not.toContain(SECRET_NAME);
+    expect(r.text).not.toContain(SECRET_VALUE);
+  });
+
+  test("a node token is refused", async () => {
+    const r = await get(`/api/secrets?network_id=${ownerNet}`, nodeToken);
+    expect(r.status).toBe(403);
+    expect(r.body.error).toBe("user_token_required");
+  });
+});
+
+describe("GET /api/providers", () => {
+  test("returns the registry without secret references", async () => {
+    const r = await get(`/api/providers?network_id=${ownerNet}`, ownerToken);
+    expect(r.status).toBe(200);
+    expect(r.body.providers).toHaveLength(1);
+    expect(r.body.providers[0]).toMatchObject({ id: "hc-provider", label: "HC Provider", source: "hub" });
+    // The vault key NAME is a hint an attacker does not need; `exposeRefs` is
+    // false here on purpose.
+    expect(r.body.providers[0].secret_key_ref).toBeUndefined();
+    expect(r.text).not.toContain("HC_PROVIDER_KEY");
+    expect(r.text).not.toContain(SECRET_VALUE);
+  });
+
+  test("a member of another network is refused", async () => {
+    const r = await get(`/api/providers?network_id=${ownerNet}`, strangerToken);
+    expect(r.status).toBe(403);
+    expect(r.text).not.toContain("hc-provider");
+  });
+
+  test("a node token is refused", async () => {
+    const r = await get(`/api/providers?network_id=${ownerNet}`, nodeToken);
+    expect(r.status).toBe(403);
+    expect(r.body.error).toBe("user_token_required");
+  });
+});

package/src/node-secret-rest-http.test.ts

@@ -0,0 +1,190 @@
+// #1491 E1 — the node-secret lane over REST.
+//
+// The lane itself is old (tools.ts `node_secret_*` → scoped-secrets.ts → node
+// doorbell → agent-node `reconcileNodeSecrets`). What was missing is **any way
+// for the client to drive it**: MCP-only, request/ack shaped. These two routes
+// are deliberately thin — enqueue, then poll — and the authorization stays in
+// the lane (owner/admin), not duplicated here.
+//
+// Load-bearing assertions:
+//   * a plain member of the network is refused (403), an owner gets through;
+//   * a node that does not advertise `node_secrets_capable` is a 409, not a
+//     silent queue entry that expires 120s later;
+//   * `put`/`delete` without a revision is a 400 (inventing 0 would clobber a
+//     file the operator edited in between);
+//   * the poll returns the node's snapshot once it acks — key NAMES and a
+//     revision only, never a value.
+import { afterAll, beforeAll, beforeEach, describe, expect, test } from "bun:test";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+const PRIVATE_DB_DIR = mkdtempSync(join(tmpdir(), "anet-nodesecret-rest-"));
+process.env.COMMHUB_DB ||= join(PRIVATE_DB_DIR, "hub.db");
+
+let server: ReturnType<typeof Bun.serve>;
+let base = "";
+let ownerToken = "", memberToken = "";
+let net = "", ownerId = "", memberId = "";
+const CAPABLE = "n_capable";
+const PLAIN = "n_plain";
+
+const post = async (path: string, token: string, body: unknown) => {
+  const r = await fetch(`${base}${path}`, {
+    method: "POST",
+    headers: { Authorization: `Bearer ${token}`, "Content-Type": "application/json" },
+    body: JSON.stringify(body),
+  });
+  return { status: r.status, body: await r.json() as any };
+};
+const get = async (path: string, token: string) => {
+  const r = await fetch(`${base}${path}`, { headers: { Authorization: `Bearer ${token}` } });
+  return { status: r.status, body: await r.json() as any };
+};
+
+beforeAll(async () => {
+  const { db } = await import("./db.js");
+  const { register, addNetworkMember } = await import("./auth.js");
+  const stamp = Date.now();
+
+  const owner = register(`ns_owner_${stamp}`, "NsOwner-Strong-1!");
+  const member = register(`ns_member_${stamp}`, "NsMember-Strong-1!");
+  expect(owner.ok && member.ok).toBe(true);
+  ownerToken = owner.token!;
+  memberToken = member.token!;
+  net = owner.network_id!;
+  ownerId = db.get<{ user_id: string }>("SELECT user_id FROM users WHERE username = ?1", `ns_owner_${stamp}`)!.user_id;
+  memberId = db.get<{ user_id: string }>("SELECT user_id FROM users WHERE username = ?1", `ns_member_${stamp}`)!.user_id;
+  // A plain member of the same network: must still be refused by the lane.
+  expect(addNetworkMember(net, memberId, "member").ok).toBe(true);
+
+  const seedNode = (nodeId: string, capable: boolean) => db.run(
+    `INSERT INTO nodes (node_id, node_name, alias, network_id, lifecycle_state, config_snapshot)
+     VALUES (?1, ?1, ?1, ?2, 'active', ?3)`,
+    [nodeId, net, JSON.stringify(capable ? { node_secrets_capable: true } : {})],
+  );
+  seedNode(CAPABLE, true);
+  seedNode(PLAIN, false);
+
+  const mod = await import("./server.js");
+  server = mod.bootServer({ port: 0, hostname: "127.0.0.1" });
+  base = `http://127.0.0.1:${server.port}`;
+});
+
+afterAll(() => {
+  try { server?.stop(true); } catch {}
+  try { rmSync(PRIVATE_DB_DIR, { recursive: true, force: true }); } catch {}
+});
+
+/** The lane allows ONE pending request per node. Every test starts from a clean
+ *  queue, otherwise ordering decides the outcome (the first version of this file
+ *  went red exactly that way: a `list` from an earlier test left the node busy). */
+async function drainPending() {
+  const { pullNodeSecrets, ackNodeSecrets } = await import("./scoped-secrets.js");
+  const daemon = { ok: true as const, networkId: net, daemonNodeId: CAPABLE, daemonAlias: CAPABLE };
+  const pulled = pullNodeSecrets(daemon);
+  const list = pulled && Array.isArray((pulled as any).requests) ? (pulled as any).requests : [];
+  for (const r of list) ackNodeSecrets(daemon, r.request_id, null, true);
+}
+
+beforeEach(async () => { await drainPending(); });
+
+describe("POST /api/nodes/:id/secrets", () => {
+  test("owner can enqueue a list request", async () => {
+    const r = await post(`/api/nodes/${CAPABLE}/secrets?network_id=${net}`, ownerToken, { action: "list" });
+    expect(r.status).toBe(200);
+    expect(r.body.ok).toBe(true);
+    expect(String(r.body.request_id)).toStartWith("nsk_");
+  });
+
+  test("a plain member of the same network is refused (403)", async () => {
+    const r = await post(`/api/nodes/${CAPABLE}/secrets?network_id=${net}`, memberToken, { action: "list" });
+    expect(r.status).toBe(403);
+    expect(r.body.error).toBe("secret_admin_required");
+  });
+
+  test("a node without node_secrets_capable is a 409, not a queued request", async () => {
+    const r = await post(`/api/nodes/${PLAIN}/secrets?network_id=${net}`, ownerToken, { action: "list" });
+    expect(r.status).toBe(409);
+    expect(r.body.error).toBe("node_secrets_upgrade_required");
+  });
+
+  test("put without a revision is a 400", async () => {
+    const r = await post(`/api/nodes/${CAPABLE}/secrets?network_id=${net}`, ownerToken, { action: "put", key: "A_KEY", value: "v" });
+    expect(r.status).toBe(400);
+    expect(r.body.error).toBe("revision_required");
+  });
+
+  test("an unknown action is a 400", async () => {
+    const r = await post(`/api/nodes/${CAPABLE}/secrets?network_id=${net}`, ownerToken, { action: "wipe" });
+    expect(r.status).toBe(400);
+    expect(r.body.error).toBe("invalid_action");
+  });
+
+  test("a second pending request on the same node is a 409 (secret_store_busy)", async () => {
+    // The previous test cases left requests pending; the lane allows one at a
+    // time per node. Drain by acking through the lane's own API.
+    const { ackNodeSecrets } = await import("./scoped-secrets.js");
+    const { db } = await import("./db.js");
+    const pending = db.all<any>("SELECT 1"); // no-op, keeps the import honest
+    expect(Array.isArray(pending)).toBe(true);
+    const first = await post(`/api/nodes/${CAPABLE}/secrets?network_id=${net}`, ownerToken, { action: "list" });
+    if (first.status === 200) {
+      const second = await post(`/api/nodes/${CAPABLE}/secrets?network_id=${net}`, ownerToken, { action: "list" });
+      expect(second.status).toBe(409);
+      expect(second.body.error).toBe("secret_store_busy");
+      // Clean up so the poll test below starts from a known state.
+      ackNodeSecrets(
+        { ok: true, networkId: net, daemonNodeId: CAPABLE, daemonAlias: CAPABLE },
+        first.body.request_id, { network_id: net, daemon_node_id: null, node_id: CAPABLE, revision: 1, activation: "next_start", keys: [] }, true,
+      );
+    } else {
+      expect(first.status).toBe(409);
+    }
+  });
+});
+
+describe("GET /api/nodes/:id/secrets/:request_id", () => {
+  test("poll returns the node's ack snapshot (names + revision)", async () => {
+    const { ackNodeSecrets } = await import("./scoped-secrets.js");
+    const created = await post(`/api/nodes/${CAPABLE}/secrets?network_id=${net}`, ownerToken, { action: "list" });
+    expect(created.status).toBe(200);
+    const rid = created.body.request_id as string;
+
+    // Before the node answers, the poll says pending.
+    const pending = await get(`/api/nodes/${CAPABLE}/secrets/${rid}?network_id=${net}`, ownerToken);
+    expect(pending.status).toBe(200);
+    expect(pending.body.status).toBe("pending");
+
+    // The node answers through its own lane call (same code path as the doorbell).
+    const acked = ackNodeSecrets(
+      { ok: true, networkId: net, daemonNodeId: CAPABLE, daemonAlias: CAPABLE },
+      rid,
+      { network_id: net, daemon_node_id: null, node_id: CAPABLE, revision: 2, activation: "next_start", keys: [{ key: "ALPHA_KEY", source: "node" }] },
+    );
+    expect(acked.ok).toBe(true);
+
+    const done = await get(`/api/nodes/${CAPABLE}/secrets/${rid}?network_id=${net}`, ownerToken);
+    expect(done.status).toBe(200);
+    expect(done.body.status).toBe("succeeded");
+    expect(done.body.snapshot.keys).toEqual([{ key: "ALPHA_KEY", source: "node" }]);
+    // Names only — no value field anywhere in the payload.
+    expect(JSON.stringify(done.body)).not.toContain("value");
+  });
+
+  test("a plain member cannot poll (403)", async () => {
+    const created = await post(`/api/nodes/${CAPABLE}/secrets?network_id=${net}`, ownerToken, { action: "list" });
+    const rid = created.status === 200 ? created.body.request_id : "nsk_missing";
+    if (created.status === 200) {
+      const { ackNodeSecrets } = await import("./scoped-secrets.js");
+      ackNodeSecrets({ ok: true, networkId: net, daemonNodeId: CAPABLE, daemonAlias: CAPABLE }, rid, null, true);
+    }
+    const r = await get(`/api/nodes/${CAPABLE}/secrets/${rid}?network_id=${net}`, memberToken);
+    expect(r.status).toBe(403);
+  });
+
+  test("an unknown request id is a 404", async () => {
+    const r = await get(`/api/nodes/${CAPABLE}/secrets/nsk_does_not_exist?network_id=${net}`, ownerToken);
+    expect(r.status).toBe(404);
+  });
+});

package/src/observer-avatar-http.test.ts

@@ -276,10 +276,21 @@ describe("#461 observer receives third-party traffic summaries", () => {
     await readFrame(reader); // connected
 
     const secret = `SECRET-TASK-CONTENT-${Date.now()}`;
+    const body = { alias: TARGET_ALIAS, task: secret, priority: "high", from: "third-party-sender", network_id: memberNetworkId };
+    // Human tokens send as their authenticated username; they cannot stand
+    // in for an Agent. Keep that refusal and exercise the observer with an
+    // actual bound sender token instead of weakening the identity contract.
+    const spoof = await fetch(`${BASE}/api/task`, {
+      method: "POST", headers: { ...auth(memberToken), "Content-Type": "application/json" }, body: JSON.stringify(body),
+    });
+    expect(spoof.status).toBe(403);
+    expect((await spoof.json() as any).error).toBe("from_session_identity_mismatch");
+    const sender = createNetworkTokenForNode(memberUserId, memberNetworkId, "third-party-sender", `node_obs_sender_${Date.now()}`);
+    expect(sender.ok).toBe(true);
     const dispatch = await fetch(`${BASE}/api/task`, {
       method: "POST",
-      headers: { ...auth(memberToken), "Content-Type": "application/json" },
-      body: JSON.stringify({ alias: TARGET_ALIAS, task: secret, priority: "high", from: "third-party-sender", network_id: memberNetworkId }),
+      headers: { ...auth(sender.token!), "Content-Type": "application/json" },
+      body: JSON.stringify(body),
     });
     expect([200, 202]).toContain(dispatch.status);
     const dispatched = await dispatch.json() as any;

package/src/report-status-resume-id-handover.test.ts

@@ -90,6 +90,11 @@ function rows(): Row[] {
   return db.all("SELECT resume_id, status, version, agent, hostname, cpu_cores, mem_total_gb, registered_at, task FROM sessions WHERE alias = ?1 AND network_id = ?2", [ALIAS, NET_ID]) as Row[];
 }
 
+type OsRow = { resume_id: string; os_user: string | null };
+function osRows(): OsRow[] {
+  return db.all("SELECT resume_id, os_user FROM sessions WHERE alias = ?1 AND network_id = ?2", [ALIAS, NET_ID]) as OsRow[];
+}
+
 describe("report_status: 同 alias 换 resume_id 时,描述性列从被替换的那行接手", () => {
   test("第二个上报者(grok-cli)不带 version/agent/遥测 → 这些列保留,status/task 以本次为准,仍只有一行", async () => {
     seed();
@@ -147,4 +152,33 @@ describe("report_status: 同 alias 换 resume_id 时,描述性列从被替换的
     expect(all[0]!.version).toBeNull();
     expect(all[0]!.registered_at).not.toBe(OLD_REGISTERED_AT);
   });
+
+  test("same resume_id stores os_user, and a later report that omits it keeps the value", async () => {
+    seed();
+    const tools = buildHandlers();
+    const set = await call(tools.report_status!, { resume_id: RESUME_SDK, alias: ALIAS, status: "working", os_user: "alice", network_id: NET_ID });
+    expect(set.ok, JSON.stringify(set)).toBe(true);
+    expect(osRows()).toEqual([{ resume_id: RESUME_SDK, os_user: "alice" }]);
+    const keep = await call(tools.report_status!, { resume_id: RESUME_SDK, alias: ALIAS, status: "idle", network_id: NET_ID });
+    expect(keep.ok, JSON.stringify(keep)).toBe(true);
+    expect(osRows()).toEqual([{ resume_id: RESUME_SDK, os_user: "alice" }]);
+  });
+
+  test("换 resume_id 且本次不带 os_user 时,从被替换的那行接手", async () => {
+    seed();
+    db.run("UPDATE sessions SET os_user = ?1 WHERE resume_id = ?2", ["alice", RESUME_SDK]);
+    const tools = buildHandlers();
+    const r = await call(tools.report_status!, { resume_id: RESUME_CLI, alias: ALIAS, status: "working", network_id: NET_ID });
+    expect(r.ok, JSON.stringify(r)).toBe(true);
+    expect(osRows()).toEqual([{ resume_id: RESUME_CLI, os_user: "alice" }]);
+  });
+
+  test("换 resume_id 且本次带了 os_user 时,以上报为准", async () => {
+    seed();
+    db.run("UPDATE sessions SET os_user = ?1 WHERE resume_id = ?2", ["alice", RESUME_SDK]);
+    const tools = buildHandlers();
+    const r = await call(tools.report_status!, { resume_id: RESUME_CLI, alias: ALIAS, status: "idle", os_user: "bob", network_id: NET_ID });
+    expect(r.ok, JSON.stringify(r)).toBe(true);
+    expect(osRows()).toEqual([{ resume_id: RESUME_CLI, os_user: "bob" }]);
+  });
 });

package/src/report-status-secret-keys.test.ts

@@ -0,0 +1,140 @@
+// #1474 (#909) — `report_status` accepts the NAMES of the env keys a node has.
+//
+// Called through a real MCP client (InMemoryTransport) rather than the raw
+// handler: the shape rules live in the tool's zod schema, and invoking the
+// handler directly bypasses them — the first version of this file "passed" a
+// `lower-case` key because no validation ran.
+//
+// Two behaviours are load-bearing:
+//   1. `[]` is a REAL report ("this node has no secrets") and must overwrite the
+//      stored list; only an ABSENT field keeps the previous value.
+//   2. A value accidentally placed in the array must be rejected at the
+//      boundary, not stored and later rendered.
+import { beforeEach, describe, expect, test } from "bun:test";
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { InMemoryTransport } from "@modelcontextprotocol/sdk/inMemory.js";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { db } from "./db.js";
+import { registerTools } from "./tools.js";
+
+const NET = "net_secret_keys";
+const USER = "u_secret_keys";
+const RESUME = "r_secret_keys";
+const ALIAS = "sk-node";
+
+type ToolResult = { content: Array<{ type: string; text?: string }>; isError?: boolean };
+
+async function connectClient() {
+  const server = new McpServer({ name: "secret-keys-test", version: "1" });
+  // report_status is a node heartbeat: the harness presents a NETWORK token.
+  registerTools(server, undefined, NET, USER, ALIAS, true, null);
+  const client = new Client({ name: "secret-keys-client", version: "1" });
+  const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
+  await server.connect(serverTransport);
+  await client.connect(clientTransport);
+  return client;
+}
+
+const report = (extra: Record<string, unknown> = {}) => ({
+  resume_id: RESUME, alias: ALIAS, status: "idle", network_id: NET, ...extra,
+});
+
+async function call(client: Client, args: Record<string, unknown>): Promise<{ ok: boolean; body: any }> {
+  const res = (await client.callTool({ name: "report_status", arguments: args })) as ToolResult;
+  const text = res.content[0]?.text;
+  if (!text) throw new Error("missing text tool result");
+  // A schema rejection comes back as a plain error string ("MCP error ..."),
+  // not JSON: that is exactly the boundary we want to observe.
+  let body: any;
+  try { body = JSON.parse(text); } catch { body = { error: text }; }
+  return { ok: res.isError !== true, body };
+}
+
+const stored = () =>
+  db.get<{ secret_keys: string | null }>("SELECT secret_keys FROM sessions WHERE resume_id = ?1", RESUME)?.secret_keys ?? null;
+
+beforeEach(() => {
+  db.run("INSERT OR IGNORE INTO users (user_id, username, password_hash, role, created_at) VALUES (?1, ?2, 'x', 'user', datetime('now'))", [USER, USER]);
+  db.run("INSERT OR IGNORE INTO networks (network_id, network_name, owner_id, created_at) VALUES (?1, ?1, ?2, datetime('now'))", [NET, USER]);
+  db.run("INSERT OR IGNORE INTO network_members (user_id, network_id, role, joined_at) VALUES (?1, ?2, 'owner', datetime('now'))", [USER, NET]);
+  db.run("DELETE FROM sessions WHERE resume_id = ?1", [RESUME]);
+  db.run(
+    `INSERT INTO sessions (resume_id, alias, status, network_id, updated_at, last_seen_at)
+     VALUES (?1, ?2, 'idle', ?3, datetime('now'), datetime('now'))`,
+    [RESUME, ALIAS, NET],
+  );
+});
+
+describe("report_status — secret key names", () => {
+  test("stores the names as a JSON array", async () => {
+    const client = await connectClient();
+    const r = await call(client, report({ secret_keys: ["ALPHA_KEY", "BETA_KEY"] }));
+    expect(r.body.ok).toBe(true);
+    expect(stored()).toBe(JSON.stringify(["ALPHA_KEY", "BETA_KEY"]));
+  });
+
+  test("an absent field keeps the previous list", async () => {
+    const client = await connectClient();
+    await call(client, report({ secret_keys: ["ALPHA_KEY"] }));
+    await call(client, report());
+    expect(stored()).toBe(JSON.stringify(["ALPHA_KEY"]));
+  });
+
+  test("an EMPTY array is a real report and clears the list", async () => {
+    const client = await connectClient();
+    await call(client, report({ secret_keys: ["ALPHA_KEY"] }));
+    await call(client, report({ secret_keys: [] }));
+    expect(stored()).toBe("[]");
+  });
+
+  test("a malformed name is rejected at the boundary and nothing is written", async () => {
+    const client = await connectClient();
+    await call(client, report({ secret_keys: ["ALPHA_KEY"] }));
+    const r = await call(client, report({ secret_keys: ["lower-case"] }));
+    expect(r.ok).toBe(false);
+    expect(stored()).toBe(JSON.stringify(["ALPHA_KEY"]));
+  });
+
+  test("more than 50 names is rejected", async () => {
+    const client = await connectClient();
+    const many = Array.from({ length: 51 }, (_, i) => `KEY_${String(i).padStart(3, "0")}`);
+    const r = await call(client, report({ secret_keys: many }));
+    expect(r.ok).toBe(false);
+    expect(stored()).toBeNull();
+  });
+
+  test("a value-shaped string is rejected (the field is a name list, not free text)", async () => {
+    const client = await connectClient();
+    const value = "ghp_" + "A".repeat(40);
+    const r = await call(client, report({ secret_keys: [value] }));
+    expect(r.ok).toBe(false);
+    expect(stored()).toBeNull();
+  });
+});
+
+// #1510 — the node reports how it reaches this hub; reporting only.
+describe("report_status — env_transport", () => {
+  test("stores the reported link kind", async () => {
+    const client = await connectClient();
+    const r = await call(client, report({ env_transport: "loopback" }));
+    expect(r.body.ok).toBe(true);
+    const row = db.get<{ env_transport: string | null }>("SELECT env_transport FROM sessions WHERE resume_id = ?1", RESUME);
+    expect(row?.env_transport).toBe("loopback");
+  });
+
+  test("an unknown value is rejected at the boundary", async () => {
+    const client = await connectClient();
+    const r = await call(client, report({ env_transport: "carrier-pigeon" }));
+    expect(r.ok).toBe(false);
+    const row = db.get<{ env_transport: string | null }>("SELECT env_transport FROM sessions WHERE resume_id = ?1", RESUME);
+    expect(row?.env_transport ?? null).toBeNull();
+  });
+
+  test("an absent field keeps the previous value", async () => {
+    const client = await connectClient();
+    await call(client, report({ env_transport: "https" }));
+    await call(client, report());
+    const row = db.get<{ env_transport: string | null }>("SELECT env_transport FROM sessions WHERE resume_id = ?1", RESUME);
+    expect(row?.env_transport).toBe("https");
+  });
+});

package/src/requirements-http.test.ts

@@ -373,7 +373,7 @@ describe("requirements stay on the hub", () => {
     expect((await api(ownerToken, path, { method: "PATCH", body: JSON.stringify({ due: "" }) })).body.requirement.due).toBe("");
     const listed = await api(ownerToken, "/api/requirements");
     expect(listed.body.capabilities).toContain("due_datetime");
-    expect(listed.body.capabilities).toEqual(["agent_owner", "description", "checklist", "projects", "due_datetime", "external_ref", "archived", "agent_api", "sub_requirements", "tags", "priority_lowest", "start_date", "requirement_seq", "search", "paging", "completed_at", "stats", "tag_ops", "list_summary", "changes", "events", "last_event", "column_abandoned"]);
+    expect(listed.body.capabilities).toEqual(["agent_owner", "description", "checklist", "projects", "due_datetime", "external_ref", "archived", "agent_api", "sub_requirements", "tags", "priority_lowest", "start_date", "requirement_seq", "search", "paging", "completed_at", "stats", "tag_status_snapshot", "tag_ops", "list_summary", "changes", "events", "last_event", "column_abandoned"]);
   });
 
   test("sub-requirements: parent_id in the same network, no cycles, ≤ 5 levels, child counts, filters, delete detaches children", async () => {

package/src/requirements-people.ts

@@ -17,7 +17,9 @@ type HiddenNode = ((nodeId: string) => boolean) | null;
 export const PEOPLE_DEFAULT_LIMIT = 50;
 export const PEOPLE_MAX_LIMIT = 200;
 
-export type DirectoryAgent = { node_id: string; alias: string };
+/** `department_id`: Agent 的**显式**部门归属(可空)。空 = 仍按「负责人在哪个部门」推断,
+ *  客户端据此把 Agent 放对格子 —— 2026-10-19 前没有这一列,328 个 Agent 只能全算「未归属」。 */
+export type DirectoryAgent = { node_id: string; alias: string; department_id?: string | null };
 export type DirectoryPerson = {
   user_id: string;
   username: string;
@@ -62,15 +64,17 @@ export function peopleDirectory(networkId: string, hidden: HiddenNode, query: {
       ORDER BY u.username, u.user_id`,
     networkId,
   );
-  const nodes = db.all<{ node_id: string; alias: string | null; node_name: string; owner_user_id: string | null }>(
-    "SELECT node_id, alias, node_name, owner_user_id FROM nodes WHERE network_id = ?1 ORDER BY COALESCE(alias, node_name), node_id",
+  const nodes = db.all<{ node_id: string; alias: string | null; node_name: string; owner_user_id: string | null; department_id: string | null }>(
+    "SELECT node_id, alias, node_name, owner_user_id, department_id FROM nodes WHERE network_id = ?1 ORDER BY COALESCE(alias, node_name), node_id",
     networkId,
   ).filter(n => !hidden?.(n.node_id));
   const memberIds = new Set(members.map(m => m.user_id));
   const byOwner = new Map<string, DirectoryAgent[]>();
   const unowned: DirectoryAgent[] = [];
   for (const n of nodes) {
-    const agent = { node_id: n.node_id, alias: n.alias || n.node_name };
+    // 只在**显式**归属时带这一格:没设 = 沿用「按负责人的部门推断」的老口径,
+    // 也保证旧客户端拿到的行形状不变(多一个键会让严格要求形状的测试/客户端意外)。
+    const agent = { node_id: n.node_id, alias: n.alias || n.node_name, ...(n.department_id ? { department_id: n.department_id } : {}) };
     if (n.owner_user_id && memberIds.has(n.owner_user_id)) {
       const list = byOwner.get(n.owner_user_id) ?? [];
       list.push(agent);

package/src/rest-projections.ts

@@ -53,6 +53,8 @@ export const SCHEDULED_TASK_STORAGE_COLUMNS = [
   "target_alias", "task_content", "priority", "schedule_type", "schedule_json",
   "timezone", "overlap_policy", "misfire_policy", "status", "next_run_at",
   "last_run_at", "revision", "created_at", "updated_at",
+  "no_change_backoff", "backoff_streak", "backoff_effective_seconds", "backoff_last_run_id",
+  "requirement_wake_json", "requirement_wake_cursor", "requirement_wake_last_event_id",
 ] as const;
 
 export function sqlColumns(columns: readonly string[], qualifier?: string): string {

package/src/schedule-agent.ts

@@ -140,7 +140,7 @@ export function agentUpdateSchedule(id: NodeIdentity, canWrite: boolean, schedul
   const denied = targetDenied(id, route, target);
   if (denied) return denied;
   try {
-    const patched = patchSchedule(row, { ...body, revision: body.revision ?? row.revision });
+    const patched = patchSchedule(row, { ...body, revision: body.revision ?? row.revision }, id.ownerUserId);
     return { ok: true, schedule: decodeRowForAgent(patched) };
   } catch (e) { return inputError(e); }
 }