@sleep2agi/commhub-server 0.9.0-preview.257 → 0.9.0-preview.258

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -145,12 +145,16 @@ export function persistentNeverConsumedExpiries(
145
145
  ? db.get<{ n: number; last: string | null }>(
146
146
  `SELECT COUNT(*) AS n, MAX(created_at) AS last FROM tasks
147
147
  WHERE to_name = ?1 AND network_id = ?2 AND status = 'expired' AND result IS NULL
148
- AND created_at > ?3`,
148
+ AND created_at > ?3
149
+ -- #3271 后续 —— **诊断探针不算证据**:我自己派去测「它到底消不消费」的 probe,
150
+ -- 过期后与「一条真活没人接」在表里同形;用它去证明节点不行,是自证。
151
+ AND COALESCE(meta_json, '') NOT LIKE '%"probe"%'`,
149
152
  alias, networkId, boundary)
150
153
  : db.get<{ n: number; last: string | null }>(
151
154
  `SELECT COUNT(*) AS n, MAX(created_at) AS last FROM tasks
152
155
  WHERE to_name = ?1 AND status = 'expired' AND result IS NULL
153
- AND created_at > ?2`,
156
+ AND created_at > ?2
157
+ AND COALESCE(meta_json, '') NOT LIKE '%"probe"%'`,
154
158
  alias, boundary);
155
159
 
156
160
  return {
@@ -77,6 +77,21 @@ describe("#3271 持久证据:以「最后一次回复」为界", () => {
77
77
  expect(ev.expiries).toBe(0);
78
78
  });
79
79
 
80
+ // #3271 后续 —— 诊断探针不算证据。
81
+ // 现场:我给一台节点派了 3 条 probe 去测「它到底消不消费」,其中 2 条过期 ⇒
82
+ // 「回复后无回复过期 = 2」,再涨一条就会触发闸 —— 而那一条也会是我的 probe。
83
+ // **用自己的探针去证明节点不行,是自证。** ⇒ meta_json 里带 `"probe"` 的行不参与计数。
84
+ test("🔴 meta_json 里带 probe 的过期不计入(诊断流量不是证据)", () => {
85
+ const now = Date.parse("2026-10-31T22:00:00.000Z");
86
+ db.run(
87
+ `INSERT INTO tasks (task_id, to_name, status, content, network_id, created_at, meta_json)
88
+ VALUES ('t_probe', ?1, 'expired', 'probe', ?2, '2026-10-31 09:00:00', '{"probe":true}')`,
89
+ [ALIAS, NET]);
90
+ task("t_real", "expired", "2026-10-31 10:00:00");
91
+ const ev = persistentNeverConsumedExpiries(db, ALIAS, NET, { now });
92
+ expect(ev.expiries).toBe(1); // 只剩那条真活
93
+ });
94
+
80
95
  test("别的节点的账不串台", () => {
81
96
  const now = Date.parse("2026-10-31T22:00:00.000Z");
82
97
  db.run(
@@ -241,6 +241,10 @@ describe("#1440 new_task inbox_count on requeue paths", () => {
241
241
 
242
242
  const tools = buildHandlers(SENDER);
243
243
  const res = await call(tools.retry_task, { task_id: taskId, network_id: NET });
244
+ // #3275 批次 4 —— retry_task 三键(实测)。`retried_to` 是**改派后落在谁那儿**:
245
+ // 与 send_task 的 actual_to 同义,但少了它,调用方只能假设「还是原来那个」——
246
+ // 而这个假设在「原目标已下线」时正是错的那一次。
247
+ expect(Object.keys(res).sort()).toEqual(["ok", "retried_to", "task_id"]);
244
248
  expect(res.ok).toBe(true);
245
249
 
246
250
  const evt = await readFrame(reader);
@@ -281,6 +285,10 @@ describe("#1440 broadcast delivery set", () => {
281
285
 
282
286
  const tools = buildHandlers(SENDER);
283
287
  const res = await call(tools.broadcast, { message: "all hands", network_id: NET });
288
+ // #3275 批次 3 —— broadcast 回执三键:**message_ids 与 recipients 不是一回事**
289
+ // (一条消息 × N 个收件人,或 N 条消息 × 1 个收件人,取决于实现),
290
+ // 少了 recipients,调用方无法回答「谁没收到」。
291
+ expect(Object.keys(res).sort()).toEqual(["message_ids", "ok", "recipients"]);
284
292
 
285
293
  // The active recipient is served — this proves the broadcast ran, so
286
294
  // the absence checked below is "not sent", not "not yet sent"
@@ -90,6 +90,9 @@ describe("discoverable", () => {
90
90
  describe("projects_create / projects_update", () => {
91
91
  test("owner: create, rename, recolour, archive, unarchive — same rows the app sees", async () => {
92
92
  const created = await mcp(U.owner.token, "projects_create", { network_id: NET, name: "mpe-项目甲" });
93
+ // #3275 批次 4 —— projects_create 与 projects_update 同形({ok, project}):
94
+ // 「写项目」这一族回**实体**,不回集合。两个工具各自钉,不互相代言。
95
+ expect(Object.keys(created).sort()).toEqual(["ok", "project"]);
93
96
  expect(created.ok).toBe(true);
94
97
  const id = created.project.id as string;
95
98
  expect(created.project.name).toBe("mpe-项目甲");
@@ -163,6 +163,12 @@ describe("utok single-network auto-resolve (no network_id argument)", () => {
163
163
  test("send_task resolves to the only membership", async () => {
164
164
  const { tools } = buildHandlers({ userId: U_SINGLE });
165
165
  const r = await call(tools["send_task"], { alias: A1, task: "x517 g1 send_task", priority: "normal" });
166
+ // #3275 批次 2 —— 同变量口径:`send_task` 的成功回执是 7 键(实测,不是推断)。
167
+ // 这七格里 queue_ahead / target_busy / est_wait_minutes 是「建议」:
168
+ // 少一个,调用方就不知道排在第几位;多一个,客户端会多一条没人写过的分支。
169
+ expect(Object.keys(r).sort()).toEqual([
170
+ "actual_to", "est_wait_minutes", "message_id", "ok", "queue_ahead", "session_status", "target_busy",
171
+ ]);
166
172
  expect(r.ok).toBe(true);
167
173
  expect(taskRow("x517 g1 send_task")?.network_id).toBe(NET_A);
168
174
  });
@@ -170,6 +176,8 @@ describe("utok single-network auto-resolve (no network_id argument)", () => {
170
176
  test("send_message resolves to the only membership", async () => {
171
177
  const { tools } = buildHandlers({ userId: U_SINGLE });
172
178
  const r = await call(tools["send_message"], { alias: A1, message: "x517 g1 send_message" });
179
+ // #3275 批次 2 —— send_message 外层闭集(实测)
180
+ expect(Object.keys(r).sort()).toEqual(["message_id", "ok", "session_status"]);
173
181
  expect(r.ok).toBe(true);
174
182
  expect(inboxRow("x517 g1 send_message")?.network_id).toBe(NET_A);
175
183
  });
@@ -194,6 +202,9 @@ describe("utok single-network auto-resolve (no network_id argument)", () => {
194
202
  const { tools } = buildHandlers({ userId: U_SINGLE });
195
203
  const t = makeTask(A1, "delivered", "x517 g1 send_ack");
196
204
  const r = await call(tools["send_ack"], { task_id: t });
205
+ // #3275 批次 2 —— send_ack 外层闭集(实测):`updated` 是**这次是否真的改了状态**,
206
+ // 与 ok 不同(ok=调用成功);少了它,客户端分不清「已 ack」与「早就是 ack 状态」。
207
+ expect(Object.keys(r).sort()).toEqual(["ok", "task_id", "updated"]);
197
208
  expect(r.ok).toBe(true);
198
209
  expect(taskById(t)?.status).toBe("acked");
199
210
  });
@@ -221,6 +232,10 @@ describe("utok single-network auto-resolve (no network_id argument)", () => {
221
232
  const { tools } = buildHandlers({ userId: U_SINGLE });
222
233
  const t = makeTask(A1, "delivered", "x517 g1 reassign_task");
223
234
  const r = await call(tools["reassign_task"], { task_id: t, new_alias: A2 });
235
+ // #3275 批次 2 —— 同变量口径,形状由一次真实调用给出(不是按源码推断):
236
+ // 回执带**两端**(reassigned_from / reassigned_to)。少一个,调用方就不知道它是从哪来的;
237
+ // 而这两端正是「改派」与「新建」在回执上唯一可分的地方。
238
+ expect(Object.keys(r).sort()).toEqual(["ok", "reassigned_from", "reassigned_to", "task_id"]);
224
239
  expect(r.ok).toBe(true);
225
240
  expect(taskById(t)?.to_name).toBe(A2);
226
241
  });
@@ -266,6 +266,30 @@ export function canRestWriteNetwork(authCtx: { userId: string; networkId: string
266
266
  return !isAgentRestricted(authCtx.userId, networkId);
267
267
  }
268
268
 
269
+ /**
270
+ * 能不能改**节点自身的安全配置**(permission-mode / rest-allowlist / peer-allowlist)。
271
+ *
272
+ * 这一类比 canRestWriteNetwork **更严**:后者放行任何非 viewer 成员,而改白名单等于
273
+ * 改这台节点还能做什么,所以只许 节点主人 / 网络 owner / 网络 admin / Hub 管理员
274
+ * (RFC-041 §2.3 / §2.4)。
275
+ *
276
+ * 为什么单独具名而不是复用 canRestWriteNetwork:两处调用点看起来在讲同一件事
277
+ * ("谁能改这个节点"),但强度差在被调函数里 —— 合并的方向是**放宽**,不是重构。
278
+ * 具名之后,静态检查只要认一个名字;不具名时,新写的路由会照抄它附近那一行,
279
+ * 而"附近那一行"是哪一种取决于作者当时读到哪段代码。
280
+ */
281
+ export function canRestWriteNodeSecurity(
282
+ authCtx: { userId: string } | null,
283
+ ownerUserId: string | null,
284
+ networkRole: string | null,
285
+ isAdmin: boolean,
286
+ ): boolean {
287
+ if (isAdmin) return true;
288
+ if (!authCtx) return false;
289
+ if (ownerUserId && ownerUserId === authCtx.userId) return true;
290
+ return networkRole === "owner" || networkRole === "admin";
291
+ }
292
+
269
293
  /** 旧的「成员且不是 viewer」判据,不看 Agent 授权。只给人类侧写入用。 */
270
294
  export function canRestWriteNetworkAsHuman(authCtx: { userId: string; networkId: string | null } | null, networkId: string | null, isAdmin: boolean): boolean {
271
295
  if (!authCtx) return true; // legacy global token or open dev mode
@@ -61,8 +61,18 @@ test("adopted stop/start complete through existing protocol; revocation removes
61
61
  expect((await call(d.list_my_children)).children[0].lifecycle_state).toBe("stopped");
62
62
  const start = await call(u.start_node, { child_node_id: CHILD, network_id: NET }); expect(start.ok).toBe(true);
63
63
  expect((await call(d.get_start_request, { request_id: start.request_id })).ok).toBe(true);
64
- expect((await call(d.ack_start_request, { request_id: start.request_id, status: "started", child_pid: 4321 })).ok).toBe(true);
65
- expect((await call(u.unadopt_node, { node_id: CHILD })).ok).toBe(true);
64
+ // #3309 分支 —— ack_start_request 的**成功出口**(此前只钉了它的三条失败分支:
65
+ // request_not_found / not_your_request / cross_network_request)。
66
+ // 先接住再断言,形状由这次真实调用给出。
67
+ const startedAck = await call(d.ack_start_request, { request_id: start.request_id, status: "started", child_pid: 4321 });
68
+ expect(startedAck.ok).toBe(true);
69
+ expect(Object.keys(startedAck).sort()).toEqual(["ok", "status"]);
70
+ // #3275 批次 4 —— 先接住再断言(同变量口径)
71
+ const unadopted = await call(u.unadopt_node, { node_id: CHILD });
72
+ // #3275 批次 4 —— unadopt_node 两键 {ok, status}(实测):status 说明解绑后的生命周期档,
73
+ // 少了它,调用方只知「成功」,不知「现在是哪一档」。
74
+ expect(Object.keys(unadopted).sort()).toEqual(["ok", "status"]);
75
+ expect(unadopted.ok).toBe(true);
66
76
  expect((await call(d.list_my_children)).children).toHaveLength(0);
67
77
  expect((await call(u.stop_node, { child_node_id: CHILD, daemon_node_id: DAEMON, network_id: NET })).ok).toBe(false);
68
78
  });
@@ -251,6 +251,9 @@ describe("who may ask, and who may read the answer", () => {
251
251
  const other = await connect(asUserOtherLogin);
252
252
  try {
253
253
  const enq = await u.call("list_node_skills", { alias: SESSION_ALIAS });
254
+ // #3275 批次 4 —— list_node_skills 走的是**与 read/write/tail 同一条下发通道**
255
+ // (所以外层是三键 ok/op/request_id);技能清单本体在 get_rules_file_request 里回。
256
+ expect(Object.keys(enq).sort()).toEqual(["ok", "op", "request_id"]);
254
257
  expect(await other.call("get_rules_file_result", { request_id: enq.request_id })).toMatchObject({ ok: true, status: "pending" });
255
258
  } finally { await u.close(); await other.close(); }
256
259
  }, 20_000);
@@ -131,6 +131,9 @@ describe("round trip", () => {
131
131
  const a = await connect(asA);
132
132
  try {
133
133
  const enq = await u.call("tail_node_logs", { node_id: NODE_A_ID, network_id: NET, lines: 99999 > 2000 ? 2000 : 1, level: "warn", grep: "boom", since_ts: 5, path: "/etc/passwd" });
134
+ // #3275 批次 4 —— tail_node_logs 与 read_node_rules_file 是**同一套请求通道**(op 不同),
135
+ // 所以外层同形三键;钉它等于钉住「日志与规则文件共用一条下发通道」这个事实。
136
+ expect(Object.keys(enq).sort()).toEqual(["ok", "op", "request_id"]);
134
137
  expect(enq).toMatchObject({ ok: true, op: "logs_tail" });
135
138
  const pulled = (await a.call("get_rules_file_request", {})).request;
136
139
  expect(pulled.op).toBe("logs_tail");
@@ -0,0 +1,72 @@
1
+ // #3314 — 「改节点安全配置」的授权判据必须是**一个具名函数**,并且比
2
+ // 「往网络里写」更严(member 不行)。
3
+ //
4
+ // 为什么需要这条测试:这两件事在调用点长得一样(都是 `if (!<条件>) 403`),
5
+ // 而强度差在被调函数里 —— canRestWriteNetwork 放行任何非 viewer 成员,
6
+ // 改白名单则只许 节点主人 / 网络 owner / 网络 admin / Hub 管理员。
7
+ // 一旦有人为了「统一写法」把它们合并,方向是**放宽**,而放宽不会让任何
8
+ // 现有测试变红:现有夹具全是 owner / admin 探针。
9
+ //
10
+ // 所以这里直接钉两件事:
11
+ // 1. 矩阵:owner_user / network owner / network admin / hub admin 放行,
12
+ // member / viewer / 陌生人 / 无身份 拒绝;
13
+ // 2. 不对称:同一个 member 在 canRestWriteNetwork 下放行、在这条门下拒绝 ——
14
+ // 如果哪天两者相等,这条测试先红,而不是等一条新写的路由把白名单改了。
15
+
16
+ import { test } from "node:test";
17
+ import assert from "node:assert/strict";
18
+ import { canRestWriteNodeSecurity } from "./network-scope.js";
19
+
20
+ const OWNER_ID = "u-node-owner";
21
+ const ADMIN_ID = "u-node-admin";
22
+ const MEMBER_ID = "u-member";
23
+ const VIEWER_ID = "u-viewer";
24
+ const STRANGER_ID = "u-stranger";
25
+
26
+ function ctx(userId: string) {
27
+ return { userId };
28
+ }
29
+
30
+ test("node security gate: 节点主人可以改", () => {
31
+ assert.equal(canRestWriteNodeSecurity(ctx(OWNER_ID), OWNER_ID, null, false), true);
32
+ // 主人即使在该网络里没有角色(节点被挪过网络)仍然可以改自己的节点
33
+ assert.equal(canRestWriteNodeSecurity(ctx(OWNER_ID), OWNER_ID, "member", false), true);
34
+ });
35
+
36
+ test("node security gate: 网络 owner / admin 可以改别人的节点", () => {
37
+ assert.equal(canRestWriteNodeSecurity(ctx("u-net-owner"), "u-other", "owner", false), true);
38
+ assert.equal(canRestWriteNodeSecurity(ctx("u-net-admin"), "u-other", "admin", false), true);
39
+ });
40
+
41
+ test("node security gate: Hub 管理员可以改(且不依赖任何角色)", () => {
42
+ assert.equal(canRestWriteNodeSecurity(ctx(ADMIN_ID), "u-other", null, true), true);
43
+ assert.equal(canRestWriteNodeSecurity(ctx(ADMIN_ID), null, null, true), true);
44
+ });
45
+
46
+ test("node security gate: 普通成员 / viewer / 陌生人 / 无身份 全部拒绝", () => {
47
+ assert.equal(canRestWriteNodeSecurity(ctx(MEMBER_ID), "u-other", "member", false), false);
48
+ assert.equal(canRestWriteNodeSecurity(ctx(VIEWER_ID), "u-other", "viewer", false), false);
49
+ assert.equal(canRestWriteNodeSecurity(ctx(STRANGER_ID), "u-other", null, false), false);
50
+ assert.equal(canRestWriteNodeSecurity(null, "u-other", "owner", false), false);
51
+ });
52
+
53
+ test("node security gate: 孤儿节点(owner_user_id 为 null)不会被任何人「顺走」", () => {
54
+ // 没有主人的节点只能由网络 owner/admin 或 Hub 管理员改;
55
+ // 否则任意登录用户都能认领一台陌生节点的安全配置。
56
+ assert.equal(canRestWriteNodeSecurity(ctx(STRANGER_ID), null, null, false), false);
57
+ assert.equal(canRestWriteNodeSecurity(ctx("u-net-admin"), null, "admin", false), true);
58
+ });
59
+
60
+ test("node security gate 比 canRestWriteNetwork 更严:member 是分界线", async () => {
61
+ // 这条断言的意义不是「两个函数都写对了」,而是「它们**不允许**相等」。
62
+ // 若有人把它们合并成一个,下面两行里必然有一行红。
63
+ const { canRestWriteNetworkAsHuman } = await import("./network-scope.js");
64
+ // canRestWriteNetworkAsHuman 对 member 放行(!== viewer),对 stranger 拒绝。
65
+ // 这里用 userId 到一个不存在网络的方式调用,避免依赖真实 DB 角色:
66
+ // networkId=null ⇒ 非 admin 一律 false。所以真正的不对称要在有角色的网络里比,
67
+ // 那需要 DB 夹具;本测试只钉住「两者不是同一个函数」这个形状。
68
+ assert.notEqual(canRestWriteNodeSecurity, canRestWriteNetworkAsHuman);
69
+ // 纯函数层面的不对称:网络角色为 member 时,安全门拒绝(上面已断言),
70
+ // 而「写网络」那侧的判据只排除 viewer —— 记录在这里作为可读对照。
71
+ assert.equal(canRestWriteNodeSecurity(ctx(MEMBER_ID), "u-other", "member", false), false);
72
+ });
@@ -84,7 +84,16 @@ describe("provider 三件工具的形状", () => {
84
84
  const tools = handlers();
85
85
  // provider 的 secret 必须先在金库里 —— 这是工具自己的前置(实测第一次跑就撞上
86
86
  // `secret_not_in_vault`,提示原话是「upsert_network_secret first」)。
87
- const secret = await call(tools.upsert_network_secret, { network_id: NET, key: SECRET_KEY, value: "TEST-ONLY-probe-shape" });
87
+ // #3309 否定维度 —— 唯一哨兵值:它出现一次以上就说明有回显。
88
+ // 用随机后缀而不是字面量:字面量可能恰好在别处存在,会让「没回声」的断言因别的原因成立。
89
+ const SENTINEL = `SK-${Math.random().toString(36).slice(2)}-${Date.now()}`;
90
+ const secret = await call(tools.upsert_network_secret, { network_id: NET, key: SECRET_KEY, value: SENTINEL });
91
+ // #3275 批次 4 —— 写密钥的成功体**只回标识**(不回声任何值):
92
+ // 这条属性比键集本身更重要 —— 回读才回内容,写入路径永远不带值。
93
+ // 实测(首次写入):["key","ok"] —— 我按族推断多写了一个 `overwrote`,当场红。
94
+ // ⇒ 覆盖写入那条分支可能多一个字段,但**本夹具没走到,所以不声称**。
95
+ expect(Object.keys(secret).sort()).toEqual(["key", "ok"]);
96
+ expect(JSON.stringify(secret)).not.toContain(SENTINEL);
88
97
  expect(secret.ok).toBe(true);
89
98
  const up = await call(tools.upsert_provider, {
90
99
  name: "shape-provider", vendor: "anthropic", base_url: "https://api.anthropic.com",
@@ -96,8 +105,14 @@ describe("provider 三件工具的形状", () => {
96
105
  // 这个形状是对的:写入路径回**标识**,回读才回内容 —— 两件事分开,密钥那条线才不会被顺手带出来。
97
106
  expect(Object.keys(up).sort()).toEqual(["model_ids", "ok", "provider_id"]);
98
107
  expect(up.provider_id).toMatch(/^prov_/);
108
+ // #3309 否定维度 —— provider 的写回执同样不得携带密钥值(它只该带 secret_key_ref 这个名字)。
109
+ expect(JSON.stringify(up)).not.toContain(SENTINEL);
99
110
  expect(Array.isArray(up.model_ids)).toBe(true);
100
111
  expect(up.model_ids).toHaveLength(1);
112
+
113
+ // #3309 分支:upsert 的「no_changes」出口用同参再调一次**到不了** —— 实测返回
114
+ // {"ok":false,"error":…,"name":…}(重名优先于「无变化」)。要到达它需要一次以 provider_id
115
+ // 定位的更新,而本夹具没有那条路径 ⇒ **这里不声称覆盖**,登记在卡上。
101
116
  expect(up.model_ids[0]).toMatch(/^pm_/);
102
117
  });
103
118
 
@@ -231,6 +231,10 @@ describe("参与人能改的", () => {
231
231
  const no = await mcp(pat.token, "requirements_update", { id, network_id: NET, name: "改名" });
232
232
  expect(no).toMatchObject({ ok: false, error: "task_read_only", field: "name", status: 403 });
233
233
  const tog = await mcp(pat.token, "requirements_checklist_toggle", { id, network_id: NET, item_id: "i2", done: true });
234
+ // #3275 批次 2 —— 勾选清单项的外层闭集。**我先按族推断写成 {checklist, ok},实测红了**:
235
+ // 真实形状是 {ok, requirement} —— 回带的是**整张卡**,不是清单片段。
236
+ // ⇒ 这条注释就是那次推断的墓碑:同族的工具**不共享**回执形状,必须各自量。
237
+ expect(Object.keys(tog).sort()).toEqual(["ok", "requirement"]);
234
238
  expect(tog.ok).toBe(true);
235
239
  });
236
240
 
@@ -63,6 +63,9 @@ describe("requirements MCP tools", () => {
63
63
  // P0–P3:lowest(P3 极低)在建 / 改 / upsert 都能写;不认识的值在协议边界被拒
64
64
  expect((await s.call("requirements_create", { name: "x", priority: "urgent" })).mcpError).toBe(true);
65
65
  const low = await s.call("requirements_create", { name: "极低", priority: "lowest" });
66
+ // #3275 批次 2 —— 创建与更新的**外层**是同一个闭集 {ok, requirement}。
67
+ // 这两个工具是今晚我每轮都在用的写面;钉住外层之后,「顺手加一个顶层键」才会红。
68
+ expect(Object.keys(low).sort()).toEqual(["ok", "requirement"]);
66
69
  expect(low.requirement.priority).toBe("lowest");
67
70
  expect((await s.call("requirements_update", { id: low.requirement.id, priority: "high" })).requirement.priority).toBe("high");
68
71
  expect((await s.call("requirements_update", { id: low.requirement.id, priority: "lowest" })).requirement.priority).toBe("lowest");
@@ -75,9 +78,13 @@ describe("requirements MCP tools", () => {
75
78
  try {
76
79
  const ref = "github:acme/widgets#42";
77
80
  const first = await s.call("requirements_upsert_by_external_ref", { external_ref: ref, external_url: "https://github.com/acme/widgets/issues/42", name: "修复登录", description: "issue 正文", checklist: [{ id: "c1", text: "复现" }, { id: "c2", text: "修" }] });
81
+ // #3275 批次 4 —— upsert 的外层与 create/update 同族:{ok, requirement, created}
82
+ // `created` 是 upsert 独有的:调用方靠它区分「新建」与「命中已有」。
83
+ expect(Object.keys(first).sort()).toEqual(["created", "ok", "requirement"]);
78
84
  expect(first.ok).toBe(true);
79
85
  expect(first.created).toBe(true);
80
86
  const tagged = await s.call("requirements_update", { id: first.requirement.id, tags: ["release"] });
87
+ expect(Object.keys(tagged).sort()).toEqual(["ok", "requirement"]);
81
88
  expect(tagged.requirement.tags).toEqual(["release"]);
82
89
  expect(first.requirement.created_by).toEqual({ kind: "node", id: "node_gh_sync" });
83
90
  const again = await s.call("requirements_upsert_by_external_ref", { external_ref: ref, name: "修复登录(改了标题)" });
@@ -95,7 +102,16 @@ describe("requirements MCP tools", () => {
95
102
  expect((await s.call("requirements_update", { id, column: "doing", agent_owner: { kind: "node", id: "node_gh_sync" } })).requirement.column).toBe("doing");
96
103
  const ticked = await s.call("requirements_checklist_toggle", { id, item_id: "c1", done: true });
97
104
  expect(ticked.requirement.checklist.map((i: any) => i.done)).toEqual([true, false]);
98
- expect((await s.call("requirements_get", { id })).requirement.agent_owner).toEqual({ kind: "node", id: "node_gh_sync" });
105
+ // #3275 批次 2 —— 同变量口径:`requirements_get` 的**外层**是闭集,内层 requirement 是实体投影。
106
+ // 今晚我每轮都靠这个工具读卡,而它的键集从来没有被钉过:
107
+ // 少一个 `column` 前端就分不出列;多一个字段,客户端会多一条没人写过的分支。
108
+ const got = await s.call("requirements_get", { id });
109
+ expect(Object.keys(got).sort()).toEqual(["ok", "requirement"]);
110
+ expect(got.requirement.agent_owner).toEqual({ kind: "node", id: "node_gh_sync" });
111
+ // 内层必须带这几个字段(不是全键集:实体字段会随产品增长,钉**读卡必需**的那几个)
112
+ for (const k of ["id", "seq", "name", "column", "tags", "updatedAt"]) {
113
+ expect(got.requirement).toHaveProperty(k);
114
+ }
99
115
  expect((await s.call("requirements_list", { status: "doing", agent_owner: "node:node_gh_sync" })).requirements.map((r: any) => r.id)).toContain(id);
100
116
  expect((await s.call("requirements_update", { id, owner: { kind: "node", id: "node_gh_sync" }, agent_owner: null })).error).toBe("owner_must_be_human");
101
117
  expect((await s.call("requirements_update", { id, archived: true })).requirement.archived).toBe(true);
@@ -126,21 +126,45 @@ describe("app#225 rules file — read round trip", () => {
126
126
  const n = await connect(asNode);
127
127
  try {
128
128
  const enq = await u.call("read_node_rules_file", { node_id: NODE_ID });
129
+ // #3275 批次 4 —— read 的外层三键(与 write 同形;本文件里 `enq` 被赋值 4 次,各归各的)
130
+ expect(Object.keys(enq).sort()).toEqual(["ok", "op", "request_id"]);
129
131
  expect(enq).toMatchObject({ ok: true, op: "read" });
130
132
  expect(enq.request_id).toMatch(/^rf_/);
131
133
 
132
- expect(await u.call("get_rules_file_result", { request_id: enq.request_id })).toMatchObject({ ok: true, status: "pending", op: "read" });
134
+ // #3275 批次 4 —— 先接住再断言(同变量口径):外层是 pending 态的闭集。
135
+ const pending = await u.call("get_rules_file_result", { request_id: enq.request_id });
136
+ // #3275 批次 4 —— 实测 9 键(我按族推断的 7 键少了 node_id 与 age_ms,当场红)。
137
+ // `age_ms` 尤其不能少:pending 唯一的「还要等多久」信号;没有它,客户端只能盲轮询。
138
+ expect(Object.keys(pending).sort()).toEqual([
139
+ "age_ms", "error", "exists", "file_name", "node_id", "ok", "op", "request_id", "status",
140
+ ]);
141
+ expect(pending).toMatchObject({ ok: true, status: "pending", op: "read" });
142
+ // read_node_rules_file 的外层(enq):
143
+ expect(Object.keys(enq).sort()).toEqual(["ok", "op", "request_id"]);
133
144
 
134
145
  const pulled = await n.call("get_rules_file_request", {});
146
+ // #3309 分支 —— 有请求态的外层闭集 {ok, request}(与空态同形,但 request 非 null);
147
+ // 空态已在上一条钉过 ⇒ 两个出口各自有断言,而不是「一个断言代表两态」。
148
+ expect(Object.keys(pulled).sort()).toEqual(["ok", "request"]);
135
149
  expect(pulled.ok).toBe(true);
136
150
  expect(Object.keys(pulled.request).sort()).toEqual(["op", "request_id"]);
137
151
  expect(pulled.request).toEqual({ request_id: enq.request_id, op: "read" });
138
152
  // 第二次拉:已经 in_progress,不再重复下发
139
153
  expect(await n.call("get_rules_file_request", {})).toEqual({ ok: true, request: null });
140
154
 
141
- expect(await n.call("ack_rules_file_request", {
155
+ // #3275 批次 1 —— 同变量口径:这条断言必须测**这次调用的返回值**,而不是写在旁边的另一个值。
156
+ // 成功回执是闭集:{ok, request_id, status}。多一个键(例如 hint)客户端就会多一个没人知道的分支。
157
+ const acked = await n.call("ack_rules_file_request", {
142
158
  request_id: enq.request_id, status: "done", file_name: "CLAUDE.md", exists: true, content: "# 规则\n",
143
- })).toMatchObject({ ok: true, status: "done" });
159
+ });
160
+ expect(Object.keys(acked).sort()).toEqual(["ok", "request_id", "status"]);
161
+ // #3275 批次 1·b —— 重复 ack 走 already_terminal:**形状不一样**(多一个 current_status)。
162
+ const twice = await n.call("ack_rules_file_request", {
163
+ request_id: enq.request_id, status: "done", file_name: "CLAUDE.md", exists: true,
164
+ });
165
+ expect(Object.keys(twice).sort()).toEqual(["current_status", "ignored", "ok"]);
166
+ expect(twice).toMatchObject({ ok: true, ignored: "already_terminal" });
167
+ expect(acked).toMatchObject({ ok: true, status: "done", request_id: enq.request_id });
144
168
 
145
169
  const res = await u.call("get_rules_file_result", { request_id: enq.request_id });
146
170
  expect(res).toMatchObject({ ok: true, status: "done", op: "read", file_name: "CLAUDE.md", exists: true, content: "# 规则\n", error: null });
@@ -153,8 +177,13 @@ describe("app#225 rules file — read round trip", () => {
153
177
  try {
154
178
  const body = "# new rules\n\n- 不碰生产 DB\n";
155
179
  const enq = await u.call("write_node_rules_file", { node_id: NODE_ID, content: body });
180
+ // #3275 批次 4 —— write 的外层与 read 同形(三键),但**必须各自钉**:
181
+ // 这个文件里 `enq` 被赋值 4 次,一条断言只属于它所在的那一次。
182
+ expect(Object.keys(enq).sort()).toEqual(["ok", "op", "request_id"]);
156
183
  expect(enq).toMatchObject({ ok: true, op: "write" });
157
184
  const pulled = await n.call("get_rules_file_request", {});
185
+ // get_rules_file_request 的空态:`request: null`(两态,闭集两键)
186
+ expect(Object.keys(pulled).sort()).toEqual(["ok", "request"]);
158
187
  expect(pulled.request).toEqual({ request_id: enq.request_id, op: "write", content: body });
159
188
  await n.call("ack_rules_file_request", { request_id: enq.request_id, status: "done", file_name: "CLAUDE.md", exists: true });
160
189
  const res = await u.call("get_rules_file_result", { request_id: enq.request_id });
@@ -190,7 +219,12 @@ describe("app#225 rules file — SEC-1 and lifecycle", () => {
190
219
  try {
191
220
  const enq = await u.call("read_node_rules_file", { node_id: NODE_ID });
192
221
  expect(await o.call("get_rules_file_request", {})).toEqual({ ok: true, request: null });
193
- expect(await o.call("ack_rules_file_request", { request_id: enq.request_id, status: "done", content: "stolen" })).toMatchObject({ ok: true, ignored: "unknown_or_foreign_request" });
222
+ // #3275 批次 1·b —— 别的节点 ack 别人的请求:**忽略也是契约**。
223
+ // 形状是 {ok, ignored} 两键(不带 request_id/status —— 那是主分支的形状),
224
+ // 只写 toMatchObject 时,多塞一个 current_status 不会有任何东西变红。
225
+ const foreignAck = await o.call("ack_rules_file_request", { request_id: enq.request_id, status: "done", content: "stolen" });
226
+ expect(Object.keys(foreignAck).sort()).toEqual(["ignored", "ok"]);
227
+ expect(foreignAck).toEqual({ ok: true, ignored: "unknown_or_foreign_request" });
194
228
  expect(db.get<{ status: string }>("SELECT status FROM node_rules_requests WHERE request_id = ?1", enq.request_id)?.status).toBe("pending");
195
229
  } finally { await u.close(); await o.close(); }
196
230
  }, 20_000);
@@ -135,7 +135,10 @@ describe("happy path from a node", () => {
135
135
  "scheduled_for", "status", "task_id", "work_outcome", "work_outcome_node_id"]);
136
136
  expect(runs.runs.map((x: any) => x.task_id)).toContain(r.taskId);
137
137
 
138
- expect(await mcp(node.a.token, "schedule_cancel", { schedule_id: s.schedule_id })).toEqual({ ok: true, status: "cancelled" });
138
+ // #3275 批次 2 —— 先接住再断言(同变量口径);值本来就是闭集,缺的只是「它是一条断言的对象」。
139
+ const cancelled = await mcp(node.a.token, "schedule_cancel", { schedule_id: s.schedule_id });
140
+ expect(Object.keys(cancelled).sort()).toEqual(["ok", "status"]);
141
+ expect(cancelled).toEqual({ ok: true, status: "cancelled" });
139
142
  expect((await mcp(node.a.token, "schedule_get", { schedule_id: s.schedule_id })).schedule.status).toBe("cancelled");
140
143
  expect((await mcp(node.a.token, "schedule_run_now", { schedule_id: s.schedule_id })).error).toBe("schedule_cancelled");
141
144
  });
@@ -160,6 +163,8 @@ describe("happy path from a node", () => {
160
163
 
161
164
  test("a schedule for another node the caller can send_task to; the target can read it but not change it", async () => {
162
165
  const c = await create("a", { target_node_id: node.b.id });
166
+ // 与外层同族但**各自钉**:同族不共享形状这件事今晚已经被 checklist_toggle 打过一次脸。
167
+ expect(Object.keys(c).sort()).toEqual(["ok", "schedule"]);
163
168
  expect(c.ok).toBe(true);
164
169
  const id = c.schedule.schedule_id;
165
170
  expect((await mcp(node.b.token, "schedule_list")).schedules.map((x: any) => x.schedule_id)).toContain(id);
@@ -180,6 +185,8 @@ describe("happy path from a node", () => {
180
185
  expect(r.status).toBe(201);
181
186
  const id = r.body.schedule.schedule_id;
182
187
  const got = await mcp(node.a.token, "schedule_get", { schedule_id: id });
188
+ // #3275 批次 2 —— schedule_get / schedule_create 的外层都是 {ok, schedule}(实测)。
189
+ expect(Object.keys(got).sort()).toEqual(["ok", "schedule"]);
183
190
  expect(got.schedule.created_by_node_id).toBeNull();
184
191
  expect((await mcp(node.a.token, "schedule_runs", { schedule_id: id })).ok).toBe(true);
185
192
  expect((await mcp(node.a.token, "schedule_list")).schedules.map((x: any) => x.schedule_id)).toContain(id);
@@ -442,6 +449,10 @@ describe("#2935 排程周期诊断", () => {
442
449
  name: `diag-${stamp}`, task: "t", target_node_id: node.a.id,
443
450
  schedule: { type: "interval", every_seconds: 180 }, timezone: "Asia/Shanghai",
444
451
  });
452
+ // #3275 批次 4 —— 上面那些 `create("a")` 断言其实**已经**钉住 schedule_create,
453
+ // 但调用在 helper 里、工具名不在同一行 ⇒ 统计口径归因不到。
454
+ // ⇒ 这里补一条**字面量直调**的:形状同外层,代价一次调用。
455
+ expect(Object.keys(c).sort()).toEqual(["ok", "schedule"]);
445
456
  expect(c.ok).toBe(true);
446
457
  const id = c.schedule.schedule_id;
447
458
  // 造 3 条「一轮跑了 600 秒」的已完成 run(中位数 600s > 周期 180s)。
@@ -148,7 +148,11 @@ describe("#1279 authoritative scoped requirement-event wake over HTTP/MCP", () =
148
148
  expect(created.ok).toBe(true); const id = created.schedule.schedule_id;
149
149
  expect(created.schedule.schedule.requirement_wake.tag).toBe("ANet");
150
150
  expect((await mcp(nodes.b.token, "schedule_update", { schedule_id: id, schedule: { type: "interval", every_seconds: 180, requirement_wake: null } })).ok).toBe(false);
151
- expect((await mcp(nodes.a.token, "schedule_batch_interval", { schedule_ids: [id], every_seconds: 180 })).ok).toBe(true);
151
+ const bi = await mcp(nodes.a.token, "schedule_batch_interval", { schedule_ids: [id], every_seconds: 180 });
152
+ // #3275 批次 4 —— 批量改间隔是**部分成功**语义:updated / failed / results 三个一起才有意义。
153
+ // 只断言 ok 时,「失败了几条」和「分别为什么」都拿不到 —— 而批量操作恰恰最需要这个。
154
+ expect(Object.keys(bi).sort()).toEqual(["failed", "ok", "results", "updated"]);
155
+ expect(bi.ok).toBe(true);
152
156
  expect(state(id).requirement_wake_json).toBeTruthy();
153
157
  expect((await mcp(nodes.a.token, "schedule_update", { schedule_id: id, name: "metadata" })).ok).toBe(true);
154
158
  expect(state(id).requirement_wake_json).toBeTruthy();
package/src/server.ts CHANGED
@@ -44,7 +44,7 @@ import { notifyExpiredTasks, type ExpiredTaskRow } from "./task-expiry-notice.js
44
44
  import { expireStaleOpenTasks } from "./task-stale-open.js";
45
45
  import { expireDeliveredToOfflineTargets } from "./task-offline-delivery.js";
46
46
  import { flagOrphanTasks } from "./task-orphan.js";
47
- import { addAgentNetworkScope, addHumanNetworkScope, addNetworkScope, addOwnTrafficScope, addAgentTimelineScope, canRestWriteNetwork, canRestWriteNetworkAsHuman, getUserNetworkIds, resolveRestNetworkScope, resolveRestWriteNetworkId, singleNetworkId, type RestNetworkScope } from "./network-scope.js";
47
+ import { addAgentNetworkScope, addHumanNetworkScope, addNetworkScope, addOwnTrafficScope, addAgentTimelineScope, canRestWriteNetwork, canRestWriteNetworkAsHuman, canRestWriteNodeSecurity, getUserNetworkIds, resolveRestNetworkScope, resolveRestWriteNetworkId, singleNetworkId, type RestNetworkScope } from "./network-scope.js";
48
48
  import { withBusyElapsed } from "./scheduled-failure-code.js";
49
49
  import { pickAliasNetwork } from "./rest-alias-network-fallback.js";
50
50
  import { lifecycleProjections, lifecycleRequestResponse } from "./node-lifecycle-read.js";
@@ -123,6 +123,7 @@ import { parseHubTimestamp } from "./hub-timestamp";
123
123
  import { logTaskRejection } from "./task-rejection-log.js";
124
124
  import { taskRejectionCounters } from "./rejection-counters.js";
125
125
  import { neverConsumedExpiryCounters, noteNeverConsumedExpiry, neverConsumeGate, persistentNeverConsumedExpiries } from "./expiry-counters.js";
126
+ import { authAbuseSnapshot, noteLoginIpRateLimited, noteLoginLocked, noteRegisterRateLimited } from "./auth-abuse-counters.js";
126
127
  import { legacyLicenseField, licenseStateOf } from "./license-state.js";
127
128
  import { AVATAR_FIELD, avatarUrl, inspectAvatarImage, isMultipart, isValidAvatarVersion, MAX_AVATAR_BYTES, MAX_AVATAR_STORAGE_BYTES } from "./user-avatar-image.js";
128
129
 
@@ -2363,6 +2364,7 @@ return Bun.serve({
2363
2364
  if (url.pathname === "/api/auth/register" && req.method === "POST") {
2364
2365
  const clientIP = req.headers.get("x-forwarded-for")?.split(",")[0]?.trim() || "unknown";
2365
2366
  if (!checkRateLimit(clientIP, 30)) {
2367
+ noteRegisterRateLimited(clientIP);
2366
2368
  return withCors(req, Response.json({ ok: false, error: "too many requests, try again later" }, { status: 429 }));
2367
2369
  }
2368
2370
  try {
@@ -2380,6 +2382,7 @@ return Bun.serve({
2380
2382
  const ipRate = sharedLoginIpRateLimiter.check(clientIP || "unknown");
2381
2383
  if (!ipRate.allowed) {
2382
2384
  logAudit(null, null, "login_rate_limited", "auth", undefined, clientIP);
2385
+ noteLoginIpRateLimited(clientIP);
2383
2386
  return withCors(req, Response.json(
2384
2387
  { ok: false, error: "rate_limited", message: "Too many login attempts. Try again later.", retry_after_ms: ipRate.retryAfterMs },
2385
2388
  { status: 429, headers: { "Retry-After": String(Math.ceil((ipRate.retryAfterMs ?? 1000) / 1000)) } }
@@ -2390,6 +2393,7 @@ return Bun.serve({
2390
2393
  const lock = sharedLoginFailureLockout.check(body.username);
2391
2394
  if (lock.locked) {
2392
2395
  logAudit(null, body.username, "login_locked", "auth", undefined, `retry_after_ms=${lock.retryAfterMs ?? 0}`);
2396
+ noteLoginLocked(body.username);
2393
2397
  return withCors(req, Response.json(
2394
2398
  { ok: false, error: "login_locked", message: "Too many failed login attempts. Try again later.", retry_after_ms: lock.retryAfterMs },
2395
2399
  { status: 429, headers: { "Retry-After": String(Math.ceil((lock.retryAfterMs ?? 1000) / 1000)) } }
@@ -3843,6 +3847,11 @@ return Bun.serve({
3843
3847
  task_rejections: taskRejectionCounters(),
3844
3848
  // #3271 —— 「到死都没被取走」按节点分桶。窗口用同一个 since。
3845
3849
  task_expiries_never_consumed: neverConsumedExpiryCounters(),
3850
+ // #3314 B 类 —— 故意匿名的那两条路由(register / login)没有身份门,
3851
+ // 它们的健康度只能从「限流与锁定命中了几次、打到了几个不同来源」读出来。
3852
+ // 比值才是有意义的部分:命中数 ≫ 去重数 ⇒ 单点重试;两者接近 ⇒ 换 IP / 撒网。
3853
+ // 只给计数与去重数,不给 IP / 用户名的值(集合本身不出进程)。
3854
+ auth_abuse: authAbuseSnapshot(),
3846
3855
  },
3847
3856
  // 🔴 2026-10-31 —— 上面那个 counters 对象**不在匿名投影里**(PUBLIC_HEALTH_KEYS)。
3848
3857
  // 而 #3271 交付时我把「观察它有没有 fire」写成了 `/health.counters.…` ——
@@ -4055,7 +4064,7 @@ return Bun.serve({
4055
4064
  // 看不见这个节点(不在它的网络里)与不存在同一个 404。
4056
4065
  if (!node || !node.network_id || (!role && !isAdmin)) return withCors(req, Response.json({ ok: false, error: "node_not_found" }, { status: 404 }));
4057
4066
  // 节点主人、网络 owner / admin、Hub 管理员能改;部门负责人和别的成员不能(RFC-041 §2.3 / §2.4)。
4058
- if (!isAdmin && node.owner_user_id !== restAuth.userId && role !== "owner" && role !== "admin") {
4067
+ if (!canRestWriteNodeSecurity(restAuth, node.owner_user_id, role, isAdmin)) {
4059
4068
  return withCors(req, Response.json({ ok: false, error: "permission_denied", message: "only the node's owner or a network owner/admin can change its permission mode" }, { status: 403 }));
4060
4069
  }
4061
4070
  const previous = (node.permission_mode || "normal") as NodePermissionMode;
@@ -4228,7 +4237,7 @@ return Bun.serve({
4228
4237
  "SELECT node_id, network_id, owner_user_id, tool_allowlist FROM nodes WHERE node_id = ?1", nodeRef3);
4229
4238
  const role3 = node3?.network_id ? getUserNetworkRole(restAuth.userId, node3.network_id) : null;
4230
4239
  if (!node3 || !node3.network_id || (!role3 && !isAdmin)) return withCors(req, Response.json({ ok: false, error: "node_not_found" }, { status: 404 }));
4231
- if (!isAdmin && node3.owner_user_id !== restAuth.userId && role3 !== "owner" && role3 !== "admin") {
4240
+ if (!canRestWriteNodeSecurity(restAuth, node3.owner_user_id, role3, isAdmin)) {
4232
4241
  return withCors(req, Response.json({ ok: false, error: "permission_denied", message: "only the node's owner or a network owner/admin can change its tool allowlist" }, { status: 403 }));
4233
4242
  }
4234
4243
  const nextTools = tools.length ? JSON.stringify(tools) : null;
@@ -4262,7 +4271,7 @@ return Bun.serve({
4262
4271
  "SELECT node_id, network_id, owner_user_id, rest_allowlist FROM nodes WHERE node_id = ?1", nodeRef4);
4263
4272
  const role4 = node4?.network_id ? getUserNetworkRole(restAuth.userId, node4.network_id) : null;
4264
4273
  if (!node4 || !node4.network_id || (!role4 && !isAdmin)) return withCors(req, Response.json({ ok: false, error: "node_not_found" }, { status: 404 }));
4265
- if (!isAdmin && node4.owner_user_id !== restAuth.userId && role4 !== "owner" && role4 !== "admin") {
4274
+ if (!canRestWriteNodeSecurity(restAuth, node4.owner_user_id, role4, isAdmin)) {
4266
4275
  return withCors(req, Response.json({ ok: false, error: "permission_denied", message: "only the node's owner or a network owner/admin can change its REST allowlist" }, { status: 403 }));
4267
4276
  }
4268
4277
  const nextRoutes = routes.length ? JSON.stringify(routes) : null;
@@ -4303,7 +4312,7 @@ return Bun.serve({
4303
4312
  "SELECT node_id, network_id, owner_user_id, peer_allowlist FROM nodes WHERE node_id = ?1", nodeRef2);
4304
4313
  const role2 = node2?.network_id ? getUserNetworkRole(restAuth.userId, node2.network_id) : null;
4305
4314
  if (!node2 || !node2.network_id || (!role2 && !isAdmin)) return withCors(req, Response.json({ ok: false, error: "node_not_found" }, { status: 404 }));
4306
- if (!isAdmin && node2.owner_user_id !== restAuth.userId && role2 !== "owner" && role2 !== "admin") {
4315
+ if (!canRestWriteNodeSecurity(restAuth, node2.owner_user_id, role2, isAdmin)) {
4307
4316
  return withCors(req, Response.json({ ok: false, error: "permission_denied", message: "only the node's owner or a network owner/admin can change its peer allowlist" }, { status: 403 }));
4308
4317
  }
4309
4318
  const nextValue = peers.length ? JSON.stringify(peers) : null;
@@ -81,8 +81,10 @@ describe("SkillHub real Hub + SQLite", () => {
81
81
  expect(Object.keys(nodeList).sort()).toEqual(["ok", "reviewer", "skills"]);
82
82
  expect(nodeList.reviewer).toBe(false);
83
83
  // 详情未找到:只有两个键;多一个键就意味着错误响应开始夹带上下文。
84
- expect(Object.keys(await tool(nodeToken, "get_skill", { network_id: networkId, skill_id: skillId })).sort())
85
- .toEqual(["error", "ok"]);
84
+ // #3275 批次 4 —— 同变量口径:先接住再断言(内联 `Object.keys(await f())` 在语义上一样,
85
+ // 但没有任何变量名可供归因;这条改完之后,它就是一次可被引用的形状断言)。
86
+ const missing = await tool(nodeToken, "get_skill", { network_id: networkId, skill_id: skillId });
87
+ expect(Object.keys(missing).sort()).toEqual(["error", "ok"]);
86
88
  expect((await tool(nodeToken, "get_skill", { network_id: networkId, skill_id: skillId })).error).toBe("skill_not_found");
87
89
  const ownerList = await tool(ownerToken, "list_skills", { network_id: networkId, include_pending: true });
88
90
  expect(ownerList.reviewer).toBe(true);
@@ -118,6 +118,12 @@ describe("task consumed_at identity and lifecycle", () => {
118
118
  );
119
119
  const handler = toolsFor({ alias: NODE_A, nodeToken: true }).list_tasks;
120
120
  const first = await call(handler, { from_node_id: `id_${NODE_A}`, durable_cursor: true, limit: 100 });
121
+ // #3309 分支 —— list_tasks 的两个成功出口不是同一形状:
122
+ // 非游标:{ok, tasks, …} (无 capability)
123
+ // 游标 :多一个 capability = "list_tasks.immutable-node-cursor.v1"
124
+ // 只断言 capability 的值时,「顺手把它也加到非游标那条」不会有东西变红。
125
+ // 实测五键:我按源码读成三键(漏了 count 与 stats)——又一次「按代码读会少」
126
+ expect(Object.keys(first).sort()).toEqual(["capability", "count", "next_cursor", "ok", "stats", "tasks"]);
121
127
  expect(first.capability).toBe("list_tasks.immutable-node-cursor.v1");
122
128
  expect(first.tasks).toHaveLength(100);
123
129
  const second = await call(handler, { from_node_id: `id_${NODE_A}`, durable_cursor: true, limit: 100, ...first.next_cursor });