@sleep2agi/commhub-server 0.9.0-preview.20 → 0.9.0-preview.21

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sleep2agi/commhub-server",
-  "version": "0.9.0-preview.20",
+  "version": "0.9.0-preview.21",
   "description": "CommHub Server — AI Agent communication hub with MCP protocol, multi-network isolation, user auth, and 17 MCP tools.",
   "type": "module",
   "main": "src/index.ts",

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

@@ -721,3 +721,110 @@ describe("SEC-1 — update lifecycle: single-flight + cross-network pending look
     expect(inFlight).toBeDefined();
   });
 });
+
+// ── #260 P5 codex-catch regression: channels finalize ─────────────
+describe("finalizePendingMatchingUpdates — #260 P5 channels content-match", () => {
+  function insertPendingUpdate(opts: {
+    update_id?: string;
+    node_id: string;
+    network_id: string;
+    patch: any;
+    apply_mode: "hot" | "restart" | "restart_only";
+    status?: "pending" | "restarting";
+  }): string {
+    const id = opts.update_id ?? `cu_${uuidv4()}`;
+    db.run(
+      `INSERT INTO node_config_updates (update_id, node_id, network_id, patch_json, apply_mode, base_revision, status, created_at, created_by_token) VALUES (?1, ?2, ?3, ?4, ?5, 0, ?6, ?7, 'test')`,
+      [id, opts.node_id, opts.network_id, JSON.stringify(opts.patch), opts.apply_mode, opts.status ?? "pending", Date.now()],
+    );
+    return id;
+  }
+
+  test("channels-only patch: snapshot BEFORE apply (first boot) must NOT finalize", () => {
+    const nid = insertNode({ alias: "n-chan-1", network_id: "netA" });
+    const uid = insertPendingUpdate({
+      node_id: nid, network_id: "netA",
+      // Note the empty flags object — the pre-fix bug was that this
+      // trivially matched the flags loop and hub falsely finalized.
+      patch: { flags: {}, channels: ["feishu"] },
+      apply_mode: "restart",
+    });
+    // Node's startup snapshot BEFORE it consumed the update — no
+    // channels forked yet, so buildConfigSnapshot emits channels=[].
+    const r = finalizePendingMatchingUpdates(nid, { model: "x", flags: {}, channels: [] });
+    expect(r.finalizedCount).toBe(0);
+    expect(db.get<any>("SELECT status FROM node_config_updates WHERE update_id = ?1", uid).status).toBe("pending");
+  });
+
+  test("channels-only patch: snapshot AFTER apply (restart complete) finalizes", () => {
+    const nid = insertNode({ alias: "n-chan-2", network_id: "netA" });
+    const uid = insertPendingUpdate({
+      node_id: nid, network_id: "netA",
+      patch: { flags: {}, channels: ["feishu"] },
+      apply_mode: "restart",
+    });
+    const r = finalizePendingMatchingUpdates(nid, { model: "x", flags: {}, channels: ["feishu"] });
+    expect(r.finalizedCount).toBe(1);
+    expect(r.finalizedIds).toContain(uid);
+    expect(db.get<any>("SELECT status FROM node_config_updates WHERE update_id = ?1", uid).status).toBe("applied");
+  });
+
+  test("channels set-equality: order doesn't matter", () => {
+    const nid = insertNode({ alias: "n-chan-3", network_id: "netA" });
+    insertPendingUpdate({
+      node_id: nid, network_id: "netA",
+      patch: { flags: {}, channels: ["telegram", "feishu"] },
+      apply_mode: "restart",
+    });
+    // Snapshot order swapped — still matches.
+    const r = finalizePendingMatchingUpdates(nid, { model: "x", flags: {}, channels: ["feishu", "telegram"] });
+    expect(r.finalizedCount).toBe(1);
+  });
+
+  test("channels: [] disable-all — finalize when snapshot also [] (post-restart)", () => {
+    const nid = insertNode({ alias: "n-chan-4", network_id: "netA" });
+    insertPendingUpdate({
+      node_id: nid, network_id: "netA",
+      patch: { flags: {}, channels: [] },
+      apply_mode: "restart",
+    });
+    const r = finalizePendingMatchingUpdates(nid, { model: "x", flags: {}, channels: [] });
+    expect(r.finalizedCount).toBe(1);
+  });
+
+  test("channels: [] disable-all — do NOT finalize when snapshot still has channels", () => {
+    const nid = insertNode({ alias: "n-chan-5", network_id: "netA" });
+    insertPendingUpdate({
+      node_id: nid, network_id: "netA",
+      patch: { flags: {}, channels: [] },
+      apply_mode: "restart",
+    });
+    // Node hasn't restarted yet — old telegram worker still forked.
+    const r = finalizePendingMatchingUpdates(nid, { model: "x", flags: {}, channels: ["telegram"] });
+    expect(r.finalizedCount).toBe(0);
+  });
+
+  test("snapshot omits channels field entirely (pre-P5 agent-node) → NOT finalized on channels-carrying patch", () => {
+    const nid = insertNode({ alias: "n-chan-6", network_id: "netA" });
+    insertPendingUpdate({
+      node_id: nid, network_id: "netA",
+      patch: { flags: {}, channels: ["feishu"] },
+      apply_mode: "restart",
+    });
+    const r = finalizePendingMatchingUpdates(nid, { model: "x", flags: {} });  // no channels key
+    expect(r.finalizedCount).toBe(0);
+  });
+
+  test("model + channels compound match: both must satisfy", () => {
+    const nid = insertNode({ alias: "n-chan-7", network_id: "netA" });
+    insertPendingUpdate({
+      node_id: nid, network_id: "netA",
+      patch: { model: "opus-new", flags: {}, channels: ["telegram"] },
+      apply_mode: "restart",
+    });
+    // Wrong channels → not finalized even though model matches.
+    expect(finalizePendingMatchingUpdates(nid, { model: "opus-new", flags: {}, channels: [] }).finalizedCount).toBe(0);
+    // Both match → finalized.
+    expect(finalizePendingMatchingUpdates(nid, { model: "opus-new", flags: {}, channels: ["telegram"] }).finalizedCount).toBe(1);
+  });
+});

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

