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

package/src/session-task-on-dispatch.ts

@@ -0,0 +1,14 @@
+// Board #668. A dispatch preview is what the hub shows before the node
+// reports. Once the session is already working, that text is the task in
+// flight — a newer message waits in the inbox and must not replace it.
+// Idle and every other status still take the preview.
+
+const PLACEHOLDER = /^\?\d+$/;
+
+/** SQL expression for `sessions.task` on dispatch. `placeholder` is a `?N` bind. */
+export function sessionTaskOnDispatch(placeholder: string): string {
+  if (!PLACEHOLDER.test(placeholder)) {
+    throw new Error("sessionTaskOnDispatch placeholder must be a ?N bind");
+  }
+  return `CASE WHEN status = 'working' THEN task ELSE ${placeholder} END`;
+}

package/src/shared/codex-inventory.ts

@@ -0,0 +1,34 @@
+// #906 key-free existing Codex inventory. Identical public contract in each package.
+export function validCodexInventory(v: any): boolean {
+  const fields = (o: any, allowed: string[]) => o && typeof o === 'object' && !Array.isArray(o)
+    && Object.keys(o).every(k => allowed.includes(k));
+  const id = (s: any) => typeof s === 'string' && /^[A-Za-z0-9][A-Za-z0-9._:/-]{0,199}$/.test(s);
+  const nullable = (s: any) => s === null || id(s);
+  if (!fields(v, ['observed_at', 'scope', 'rows', 'installation']) || !Number.isSafeInteger(v.observed_at) || v.observed_at <= 0
+    || v.scope !== 'hub_bound_nodes' || !Array.isArray(v.rows) || v.rows.length > 200
+    || new Set(v.rows.map((r: any) => r?.node_id)).size !== v.rows.length) return false;
+  if (v.installation !== undefined && (!fields(v.installation, ['status', 'version'])
+    || !['found', 'missing', 'unknown'].includes(v.installation.status)
+    || !(v.installation.version === null || (typeof v.installation.version === 'string' && /^\d+\.\d+\.\d+(?:[-+.][0-9A-Za-z.-]+)?$/.test(v.installation.version) && v.installation.version.length <= 64)))) return false;
+  for (const r of v.rows) {
+    if (!r || !id(r.node_id) || typeof r.alias !== 'string' || !/^[\p{L}\p{N}][\p{L}\p{N}_.-]{0,99}$/u.test(r.alias)) return false;
+    if (['unavailable', 'not_codex'].includes(r.status)) {
+      if (!fields(r, ['node_id', 'alias', 'status'])) return false;
+      continue;
+    }
+    if (r.status !== 'observed' || !fields(r, ['node_id', 'alias', 'status', 'runtime', 'home_ref', 'home_source',
+      'config_status', 'configured_provider', 'configured_model', 'provider_ids', 'auth_kind', 'credential_status',
+      'account_fingerprint', 'verification', 'effective_state', 'node_configured_model', 'config_revision'])) return false;
+    if (r.config_revision !== undefined && r.config_revision !== null && (typeof r.config_revision !== 'string' || !/^[a-f0-9]{64}$/.test(r.config_revision))) return false;
+    if (!nullable(r.runtime) || !/^[a-f0-9]{16}$/.test(r.home_ref)
+      || !['host_default', 'config.codexHome', 'node-codex-home', 'config.env'].includes(r.home_source)
+      || !['read', 'missing', 'unreadable'].includes(r.config_status) || !nullable(r.configured_provider)
+      || !nullable(r.configured_model) || !nullable(r.node_configured_model)
+      || !Array.isArray(r.provider_ids) || r.provider_ids.length > 101 || !r.provider_ids.every(id)
+      || !['unknown', 'chatgpt', 'api_key'].includes(r.auth_kind)
+      || !['unknown', 'present', 'unreadable'].includes(r.credential_status)
+      || !(r.account_fingerprint === null || /^[a-f0-9]{16}$/.test(r.account_fingerprint))
+      || r.verification !== 'not_checked' || r.effective_state !== 'not_checked') return false;
+  }
+  return true;
+}

package/src/shared/daemon-provider-snapshot.ts

