@sleep2agi/commhub-server 0.9.0-preview.61 → 0.9.0-preview.65

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sleep2agi/commhub-server",
-  "version": "0.9.0-preview.61",
+  "version": "0.9.0-preview.65",
   "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/create-node-validate.ts

@@ -205,6 +205,40 @@ export function serializeEnvLocal(env: Record<string, string>): string {
   }).join("\n") + "\n";
 }
 
+// app「新建节点」工作目录 —— hub 只判**形状**(daemon 才知道那台机器的 $HOME、系统目录、
+// 目录里住没住别的节点,那几条在 agent-node/src/runtime/child-workdir.ts)。
+// 这里挡的是「根本不像一条路径」的输入,让它在派发前就失败,而不是占一个请求行再被 daemon 拒。
+export const MAX_WORKDIR_LEN = 1024;
+export function validateWorkdir(s: unknown): asserts s is string | undefined | null {
+  if (s === undefined || s === null) return;
+  if (typeof s !== "string") throw new ValidationError("workdir_invalid", { reason: "must be string" });
+  const v = s.trim();
+  if (v.length === 0 || v.length > MAX_WORKDIR_LEN) {
+    throw new ValidationError("workdir_invalid", { reason: `length 1..${MAX_WORKDIR_LEN}` });
+  }
+  if (/[\u0000-\u001f\u007f]/.test(v)) throw new ValidationError("workdir_invalid", { reason: "control character" });
+  const shapeOk = v.startsWith("/") || v === "~" || v.startsWith("~/") || /^[A-Za-z]:[\\/]/.test(v);
+  if (!shapeOk) {
+    throw new ValidationError("workdir_invalid", { reason: "must be absolute (/…, ~/…, or C:\\…)", value: v.slice(0, 80) });
+  }
+}
+
+/** daemon 自报的默认工作目录根(`daemon_capabilities.default_workdir_root`),消毒后返回;
+ *  没报 / 形状不对 = null。**非 null 即表示该 daemon 认 `node_spec.workdir`** ——
+ *  create_node 的「老 daemon 不收 workdir」门和 /api/host-supervisors 的透出共用这一个判据。 */
+export function daemonDefaultWorkdirRoot(configSnapshot: unknown): string | null {
+  try {
+    const snap = typeof configSnapshot === "string" ? JSON.parse(configSnapshot) : configSnapshot;
+    const v = (snap as any)?.daemon_capabilities?.default_workdir_root;
+    if (typeof v !== "string" || v.length === 0 || v.length > MAX_WORKDIR_LEN) return null;
+    if (/[\u0000-\u001f\u007f]/.test(v)) return null;
+    if (!(v.startsWith("/") || /^[A-Za-z]:[\\/]/.test(v))) return null;
+    return v;
+  } catch {
+    return null;
+  }
+}
+
 // §4.2.5 — channels fail-closed in P1.
 export function validateChannelsP1(channels: unknown): void {
   if (channels === undefined || channels === null) return;

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

@@ -0,0 +1,254 @@
+import { afterAll, beforeAll, beforeEach, describe, expect, test } from "bun:test";
+import "./require-explicit-test-db.js";
+import { db } from "./db.js";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { registerTools } from "./tools.js";
+import { daemonDefaultWorkdirRoot, validateWorkdir, ValidationError } from "./create-node-validate.js";
+import { addNetworkMember, login, register } from "./auth.js";
+
+// app「新建节点」工作目录 —— hub 这一层管三件事:
+//   ① node_spec.workdir 的**形状**(绝对 / ~/… / C:\…),派发前就拒
+//   ② daemon 没自报 default_workdir_root(= 老 daemon,会静默忽略 workdir)⇒ 拒,不派
+//   ③ 请求行存下 workdir,get_create_request 原样交给 daemon;不带就**不出现**这个键
+// 以及 /api/host-supervisors 只给 admin/owner 透出默认根(它是那台机器的家目录路径)。
+
+const NET = "net_workdir_gate";
+const USER_ID = "u_workdir_admin";
+const DAEMON_ID = "node_workdir_daemon";
+const DAEMON_ALIAS = "workdir-daemon";
+const DAEMON_TOK = "tok_workdir_daemon";
+const ROOT = "/home/user";
+
+interface ToolHandler { (args: any, extra?: any): Promise<{ content: Array<{ type: "text"; text: string }> }>; }
+interface Reply { ok?: boolean; error?: string; request_id?: string; node_spec?: any; [k: string]: unknown; }
+
+function cleanup() {
+  for (const t of ["node_create_requests", "audit_log", "nodes", "sessions", "api_tokens", "network_members"]) {
+    try { db.run(`DELETE FROM ${t} 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_ID]); } catch {}
+}
+beforeEach(cleanup);
+afterAll(cleanup);
+
+function seed(caps: Record<string, unknown>) {
+  db.run(`INSERT INTO users (user_id, username, password_hash, role, created_at) VALUES (?1, ?1, 'x', 'user', datetime('now'))`, [USER_ID]);
+  db.run(`INSERT OR REPLACE INTO networks (network_id, network_name, owner_id, created_at) VALUES (?1, ?1, ?2, datetime('now'))`, [NET, USER_ID]);
+  db.run(`INSERT INTO network_members (user_id, network_id, role, joined_at) VALUES (?1, ?2, 'admin', datetime('now'))`, [USER_ID, NET]);
+  db.run(
+    `INSERT INTO nodes (node_id, node_name, alias, network_id, config_snapshot, hostname, created_at, updated_at, lifecycle_state)
+     VALUES (?1, ?2, ?2, ?3, ?4, 'host-x', datetime('now'), datetime('now'), 'active')`,
+    [DAEMON_ID, DAEMON_ALIAS, NET, JSON.stringify({ role: "host_supervisor", daemon_capabilities: { runtimes_supported: ["claude-agent-sdk"], ...caps } })],
+  );
+  db.run(
+    `INSERT INTO api_tokens (token_id, user_id, network_id, scope, name, token_hash, expires_at, revoked_at)
+     VALUES (?1, ?2, ?3, 'network', ?4, ?5, NULL, NULL)`,
+    [DAEMON_TOK, USER_ID, NET, `node:${DAEMON_ALIAS}`, `hash_${DAEMON_TOK}`],
+  );
+}
+
+function tools(callerTokenId: string | null = null): Record<string, ToolHandler> {
+  const server = new McpServer({ name: "test", version: "0" }) as any;
+  const out: Record<string, ToolHandler> = {};
+  const origTool = server.tool.bind(server);
+  server.tool = (name: string, d: string, schema: any, handler: ToolHandler) => { out[name] = handler; return origTool(name, d, schema, handler); };
+  const origRegisterTool = server.registerTool?.bind(server);
+  if (origRegisterTool) {
+    server.registerTool = (name: string, cfg: any, handler: ToolHandler) => { out[name] = handler; return origRegisterTool(name, cfg, handler); };
+  }
+  registerTools(server, undefined, NET, USER_ID, null, true, callerTokenId);
+  return out;
+}
+
+async function call(h: ToolHandler, args: any): Promise<Reply> {
+  return JSON.parse((await h(args)).content[0].text) as Reply;
+}
+
+const baseSpec = { name: "wd-child", runtime: "claude-agent-sdk", model: "claude-sonnet-4-5", flags: {} };
+
+function rowCount(): number {
+  return db.get<{ n: number }>("SELECT COUNT(*) AS n FROM node_create_requests WHERE daemon_node_id = ?1", DAEMON_ID)?.n ?? -1;
+}
+
+describe("validateWorkdir — shape only", () => {
+  const ok = ["/home/user/proj", "/srv/x", "~", "~/proj", "C:\\Users\\alice\\proj", "D:/work", "  /padded  "];
+  for (const v of ok) test(`accepts ${JSON.stringify(v)}`, () => { expect(() => validateWorkdir(v)).not.toThrow(); });
+  test("accepts undefined / null (field omitted)", () => {
+    expect(() => validateWorkdir(undefined)).not.toThrow();
+    expect(() => validateWorkdir(null)).not.toThrow();
+  });
+  const bad: unknown[] = ["", "   ", "proj", "./proj", "../x", "~alice/x", "C:proj", "/a\nb", "/a\u0000b", "x".repeat(10) + "/", "/" + "a".repeat(1024), 42, {}];
+  for (const v of bad) {
+    test(`rejects ${JSON.stringify(v)?.slice(0, 40)}`, () => {
+      let code = "";
+      try { validateWorkdir(v); } catch (e) { code = (e as ValidationError).code; }
+      expect(code).toBe("workdir_invalid");
+    });
+  }
+});
+
+describe("daemonDefaultWorkdirRoot — sanitize the self-report", () => {
+  const snap = (v: unknown) => JSON.stringify({ daemon_capabilities: { default_workdir_root: v } });
+  test("absolute posix root passes through", () => { expect(daemonDefaultWorkdirRoot(snap(ROOT))).toBe(ROOT); });
+  test("windows root passes through", () => { expect(daemonDefaultWorkdirRoot(snap("C:\\Users\\alice"))).toBe("C:\\Users\\alice"); });
+  test("object snapshot (not string) also accepted", () => {
+    expect(daemonDefaultWorkdirRoot({ daemon_capabilities: { default_workdir_root: ROOT } })).toBe(ROOT);
+  });
+  for (const v of [undefined, null, "", "relative", "~/x", 7, "/a\nb", "/" + "a".repeat(1100)]) {
+    test(`not reported / malformed ${JSON.stringify(v)?.slice(0, 30)} → null`, () => {
+      expect(daemonDefaultWorkdirRoot(snap(v))).toBeNull();
+    });
+  }
+  test("null / garbage snapshot → null", () => {
+    expect(daemonDefaultWorkdirRoot(null)).toBeNull();
+    expect(daemonDefaultWorkdirRoot("{not json")).toBeNull();
+  });
+});
+
+describe("create_node + workdir", () => {
+  test("🔴 old daemon (no default_workdir_root) + workdir → workdir_not_supported_by_daemon, NO row", async () => {
+    seed({});
+    const r = await call(tools().create_node, { daemon_node_id: DAEMON_ID, node_spec: { ...baseSpec, workdir: `${ROOT}/wd-child` } });
+    expect(r.ok).toBe(false);
+    expect(r.error).toBe("workdir_not_supported_by_daemon");
+    expect(rowCount()).toBe(0);
+  });
+
+  test("old daemon WITHOUT workdir still dispatches (no regression for existing callers)", async () => {
+    seed({});
+    const r = await call(tools().create_node, { daemon_node_id: DAEMON_ID, node_spec: baseSpec });
+    expect(r.ok).toBe(true);
+    const row = db.get<{ workdir: string | null }>("SELECT workdir FROM node_create_requests WHERE request_id = ?1", r.request_id);
+    expect(row?.workdir).toBeNull();
+  });
+
+  test("bad shape rejected before dispatch → workdir_invalid, NO row", async () => {
+    seed({ default_workdir_root: ROOT });
+    const r = await call(tools().create_node, { daemon_node_id: DAEMON_ID, node_spec: { ...baseSpec, workdir: "relative/dir" } });
+    expect(r.error).toBe("workdir_invalid");
+    expect(rowCount()).toBe(0);
+  });
+
+  test("new daemon + workdir → row stores it and get_create_request hands it to the daemon", async () => {
+    seed({ default_workdir_root: ROOT });
+    const wd = `${ROOT}/wd-child`;
+    const r = await call(tools().create_node, { daemon_node_id: DAEMON_ID, node_spec: { ...baseSpec, workdir: wd } });
+    expect(r.ok).toBe(true);
+    const row = db.get<{ workdir: string | null }>("SELECT workdir FROM node_create_requests WHERE request_id = ?1", r.request_id);
+    expect(row?.workdir).toBe(wd);
+    const g = await call(tools(DAEMON_TOK).get_create_request, { request_id: r.request_id });
+    expect(g.ok).toBe(true);
+    expect(g.node_spec.workdir).toBe(wd);
+    expect(g.node_spec.name).toBe(baseSpec.name);
+  });
+
+  test("workdir is trimmed before storage", async () => {
+    seed({ default_workdir_root: ROOT });
+    const r = await call(tools().create_node, { daemon_node_id: DAEMON_ID, node_spec: { ...baseSpec, workdir: `  ~/wd-child  ` } });
+    expect(r.ok).toBe(true);
+    const row = db.get<{ workdir: string | null }>("SELECT workdir FROM node_create_requests WHERE request_id = ?1", r.request_id);
+    expect(row?.workdir).toBe("~/wd-child");
+  });
+
+  test("new daemon WITHOUT workdir → get_create_request node_spec has NO workdir key (daemon keeps legacy layout)", async () => {
+    seed({ default_workdir_root: ROOT });
+    const r = await call(tools().create_node, { daemon_node_id: DAEMON_ID, node_spec: baseSpec });
+    expect(r.ok).toBe(true);
+    const g = await call(tools(DAEMON_TOK).get_create_request, { request_id: r.request_id });
+    expect(g.ok).toBe(true);
+    expect("workdir" in g.node_spec).toBe(false);
+  });
+
+  test("audit detail records the requested workdir", async () => {
+    seed({ default_workdir_root: ROOT });
+    const wd = `${ROOT}/wd-child`;
+    const r = await call(tools().create_node, { daemon_node_id: DAEMON_ID, node_spec: { ...baseSpec, workdir: wd } });
+    const a = db.get<{ detail: string }>(
+      "SELECT detail FROM audit_log WHERE target_id = ?1 AND action = 'create_node_dispatch_attempted'", r.request_id,
+    );
+    expect(JSON.parse(a?.detail || "{}").workdir).toBe(wd);
+  });
+
+  test("list_host_supervisors (MCP) surfaces default_workdir_root for admin", async () => {
+    seed({ default_workdir_root: ROOT });
+    const r = await call(tools().list_host_supervisors, {});
+    const d = (r as any).daemons.find((x: any) => x.daemon_node_id === DAEMON_ID);
+    expect(d.default_workdir_root).toBe(ROOT);
+  });
+
+  test("list_host_supervisors (MCP) omits the key for an old daemon", async () => {
+    seed({});
+    const r = await call(tools().list_host_supervisors, {});
+    const d = (r as any).daemons.find((x: any) => x.daemon_node_id === DAEMON_ID);
+    expect(d).toBeDefined();
+    expect("default_workdir_root" in d).toBe(false);
+  });
+});
+
+// ── REST /api/host-supervisors: admin sees the root, member does not ──────────
+let BASE = "";
+let server: any = null;
+let ownerTok = "", memberTok = "", restNet = "", ownerId = "";
+describe("/api/host-supervisors — default_workdir_root visibility", () => {
+  beforeAll(async () => {
+    process.env.HOST = "127.0.0.1";
+    const sfx = `${Date.now()}_${Math.floor(Math.random() * 1000)}`;
+    const pw = "BootstrapPw123Aa!";
+    const s = register(`wd_seed_${sfx}`, pw, undefined, "seed");
+    if (!s.ok) throw new Error("seed failed");
+    db.run("UPDATE users SET role = 'admin' WHERE username = ?1", [`wd_seed_${sfx}`]);
+    const o = register(`wd_owner_${sfx}`, pw, undefined, "seed");
+    if (!o.ok || !o.token) throw new Error("owner register failed");
+    ownerTok = o.token; restNet = o.network_id ?? "";
+    ownerId = login(`wd_owner_${sfx}`, pw).user!.user_id;
+    const m = register(`wd_member_${sfx}`, pw, undefined, "seed");
+    if (!m.ok || !m.token) throw new Error("member register failed");
+    memberTok = m.token;
+    const memberId = login(`wd_member_${sfx}`, pw).user!.user_id;
+    const add = addNetworkMember(restNet, memberId, "member");
+    if (!add.ok) throw new Error("add member failed: " + add.error);
+    const { bootServer } = await import("./server.js");
+    server = bootServer({ port: 0, hostname: "127.0.0.1" });
+    BASE = `http://127.0.0.1:${server.port}`;
+    for (const [alias, caps] of [["wd-new", { default_workdir_root: ROOT }], ["wd-old", {}]] as const) {
+      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, ?2, 'claude-agent-sdk', 'm', '/tmp/cfg.json', '[]', 'h', 'h', ?3, 0, ?4)`,
+        [`wd_n_${alias}`, alias, restNet, JSON.stringify({ role: "host_supervisor", daemon_capabilities: caps })],
+      );
+      db.run(
+        `INSERT OR REPLACE INTO api_tokens (token_id, token_hash, user_id, network_id, name, scope) VALUES (?1, ?2, ?3, ?4, ?5, 'network')`,
+        [`wd_t_${alias}`, `hash_wd_${alias}`, ownerId, restNet, `node:${alias}`],
+      );
+    }
+  });
+  afterAll(() => {
+    try { server?.stop?.(true); } catch {}
+    try { db.run("DELETE FROM nodes WHERE network_id = ?1", [restNet]); } catch {}
+    try { db.run("DELETE FROM api_tokens WHERE network_id = ?1 AND name LIKE 'node:%'", [restNet]); } catch {}
+  });
+
+  async function list(tok: string): Promise<any[]> {
+    const res = await fetch(`${BASE}/api/host-supervisors?network_id=${encodeURIComponent(restNet)}`, { headers: { Authorization: `Bearer ${tok}` } });
+    const b = await res.json();
+    if (!b.ok) throw new Error("list failed: " + JSON.stringify(b));
+    return b.daemons;
+  }
+
+  test("owner sees default_workdir_root on the new daemon", async () => {
+    const d = (await list(ownerTok)).find(x => x.alias === "wd-new");
+    expect(d?.default_workdir_root).toBe(ROOT);
+  });
+  test("old daemon row has NO default_workdir_root key (app hides the row)", async () => {
+    const d = (await list(ownerTok)).find(x => x.alias === "wd-old");
+    expect(d).toBeDefined();
+    expect("default_workdir_root" in d).toBe(false);
+  });
+  test("🔴 member does NOT see the host's home path", async () => {
+    const rows = await list(memberTok);
+    const d = rows.find(x => x.alias === "wd-new");
+    expect(d).toBeDefined();
+    expect("default_workdir_root" in d).toBe(false);
+  });
+});

package/src/db.ts

@@ -733,6 +733,15 @@ function migrateNodeCreateRequestsModelNullable() {
 }
 migrateNodeCreateRequestsModelNullable();
 
+// app「新建节点」工作目录 —— 请求带的 node_spec.workdir(可空;空 = 落 daemon cwd 的老行为)。
+// 🔴 必须排在上面那个重建表迁移**之后**:它按显式列清单拷贝,排在前面的话,老库(model NOT NULL)
+//    第一次启动时这一列会被重建吞掉。
+try {
+  db.exec(`ALTER TABLE node_create_requests ADD COLUMN workdir TEXT`);
+} catch (e: any) {
+  if (!/duplicate column|already exists/i.test(e?.message || "")) throw e;
+}
+
 // #1493 — 把 user_inbox.network_id 升到 **schema 级 NOT NULL**(belt-and-suspenders,
 // 叠在 send_desktop_message 的代码级三闸之上:canWrite / `!effectiveNetId` return /
 // getUserNetworkRole,tools.ts)。「不产生 network_id=NULL 孤儿」现是代码级保证 + #1492
@@ -941,6 +950,32 @@ db.exec(`
     ON skillhub_skills(network_id, slug, version);
 `);
 
+// 需求池。长期卡片，按 network 隔离。不是 tasks。
+db.exec(`
+  CREATE TABLE IF NOT EXISTS requirements (
+    requirement_id TEXT PRIMARY KEY,
+    network_id     TEXT NOT NULL,
+    title          TEXT NOT NULL,
+    column_name    TEXT NOT NULL DEFAULT 'pool' CHECK(column_name IN ('pool', 'doing', 'done')),
+    priority       TEXT NOT NULL DEFAULT 'normal' CHECK(priority IN ('high', 'normal', 'low')),
+    due_on         TEXT,
+    assignee       TEXT,
+    client_id      TEXT,
+    issues_json    TEXT,
+    created_by     TEXT,
+    created_at     TEXT NOT NULL DEFAULT (datetime('now')),
+    updated_at     TEXT NOT NULL DEFAULT (datetime('now'))
+  );
+  CREATE INDEX IF NOT EXISTS idx_requirements_network
+    ON requirements(network_id, created_at DESC);
+`);
+try { db.exec("ALTER TABLE requirements ADD COLUMN client_id TEXT"); } catch {}
+try { db.exec("ALTER TABLE requirements ADD COLUMN issues_json TEXT"); } catch {}
+db.exec("CREATE UNIQUE INDEX IF NOT EXISTS idx_requirements_client ON requirements(network_id, client_id) WHERE client_id IS NOT NULL AND client_id != ''");
+for (const column of ["owner_json TEXT", "participants_json TEXT NOT NULL DEFAULT '[]'"]) {
+  try { db.exec(`ALTER TABLE requirements ADD COLUMN ${column}`); } catch (e: any) { if (!/duplicate column|already exists/i.test(e?.message || "")) throw e; }
+}
+
 // ── V3: licenses table ──
 db.exec(`
   CREATE TABLE IF NOT EXISTS licenses (

package/src/requirements-http.test.ts

@@ -0,0 +1,241 @@
+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 dir = mkdtempSync(join(tmpdir(), "anet-requirements-"));
+process.env.COMMHUB_DB = join(dir, "hub.db");
+
+let server: { port: number; stop?: (force?: boolean) => void };
+let base = "";
+let ownerToken = "";
+let viewerToken = "";
+let otherToken = "";
+let nodeToken = "";
+let ownerNetwork = "";
+
+async function api(token: string, path: string, init?: RequestInit) {
+  const res = await fetch(`${base}${path}`, {
+    ...init,
+    headers: { Authorization: `Bearer ${token}`, "Content-Type": "application/json", ...(init?.headers || {}) },
+  });
+  return { status: res.status, body: await res.json() as any };
+}
+
+beforeAll(async () => {
+  const { db } = await import("./db.js");
+  const { addNetworkMember, createNetworkTokenForNode, register } = await import("./auth.js");
+  const owner = register(`req_owner_${Date.now()}`, "RequirementsOwner123!", undefined, "seed");
+  expect(owner.ok).toBe(true);
+  ownerToken = owner.token!;
+  ownerNetwork = owner.network_id!;
+  const networkId = owner.network_id!;
+  const ownerId = db.get<{ owner_id: string }>("SELECT owner_id FROM networks WHERE network_id = ?1", networkId)!.owner_id;
+  const viewer = register(`req_viewer_${Date.now()}`, "RequirementsViewer123!", undefined, "seed");
+  expect(viewer.ok).toBe(true);
+  viewerToken = viewer.token!;
+  const viewerId = db.get<{ user_id: string }>("SELECT user_id FROM users WHERE username = ?1", viewer.user!.username)!.user_id;
+  addNetworkMember(networkId, viewerId, "viewer", ownerId);
+  const ntok = createNetworkTokenForNode(ownerId, networkId, "req-node");
+  expect(ntok.ok).toBe(true);
+  nodeToken = ntok.token!;
+  const other = register(`req_other_${Date.now()}`, "RequirementsOther123!", undefined, "seed");
+  expect(other.ok).toBe(true);
+  otherToken = other.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("requirements stay on the hub", () => {
+  let id = "";
+
+  test("typed assignments validate network membership, preserve kinds and clear explicitly", async () => {
+    const { db } = await import('./db.js');
+    const ownerId = db.get<{ owner_id: string }>('SELECT owner_id FROM networks WHERE network_id=?1', ownerNetwork)!.owner_id;
+    db.run('INSERT INTO nodes(node_id,node_name,alias,display_name,network_id) VALUES (?1,?2,?2,?3,?4)', [ownerId, 'same-name', '自定义 Agent 名', ownerNetwork]);
+    db.run('INSERT INTO nodes(node_id,node_name,network_id) VALUES (?1,?2,?3)', ['foreign-person-node', 'foreign-node', 'other-network']);
+    const people = await api(ownerToken, `/api/requirements/people?network_id=${ownerNetwork}`);
+    expect(people.status).toBe(200);
+    expect(people.body.people.some((p: any) => p.id === ownerId && p.kind === 'user')).toBe(true);
+    expect(people.body.people.some((p: any) => p.id === ownerId && p.kind === 'node' && p.name === '自定义 Agent 名')).toBe(true);
+    expect(people.body.people.every((p: any) => p.networkId === ownerNetwork)).toBe(true);
+    const user = { kind: 'user', id: ownerId };
+    const node = { kind: 'node', id: ownerId };
+    const created = await api(ownerToken, '/api/requirements', { method: 'POST', body: JSON.stringify({ name: 'typed people', owner: user, participants: [user, node, user] }) });
+    expect(created.status).toBe(201);
+    expect(created.body.requirement.owner).toEqual(user);
+    expect(created.body.requirement.participants).toEqual([user, node]);
+    const path = `/api/requirements/${created.body.requirement.id}`;
+    const changed = await api(ownerToken, path, { method: 'PATCH', body: JSON.stringify({ owner: node }) });
+    expect(changed.status).toBe(200);
+    expect(changed.body.requirement.owner).toEqual(node);
+    expect(changed.body.requirement.participants).toEqual([user, node]);
+    expect(changed.body.requirement.column).toBe('pool');
+    for (const token of [viewerToken, nodeToken]) {
+      expect((await api(token, path, { method: 'PATCH', body: JSON.stringify({ owner: null, participants: [] }) })).status).toBe(403);
+    }
+    expect((await api(otherToken, path, { method: 'PATCH', body: JSON.stringify({ owner: null }) })).status).toBe(404);
+    for (const invalid of [{ kind: 'node', id: 'foreign-person-node' }, { kind: 'user', id: 'unknown' }, { kind: 'admin', id: ownerId }]) {
+      expect((await api(ownerToken, path, { method: 'PATCH', body: JSON.stringify({ participants: [invalid] }) })).status).toBe(400);
+    }
+    const listed = await api(ownerToken, '/api/requirements');
+    expect(listed.body.requirements.find((row: any) => row.id === created.body.requirement.id).owner).toEqual(node);
+    const cleared = await api(ownerToken, path, { method: 'PATCH', body: JSON.stringify({ owner: null, participants: [] }) });
+    expect(cleared.status).toBe(200);
+    expect(cleared.body.requirement.owner).toBeNull();
+    expect(cleared.body.requirement.participants).toEqual([]);
+  });
+
+  test("owner creates a card in the pool", async () => {
+    const created = await api(ownerToken, "/api/requirements", {
+      method: "POST",
+      body: JSON.stringify({ name: "多端同步", priority: "high", assignee: "node-a", due: "2026-10-01" }),
+    });
+    expect(created.status).toBe(201);
+    expect(created.body.requirement.column).toBe("pool");
+    expect(created.body.requirement.name).toBe("多端同步");
+    expect(created.body.requirement.assignee).toBe("node-a");
+    expect(created.body.requirement.due).toBe("2026-10-01");
+    id = created.body.requirement.id;
+  });
+
+  test("the same account reads it back", async () => {
+    const listed = await api(ownerToken, "/api/requirements");
+    expect(listed.status).toBe(200);
+    expect(listed.body.requirements.some((row: { id: string }) => row.id === id)).toBe(true);
+  });
+
+  test("moving a card is stored on the hub", async () => {
+    const moved = await api(ownerToken, `/api/requirements/${id}`, {
+      method: "PATCH",
+      body: JSON.stringify({ column: "doing" }),
+    });
+    expect(moved.status).toBe(200);
+    expect(moved.body.requirement.column).toBe("doing");
+  });
+
+  test("another network cannot see it", async () => {
+    const listed = await api(otherToken, "/api/requirements");
+    expect(listed.status).toBe(200);
+    expect(listed.body.requirements.some((row: { id: string }) => row.id === id)).toBe(false);
+  });
+
+  test("a viewer cannot add or move", async () => {
+    const denied = await api(viewerToken, "/api/requirements", {
+      method: "POST",
+      body: JSON.stringify({ name: "不行", network_id: ownerNetwork }),
+    });
+    expect(denied.status).toBe(403);
+    const move = await api(viewerToken, `/api/requirements/${id}`, {
+      method: "PATCH",
+      body: JSON.stringify({ column: "done" }),
+    });
+    expect(move.status).toBe(403);
+  });
+
+  test("a node token cannot use the board", async () => {
+    const denied = await api(nodeToken, "/api/requirements");
+    expect(denied.status).toBe(403);
+  });
+
+  test("the same client_id does not create a second card", async () => {
+    const first = await api(ownerToken, "/api/requirements", {
+      method: "POST",
+      body: JSON.stringify({ name: "迁移甲", client_id: "local_card_1", column: "doing" }),
+    });
+    expect(first.status).toBe(201);
+    expect(first.body.requirement.column).toBe("doing");
+    const again = await api(ownerToken, "/api/requirements", {
+      method: "POST",
+      body: JSON.stringify({ name: "迁移甲", client_id: "local_card_1", column: "done" }),
+    });
+    expect(again.status).toBe(200);
+    expect(again.body.requirement.id).toBe(first.body.requirement.id);
+    expect(again.body.requirement.column).toBe("doing");
+    const listed = await api(ownerToken, "/api/requirements");
+    const matches = listed.body.requirements.filter((row: { id: string }) => row.id === first.body.requirement.id);
+    expect(matches.length).toBe(1);
+  });
+
+  test("a card can bind a github issue and a bad link is rejected", async () => {
+    const created = await api(ownerToken, "/api/requirements", {
+      method: "POST",
+      body: JSON.stringify({
+        name: "绑 issue",
+        issues: [{ url: "https://github.com/sleep2agi/agent-network-app/issues/472", title: "picker" }],
+      }),
+    });
+    expect(created.status).toBe(201);
+    expect(created.body.requirement.issues).toEqual([
+      { repo: "sleep2agi/agent-network-app", number: 472, title: "picker" },
+    ]);
+    const moved = await api(ownerToken, `/api/requirements/${created.body.requirement.id}`, {
+      method: "PATCH",
+      body: JSON.stringify({ column: "doing" }),
+    });
+    expect(moved.body.requirement.issues[0].number).toBe(472);
+    const bad = await api(ownerToken, `/api/requirements/${created.body.requirement.id}`, {
+      method: "PATCH",
+      body: JSON.stringify({ issues: ["javascript:alert(1)"] }),
+    });
+    expect(bad.status).toBe(400);
+  });
+
+  test("an existing card can change its text without dropping omitted fields", async () => {
+    const { db } = await import("./db.js");
+    const ownerId = db.get<{ owner_id: string }>("SELECT owner_id FROM networks WHERE network_id=?1", ownerNetwork)!.owner_id;
+    const created = await api(ownerToken, "/api/requirements", {
+      method: "POST",
+      body: JSON.stringify({
+        name: "旧标题",
+        priority: "low",
+        assignee: "node-a",
+        due: "2026-10-01",
+        column: "doing",
+        owner: { kind: "user", id: ownerId },
+      }),
+    });
+    expect(created.status).toBe(201);
+    const id = created.body.requirement.id;
+    const renamed = await api(ownerToken, `/api/requirements/${id}`, {
+      method: "PATCH",
+      body: JSON.stringify({ name: "新标题" }),
+    });
+    expect(renamed.status).toBe(200);
+    expect(renamed.body.requirement.name).toBe("新标题");
+    expect(renamed.body.requirement.priority).toBe("low");
+    expect(renamed.body.requirement.assignee).toBe("node-a");
+    expect(renamed.body.requirement.due).toBe("2026-10-01");
+    expect(renamed.body.requirement.column).toBe("doing");
+    expect(renamed.body.requirement.owner).toEqual({ kind: "user", id: ownerId });
+    const cleared = await api(ownerToken, `/api/requirements/${id}`, {
+      method: "PATCH",
+      body: JSON.stringify({ due: "", assignee: "", priority: "high" }),
+    });
+    expect(cleared.status).toBe(200);
+    expect(cleared.body.requirement.name).toBe("新标题");
+    expect(cleared.body.requirement.due).toBe("");
+    expect(cleared.body.requirement.assignee).toBe("");
+    expect(cleared.body.requirement.priority).toBe("high");
+    expect(cleared.body.requirement.owner).toEqual({ kind: "user", id: ownerId });
+    expect((await api(ownerToken, `/api/requirements/${id}`, { method: "PATCH", body: JSON.stringify({ name: "  " }) })).status).toBe(400);
+    expect((await api(ownerToken, `/api/requirements/${id}`, { method: "PATCH", body: JSON.stringify({ due: "2026-13-01" }) })).status).toBe(400);
+    expect((await api(viewerToken, `/api/requirements/${id}`, { method: "PATCH", body: JSON.stringify({ name: "越权" }) })).status).toBe(403);
+    expect((await api(otherToken, `/api/requirements/${id}`, { method: "PATCH", body: JSON.stringify({ name: "别人的" }) })).status).toBe(404);
+    const listed = await api(ownerToken, "/api/requirements");
+    expect(listed.body.requirements.find((row: { id: string }) => row.id === id).name).toBe("新标题");
+  });
+
+  test("empty name and a bad date are rejected", async () => {
+    const empty = await api(ownerToken, "/api/requirements", { method: "POST", body: JSON.stringify({ name: "  " }) });
+    expect(empty.status).toBe(400);
+    const date = await api(ownerToken, "/api/requirements", { method: "POST", body: JSON.stringify({ name: "日期", due: "2026-13-01" }) });
+    expect(date.status).toBe(400);
+  });
+});

package/src/requirements.ts

@@ -0,0 +1,281 @@
+// 需求池。长期卡片，存在 Hub 上，手机和电脑读同一份。
+// 不是 tasks：tasks 是正在派给节点的活，状态由节点收尾。
+import { db } from "./db.js";
+import { addNetworkScope, canRestWriteNetwork, resolveRestWriteNetworkId, type RestNetworkScope } from "./network-scope.js";
+
+type RequestAuth = { userId: string; networkId: string | null; username: string } | null;
+
+export type RequirementsRequestContext = {
+  req: Request;
+  url: URL;
+  auth: RequestAuth;
+  isAdmin: boolean;
+  isNodeToken: boolean;
+  scope: RestNetworkScope;
+};
+
+const COLUMNS = new Set(["pool", "doing", "done"]);
+const PRIORITIES = new Set(["high", "normal", "low"]);
+const DUE = /^\d{4}-\d{2}-\d{2}$/;
+
+type Row = {
+  owner_json: string | null;
+  participants_json: string;
+  requirement_id: string;
+  network_id: string;
+  title: string;
+  column_name: string;
+  priority: string;
+  due_on: string | null;
+  assignee: string | null;
+  issues_json: string | null;
+  created_at: string;
+};
+
+function jsonError(error: string, status: number): Response {
+  return Response.json({ ok: false, error }, { status });
+}
+
+function dueOk(due: string): boolean {
+  if (!DUE.test(due)) return false;
+  const [y, m, d] = due.split("-").map(Number);
+  const dt = new Date(Date.UTC(y, m - 1, d));
+  return dt.getUTCFullYear() === y && dt.getUTCMonth() === m - 1 && dt.getUTCDate() === d;
+}
+
+const REPO = /^[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+$/;
+const ISSUE_URL = /^https:\/\/github\.com\/([A-Za-z0-9_.-]+)\/([A-Za-z0-9_.-]+)\/issues\/(\d+)\/?$/;
+
+function clipTitle(value: unknown): string {
+  return typeof value === "string" ? value.replace(/[\r\n\t]/g, " ").trim().slice(0, 120) : "";
+}
+
+function issueFromParts(repo: string, number: number, title: string) {
+  if (!REPO.test(repo) || !Number.isInteger(number) || number < 1 || number > 10_000_000) return null;
+  return { repo, number, title: clipTitle(title) };
+}
+
+function oneIssue(item: unknown) {
+  if (typeof item === "string") {
+    const m = ISSUE_URL.exec(item.trim());
+    return m ? issueFromParts(`${m[1]}/${m[2]}`, Number(m[3]), "") : null;
+  }
+  if (!item || typeof item !== "object") return null;
+  const row = item as Record<string, unknown>;
+  if (typeof row.url === "string") {
+    const m = ISSUE_URL.exec(row.url.trim());
+    if (m) return issueFromParts(`${m[1]}/${m[2]}`, Number(m[3]), clipTitle(row.title));
+  }
+  const repo = typeof row.repo === "string" ? row.repo.trim() : "";
+  const number = typeof row.number === "number" ? row.number : Number(row.number);
+  return issueFromParts(repo, number, clipTitle(row.title));
+}
+
+function normalizeIssues(raw: unknown) {
+  if (!Array.isArray(raw) || raw.length > 8) return null;
+  const out: { repo: string; number: number; title: string }[] = [];
+  const seen = new Set<string>();
+  for (const item of raw) {
+    const issue = oneIssue(item);
+    if (!issue) return null;
+    const key = `${issue.repo}#${issue.number}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    out.push(issue);
+  }
+  return out;
+}
+
+function storedIssues(raw: string | null) {
+  if (!raw) return [];
+  try {
+    const parsed = normalizeIssues(JSON.parse(raw));
+    return parsed ?? [];
+  } catch {
+    return [];
+  }
+}
+
+function toPublic(row: Row) {
+  return {
+    owner: row.owner_json ? JSON.parse(row.owner_json) : null,
+    participants: JSON.parse(row.participants_json || '[]'),
+    id: row.requirement_id,
+    name: row.title,
+    priority: row.priority,
+    assignee: row.assignee || "",
+    due: row.due_on || "",
+    column: row.column_name,
+    createdAt: row.created_at,
+    issues: storedIssues(row.issues_json),
+  };
+}
+
+async function bodyObject(req: Request): Promise<Record<string, unknown>> {
+  const value = await req.json();
+  if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error("invalid_json");
+  return value as Record<string, unknown>;
+}
+
+function writeNetwork(body: Record<string, unknown>, ctx: RequirementsRequestContext): string | null {
+  if (ctx.auth?.networkId) return ctx.auth.networkId;
+  if (typeof body.network_id === "string" && body.network_id.trim()) return body.network_id.trim();
+  return resolveRestWriteNetworkId(ctx.scope, ctx.auth, ctx.isAdmin);
+}
+
+function canWrite(ctx: RequirementsRequestContext, networkId: string | null): boolean {
+  return !ctx.isNodeToken && canRestWriteNetwork(ctx.auth, networkId, ctx.isAdmin);
+}
+
+const SELECT = "requirement_id, network_id, title, column_name, priority, due_on, assignee, issues_json, created_at, owner_json, participants_json";
+
+type PersonRef = { kind: 'user' | 'node'; id: string };
+function personRef(value: unknown, networkId: string): PersonRef {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) throw new Error('invalid_person');
+  const row = value as Record<string, unknown>;
+  if ((row.kind !== 'user' && row.kind !== 'node') || typeof row.id !== 'string' || !row.id.trim()) throw new Error('invalid_person');
+  const exists = row.kind === 'user'
+    ? db.get("SELECT 1 FROM network_members m JOIN users u ON u.user_id=m.user_id WHERE m.network_id=?1 AND m.user_id=?2", networkId, row.id)
+    : db.get("SELECT 1 FROM nodes WHERE network_id=?1 AND node_id=?2", networkId, row.id);
+  if (!exists) throw new Error('person_not_in_network');
+  return { kind: row.kind, id: row.id };
+}
+
+function assignments(body: Record<string, unknown>, networkId: string, current?: Row) {
+  const owner = 'owner' in body ? body.owner === null ? null : personRef(body.owner, networkId) : current?.owner_json ? JSON.parse(current.owner_json) : null;
+  let participants = current ? JSON.parse(current.participants_json || '[]') : [];
+  if ('participants' in body) {
+    if (!Array.isArray(body.participants) || body.participants.length > 100) throw new Error('invalid_participants');
+    const refs = body.participants.map(value => personRef(value, networkId));
+    participants = [...new Map(refs.map(ref => [`${ref.kind}:${ref.id}`, ref])).values()];
+  }
+  return { ownerJson: owner === null ? null : JSON.stringify(owner), participantsJson: JSON.stringify(participants) };
+}
+
+export async function handleRequirementsRequest(ctx: RequirementsRequestContext): Promise<Response | null> {
+  const { req, url } = ctx;
+  if (url.pathname !== "/api/requirements" && !url.pathname.startsWith("/api/requirements/")) return null;
+  if (ctx.isNodeToken) return jsonError("user_token_required", 403);
+
+  if (url.pathname === '/api/requirements/people' && req.method === 'GET') {
+    const networkId = resolveRestWriteNetworkId(ctx.scope, ctx.auth, ctx.isAdmin);
+    if (!networkId) return jsonError('network_id_required', 400);
+    const users = db.all<{ id: string; name: string }>(
+      "SELECT u.user_id AS id, COALESCE(NULLIF(u.display_name,''), u.username) AS name FROM network_members m JOIN users u ON u.user_id=m.user_id WHERE m.network_id=?1 ORDER BY name, id", networkId,
+    );
+    const nodes = db.all<{ id: string; name: string }>(
+      "SELECT node_id AS id, COALESCE(NULLIF(display_name,''), NULLIF(alias,''), node_name) AS name FROM nodes WHERE network_id=?1 ORDER BY name, id", networkId,
+    );
+    return Response.json({ ok: true, people: [...users.map(row => ({ ...row, kind: 'user', networkId })), ...nodes.map(row => ({ ...row, kind: 'node', networkId }))] });
+  }
+
+  if (url.pathname === "/api/requirements" && req.method === "GET") {
+    const params: unknown[] = [];
+    let sql = `SELECT ${SELECT} FROM requirements WHERE 1=1`;
+    sql = addNetworkScope(sql, params, ctx.scope);
+    sql += " ORDER BY created_at DESC LIMIT 500";
+    const rows = db.all<Row>(sql, ...params).map(toPublic);
+    return Response.json({ ok: true, requirements: rows });
+  }
+
+  if (url.pathname === "/api/requirements" && req.method === "POST") {
+    let body: Record<string, unknown>;
+    try { body = await bodyObject(req); } catch { return jsonError("invalid_json", 400); }
+    const networkId = writeNetwork(body, ctx);
+    if (!networkId) return jsonError("network_id_required", 400);
+    if (!canWrite(ctx, networkId)) return jsonError("permission_denied", 403);
+    const name = typeof body.name === "string" ? body.name.trim() : "";
+    if (!name || name.length > 80) return jsonError("invalid_name", 400);
+    const priority = typeof body.priority === "string" ? body.priority : "normal";
+    if (!PRIORITIES.has(priority)) return jsonError("invalid_priority", 400);
+    const due = typeof body.due === "string" ? body.due.trim() : "";
+    if (due && !dueOk(due)) return jsonError("invalid_due", 400);
+    const assignee = typeof body.assignee === "string" ? body.assignee.trim().slice(0, 80) : "";
+    const clientId = typeof body.client_id === "string" ? body.client_id.trim() : "";
+    if (clientId && !/^[A-Za-z0-9._-]{1,80}$/.test(clientId)) return jsonError("invalid_client_id", 400);
+    const column = typeof body.column === "string" && COLUMNS.has(body.column) ? body.column : "pool";
+    const issues = body.issues === undefined ? [] : normalizeIssues(body.issues);
+    if (issues === null) return jsonError("invalid_issues", 400);
+    if (clientId) {
+      const existing = db.get<Row>(
+        `SELECT ${SELECT} FROM requirements WHERE network_id = ?1 AND client_id = ?2`,
+        networkId, clientId,
+      );
+      if (existing) return Response.json({ ok: true, requirement: toPublic(existing) });
+    }
+    const id = `req_${crypto.randomUUID()}`;
+    const createdAt = new Date().toISOString();
+    let people;
+    try { people = assignments(body, networkId); } catch (e) { return jsonError((e as Error).message, 400); }
+    try {
+      db.run(
+        `INSERT INTO requirements
+         (requirement_id, network_id, title, column_name, priority, due_on, assignee, client_id, issues_json, created_by, created_at, updated_at, owner_json, participants_json)
+         VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10, ?11, ?11, ?12, ?13)`,
+        [id, networkId, name, column, priority, due || null, assignee, clientId || null, JSON.stringify(issues), ctx.auth?.userId ?? null, createdAt, people.ownerJson, people.participantsJson],
+      );
+    } catch {
+      if (!clientId) return jsonError("insert_failed", 500);
+      const existing = db.get<Row>(
+        `SELECT ${SELECT} FROM requirements WHERE network_id = ?1 AND client_id = ?2`,
+        networkId, clientId,
+      );
+      if (!existing) return jsonError("insert_failed", 500);
+      return Response.json({ ok: true, requirement: toPublic(existing) });
+    }
+    const created = db.get<Row>(`SELECT ${SELECT} FROM requirements WHERE requirement_id = ?1`, id)!;
+    return Response.json({ ok: true, requirement: toPublic(created) }, { status: 201 });
+  }
+
+  const match = url.pathname.match(/^\/api\/requirements\/([^/]+)$/);
+  if (!match || req.method !== "PATCH") return jsonError("not_found", 404);
+  const id = decodeURIComponent(match[1]);
+  let body: Record<string, unknown>;
+  try { body = await bodyObject(req); } catch { return jsonError("invalid_json", 400); }
+  const hasColumn = 'column' in body;
+  const hasIssues = Object.prototype.hasOwnProperty.call(body, "issues");
+  const hasName = 'name' in body;
+  const hasPriority = 'priority' in body;
+  const hasDue = 'due' in body;
+  const hasAssignee = 'assignee' in body;
+  if (!hasColumn && !hasIssues && !hasName && !hasPriority && !hasDue && !hasAssignee && !('owner' in body) && !('participants' in body)) return jsonError('empty_patch', 400);
+  if (hasColumn && !COLUMNS.has(String(body.column))) return jsonError("invalid_column", 400);
+  const issues = hasIssues ? normalizeIssues(body.issues) : null;
+  if (hasIssues && issues === null) return jsonError("invalid_issues", 400);
+  const params: unknown[] = [id];
+  let sql = `SELECT ${SELECT} FROM requirements WHERE requirement_id = ?1`;
+  sql = addNetworkScope(sql, params, ctx.scope);
+  const row = db.get<Row>(sql, ...params);
+  if (!row) return jsonError("requirement_not_found", 404);
+  if (!canWrite(ctx, row.network_id)) return jsonError("permission_denied", 403);
+  let name = row.title;
+  if (hasName) {
+    name = typeof body.name === "string" ? body.name.trim() : "";
+    if (!name || name.length > 80) return jsonError("invalid_name", 400);
+  }
+  let priority = row.priority;
+  if (hasPriority) {
+    if (typeof body.priority !== "string" || !PRIORITIES.has(body.priority)) return jsonError("invalid_priority", 400);
+    priority = body.priority;
+  }
+  let due = row.due_on || "";
+  if (hasDue) {
+    if (typeof body.due !== "string") return jsonError("invalid_due", 400);
+    due = body.due.trim();
+    if (due && !dueOk(due)) return jsonError("invalid_due", 400);
+  }
+  let assignee = row.assignee || "";
+  if (hasAssignee) {
+    if (typeof body.assignee !== "string") return jsonError("invalid_assignee", 400);
+    assignee = body.assignee.trim().slice(0, 80);
+  }
+  let people;
+  try { people = assignments(body, row.network_id, row); } catch (e) { return jsonError((e as Error).message, 400); }
+  const updatedAt = new Date().toISOString();
+  db.run(
+    "UPDATE requirements SET column_name = ?1, updated_at = ?2, title = ?7, priority = ?8, due_on = ?9, assignee = ?10, owner_json = ?4, participants_json = ?5, issues_json = ?6 WHERE requirement_id = ?3",
+    [hasColumn ? body.column : row.column_name, updatedAt, row.requirement_id, people.ownerJson, people.participantsJson, hasIssues ? JSON.stringify(issues) : row.issues_json, name, priority, due || null, assignee],
+  );
+  const updated = db.get<Row>(`SELECT ${SELECT} FROM requirements WHERE requirement_id = ?1`, row.requirement_id)!;
+  return Response.json({ ok: true, requirement: toPublic(updated) });
+}

package/src/server.ts

@@ -16,6 +16,7 @@ import { pendingInboxCount } from "./inbox-count.js";
 import { addNetworkScope, canRestWriteNetwork, getUserNetworkIds, resolveRestNetworkScope, resolveRestWriteNetworkId, singleNetworkId, type RestNetworkScope } from "./network-scope.js";
 import { validateAvatarUrl } from "./avatar-validate.js";
 import { narrowTags, parseStoredTags, validateScalarAttr } from "./node-attrs-validate.js";
+import { daemonDefaultWorkdirRoot } from "./create-node-validate.js";
 import { register, login, resolveToken, getUserNetworks, getUserAllNetworks, createNetwork, deleteNetwork, renameNetwork, changePassword, issueUserToken, listTokens, createToken, revokeToken, getNetworkMembers, getUserNetworkRole, addNetworkMember, updateMemberRole, removeNetworkMember, createInvite, joinByInvite, createNetworkTokenForNode, type AuthUser } from "./auth.js";
 import { abortRename, cleanupCommittedRenameSessions, commitRename, prepareRename, resolveCanonicalAlias } from "./rename.js";
 import { sharedSendDedup, buildDuplicateSendPayload } from "./send_dedup.js";
@@ -54,6 +55,7 @@ import { resolveRestFromSession } from "./rest-identity.js";
 import { stampTaskAuthOrigin, type TaskAuthOrigin } from "./task-auth-origin.js";
 import { diagnoseTask } from "./task-diagnostic.js";
 import { assertScheduledTaskBackendSupported, handleScheduledTaskRequest, startScheduledTaskScheduler } from "./scheduled-tasks.js";
+import { handleRequirementsRequest } from "./requirements.js";
 import { handleExternalScheduleEditRequest } from "./external-schedule-edits.js";
 import { recordDeliveredStaleEvents } from "./task-lifecycle-watcher.js";
 import { SIDE_THREAD_FEATURE_FLAG, SideThreadCoordinator, SideThreadPortRegistry, SideThreadStore, type SideThreadActor, type SideThreadAttachmentRef, type SideThreadExecutionPort } from "./side-thread.js";
@@ -1625,6 +1627,16 @@ return Bun.serve({
     });
     if (scheduledResponse) return withCors(req, scheduledResponse);
 
+    const requirementsResponse = await handleRequirementsRequest({
+      req,
+      url,
+      auth: restAuth,
+      isAdmin,
+      isNodeToken: requestToken(req).startsWith("ntok_"),
+      scope: restScope,
+    });
+    if (requirementsResponse) return withCors(req, requirementsResponse);
+
     // ── #473 REST: SSE connection detail (ops-only) ──
     // The per-key breakdown /health used to expose anonymously: keys are
     // `{networkId}:{alias}` (+ `\0netobs:{networkId}` observer keys via
@@ -3419,6 +3431,13 @@ return Bun.serve({
               out.create_capability_observed_ms_ago = observedMsAgo;
             }
           }
+          // app「新建节点」确认页的默认工作目录根。出现即表示该 daemon 认 node_spec.workdir;
+          // 缺席(老 daemon / 老 hub 的 zod 剥掉了它)时 app 藏起那一行、不发 workdir。
+          // 🔴 它是那台机器的家目录路径 —— 与 ip_internal 同级,只给 admin/owner。
+          if (isPrivileged) {
+            const workdirRoot = daemonDefaultWorkdirRoot(r.config_snapshot);
+            if (workdirRoot) out.default_workdir_root = workdirRoot;
+          }
           return out;
         });
       return withCors(req, Response.json({ ok: true, daemons, count: daemons.length }));

package/src/tools.ts

@@ -15,6 +15,8 @@ import {
   validateRuntime,
   validateModel,
   validateChannelsP1,
+  validateWorkdir,
+  daemonDefaultWorkdirRoot,
   validateEnvRefs,
   FLAG_KEYS,
   validateFlagValue,
@@ -712,6 +714,10 @@ export function registerTools(server: McpServer, clientIP?: string, enforceNetwo
           // 不上报这一格 ≠ 0。旧 daemon 压根不发,读的人必须能把
           // 「刚测的」「很久以前测的」「不知道」分成三件事说。
           create_capability_observed_ms_ago: z.number().nullable().catch(null).optional(),
+          // app「新建节点」工作目录:daemon 的默认根。出现即表示该 daemon 认 node_spec.workdir。
+          // `.catch(undefined)`:同上一格的立场 —— 一个诊断/展示字段不许拒掉整份 report。
+          // 读取侧再按形状消毒(create-node-validate.ts daemonDefaultWorkdirRoot)。
+          default_workdir_root: z.string().max(1024).optional().catch(undefined),
         }).optional(),
       }).optional().describe("RFC-024 — masked node config snapshot"),
       // app#225 follow-up — the reporting process answers the `rules_file`
@@ -3740,6 +3746,9 @@ export function registerTools(server: McpServer, clientIP?: string, enforceNetwo
             telemetry.mem_gb = r.session_mem_total_gb ?? null;
             telemetry.ip_internal = r.session_ip ?? null;
           }
+          // 工作目录默认根会暴露那台机器的家目录路径 —— 与 IP 同级,只给 admin/owner
+          // (也只有他们能 create_node)。见 create-node-validate.ts daemonDefaultWorkdirRoot。
+          const workdirRoot = isPrivileged ? daemonDefaultWorkdirRoot(r.config_snapshot) : null;
           return {
             daemon_node_id: r.node_id,
             alias: r.alias,
@@ -3749,6 +3758,7 @@ export function registerTools(server: McpServer, clientIP?: string, enforceNetwo
             runtimes_supported: runtimes,
             allowed_secret_keys: secrets,
             host_telemetry: telemetry,
+            ...(workdirRoot ? { default_workdir_root: workdirRoot } : {}),
           };
         });
 
@@ -3771,6 +3781,9 @@ export function registerTools(server: McpServer, clientIP?: string, enforceNetwo
         flags: z.record(z.string(), z.unknown()).optional(),
         env_refs: z.array(z.string().max(64)).optional(),
         channels: z.array(z.unknown()).optional(),
+        // app「新建节点」确认页的工作目录(绝对路径或 ~/…,daemon 侧展开并校验)。
+        // 缺席 = 老行为:落 daemon 的 cwd。
+        workdir: z.string().max(1024).optional().nullable(),
       }),
       network_id: z.string().max(200).optional(),
     },
@@ -3915,6 +3928,7 @@ export function registerTools(server: McpServer, clientIP?: string, enforceNetwo
         validateRuntime(node_spec.runtime);
         validateModel(node_spec.model);
         validateChannelsP1((node_spec as any).channels);
+        validateWorkdir(node_spec.workdir);
         for (const [k, v] of Object.entries(node_spec.flags || {})) {
           if (!(FLAG_KEYS as readonly string[]).includes(k)) throw new ValidationError("flag_key_unknown", { field: k });
           validateFlagValue(k, v);
@@ -3922,6 +3936,18 @@ export function registerTools(server: McpServer, clientIP?: string, enforceNetwo
       } catch (e) {
         return validationFailReply(e);
       }
+      // 🔴 老 daemon 会**静默忽略** node_spec.workdir,把节点建在它自己的 cwd 里 ——
+      //    用户以为指定了目录,实际落到了别处(常常就是 $HOME)。所以没自报支持的 daemon
+      //    直接拒,而不是派一个会被悄悄改写的请求。app 在这种 daemon 上本就不显示那一行。
+      const requestedWorkdir = typeof node_spec.workdir === "string" ? node_spec.workdir.trim() : null;
+      if (requestedWorkdir && !daemonDefaultWorkdirRoot(daemon.config_snapshot)) {
+        return { content: [{ type: "text" as const, text: JSON.stringify({
+          ok: false,
+          error: "workdir_not_supported_by_daemon",
+          hint: "this daemon's agent-node predates create-node workdir support; upgrade it, or omit workdir to use its current directory",
+          daemon_node_id,
+        }) }] };
+      }
 
       // P1 daemon-side allowlist: if daemon publishes allowed_runtimes,
       // enforce at hub for fast-fail; daemon repeats.
@@ -4007,12 +4033,13 @@ export function registerTools(server: McpServer, clientIP?: string, enforceNetwo
       const envKeys = Object.keys(envBlob);
       db.run(
         `INSERT INTO node_create_requests
-           (request_id, daemon_node_id, child_name, network_id, runtime, model, flags_json, env_keys, status, child_token_id, created_at, created_by_token)
-         VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, 'pending', ?9, ?10, ?11)`,
+           (request_id, daemon_node_id, child_name, network_id, runtime, model, flags_json, env_keys, status, child_token_id, created_at, created_by_token, workdir)
+         VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, 'pending', ?9, ?10, ?11, ?12)`,
         [
           requestId, daemon_node_id, node_spec.name, networkIdForChild,
           node_spec.runtime, node_spec.model ?? null, JSON.stringify(node_spec.flags || {}),
           JSON.stringify(envKeys), childTokenId, Date.now(), callerTokenId || "unknown",
+          requestedWorkdir,
         ],
       );
 
@@ -4035,6 +4062,7 @@ export function registerTools(server: McpServer, clientIP?: string, enforceNetwo
           model: node_spec.model ?? null,
           flag_keys: Object.keys(node_spec.flags || {}),
           env_keys: envKeys,
+          workdir: requestedWorkdir,
         },
       });
 
@@ -4168,8 +4196,8 @@ export function registerTools(server: McpServer, clientIP?: string, enforceNetwo
         return { content: [{ type: "text" as const, text: JSON.stringify({ ok: false, error: "env_blob_unavailable" }) }] };
       }
       // Hydrate spec from row.
-      const specRow = db.get<{ child_name: string; runtime: string; model: string | null; flags_json: string }>(
-        `SELECT child_name, runtime, model, flags_json FROM node_create_requests WHERE request_id = ?1`,
+      const specRow = db.get<{ child_name: string; runtime: string; model: string | null; flags_json: string; workdir: string | null }>(
+        `SELECT child_name, runtime, model, flags_json, workdir FROM node_create_requests WHERE request_id = ?1`,
         request_id,
       );
       if (!specRow) {
@@ -4192,6 +4220,8 @@ export function registerTools(server: McpServer, clientIP?: string, enforceNetwo
             model: specRow.model,
             flags: JSON.parse(specRow.flags_json),
             channels: [],
+            // 只在请求真带了时出现:老 daemon 看不到多余的键,新 daemon 缺席即走老布局。
+            ...(specRow.workdir ? { workdir: specRow.workdir } : {}),
           },
           child_token: blob.child_token,
           env_blob: blob.env_blob,