@sleep2agi/commhub-server 0.9.0-preview.106 → 0.9.0-preview.108

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sleep2agi/commhub-server",
-  "version": "0.9.0-preview.106",
+  "version": "0.9.0-preview.108",
   "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/api-host-supervisors-runtime-readiness.test.ts

@@ -0,0 +1,182 @@
+// #622 —— daemon 逐 runtime 自检(runtime_readiness)从 report_status 一路走到
+// /api/host-supervisors。三件事:
+//   1. report_status 的 zod 形状收得宽:坏的 runtime_readiness 只丢它自己,
+//      绝不拒掉整份 report(否则一台 daemon 发了个奇怪的诊断字段就在 hub 上失联);
+//   2. 新字段会被**保留**(daemon_capabilities 不是 strict,schema 里没声明的键会被
+//      静默剥掉 —— 不加 schema 就永远到不了 REST);
+//   3. REST 只在 daemon 报了时输出,旧 daemon 的行里**没有**这个键;
+//      can_create_nodes 语义不变。
+
+import { describe, expect, test, beforeAll, afterAll } from "bun:test";
+import "./require-explicit-test-db.js";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { register, login } from "./auth.js";
+import { db } from "./db.js";
+import { registerTools } from "./tools.js";
+import { sanitizeRuntimeReadiness } from "./runtime-readiness.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();
+const snapSchema = () => schemas.report_status.config_snapshot;
+const base = { flags: {}, config_update_capable: false, peer_reply_inbox_capable: true };
+
+const READY = {
+  ok: true, state: "ready", reason: "可以创建", version: "2.1.290",
+  checked_at: "2026-10-06T03:00:00.000Z", cli: "found", auth: "present", network: "reachable",
+};
+const MISSING = {
+  ok: false, state: "missing_cli", reason: "新节点的 PATH 上找不到可用的 grok 命令", checked_at: "2026-10-06T03:00:00.000Z",
+  cli: "missing", auth: "present", network: "skipped",
+};
+
+describe("#622 report_status schema —— runtime_readiness", () => {
+  test("合法值透传(没被 daemon_capabilities 的非 strict 剥掉)", () => {
+    const parsed = snapSchema().parse({ ...base, daemon_capabilities: {
+      can_create_nodes: true,
+      runtime_readiness: { "claude-code-cli": READY, "grok-build-acp": MISSING, "codex-sdk": { ...READY, shared_login_count: 27 } },
+    } });
+    expect(parsed.daemon_capabilities.runtime_readiness["claude-code-cli"].state).toBe("ready");
+    expect(parsed.daemon_capabilities.runtime_readiness["grok-build-acp"].state).toBe("missing_cli");
+    expect(parsed.daemon_capabilities.runtime_readiness["codex-sdk"].shared_login_count).toBe(27);
+    expect(parsed.daemon_capabilities.can_create_nodes).toBe(true);
+  });
+
+  test("🔴 坏形状绝不拒整份 report —— 只丢这一格", () => {
+    for (const bad of [
+      "string", 42, null, [], { x: "notobj" },
+      Object.fromEntries(Array.from({ length: 40 }, (_, i) => [`rt${i}`, READY])),
+    ]) {
+      const parsed = snapSchema().parse({ ...base, daemon_capabilities: { can_create_nodes: true, runtime_readiness: bad } });
+      expect(parsed.daemon_capabilities.can_create_nodes).toBe(true);
+      expect(parsed.daemon_capabilities.runtime_readiness).toBeUndefined();
+    }
+  });
+
+  test("单个字段坏:schema 不拒整份;读取侧消毒把它兜成 unknown", () => {
+    const parsed = snapSchema().parse({ ...base, daemon_capabilities: {
+      can_create_nodes: true,
+      runtime_readiness: { a: { ok: "yes", state: 7, reason: "x".repeat(5000), shared_login_count: -3 } },
+    } });
+    expect(parsed.daemon_capabilities.can_create_nodes).toBe(true);
+    const a = sanitizeRuntimeReadiness(parsed.daemon_capabilities.runtime_readiness)!.a;
+    expect(a.ok).toBe(false);
+    expect(a.state).toBe("unknown");
+    expect(a.reason.length).toBe(600);
+    expect(a.shared_login_count).toBeUndefined();
+  });
+
+  test("总字节超 16 KB:整格丢掉(异常 daemon 不能往库里塞大对象)", () => {
+    const big = { a: { ...READY, reason: "x".repeat(20_000) } };
+    const parsed = snapSchema().parse({ ...base, daemon_capabilities: { can_create_nodes: true, runtime_readiness: big } });
+    expect(parsed.daemon_capabilities.runtime_readiness).toBeUndefined();
+    expect(parsed.daemon_capabilities.can_create_nodes).toBe(true);
+  });
+});
+
+describe("#622 sanitizeRuntimeReadiness(读取侧)", () => {
+  test("不认识的 state → unknown;ok 只有 ready 时才可能为真", () => {
+    const s = sanitizeRuntimeReadiness({
+      a: { ok: true, state: "something_new", reason: "r" },
+      b: { ok: true, state: "no_network", reason: "r" },
+    })!;
+    expect(s.a.state).toBe("unknown");
+    expect(s.a.ok).toBe(false);
+    expect(s.b.ok).toBe(false);
+  });
+  test("没报 / 空 → undefined(调用方据此不输出键)", () => {
+    expect(sanitizeRuntimeReadiness(undefined)).toBeUndefined();
+    expect(sanitizeRuntimeReadiness({})).toBeUndefined();
+    expect(sanitizeRuntimeReadiness([])).toBeUndefined();
+  });
+  test("未知枚举值的 cli/auth/network 被丢掉", () => {
+    const s = sanitizeRuntimeReadiness({ a: { ...READY, cli: "/home/x/bin/claude", network: "maybe" } })!;
+    expect(s.a.cli).toBeUndefined();
+    expect(s.a.network).toBeUndefined();
+    expect(s.a.auth).toBe("present");
+  });
+});
+
+let BASE = "";
+let server: any = null;
+let userToken = "";
+let userNetworkId = "";
+let userId = "";
+
+beforeAll(async () => {
+  process.env.HOST = "127.0.0.1";
+  const suffix = `${Date.now()}_${Math.floor(Math.random() * 1000)}`;
+  const password = "BootstrapPw123Aa!";
+  const seed = register(`rr_seed_${suffix}`, password, undefined, "seed");
+  if (!seed.ok) throw new Error("seed failed");
+  db.run("UPDATE users SET role = 'admin' WHERE username = ?1", [`rr_seed_${suffix}`]);
+  const u = register(`rr_u_${suffix}`, password, undefined, "seed");
+  if (!u.ok || !u.token) throw new Error("user register failed");
+  userToken = u.token;
+  userNetworkId = u.network_id ?? "";
+  userId = login(`rr_u_${suffix}`, password).user!.user_id;
+  const { bootServer } = await import("./server.js");
+  server = bootServer({ port: 0, hostname: "127.0.0.1" });
+  BASE = `http://127.0.0.1:${server.port}`;
+  await new Promise((r) => setTimeout(r, 100));
+});
+
+afterAll(() => {
+  try { server?.stop?.(true); } catch {}
+});
+
+function seedDaemon(alias: string, snapshot: object): void {
+  db.run(
+    `INSERT OR REPLACE INTO nodes (
+       node_id, node_name, alias, runtime, model, config_path,
+       channels, server, hostname, network_id, config_revision, config_snapshot
+     ) VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10, ?11, ?12)`,
+    [`rr_n_${alias}`, alias, alias, "claude-agent-sdk", null, "/tmp/cfg.json", "[]", "test-host", "test-host",
+     userNetworkId, 0, JSON.stringify(snapshot)],
+  );
+  db.run(
+    `INSERT OR REPLACE INTO api_tokens (token_id, token_hash, user_id, network_id, name, scope)
+     VALUES (?1, ?2, ?3, ?4, ?5, ?6)`,
+    [`rr_t_${alias}`, `hash_rr_${alias}`, userId, userNetworkId, `node:${alias}`, "network"],
+  );
+}
+
+async function listDaemons(): Promise<any[]> {
+  const res = await fetch(`${BASE}/api/host-supervisors`, { headers: { Authorization: `Bearer ${userToken}` } });
+  const body = await res.json();
+  if (!body.ok) throw new Error("list failed: " + JSON.stringify(body));
+  return body.daemons;
+}
+
+describe("#622 /api/host-supervisors 输出 runtime_readiness", () => {
+  test("新 daemon:逐 runtime 透传;can_create_nodes 不受影响", async () => {
+    db.run("DELETE FROM nodes WHERE network_id = ?1", [userNetworkId]);
+    seedDaemon("rr-new", { role: "host_supervisor", daemon_capabilities: {
+      runtimes_supported: ["claude-code-cli", "grok-build-acp"],
+      can_create_nodes: true,
+      runtime_readiness: { "claude-code-cli": READY, "grok-build-acp": MISSING },
+    } });
+    const d = (await listDaemons()).find((x) => x.alias === "rr-new");
+    expect(d.can_create_nodes).toBe(true);
+    expect(d.runtime_readiness["claude-code-cli"]).toEqual(READY);
+    expect(d.runtime_readiness["grok-build-acp"].state).toBe("missing_cli");
+    expect(d.runtime_readiness["grok-build-acp"].ok).toBe(false);
+  });
+
+  test("🔴 旧 daemon(不报):响应里没有这个键 —— 不是 {}、不是 null", async () => {
+    db.run("DELETE FROM nodes WHERE network_id = ?1", [userNetworkId]);
+    seedDaemon("rr-old", { role: "host_supervisor", daemon_capabilities: { runtimes_supported: ["claude-agent-sdk"], can_create_nodes: true } });
+    const d = (await listDaemons()).find((x) => x.alias === "rr-old");
+    expect(d.can_create_nodes).toBe(true);
+    expect("runtime_readiness" in d).toBe(false);
+  });
+});