@@ -0,0 +1,49 @@
+// #906 public Provider snapshot contract. Mirrored across separately published
+// server/agent-node packages; drift is tested. No secret-shaped extension fields.
+import { validCodexInventory } from './codex-inventory.js';
+export function validateDaemonProviderSnapshot(value: unknown, networkId: string, daemonId: string): unknown {
+  const fail = (): never => { throw new Error("invalid_provider_snapshot"); };
+  const obj = (v: any, fields: string[]) => {
+    if (!v || typeof v !== "object" || Array.isArray(v) || Object.keys(v).some(k => !fields.includes(k))) fail();
+    return v;
+  };
+  const id = (v: unknown) => typeof v === "string" && /^[A-Za-z0-9][A-Za-z0-9_-]{0,63}$/.test(v);
+  const unique = (xs: any[], key: string) => { if (new Set(xs.map(x => x[key])).size !== xs.length) fail(); };
+  const arr = (v: any, max: number, empty = false): any[] => {
+    if (!Array.isArray(v) || (!empty && !v.length) || v.length > max) fail();
+    return v;
+  };
+  const s = obj(value, ["network_id", "daemon_node_id", "revision", "source", "providers", "codex_inventory"]);
+  if (s.codex_inventory !== undefined && !validCodexInventory(s.codex_inventory)) fail();
+  if (s.network_id !== networkId || s.daemon_node_id !== daemonId || s.source !== "daemon"
+    || !Number.isSafeInteger(s.revision) || s.revision < 0) fail();
+  const providers = arr(s.providers, 100, true);
+  unique(providers, "id");
+  for (const p of providers) {
+    obj(p, ["id", "label", "enabled", "runtimes"]);
+    if (!id(p.id) || typeof p.label !== "string" || !p.label.trim() || p.label.length > 100
+      || /[\x00-\x1f\x7f]/.test(p.label) || typeof p.enabled !== "boolean") fail();
+    const runtimes = arr(p.runtimes, 8); unique(runtimes, "runtime");
+    for (const r of runtimes) {
+      obj(r, ["runtime", "auth"]); if (r.runtime !== "codex-tui") fail();
+      const auths = arr(r.auth, 32); unique(auths, "id");
+      for (const a of auths) {
+        obj(a, ["id", "kind", "models", "baseUrl", "credential_present", "verification", "application"]);
+        if (!id(a.id) || a.verification !== "not_checked" || a.application !== "not_applied") fail();
+        const models = arr(a.models, 200);
+        if (new Set(models).size !== models.length || models.some(m => typeof m !== "string" || !/^[A-Za-z0-9][A-Za-z0-9._:-]{0,199}$/.test(m))) fail();
+        if (a.kind === "chatgpt") {
+          if (p.id !== "openai" || a.baseUrl !== undefined || a.credential_present !== false) fail();
+        } else if (a.kind === "api_key") {
+          if (a.credential_present !== true || typeof a.baseUrl !== "string" || a.baseUrl.length > 2048) fail();
+          let u: URL; try { u = new URL(a.baseUrl); } catch { return fail(); }
+          if (u.protocol !== "https:" || u.username || u.password || u.search || u.hash) fail();
+        } else fail();
+      }
+    }
+  }
+  // JSON roundtrip detaches the validated object from mutable caller references.
+  const encoded = JSON.stringify(s);
+  if (new TextEncoder().encode(encoded).byteLength > 1024 * 1024) fail();
+  return JSON.parse(encoded);
+}

package/src/shared/external-schedule-contract.ts

