@sleep2agi/commhub-server 0.9.0-preview.12 → 0.9.0-preview.121

package/src/codex-config-flags.ts

@@ -0,0 +1,77 @@
+/** Shared Codex node `flags.*` contract (create_node + update_node_config). */
+
+export const REASONING_EFFORT_VALUES = [
+  "none",
+  "minimal",
+  "low",
+  "medium",
+  "high",
+  "xhigh",
+] as const;
+
+export type ModelReasoningEffort = (typeof REASONING_EFFORT_VALUES)[number];
+
+export const CODEX_APPROVAL_POLICIES = [
+  "untrusted",
+  "on-failure",
+  "on-request",
+  "never",
+] as const;
+
+export const CODEX_SANDBOX_MODES = [
+  "read-only",
+  "workspace-write",
+  "danger-full-access",
+] as const;
+
+/** Runtimes that may carry Codex posture / reasoning flags. */
+export const CODEX_CONFIG_FLAG_RUNTIMES = new Set<string>(["codex-sdk", "codex-app-server"]);
+
+export const CODEX_CONFIG_ONLY_FLAG_KEYS = new Set<string>([
+  "approvalPolicy",
+  "sandboxMode",
+  "skipGitRepoCheck",
+  "copresenceFullAccess",
+  "modelReasoningEffort",
+]);
+
+export function isModelReasoningEffort(v: unknown): v is ModelReasoningEffort {
+  return typeof v === "string" && (REASONING_EFFORT_VALUES as readonly string[]).includes(v);
+}
+
+export function validateCodexConfigFlag(
+  key: string,
+  val: unknown,
+  runtime: string | null | undefined,
+): { field: string; reason: string } | null {
+  if (!CODEX_CONFIG_ONLY_FLAG_KEYS.has(key)) return null;
+  if (runtime && !CODEX_CONFIG_FLAG_RUNTIMES.has(runtime)) {
+    return { field: `flags.${key}`, reason: `only supported for codex-sdk / codex-app-server runtimes` };
+  }
+  if (key === "copresenceFullAccess" && runtime && runtime !== "codex-app-server") {
+    return { field: "flags.copresenceFullAccess", reason: "only supported when node runtime is codex-app-server" };
+  }
+  switch (key) {
+    case "approvalPolicy":
+      if (typeof val !== "string" || !(CODEX_APPROVAL_POLICIES as readonly string[]).includes(val)) {
+        return { field: "flags.approvalPolicy", reason: `must be one of ${CODEX_APPROVAL_POLICIES.join("/")}` };
+      }
+      return null;
+    case "sandboxMode":
+      if (typeof val !== "string" || !(CODEX_SANDBOX_MODES as readonly string[]).includes(val)) {
+        return { field: "flags.sandboxMode", reason: `must be one of ${CODEX_SANDBOX_MODES.join("/")}` };
+      }
+      return null;
+    case "skipGitRepoCheck":
+    case "copresenceFullAccess":
+      if (typeof val !== "boolean") return { field: `flags.${key}`, reason: "must be boolean" };
+      return null;
+    case "modelReasoningEffort":
+      if (!isModelReasoningEffort(val)) {
+        return { field: "flags.modelReasoningEffort", reason: `must be one of ${REASONING_EFFORT_VALUES.join("/")}` };
+      }
+      return null;
+    default:
+      return null;
+  }
+}

package/src/codex-fork-contract.ts

@@ -0,0 +1,23 @@
+import { z } from "zod/v4";
+
+export const forkRecoveryRequestSchema = z.object({
+  kind: z.literal("fork_on_missing_ordinal"), confirmed: z.literal(true),
+}).strict();
+const threadId = z.string().length(36).regex(/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i);
+export const forkRecoveryResultSchema = z.discriminatedUnion("state", [
+  z.object({ state: z.literal("forked"), old_thread_id: threadId, new_thread_id: threadId }).strict(),
+  z.object({ state: z.literal("not_observed") }).strict(),
+  z.object({ state: z.literal("unknown"), reason: z.enum([
+    "invalid_request_id", "history_unreadable", "history_invalid", "request_ambiguous", "mapping_invalid",
+    "result_not_reported", "result_invalid",
+  ]) }).strict(),
+]).refine(r => r.state !== "forked" || r.old_thread_id !== r.new_thread_id);
+
+// Read paths re-validate stored data, not just the write-time MCP schema.
+export function publicForkResult(raw: unknown) {
+  try {
+    const parsed = forkRecoveryResultSchema.safeParse(typeof raw === "string" ? JSON.parse(raw) : raw);
+    if (parsed.success) return parsed.data;
+  } catch { /* corrupted/legacy storage must not expose arbitrary fields */ }
+  return { state: "unknown", reason: raw == null ? "result_not_reported" : "result_invalid" } as const;
+}

package/src/codex-fork-migration.test.ts