@@ -9,9 +9,11 @@ import { describe, expect, test } from "bun:test";
 import {
   ALLOWED_FLAGS,
   SECURITY_SENSITIVE_FLAGS,
+  EDITABLE_CHANNELS,
   isAllowedToChangeFlag,
   computeApplyMode,
   validatePatch,
+  narrowChannelsPatch,
 } from "./config-apply-validate";
 
 describe("ALLOWED_FLAGS — exact contract (no silent extension)", () => {
@@ -258,3 +260,93 @@ describe("validatePatch — combinations", () => {
     expect(r?.field).toBe("flags.maxTurns");
   });
 });
+
+// ── #260 P5 — channels support (restart-tier, non-security-sensitive) ─
+describe("EDITABLE_CHANNELS — mirrors agent-node runtime capability (cli.ts:671-676)", () => {
+  test("contains exactly telegram + feishu (channels agent-node actually forks workers for)", () => {
+    expect(EDITABLE_CHANNELS.size).toBe(2);
+    expect(EDITABLE_CHANNELS.has("telegram")).toBe(true);
+    expect(EDITABLE_CHANNELS.has("feishu")).toBe(true);
+  });
+  test("commhub is NOT editable — it's the RPC transport, not a per-node channel worker", () => {
+    expect(EDITABLE_CHANNELS.has("commhub")).toBe(false);
+  });
+  test("wechat is NOT editable — roadmap only on dashboard", () => {
+    expect(EDITABLE_CHANNELS.has("wechat")).toBe(false);
+  });
+});
+
+describe("narrowChannelsPatch — hostile input hygiene at the wire boundary", () => {
+  test("straight allow-listed input passes verbatim", () => {
+    expect(narrowChannelsPatch(["telegram", "feishu"])).toEqual(["telegram", "feishu"]);
+  });
+  test("empty array preserved — 'disable all editable channels' is a real state", () => {
+    expect(narrowChannelsPatch([])).toEqual([]);
+  });
+  test("non-array returns null (patch didn't touch channels)", () => {
+    expect(narrowChannelsPatch(undefined)).toBeNull();
+    expect(narrowChannelsPatch("telegram" as any)).toBeNull();
+    expect(narrowChannelsPatch({} as any)).toBeNull();
+  });
+  test("case-folded to lower", () => {
+    expect(narrowChannelsPatch(["FEISHU", "Telegram"])).toEqual(["feishu", "telegram"]);
+  });
+  test("duplicates deduped (Set)", () => {
+    expect(narrowChannelsPatch(["telegram", "telegram", "feishu", "TELEGRAM"])).toEqual(["telegram", "feishu"]);
+  });
+  test("unknown channel keys dropped silently (roadmap wechat, transport commhub, evil keys)", () => {
+    expect(narrowChannelsPatch(["wechat", "telegram", "evil-hacker", "commhub"])).toEqual(["telegram"]);
+  });
+  test("non-string entries dropped (numbers, objects, nulls)", () => {
+    expect(narrowChannelsPatch(["telegram", 42, {}, null, "feishu"] as any)).toEqual(["telegram", "feishu"]);
+  });
+  test("SQL-injection-shaped value dropped (not exact key match)", () => {
+    expect(narrowChannelsPatch(["telegram; drop table users;", "feishu"])).toEqual(["feishu"]);
+  });
+  test("whitespace around a key still trims to the key", () => {
+    expect(narrowChannelsPatch(["  feishu  "])).toEqual(["feishu"]);
+  });
+});
+
+describe("computeApplyMode — channels tier (restart)", () => {
+  test("channels-only patch → restart (boot forks per-channel workers)", () => {
+    expect(computeApplyMode(undefined, {}, ["feishu"])).toBe("restart");
+  });
+  test("empty-array channels → restart (still a state change)", () => {
+    expect(computeApplyMode(undefined, {}, [])).toBe("restart");
+  });
+  test("no channels key + no flags + no model → restart_only", () => {
+    expect(computeApplyMode(undefined, {}, undefined)).toBe("restart_only");
+  });
+  test("channels + hot-tier flag together stays restart (upgrade rules)", () => {
+    expect(computeApplyMode(undefined, { maxTurns: 5 }, ["telegram"])).toBe("restart");
+  });
+  test("channels + model → restart (model was already restart)", () => {
+    expect(computeApplyMode("gpt-5", {}, ["feishu"])).toBe("restart");
+  });
+});
+
+describe("validatePatch — channels defensive gate", () => {
+  test("valid channels array passes", () => {
+    expect(validatePatch(undefined, {}, ["telegram", "feishu"])).toBeNull();
+    expect(validatePatch(undefined, {}, [])).toBeNull();
+    expect(validatePatch(undefined, {}, ["telegram"])).toBeNull();
+  });
+  test("commhub rejected — RPC transport, not a per-node channel", () => {
+    const r = validatePatch(undefined, {}, ["commhub"]);
+    expect(r?.field).toBe("channels.commhub");
+  });
+  test("out-of-allowlist channel rejected (caller bypassed narrowing)", () => {
+    const r = validatePatch(undefined, {}, ["wechat"]);
+    expect(r?.field).toBe("channels.wechat");
+    expect(r?.reason).toMatch(/allowlist/);
+  });
+  test("non-string entry rejected", () => {
+    const r = validatePatch(undefined, {}, [42] as any);
+    expect(r?.field).toBe("channels");
+  });
+  test("non-array rejected", () => {
+    const r = validatePatch(undefined, {}, "telegram" as any);
+    expect(r?.field).toBe("channels");
+  });
+});