package/src/auth-weak-password-login.test.ts

@@ -0,0 +1,176 @@
+// #649: a successful login with a weak password flags the account.
+//
+// Accounts created before #261 (2026-06-28) added `must_change_password` sit at 0 even when they
+// still use the bootstrap default. Login is the one place the plaintext is in hand, so a login that
+// succeeds with a password failing validatePasswordStrength (too short / in WEAK_PASSWORDS) sets the
+// flag and returns `must_change_password: true`. Changing the password clears it.
+//
+// Every case goes through the real HTTP route (bootServer + fetch POST /api/auth/login), not the
+// module function, so the response shape is the one clients see. The aggregate runner gives this
+// file its own COMMHUB_DB / HOME / TMPDIR; the hub listens on port 0.
+// Mutation: drop the new block in login() and the weak cases go red (flag stays 0, field absent).
+
+import { describe, expect, test, beforeAll, afterAll } from "bun:test";
+import { mkdtempSync, rmSync } from "fs";
+import { join } from "path";
+import { tmpdir } from "os";
+import { createHash } from "crypto";
+import { register } from "./auth.js";
+import { db, hashPassword } from "./db.js";
+import { WEAK_PASSWORDS } from "./password-dict.js";
+
+const DIR = mkdtempSync(join(tmpdir(), "anet-weakpw-"));
+let BASE = "";
+let hub: any = null;
+const STRONG = "Str0ng-Fixture-Passw0rd!";
+// Fixture plaintexts only (not anyone's real password).
+const TOO_SHORT = "abc1234";          // 7 chars: fails the length rule (same shape as an old bootstrap default)
+const IN_LIST = "password1";          // ≥ 8 chars but in WEAK_PASSWORDS
+
+async function post(path: string, body: unknown, token = "") {
+  const res = await fetch(`${BASE}${path}`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json", ...(token ? { Authorization: `Bearer ${token}` } : {}) },
+    body: JSON.stringify(body),
+  });
+  return { status: res.status, body: await res.json().catch(() => null) as any };
+}
+const login = (username: string, password: string) => post("/api/auth/login", { username, password });
+const flag = (userId: string) => db.get<any>("SELECT must_change_password AS f FROM users WHERE user_id = ?1", userId)?.f;
+
+let seq = 0;
+/** A user created the normal way (strong password), then rewound to an "old account" state:
+ *  its stored hash replaced by `password` and the flag forced to 0. */
+function oldAccount(password: string, opts: { legacySha256?: boolean } = {}) {
+  const username = `weakpw_${Date.now()}_${seq++}`;
+  const reg = register(username, STRONG, undefined, undefined, { issueTokens: false });
+  expect(reg.ok).toBe(true);
+  const userId = reg.user!.user_id;
+  const hash = opts.legacySha256 ? createHash("sha256").update(`anet:${password}`).digest("hex") : hashPassword(password); // legacy = pre-A1 `anet:`-prefixed sha256 (auth-kdf-migration.test.ts)
+  db.run("UPDATE users SET password_hash = ?1, must_change_password = 0 WHERE user_id = ?2", [hash, userId]);
+  expect(flag(userId)).toBe(0);
+  return { username, userId };
+}
+
+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";
+  process.env.COMMHUB_LOGIN_IP_MAX = "1000";
+  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}`;
+}, 30_000);
+
+afterAll(() => {
+  try { hub?.stop?.(true); } catch {}
+  try { rmSync(DIR, { recursive: true, force: true }); } catch {}
+});
+
+describe("fixtures are what they claim", () => {
+  test("TOO_SHORT is < 8 chars and IN_LIST is >= 8 chars and in WEAK_PASSWORDS; STRONG is neither", () => {
+    expect(TOO_SHORT.length).toBeLessThan(8);
+    expect(IN_LIST.length).toBeGreaterThanOrEqual(8);
+    expect(WEAK_PASSWORDS.has(IN_LIST)).toBe(true);
+    expect(STRONG.length).toBeGreaterThanOrEqual(8);
+    expect(WEAK_PASSWORDS.has(STRONG.toLowerCase())).toBe(false);
+  });
+});
+
+describe("successful login with a weak password sets must_change_password", () => {
+  test("too-short password, flag forced to 0 → login → flag 1 and response says must_change_password: true", async () => {
+    const u = oldAccount(TOO_SHORT);
+    const r = await login(u.username, TOO_SHORT);
+    expect(r.status).toBe(200);
+    expect(r.body.ok).toBe(true);
+    expect(r.body.must_change_password).toBe(true);
+    expect(flag(u.userId)).toBe(1);
+  });
+
+  test("password in WEAK_PASSWORDS (length OK) → flagged", async () => {
+    const u = oldAccount(IN_LIST);
+    const r = await login(u.username, IN_LIST);
+    expect(r.status).toBe(200);
+    expect(r.body.must_change_password).toBe(true);
+    expect(flag(u.userId)).toBe(1);
+  });
+
+  test("weak-list match is case-insensitive like validatePasswordStrength", async () => {
+    const upper = IN_LIST.toUpperCase();
+    const u = oldAccount(upper);
+    const r = await login(u.username, upper);
+    expect(r.status).toBe(200);
+    expect(r.body.must_change_password).toBe(true);
+    expect(flag(u.userId)).toBe(1);
+  });
+
+  test("legacy sha256 hash + weak password → login succeeds, hash upgraded, flag set", async () => {
+    const u = oldAccount(TOO_SHORT, { legacySha256: true });
+    const r = await login(u.username, TOO_SHORT);
+    expect(r.status).toBe(200);
+    expect(r.body.must_change_password).toBe(true);
+    expect(flag(u.userId)).toBe(1);
+    const stored = db.get<any>("SELECT password_hash FROM users WHERE user_id = ?1", u.userId).password_hash;
+    expect(stored.startsWith("scrypt$")).toBe(true);
+  });
+});
+
+describe("no flag where it does not belong", () => {
+  test("strong password → flag stays 0 and the field is absent", async () => {
+    const u = oldAccount(STRONG);
+    const r = await login(u.username, STRONG);
+    expect(r.status).toBe(200);
+    expect(r.body.ok).toBe(true);
+    expect("must_change_password" in r.body).toBe(false);
+    expect(flag(u.userId)).toBe(0);
+  });
+
+  test("failed login against a weak-password account does not touch the flag", async () => {
+    const u = oldAccount(TOO_SHORT);
+    const r = await login(u.username, "wrong-password-xyz");
+    expect(r.status).toBe(401);
+    expect(r.body.must_change_password).toBeUndefined();
+    expect(flag(u.userId)).toBe(0);
+  });
+
+  test("an already-flagged account with a strong password still reports the flag (#261 behaviour kept)", async () => {
+    const u = oldAccount(STRONG);
+    db.run("UPDATE users SET must_change_password = 1 WHERE user_id = ?1", [u.userId]);
+    const r = await login(u.username, STRONG);
+    expect(r.body.must_change_password).toBe(true);
+    expect(flag(u.userId)).toBe(1);
+  });
+});
+
+describe("changing the password clears the flag", () => {
+  test("weak login flags → POST /api/auth/password to a strong one → flag 0 → next login has no field", async () => {
+    const u = oldAccount(TOO_SHORT);
+    const first = await login(u.username, TOO_SHORT);
+    expect(first.body.must_change_password).toBe(true);
+    const changed = await post("/api/auth/password", { old_password: TOO_SHORT, new_password: STRONG }, first.body.token);
+    expect(changed.status).toBe(200);
+    expect(changed.body.ok).toBe(true);
+    expect(flag(u.userId)).toBe(0);
+    const again = await login(u.username, STRONG);
+    expect(again.status).toBe(200);
+    expect("must_change_password" in again.body).toBe(false);
+  });
+});
+
+describe("the plaintext is never logged", () => {
+  test("console output during a weak-password login does not contain the password", async () => {
+    const u = oldAccount(IN_LIST);
+    const seen: string[] = [];
+    const orig = { log: console.log, warn: console.warn, error: console.error, info: console.info };
+    for (const k of Object.keys(orig) as (keyof typeof orig)[]) {
+      (console as any)[k] = (...a: unknown[]) => { seen.push(a.map(String).join(" ")); };
+    }
+    try {
+      const r = await login(u.username, IN_LIST);
+      expect(r.body.must_change_password).toBe(true);
+    } finally {
+      Object.assign(console, orig);
+    }
+    expect(seen.some(l => l.includes(IN_LIST))).toBe(false);
+  });
+});

package/src/auth.ts

@@ -196,6 +196,20 @@ export function login(username: string, password: string, client: SessionClientI
     }
   }
 
+  // #649: a successful login whose plaintext fails the same strength rule as
+  // register/changePassword (too short, or in WEAK_PASSWORDS) flags the account.
+  // Catches accounts created before #261 added must_change_password (they sit at
+  // 0 with the bootstrap default). changePassword clears it. Never log the password.
+  let mustChangePassword = user.must_change_password === 1;
+  if (!mustChangePassword && validatePasswordStrength(password) !== null) {
+    mustChangePassword = true;
+    try {
+      db.run("UPDATE users SET must_change_password = 1 WHERE user_id = ?1", [user.user_id]);
+    } catch (e: any) {
+      console.log(`[commhub auth] weak-password flag write failed for user ${user.user_id}: ${e?.message ?? e}`);
+    }
+  }
+
   // Issue a NEW user token — do NOT rotate/invalidate existing ones. Each
   // login (cli, dashboard, second machine) gets its own row so they don't
   // kick each other out of session. Tokens can be revoked via /api/auth/tokens.
@@ -223,7 +237,7 @@ export function login(username: string, password: string, client: SessionClientI
     network_id: networkId,
     // #261 P0-2 — only include field when truthy (back-compat; old clients
     // don't see this field at all unless their account is flagged).
-    ...(user.must_change_password === 1 ? { must_change_password: true } : {}),
+    ...(mustChangePassword ? { must_change_password: true } : {}),
   };
 }
 

package/src/config-apply-validate.test.ts

@@ -249,6 +249,15 @@ describe("validatePatch — per-flag enum / range", () => {
     expect(validatePatch(undefined, { timeout: 3_600_001 })?.field).toBe("flags.timeout");
     expect(validatePatch(undefined, { timeout: 60.5 })?.field).toBe("flags.timeout");
   });
+  test("timeout: 0 = no limit; 1..999 is seconds-shaped and rejected (#605)", () => {
+    expect(validatePatch(undefined, { timeout: 0 })).toBeNull();
+    expect(validatePatch(undefined, { timeout: 1000 })).toBeNull();
+    for (const v of [1, 600, 999]) {
+      const r = validatePatch(undefined, { timeout: v });
+      expect(r?.field).toBe("flags.timeout");
+      expect(r?.reason).toContain("milliseconds");
+    }
+  });
 });
 
 describe("validatePatch — combinations", () => {

package/src/config-apply-validate.ts

@@ -5,6 +5,8 @@
 // tools.ts wrap these with auth checks (SEC-1 network scope, ntok_/utok_
 // caller identity, role gates).
 
+import { isValidTimeoutMs, TIMEOUT_MS_REASON } from "./create-node-validate.js";
+
 /**
  * Fields the dashboard may change. Anything not in this list is rejected
  * by hub-side validation regardless of role — the UI cannot smuggle
@@ -239,8 +241,10 @@ export function validatePatch(
         }
         break;
       case "timeout":
-        if (typeof val !== "number" || !Number.isInteger(val) || val < 0 || val > 3_600_000) {
-          return { field: "flags.timeout", reason: "must be an integer ms in [0, 3_600_000]" };
+        // #605 —— 与 create_node 同一把尺子(create-node-validate.ts isValidTimeoutMs):
+        // 毫秒,0 或 1000..3_600_000;1..999 是「按秒填了」的形状,拒绝而不是给一个亚秒超时。
+        if (!isValidTimeoutMs(val)) {
+          return { field: "flags.timeout", reason: TIMEOUT_MS_REASON };
         }
         break;
     }

package/src/create-node-validate.test.ts

@@ -69,6 +69,30 @@ describe("validateFlagValue (§4.2.2)", () => {
     expect(() => validateFlagValue("permissionMode", "plan")).not.toThrow();
     expect(() => validateFlagValue("permissionMode", "anything-else")).toThrow(ValidationError);
   });
+  // #605 —— agent-node 按毫秒读 flags.timeout(默认 300000)。这里曾收 1..86400(秒的形状):
+  // 600 原样到子节点 = 0.6 秒超时;600000(10 分钟)反被拒。现在与 update_node_config 同一把尺子。
+  test("timeout is milliseconds: 0 or 1000..3_600_000 (#605)", () => {
+    for (const v of [0, 1000, 300_000, 600_000, 3_600_000]) {
+      expect(() => validateFlagValue("timeout", v)).not.toThrow();
+    }
+    for (const v of [1, 600, 999, 86_400 * 1000 + 1, 3_600_001, -1, 1500.5, "600000", null]) {
+      expect(() => validateFlagValue("timeout", v)).toThrow(ValidationError);
+    }
+    try { validateFlagValue("timeout", 600); throw new Error("unreachable"); }
+    catch (e) {
+      expect(e).toBeInstanceOf(ValidationError);
+      expect((e as ValidationError).code).toBe("flag_value_invalid");
+      expect(String((e as ValidationError).detail?.reason)).toContain("milliseconds");
+    }
+  });
+  test("timeout range matches update_node_config's (#605)", async () => {
+    const { validatePatch } = await import("./config-apply-validate.js");
+    for (const v of [0, 1, 600, 999, 1000, 600_000, 3_600_000, 3_600_001, -1, 1.5]) {
+      let createOk = true;
+      try { validateFlagValue("timeout", v); } catch { createOk = false; }
+      expect({ v, ok: createOk }).toEqual({ v, ok: validatePatch(undefined, { timeout: v }) === null });
+    }
+  });
 });
 
 describe("validateEnvRefs (§4.4.7 + B1 G7/G8 sub-cases)", () => {

package/src/create-node-validate.ts

@@ -108,6 +108,23 @@ export function validateModel(s: unknown): asserts s is string | undefined | nul
   }
 }
 
+/**
+ * #605 —— `flags.timeout` 的单位是**毫秒**:agent-node 就是这么读的(cli.ts currentClaudeTimeoutMs /
+ * currentCodexTimeoutMs → util/timeout.ts resolveTimeoutMs、runtime/opencode-timeout.ts,默认 300000)。
+ * 这里曾按「秒」收 1..86400:填 600 想要 10 分钟的人拿到 0.6 秒、每个任务都超时;真正的毫秒值被拒。
+ *
+ * 范围与 update_node_config(config-apply-validate.ts)/ agent-node config-apply 同一把尺子:
+ * 0(不设上限)或 TIMEOUT_MS_MIN..TIMEOUT_MS_MAX。1..999 拒绝 —— 旧客户端按秒发的小值分辨不出意图,
+ * 不偷偷乘 1000,但也不再让任何人悄悄拿到一个亚秒超时。
+ */
+export const TIMEOUT_MS_MIN = 1000;
+export const TIMEOUT_MS_MAX = 3_600_000;
+export const TIMEOUT_MS_REASON =
+  `timeout is in milliseconds: 0 (no limit) or an integer ${TIMEOUT_MS_MIN}..${TIMEOUT_MS_MAX} (e.g. 600000 = 10 min)`;
+export function isValidTimeoutMs(v: unknown): v is number {
+  return typeof v === "number" && Number.isInteger(v) && (v === 0 || (v >= TIMEOUT_MS_MIN && v <= TIMEOUT_MS_MAX));
+}
+
 export function validateFlagValue(k: string, v: unknown): void {
   switch (k) {
     case "permissionMode":
@@ -129,8 +146,8 @@ export function validateFlagValue(k: string, v: unknown): void {
       }
       return;
     case "timeout":
-      if (!Number.isInteger(v) || (v as number) < 1 || (v as number) > 86400) {
-        throw new ValidationError("flag_value_invalid", { field: k, reason: "must be integer 1..86400" });
+      if (!isValidTimeoutMs(v)) {
+        throw new ValidationError("flag_value_invalid", { field: k, reason: TIMEOUT_MS_REASON });
       }
       return;
     case "copresence":
@@ -214,7 +231,7 @@ export function validateEnvRefs(
   return out;
 }
 
-// §4.4.7 — safe serializer for .env.local. Dotenv-quoted with escape
+// §4.4.7 — safe serializer for the node secrets.env file. Dotenv-quoted with escape
 // for backslash / double-quote / newline / carriage-return so that a
 // value containing `\n"evil=KEY2"` cannot pollute the next line.
 export function serializeEnvLocal(env: Record<string, string>): string {

package/src/db.ts

@@ -2104,3 +2104,23 @@ export function logTaskEvent(taskId: string, fromStatus: string | null, toStatus
 if (db.dialect === "postgres") {
   for (const table of ["nodes", "user_inbox"]) db.exec(`ALTER TABLE ${table} ADD COLUMN IF NOT EXISTS rowid BIGSERIAL`);
 }
+
+// Board #625: common SQLite/PostgreSQL DDL. Adoption records authority, not processes.
+db.exec(`
+  CREATE TABLE IF NOT EXISTS node_daemon_bindings (
+    request_id TEXT PRIMARY KEY,
+    network_id TEXT NOT NULL,
+    node_id TEXT NOT NULL,
+    daemon_node_id TEXT NOT NULL,
+    workdir TEXT NOT NULL,
+    requested_by TEXT NOT NULL,
+    status TEXT NOT NULL CHECK (status IN ('pending','active','refused','revoked')),
+    error TEXT,
+    created_at BIGINT NOT NULL,
+    updated_at BIGINT NOT NULL
+  );
+  CREATE UNIQUE INDEX IF NOT EXISTS idx_ndb_live_node
+    ON node_daemon_bindings(node_id) WHERE status IN ('pending','active');
+  CREATE INDEX IF NOT EXISTS idx_ndb_daemon_network
+    ON node_daemon_bindings(daemon_node_id,network_id,status);
+`);

package/src/mcp-context-cost-http.test.ts

@@ -25,7 +25,8 @@ if (!activeDbPath) throw new Error("mcp-context-cost requires COMMHUB_DB (or COM
  * 上限跟着收到用户这一档(~1.7 KB 余量);节点 / 全部工具的上限在 tool-audience-http.test.ts。
  * 加工具或加说明超过它,就在这里改数字并在 PR 里说为什么。
  */
-const TOOLS_LIST_MAX_BYTES = 56_500;
+// Board #625: two human adoption tools; measured 58 tools / 56,615 B.
+const TOOLS_LIST_MAX_BYTES = 57_500;
 /** 单个工具(名字 + 描述 + 输入 schema)的上限;最大的是 report_status(节点心跳,~8.4 KB 的遥测结构)。 */
 const TOOL_MAX_BYTES = 9_000;
 /** 单条工具描述的上限(说明写进参数的 describe,或者拆短)。 */