@@ -0,0 +1,38 @@
+import { expect, test } from "bun:test";
+import { Database } from "bun:sqlite";
+import { execFileSync } from "node:child_process";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+test("legacy start table upgrades twice without changing ordinary rows or losing fork receipts", () => {
+  const root = mkdtempSync(join(tmpdir(), "fork-migration-"));
+  const path = join(root, "legacy.db");
+  try {
+    let db = new Database(path);
+    db.exec(`CREATE TABLE node_start_requests (
+      request_id TEXT PRIMARY KEY, network_id TEXT NOT NULL, daemon_node_id TEXT NOT NULL,
+      child_node_id TEXT NOT NULL, child_alias TEXT NOT NULL, created_by_token TEXT NOT NULL,
+      status TEXT NOT NULL DEFAULT 'pending', error TEXT, child_pid INTEGER,
+      created_at INTEGER NOT NULL, delivered_at INTEGER, acked_at INTEGER);
+      INSERT INTO node_start_requests(request_id,network_id,daemon_node_id,child_node_id,child_alias,created_by_token,status,created_at)
+        VALUES('str_legacy','net_fixture','node_daemon','node_child','fixture','fixture','started',1);`);
+    db.close();
+    const migrate = () => execFileSync(process.execPath, ["-e",
+      `await import(${JSON.stringify(fileURLToPath(new URL("./db.ts", import.meta.url)))}); process.exit(0);`],
+      { env: { ...process.env, COMMHUB_DB: path }, timeout: 15_000, stdio: "pipe" });
+    migrate();
+    db = new Database(path);
+    expect(db.query("SELECT status,fork_recovery_json,fork_result_json FROM node_start_requests WHERE request_id='str_legacy'").get())
+      .toEqual({ status: "started", fork_recovery_json: null, fork_result_json: null });
+    const receipt = JSON.stringify({ state: "not_observed" });
+    db.query("UPDATE node_start_requests SET fork_result_json=? WHERE request_id='str_legacy'").run(receipt);
+    db.close();
+    migrate();
+    db = new Database(path);
+    expect(db.query("SELECT fork_result_json FROM node_start_requests WHERE request_id='str_legacy'").get())
+      .toEqual({ fork_result_json: receipt });
+    db.close();
+  } finally { rmSync(root, { recursive: true, force: true }); }
+});

package/src/commhub-bin-args.test.ts