@@ -0,0 +1,60 @@
+const FIELD_BOUNDS = [
+  [0, 59],
+  [0, 23],
+  [1, 31],
+  [1, 12],
+  [0, 7],
+] as const;
+
+function integer(text: string, min: number, max: number): number {
+  if (!/^\d+$/.test(text)) throw new Error("invalid_cron");
+  const value = Number(text);
+  if (!Number.isSafeInteger(value) || value < min || value > max) throw new Error("invalid_cron");
+  return value;
+}
+
+function validateAtom(atom: string, min: number, max: number): void {
+  const [base, step, extra] = atom.split("/");
+  if (extra !== undefined || !base) throw new Error("invalid_cron");
+  if (step !== undefined) integer(step, 1, max - min + 1);
+  if (base === "*") return;
+  const range = base.split("-");
+  if (range.length === 1) {
+    integer(range[0], min, max);
+    return;
+  }
+  if (range.length !== 2) throw new Error("invalid_cron");
+  const start = integer(range[0], min, max);
+  const end = integer(range[1], min, max);
+  if (start > end) throw new Error("invalid_cron");
+}
+
+/** Strict five-field cron timing. It deliberately excludes commands, names,
+ * @aliases, a sixth seconds field and every control character. */
+export function parseManagedCronExpression(raw: unknown): string {
+  if (typeof raw !== "string" || raw.length < 5 || raw.length > 120) throw new Error("invalid_cron");
+  if (/[^\x20-\x7e]/.test(raw) || /[\r\n]/.test(raw)) throw new Error("invalid_cron");
+  const fields = raw.trim().split(/ +/);
+  if (fields.length !== 5) throw new Error("invalid_cron");
+  fields.forEach((field, index) => {
+    if (!field || !/^[0-9*/,-]+$/.test(field)) throw new Error("invalid_cron");
+    for (const atom of field.split(",")) validateAtom(atom, FIELD_BOUNDS[index][0], FIELD_BOUNDS[index][1]);
+  });
+  return fields.join(" ");
+}
+
+export type ExternalSchedulePatch = { enabled?: boolean; cron?: string };
+
+export function parseExternalSchedulePatch(raw: unknown): ExternalSchedulePatch {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) throw new Error("invalid_patch");
+  const obj = raw as Record<string, unknown>;
+  const keys = Object.keys(obj);
+  if (keys.length === 0 || keys.some((key) => key !== "enabled" && key !== "cron")) throw new Error("invalid_patch");
+  const patch: ExternalSchedulePatch = {};
+  if (obj.enabled !== undefined) {
+    if (typeof obj.enabled !== "boolean") throw new Error("invalid_enabled");
+    patch.enabled = obj.enabled;
+  }
+  if (obj.cron !== undefined) patch.cron = parseManagedCronExpression(obj.cron);
+  return patch;
+}

package/src/shared/node-name.test.ts

@@ -0,0 +1,62 @@
+import { describe, expect, test } from "bun:test";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import {
+  NODE_FOLDER_RE, NODE_NAME_CASES, LEGACY_NODE_NAME_RE,
+  checkNodeName, nodeDirNameFor, nodeFolderSlug, fnv1aHex,
+} from "./node-name.js";
+
+// Board #652 — one name rule for hub + daemon (+ the app's pinned copy).
+
+describe("#652 checkNodeName — shared vectors", () => {
+  for (const c of NODE_NAME_CASES) {
+    test(`${JSON.stringify(c.input).slice(0, 24)} → ${c.ok ? "ok" : c.error}`, () => {
+      const r = checkNodeName(c.input);
+      expect(r.ok).toBe(c.ok);
+      if (!r.ok) {
+        expect(r.error).toBe(c.error!);
+        expect(r.message.length).toBeGreaterThan(0);
+      }
+      if (c.slug !== undefined) expect(nodeFolderSlug(c.input)).toBe(c.slug);
+    });
+  }
+
+  test("the vector table really contains Chinese names that pass (old rule would refuse them)", () => {
+    const cjkOk = NODE_NAME_CASES.filter(c => c.ok && /\p{Script=Han}/u.test(c.input));
+    expect(cjkOk.length).toBeGreaterThan(0);
+    for (const c of cjkOk) expect(LEGACY_NODE_NAME_RE.test(c.input)).toBe(false);
+  });
+});
+
+describe("#652 folder slug", () => {
+  test("every slug — incl. every accepted vector — matches the ASCII folder rule", () => {
+    for (const c of NODE_NAME_CASES.filter(x => x.ok)) {
+      const s = nodeFolderSlug(c.input);
+      expect(NODE_FOLDER_RE.test(s)).toBe(true);
+      expect(/^[\x21-\x7e]+$/.test(s)).toBe(true);
+    }
+  });
+  test("non-ASCII → node-<6 hex>, deterministic", () => {
+    expect(nodeFolderSlug("测试")).toMatch(/^node-[0-9a-f]{6}$/);
+    expect(nodeFolderSlug("测试")).toBe(nodeFolderSlug(" 测试 "));
+    expect(nodeFolderSlug("测试")).not.toBe(nodeFolderSlug("测验"));
+  });
+  test("fnv1a known answers (pins the app reimplementation)", () => {
+    expect(fnv1aHex("")).toBe("811c9dc5");
+    expect(fnv1aHex("a")).toBe("e40c292c");
+    expect(fnv1aHex("foobar")).toBe("bf9cf968");
+  });
+  test("nodeDirNameFor keeps legacy names as-is (existing nodes never move)", () => {
+    for (const n of ["a", "demo-bot", "node_1", "my_agent"]) expect(nodeDirNameFor(n)).toBe(n);
+    expect(nodeDirNameFor("测试")).toBe(nodeFolderSlug("测试"));
+    expect(nodeDirNameFor("MyBot")).toBe("mybot");
+  });
+});
+
+describe("#652 hub/daemon node-name drift guard", () => {
+  test("byte-identical source files", () => {
+    const hub = readFileSync(join(import.meta.dir, "node-name.ts"), "utf-8");
+    const daemon = readFileSync(join(import.meta.dir, "..", "..", "..", "agent-node", "src", "shared", "node-name.ts"), "utf-8");
+    expect(daemon).toBe(hub);
+  });
+});

