@sleep2agi/commhub-server 0.9.0-preview.13 → 0.9.0-preview.130

package/src/rename.ts

@@ -15,8 +15,10 @@
 import { randomUUID } from "crypto";
 import { db } from "./db";
 import { getUserNetworkRole, getNetworkMembers } from "./auth";
+import { canSeeAgent, isAgentRestricted } from "./agent-access";
 import { pushEvent } from "./push";
 import { eventBus } from "./event_bus";
+import { aliasControlCharacter, describeAliasControlCharacter } from "./node-alias-control";
 
 export interface RenameResult {
   ok: boolean;
@@ -24,6 +26,9 @@ export interface RenameResult {
   error?: string;
   code?: string;
   suggested?: string;
+  reason?: string;
+  char?: string;
+  message?: string;
 }
 
 export interface CanonicalAlias {
@@ -35,7 +40,8 @@ export interface CanonicalAlias {
 
 function hasWriteAccess(userId: string, networkId: string): boolean {
   const role = getUserNetworkRole(userId, networkId);
-  return !!role && role !== "viewer";
+  // 改名是对 Agent 的写操作;受限成员(只看授权 Agent 的成员)不能改。
+  return !!role && role !== "viewer" && !isAgentRestricted(userId, networkId);
 }
 
 // Resolve committed alias renames (old -> new), following short chains such
@@ -109,6 +115,17 @@ export function prepareRename(
 ): RenameResult {
   if (!hasWriteAccess(userId, networkId)) return { ok: false, error: "no write access to this network" };
   if (!oldAlias || !newAlias) return { ok: false, error: "old and new alias required" };
+  const control = aliasControlCharacter(newAlias);
+  if (control !== null) {
+    return {
+      ok: false,
+      code: "node_alias_invalid",
+      error: "node_alias_invalid",
+      reason: "control_character",
+      char: control,
+      message: `alias cannot contain control character ${describeAliasControlCharacter(control)}`,
+    };
+  }
   if (oldAlias === newAlias) return { ok: false, error: "old and new alias are identical" };
 
   // old-alias must exist as a session in this network
@@ -214,8 +231,11 @@ export function commitRename(userId: string, txnId: string): RenameResult {
   // without this it would never receive node.renamed (#84 SSE channel fix:
   // N站马 confirmed the dashboard listens on the user channel). All members get
   // it, not just the owner, since any member's dashboard should reflect the rename.
+  // 多用户 Agent 权限:受限成员只收到他被授权的那个 Agent 的改名(否则等于把 alias 广播给他)。
   for (const member of getNetworkMembers(txn.network_id)) {
-    if (member.username) pushEvent(member.username, renamedEvent, txn.network_id);
+    if (!member.username) continue;
+    if (!canSeeAgent(member.user_id, txn.network_id, { alias: txn.new_alias, nodeId: renamedNode?.node_id ?? null })) continue;
+    pushEvent(member.username, renamedEvent, txn.network_id);
   }
 
   return { ok: true, txn_id: txnId };

package/src/reply-target-derivation.test.ts

@@ -0,0 +1,96 @@
+// f015d9d6 根因隔离：admin(dashboard/人类) 发给「无 node_id 的 MCP 会话」的任务，
+// 其回执被 reply_target_mismatch 拒绝。
+//
+// 上报时给出的假设是「校验依赖投递绑定 ⇒ 任务还没真正 deliver 进会话时回执会被拒」。
+// 本文件把两个变量分开量，一次只动一个：
+//   变量 1 = 任务是否已投递（status created vs delivered，有无 SSE 订阅者）
+//   变量 2 = 调用方是否显式传 alias
+// 如果假设成立，变量 1 应当决定结果；如果 alias 推导才是决定因素，变量 2 才会。
+import { beforeEach, afterAll, describe, expect, test } from "bun:test";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { db } from "./db.js";
+import { registerTools } from "./tools.js";
+import { __resetSSEClientsForTest, createSSEStream } from "./push.js";
+
+const NET = "net_admin_reply_f015";
+const USER = "user_admin_reply_f015";
+const ADMIN = "admin-f015";           // 人类/dashboard 发起方，无 node
+const AGENT = "agent-mcp-f015";       // MCP 会话：sessions 行 node_id = NULL
+const AGENT_NODE = "node-agent-f015"; // token 绑定的 node（会话本身仍无 node_id）
+
+type ToolHandler = (args: any) => Promise<{ content: Array<{ type: "text"; text: string }> }>;
+
+function cleanup() {
+  __resetSSEClientsForTest();
+  for (const t of ["tasks", "inbox", "task_events", "sessions", "api_tokens", "nodes", "rename_txn"]) {
+    try { db.run(`DELETE FROM ${t} WHERE network_id = ?1`, [NET]); } catch {}
+  }
+  try { db.run("DELETE FROM network_members WHERE network_id = ?1", [NET]); } catch {}
+  try { db.run("DELETE FROM networks WHERE network_id = ?1", [NET]); } catch {}
+  try { db.run("DELETE FROM users WHERE user_id = ?1", [USER]); } catch {}
+}
+
+function seed() {
+  db.run("INSERT INTO users (user_id, username, password_hash, role, created_at) VALUES (?1, ?1, 'x', 'admin', datetime('now'))", [USER]);
+  db.run("INSERT INTO networks (network_id, network_name, owner_id, created_at) VALUES (?1, ?1, ?2, datetime('now'))", [NET, USER]);
+  db.run("INSERT INTO network_members (user_id, network_id, role, joined_at) VALUES (?1, ?2, 'owner', datetime('now'))", [USER, NET]);
+  db.run(
+    "INSERT INTO nodes (node_id, node_name, alias, network_id, hostname, config_snapshot, created_at, updated_at, lifecycle_state) VALUES (?1, ?2, ?2, ?3, 'host', '{}', datetime('now'), datetime('now'), 'active')",
+    [AGENT_NODE, AGENT, NET],
+  );
+  // 🔴 关键夹具属性：会话行 node_id 为 NULL —— 这正是 MCP 挂载的 claude-code 会话的形状
+  db.run(
+    "INSERT INTO sessions (resume_id, alias, status, node_id, network_id, updated_at, last_seen_at) VALUES (?1, ?2, 'idle', NULL, ?3, datetime('now'), datetime('now'))",
+    [`cc-n_${AGENT}`, AGENT, NET],
+  );
+  db.run(
+    "INSERT INTO api_tokens (token_id, token_hash, user_id, network_id, name, scope, bound_node_id) VALUES (?1, ?2, ?3, ?4, ?5, 'network', ?6)",
+    [`token-${AGENT}`, `hash-${AGENT}`, USER, NET, `node:${AGENT}`, AGENT_NODE],
+  );
+}
+
+function toolsFor(alias: string): Record<string, ToolHandler> {
+  const server = new McpServer({ name: "admin-reply-f015", version: "0" }) as any;
+  const tools: Record<string, ToolHandler> = {};
+  const original = server.tool.bind(server);
+  server.tool = (name: string, description: string, schema: any, handler: ToolHandler) => {
+    tools[name] = handler; return original(name, description, schema, handler);
+  };
+  registerTools(server, undefined, NET, USER, alias, true, `token-${alias}`);
+  return tools;
+}
+
+function parse(res: { content: Array<{ text: string }> }) { return JSON.parse(res.content[0].text); }
+
+/** 造一条 admin(人类) → AGENT 的任务；delivered 控制「是否已投递」这一个变量。 */
+function seedAdminTask(taskId: string, delivered: boolean) {
+  db.run(
+    `INSERT INTO tasks (task_id, from_name, from_node_id, to_name, to_node_id, content, status, priority, network_id, created_at)
+     VALUES (?1, ?2, NULL, ?3, NULL, 'ping', ?4, 'normal', ?5, datetime('now'))`,
+    [taskId, ADMIN, AGENT, delivered ? "delivered" : "created", NET],
+  );
+}
+
+describe("f015d9d6 — admin→无 node_id 的 MCP 会话，回执绑定", () => {
+  beforeEach(() => { cleanup(); seed(); });
+  afterAll(() => cleanup());
+
+  test("变量1：任务【未投递】+ 省略 alias（走 #1085 推导）⇒ 回执应当成功", async () => {
+    seedAdminTask("t-undelivered", false);
+    const r = parse(await toolsFor(AGENT).send_reply({ in_reply_to: "t-undelivered", text: "done", status: "completed" }));
+    expect(r).toEqual(expect.objectContaining({ ok: true }));
+  });
+
+  test("变量1 对照：任务【已投递且有 SSE 订阅者】+ 省略 alias ⇒ 同样成功", async () => {
+    seedAdminTask("t-delivered", true);
+    createSSEStream(AGENT, NET);
+    const r = parse(await toolsFor(AGENT).send_reply({ in_reply_to: "t-delivered", text: "done", status: "completed" }));
+    expect(r).toEqual(expect.objectContaining({ ok: true }));
+  });
+
+  test("变量2：显式传一个不等于任务发起方的 alias ⇒ reply_target_mismatch", async () => {
+    seedAdminTask("t-wrong-alias", true);
+    const r = parse(await toolsFor(AGENT).send_reply({ alias: "someone-else", in_reply_to: "t-wrong-alias", text: "done", status: "completed" }));
+    expect(r).toEqual(expect.objectContaining({ ok: false, error: "reply_target_mismatch" }));
+  });
+});

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/report-status-host-schema.test.ts

@@ -0,0 +1,235 @@
+// report_status 的 host 遥测 schema 必须接受 agent-node **声明会发**的 null。
+//
+// 来源不是推理，是 #1225 复现容器里量到的一次真崩：`--network none` 里
+// agent-node 一启动就死在
+//   MCP error -32602: Invalid input: expected string, received null at host.ip
+// 而 register() 是 `await callCommHub("report_status", …)` 且没有 catch ——
+// 于是**整个节点进程当场退出**，和 runtime 无关（opencode/claude/codex 一样）。
+//
+// 触发条件不是"容器"，是"这台机器没有非回环 IPv4"：
+// agent-node 的 firstNonInternalIPv4()（host-telemetry.ts:48-59）在那种机器上
+// 返回 null，而 HostTelemetry 的类型本来就写着 `ip: string | null`。
+//
+// 🔴 这里断言的是 **schema 本身**，不是 handler。直接调 handler 会绕过 zod ——
+//    而缺陷恰恰只存在于 zod 那一层，绕过去就永远绿。
+import { describe, expect, test } from "bun:test";
+import { z } from "zod";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { registerTools } from "./tools.js";
+
+function captureToolSchemas(): Record<string, any> {
+  const mcp = new McpServer({ name: "schema-probe", version: "0" }) as any;
+  const schemas: Record<string, any> = {};
+  const origTool = mcp.tool.bind(mcp);
+  mcp.tool = (name: string, desc: string, schema: any, handler: any) => {
+    schemas[name] = schema;
+    return origTool(name, desc, schema, handler);
+  };
+  registerTools(mcp, undefined, null, null, null, false, "tok_schema_probe");
+  return schemas;
+}
+
+const schemas = captureToolSchemas();
+
+describe("report_status host telemetry schema", () => {
+  test("前提：抓到的确实是 report_status 的 host 形状", () => {
+    expect(schemas.report_status).toBeTruthy();
+    expect(schemas.report_status.host).toBeTruthy();
+  });
+
+  test("🔴 host.ip = null 必须被接受（没有非回环 IPv4 的机器就是发 null）", () => {
+    const host = schemas.report_status.host;
+    const parsed = host.parse({ hostname: "boxy", ip: null });
+    expect(parsed.ip).toBeNull();
+  });
+
+  test("🔴 host.hostname = null 同样被接受（与 ip 同为字符串字段，一起对齐）", () => {
+    const host = schemas.report_status.host;
+    expect(host.parse({ hostname: null, ip: "10.0.0.2" }).hostname).toBeNull();
+  });
+
+  test("agent-node 那条完整心跳负载整体过 schema", () => {
+    // 形状抄自 agent-node/src/host-telemetry.ts 的 HostTelemetry：
+    // 没有网络、没有 /proc 时每一项都可能是 null。
+    const full = {
+      hostname: "unknown", ip: null,
+      cpu_load_1min: null, cpu_cores: null,
+      mem_total_gb: null, mem_used_gb: null, mem_avail_gb: null,
+      disk_total_gb: null, disk_used_gb: null, disk_avail_gb: null,
+    };
+    expect(() => schemas.report_status.host.parse(full)).not.toThrow();
+  });
+
+  test("放宽的只有 null —— 类型错的值仍然被拒", () => {
+    const host = schemas.report_status.host;
+    expect(() => host.parse({ ip: 12345 })).toThrow();
+    expect(() => host.parse({ ip: "x".repeat(201) })).toThrow();
+  });
+
+  test("整条 report_status 负载（不只是 host 子对象）也接受 ip=null", () => {
+    const full = z.object(schemas.report_status);
+    expect(() => full.parse({
+      resume_id: "probe-resume", alias: "probe-node", status: "idle",
+      host: { hostname: "unknown", ip: null },
+    })).not.toThrow();
+  });
+});
+
+/* #1545 —— `create_capability_observed_ms_ago` 的**验证宽度**本身就是判据。
+ *
+ * 这一格是纯诊断信息(那个 can_create_nodes 是多久以前测出来的)。zod 对象里
+ * 任何一个**已知字段**验证失败,整份 report_status 都会被拒 —— 不是丢掉这一格。
+ * 所以给它加 `.int()/.min()/.max()` 等于:一台节点发了个奇怪的诊断数字,
+ * 就在 hub 上整个失联。**#1225/#1498 已经用 host.ip 演过一遍这件事了。**
+ *
+ * 消毒在读取处(`/api/host-supervisors`),不在这里。 */
+describe("#1545 create_capability_observed_ms_ago —— schema 必须收得宽", () => {
+  const caps = () => schemas.report_status.config_snapshot;
+
+  test("前提:抓到的确实是 config_snapshot 形状,且它接受 daemon_capabilities", () => {
+    expect(caps()).toBeTruthy();
+    const parsed = caps().parse({
+      flags: {}, config_update_capable: false, peer_reply_inbox_capable: true,
+      daemon_capabilities: { can_create_nodes: true },
+    });
+    expect(parsed.daemon_capabilities.can_create_nodes).toBe(true);
+  });
+
+  test("正常值:透传", () => {
+    const parsed = caps().parse({
+      flags: {}, config_update_capable: false, peer_reply_inbox_capable: true,
+      daemon_capabilities: { can_create_nodes: true, create_capability_observed_ms_ago: 0 },
+    });
+    expect(parsed.daemon_capabilities.create_capability_observed_ms_ago).toBe(0);
+  });
+
+  test("null 必须被接受(显式「我没测过」和「我不发这一格」都要能表达)", () => {
+    const parsed = caps().parse({
+      flags: {}, config_update_capable: false, peer_reply_inbox_capable: true,
+      daemon_capabilities: { can_create_nodes: true, create_capability_observed_ms_ago: null },
+    });
+    expect(parsed.daemon_capabilities.create_capability_observed_ms_ago).toBeNull();
+  });
+
+  /* 🔴 这四个值**一个都不许让整份 report 被拒**。它们在读取侧会被当成「没报」,
+   *    但那是读取侧的事 —— 这一层的职责只有一个:别把节点踢下线。 */
+  test.each([
+    ["负数", -1],
+    ["非整数", 1234.5678],
+    ["超过一年", 400 * 24 * 60 * 60 * 1000],
+    ["NaN", Number.NaN],
+  ])("怪值不得拒掉整份 report_status:%s", (_label, value) => {
+    expect(() => caps().parse({
+      flags: {}, config_update_capable: false, peer_reply_inbox_capable: true,
+      daemon_capabilities: { can_create_nodes: false,
+        create_nodes_blocked_reason: "anet_bin_source",
+        create_capability_observed_ms_ago: value },
+    })).not.toThrow();
+  });
+
+  /* 🔴 反向锚:上面那组「不抛」如果只是因为**这个 key 压根没被 schema 看见**,
+   * 它们会一样绿。所以这里证明 schema 确实在看它:喂一个非数字,值必须**被改写成
+   * null**(而不是原样穿过去)。原样穿过去 = key 被忽略,那组测试就什么也没测。 */
+  test("反向锚:非数字被改写成 null(不是原样穿过)⇒ 证明 schema 确实在看这个 key", () => {
+    const parsed = caps().parse({
+      flags: {}, config_update_capable: false, peer_reply_inbox_capable: true,
+      daemon_capabilities: { can_create_nodes: true, create_capability_observed_ms_ago: "0" },
+    });
+    expect(parsed.daemon_capabilities.create_capability_observed_ms_ago).toBeNull();
+    expect(parsed.daemon_capabilities.create_capability_observed_ms_ago).not.toBe("0");
+  });
+});
+
+/* 🔴 #1545 —— 把 `host:` 上方那段方框注释里的表**钉住**。
+ *
+ * 那段注释说的是:这份 schema 的子对象一半 strict 一半不 strict,而「往里加一个
+ * hub 还不认识的键」的后果完全相反 —— 非 strict 静默丢弃(节点活着、字段蒸发),
+ * strict 拒掉整份 report(节点当场失联,#1225 的形状)。
+ *
+ * 注释会烂。这组测试的作用**不是禁止改 strict**(两种都各有其位),而是:谁改了,
+ * 谁就会在这里撞红,从而**被迫连注释一起改**。所以断言写成「和注释里那张表一致」,
+ * 而不是「必须是某个值」。 */
+describe("adoption_candidates ingest does not reject the heartbeat or keep secrets", () => {
+  const caps = () => schemas.report_status.config_snapshot;
+  const base = { flags: {}, config_update_capable: false, peer_reply_inbox_capable: true };
+
+  test("a clean row is kept, a bad sibling is dropped, and token keys are stripped", () => {
+    const parsed = caps().parse({ ...base, daemon_capabilities: { adopt_capable: true, adoption_candidates: [
+      { node_id: "n_ok", alias: "演示", workdir: "/tmp/proj", runtime: "claude-agent-sdk", launch_hint: "stopped", token: "ntok_supersecret" },
+      { node_id: "n_bad", alias: "x", workdir: "relative", launch_hint: "stopped" },
+      { node_id: "n_hint", alias: "y", workdir: "/tmp/y", launch_hint: "nope" },
+    ] } });
+    expect(parsed.daemon_capabilities.adoption_candidates.filter(Boolean)).toEqual([
+      { node_id: "n_ok", alias: "演示", workdir: "/tmp/proj", runtime: "claude-agent-sdk", launch_hint: "stopped" },
+    ]);
+    expect(JSON.stringify(parsed)).not.toContain("ntok_supersecret");
+  });
+
+  test("a non-array does not reject report_status and does not keep the payload", () => {
+    const parsed = caps().parse({ ...base, daemon_capabilities: { adopt_capable: true, adoption_candidates: { token: "ntok_supersecret" } } });
+    expect(parsed.daemon_capabilities.adoption_candidates).toBeUndefined();
+    expect(JSON.stringify(parsed)).not.toContain("ntok_supersecret");
+    expect(parsed.daemon_capabilities.adopt_capable).toBe(true);
+  });
+});
+
+describe("#1545 report_status 子对象的 strict 分布(注释里那张表的可执行副本)", () => {
+  const rs = () => schemas.report_status;
+  const UNKNOWN = { __hub_does_not_know_this_key__: 1 };
+
+  function acceptsUnknownKey(schema: any, base: object): "dropped" | "rejected" {
+    try {
+      const parsed = schema.parse({ ...base, ...UNKNOWN });
+      return "__hub_does_not_know_this_key__" in parsed ? "rejected" /* 不可能:留着说明它根本没被处理 */ : "dropped";
+    } catch { return "rejected"; }
+  }
+
+  const SIDE_THREAD = {
+    supported: true, runtime: "codex", runtimeVersion: "1.0",
+    topology: "native-exact-fork", evidenceRevision: "r1",
+  };
+  const SNAP_BASE = { flags: {}, config_update_capable: false, peer_reply_inbox_capable: true };
+
+  test.each([
+    ["host", () => rs().host, {}, "dropped"],
+    ["process_telemetry", () => rs().process_telemetry, {}, "dropped"],
+    ["config_snapshot", () => rs().config_snapshot, SNAP_BASE, "dropped"],
+    ["external_schedules", () => rs().external_schedules, { schedules: [] }, "rejected"],
+  ])("%s → 未知键被 %s", (_name, get, base, expected) => {
+    expect(acceptsUnknownKey(get(), base)).toBe(expected as string);
+  });
+
+  test("daemon_capabilities(嵌在 config_snapshot 里)→ 未知键被丢弃,不拒整份", () => {
+    const parsed: any = rs().config_snapshot.parse({
+      ...SNAP_BASE,
+      daemon_capabilities: { can_create_nodes: true, ...UNKNOWN },
+    });
+    expect(parsed.daemon_capabilities.can_create_nodes).toBe(true);
+    expect("__hub_does_not_know_this_key__" in parsed.daemon_capabilities).toBe(false);
+  });
+
+  test("side_thread_capability(同一个 config_snapshot 里)→ 未知键拒掉**整份**", () => {
+    expect(() => rs().config_snapshot.parse({
+      ...SNAP_BASE,
+      side_thread_capability: { ...SIDE_THREAD, ...UNKNOWN },
+    })).toThrow();
+    // 反向锚:去掉那个未知键必须过 —— 否则上面那条可能是被别的必填字段拒的,
+    // 和 strict 无关。
+    expect(() => rs().config_snapshot.parse({
+      ...SNAP_BASE, side_thread_capability: SIDE_THREAD,
+    })).not.toThrow();
+  });
+
+  /* 分母自证:上面这张表**两侧都有**。如果哪天全变成 dropped(或全 rejected),
+   * 那段注释描述的「不对称」就不存在了,而这条会先红。 */
+  test("这张表确实是不对称的(两种后果各至少一个)", () => {
+    const results = [
+      acceptsUnknownKey(rs().host, {}),
+      acceptsUnknownKey(rs().process_telemetry, {}),
+      acceptsUnknownKey(rs().config_snapshot, SNAP_BASE),
+      acceptsUnknownKey(rs().external_schedules, { schedules: [] }),
+    ];
+    expect(results.filter(r => r === "dropped").length).toBeGreaterThan(0);
+    expect(results.filter(r => r === "rejected").length).toBeGreaterThan(0);
+  });
+});