@sleep2agi/commhub-server 0.9.0-preview.139 → 0.9.0-preview.140

package/src/scheduled-work-outcome-http.test.ts

@@ -0,0 +1,154 @@
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { createNetworkTokenForNode, register } from "./auth.js";
+import { db, syncScheduledRunForTask } from "./db.js";
+import { runDueScheduledTasks } from "./scheduled-tasks.js";
+
+if (!process.env.COMMHUB_DB) throw new Error("test1274 requires an explicit disposable SQLite COMMHUB_DB");
+let server: any, base = "", network = "", ownerToken = "", ownerId = "";
+const stamp = Date.now(), nodes: Record<string, { id: string; alias: string; token: string; tokenId: string }> = {};
+async function rest(token: string, method: string, path: string, body?: unknown) {
+  const r = await fetch(base + path, { method, headers: { Authorization: `Bearer ${token}`,
+    "Content-Type": "application/json" }, body: body === undefined ? undefined : JSON.stringify(body) });
+  return { status: r.status, body: await r.json() as any };
+}
+async function mcp(token: string, name: string, args: Record<string, unknown>) {
+  const r = await fetch(base + "/mcp", { method: "POST", headers: { Authorization: `Bearer ${token}`,
+    "Content-Type": "application/json", Accept: "application/json, text/event-stream" },
+    body: JSON.stringify({ jsonrpc: "2.0", id: 1, method: "tools/call", params: { name, arguments: args } }) });
+  const raw = await r.text(), line = raw.split("\n").find(x => x.startsWith("data: "));
+  const envelope = JSON.parse(line ? line.slice(6) : raw);
+  try { return JSON.parse(envelope.result.content[0].text); }
+  catch { return { ok: false, transportError: true }; }
+}
+const readRun = (taskId: string) => db.get<any>(
+  "SELECT run_id, schedule_id, status, work_outcome, work_outcome_node_id, schedule_revision FROM scheduled_task_runs WHERE task_id = ?1 AND network_id = ?2", taskId, network)!;
+const readTask = (taskId: string) => db.get<any>("SELECT status, result FROM tasks WHERE task_id = ?1", taskId)!;
+const countReplies = (taskId: string) => db.get<{ n: number }>("SELECT COUNT(*) AS n FROM inbox WHERE in_reply_to = ?1 AND type = 'reply'", taskId)!.n;
+async function fire() {
+  const created = await rest(ownerToken, "POST", "/api/scheduled-tasks", { network_id: network,
+    name: `test1274-${crypto.randomUUID()}`, target_node_id: nodes.a.id, task: "fixture1274 work",
+    schedule: { type: "interval", every_seconds: 120 }, timezone: "UTC" });
+  expect(created.status).toBe(201);
+  const scheduleId = created.body.schedule.schedule_id;
+  db.run("UPDATE scheduled_tasks SET next_run_at = ?1 WHERE schedule_id != ?2", [new Date(Date.now() + 86400_000).toISOString(), scheduleId]);
+  db.run("UPDATE scheduled_tasks SET next_run_at = ?1 WHERE schedule_id = ?2", [new Date(Date.now() - 1000).toISOString(), scheduleId]);
+  await runDueScheduledTasks();
+  const run = db.get<any>("SELECT task_id FROM scheduled_task_runs WHERE schedule_id = ?1", scheduleId)!;
+  expect(run.task_id).toBeTruthy();
+  return { taskId: run.task_id as string, scheduleId };
+}
+const reply = (taskId: string, meta?: unknown, status = "replied", token = nodes.a.token, extra = {}) =>
+  mcp(token, "send_reply", { in_reply_to: taskId, text: "本轮无新增", status, ...(meta === undefined ? {} : { meta }), ...extra });
+const cadence = (id: string) => db.get<any>("SELECT next_run_at, last_run_at, revision, schedule_json, target_node_id FROM scheduled_tasks WHERE schedule_id = ?1", id)!;
+
+beforeAll(async () => {
+  const owner = register(`work_owner_${stamp}`, "Fixture1274Only!x"); ownerToken = owner.token!;
+  network = owner.network_id!; ownerId = owner.user!.user_id;
+  for (const key of ["a", "b"]) {
+    const id = `n_work_${key}_${stamp}`, alias = `work-${key}-${stamp}`;
+    const token = createNetworkTokenForNode(ownerId, network, alias, id); expect(token.ok).toBe(true);
+    nodes[key] = { id, alias, token: token.token!, tokenId: token.token_id! };
+    db.run("INSERT INTO sessions (resume_id, alias, status, node_id, network_id) VALUES (?1, ?2, 'idle', ?3, ?4)", [`r_${id}`, alias, id, network]);
+  }
+  const mod = await import("./server.js"); server = mod.bootServer({ port: 0, hostname: "127.0.0.1" });
+  base = `http://127.0.0.1:${server.port}`;
+}, 30_000);
+afterAll(() => server?.stop?.(true));
+
+describe("#1274 exact successful scheduler work outcomes over real HTTP/MCP", () => {
+  test("explicit no_changes persists with the same successful run and is readable; cadence stays unchanged", async () => {
+    const { taskId, scheduleId } = await fire(), before = cadence(scheduleId);
+    expect(readRun(taskId).schedule_revision).toBe(before.revision);
+    const out = await reply(taskId, { scheduled_work_outcome: "no_changes", scheduled_run_id: "forged-and-ignored" });
+    expect(out.ok).toBe(true); expect(out.scheduled_work_outcome).toBe("no_changes");
+    expect(readTask(taskId).status).toBe("replied");
+    expect(readRun(taskId)).toMatchObject({ status: "replied", work_outcome: "no_changes", work_outcome_node_id: nodes.a.id });
+    expect(cadence(scheduleId)).toEqual(before);
+    const history = await rest(ownerToken, "GET", `/api/scheduled-tasks/${scheduleId}/runs`);
+    expect(history.status).toBe(200);
+    expect(history.body.runs[0]).toMatchObject({ task_id: taskId, work_outcome: "no_changes", schedule_revision: before.revision, work_outcome_node_id: nodes.a.id });
+  });
+  test("changed is explicit even when the reply's natural-language text says no changes", async () => {
+    const { taskId } = await fire(); expect((await reply(taskId, { scheduled_work_outcome: "changed" })).ok).toBe(true);
+    expect(readRun(taskId).work_outcome).toBe("changed");
+  });
+  test("legacy success and empty-looking text remain unknown with unchanged response shape", async () => {
+    const { taskId } = await fire(), out = await reply(taskId);
+    expect(out.ok).toBe(true); expect(out.scheduled_work_outcome).toBeUndefined();
+    expect(readRun(taskId)).toMatchObject({ status: "replied", work_outcome: null, work_outcome_node_id: null });
+  });
+  test("malformed, failed and cancelled signals do not write; ordinary terminal failures stay unknown", async () => {
+    for (const [status, value] of [["replied", null], ["replied", "empty"], ["failed", "no_changes"], ["cancelled", "no_changes"]]) {
+      const { taskId } = await fire(); expect((await reply(taskId, { scheduled_work_outcome: value }, status!)).ok).toBe(false);
+      expect(readTask(taskId).status).toBe("delivered"); expect(countReplies(taskId)).toBe(0);
+      expect((await reply(taskId, undefined, status!)).ok).toBe(true); expect(readRun(taskId).work_outcome).toBeNull();
+    }
+  });
+  test("sibling node and a human token cannot classify the assigned node's run", async () => {
+    const { taskId } = await fire();
+    expect((await reply(taskId, { scheduled_work_outcome: "no_changes" }, "replied", nodes.b.token)).ok).toBe(false);
+    expect((await reply(taskId, { scheduled_work_outcome: "no_changes" }, "replied", ownerToken)).ok).toBe(false);
+    expect(readTask(taskId).status).toBe("delivered"); expect(readRun(taskId).work_outcome).toBeNull(); expect(countReplies(taskId)).toBe(0);
+  });
+  test("a foreign network token cannot classify or terminalize the run", async () => {
+    const { taskId } = await fire(), foreign = register(`work_foreign_${crypto.randomUUID()}`, "Fixture1274Only!x");
+    const token = createNetworkTokenForNode(foreign.user!.user_id, foreign.network_id!, `foreign-${crypto.randomUUID()}`, `n_${crypto.randomUUID()}`);
+    expect((await reply(taskId, { scheduled_work_outcome: "no_changes" }, "replied", token.token!)).ok).toBe(false);
+    expect(readTask(taskId).status).toBe("delivered"); expect(countReplies(taskId)).toBe(0);
+  });
+  test("a legacy unbound node token can still reply normally but cannot report a work signal", async () => {
+    const { taskId } = await fire();
+    db.run("UPDATE api_tokens SET bound_node_id = NULL WHERE token_id = ?1 AND network_id = ?2", [nodes.a.tokenId, network]);
+    try {
+      expect((await reply(taskId, { scheduled_work_outcome: "no_changes" })).ok).toBe(false);
+      expect((await reply(taskId)).ok).toBe(true); expect(readRun(taskId).work_outcome).toBeNull();
+    } finally { db.run("UPDATE api_tokens SET bound_node_id = ?1 WHERE token_id = ?2 AND network_id = ?3", [nodes.a.id, nodes.a.tokenId, network]); }
+  });
+  test("forged schedule metadata on an ordinary task cannot become an authoritative occurrence", async () => {
+    const { scheduleId } = await fire(); const sent = await rest(ownerToken, "POST", "/api/task", { network_id: network, alias: nodes.a.alias, task: "ordinary1274" });
+    expect(sent.status).toBe(200);
+    expect((await reply(sent.body.task_id, { scheduled_work_outcome: "no_changes", scheduled_task_id: scheduleId })).ok).toBe(false);
+    expect(readTask(sent.body.task_id).status).toBe("delivered"); expect(countReplies(sent.body.task_id)).toBe(0);
+  });
+  test("multiple authoritative bindings refuse instead of fanning one outcome into two runs", async () => {
+    const { taskId, scheduleId } = await fire(), run = readRun(taskId), duplicate = `srun_dup_${crypto.randomUUID()}`;
+    db.run("INSERT INTO scheduled_task_runs (run_id, schedule_id, network_id, scheduled_for, task_id, status) VALUES (?1, ?2, ?3, ?4, ?5, 'delivered')", [duplicate, scheduleId, network, new Date(Date.now() + 86400_000).toISOString(), taskId]);
+    try { expect((await reply(taskId, { scheduled_work_outcome: "no_changes" })).error).toBe("scheduled_work_outcome_run_unresolved");
+      expect(readTask(taskId).status).toBe("delivered"); expect(countReplies(taskId)).toBe(0); }
+    finally { db.run("DELETE FROM scheduled_task_runs WHERE run_id = ?1", duplicate); }
+    expect(readRun(taskId).run_id).toBe(run.run_id); expect(readRun(taskId).work_outcome).toBeNull();
+  });
+  test("expired/late receipts never classify a run or rewrite its original terminal state", async () => {
+    const { taskId } = await fire(), thread_id = `thread_${crypto.randomUUID()}`, turn_id = `turn_${crypto.randomUUID()}`;
+    db.run("UPDATE tasks SET status = 'expired', thread_id = ?1, turn_id = ?2, completed_at = datetime('now') WHERE task_id = ?3", [thread_id, turn_id, taskId]); syncScheduledRunForTask(taskId, network);
+    expect((await reply(taskId, { scheduled_work_outcome: "no_changes" }, "replied", nodes.a.token, { thread_id, turn_id })).error).toBe("scheduled_work_outcome_terminal");
+    expect((await reply(taskId, undefined, "replied", nodes.a.token, { thread_id, turn_id })).late).toBe(true);
+    expect(readTask(taskId).status).toBe("expired"); expect(readRun(taskId)).toMatchObject({ status: "expired", work_outcome: null });
+  });
+  test("success cannot retry; an expired fixture task clears stale outcome on retry and later failure", async () => {
+    const { taskId } = await fire(); expect((await reply(taskId, { scheduled_work_outcome: "no_changes" })).ok).toBe(true);
+    expect((await mcp(ownerToken, "retry_task", { task_id: taskId, network_id: network })).ok).toBe(false);
+    // Fixture-only legacy/corrupt terminal injection: preserve the stale run
+    // signal deliberately so the retry clearing branch is load-bearing.
+    db.run("UPDATE tasks SET status = 'expired' WHERE task_id = ?1", taskId);
+    expect((await mcp(ownerToken, "retry_task", { task_id: taskId, network_id: network })).ok).toBe(true);
+    expect(readRun(taskId)).toMatchObject({ status: "delivered", work_outcome: null, work_outcome_node_id: null });
+    expect((await reply(taskId, undefined, "failed")).ok).toBe(true); expect(readRun(taskId)).toMatchObject({ status: "failed", work_outcome: null });
+  });
+  test("injected outcome write failure rolls back task, inbox and run atomically", async () => {
+    const { taskId } = await fire(), run = readRun(taskId);
+    db.exec(`CREATE TRIGGER test1274_outcome_fault BEFORE UPDATE OF work_outcome ON scheduled_task_runs WHEN NEW.run_id = '${run.run_id}' AND NEW.work_outcome IS NOT NULL BEGIN SELECT RAISE(ABORT, 'test1274_fault'); END`);
+    try { expect((await reply(taskId, { scheduled_work_outcome: "no_changes" })).ok).not.toBe(true); }
+    finally { db.exec("DROP TRIGGER test1274_outcome_fault"); }
+    expect(readTask(taskId)).toMatchObject({ status: "delivered", result: null });
+    expect(readRun(taskId)).toMatchObject({ status: "delivered", work_outcome: null }); expect(countReplies(taskId)).toBe(0);
+    expect((await reply(taskId, { scheduled_work_outcome: "changed" })).ok).toBe(true);
+  });
+  test("a later schedule edit cannot relabel the dispatch revision; history alone grants no backoff", async () => {
+    const { taskId, scheduleId } = await fire(), revision = readRun(taskId).schedule_revision;
+    const edit = await rest(ownerToken, "PATCH", `/api/scheduled-tasks/${scheduleId}`, { revision, name: "edited1274" }); expect(edit.status).toBe(200);
+    const before = cadence(scheduleId); expect(before.revision).toBe(revision + 1);
+    expect((await reply(taskId, { scheduled_work_outcome: "no_changes" })).ok).toBe(true);
+    expect(readRun(taskId).schedule_revision).toBe(revision); expect(cadence(scheduleId)).toEqual(before);
+  });
+});

