@sleep2agi/commhub-server 0.9.0-preview.7 → 0.9.0-preview.71

package/src/report-status-host-schema.test.ts

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

package/src/report-status-resume-id-handover.test.ts

@@ -0,0 +1,150 @@
+// 同一 alias 换 resume_id 上报时,hub 的 report_status 走的是「DELETE 旧行 + INSERT 新行」,
+// ON CONFLICT 里的 COALESCE 一次都不会触发 —— 上报里没带的描述性列(version / agent /
+// hostname / 遥测 / registered_at)全部变 NULL。
+//
+// 2026-09-04 DEV 真机(hub 日志):
+//   12:46:47 grok-v1 (sdk-n_6c)  → report_status: working       version=2.5.0-preview.64
+//   12:46:53 grok-v1 (grok-cli)  → report_status: working       ← TUI 的 MCP 上报,不带 version
+//   12:46:54 grok-v1 (sdk-n_6c)  → report_status: idle          ← 又换回来,也不带 version
+// 结果:version=NULL、registered_at 被改成 12:46:54。舰队里 grok 3/10、claude 5/15 有 version,
+// codex 34/34 有 —— 差别就是有没有第二个上报者。
+//
+// 判据:换 resume_id 之后,只有一行;上报了的列以上报为准,没上报的列从被替换的那行接手。
+import { afterAll, beforeEach, describe, expect, test } from "bun:test";
+import { db } from "./db.js";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { registerTools } from "./tools.js";
+
+const NET_ID = "net_handover";
+const USER_ID = "u_handover";
+const NODE_ID = "n_handover";
+const ALIAS = "grok-handover";
+const TOK_ID = "tok_handover";
+const RESUME_SDK = `sdk-${NODE_ID}`;
+const RESUME_CLI = `grok-cli-${NODE_ID}`;
+const OLD_REGISTERED_AT = "2026-01-02 03:04:05";
+
+type ToolHandler = (args: any, extra?: any) => Promise<{ content: Array<{ type: "text"; text: string }> }>;
+
+function cleanup() {
+  for (const [sql, params] of [
+    ["DELETE FROM agent_telemetry WHERE network_id = ?1", [NET_ID]],
+    ["DELETE FROM sessions WHERE network_id = ?1", [NET_ID]],
+    ["DELETE FROM nodes WHERE network_id = ?1", [NET_ID]],
+    ["DELETE FROM api_tokens WHERE network_id = ?1", [NET_ID]],
+    ["DELETE FROM network_members WHERE network_id = ?1", [NET_ID]],
+    ["DELETE FROM networks WHERE network_id = ?1", [NET_ID]],
+    ["DELETE FROM users WHERE user_id = ?1", [USER_ID]],
+  ] as const) {
+    try { db.run(sql, params as any); } catch {}
+  }
+}
+beforeEach(cleanup);
+afterAll(cleanup);
+
+function seed() {
+  db.run(`INSERT INTO users (user_id, username, password_hash, role, created_at) VALUES (?1, ?2, 'x', 'user', datetime('now'))`, [USER_ID, USER_ID]);
+  db.run(`INSERT INTO networks (network_id, network_name, owner_id, created_at) VALUES (?1, ?2, ?3, datetime('now'))`, [NET_ID, NET_ID, USER_ID]);
+  db.run(`INSERT INTO network_members (user_id, network_id, role, joined_at) VALUES (?1, ?2, 'owner', datetime('now'))`, [USER_ID, NET_ID]);
+  db.run(
+    `INSERT INTO nodes (node_id, node_name, alias, network_id, hostname, created_at, updated_at, lifecycle_state)
+     VALUES (?1, ?2, ?3, ?4, ?5, datetime('now'), datetime('now'), 'active')`,
+    [NODE_ID, ALIAS, ALIAS, NET_ID, "dev-box"],
+  );
+  // agent-node 自己注册的那行:带 version / agent / hostname / 遥测 / 早就存在的 registered_at
+  db.run(
+    `INSERT INTO sessions (resume_id, alias, status, node_id, network_id, version, agent, hostname, server, project_dir,
+                           cpu_cores, mem_total_gb, disk_total_gb, registered_at, updated_at, last_seen_at)
+     VALUES (?1, ?2, 'working', ?3, ?4, '2.5.0-preview.64', 'agent-node:grok-build-cli', 'dev-box', 'dev-box', '/home/x/proj',
+             8, 61.4, 500, ?5, datetime('now'), datetime('now'))`,
+    [RESUME_SDK, ALIAS, NODE_ID, NET_ID, OLD_REGISTERED_AT],
+  );
+  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)`,
+    [TOK_ID, USER_ID, NET_ID, `node:${ALIAS}`, `hash_${TOK_ID}`],
+  );
+}
+
+function buildHandlers(): Record<string, ToolHandler> {
+  const server = new McpServer({ name: "test", version: "0" }) as any;
+  const tools: Record<string, ToolHandler> = {};
+  const origTool = server.tool.bind(server);
+  server.tool = (name: string, _desc: string, _schema: any, handler: ToolHandler) => { tools[name] = handler; return origTool(name, _desc, _schema, handler); };
+  const origRegisterTool = server.registerTool?.bind(server);
+  if (origRegisterTool) {
+    server.registerTool = (name: string, _cfg: any, handler: ToolHandler) => { tools[name] = handler; return origRegisterTool(name, _cfg, handler); };
+  }
+  registerTools(server, undefined, NET_ID, USER_ID, ALIAS, true, TOK_ID);
+  return tools;
+}
+
+async function call(handler: ToolHandler, args: any): Promise<any> {
+  const r = await handler(args);
+  return JSON.parse(r.content[0]!.text);
+}
+
+type Row = { resume_id: string; status: string; version: string | null; agent: string | null; hostname: string | null;
+  cpu_cores: number | null; mem_total_gb: number | null; registered_at: string; task: string | null };
+function rows(): Row[] {
+  return db.all("SELECT resume_id, status, version, agent, hostname, cpu_cores, mem_total_gb, registered_at, task FROM sessions WHERE alias = ?1 AND network_id = ?2", [ALIAS, NET_ID]) as Row[];
+}
+
+describe("report_status: 同 alias 换 resume_id 时,描述性列从被替换的那行接手", () => {
+  test("第二个上报者(grok-cli)不带 version/agent/遥测 → 这些列保留,status/task 以本次为准,仍只有一行", async () => {
+    seed();
+    const tools = buildHandlers();
+    const r = await call(tools.report_status!, { resume_id: RESUME_CLI, alias: ALIAS, status: "working", task: "PING 已收到", network_id: NET_ID });
+    expect(r.ok, JSON.stringify(r)).toBe(true);
+    const all = rows();
+    expect(all.length).toBe(1);
+    const row = all[0]!;
+    expect(row.resume_id).toBe(RESUME_CLI);
+    expect(row.status).toBe("working");
+    expect(row.task).toBe("PING 已收到");
+    expect(row.version).toBe("2.5.0-preview.64");
+    expect(row.agent).toBe("agent-node:grok-build-cli");
+    expect(row.hostname).toBe("dev-box");
+    expect(row.cpu_cores).toBe(8);
+    expect(row.mem_total_gb).toBe(61.4);
+    expect(row.registered_at).toBe(OLD_REGISTERED_AT);
+  });
+
+  test("上报里带了的列以上报为准(version 变了就用新的)", async () => {
+    seed();
+    const tools = buildHandlers();
+    const r = await call(tools.report_status!, { resume_id: RESUME_CLI, alias: ALIAS, status: "idle", version: "9.9.9", hostname: "other-box", network_id: NET_ID });
+    expect(r.ok, JSON.stringify(r)).toBe(true);
+    const row = rows()[0]!;
+    expect(rows().length).toBe(1);
+    expect(row.version).toBe("9.9.9");
+    expect(row.hostname).toBe("other-box");
+    expect(row.agent).toBe("agent-node:grok-build-cli");
+  });
+
+  test("再换回原 resume_id(sdk)也不丢:两个上报者轮流说话,version 始终在", async () => {
+    seed();
+    const tools = buildHandlers();
+    await call(tools.report_status!, { resume_id: RESUME_CLI, alias: ALIAS, status: "working", network_id: NET_ID });
+    const r = await call(tools.report_status!, { resume_id: RESUME_SDK, alias: ALIAS, status: "idle", network_id: NET_ID });
+    expect(r.ok, JSON.stringify(r)).toBe(true);
+    const all = rows();
+    expect(all.length).toBe(1);
+    expect(all[0]!.resume_id).toBe(RESUME_SDK);
+    expect(all[0]!.status).toBe("idle");
+    expect(all[0]!.version).toBe("2.5.0-preview.64");
+    expect(all[0]!.registered_at).toBe(OLD_REGISTERED_AT);
+  });
+
+  test("没有别的行可接手时(全新 alias)行为不变:INSERT 一行,registered_at 取 now", async () => {
+    seed();
+    db.run("DELETE FROM sessions WHERE network_id = ?1", [NET_ID]);
+    const tools = buildHandlers();
+    const r = await call(tools.report_status!, { resume_id: RESUME_SDK, alias: ALIAS, status: "idle", network_id: NET_ID });
+    expect(r.ok, JSON.stringify(r)).toBe(true);
+    const all = rows();
+    expect(all.length).toBe(1);
+    expect(all[0]!.version).toBeNull();
+    expect(all[0]!.registered_at).not.toBe(OLD_REGISTERED_AT);
+  });
+});

package/src/require-explicit-test-db.ts

@@ -0,0 +1,9 @@
+// #434: real-server integration tests must know their DB before importing
+// auth/db/server modules. Setting COMMHUB_DB in beforeAll is too late because
+// ESM dependencies have already evaluated the db singleton.
+if (!process.env.COMMHUB_DB) {
+  throw new Error(
+    "explicit_test_database_required: run `cd server && bun run test`, " +
+    "or set COMMHUB_DB to an isolated temporary path before running this file",
+  );
+}

package/src/requirement-tags.ts

@@ -0,0 +1,16 @@
+/** Small, network-local labels; count Unicode code points rather than UTF-16 units. */
+export function normalizeTags(value: unknown): string[] | null {
+  if (!Array.isArray(value) || value.length > 10) return null;
+  const tags: string[] = [];
+  for (const valueTag of value) {
+    if (typeof valueTag !== "string") return null;
+    const tag = valueTag.trim();
+    if (!tag || [...tag].length > 20 || /[\u0000-\u001f\u007f]/u.test(tag)) return null;
+    if (!tags.includes(tag)) tags.push(tag);
+  }
+  return tags;
+}
+
+export function storedTags(value: string | null): string[] {
+  try { return normalizeTags(JSON.parse(value || "[]")) ?? []; } catch { return []; }
+}

package/src/requirements-etag-http.test.ts

@@ -0,0 +1,91 @@
+// GET /api/requirements conditional requests: ETag on every list response, 304 with an empty body
+// when If-None-Match matches. The app polls the whole list every 15 s (production: 500 rows,
+// 708 KB / 163 KB gzip) and it is unchanged on almost every poll. Old clients never send
+// If-None-Match and keep getting the full 200.
+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-etag-"));
+process.env.COMMHUB_DB = join(dir, "hub.db");
+
+let server: { port: number; stop?: (force?: boolean) => void };
+let base = "";
+let ownerToken = "", network = "";
+
+const list = (token: string, headers: Record<string, string> = {}) =>
+  fetch(`${base}/api/requirements?network_id=${network}`, { headers: { Authorization: `Bearer ${token}`, ...headers } });
+
+beforeAll(async () => {
+  const { register } = await import("./auth.js");
+  const owner = register(`etag_owner_${Date.now()}`, "EtagOwnerPassw0rd!", undefined, "seed");
+  ownerToken = owner.token!; network = owner.network_id!;
+  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}`;
+  const created = await fetch(`${base}/api/requirements`, {
+    method: "POST",
+    headers: { Authorization: `Bearer ${ownerToken}`, "Content-Type": "application/json" },
+    body: JSON.stringify({ name: "etag card", network_id: network }),
+  });
+  expect(created.status).toBe(201);
+}, 30_000);
+
+afterAll(() => {
+  try { server?.stop?.(true); } catch {}
+  try { rmSync(dir, { recursive: true, force: true }); } catch {}
+});
+
+describe("GET /api/requirements conditional requests", () => {
+  test("a plain GET is the same 200 JSON as before, plus ETag and private/no-cache", async () => {
+    const res = await list(ownerToken);
+    expect(res.status).toBe(200);
+    expect(res.headers.get("content-type")).toBe("application/json;charset=utf-8");
+    expect(res.headers.get("etag")).toMatch(/^W\/"[A-Za-z0-9_-]{27}"$/);
+    expect(res.headers.get("cache-control")).toBe("private, no-cache");
+    const body = await res.json() as any;
+    expect(body.ok).toBe(true);
+    expect(body.requirements.map((r: any) => r.name)).toEqual(["etag card"]);
+    expect(Array.isArray(body.capabilities)).toBe(true);
+  });
+
+  test("If-None-Match with the current ETag → 304, empty body, same ETag", async () => {
+    const etag = (await list(ownerToken)).headers.get("etag")!;
+    const res = await list(ownerToken, { "If-None-Match": etag });
+    expect(res.status).toBe(304);
+    expect(res.headers.get("etag")).toBe(etag);
+    expect(await res.text()).toBe("");
+    // strong/weak spelling and lists are accepted
+    expect((await list(ownerToken, { "If-None-Match": etag.replace(/^W\//, "") })).status).toBe(304);
+    expect((await list(ownerToken, { "If-None-Match": `W/"stale", ${etag}` })).status).toBe(304);
+  });
+
+  test("304 survives gzip negotiation (not compressed, still empty)", async () => {
+    const etag = (await list(ownerToken, { "Accept-Encoding": "gzip" })).headers.get("etag")!;
+    const res = await list(ownerToken, { "If-None-Match": etag, "Accept-Encoding": "gzip" });
+    expect(res.status).toBe(304);
+    expect(res.headers.get("content-encoding")).toBeNull();
+  });
+
+  test("any change to the list changes the ETag → full 200 again", async () => {
+    const before = await list(ownerToken);
+    const etag = before.headers.get("etag")!;
+    const id = ((await before.json()) as any).requirements[0].id;
+    const patched = await fetch(`${base}/api/requirements/${id}?network_id=${network}`, {
+      method: "PATCH",
+      headers: { Authorization: `Bearer ${ownerToken}`, "Content-Type": "application/json" },
+      body: JSON.stringify({ name: "etag card renamed" }),
+    });
+    expect(patched.status).toBe(200);
+    const res = await list(ownerToken, { "If-None-Match": etag });
+    expect(res.status).toBe(200);
+    expect(res.headers.get("etag")).not.toBe(etag);
+    expect(((await res.json()) as any).requirements[0].name).toBe("etag card renamed");
+  });
+
+  test("a stale or foreign ETag never yields 304", async () => {
+    expect((await list(ownerToken, { "If-None-Match": 'W/"not-the-current-one"' })).status).toBe(200);
+    expect((await list(ownerToken, { "If-None-Match": "" })).status).toBe(200);
+  });
+});