@@ -0,0 +1,85 @@
+import { afterAll, describe, expect, test } from "bun:test";
+import { existsSync, mkdtempSync, readFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+// commhub-server must refuse what it does not understand instead of starting a
+// Hub on the defaults (the live ~/.commhub/commhub.db). Every child gets a
+// throwaway HOME and a throwaway PORT, so even a regression binds nothing real.
+const BIN = join(dirname(fileURLToPath(import.meta.url)), "..", "bin", "commhub.ts");
+const PKG_VERSION = JSON.parse(readFileSync(join(dirname(BIN), "..", "package.json"), "utf8")).version as string;
+const home = mkdtempSync(join(tmpdir(), "anet-bin-args-"));
+const PORT = String(26000 + Math.floor(Math.random() * 3000));
+
+afterAll(() => rmSync(home, { recursive: true, force: true }));
+
+function run(args: string[], extraEnv: Record<string, string> = {}, timeoutMs = 15_000) {
+  const proc = Bun.spawnSync(["bun", BIN, ...args], {
+    env: { PATH: process.env.PATH ?? "", HOME: home, PORT, HOST: "127.0.0.1", ...extraEnv },
+    stdout: "pipe", stderr: "pipe", timeout: timeoutMs,
+  });
+  return { code: proc.exitCode, stdout: proc.stdout.toString(), stderr: proc.stderr.toString() };
+}
+
+async function listening(port: string): Promise<boolean> {
+  try { await fetch(`http://127.0.0.1:${port}/health`, { signal: AbortSignal.timeout(500) }); return true; } catch { return false; }
+}
+
+describe("commhub-server argument handling", () => {
+  for (const [args, message] of [
+    [["bogus"], "unknown command bogus"],
+    [["--port=29999"], "unknown option --port=29999"],
+    [["--bogus-flag"], "unknown option --bogus-flag"],
+    [["--port"], "--port needs a value"],
+    [["--db", "--dev-open"], "--db needs a value"],
+  ] as const) {
+    test(`${args.join(" ")} → exit 2, no database, nothing listening`, async () => {
+      const r = run([...args]);
+      expect(r.code).toBe(2);
+      expect(r.stderr).toContain(message);
+      expect(r.stderr).toContain("commhub-server --help");
+      expect(existsSync(join(home, ".commhub"))).toBe(false);
+      expect(await listening(PORT)).toBe(false);
+    });
+  }
+
+  test("migrate-to-pg with missing or unknown arguments exits 2 and starts nothing", async () => {
+    const missing = run(["migrate-to-pg", "--from", "/x.db"]);
+    expect(missing.code).toBe(2);
+    expect(missing.stdout).toContain("commhub-server migrate-to-pg --from <sqlite file> --to <postgres url>");
+    const unknown = run(["migrate-to-pg", "--from", "/x.db", "--to", "postgres://u@127.0.0.1/anet_x_test", "--bogus"]);
+    expect(unknown.code).toBe(2);
+    expect(unknown.stderr).toContain("unknown argument --bogus");
+    expect(existsSync(join(home, ".commhub"))).toBe(false);
+    expect(await listening(PORT)).toBe(false);
+  });
+
+  test("--help and --version exit 0 without starting", async () => {
+    const help = run(["--help"]);
+    expect(help.code).toBe(0);
+    expect(help.stdout).toContain("--port, -p <port>");
+    const version = run(["--version"]);
+    expect(version.code).toBe(0);
+    expect(version.stdout.trim()).toBe(PKG_VERSION);
+    expect(existsSync(join(home, ".commhub"))).toBe(false);
+  });
+
+  test("the known forms still start a Hub", async () => {
+    const db = join(home, "known.db");
+    const port = String(Number(PORT) + 1);
+    const child = Bun.spawn(["bun", BIN, "--port", port, "--host", "127.0.0.1", "--db", db, "--dev-open"], {
+      env: { PATH: process.env.PATH ?? "", HOME: home }, stdout: "pipe", stderr: "pipe",
+    });
+    try {
+      let up = false;
+      for (let i = 0; i < 100 && !up; i++) { up = await listening(port); if (!up) await Bun.sleep(100); }
+      expect(up).toBe(true);
+      expect(existsSync(db)).toBe(true);
+      expect(existsSync(join(home, ".commhub", "commhub.db"))).toBe(false);
+    } finally {
+      child.kill();
+      await child.exited;
+    }
+  }, 30_000);
+});

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)", () => {
@@ -24,20 +26,28 @@ describe("ALLOWED_FLAGS — exact contract (no silent extension)", () => {
     // the BLOCKER 2 schema-mismatch issue. P2 to add a claude-code-cli
     // config-apply path.
     expect([...ALLOWED_FLAGS].sort()).toEqual([
+      "approvalPolicy",
       "budget",
+      "copresenceFullAccess",
       "dangerouslySkipPermissions",
       "maxTurns",
+      "modelReasoningEffort",
       "permissionMode",
+      "sandboxMode",
+      "skipGitRepoCheck",
       "timeout",
     ]);
   });
 });
 
 describe("SECURITY_SENSITIVE_FLAGS — privilege-elevation surface", () => {
-  test("contains the 2 privilege-elevation flags (teammateMode dropped — see ALLOWED_FLAGS comment)", () => {
+  test("contains privilege-elevation flags (teammateMode dropped — see ALLOWED_FLAGS comment)", () => {
     expect([...SECURITY_SENSITIVE_FLAGS].sort()).toEqual([
+      "approvalPolicy",
+      "copresenceFullAccess",
       "dangerouslySkipPermissions",
       "permissionMode",
+      "sandboxMode",
     ]);
   });
 
@@ -159,6 +169,10 @@ describe("computeApplyMode — tier classifier (RFC-024 §4)", () => {
     expect(computeApplyMode("gpt-5", { maxTurns: 50 })).toBe("restart");
   });
 
+  test("modelReasoningEffort flag alone → restart tier", () => {
+    expect(computeApplyMode(undefined, { modelReasoningEffort: "medium" })).toBe("restart");
+  });
+
   test("mixed (only hot flags) → hot", () => {
     expect(computeApplyMode(undefined, { maxTurns: 50, budget: 100 })).toBe("hot");
   });
@@ -247,6 +261,15 @@ describe("validatePatch — per-flag enum / range", () => {
     expect(validatePatch(undefined, { timeout: 3_600_001 })?.field).toBe("flags.timeout");
     expect(validatePatch(undefined, { timeout: 60.5 })?.field).toBe("flags.timeout");
   });
+  test("timeout: 0 = no limit; 1..999 is seconds-shaped and rejected (#605)", () => {
+    expect(validatePatch(undefined, { timeout: 0 })).toBeNull();
+    expect(validatePatch(undefined, { timeout: 1000 })).toBeNull();
+    for (const v of [1, 600, 999]) {
+      const r = validatePatch(undefined, { timeout: v });
+      expect(r?.field).toBe("flags.timeout");
+      expect(r?.reason).toContain("milliseconds");
+    }
+  });
 });
 
 describe("validatePatch — combinations", () => {
@@ -258,3 +281,113 @@ 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");
+  });
+});
+
+describe("Codex config flags (#815)", () => {
+  test("yolo bundle on codex-app-server passes", () => {
+    expect(validatePatch(undefined, {
+      approvalPolicy: "never",
+      sandboxMode: "danger-full-access",
+      skipGitRepoCheck: true,
+      copresenceFullAccess: true,
+      modelReasoningEffort: "low",
+    }, undefined, "codex-app-server")).toBeNull();
+  });
+  test("modelReasoningEffort invalid enum rejected", () => {
+    expect(validatePatch(undefined, { modelReasoningEffort: "max" }, undefined, "codex-app-server")?.field)
+      .toBe("flags.modelReasoningEffort");
+  });
+  test("codex flags on claude runtime rejected", () => {
+    expect(validatePatch(undefined, { modelReasoningEffort: "low" }, undefined, "claude-agent-sdk")?.field)
+      .toBe("flags.modelReasoningEffort");
+  });
+});