package/src/shared/node-name.ts

@@ -0,0 +1,161 @@
+// Board #652 — node name (= network alias) rules and the ASCII folder slug derived from it.
+//
+// Single source of truth for hub + daemon. This file is byte-identical in
+// server/src/shared/node-name.ts and agent-node/src/shared/node-name.ts
+// (node-name-drift.test.ts fails the build on any difference), and the app
+// (sleep2agi/agent-network-app) keeps a copy pinned to NODE_NAME_CASES below.
+//
+// Before #652 the name had to match /^[a-z][a-z0-9_-]{0,63}$/, so the app
+// wizard refused 「测试」 while the real fleet runs Chinese aliases started by
+// hand. House rule: the alias may be Chinese, the working directory may not.
+// So the name is now any Unicode letters/digits, and every directory derived
+// from it uses nodeFolderSlug() (or the legacy name, for names the old rule
+// already accepted — see nodeDirNameFor).
+
+/** The old rule. Every name it accepts keeps its old directory (nodeDirNameFor). */
+export const LEGACY_NODE_NAME_RE = /^[a-z][a-z0-9_-]{0,63}$/;
+
+/** Folder / slug rule: what a working directory or `.anet/nodes/<dir>` may be called. */
+export const NODE_FOLDER_RE = /^[a-z][a-z0-9-]{0,63}$/;
+
+export const NODE_NAME_MAX_CHARS = 64;
+
+// First char: a letter, a digit or `_` (never `-`: `anet node start -x` reads as a flag;
+// never `.`: hidden files, `..`). Rest: letters, digits, combining marks (Devanagari,
+// Thai… need them), `_`, `-`. Nothing else — no whitespace, `/ \ :`, `.`, quotes,
+// `$`, backticks, control characters: the name ends up in argv, tmux session names
+// (tmux rewrites `.` and `:`), JSON, logs and file names in the trash directory.
+const NODE_NAME_RE = /^[\p{L}\p{N}_][\p{L}\p{M}\p{N}_-]*$/u;
+
+export type NodeNameError =
+  | "empty"
+  | "too_long"
+  | "leading_dash"
+  | "forbidden_char"
+  | "not_nfc";
+
+export type NodeNameCheck =
+  | { ok: true; name: string }
+  | { ok: false; error: NodeNameError; char?: string; message: string };
+
+/** Trim + NFC. Callers store the returned `name`, not the raw input. */
+export function normalizeNodeName(raw: string): string {
+  return raw.trim().normalize("NFC");
+}
+
+function describeChar(ch: string): string {
+  const cp = ch.codePointAt(0) ?? 0;
+  if (cp < 0x20 || cp === 0x7f) return `U+${cp.toString(16).toUpperCase().padStart(4, "0")}`;
+  if (/\s/u.test(ch)) return "空格";
+  return ch;
+}
+
+/**
+ * Check a node name. `raw` is trimmed first; the trimmed, NFC form must be
+ * 1..64 characters (code points) of letters / digits / `_` / `-`, not starting with `-`.
+ */
+export function checkNodeName(raw: unknown): NodeNameCheck {
+  if (typeof raw !== "string") return { ok: false, error: "empty", message: "名字不能为空" };
+  const trimmed = raw.trim();
+  if (trimmed.length === 0) return { ok: false, error: "empty", message: "名字不能为空" };
+  const chars = [...trimmed];
+  if (chars.length > NODE_NAME_MAX_CHARS) {
+    return { ok: false, error: "too_long", message: `名字最多 ${NODE_NAME_MAX_CHARS} 个字符` };
+  }
+  if (trimmed !== trimmed.normalize("NFC")) {
+    return { ok: false, error: "not_nfc", message: "名字需要是 Unicode NFC 规范形式" };
+  }
+  if (chars[0] === "-") {
+    return { ok: false, error: "leading_dash", char: "-", message: "名字不能以 - 开头" };
+  }
+  if (!NODE_NAME_RE.test(trimmed)) {
+    const bad = chars.find((ch, i) => !(i === 0 ? /^[\p{L}\p{N}_]$/u : /^[\p{L}\p{M}\p{N}_-]$/u).test(ch)) ?? chars[0]!;
+    return {
+      ok: false,
+      error: "forbidden_char",
+      char: bad,
+      message: `名字里不能有「${describeChar(bad)}」：只能用文字、字母、数字、_ 和 -`,
+    };
+  }
+  return { ok: true, name: trimmed };
+}
+
+export function isValidNodeName(raw: unknown): boolean {
+  return checkNodeName(raw).ok;
+}
+
+/** FNV-1a 32-bit over the UTF-8 bytes, 8 hex digits. Tiny, dependency-free, and the
+ *  app reimplements it byte for byte (no crypto module needed in the browser / RN). */
+export function fnv1aHex(s: string): string {
+  const bytes = new TextEncoder().encode(s);
+  let h = 0x811c9dc5;
+  for (const b of bytes) {
+    h ^= b;
+    h = Math.imul(h, 0x01000193) >>> 0;
+  }
+  return h.toString(16).padStart(8, "0");
+}
+
+/**
+ * ASCII folder name for a node name. Pure-ASCII names are transliterated
+ * (lowercase, runs of anything outside [a-z0-9] become one `-`, trimmed, `node-`
+ * prefixed when they do not start with a letter); anything else — and anything the
+ * transliteration empties — becomes `node-<first 6 hex of fnv1a(name)>`.
+ * The result always matches NODE_FOLDER_RE.
+ */
+export function nodeFolderSlug(raw: string): string {
+  const name = normalizeNodeName(raw);
+  // eslint-disable-next-line no-control-regex
+  if (/^[\x00-\x7f]*$/.test(name)) {
+    let s = name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+    if (s && !/^[a-z]/.test(s)) s = `node-${s}`;
+    s = s.slice(0, NODE_NAME_MAX_CHARS).replace(/-+$/, "");
+    if (NODE_FOLDER_RE.test(s)) return s;
+  }
+  return `node-${fnv1aHex(name).slice(0, 6)}`;
+}
+
+/**
+ * The directory under `.anet/nodes/` a daemon-created node lives in.
+ * Names the old rule accepted keep their old directory (= the name) so nothing that
+ * worked before #652 moves; every other name gets nodeFolderSlug(name).
+ */
+export function nodeDirNameFor(name: string): string {
+  return LEGACY_NODE_NAME_RE.test(name) ? name : nodeFolderSlug(name);
+}
+
+/** Shared test vectors — the app's copy must produce the same verdicts and slugs. */
+export const NODE_NAME_CASES: ReadonlyArray<{ input: string; ok: boolean; error?: NodeNameError; slug?: string }> = [
+  { input: "测试", ok: true, slug: "node-f78149" },
+  { input: "研发助手A", ok: true, slug: "node-1d348f" },
+  { input: "AB测试牛", ok: true, slug: "node-048250" },
+  { input: "my-bot", ok: true, slug: "my-bot" },
+  { input: "MyBot_2", ok: true, slug: "mybot-2" },
+  { input: "  spaced  ", ok: true, slug: "spaced" },
+  { input: "123", ok: true, slug: "node-123" },
+  { input: "_x", ok: true, slug: "x" },
+  { input: "Ünïcödé", ok: true, slug: "node-030667" },
+  { input: "a".repeat(64), ok: true, slug: "a".repeat(64) },
+  { input: "测".repeat(64), ok: true, slug: "node-50c3fb" },
+  { input: "", ok: false, error: "empty" },
+  { input: "   ", ok: false, error: "empty" },
+  { input: "a".repeat(65), ok: false, error: "too_long" },
+  { input: "测".repeat(65), ok: false, error: "too_long" },
+  { input: "-x", ok: false, error: "leading_dash" },
+  { input: "e\u0301", ok: false, error: "not_nfc" },
+  { input: ".hidden", ok: false, error: "forbidden_char" },
+  { input: "..", ok: false, error: "forbidden_char" },
+  { input: "a/b", ok: false, error: "forbidden_char" },
+  { input: "a\\b", ok: false, error: "forbidden_char" },
+  { input: "a:b", ok: false, error: "forbidden_char" },
+  { input: "a.b", ok: false, error: "forbidden_char" },
+  { input: "a b", ok: false, error: "forbidden_char" },
+  { input: "a\u0000b", ok: false, error: "forbidden_char" },
+  { input: "a\nb", ok: false, error: "forbidden_char" },
+  { input: "a$b", ok: false, error: "forbidden_char" },
+  { input: "a`b", ok: false, error: "forbidden_char" },
+  { input: "a'b", ok: false, error: "forbidden_char" },
+  { input: "a\"b", ok: false, error: "forbidden_char" },
+  { input: "a;b", ok: false, error: "forbidden_char" },
+  { input: "a*b", ok: false, error: "forbidden_char" },
+];

