@sleep2agi/commhub-server 0.9.0-preview.113 → 0.9.0-preview.115

package/src/task-late-replies.ts

@@ -0,0 +1,54 @@
+import type { DbAdapter } from "./db-adapter";
+
+type StoredLateReply = {
+  late_reply_id: string;
+  task_id: string;
+  from_node_id: string;
+  thread_id: string;
+  turn_id: string;
+  status: "replied" | "failed" | "cancelled";
+  result: string;
+  meta_json: string | null;
+  created_at: string;
+};
+
+function parsedMeta(raw: string | null): Record<string, unknown> | null {
+  if (!raw) return null;
+  try {
+    const value = JSON.parse(raw);
+    return value && typeof value === "object" && !Array.isArray(value)
+      ? value as Record<string, unknown>
+      : null;
+  } catch {
+    return null;
+  }
+}
+
+/** Stable detail projection. Storage routing ids stay private. */
+export function listTaskLateReplies(database: DbAdapter, taskId: string, networkId: string | null) {
+  const params: unknown[] = [taskId];
+  let sql = `SELECT late_reply_id,task_id,from_node_id,thread_id,turn_id,status,result,meta_json,created_at
+    FROM task_late_replies WHERE task_id=?1`;
+  if (networkId) {
+    params.push(networkId);
+    sql += " AND network_id=?2";
+  } else {
+    sql += " AND network_id IS NULL";
+  }
+  sql += " ORDER BY created_at,late_reply_id";
+  return database.all<StoredLateReply>(sql, ...params).map((row) => {
+    const meta = parsedMeta(row.meta_json);
+    return {
+      late_reply_id: row.late_reply_id,
+      task_id: row.task_id,
+      from_node_id: row.from_node_id,
+      thread_id: row.thread_id,
+      turn_id: row.turn_id,
+      status: row.status,
+      result: row.result,
+      created_at: row.created_at,
+      late: true as const,
+      ...(meta ? { meta } : {}),
+    };
+  });
+}

package/src/task-late-reply-http.test.ts