package/src/scheduled-work-outcome.ts

@@ -0,0 +1,50 @@
+import { db } from "./db.js";
+
+export type ScheduledWorkOutcome = "changed" | "no_changes";
+export function parseScheduledWorkOutcome(meta: unknown, status: string):
+  { ok: true; outcome?: ScheduledWorkOutcome } | { ok: false; error: string } {
+  if (!meta || typeof meta !== "object" || Array.isArray(meta)
+    || !Object.hasOwn(meta, "scheduled_work_outcome")) return { ok: true };
+  const outcome = (meta as Record<string, unknown>).scheduled_work_outcome;
+  if (outcome !== "changed" && outcome !== "no_changes")
+    return { ok: false, error: "invalid_scheduled_work_outcome" };
+  if (status !== "replied") return { ok: false, error: "scheduled_work_outcome_requires_success" };
+  return { ok: true, outcome };
+}
+
+type Binding = { run_id: string; schedule_id: string; task_id: string; network_id: string; node_id: string };
+/** Called within the normal reply transaction, after the existing sender and
+ * recipient checks. Caller metadata never supplies schedule/run bindings. */
+export function qualifyScheduledWorkOutcome(taskId: string, networkId: string, nodeId: string | null):
+  { ok: true; binding: Binding } | { ok: false; error: string } {
+  if (!nodeId) return { ok: false, error: "scheduled_work_outcome_bound_node_required" };
+  if (db.transactionalFeaturesRefusal !== null)
+    return { ok: false, error: "scheduled_work_outcome_backend_unsupported" };
+  const task = db.get<{ to_node_id: string | null; from_name: string; status: string }>(
+    "SELECT to_node_id, from_name, status FROM tasks WHERE task_id = ?1 AND network_id = ?2", taskId, networkId);
+  if (!task || task.to_node_id !== nodeId || task.from_name !== "scheduler"
+    || !["created", "delivered", "acked", "running"].includes(task.status))
+    return { ok: false, error: "scheduled_work_outcome_task_not_owned" };
+  const runs = db.all<{ run_id: string; schedule_id: string; status: string; work_outcome: string | null }>(
+    `SELECT r.run_id, r.schedule_id, r.status, r.work_outcome FROM scheduled_task_runs r
+     WHERE r.task_id = ?1 AND r.network_id = ?2`, taskId, networkId);
+  if (runs.length !== 1 || !["queued", "delivered"].includes(runs[0].status) || runs[0].work_outcome !== null)
+    return { ok: false, error: "scheduled_work_outcome_run_unresolved" };
+  if (!db.get("SELECT schedule_id FROM scheduled_tasks WHERE schedule_id = ?1 AND network_id = ?2", runs[0].schedule_id, networkId))
+    return { ok: false, error: "scheduled_work_outcome_run_unresolved" };
+  return { ok: true, binding: { run_id: runs[0].run_id, schedule_id: runs[0].schedule_id,
+    task_id: taskId, network_id: networkId, node_id: nodeId } };
+}
+
+/** The task has just reached replied in this same transaction. An outcome
+ * write failure must roll back task, inbox and run together. No cadence write. */
+export function saveScheduledWorkOutcome(binding: Binding, outcome: ScheduledWorkOutcome): void {
+  const result = db.run(
+    `UPDATE scheduled_task_runs SET work_outcome = ?1, work_outcome_node_id = ?6
+     WHERE run_id = ?2 AND schedule_id = ?3 AND task_id = ?4 AND network_id = ?5
+       AND work_outcome IS NULL AND status IN ('queued', 'delivered')
+       AND EXISTS (SELECT 1 FROM tasks t WHERE t.task_id = ?4 AND t.network_id = ?5
+                   AND t.to_node_id = ?6 AND t.from_name = 'scheduler' AND t.status = 'replied')`,
+    [outcome, binding.run_id, binding.schedule_id, binding.task_id, binding.network_id, binding.node_id]);
+  if (result.changes !== 1) throw new Error("scheduled_work_outcome_atomic_write_failed");
+}