package/src/shared/provider-application.ts

@@ -0,0 +1,24 @@
+// #906 public application protocol. No paths, endpoints or credentials.
+export type ProviderApplicationSelection = {
+  node_id: string; node_revision: string; provider_id: string; auth_id: string;
+  model: string; confirm_restart: true;
+};
+const fields = (v: any, names: string[]) => v && typeof v === 'object' && !Array.isArray(v)
+  && Object.keys(v).length === names.length && Object.keys(v).every(k => names.includes(k));
+const id = (v: any) => typeof v === 'string' && /^[A-Za-z0-9][A-Za-z0-9._:/-]{0,199}$/.test(v);
+const hash = (v: any) => typeof v === 'string' && /^[a-f0-9]{64}$/.test(v);
+export function validProviderApplicationSelection(v: any): v is ProviderApplicationSelection {
+  return fields(v, ['node_id', 'node_revision', 'provider_id', 'auth_id', 'model', 'confirm_restart'])
+    && id(v.node_id) && hash(v.node_revision) && id(v.provider_id) && id(v.auth_id) && id(v.model)
+    && v.confirm_restart === true;
+}
+export function validProviderApplicationReceipt(v: any, requestId: string, revision: number,
+  selection: ProviderApplicationSelection): boolean {
+  return fields(v, ['status', 'request_id', 'node_id', 'provider_id', 'auth_id', 'model', 'runtime_provider',
+    'node_revision', 'provider_revision', 'verification', 'applied_at'])
+    && v.status === 'applied' && v.request_id === requestId && v.node_id === selection.node_id
+    && v.provider_id === selection.provider_id && v.auth_id === selection.auth_id && v.model === selection.model
+    && typeof v.runtime_provider === 'string' && /^anet_[a-f0-9]{20}$/.test(v.runtime_provider)
+    && hash(v.node_revision) && v.provider_revision === revision && v.verification === 'runtime_confirmed'
+    && Number.isSafeInteger(v.applied_at) && v.applied_at > 0 && v.applied_at <= Date.now() + 30_000;
+}