@@ -0,0 +1,152 @@
+import { afterAll, beforeAll, expect, test } from "bun:test";
+import { mkdtempSync } from "node:fs";
+
+process.env.COMMHUB_DB ||= `${mkdtempSync("/tmp/late710-")}/hub.db`;
+
+let db: any;
+let hub: ReturnType<typeof Bun.serve>;
+let base = "";
+let owner: any;
+let outsider: any;
+let workerToken = "";
+let siblingToken = "";
+const workerId = "n_late710_worker";
+const siblingId = "n_late710_sibling";
+const taskId = "task_late710_terminal";
+const threadId = "thread_late710_exact";
+const turnId = "turn_late710_exact";
+
+async function mcp(token: string, name: string, args: Record<string, unknown>) {
+  const response = await fetch(`${base}/mcp`, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${token}`,
+      "Content-Type": "application/json",
+      Accept: "application/json, text/event-stream",
+      "MCP-Protocol-Version": "2025-03-26",
+    },
+    body: JSON.stringify({ jsonrpc: "2.0", id: 1, method: "tools/call", params: { name, arguments: args } }),
+  });
+  expect(response.status).toBe(200);
+  const raw = await response.text();
+  const events = raw.split("\n").filter((line) => line.startsWith("data:"));
+  const envelope = JSON.parse(events.length ? events.at(-1)!.slice(5) : raw);
+  expect(envelope.error).toBeUndefined();
+  return JSON.parse(envelope.result.content[0].text);
+}
+
+async function get(token: string, path: string) {
+  const response = await fetch(`${base}${path}`, { headers: { Authorization: `Bearer ${token}` } });
+  return { status: response.status, body: await response.json() as any };
+}
+
+beforeAll(async () => {
+  ({ db } = await import("./db.js"));
+  const { register } = await import("./auth.js");
+  const { generateNetworkToken, hashToken } = await import("./db.js");
+  owner = register("late710_owner", "Fixture-Strong1!");
+  outsider = register("late710_outside", "Fixture-Strong1!");
+  expect(owner.ok && outsider.ok).toBe(true);
+
+  const addNode = (nodeId: string, alias: string) => {
+    db.run(`INSERT INTO nodes(node_id,node_name,alias,network_id,owner_user_id,lifecycle_state)
+      VALUES(?1,?2,?2,?3,?4,'active')`, [nodeId, alias, owner.network_id, owner.user.user_id]);
+    db.run(`INSERT INTO sessions(resume_id,alias,node_id,network_id,status,last_seen_at)
+      VALUES(?1,?2,?1,?3,'idle',datetime('now'))`, [nodeId, alias, owner.network_id]);
+    const raw = generateNetworkToken();
+    db.run(`INSERT INTO api_tokens(token_id,user_id,network_id,scope,name,token_hash,bound_node_id,node_identity_epoch)
+      VALUES(?1,?2,?3,'network',?4,?5,?1,2)`, [nodeId, owner.user.user_id, owner.network_id, `node:${alias}`, hashToken(raw)]);
+    return raw;
+  };
+  workerToken = addNode(workerId, "late710-worker");
+  siblingToken = addNode(siblingId, "late710-sibling");
+  db.run(`INSERT INTO tasks
+    (task_id,from_name,to_name,to_node_id,status,content,result,network_id,thread_id,turn_id,completed_at)
+    VALUES(?1,?2,'late710-worker',?3,'failed','original task','watchdog interrupted',?4,?5,?6,datetime('now'))`,
+    [taskId, owner.user.username, workerId, owner.network_id, threadId, turnId]);
+
+  const { bootServer } = await import("./server.js");
+  hub = bootServer({ port: 0, hostname: "127.0.0.1" });
+  base = `http://127.0.0.1:${hub.port}`;
+}, 60_000);
+
+afterAll(() => hub?.stop(true));
+
+test("exact executor and exact turn append one late receipt without rewriting terminal task", async () => {
+  const before = db.get("SELECT status,result,completed_at FROM tasks WHERE task_id=?1", taskId);
+  const accepted = await mcp(workerToken, "send_reply", {
+    in_reply_to: taskId,
+    text: "recovered final result",
+    status: "replied",
+    thread_id: threadId,
+    turn_id: turnId,
+  });
+  expect(accepted).toMatchObject({ ok: true, late: true, duplicate: false });
+  expect(db.get("SELECT status,result,completed_at FROM tasks WHERE task_id=?1", taskId)).toEqual(before);
+  expect(db.get("SELECT COUNT(*) AS n FROM task_events WHERE task_id=?1", taskId).n).toBe(0);
+
+  const detail = await get(owner.token, `/api/tasks/${taskId}`);
+  expect(detail.status).toBe(200);
+  expect(detail.body.task.late_replies).toEqual([expect.objectContaining({
+    late: true, task_id: taskId, from_node_id: workerId,
+    thread_id: threadId, turn_id: turnId, status: "replied", result: "recovered final result",
+  })]);
+  const legacyDetail = await get(owner.token, `/api/tasks?task_id=${taskId}&limit=1&network_id=${owner.network_id}`);
+  expect(legacyDetail.body.tasks[0].late_replies).toEqual(detail.body.task.late_replies);
+  const mcpDetail = await mcp(owner.token, "get_task", { task_id: taskId });
+  expect(mcpDetail.task.late_replies).toEqual(detail.body.task.late_replies);
+
+  const messages = await get(owner.token, `/api/messages?alias=${encodeURIComponent(owner.user.username)}&since=2000-01-01%2000:00:00`);
+  expect(messages.body.messages).toContainEqual(expect.objectContaining({ id: accepted.message_id, late: true, content: "recovered final result" }));
+  const inbox = await mcp(owner.token, "get_inbox", { alias: owner.user.username, limit: 100 });
+  expect(inbox.messages).toContainEqual(expect.objectContaining({ id: accepted.message_id, late: true, content: "recovered final result" }));
+});
+
+test("exact retry is idempotent and a changed payload conflicts", async () => {
+  const retry = await mcp(workerToken, "send_reply", {
+    in_reply_to: taskId, text: "recovered final result", status: "replied", thread_id: threadId, turn_id: turnId,
+  });
+  expect(retry).toMatchObject({ ok: true, late: true, duplicate: true });
+  expect(db.get("SELECT COUNT(*) AS n FROM task_late_replies WHERE task_id=?1", taskId).n).toBe(1);
+  expect(db.get("SELECT COUNT(*) AS n FROM inbox WHERE in_reply_to=?1 AND content='recovered final result'", taskId).n).toBe(1);
+  expect(await mcp(workerToken, "send_reply", {
+    in_reply_to: taskId, text: "different result", status: "replied", thread_id: threadId, turn_id: turnId,
+  })).toMatchObject({ ok: false, error: "late_reply_conflict" });
+});
+
+test("wrong executor, sibling turn, cross-network reader and legacy shape cannot append", async () => {
+  const count = () => db.get("SELECT COUNT(*) AS n FROM task_late_replies").n;
+  const before = count();
+  expect(await mcp(siblingToken, "send_reply", {
+    in_reply_to: taskId, text: "impostor", thread_id: threadId, turn_id: turnId,
+  })).toMatchObject({ ok: false, error: "late_reply_task_not_owned" });
+  expect(await mcp(workerToken, "send_reply", {
+    in_reply_to: taskId, text: "wrong turn", thread_id: threadId, turn_id: "turn_late710_sibling",
+  })).toMatchObject({ ok: false, error: "late_reply_context_mismatch" });
+  expect(await mcp(workerToken, "send_reply", {
+    in_reply_to: taskId, text: "legacy terminal reply",
+  })).toMatchObject({ ok: false, error: "reply_task_terminal" });
+  expect(await mcp(owner.token, "send_reply", {
+    in_reply_to: taskId, text: "human cannot forge runtime evidence", thread_id: threadId, turn_id: turnId,
+  })).toMatchObject({ ok: false, error: "late_reply_node_token_required" });
+  // Length bound is enforced in the handler (kept out of tools/list for #476).
+  for (const bad of ["", "x".repeat(201)]) {
+    expect(await mcp(workerToken, "send_reply", {
+      in_reply_to: taskId, text: "bad identity", thread_id: bad, turn_id: turnId,
+    })).toMatchObject({ ok: false, error: "late_reply_context_invalid" });
+  }
+  expect(count()).toBe(before);
+  expect((await get(outsider.token, `/api/tasks/${taskId}`)).status).toBe(404);
+  expect((await mcp(outsider.token, "get_task", { task_id: taskId })).ok).toBe(false);
+});
+
+test("nonterminal legacy reply retains its established behavior", async () => {
+  const openId = "task_late710_open";
+  db.run(`INSERT INTO tasks(task_id,from_name,to_name,to_node_id,status,content,network_id)
+    VALUES(?1,?2,'late710-worker',?3,'running','legacy open',?4)`, [openId, owner.user.username, workerId, owner.network_id]);
+  const result = await mcp(workerToken, "send_reply", { in_reply_to: openId, text: "ordinary final" });
+  expect(result).toMatchObject({ ok: true });
+  expect(result.late).toBeUndefined();
+  expect(db.get("SELECT status,result FROM tasks WHERE task_id=?1", openId)).toEqual({ status: "replied", result: "ordinary final" });
+  expect(db.get("SELECT COUNT(*) AS n FROM task_late_replies WHERE task_id=?1", openId).n).toBe(0);
+});