package/src/scoped-secrets.ts

@@ -4,6 +4,8 @@ import { db } from './db';
 import { getUserNetworkRole } from './auth';
 import { providerScanTargets } from './daemon-provider-snapshots';
 import { validScopedSecretKey } from './shared/scoped-secret-contract';
+import { observeSecretWrite, transportOf } from './env-transport-gate.js';
+import { refusesPlainTransport } from './env-transport-policy.js';
 type Human = { userId?: string | null; isNode: boolean; networkId: string | null };
 type Daemon = { ok: false; error: string } | { ok: true; networkId: string; daemonNodeId: string; daemonAlias: string };
 type Request = { request_id: string; network_id: string; daemon_node_id: string | null; node_id: string | null;
@@ -37,6 +39,13 @@ export function requestNodeSecrets(h: Human, node: string, action: Request['acti
   if (action !== 'list' && (!validScopedSecretKey(key) || !Number.isSafeInteger(revision) || revision! < 0
     || (action === 'put' && (typeof value !== 'string' || !value || Buffer.byteLength(value) > 8192 || value.includes('\0'))))) return denied('invalid_secret_input');
   expire();
+  // #1510 — transport gate (log-only by default). A `put` carries the secret, so
+  // that is the only action worth observing; delete/list leak nothing.
+  if (action === 'put') {
+    const transport = transportOf(h.networkId!, node);
+    if (refusesPlainTransport(transport)) return denied('secret_transport_plain');
+    observeSecretWrite(h.networkId!, node, `node_secret_${action}`);
+  }
   if ([...requests.values()].some(r => r.network_id === h.networkId && r.daemon_node_id === null && r.node_id === node && r.status === 'pending')) return denied('secret_store_busy');
   if (requests.size >= 1000) return denied('secret_queue_busy');
   const r: Request = { request_id: `nsk_${randomUUID()}`, network_id: h.networkId!, daemon_node_id: null,
@@ -77,6 +86,12 @@ export function requestScopedSecrets(h: Human, daemon: string, node: string | nu
   if (action !== 'list' && (!validScopedSecretKey(key)
     || !Number.isSafeInteger(revision) || revision! < 0 || (action === 'put' && (typeof value !== 'string' || !value || Buffer.byteLength(value) > 8192 || value.includes('\0'))))) return denied('invalid_secret_input');
   expire();
+  // #1510 — same observation on the daemon lane (the daemon applies the value).
+  if (action === 'put') {
+    const transport = transportOf(h.networkId!, daemon);
+    if (refusesPlainTransport(transport)) return denied('secret_transport_plain');
+    observeSecretWrite(h.networkId!, daemon, `secret_${action}`);
+  }
   if ([...requests.values()].some(r => r.network_id === h.networkId && r.daemon_node_id === daemon && r.status === 'pending')) return denied('secret_store_busy');
   if (requests.size >= 1000) return denied('secret_queue_busy');
   const r: Request = { request_id: `dsk_${randomUUID()}`, network_id: h.networkId!, daemon_node_id: daemon,

package/src/server.ts

@@ -11,7 +11,7 @@ import { statusAliasResolverRead } from "./status-alias-resolver.js";
 import { readNodeHealth } from "./node-health-store.js";
 import { wantsAllTools } from "./tool-audience.js";
 import { assertNodeHealthy, degradedLayers } from "./node-health-guard.js";
-import { auditDepartment, createDepartment, deleteDepartment, listDepartments, setMemberDepartment, updateDepartment } from "./departments.js";
+import { auditDepartment, createDepartment, deleteDepartment, listDepartments, setAgentDepartment, setMemberDepartment, updateDepartment } from "./departments.js";
 import { addManualMember, canManageGroup, createDepartmentGroup, getDepartmentGroup, groupById, groupTx, groupViewerCan, isGroupMember, listGroupMembers, listVisibleGroups, readGroup, removeManualMember, renameGroup, syncDepartmentGroups } from "./department-groups.js";
 import { DEPARTMENT_SCOPE_DENIED, departmentLeaders, departmentSubtree, headScope, listDepartmentProjectGrants, managedDepartmentIds, membersIn, replaceDepartmentProjectGrants } from "./department-heads.js";
 import { redactMessageRow } from "./redact-tokens.js";
@@ -86,6 +86,9 @@ import { listTaskLateReplies } from "./task-late-replies.js";
 import { assertScheduledTaskBackendSupported, handleScheduledTaskRequest, startScheduledTaskScheduler } from "./scheduled-tasks.js";
 import { startDueReminderTimer } from "./requirement-due-reminders.js";
 import { handleRequirementsRequest } from "./requirements.js";
+import { readHubProviders } from "./hub-provider-config.js";
+import { requestNodeSecrets, getScopedSecrets } from "./scoped-secrets.js";
+import { readEnvTransportLog } from "./env-transport-gate.js";
 import { labelRoute, mcpRouteLabel, recordRouteTiming, routeStats, setRouteCallerMasterToken, setRouteCallerTokenReader } from "./route-timing.js";
 import { handleExternalScheduleEditRequest } from "./external-schedule-edits.js";
 import { recordDeliveredStaleEvents } from "./task-lifecycle-watcher.js";
@@ -1970,12 +1973,13 @@ return Bun.serve({
     // 在这棵子树里也能写;越出子树 → 403 department_scope_denied(固定一个错误)。不是负责人的成员与以前逐字节相同。 ──
     const deptMatch = url.pathname.match(/^\/api\/networks\/([^/]+)\/departments(?:\/([^/]+))?$/);
     const memberDeptMatch = url.pathname.match(/^\/api\/networks\/([^/]+)\/members\/([^/]+)\/department$/);
+    const nodeDeptMatch = url.pathname.match(/^\/api\/networks\/([^/]+)\/nodes\/([^/]+)\/department$/);
     const deptSubMatch = url.pathname.match(/^\/api\/networks\/([^/]+)\/departments\/([^/]+)\/(project-grants|nodes|group)$/);
-    if (deptMatch || memberDeptMatch || deptSubMatch) {
+    if (deptMatch || memberDeptMatch || deptSubMatch || nodeDeptMatch) {
       const token = requestToken(req, { allowQueryToken: false });
       const resolved = token ? resolveToken(token) : null;
       if (!resolved) return withCors(req, Response.json({ ok: false, error: "auth required" }, { status: 401 }));
-      const netId = decodeURIComponent((deptMatch ?? memberDeptMatch ?? deptSubMatch)![1]);
+      const netId = decodeURIComponent((deptMatch ?? memberDeptMatch ?? deptSubMatch ?? nodeDeptMatch)![1]);
       if (resolved.networkId && resolved.networkId !== netId) return withCors(req, Response.json({ ok: false, error: "not a member of this network" }, { status: 403 }));
       const hubAdmin = isHubAdminCredential(resolved);
       const role = resolved.networkId ? null : getUserNetworkRole(resolved.user.user_id, netId);
@@ -2081,6 +2085,19 @@ return Bun.serve({
       // 组织架构变了,负责人们的「本部门」跟着变:断开他们(和被调动的人)的实时流,按新权限重连。
       const leadersBefore = departmentLeaders(netId);
       const kick = (extra: string[] = []) => { for (const uid of new Set([...leadersBefore, ...departmentLeaders(netId), ...extra])) closeUserStreamsInNetwork(netId, uid); };
+      // Agent(节点)显式归属部门:只有 owner / admin(以及 Hub 管理员)。
+      // 负责人对自己部门的 Agent 也可调动 —— 和「人」的调动同一条 scope 规则。
+      if (nodeDeptMatch) {
+        if (req.method !== "PUT") return withCors(req, Response.json({ ok: false, error: "method_not_allowed" }, { status: 405 }));
+        const targetNode = decodeURIComponent(nodeDeptMatch[2]);
+        if (!canManage) {
+          const current = db.get<{ department_id: string | null }>("SELECT department_id FROM nodes WHERE network_id = ?1 AND node_id = ?2", netId, targetNode);
+          if (current && (!inManaged(current.department_id) || (!inManaged(body.department_id) && (blank(body.department_id) || exists(body.department_id))))) return scopeDenied();
+        }
+        const r = setAgentDepartment(netId, targetNode, body.department_id);
+        if (r.ok) auditDepartment(resolved.user, "agent_department_set", netId, `${targetNode} → ${r.department_id ?? "(unassigned)"}${via === "leader" ? " via=leader" : ""}`);
+        return reply(r);
+      }
       if (memberDeptMatch) {
         if (req.method !== "PUT") return withCors(req, Response.json({ ok: false, error: "method_not_allowed" }, { status: 405 }));
         const targetUid = decodeURIComponent(memberDeptMatch[2]);
@@ -2717,6 +2734,148 @@ return Bun.serve({
       return withCors(req, Response.json({ ok: true, network_id: networkId, since: new Date(sinceMs).toISOString(), mode: nodePermissionsFlag(), total: nodes.reduce((n, e) => n + e.total, 0), nodes }));
     }
 
+    // ── #1473 (#909): read-only Hub catalogs for the desktop client ──
+    //
+    // Skills / network secrets / Providers have existed on this Hub only as
+    // MCP tools (list_skills, list_network_secrets, list_providers). With no
+    // HTTP surface, the client shipped a fixture page instead
+    // (agent-network-app/src/hub-scope-demo.ts: "Hub 这些写接口还没接通 ... 不发请求").
+    // These three endpoints expose the SAME rows to a USER token and never a
+    // secret value: names and timestamps only, plus the review flag, so the
+    // client can stop inventing data.
+    const hubCatalog = url.pathname === "/api/skills" ? "skills"
+      : url.pathname === "/api/secrets" ? "secrets"
+      : url.pathname === "/api/providers" ? "providers" : null;
+    if (hubCatalog && req.method === "GET") {
+      if (!restAuth) return withCors(req, Response.json({ ok: false, error: "auth required" }, { status: 401 }));
+      // A node token is not a person: it may not enumerate the network's
+      // catalogs (same rule as the node-permission report above).
+      if (restAuth.networkId) return userTokenRequired(req);
+      const networkId = singleNetworkId(restScope);
+      if (!networkId) return withCors(req, Response.json({ ok: false, error: "network_id_required" }, { status: 400 }));
+      const role = restAuth.userId ? getUserNetworkRole(restAuth.userId, networkId) : null;
+      if (!isAdmin && !role) {
+        return withCors(req, Response.json({ ok: false, error: "permission_denied", message: "network member only" }, { status: 403 }));
+      }
+      const reviewer = isAdmin || role === "owner" || role === "admin";
+      if (hubCatalog === "skills") {
+        // Pending submissions stay invisible to plain members even when they
+        // ask: `include_pending` is a reviewer switch, not a client wish.
+        const includePending = url.searchParams.get("include_pending") === "1" && reviewer;
+        const rawLimit = Number(url.searchParams.get("limit") ?? 100);
+        const limit = Number.isFinite(rawLimit) ? Math.min(Math.max(Math.trunc(rawLimit), 1), 200) : 100;
+        let sql = `SELECT skill_id, slug, name, description, version, status, source_type, source_alias,
+                          created_at, updated_at, reviewed_at, review_note
+                     FROM skillhub_skills WHERE network_id = ?1`;
+        if (!includePending) sql += ` AND status = 'published'`;
+        sql += ` ORDER BY updated_at DESC LIMIT ${limit}`;
+        return withCors(req, Response.json({ ok: true, network_id: networkId, reviewer, skills: db.all(sql, networkId) }));
+      }
+      if (hubCatalog === "secrets") {
+        // Keys and timestamps only. The ciphertext columns are not selected at
+        // all, so a future "just add the value for convenience" edit has to
+        // change this query on purpose instead of leaking by accident.
+        const rows = db.all<{ key: string; updated_at: number | string | null }>(
+          "SELECT key, updated_at FROM network_secrets WHERE network_id = ?1 ORDER BY key", networkId);
+        return withCors(req, Response.json({
+          ok: true, network_id: networkId,
+          keys: rows.map(r => ({ key: r.key, updated_at: r.updated_at ?? null })),
+        }));
+      }
+      const providers = readHubProviders({ userId: restAuth.userId ?? null, isNode: false, networkId });
+      if (!providers.ok) {
+        return withCors(req, Response.json(providers, { status: 403 }));
+      }
+      return withCors(req, Response.json({ ...providers, network_id: networkId }));
+    }
+
+    // ── #1510: the log-only view of the secret transport gate ──
+    //
+    // Answers "how many secret writes WOULD a plain-HTTP refusal have blocked,
+    // and on which node" before anyone turns the gate on. Same audience and
+    // shape as the node-permission report: network owner/admin, aggregated.
+    const envTransportLog = url.pathname.match(/^\/api\/networks\/([^/]+)\/env-transport-log$/);
+    if (envTransportLog && req.method === "GET") {
+      if (!restAuth) return withCors(req, Response.json({ ok: false, error: "auth required" }, { status: 401 }));
+      if (restAuth.networkId) return userTokenRequired(req);
+      const networkId = decodeURIComponent(envTransportLog[1]);
+      const role = restAuth.userId ? getUserNetworkRole(restAuth.userId, networkId) : null;
+      if (!isAdmin && role !== "owner" && role !== "admin") {
+        return withCors(req, Response.json({ ok: false, error: "permission_denied", message: "network owner/admin only" }, { status: 403 }));
+      }
+      const sinceRaw = url.searchParams.get("since");
+      const sinceMs = sinceRaw ? Date.parse(sinceRaw) : Date.now() - 7 * 86_400_000;
+      if (!Number.isFinite(sinceMs)) return withCors(req, Response.json({ ok: false, error: "invalid_since" }, { status: 400 }));
+      const rows = readEnvTransportLog(networkId, new Date(sinceMs).toISOString().slice(0, 13));
+      return withCors(req, Response.json({
+        ok: true, network_id: networkId, since: new Date(sinceMs).toISOString(),
+        total: rows.reduce((n, r) => n + r.hits, 0), rows,
+      }));
+    }
+
+    // ── #1491 E1: the node-secret write lane over REST ──
+    //
+    // The lane already exists end to end (tools.ts `node_secret_*` →
+    // scoped-secrets.ts → node doorbell → agent-node reconcileNodeSecrets), but
+    // it is MCP-only and request/ack shaped: a caller enqueues a request, the
+    // node applies it at its next start and acks with a snapshot. The client has
+    // no way to drive that, which is the only reason it still "cannot manage a
+    // node's env".
+    //
+    // Two endpoints, deliberately thin: enqueue, then poll. Authorization stays
+    // where it already is — requestNodeSecrets allows owner/admin only, so a
+    // plain member (or any node token) is refused by the lane itself.
+    const nodeSecretReq = url.pathname.match(/^\/api\/nodes\/([^/]+)\/secrets$/);
+    const nodeSecretGet = url.pathname.match(/^\/api\/nodes\/([^/]+)\/secrets\/([^/]+)$/);
+    if ((nodeSecretReq || nodeSecretGet) && !restAuth) {
+      return withCors(req, Response.json({ ok: false, error: "auth required" }, { status: 401 }));
+    }
+    if (nodeSecretReq && req.method === "POST") {
+      if (restAuth!.networkId) return userTokenRequired(req);
+      const networkId = singleNetworkId(restScope);
+      if (!networkId) return withCors(req, Response.json({ ok: false, error: "network_id_required" }, { status: 400 }));
+      const nodeId = decodeURIComponent(nodeSecretReq[1]);
+      if (!nodeId) return withCors(req, Response.json({ ok: false, error: "node_id_required" }, { status: 400 }));
+      let body: any;
+      try { body = await req.json(); } catch { return withCors(req, Response.json({ ok: false, error: "invalid JSON" }, { status: 400 })); }
+      const action = body?.action;
+      if (action !== "list" && action !== "put" && action !== "delete") {
+        return withCors(req, Response.json({ ok: false, error: "invalid_action", message: "action must be list | put | delete" }, { status: 400 }));
+      }
+      // A `put` without a revision is a client bug, not a server decision: the
+      // node rejects it anyway, and silently inventing 0 would overwrite a file
+      // the operator edited in the meantime.
+      if (action !== "list" && !Number.isSafeInteger(body?.revision)) {
+        return withCors(req, Response.json({ ok: false, error: "revision_required", message: "put/delete need the revision from the last list" }, { status: 400 }));
+      }
+      const result = requestNodeSecrets(
+        { userId: restAuth!.userId ?? null, isNode: false, networkId },
+        nodeId, action, body?.key, body?.value, body?.revision,
+      );
+      if (!result.ok) {
+        const status = result.error === "secret_admin_required" ? 403
+          : result.error === "node_secrets_upgrade_required" ? 409
+          : result.error === "secret_store_busy" || result.error === "secret_queue_busy" ? 409
+          : 400;
+        return withCors(req, Response.json(result, { status }));
+      }
+      return withCors(req, Response.json(result));
+    }
+    if (nodeSecretGet && req.method === "GET") {
+      if (restAuth!.networkId) return userTokenRequired(req);
+      const networkId = singleNetworkId(restScope);
+      if (!networkId) return withCors(req, Response.json({ ok: false, error: "network_id_required" }, { status: 400 }));
+      const result = getScopedSecrets(
+        { userId: restAuth!.userId ?? null, isNode: false, networkId },
+        decodeURIComponent(nodeSecretGet[2]),
+      );
+      if (!result.ok) {
+        const status = result.error === "secret_admin_required" ? 403 : 404;
+        return withCors(req, Response.json(result, { status }));
+      }
+      return withCors(req, Response.json(result));
+    }
+
     if (url.pathname === "/api/dm" || url.pathname === "/api/dm/threads") {
       if (!restAuth || !requestToken(req).startsWith("utok_")) {
         return withCors(req, Response.json({ ok: false, error: "user_token_required" }, { status: 403 }));