package/src/config-apply-validate.ts

@@ -57,6 +57,35 @@ export const RESTART_REQUIRED_FLAGS = new Set<string>([
   "timeout",
 ]);
 
+/**
+ * Channels the dashboard may enable/disable on a node via
+ * update_node_config. Intentionally narrow — the panel only exposes
+ * enable/disable, per-channel secrets stay in the node's local
+ * config.json (see #260 wire discipline).
+ *
+ * The list mirrors agent-node's actual runtime capability. See
+ * agent-node/src/cli.ts:671-676 — CHANNELS are parsed into per-type
+ * worker inits (initTelegramChannel + initFeishuChannel), and any
+ * other channel type triggers `process.exit(1)` at boot. So the
+ * hub-side allow-list here is telegram + feishu ONLY. `commhub` is
+ * the RPC transport that every node speaks unconditionally; treating
+ * it as a per-node channel would be a UX lie (toggle looks off but
+ * commhub is always on).
+ *
+ * Dashboard PR #31 currently includes `commhub` in its own
+ * EDITABLE_CHANNELS whitelist — that follow-up narrowing is filed for
+ * the next dashboard rally, and until then hub silently drops any
+ * `commhub` entry via narrowChannelsPatch.
+ *
+ * Not part of SECURITY_SENSITIVE_FLAGS (通信龙 P5 派工): flipping a
+ * channel on/off is a lifecycle-tier operation like `restart_node`, not
+ * a privilege elevation. Cross-tenant reach is already gated by SEC-1.
+ */
+export const EDITABLE_CHANNELS = new Set<string>([
+  "telegram",
+  "feishu",
+]);
+
 /**
  * Role-gate for the patch's flag set. SEC-2 enforcement lives here.
  *
@@ -99,22 +128,53 @@ export function isAllowedToChangeFlag(
 
 /**
  * Classify the patch's required apply mode. Empty patch (model + flags
- * both empty) → "restart_only" (used by restart_node tool). Any
- * restart-required field present → "restart". Otherwise → "hot".
+ * both empty, no channels) → "restart_only" (used by restart_node tool).
+ * Any restart-required field present, OR a channels change → "restart"
+ * (channels is restart-tier by design: the node reads its channel set
+ * once at boot in agent-node/src/cli.ts and forks per-channel workers
+ * from it, so a channel enable/disable takes effect on process restart
+ * only — see #260 P5 wire discipline). Otherwise → "hot".
  */
 export function computeApplyMode(
   model: string | undefined,
   flags: Record<string, unknown>,
+  channels?: string[] | undefined,
 ): "hot" | "restart" | "restart_only" {
-  const fieldCount = (model !== undefined ? 1 : 0) + Object.keys(flags).length;
+  const fieldCount = (model !== undefined ? 1 : 0) + Object.keys(flags).length + (channels !== undefined ? 1 : 0);
   if (fieldCount === 0) return "restart_only";
   if (model !== undefined) return "restart";
+  if (channels !== undefined) return "restart";
   for (const key of Object.keys(flags)) {
     if (RESTART_REQUIRED_FLAGS.has(key)) return "restart";
   }
   return "hot";
 }
 