package/src/tool-audience-http.test.ts

@@ -184,7 +184,14 @@ describe("bytes per role (#476 ceilings stay meaningful per role)", () => {
   // 量出来(#478 合入时):全部 74 个工具 71,559 B;节点 52 个 57,632 B(−19%);人 56 个 54,780 B(−23%)。留 ~1.5 KB 余量。
   // Board #625 adds 2 human tools + 2 hidden daemon protocol tools. Measured:
   // all 78 / 73,969 B; user 58 / 56,615 B; node remains 52 / 58,320 B.
-  const CEILINGS = { node: 59_000, user: 57_500, all: 75_000 } as const;
+  // Board #733 adds 7 node-only schedule_* tools (user list unchanged). Measured before → after on the same run:
+  // node 52 / 58,836 B → 59 / 61,607 B (+2,771 B, ~396 B per tool of which ~180 B is SDK per-tool overhead —
+  // $schema + execution — after trimming schemas to bare field names; values are validated server-side);
+  // all 78 / 74,485 B → 85 / 77,256 B; user 58 / 56,834 B → 58 / 56,834 B. main had 164 B node headroom left,
+  // so any new node tool needs this; ceilings keep the same ~400–750 B margin.
+  // Review follow-up: descriptions / schemas cut further → node 59 / 61,100 B, all 85 / 76,749 B (−507 B each),
+  // leaving ≥ 700 B node margin even with #2488 (+116 B) merged.
+  const CEILINGS = { node: 62_000, user: 57_500, all: 78_000 } as const;
   test("node / user / all", async () => {
     const node = await listTools(T.node_normal);
     const user = await listTools(T.owner);

package/src/tool-audience.ts

@@ -27,6 +27,9 @@ export const TOOL_AUDIENCE: Readonly<Record<string, ToolAudience>> = {
   get_adopt_request: "protocol", ack_adopt_request: "protocol",
   // ── 节点:用户令牌一律 network_token_required ──
   report_status: "node",
+  // #733 定时任务:节点工具(用户令牌一律 network_token_required;人走 REST /api/scheduled-tasks)
+  schedule_list: "node", schedule_get: "node", schedule_create: "node", schedule_update: "node",
+  schedule_cancel: "node", schedule_run_now: "node", schedule_runs: "node",
   // ── 协议:用户令牌一律 network_token_required / node_token_required / caller_not_a_daemon ──
   mark_tasks_runtime_submitted: "protocol", mark_tasks_consumed: "protocol",
   get_config_update: "protocol", ack_config_update: "protocol",

package/src/tools.ts

@@ -20,6 +20,7 @@ import { getUserNetworkRole, createNetworkTokenForNode } from "./auth.js";
 import { addAgentNetworkScope, addAgentTimelineScope, addNetworkScope, canRestWriteNetwork, canRestWriteNetworkAsHuman, getUserNetworkIds, resolveRestNetworkScope, singleNetworkId, type RestNetworkScope } from "./network-scope.js";
 import { canMessageAgent, restrictedNetworkIds, RESTRICTED_MEMBER_TOOLS, type AgentRef } from "./agent-access.js";
 import { listedToolFilter, scopeToolsList, type ToolCaller } from "./tool-audience.js";
+import { agentCancelSchedule, agentCreateSchedule, agentGetSchedule, agentListSchedules, agentRunScheduleNow, agentScheduleRuns, agentUpdateSchedule } from "./schedule-agent.js";
 import { broadcastVerdict, dispatchVerdict, humanOnlyVerdict, NODE_TOOL_CLASS, nodeDecide, nodeIdentity, nodePermissionDeniedBody, writeVerdict, type NodeIdentity, type Verdict } from "./node-permissions.js";
 import { restrictedMemberAttachmentsDenied } from "./restricted-files.js";
 import { errorBody } from "./requirements-errors.js";
@@ -82,6 +83,7 @@ import { stampTaskAuthOrigin, type TaskAuthOrigin } from "./task-auth-origin.js"
 import { dispatchQueueInfo, queueDepthByNode, queueDepthKey } from "./task-queue-ahead.js";
 import { parseHubTimestamp } from "./hub-timestamp";
 import { noteTerminalResultRead, purgeLogsResultNow, sweepNodeRequestContent } from "./node-request-retention.js";
+import { listTaskLateReplies } from "./task-late-replies.js";
 
 function ts(): string {
   return new Date().toTimeString().slice(0, 8);
@@ -102,6 +104,15 @@ function normalizeMetaJson(meta: unknown): string | null {
   try { return JSON.stringify(stripHostLocalPathsForCrossHostSafe(meta)); } catch { return null; }
 }
 
+function lateReplyContextMatches(
+  storedThreadId: string | null,
+  storedTurnId: string | null,
+  threadId: string,
+  turnId: string,
+): boolean {
+  return storedThreadId === threadId && storedTurnId === turnId;
+}
+
 /**
  * 定时任务的回复收件人。scheduler 派的任务 from_name='scheduler',回复按 from_name 落进
  * inbox(session_name='scheduler')—— 没有任何人读那一行,于是建排程的人在 app 里看得到回复
@@ -109,7 +120,7 @@ function normalizeMetaJson(meta: unknown): string | null {
  * 排程是「建它的人」的委托(见 scheduled-tasks.ts canMessageAgent),回复送到他的用户名下。
  *
  * 退回 null(= 照旧送 'scheduler')的情形:任务不是 scheduler 派的 / meta 没有排程 id /
- * 排程没有 created_by(外部或旧排程)/ 用户已不存在 / 用户名与本网络某个节点 alias 撞名
+ * 排程没有 created_by(外部或旧排程)/ 排程是 Agent 建的(#733 created_by_node_id,不往主人的未读里灌)/ 用户已不存在 / 用户名与本网络某个节点 alias 撞名
  * (那一行会变成那个节点的待办,不是用户的未读 —— 与 server.ts userInboxAliasCollides 同一条规则)。
  * 只改投递地址;任务归属、reply_target_mismatch 等校验仍按原始发送方 'scheduler' 判。
  */
@@ -124,7 +135,7 @@ function scheduledReplyRecipient(taskId: string, networkId: string | null | unde
   if (!scheduleId) return null;
   const owner = db.get<{ username: string | null }>(
     `SELECT u.username AS username FROM scheduled_tasks s JOIN users u ON u.user_id = s.created_by
-     WHERE s.schedule_id = ?1 AND s.network_id = ?2`,
+     WHERE s.schedule_id = ?1 AND s.network_id = ?2 AND s.created_by_node_id IS NULL`,
     scheduleId, task.network_id,
   );
   const username = owner?.username?.trim();
@@ -248,7 +259,7 @@ function guardNodePermissionTools(server: McpServer, tokenId: string, networkId:
   };
   const wrap = (name: string, handler: (...callArgs: any[]) => any) => async (...callArgs: any[]) => {
     const cls = NODE_TOOL_CLASS[name];
-    if (cls && cls !== "always" && cls !== "read" && cls !== "requirements") {
+    if (cls && cls !== "always" && cls !== "read" && cls !== "requirements" && cls !== "schedule") {
       const id = nodeIdentity(tokenId, networkId);
       const args = callArgs[0] && typeof callArgs[0] === "object" ? callArgs[0] as Record<string, unknown> : {};
       const verdict = id ? verdictFor(id, name, args) : null;
@@ -1404,16 +1415,18 @@ export function registerTools(server: McpServer, clientIP?: string, enforceNetwo
       console.log(`[${ts()}] ${alias} → get_inbox: ${rows0?.cnt ?? 0} pending messages`);
       const rowsParams: any[] = [alias];
       let rowsSql = `SELECT id, type, priority, content, context, from_session, created_at, network_id, meta_json,
+         CASE WHEN EXISTS(SELECT 1 FROM task_late_replies lr WHERE lr.inbox_id=inbox.id) THEN 1 ELSE 0 END AS late,
          CASE WHEN type = 'task' THEN COALESCE(task_id, id) ELSE task_id END AS task_id
          FROM inbox WHERE session_name = ?1 AND acked = 0`;
       rowsSql = addReadScope(rowsSql, rowsParams, readScope);
       rowsSql += ` ORDER BY CASE priority WHEN 'high' THEN 0 WHEN 'normal' THEN 1 ELSE 2 END, created_at
          LIMIT ?${rowsParams.length + 1}`;
       rowsParams.push(limit);
-      const rows = db.all(rowsSql, ...rowsParams).map((row: any) => ({
-        ...row,
-        meta: parseMetaJson(row.meta_json),
-      }));
+      const rows = db.all(rowsSql, ...rowsParams).map((row: any) => {
+        const { late, ...rest } = row;
+        const isLate = late === 1 || late === true;
+        return { ...rest, ...(isLate ? { late: true } : {}), meta: parseMetaJson(row.meta_json) };
+      });
 
       return {
         content: [{ type: "text" as const, text: JSON.stringify({ ok: true, messages: rows }) }],
@@ -2132,15 +2145,26 @@ export function registerTools(server: McpServer, clientIP?: string, enforceNetwo
       // both `attachments` (top-level) and `meta.attachments` are supplied,
       // top-level wins (same rule as REST /api/task L2101).
       meta: z.any().optional().describe("Optional structured reply metadata, e.g. { attachments: [...] }."),
+      // Exact late-receipt identity. Keep the tools/list schema terse (#476
+      // byte ceiling): the 1..200 length bound is enforced in handleReply,
+      // not advertised; the full contract lives in the task API docs.
+      thread_id: z.string().optional(),
+      turn_id: z.string().optional(),
     };
   const handleReply = async (args: any, peerCapabilityRequired: boolean) => {
-      const { alias, text, in_reply_to, status: replyStatus = "replied", from_session: _fromIn, network_id: netId, attachments, meta } = args;
+      const { alias, text, in_reply_to, status: replyStatus = "replied", from_session: _fromIn, network_id: netId, attachments, meta, thread_id: threadId, turn_id: turnId } = args;
       const fromMismatch = fromIdentityMismatchReply(_fromIn); if (fromMismatch) return fromMismatch; const from_session = defaultFrom(_fromIn);
       const effectiveNetId = getNetworkId(netId);
       if (!canWrite(effectiveNetId)) return writeDeniedReply(effectiveNetId);
       if (peerCapabilityRequired && !in_reply_to) {
         return { content: [{ type: "text" as const, text: JSON.stringify({ ok: false, error: "peer_reply_task_required" }) }] };
       }
+      if ([threadId, turnId].some((v) => v !== undefined && (typeof v !== "string" || v.length < 1 || v.length > 200))) {
+        return { content: [{ type: "text" as const, text: JSON.stringify({ ok: false, error: "late_reply_context_invalid", message: "thread_id and turn_id must be 1-200 characters" }) }] };
+      }
+      if ((threadId && !turnId) || (!threadId && turnId)) {
+        return { content: [{ type: "text" as const, text: JSON.stringify({ ok: false, error: "late_reply_context_incomplete", message: "thread_id and turn_id must be supplied together" }) }] };
+      }
 
       // #507 — validate attachments BEFORE any DB write. Rejects malformed
       // input (bad file_id, >20 items, size > cap, non-object item, wrong
@@ -2203,6 +2227,97 @@ export function registerTools(server: McpServer, clientIP?: string, enforceNetwo
         const lc = assertNodeActive(replyDeliveryAlias, effectiveNetId ?? null);
         if (!lc.ok) return { content: [{ type: "text" as const, text: JSON.stringify(lc) }] };
       }
+
+      // #710 — A recovered runtime turn may finish after its task became
+      // terminal. Preserve that result as an append-only receipt: never
+      // rewrite the task row and never run the parent-task reply chain.
+      if (in_reply_to) {
+        type LateTask = { status: string; from_name: string; to_node_id: string | null; thread_id: string | null; turn_id: string | null };
+        const lateParams: any[] = [in_reply_to];
+        let lateSql = "SELECT status,from_name,to_node_id,thread_id,turn_id FROM tasks WHERE task_id=?1";
+        lateSql = addScope(lateSql, lateParams, effectiveNetId);
+        const lateCandidate = db.get<LateTask>(lateSql, ...lateParams) ?? null;
+        if (lateCandidate && !["created", "delivered", "acked", "running"].includes(lateCandidate.status)) {
+          // Old runtimes do not send turn identity and retain the old result.
+          if (!threadId || !turnId) {
+            return { content: [{ type: "text" as const, text: JSON.stringify({
+              ok: false, error: "reply_task_terminal",
+              message: `cannot apply reply: task is already terminal (${lateCandidate.status})`,
+              in_reply_to, task_status: lateCandidate.status, reply_queued: false,
+            }) }] };
+          }
+          if (!callerTokenIsNetwork || !callerTokenId || !enforceNetworkId) {
+            return { content: [{ type: "text" as const, text: JSON.stringify({ ok: false, error: "late_reply_node_token_required", reply_queued: false }) }] };
+          }
+          const token = db.get<{ bound_node_id: string | null }>(
+            "SELECT bound_node_id FROM api_tokens WHERE token_id=?1 AND network_id=?2",
+            callerTokenId, enforceNetworkId,
+          );
+          if (!token?.bound_node_id || !lateCandidate.to_node_id || token.bound_node_id !== lateCandidate.to_node_id) {
+            return { content: [{ type: "text" as const, text: JSON.stringify({ ok: false, error: "late_reply_task_not_owned", reply_queued: false }) }] };
+          }
+          if (!lateReplyContextMatches(lateCandidate.thread_id, lateCandidate.turn_id, threadId, turnId)) {
+            return { content: [{ type: "text" as const, text: JSON.stringify({ ok: false, error: "late_reply_context_mismatch", reply_queued: false }) }] };
+          }
+          const canonicalOrigin = resolveCanonicalAlias(enforceNetworkId, lateCandidate.from_name).alias;
+          if (replyTargetAlias !== canonicalOrigin) {
+            return { content: [{ type: "text" as const, text: JSON.stringify({ ok: false, error: "reply_target_mismatch", reply_queued: false }) }] };
+          }
+
+          const lateOutcome = db.transaction(() => {
+            const currentParams: any[] = [in_reply_to];
+            let currentSql = "SELECT status,to_node_id,thread_id,turn_id FROM tasks WHERE task_id=?1";
+            currentSql = addScope(currentSql, currentParams, effectiveNetId);
+            const current = db.get<{ status: string; to_node_id: string | null; thread_id: string | null; turn_id: string | null }>(currentSql, ...currentParams);
+            if (!current || ["created", "delivered", "acked", "running"].includes(current.status)) {
+              return { ok: false as const, error: "late_reply_task_not_terminal" as const };
+            }
+            if (current.to_node_id !== token.bound_node_id || !lateReplyContextMatches(current.thread_id, current.turn_id, threadId, turnId)) {
+              return { ok: false as const, error: "late_reply_context_mismatch" as const };
+            }
+            const existing = db.get<{ late_reply_id: string; inbox_id: string; from_node_id: string; status: string; result: string }>(
+              "SELECT late_reply_id,inbox_id,from_node_id,status,result FROM task_late_replies WHERE task_id=?1 AND thread_id=?2 AND turn_id=?3",
+              in_reply_to, threadId, turnId,
+            );
+            if (existing) {
+              if (existing.from_node_id !== token.bound_node_id || existing.status !== replyStatus || existing.result !== text) {
+                return { ok: false as const, error: "late_reply_conflict" as const };
+              }
+              return { ok: true as const, duplicate: true as const, lateReplyId: existing.late_reply_id, inboxId: existing.inbox_id };
+            }
+            const lateReplyId = uuidv4();
+            const lateMeta = normalizeMetaJson({
+              ...(mergedMeta && typeof mergedMeta === "object" && !Array.isArray(mergedMeta) ? mergedMeta : {}),
+              late: true, late_reply_id: lateReplyId, thread_id: threadId, turn_id: turnId,
+            });
+            db.run(
+              `INSERT INTO inbox (id,session_name,node_id,type,priority,content,from_session,in_reply_to,requires_response,network_id,meta_json)
+               VALUES (?1,?2,?3,'reply','normal',?4,?5,?6,'none',?7,?8)`,
+              [id, replyDeliveryAlias, replyTargetNodeId, text, from_session, in_reply_to,
+              effectiveNetId ?? null, lateMeta],
+            );
+            db.run(
+              `INSERT INTO task_late_replies
+               (late_reply_id,inbox_id,task_id,network_id,from_node_id,thread_id,turn_id,status,result,meta_json)
+               VALUES (?1,?2,?3,?4,?5,?6,?7,?8,?9,?10)`,
+              [lateReplyId, id, in_reply_to, effectiveNetId ?? null, token.bound_node_id,
+              threadId, turnId, replyStatus, text, lateMeta],
+            );
+            return { ok: true as const, duplicate: false as const, lateReplyId, inboxId: id };
+          });
+          if (!lateOutcome.ok) {
+            return { content: [{ type: "text" as const, text: JSON.stringify({ ok: false, error: lateOutcome.error, reply_queued: false }) }] };
+          }
+          if (!lateOutcome.duplicate) {
+            pushEvent(replyDeliveryAlias, { type: "new_reply", inbox_count: pendingInboxCount(replyDeliveryAlias, effectiveNetId), from: from_session, message_id: lateOutcome.inboxId, in_reply_to, status: replyStatus, late: true }, effectiveNetId);
+            pushNetworkObserverEvent(effectiveNetId, { type: "new_reply", task_id: in_reply_to, message_id: lateOutcome.inboxId, from: from_session, to: replyDeliveryAlias, status: replyStatus, late: true });
+          }
+          return { content: [{ type: "text" as const, text: JSON.stringify({
+            ok: true, message_id: lateOutcome.inboxId, late_reply_id: lateOutcome.lateReplyId,
+            late: true, duplicate: lateOutcome.duplicate,
+          }) }] };
+        }
+      }
       const replyOutcome = db.transaction(() => {
         type ReplyTask = {
           status: string;
@@ -2581,6 +2696,9 @@ export function registerTools(server: McpServer, clientIP?: string, enforceNetwo
       let sql = "SELECT * FROM tasks WHERE task_id = ?1";
       sql = addAgentTimelineScope(sql, params, readScope, { from: "from_name", to: "to_name", fromNodeId: "from_node_id", toNodeId: "to_node_id" });
       const task = db.get<any>(sql, ...params);
+      if (task) {
+        task.late_replies = listTaskLateReplies(db, task_id, typeof task.network_id === "string" ? task.network_id : null);
+      }
       return {
         content: [{
           type: "text" as const,
@@ -6248,6 +6366,41 @@ export function registerTools(server: McpServer, clientIP?: string, enforceNetwo
     async ({ id, text, network_id }) => requirementsCall("POST", `/api/requirements/${encodeURIComponent(id)}/comments`, network_id, { text }),
   );
 
+  // Board #733 — Agents manage Hub scheduled tasks. Node tokens only (REST stays people-only); the
+  // permission model lives in schedule-agent.ts.
+  const scheduleCall = (fn: (id: NodeIdentity, canWriteNet: boolean) => Record<string, unknown>) => {
+    let body: Record<string, unknown>;
+    if (!callerTokenIsNetwork || !enforceNetworkId) body = { ok: false, error: "network_token_required" };
+    else {
+      const id = nodeIdentity(callerTokenId, enforceNetworkId);
+      body = id ? fn(id, canWrite(enforceNetworkId)) : { ok: false, error: "node_identity_unbound" };
+    }
+    return { content: [{ type: "text" as const, text: JSON.stringify(body) }] };
+  };
+  // Kept terse on purpose (#476 per-role tools/list ceilings): every value is validated server-side by the
+  // same parseScheduleSpec / validateScheduleCreate as REST, so the schema only names the fields.
+  const schedId = z.string();
+  const schedFields = {
+    name: z.string(), task: z.string(), target_node_id: z.string().optional(),
+    schedule: z.any().describe("once{run_at}|interval{every_seconds>=60}|daily{time}|weekly{time,weekdays}"),
+    timezone: z.string().optional(), priority: z.string().optional(),
+  };
+  server.tool("schedule_list", "Hub schedules for or by you.", { status: z.string().optional() },
+    async ({ status }) => scheduleCall(id => agentListSchedules(id, status)));
+  server.tool("schedule_get", "One schedule.", { schedule_id: schedId },
+    async ({ schedule_id }) => scheduleCall(id => agentGetSchedule(id, schedule_id)));
+  server.tool("schedule_create", "Schedule a task to target_node_id (default you).", schedFields,
+    async (args) => scheduleCall((id, w) => agentCreateSchedule(id, w, args as Record<string, unknown>)));
+  server.tool("schedule_update", "Edit your schedule; status=paused|active.",
+    { ...schedFields, schedule_id: schedId, base_revision: z.number().int().min(0).optional().describe("Reject if current revision differs."), name: z.string().optional(), task: z.string().optional(), schedule: z.any().optional(), status: z.string().optional() },
+    async ({ schedule_id, ...rest }) => scheduleCall((id, w) => agentUpdateSchedule(id, w, schedule_id, rest as Record<string, unknown>)));
+  server.tool("schedule_cancel", "Cancel your schedule.", { schedule_id: schedId },
+    async ({ schedule_id }) => scheduleCall((id, w) => agentCancelSchedule(id, w, schedule_id)));
+  server.tool("schedule_run_now", "Run your schedule now.", { schedule_id: schedId },
+    async ({ schedule_id }) => scheduleCall((id, w) => agentRunScheduleNow(id, w, schedule_id)));
+  server.tool("schedule_runs", "A schedule's recent runs.", { schedule_id: schedId },
+    async ({ schedule_id }) => scheduleCall(id => agentScheduleRuns(id, schedule_id)));
+
   // #478:tools/list 只列这个调用者真能用的工具(tool-audience.ts)。只滤列表,tools/call 不变。
   const caller: ToolCaller = callerTokenIsNetwork
     ? { kind: "node", tokenId: callerTokenId ?? null, networkId: enforceNetworkId ?? null, includeProtocol: listing.includeProtocol === true }