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

package/package.json

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

package/src/agent-department-http.test.ts

@@ -0,0 +1,148 @@
+// Agent(节点)显式归属部门 —— `PUT /api/networks/:net/nodes/:nodeId/department`。
+//
+// 2026-10-19 现网：组织架构页 4 个部门各「0 个 Agent」、328 个 Agent 全在「未归属」。
+// 原因不是没人管，而是后端**没有**「Agent 属于哪个部门」这个字段：那时的口径只有
+// 「负责人（人）在哪个部门」，于是没有负责人 / 负责人不在部门树里的 Agent 只能算未归属。
+//
+// 这组用例钉住：
+//   1. owner 能把 Agent 放进部门、能改、能清空；
+//   2. 清空后回到「按负责人的部门推断」的旧口径（directory 里 department_id 为 null）；
+//   3. 别的网络的部门 / 不存在的部门 / 不存在的节点都被拒；
+//   4. 普通成员不能改；本部门负责人只能在子树内调动；
+//   5. 通讯录（/api/requirements/people/directory）会把显式部门带给客户端。
+import { describe, expect, test, beforeAll, afterAll } from "bun:test";
+import { mkdtempSync, rmSync } from "fs";
+import { join } from "path";
+import { tmpdir } from "os";
+import { register } from "./auth.js";
+import { db } from "./db.js";
+
+const DIR = mkdtempSync(join(tmpdir(), "anet-agent-dept-"));
+let BASE = "";
+let hub: any = null;
+const PW = "AgentDeptPassw0rd!xyz";
+let NET = "";
+let OTHER_NET = "";
+const U: Record<string, { token: string; id: string }> = {};
+const D: Record<string, string> = {};
+let NODE_A = "";
+let NODE_OUTSIDE = "";
+
+async function send(token: string, method: string, path: string, body?: unknown) {
+  const res = await fetch(`${BASE}${path}`, {
+    method,
+    headers: token ? { Authorization: `Bearer ${token}`, "Content-Type": "application/json" } : { "Content-Type": "application/json" },
+    body: body === undefined ? undefined : JSON.stringify(body),
+  });
+  const text = await res.text();
+  let json: any = null;
+  try { json = JSON.parse(text); } catch {}
+  return { status: res.status, body: json };
+}
+const setDept = (token: string, nodeId: string, department_id: string | null) =>
+  send(token, "PUT", `/api/networks/${NET}/nodes/${nodeId}/department`, { department_id });
+const dept = (token: string, method: string, path = "", body?: unknown) =>
+  send(token, method, `/api/networks/${NET}/departments${path}`, body);
+
+function agentRow(nodeId: string) {
+  return db.get<{ department_id: string | null }>("SELECT department_id FROM nodes WHERE node_id = ?1", nodeId);
+}
+
+beforeAll(async () => {
+  process.env.COMMHUB_DB ||= join(DIR, "hub.db");
+  process.env.COMMHUB_UPLOADS_DIR = join(DIR, "uploads");
+  process.env.HOST = "127.0.0.1";
+  const a = register(`ad_owner_${Date.now()}`, PW, undefined, "Owner");
+  U.owner = { token: a.token!, id: a.user!.user_id };
+  NET = a.network_id!;
+  db.run("UPDATE users SET role = 'admin' WHERE user_id = ?1", [U.owner.id]);
+  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}`;
+
+  // 第二个网络：用来钉「别的网络的部门不能被借来用」。
+  OTHER_NET = `net_other_${Date.now()}`;
+  db.run("INSERT INTO networks (network_id, network_name, owner_id) VALUES (?1, ?1, ?2)", [OTHER_NET, U.owner.id]);
+  db.run("INSERT INTO network_members (network_id, user_id, role) VALUES (?1, ?2, 'owner')", [OTHER_NET, U.owner.id]);
+  db.run("INSERT INTO network_departments (network_id, department_id, name, sort, created_by) VALUES (?1, 'dept_other', '别的网', 0, ?2)", [OTHER_NET, U.owner.id]);
+
+  // 两个部门 + 一个普通成员
+  const made = await dept(U.owner.token, "POST", "", { name: "TMAI" });
+  expect([200, 201]).toContain(made.status);
+  D.tmai = made.body.department.id;
+  const made2 = await dept(U.owner.token, "POST", "", { name: "A 站" });
+  expect([200, 201]).toContain(made2.status);
+  D.a = made2.body.department.id;
+
+  const stamp = Date.now();
+  expect((await send(U.owner.token, "POST", "/api/admin/users", { username: `ad_member_${stamp}`, password: PW, network_id: NET, role: "member" })).status).toBe(200);
+  const login = await send("", "POST", "/api/auth/login", { username: `ad_member_${stamp}`, password: PW });
+  U.member = { token: login.body.token, id: login.body.user.user_id };
+
+  // 两个节点：一个在本网络（无负责人），一个属于别的网络。
+  NODE_A = `n_ad_${stamp}`;
+  NODE_OUTSIDE = `n_ad_out_${stamp}`;
+  db.run(
+    "INSERT INTO nodes (node_id, node_name, alias, network_id, created_at, updated_at) VALUES (?1, '测试员 3 号', '测试员 3 号', ?2, datetime('now'), datetime('now'))",
+    [NODE_A, NET],
+  );
+  db.run(
+    "INSERT INTO nodes (node_id, node_name, alias, network_id, created_at, updated_at) VALUES (?1, '别的网的节点', '别的网的节点', ?2, datetime('now'), datetime('now'))",
+    [NODE_OUTSIDE, OTHER_NET],
+  );
+});
+
+afterAll(() => {
+  try { hub?.stop?.(true); } catch {}
+  rmSync(DIR, { recursive: true, force: true });
+});
+
+describe("Agent 显式归属部门", () => {
+  test("owner 把 Agent 放进部门 → 落库；再改到另一个部门 → 跟随", async () => {
+    const first = await setDept(U.owner.token, NODE_A, D.tmai);
+    expect(first.status).toBe(200);
+    expect(first.body).toMatchObject({ ok: true, node_id: NODE_A, department_id: D.tmai });
+    expect(agentRow(NODE_A)!.department_id).toBe(D.tmai);
+
+    const moved = await setDept(U.owner.token, NODE_A, D.a);
+    expect(moved.status).toBe(200);
+    expect(agentRow(NODE_A)!.department_id).toBe(D.a);
+  });
+
+  test("清空（null / 空串）→ 回到「按负责人推断」的口径", async () => {
+    expect((await setDept(U.owner.token, NODE_A, D.tmai)).status).toBe(200);
+    const cleared = await setDept(U.owner.token, NODE_A, null);
+    expect(cleared.status).toBe(200);
+    expect(cleared.body.department_id).toBeNull();
+    expect(agentRow(NODE_A)!.department_id).toBeNull();
+
+    expect((await setDept(U.owner.token, NODE_A, D.tmai)).status).toBe(200);
+    expect((await setDept(U.owner.token, NODE_A, "")).body.department_id).toBeNull();
+  });
+
+  test("拒绝：别的网络的部门 / 不存在的部门 / 不存在的节点 / 别的网络的节点", async () => {
+    expect((await setDept(U.owner.token, NODE_A, "dept_other")).status).toBe(400);
+    expect((await setDept(U.owner.token, NODE_A, "dept_nope")).status).toBe(400);
+    expect((await setDept(U.owner.token, "n_nope", D.tmai)).status).toBe(404);
+    expect((await setDept(U.owner.token, NODE_OUTSIDE, D.tmai)).status).toBe(404);
+  });
+
+  test("普通成员改不了（403）", async () => {
+    const r = await setDept(U.member.token, NODE_A, D.tmai);
+    expect(r.status).toBe(403);
+  });
+
+  test("通讯录把显式部门带给客户端；清空后回到 null", async () => {
+    expect((await setDept(U.owner.token, NODE_A, D.a)).status).toBe(200);
+    const dir = await send(U.owner.token, "GET", `/api/requirements/people/directory?network_id=${NET}`);
+    expect(dir.status).toBe(200);
+    const agents = [...(dir.body.people ?? []).flatMap((p: any) => p.agents ?? []), ...(dir.body.agents_without_owner ?? [])];
+    const mine = agents.find((a: any) => a.node_id === NODE_A);
+    expect(mine?.department_id).toBe(D.a);
+
+    expect((await setDept(U.owner.token, NODE_A, null)).status).toBe(200);
+    const dir2 = await send(U.owner.token, "GET", `/api/requirements/people/directory?network_id=${NET}`);
+    const agents2 = [...(dir2.body.people ?? []).flatMap((p: any) => p.agents ?? []), ...(dir2.body.agents_without_owner ?? [])];
+    expect(agents2.find((a: any) => a.node_id === NODE_A)?.department_id ?? null).toBeNull();
+  });
+});

package/src/chain-attempt-dedup.test.ts

@@ -0,0 +1,447 @@
+// Node-TMAI#4 — auto-chain: attempt identity, terminal-parent safety,
+// dispatcher participation.
+//
+// This file is the trimmed re-implementation of PR #1940 on current main. The
+// original candidate carried four coupled behavioural changes; two of them
+// contradict decisions this repository made AFTER that candidate was written,
+// so they are deliberately NOT implemented here:
+//
+//   * C — "an `acked` task must expire on its deadline". #519 (task-stale-open.ts)
+//     owns this convergence and made it **activity-based and default-off** on
+//     purpose: a Hub-wide TTL sweep of acked rows would close production history
+//     the moment it ships. `patrolExpiredTasks` therefore keeps
+//     `status IN ('created','delivered')`, and task-stale-open-http.test.ts pins
+//     that an old acked row stays open while #519 is disabled.
+//
+//   * D(parent row) — "a child result must never complete its parent". #690
+//     (scheduled-run-terminal.test.ts) is built on the opposite contract: a
+//     scheduled/dispatched parent whose executor answers through a child must
+//     reach a terminal state and carry its scheduler-run mirror with it.
+//
+//   * A — "never infer parent_task_id". #668 restored the inference on purpose
+//     (`send_task` would otherwise lose the chain whenever a node forgets the id)
+//     and narrowed it to `delivered` only.
+//
+// What IS implemented here, because it is a defect on current main and conflicts
+// with nothing:
+//
+//   T) A TERMINAL parent used to be rewritten: its `result` was appended and its
+//      `completed_at` moved forward long after it finished (observed: 22 minutes
+//      later). The child result is still preserved as an audit row plus a notice
+//      to the parent's author, but the parent row now stays byte-identical.
+//   O) An OPEN parent is still completed by the chain — that is the #690
+//      contract, pinned below so a future edit cannot quietly drop it.
+//   R) One ATTEMPT of a child result is recorded against a parent at most once:
+//      a replayed reply no longer fans out into a second audit row and a second
+//      notice.
+//   N) A fresh attempt of the same task — a legal retry, identified by its inbox
+//      transport row — still gets through, even when both attempts complete in
+//      the same second (`completed_at` has second granularity).
+//   E) The de-dup key binds the ORIGIN of the result, not the walk position, so
+//      a descendant notice cannot consume an ancestor's own completion slot.
+//   P) A same-network caller may not adopt an unrelated third party's task as
+//      its parent (`parent_not_participant`).
+
+import { afterAll, beforeEach, describe, expect, test } from "bun:test";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { db, chainReplyToParent, uuidv4 } from "./db.js";
+import { registerTools } from "./tools.js";
+
+const NET = "net_cpt_dedup";
+const USER = "u_cpt_dedup";
+const PEER = "cpt-peer";     // the session dispatching work outward
+const TARGET = "cpt-target"; // the session receiving the dispatch
+const BOSS = "cpt-boss";     // the originator who reads the answers
+const THIRD = "cpt-third";   // a third party with no involvement
+
+type Handler = (args: any, extra?: any) => Promise<{ content: Array<{ type: "text"; text: string }> }>;
+
+function cleanup(): void {
+  for (const table of ["task_events", "inbox", "scheduled_task_runs", "scheduled_tasks", "tasks", "sessions", "nodes", "network_members", "networks"]) {
+    try { db.run(`DELETE FROM ${table} WHERE network_id = ?1`, [NET]); } catch {}
+  }
+  try { db.run("DELETE FROM users WHERE user_id = ?1", [USER]); } catch {}
+}
+
+function seed(): void {
+  db.run("INSERT INTO users (user_id, username, password_hash, role, created_at) VALUES (?1, ?2, 'x', 'user', datetime('now'))", [USER, 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]);
+  for (const alias of [PEER, TARGET, BOSS, THIRD]) {
+    db.run(
+      `INSERT INTO nodes (node_id, node_name, alias, network_id, lifecycle_state)
+       VALUES (?1, ?2, ?2, ?3, 'active')`,
+      [`n_${alias}`, alias, NET],
+    );
+    db.run(
+      `INSERT INTO sessions (resume_id, alias, status, node_id, network_id, updated_at, last_seen_at)
+       VALUES (?1, ?2, 'idle', ?3, ?4, datetime('now'), datetime('now'))`,
+      [`r_${alias}`, alias, `n_${alias}`, NET],
+    );
+  }
+}
+
+function handlers(): Record<string, Handler> {
+  const server = new McpServer({ name: "test-cpt-dedup", version: "0" }) as any;
+  const out: Record<string, Handler> = {};
+  const original = server.tool.bind(server);
+  server.tool = (name: string, ...args: any[]) => {
+    const h = args.at(-1);
+    if (typeof h === "function") out[name] = h;
+    return original(name, ...args);
+  };
+  registerTools(server, undefined, NET, USER, PEER, false, null);
+  return out;
+}
+
+async function call(handler: Handler, args: any): Promise<any> {
+  const r = await handler(args);
+  return JSON.parse(r.content[0].text);
+}
+
+function insertTask(o: {
+  task_id?: string;
+  from_name: string;
+  to_name: string;
+  status: string;
+  content: string;
+  parent_task_id?: string | null;
+  result?: string | null;
+  completed_at?: string | null;
+  expires_at?: string | null;
+}): string {
+  const id = o.task_id ?? uuidv4();
+  db.run(
+    `INSERT INTO tasks
+       (task_id, from_name, to_name, priority, status, content, requires_response,
+        created_at, network_id, parent_task_id, result, completed_at, expires_at)
+     VALUES (?1, ?2, ?3, 'normal', ?4, ?5, 'reply', datetime('now'), ?6, ?7, ?8, ?9, ?10)`,
+    [id, o.from_name, o.to_name, o.status, o.content, NET, o.parent_task_id ?? null, o.result ?? null, o.completed_at ?? null, o.expires_at ?? null],
+  );
+  return id;
+}
+
+/** A dispatch is identified by its inbox transport row — the same identity the
+ *  chain uses as its attempt key. Tests that want a "fresh attempt" insert one. */
+function insertTransport(taskId: string, to = TARGET, body = "dispatch"): string {
+  const id = `tr_${crypto.randomUUID().replace(/-/g, "").slice(0, 16)}`;
+  db.run(
+    `INSERT INTO inbox (id, session_name, type, priority, content, from_session, task_id, requires_response, network_id)
+     VALUES (?1, ?2, 'task', 'normal', ?3, ?4, ?5, 'reply', ?6)`,
+    [id, to, body, PEER, taskId, NET],
+  );
+  return id;
+}
+
+const taskById = (id: string) =>
+  db.get<{ status: string; result: string | null; completed_at: string | null; parent_task_id: string | null }>(
+    "SELECT status, result, completed_at, parent_task_id FROM tasks WHERE task_id = ?1", id);
+
+/** Audit rows this path appends to a parent (either shape). */
+const chainEvents = (parentId: string) =>
+  db.get<{ c: number }>(
+    "SELECT COUNT(*) AS c FROM task_events WHERE task_id = ?1 AND actor IN ('auto-chain','auto-chain-append')", parentId)?.c ?? 0;
+
+const childNotices = (childText: string) =>
+  db.get<{ c: number }>(
+    "SELECT COUNT(*) AS c FROM inbox WHERE content LIKE ?1", `%${childText}%`)?.c ?? 0;
+
+beforeEach(() => { cleanup(); seed(); });
+afterAll(cleanup);
+
+// ─────────────────────────────────────────────────────────────────────
+// T — a terminal parent is never rewritten
+// ─────────────────────────────────────────────────────────────────────
+
+describe("T — a terminal parent stays byte-identical", () => {
+  const TERMINAL = ["replied", "failed", "cancelled", "expired"];
+
+  for (const state of TERMINAL) {
+    test(`parent status=${state}: status/result/completed_at unchanged; child result recorded`, () => {
+      const ORIGINAL = `ORIGINAL-${state}-ANSWER`;
+      const STAMP = "2026-01-01 00:00:00";
+      const parent = insertTask({
+        from_name: BOSS, to_name: PEER, status: state, content: `cpt-t parent in ${state}`,
+        result: ORIGINAL, completed_at: STAMP,
+      });
+      const child = insertTask({
+        from_name: PEER, to_name: TARGET, status: "replied",
+        content: `cpt-t child for ${state}`, parent_task_id: parent,
+      });
+      insertTransport(child);
+
+      const res = chainReplyToParent(child, `CHILD-ANSWER-FOR-${state}`, "replied", 5, NET);
+
+      const after = taskById(parent);
+      expect(after?.status).toBe(state);
+      expect(after?.result).toBe(ORIGINAL);
+      expect(after?.completed_at).toBe(STAMP);
+
+      // Preserved as an audit row plus a notice — never as the parent's answer.
+      expect(res.chained).toBe(true);
+      expect(chainEvents(parent)).toBe(1);
+      expect(childNotices(`CHILD-ANSWER-FOR-${state}`)).toBe(1);
+    });
+  }
+
+  test("a terminal parent with a NULL result does not gain one", () => {
+    const parent = insertTask({
+      from_name: BOSS, to_name: PEER, status: "cancelled", content: "cpt-t cancelled parent",
+      result: null, completed_at: "2026-02-02 02:02:02",
+    });
+    const child = insertTask({
+      from_name: PEER, to_name: TARGET, status: "replied",
+      content: "cpt-t child of cancelled parent", parent_task_id: parent,
+    });
+    insertTransport(child);
+
+    chainReplyToParent(child, "LATE-CHILD-ANSWER", "replied", 5, NET);
+
+    const after = taskById(parent);
+    expect(after?.status).toBe("cancelled");
+    expect(after?.result).toBeNull();
+    expect(after?.completed_at).toBe("2026-02-02 02:02:02");
+  });
+});
+
+// ─────────────────────────────────────────────────────────────────────
+// O — an OPEN parent is still completed by the chain (#690 contract)
+// ─────────────────────────────────────────────────────────────────────
+
+describe("O — an open parent is still completed by the chain (#690)", () => {
+  for (const state of ["created", "delivered", "acked", "running"]) {
+    test(`parent status=${state}: reaches replied with the child result`, () => {
+      const parent = insertTask({
+        from_name: BOSS, to_name: PEER, status: state, content: `cpt-o parent in ${state}`,
+      });
+      const child = insertTask({
+        from_name: PEER, to_name: TARGET, status: "replied",
+        content: `cpt-o child for ${state}`, parent_task_id: parent,
+      });
+      insertTransport(child);
+
+      chainReplyToParent(child, `OPEN-CHILD-${state}`, "replied", 5, NET);
+
+      const after = taskById(parent);
+      expect(after?.status).toBe("replied");
+      expect(after?.result).toContain(`OPEN-CHILD-${state}`);
+      expect(after?.completed_at).toBeTruthy();
+      expect(chainEvents(parent)).toBe(1);
+      expect(childNotices(`OPEN-CHILD-${state}`)).toBe(1);
+    });
+  }
+});
+
+// ─────────────────────────────────────────────────────────────────────
+// R — one attempt is recorded at most once
+// ─────────────────────────────────────────────────────────────────────
+
+describe("R — a replayed delivery does not fan out twice", () => {
+  test("same attempt replayed: one audit row, one notice, second call not chained", () => {
+    const parent = insertTask({
+      from_name: BOSS, to_name: PEER, status: "delivered", content: "cpt-r replay parent",
+    });
+    const child = insertTask({
+      from_name: PEER, to_name: TARGET, status: "replied",
+      content: "cpt-r replay child", parent_task_id: parent,
+    });
+    insertTransport(child);
+
+    const first = chainReplyToParent(child, "REPLAY-ANSWER", "replied", 5, NET);
+    const second = chainReplyToParent(child, "REPLAY-ANSWER", "replied", 5, NET);
+
+    expect(first.chained).toBe(true);
+    expect(second.chained).toBe(false);
+    expect(chainEvents(parent)).toBe(1);
+    expect(childNotices("REPLAY-ANSWER")).toBe(1);
+  });
+
+  test("a terminal parent dedups its audit row too", () => {
+    const parent = insertTask({
+      from_name: BOSS, to_name: PEER, status: "replied", content: "cpt-r terminal parent",
+      result: "ALREADY-ANSWERED", completed_at: "2026-03-03 03:03:03",
+    });
+    const child = insertTask({
+      from_name: PEER, to_name: TARGET, status: "replied",
+      content: "cpt-r terminal child", parent_task_id: parent,
+    });
+    insertTransport(child);
+
+    expect(chainReplyToParent(child, "TERMINAL-REPLAY", "replied", 5, NET).chained).toBe(true);
+    expect(chainReplyToParent(child, "TERMINAL-REPLAY", "replied", 5, NET).chained).toBe(false);
+    expect(chainEvents(parent)).toBe(1);
+    expect(childNotices("TERMINAL-REPLAY")).toBe(1);
+  });
+});
+
+// ─────────────────────────────────────────────────────────────────────
+// N — a NEW attempt is not swallowed, even in the same second
+// ─────────────────────────────────────────────────────────────────────
+
+describe("N — a legal second attempt keeps its own notice", () => {
+  test("retry queues a new transport row → the second result still records", () => {
+    const parent = insertTask({
+      from_name: BOSS, to_name: PEER, status: "delivered", content: "cpt-n retry parent",
+    });
+    const child = insertTask({
+      from_name: PEER, to_name: TARGET, status: "replied",
+      content: "cpt-n retry child", parent_task_id: parent,
+    });
+    insertTransport(child);
+
+    expect(chainReplyToParent(child, "ATTEMPT-ONE", "replied", 5, NET).chained).toBe(true);
+
+    // retry_task: reset the task, then queue a fresh transport row (same
+    // transaction, new row). Both attempts carry the same second-granularity
+    // delivery stamp — the transport row is what tells them apart.
+    db.run(
+      "UPDATE tasks SET status = 'replied', result = NULL, completed_at = '2026-04-04 04:04:04' WHERE task_id = ?1",
+      [child],
+    );
+    insertTransport(child, TARGET, "retry dispatch");
+    db.run(
+      "UPDATE tasks SET status = 'replied', result = NULL, completed_at = '2026-04-04 04:04:04' WHERE task_id = ?1",
+      [child],
+    );
+
+    expect(chainReplyToParent(child, "ATTEMPT-TWO", "replied", 5, NET).chained).toBe(true);
+    expect(childNotices("ATTEMPT-ONE")).toBe(1);
+    expect(childNotices("ATTEMPT-TWO")).toBe(1);
+    expect(chainEvents(parent)).toBe(2);
+  });
+});
+
+// ─────────────────────────────────────────────────────────────────────
+// E — the key binds the ORIGIN, not the walk position
+// ─────────────────────────────────────────────────────────────────────
+
+describe("E — a descendant notice does not consume the executor's own completion", () => {
+  test("grandparent ← parent ← leaf: leaf notice then parent completion both record", () => {
+    const grandparent = insertTask({
+      from_name: BOSS, to_name: PEER, status: "delivered", content: "cpt-e grandparent",
+    });
+    const parent = insertTask({
+      from_name: PEER, to_name: THIRD, status: "running",
+      content: "cpt-e parent", parent_task_id: grandparent,
+    });
+    const leaf = insertTask({
+      from_name: THIRD, to_name: TARGET, status: "replied",
+      content: "cpt-e leaf", parent_task_id: parent,
+    });
+    insertTransport(leaf);
+    insertTransport(parent, THIRD, "parent dispatch");
+
+    // (1) the leaf answers the parent; the notice also walks up to the
+    //     grandparent.
+    const early = chainReplyToParent(leaf, "LEAF-EARLY", "replied", 5, NET);
+    expect(early.chained).toBe(true);
+    // Two hops carry the same reply: one notice to the parent's author and
+    // one to the grandparent's author.
+    expect(childNotices("LEAF-EARLY")).toBe(2);
+    const afterLeaf = chainEvents(grandparent);
+
+    // (2) the parent — a real executor — now finishes for real.
+    const result = chainReplyToParent(parent, "PARENT-FINAL", "replied", 5, NET);
+    expect(result.chained).toBe(true);
+    expect(childNotices("PARENT-FINAL")).toBe(1);
+
+    // The parent's own completion is a different event from the descendant
+    // notice that already reached the grandparent.
+    expect(chainEvents(grandparent)).toBe(afterLeaf + 1);
+  });
+
+  test("two different leaves under one parent each keep their own notice", () => {
+    const parent = insertTask({
+      from_name: BOSS, to_name: PEER, status: "delivered", content: "cpt-e shared parent",
+    });
+    const firstLeaf = insertTask({
+      from_name: PEER, to_name: TARGET, status: "replied",
+      content: "cpt-e leaf one", parent_task_id: parent,
+    });
+    const secondLeaf = insertTask({
+      from_name: PEER, to_name: THIRD, status: "replied",
+      content: "cpt-e leaf two", parent_task_id: parent,
+    });
+    insertTransport(firstLeaf);
+    insertTransport(secondLeaf, THIRD, "second leaf dispatch");
+
+    expect(chainReplyToParent(firstLeaf, "LEAF-ONE", "replied", 5, NET).chained).toBe(true);
+    expect(chainReplyToParent(secondLeaf, "LEAF-TWO", "replied", 5, NET).chained).toBe(true);
+
+    expect(childNotices("LEAF-ONE")).toBe(1);
+    expect(childNotices("LEAF-TWO")).toBe(1);
+    expect(chainEvents(parent)).toBe(2);
+  });
+});
+
+// ─────────────────────────────────────────────────────────────────────
+// P — an explicit parent requires a participation relation
+// ─────────────────────────────────────────────────────────────────────
+
+describe("P — explicit parent requires a participation relation", () => {
+  test("a third party's task cannot be adopted as parent", async () => {
+    const stranger = insertTask({
+      from_name: BOSS, to_name: THIRD, status: "delivered",
+      content: "cpt-p a task between other parties",
+    });
+
+    const reply = await call(handlers().send_task, {
+      alias: TARGET,
+      task: "cpt-p attempt to adopt a stranger parent",
+      priority: "normal",
+      from_session: PEER,
+      network_id: NET,
+      parent_task_id: stranger,
+    });
+
+    expect(reply.ok).toBe(false);
+    expect(reply.error).toBe("parent_not_participant");
+    const spawned = db.get<{ c: number }>(
+      "SELECT COUNT(*) AS c FROM tasks WHERE content = ?1",
+      "cpt-p attempt to adopt a stranger parent",
+    );
+    expect(spawned?.c).toBe(0);
+    expect(taskById(stranger)?.status).toBe("delivered");
+  });
+
+  test("the parent's own originator may chain a follow-up onto it", async () => {
+    const parent = insertTask({
+      from_name: PEER, to_name: THIRD, status: "delivered",
+      content: "cpt-p parent dispatched by the peer",
+    });
+
+    const reply = await call(handlers().send_task, {
+      alias: TARGET,
+      task: "cpt-p originator follow-up",
+      priority: "normal",
+      from_session: PEER,
+      network_id: NET,
+      parent_task_id: parent,
+    });
+    expect(reply.ok).toBe(true);
+    const child = db.get<{ parent_task_id: string | null }>(
+      "SELECT parent_task_id FROM tasks WHERE content = ?1", "cpt-p originator follow-up");
+    expect(child?.parent_task_id).toBe(parent);
+  });
+
+  test("a cross-network parent is still refused with its own error code", async () => {
+    const foreign = uuidv4();
+    db.run(
+      `INSERT INTO tasks (task_id, from_name, to_name, priority, status, content, requires_response, created_at, network_id)
+       VALUES (?1, ?2, ?3, 'normal', 'delivered', 'cpt-p foreign parent', 'reply', datetime('now'), ?4)`,
+      [foreign, BOSS, THIRD, "net_other_cpt"],
+    );
+
+    const reply = await call(handlers().send_task, {
+      alias: TARGET,
+      task: "cpt-p cross-network parent attempt",
+      priority: "normal",
+      from_session: PEER,
+      network_id: NET,
+      parent_task_id: foreign,
+    });
+    expect(reply.ok).toBe(false);
+    expect(reply.error).toBe("cross_network_parent");
+    db.run("DELETE FROM tasks WHERE task_id = ?1", [foreign]);
+  });
+});

package/src/create-node-tool-schema.test.ts

@@ -22,6 +22,7 @@ describe("create_node MCP schema", () => {
     const base = { name: "v2-node", runtime: "opencode-cli" };
     expect(nodeSpec.safeParse({ ...base, opencodeGeneration: "v2" }).success).toBe(false);
     expect(nodeSpec.safeParse({ ...base, opencodeUnsafeTools: true }).success).toBe(false);
+    expect(nodeSpec.safeParse({ ...base, opencodeNewServer: true }).success).toBe(false);
     const flags = { opencodeGeneration: "v2", opencodeUnsafeTools: true };
     expect(nodeSpec.parse({ ...base, flags }).flags).toEqual(flags);
     expect(nodeSpec.parse(base)).toEqual(base);

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

@@ -241,6 +241,12 @@ describe("buildAnetArgs (§4.2.2 F2 — fully validated argv)", () => {
     expect(() => validateOpenCodeV2ProviderModel("claude-agent-sdk", undefined, { opencodeGeneration: "v2", opencodeUnsafeTools: true })).not.toThrow();
     expect(buildAnetArgs({ name: "x", runtime: "opencode-cli" })).toEqual(["node", "create", "x", "--runtime", "opencode-cli"]);
   });
+  test("OpenCode V2 can opt out of the host shared Server", () => {
+    const args = buildAnetArgs({ name: "v2", runtime: "opencode-cli", model: "stub/model",
+      flags: { opencodeGeneration: "v2", opencodeUnsafeTools: true, opencodeNewServer: true } });
+    expect(args).toContain("--opencode-new-server");
+    expect(() => buildAnetArgs({ name: "v1", runtime: "opencode-cli", flags: { opencodeNewServer: true } })).toThrow();
+  });
   test("omitted model is allowed and does not emit --model", () => {
     const args = buildAnetArgs({
       name: "x", runtime: "codex-sdk",