package/src/shared/reserved-env-drift.test.ts

@@ -17,27 +17,37 @@ import {
 
 const HUB_PATH = join(import.meta.dir, "reserved-env.ts");
 const DAEMON_PATH = join(import.meta.dir, "..", "..", "..", "agent-node", "src", "shared", "reserved-env.ts");
+const CLI_PATH = join(import.meta.dir, "..", "..", "..", "agent-network", "src", "shared", "reserved-env.ts");
 
 describe("RFC-026 v4 §4.4.7 G9 — hub/daemon reserved-env drift guard", () => {
   test("byte-identical source files", () => {
     const hub = readFileSync(HUB_PATH, "utf-8");
     const daemon = readFileSync(DAEMON_PATH, "utf-8");
+    const cli = readFileSync(CLI_PATH, "utf-8");
     expect(daemon).toBe(hub);
+    expect(cli).toBe(hub);
   });
 
   test("imported constants are set-equal at runtime", async () => {
     // Use a dynamic file import path so this test breaks if the file
     // moves but still references the daemon copy.
     const daemonMod = await import(DAEMON_PATH);
+    const cliMod = await import(CLI_PATH);
     const daemonExact = daemonMod.RESERVED_ENV_KEYS_EXACT as Set<string>;
     const daemonPrefixes = daemonMod.RESERVED_ENV_PREFIXES as ReadonlyArray<string>;
+    const cliExact = cliMod.RESERVED_ENV_KEYS_EXACT as Set<string>;
+    const cliPrefixes = cliMod.RESERVED_ENV_PREFIXES as ReadonlyArray<string>;
 
     // EXACT set equality
     expect(daemonExact.size).toBe(HUB_EXACT.size);
     for (const k of HUB_EXACT) expect(daemonExact.has(k)).toBe(true);
     for (const k of daemonExact) expect(HUB_EXACT.has(k)).toBe(true);
+    expect(cliExact.size).toBe(HUB_EXACT.size);
+    for (const k of HUB_EXACT) expect(cliExact.has(k)).toBe(true);
+    for (const k of cliExact) expect(HUB_EXACT.has(k)).toBe(true);
 
     // PREFIX array order-independent equality
     expect(new Set(daemonPrefixes)).toEqual(new Set(HUB_PREFIXES));
+    expect(new Set(cliPrefixes)).toEqual(new Set(HUB_PREFIXES));
   });
 });

package/src/shared/task-content-limit-drift.test.ts

@@ -0,0 +1,28 @@
+import { describe, expect, test } from "bun:test";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { SESSION_TASK_PREVIEW_MAX, TASK_CONTENT_MAX, sessionTaskPreview } from "./task-content-limit.js";
+
+// Board #668 — the node reports the whole task so the hub can match it
+// against tasks.content. Both sides must agree on the cap.
+const HUB_PATH = join(import.meta.dir, "task-content-limit.ts");
+const NODE_PATH = join(import.meta.dir, "..", "..", "..", "agent-node", "src", "shared", "task-content-limit.ts");
+
+describe("#668 — hub/node task-content-limit drift guard", () => {
+  test("byte-identical source files", () => {
+    expect(readFileSync(NODE_PATH, "utf-8")).toBe(readFileSync(HUB_PATH, "utf-8"));
+  });
+
+  test("constants equal at runtime", async () => {
+    const node = await import(NODE_PATH);
+    expect(node.TASK_CONTENT_MAX).toBe(TASK_CONTENT_MAX);
+    expect(node.SESSION_TASK_PREVIEW_MAX).toBe(SESSION_TASK_PREVIEW_MAX);
+  });
+
+  test("preview is the first 200 chars", () => {
+    expect(SESSION_TASK_PREVIEW_MAX).toBe(200);
+    const long = "字".repeat(TASK_CONTENT_MAX);
+    expect(sessionTaskPreview(long)).toBe(long.slice(0, 200));
+    expect(sessionTaskPreview("short")).toBe("short");
+  });
+});

package/src/shared/task-content-limit.ts

@@ -0,0 +1,25 @@
+// Board #668 — task text limits shared by hub and node.
+//
+// This file is byte-identical in server/src/shared/task-content-limit.ts and
+// agent-node/src/shared/task-content-limit.ts (task-content-limit-drift.test.ts
+// fails the build on any difference).
+//
+// TASK_CONTENT_MAX is the cap every dispatch entry (send_task, REST /api/task,
+// scheduled tasks) and report_status.task accept. The node reports the whole
+// task text so the hub can match it against tasks.content and write
+// started_at. If the dispatch cap grew without the node and report_status
+// following, long tasks would silently stop matching again.
+//
+// SESSION_TASK_PREVIEW_MAX is what the hub keeps in sessions.task. That column
+// is readable by get_all_status, the full /api/status and members who may see
+// the agent but not its conversations, so only a short preview is stored —
+// the full text is used for matching, never persisted on the session row.
+
+export const TASK_CONTENT_MAX = 10_000;
+
+export const SESSION_TASK_PREVIEW_MAX = 200;
+
+/** The preview stored in sessions.task — same cut as the dispatch preview. */
+export function sessionTaskPreview(task: string): string {
+  return task.slice(0, SESSION_TASK_PREVIEW_MAX);
+}