+/**
+ * Narrow + allow-list `channels` from untrusted patch JSON. Returns the
+ * final channel key list (case-folded, deduped, in EDITABLE_CHANNELS
+ * order-preserving), OR null if the input isn't an array. Non-strings,
+ * unknown keys, empty strings, and duplicates are silently dropped —
+ * same fail-shape as the dashboard route's whitelist so the two sides
+ * behave identically end-to-end. Callers pass `undefined` through when
+ * the patch didn't include a channels key at all (a distinct case from
+ * `channels: []` which means "disable all editable channels").
+ */
+export function narrowChannelsPatch(raw: unknown): string[] | null {
+  if (!Array.isArray(raw)) return null;
+  const allow = EDITABLE_CHANNELS;
+  const seen = new Set<string>();
+  const out: string[] = [];
+  for (const v of raw) {
+    if (typeof v !== "string") continue;
+    const key = v.trim().toLowerCase();
+    if (!allow.has(key) || seen.has(key)) continue;
+    seen.add(key);
+    out.push(key);
+  }
+  return out;
+}
+
 /**
  * Validate the patch shape — allowlist + per-field range / enum. Returns
  * null on pass, or `{ field, reason }` on reject. Caller wraps in error
@@ -123,12 +183,30 @@ export function computeApplyMode(
 export function validatePatch(
   model: string | undefined,
   flags: Record<string, unknown>,
+  channels?: string[] | undefined,
 ): { field: string; reason: string } | null {
   if (model !== undefined) {
     if (typeof model !== "string" || model.length === 0 || model.length > 200) {
       return { field: "model", reason: "must be a non-empty string ≤ 200 chars" };
     }
   }
+  if (channels !== undefined) {
+    // Zod already enforced string[], and narrowChannelsPatch dropped
+    // unknown keys before this point — but re-verify defensively so a
+    // future caller that skips narrowChannelsPatch can't smuggle
+    // unknown keys through validatePatch alone.
+    if (!Array.isArray(channels)) {
+      return { field: "channels", reason: "must be an array of strings" };
+    }
+    for (const c of channels) {
+      if (typeof c !== "string") {
+        return { field: "channels", reason: "must contain only strings" };
+      }
+      if (!EDITABLE_CHANNELS.has(c)) {
+        return { field: `channels.${c}`, reason: "not in editable channels allowlist" };
+      }
+    }
+  }
   for (const [key, val] of Object.entries(flags)) {
     if (!ALLOWED_FLAGS.has(key)) {
       return { field: `flags.${key}`, reason: "not in allowlist" };

package/src/index.ts

@@ -172,6 +172,11 @@ function normalizeRuntime(agent: unknown): string | null {
   if (agent === "claude-code") return "claude-code-cli";
   if (agent.startsWith("agent-node:codex")) return "codex-sdk";
   if (agent.startsWith("agent-node:claude")) return "claude-agent-sdk";
+  if (agent.startsWith("agent-node:grok")) return "grok-build-acp";
+  // RFC-029 — agent-node reports `agent-node:opencode` when RUNTIME
+  // bucket resolves to "opencode". Dashboard needs the canonical
+  // launcher name so its Runtime badge matches wizard choices.
+  if (agent.startsWith("agent-node:opencode")) return "opencode-cli";
   if (agent === "http-api" || agent === "http" || agent === "api") return "http-api";
   return null;
 }

package/src/tools.ts

@@ -47,8 +47,10 @@ import { canonicalAliasExists, cleanupRenamedAliasSession, resolveCanonicalAlias
 import {
   ALLOWED_FLAGS,
   SECURITY_SENSITIVE_FLAGS,
+  EDITABLE_CHANNELS,
   computeApplyMode,
   validatePatch,
+  narrowChannelsPatch,
   isAllowedToChangeFlag,
 } from "./config-apply-validate.js";
 import { sharedSendDedup, buildDuplicateSendPayload } from "./send_dedup.js";
@@ -1565,6 +1567,22 @@ export function registerTools(server: McpServer, clientIP?: string, enforceNetwo
       patch: z.object({
         model: z.string().max(200).optional(),
         flags: z.record(z.unknown()).optional(),
+        // #260 P5 — channel enable/disable. Restart-tier field (agent-node
+        // reads config.channels once at boot to fork per-channel workers,
+        // so the swap takes effect via process restart). Not
+        // SECURITY_SENSITIVE — this is a lifecycle op, gated by SEC-1
+        // (network scope) only.
+        //
+        // Deliberately `z.array(z.unknown()).max(16)` (mirrors flags's
+        // `z.record(z.unknown())`): trust nothing at the wire boundary,
+        // narrow the same way `narrowChannelsPatch` narrows raw untrusted
+        // JSON (typeof + allowlist + dedup + case-fold). A strict
+        // `z.array(z.string())` would fail-fast on a single non-string
+        // entry, but the wire contract wants junk silently dropped so a
+        // dashboard fat-finger doesn't turn into a 400 the user has to
+        // interpret. validatePatch then re-rejects if the caller bypassed
+        // narrowing.
+        channels: z.array(z.unknown()).max(16).optional(),
       }).describe("Fields to update. Empty patch → no-op (use restart_node for that)."),
       network_id: z.string().max(200).optional(),
     },
@@ -1582,6 +1600,50 @@ export function registerTools(server: McpServer, clientIP?: string, enforceNetwo
 
       const model = typeof patch.model === "string" ? patch.model : undefined;
       const flags = (patch.flags && typeof patch.flags === "object") ? patch.flags as Record<string, unknown> : {};
+      // Narrow untrusted `channels` at the boundary (typeof + allowlist +
+      // dedup + case-fold), and distinguish two very different cases
+      // that both narrow to `[]`:
+      //   (a) `patch.channels === []` (explicit "disable all editable
+      //       channels"). Downstream must proceed and write channels=[]
+      //       so the node's next restart forks no workers.
+      //   (b) `patch.channels === ["commhub"]` or similar — the caller
+      //       sent items but every single one was invalid (dashboard PR
+      //       #31 still ships commhub, and a typo like "telegarm" would
+      //       hit the same path). Downstream MUST NOT treat this as
+      //       (a) — silently converting to disable-all would nuke the
+      //       user's existing telegram/feishu workers.
+      //
+      // The reject error is `channels_all_invalid` so the dashboard
+      // can surface the mismatch instead of showing a false success.
+      let channels: string[] | undefined = undefined;
+      if (patch.channels !== undefined) {
+        if (!Array.isArray(patch.channels)) {
+          // Zod already permits arrays only; belt+braces if it drifts.
+          return {
+            content: [{ type: "text" as const, text: JSON.stringify({ ok: false, error: "invalid_patch", field: "channels", reason: "must be an array" }) }],
+          };
+        }
+        const narrowed = narrowChannelsPatch(patch.channels) ?? [];
+        if (patch.channels.length === 0) {
+          channels = []; // (a) explicit disable-all
+        } else if (narrowed.length === 0) {
+          // (b) every entry was invalid — refuse to write. Distinct
+          // error so the dashboard can surface the failure.
+          return {
+            content: [{
+              type: "text" as const,
+              text: JSON.stringify({
+                ok: false,
+                error: "channels_all_invalid",
+                requested: patch.channels,
+                message: "every requested channel is unknown or unsupported; use an explicit empty array to disable-all",
+              }),
+            }],
+          };
+        } else {
+          channels = narrowed;
+        }
+      }
 
       // SEC-2 (final policy 2026-06-28) — security-sensitive flags
       // (permissionMode / dangerouslySkipPermissions / teammateMode)
@@ -1608,7 +1670,7 @@ export function registerTools(server: McpServer, clientIP?: string, enforceNetwo
         };
       }
 
-      const validationFail = validatePatch(model, flags);
+      const validationFail = validatePatch(model, flags, channels);
       if (validationFail) {
         return {
           content: [{
@@ -1686,8 +1748,12 @@ export function registerTools(server: McpServer, clientIP?: string, enforceNetwo
 
       // Compute apply_mode + persist + push doorbell.
       const updateId = `cu_${uuidv4()}`;
-      const applyMode = computeApplyMode(model, flags);
-      const patchJson = JSON.stringify({ ...(model !== undefined ? { model } : {}), flags });
+      const applyMode = computeApplyMode(model, flags, channels);
+      const patchJson = JSON.stringify({
+        ...(model !== undefined ? { model } : {}),
+        flags,
+        ...(channels !== undefined ? { channels } : {}),
+      });
       const networkId = node.network_id || "default";
       db.run(
         `INSERT INTO node_config_updates (update_id, node_id, network_id, patch_json, apply_mode, base_revision, status, created_at, created_by_token) VALUES (?1, ?2, ?3, ?4, ?5, ?6, 'pending', ?7, ?8)`,
@@ -3554,6 +3620,15 @@ export function finalizePendingMatchingUpdates(
 
   const snapModel: string | null | undefined = snapshot?.model;
   const snapFlags: Record<string, unknown> = (snapshot?.flags && typeof snapshot.flags === "object") ? snapshot.flags : {};
+  // #260 P5 — snapshot.channels is the (sorted, bare-type) channel set
+  // the node currently has forked. agent-node's buildConfigSnapshot
+  // always emits it (even as []), so the "absent field" case here means
+  // an older pre-#260-P5 agent-node — for those, don't finalize a
+  // channels-carrying patch (would false-positive on the OTHER fields).
+  const snapChannelsPresent = Array.isArray(snapshot?.channels);
+  const snapChannels: string[] = snapChannelsPresent
+    ? (snapshot.channels as unknown[]).filter((c): c is string => typeof c === "string")
+    : [];
 
   const finalizedIds: string[] = [];
 
@@ -3578,6 +3653,35 @@ export function finalizePendingMatchingUpdates(
           if (snapFlags[k] !== v) { matches = false; break; }
         }
       }
+      // #260 P5 — channels field content-match. Without this the
+      // node's very first startup report_status matches (patch.flags
+      // is `{}` for a channels-only update, so the flags loop is
+      // trivially satisfied) and hub prematurely marks the update
+      // applied, deleting the pending row + bumping config_revision
+      // BEFORE the doorbell reaches the child. Codex catch on PR #411.
+      //
+      // Set-equality is enough because the patch side comes from
+      // narrowChannelsPatch → already deduped + case-folded + in
+      // EDITABLE_CHANNELS iteration order; the snapshot side comes
+      // from buildConfigSnapshot which mirrors the same shape.
+      if (matches && Array.isArray(patch.channels)) {
+        if (!snapChannelsPresent) {
+          // Pre-#260-P5 agent-node — no channels field in snapshot,
+          // so we can't prove the apply landed. Skip finalize; hub's
+          // F-B reaper still supersedes this eventually.
+          matches = false;
+        } else {
+          const wanted = new Set<string>(patch.channels);
+          const have = new Set<string>(snapChannels);
+          if (wanted.size !== have.size) {
+            matches = false;
+          } else {
+            for (const w of wanted) {
+              if (!have.has(w)) { matches = false; break; }
+            }
+          }
+        }
+      }
     }
 
     if (!matches) continue;