agent-loft 0.2.30 → 0.2.31

package/src/core/task-schedule.ts

@@ -0,0 +1,250 @@
+// 定时任务的「什么时候跑」：几种常用的结构化写法 + 自定义 cron，一律按服务端所在时区解释。
+//
+// 存结构化的而不是一律存 cron：界面上的「每天 / 工作日 / 每周…」能原样回填，描述也好写；
+// 除「一次」以外都先换成 cron 再算下次时间，只有一条计算路径。
+
+export type TaskSchedule =
+  | { kind: "once"; at: number }
+  | { kind: "daily"; time: string }
+  | { kind: "weekdays"; time: string }
+  /** days：0 = 周日 … 6 = 周六 */
+  | { kind: "weekly"; days: number[]; time: string }
+  | { kind: "monthly"; day: number; time: string }
+  /** 每 every 小时一次，在第 minute 分（从 0 点起算：every=6 就是 0、6、12、18 点） */
+  | { kind: "hourly"; every: number; minute: number }
+  | { kind: "cron"; expr: string };
+
+/** 两次运行至少隔这么久：太密了会把额度跑光 */
+export const MIN_GAP_MS = 15 * 60_000;
+/** 「一次」最多排到多久以后 */
+export const ONCE_MAX_MS = 366 * 86400_000;
+
+export function serverTimeZone(): string {
+  return Intl.DateTimeFormat().resolvedOptions().timeZone || "本地时间";
+}
+
+// ---------- cron ----------
+
+type CronSpec = { minute: Set<number>; hour: Set<number>; dom: Set<number>; month: Set<number>; dow: Set<number>; domAny: boolean; dowAny: boolean };
+
+const RANGES: [number, number][] = [
+  [0, 59],
+  [0, 23],
+  [1, 31],
+  [1, 12],
+  [0, 7],
+];
+
+function parseField(raw: string, [min, max]: [number, number], name: string): Set<number> {
+  const out = new Set<number>();
+  for (const part of raw.split(",")) {
+    const m = /^(\*|(\d+)(?:-(\d+))?)(?:\/(\d+))?$/.exec(part.trim());
+    if (!m) throw new Error(`cron 的${name}字段写得不对：${raw}`);
+    const step = m[4] ? Number(m[4]) : 1;
+    let lo = min;
+    let hi = max;
+    if (m[1] !== "*") {
+      lo = Number(m[2]);
+      // 「5/15」= 从 5 起每 15
+      hi = m[3] !== undefined ? Number(m[3]) : m[4] ? max : lo;
+    }
+    if (step < 1 || lo < min || hi > max || lo > hi) throw new Error(`cron 的${name}字段超出范围：${raw}`);
+    for (let v = lo; v <= hi; v += step) out.add(v);
+  }
+  return out;
+}
+
+export function parseCron(expr: string): CronSpec {
+  const fields = expr.trim().split(/\s+/);
+  if (fields.length !== 5) throw new Error("cron 要写 5 段：分 时 日 月 周，比如「0 2 * * *」是每天 2 点");
+  const names = ["分钟", "小时", "日期", "月份", "星期"];
+  const [minute, hour, dom, month, dowRaw] = fields.map((f, i) => parseField(f, RANGES[i]!, names[i]!));
+  const dow = new Set([...dowRaw!].map((d) => d % 7));
+  return { minute: minute!, hour: hour!, dom: dom!, month: month!, dow, domAny: fields[2] === "*", dowAny: fields[4] === "*" };
+}
+
+function dayMatches(spec: CronSpec, d: Date): boolean {
+  const dom = spec.dom.has(d.getDate());
+  const dow = spec.dow.has(d.getDay());
+  // 和标准 cron 一样：日期、星期都限定了的时候，满足其一就算
+  if (spec.domAny && spec.dowAny) return true;
+  if (spec.domAny) return dow;
+  if (spec.dowAny) return dom;
+  return dom || dow;
+}
+
+/** from 之后（不含）最近一次匹配的时刻；一年内都没有就是 undefined */
+export function cronNext(spec: CronSpec, from: number): number | undefined {
+  const d = new Date(from);
+  d.setSeconds(0, 0);
+  d.setMinutes(d.getMinutes() + 1);
+  const limit = from + 400 * 86400_000;
+  while (d.getTime() <= limit) {
+    if (!spec.month.has(d.getMonth() + 1)) {
+      d.setMonth(d.getMonth() + 1, 1);
+      d.setHours(0, 0, 0, 0);
+      continue;
+    }
+    if (!dayMatches(spec, d)) {
+      d.setDate(d.getDate() + 1);
+      d.setHours(0, 0, 0, 0);
+      continue;
+    }
+    if (!spec.hour.has(d.getHours())) {
+      d.setHours(d.getHours() + 1, 0, 0, 0);
+      continue;
+    }
+    if (!spec.minute.has(d.getMinutes())) {
+      d.setMinutes(d.getMinutes() + 1, 0, 0);
+      continue;
+    }
+    return d.getTime();
+  }
+  return undefined;
+}
+
+// ---------- 结构化写法 ----------
+
+function parseTime(time: string): [number, number] {
+  const m = /^(\d{1,2}):(\d{2})$/.exec(String(time ?? "").trim());
+  if (!m || Number(m[1]) > 23 || Number(m[2]) > 59) throw new Error(`时间要写成 HH:MM，比如 02:00（收到的是「${time}」）`);
+  return [Number(m[1]), Number(m[2])];
+}
+
+export function toCron(s: Exclude<TaskSchedule, { kind: "once" }>): string {
+  switch (s.kind) {
+    case "daily": {
+      const [h, m] = parseTime(s.time);
+      return `${m} ${h} * * *`;
+    }
+    case "weekdays": {
+      const [h, m] = parseTime(s.time);
+      return `${m} ${h} * * 1-5`;
+    }
+    case "weekly": {
+      const [h, m] = parseTime(s.time);
+      return `${m} ${h} * * ${[...new Set(s.days)].sort((a, b) => a - b).join(",")}`;
+    }
+    case "monthly": {
+      const [h, m] = parseTime(s.time);
+      return `${m} ${h} ${s.day} * *`;
+    }
+    case "hourly":
+      return `${s.minute} ${s.every === 1 ? "*" : `*/${s.every}`} * * *`;
+    case "cron":
+      return s.expr.trim();
+  }
+}
+
+const int = (v: unknown, lo: number, hi: number, what: string): number => {
+  const n = Number(v);
+  if (!Number.isInteger(n) || n < lo || n > hi) throw new Error(`${what}要是 ${lo}-${hi} 之间的整数`);
+  return n;
+};
+
+/** 校验并规整（来自网页表单或 agent 的工具调用，都不可信）。不合规直接抛出给人看的错误 */
+export function normalizeSchedule(raw: unknown, now = Date.now()): TaskSchedule {
+  const r = (raw ?? {}) as Record<string, unknown>;
+  let s: Exclude<TaskSchedule, { kind: "once" }>;
+  switch (r.kind) {
+    case "once": {
+      const at = Number(r.at);
+      if (!Number.isFinite(at)) throw new Error("「一次」要给运行时间");
+      if (at < now - 60_000) throw new Error("运行时间要在现在之后");
+      if (at > now + ONCE_MAX_MS) throw new Error("最多只能排到一年以后");
+      return { kind: "once", at: Math.floor(at / 60_000) * 60_000 };
+    }
+    case "daily":
+    case "weekdays":
+      s = { kind: r.kind, time: String(r.time ?? "") };
+      break;
+    case "weekly": {
+      const days = Array.isArray(r.days) ? r.days.map((d) => int(d, 0, 7, "星期") % 7) : [];
+      if (days.length === 0) throw new Error("「每周」至少选一天");
+      s = { kind: "weekly", days: [...new Set(days)].sort((a, b) => a - b), time: String(r.time ?? "") };
+      break;
+    }
+    case "monthly":
+      s = { kind: "monthly", day: int(r.day, 1, 31, "日期"), time: String(r.time ?? "") };
+      break;
+    case "hourly":
+      s = { kind: "hourly", every: int(r.every, 1, 23, "间隔小时数"), minute: int(r.minute ?? 0, 0, 59, "分钟") };
+      break;
+    case "cron":
+      s = { kind: "cron", expr: String(r.expr ?? "").trim().replace(/\s+/g, " ") };
+      break;
+    default:
+      throw new Error("不认识的频率");
+  }
+  if ("time" in s) {
+    const [h, m] = parseTime(s.time);
+    s.time = `${String(h).padStart(2, "0")}:${String(m).padStart(2, "0")}`;
+  }
+  const spec = parseCron(toCron(s));
+  // 抽查接下来的几次，相邻两次不能太近
+  let prev = cronNext(spec, now);
+  if (prev === undefined) throw new Error("按这个写法一年内都不会运行");
+  for (let i = 0; i < 8; i++) {
+    const next = cronNext(spec, prev);
+    if (next === undefined) break;
+    if (next - prev < MIN_GAP_MS) throw new Error(`太频繁了：两次运行至少要隔 ${MIN_GAP_MS / 60_000} 分钟`);
+    prev = next;
+  }
+  return s;
+}
+
+/** from 之后下一次该跑的时刻；「一次」跑过了就没有 */
+export function nextRun(s: TaskSchedule, from: number): number | undefined {
+  if (s.kind === "once") return s.at > from ? s.at : undefined;
+  try {
+    return cronNext(parseCron(toCron(s)), from);
+  } catch {
+    return undefined;
+  }
+}
+
+// ---------- 描述 ----------
+
+const WEEK = ["日", "一", "二", "三", "四", "五", "六"];
+
+export function formatClock(ms: number): string {
+  const d = new Date(ms);
+  return `${String(d.getHours()).padStart(2, "0")}:${String(d.getMinutes()).padStart(2, "0")}`;
+}
+
+export function formatDateTime(ms: number): string {
+  const d = new Date(ms);
+  const p = (n: number) => String(n).padStart(2, "0");
+  return `${d.getFullYear()}-${p(d.getMonth() + 1)}-${p(d.getDate())} ${formatClock(ms)}`;
+}
+
+/** 给人看的一句话：「每天 02:00」「工作日 09:30」「每周一、三 08:00」 */
+export function describeSchedule(s: TaskSchedule): string {
+  switch (s.kind) {
+    case "once":
+      return `一次：${formatDateTime(s.at)}`;
+    case "daily":
+      return `每天 ${s.time}`;
+    case "weekdays":
+      return `工作日 ${s.time}`;
+    case "weekly":
+      return s.days.length === 7 ? `每天 ${s.time}` : `每周${s.days.map((d) => WEEK[d]).join("、")} ${s.time}`;
+    case "monthly":
+      return `每月 ${s.day} 日 ${s.time}`;
+    case "hourly":
+      return s.every === 1 ? `每小时第 ${s.minute} 分` : `每 ${s.every} 小时（第 ${s.minute} 分）`;
+    case "cron":
+      return `cron：${s.expr}`;
+  }
+}
+
+/**
+ * 「2026-10-23 15:00」这类本地时间（agent 给的），也认带时区的 ISO 写法。解析不了返回 NaN。
+ * 不带时区的一律按服务端时区解释 —— Date.parse 对「YYYY-MM-DDTHH:MM」本来就是按本地时间。
+ */
+export function parseLocalDateTime(text: string): number {
+  const t = String(text ?? "").trim();
+  const m = /^(\d{4})-(\d{1,2})-(\d{1,2})[ T](\d{1,2}):(\d{2})(?::\d{2})?$/.exec(t);
+  if (m) return new Date(Number(m[1]), Number(m[2]) - 1, Number(m[3]), Number(m[4]), Number(m[5])).getTime();
+  return Date.parse(t);
+}

package/src/core/tasks-bridge.ts

@@ -0,0 +1,252 @@
+// 主进程这头的定时任务工具：mcp/tasks-server.ts 经 unix socket 把 agent 的调用转过来，这里核对身份、
+// 弹授权卡、真正增删改。
+//
+// 几条规矩：
+//   - 身份只认拉起时签过名的（用户 + 对话），而且这条对话现在还得是这个人的；只碰得到他自己的任务；
+//   - 新建、修改、删除（暂停除外）一律弹授权卡让用户确认：定时任务等于「以后在没人看着的时候执行一段指令」，
+//     agent 读到的网页里要是藏着「帮我建个每小时跑的任务」，不能就这么建了；卡上没有「总是允许」；
+//   - 定时任务自己跑的那一轮里不能建、改、删任务，免得一个任务生出一串任务。
+import fs from "node:fs";
+import net from "node:net";
+import path from "node:path";
+import { config } from "./config.js";
+import { hub } from "./hub.js";
+import { interactions } from "./interactions.js";
+import { memoryOwnerOf } from "./personal.js";
+import { getConversation } from "./store.js";
+import { forgetTask } from "./task-runner.js";
+import { describeSchedule, formatDateTime, nextRun, normalizeSchedule, parseLocalDateTime, serverTimeZone, type TaskSchedule } from "./task-schedule.js";
+import { TASK_TOOL_TIMEOUT_SEC, tasksSocketPath, verifyTaskCaller } from "./tasks-mcp.js";
+import { createTask, deleteTask, getTask, listTasks, TASKS_PER_USER, updateTask, type Task, type TaskInput } from "./tasks.js";
+import { getUser } from "./users.js";
+
+type Reply = { text: string; isError?: boolean };
+const fail = (text: string): Reply => ({ text, isError: true });
+
+const STATUS: Record<string, string> = {
+  running: "运行中",
+  notified: "已提醒",
+  silent: "无需提醒",
+  error: "出错",
+  skipped: "跳过",
+  interrupted: "中断",
+};
+
+/** agent 给的频率：「一次」的时间是字符串或者「多少分钟后」，换成时间戳再校验 */
+function scheduleArg(raw: unknown, now: number): TaskSchedule {
+  const r = { ...((raw ?? {}) as Record<string, unknown>) };
+  if (r.kind === "once") {
+    r.at = r.in_minutes !== undefined ? now + Number(r.in_minutes) * 60_000 : parseLocalDateTime(String(r.at ?? ""));
+  }
+  return normalizeSchedule(r, now);
+}
+
+function whereText(task: Task, convKey: string): string {
+  if (task.target.kind === "dedicated") return "专用对话";
+  if (task.target.key === convKey) return "这条对话";
+  return `对话「${getConversation(task.target.key)?.title ?? "未命名"}」`;
+}
+
+function describeTask(task: Task, convKey: string): string {
+  const last = task.runs[0];
+  return [
+    `- [${task.id}]「${task.title}」${describeSchedule(task.schedule)}`,
+    task.enabled && task.nextRunAt ? `下次 ${formatDateTime(task.nextRunAt)}` : "已暂停",
+    task.notify === "smart" ? "有需要才提醒" : "每次都提醒",
+    `结果发到${whereText(task, convKey)}`,
+    ...(last ? [`最近一次 ${formatDateTime(last.at)} ${STATUS[last.status] ?? last.status}${last.preview ? `：${last.preview}` : last.note ? `（${last.note}）` : ""}`] : []),
+  ].join(" · ") + `\n  提示词：${task.prompt.replace(/\s+/g, " ").slice(0, 200)}`;
+}
+
+/** 弹授权卡，等用户点。返回 true 表示同意 */
+async function confirm(convKey: string, title: string, detail: string): Promise<boolean> {
+  const timeout = Math.min(config().approvalTimeoutMs, (TASK_TOOL_TIMEOUT_SEC - 60) * 1000);
+  const outcome = await interactions.create(convKey, { kind: "approval", title, detail }, timeout, hub.liveSessionId(convKey));
+  return outcome.settlement === "allow-once" || outcome.settlement === "allow-always" || outcome.settlement === "allow-session";
+}
+
+function card(fields: { schedule?: TaskSchedule; notify?: string; where?: string; mode?: string; prompt?: string; enabled?: boolean }, now: number): string {
+  const lines: string[] = [];
+  if (fields.schedule) {
+    const next = nextRun(fields.schedule, now);
+    lines.push(`**频率**：${describeSchedule(fields.schedule)}（${serverTimeZone()}）`);
+    if (next) lines.push(`**下次运行**：${formatDateTime(next)}`);
+  }
+  if (fields.notify) lines.push(`**提醒**：${fields.notify === "always" ? "每次都提醒" : "有需要才提醒（由 agent 判断）"}`);
+  if (fields.where) lines.push(`**结果发到**：${fields.where}`);
+  if (fields.mode) lines.push(`**模式**：${fields.mode === "work" ? "工作模式（能执行命令、读写文件）" : "聊天模式（只能联网搜索）"}`);
+  if (fields.enabled !== undefined) lines.push(`**状态**：${fields.enabled ? "恢复运行" : "暂停"}`);
+  if (fields.prompt) lines.push("", "**到点要做的事**：", "", ...fields.prompt.split("\n").map((l) => `> ${l}`));
+  return lines.join("\n");
+}
+
+async function call(userId: string, convKey: string, tool: string, args: Record<string, unknown>): Promise<Reply> {
+  const user = getUser(userId);
+  if (!user || user.disabled) return fail("账号已停用。");
+  const conv = getConversation(convKey);
+  if (!conv || memoryOwnerOf(conv) !== user.id) return fail("这条对话不属于当前用户，不能管理定时任务。");
+  const now = Date.now();
+  const inTaskTurn = !!hub.currentTaskTurn(convKey);
+
+  if (tool === "list_tasks") {
+    const tasks = listTasks(user.id);
+    const head = `现在是 ${formatDateTime(now)}（${serverTimeZone()}）。`;
+    if (tasks.length === 0) return { text: `${head}用户还没有定时任务。` };
+    return { text: `${head}用户有 ${tasks.length} 个定时任务（最多 ${TASKS_PER_USER} 个）：\n\n${tasks.map((t) => describeTask(t, convKey)).join("\n")}` };
+  }
+
+  if (inTaskTurn) return fail("这一轮是定时任务自己在运行，不能在这里新建、修改或删除定时任务。需要的话告诉用户，让他来操作。");
+
+  if (tool === "create_task") {
+    if (listTasks(user.id).length >= TASKS_PER_USER) return fail(`用户已经有 ${TASKS_PER_USER} 个定时任务了，到上限了，请他先删掉几个。`);
+    let schedule: TaskSchedule;
+    try {
+      schedule = scheduleArg(args.schedule, now);
+    } catch (err) {
+      return fail(err instanceof Error ? err.message : String(err));
+    }
+    const prompt = String(args.prompt ?? "").trim();
+    if (!prompt) return fail("prompt 不能为空。");
+    const dedicated = args.reply_to === "dedicated";
+    const mode = dedicated ? (args.mode === "work" ? "work" : "chat") : (conv.mode ?? "work");
+    const input: TaskInput = {
+      title: args.title,
+      prompt,
+      schedule,
+      notify: args.notify === "always" ? "always" : "smart",
+      target: dedicated ? { kind: "dedicated" } : { kind: "conv", key: convKey },
+      agent: conv.agent,
+      cwd: conv.cwd,
+      mode,
+    };
+    const title = String(args.title ?? "").trim() || prompt.replace(/\s+/g, " ").slice(0, 60);
+    const ok = await confirm(
+      convKey,
+      `新建定时任务「${title}」`,
+      card({ schedule, notify: String(input.notify), where: dedicated ? "单独开一条对话" : "这条对话", ...(dedicated ? { mode } : {}), prompt }, now),
+    );
+    if (!ok) return fail("用户没有同意，任务没有建。");
+    try {
+      const task = createTask(user.id, input, "agent");
+      return {
+        text: `已建好 [${task.id}]「${task.title}」：${describeSchedule(task.schedule)}，${task.nextRunAt ? `下次 ${formatDateTime(task.nextRunAt)}` : "没有下次"}。用户可以在网页侧栏「定时任务」里查看和修改。`,
+      };
+    } catch (err) {
+      return fail(err instanceof Error ? err.message : String(err));
+    }
+  }
+
+  const id = String(args.id ?? "").trim();
+  const task = getTask(user.id, id);
+  if (!task) return fail(`没有 id 为 ${id} 的定时任务。先用 list_tasks 看看。`);
+
+  if (tool === "delete_task") {
+    // 删了就找不回来：也要用户点一下（只是暂停的话不用问，见下面）
+    const ok = await confirm(
+      convKey,
+      `删除定时任务「${task.title}」`,
+      `${card({ schedule: task.schedule, prompt: task.prompt }, now)}\n\n删除后不会再运行，之前运行的结果还留在对话里。`,
+    );
+    if (!ok) return fail("用户没有同意，任务没有删。");
+    // 等用户点卡片的时候，任务可能已经在网页上删掉了
+    if (!deleteTask(user.id, task.id)) return fail("这个任务已经不在了。");
+    forgetTask(task);
+    return { text: `已删掉「${task.title}」。` };
+  }
+
+  if (tool === "update_task") {
+    const patch: TaskInput = {};
+    try {
+      if (args.schedule !== undefined) patch.schedule = scheduleArg(args.schedule, now);
+    } catch (err) {
+      return fail(err instanceof Error ? err.message : String(err));
+    }
+    if (args.title !== undefined) patch.title = args.title;
+    if (args.prompt !== undefined) patch.prompt = args.prompt;
+    if (args.notify !== undefined) patch.notify = args.notify;
+    if (args.enabled !== undefined) patch.enabled = args.enabled === true;
+    if (Object.keys(patch).length === 0) return fail("没有要改的字段。");
+    // 只是暂停：不会让它多跑什么，不用问
+    const pauseOnly = Object.keys(patch).length === 1 && patch.enabled === false;
+    if (!pauseOnly) {
+      const ok = await confirm(
+        convKey,
+        `修改定时任务「${task.title}」`,
+        card(
+          {
+            ...(patch.schedule ? { schedule: patch.schedule as TaskSchedule } : {}),
+            ...(patch.notify !== undefined ? { notify: String(patch.notify) } : {}),
+            ...(patch.enabled !== undefined ? { enabled: patch.enabled === true } : {}),
+            ...(patch.prompt !== undefined ? { prompt: String(patch.prompt) } : {}),
+          },
+          now,
+        ) + (patch.title !== undefined ? `\n\n**新名称**：${String(patch.title)}` : ""),
+      );
+      if (!ok) return fail("用户没有同意，任务没有改。");
+    }
+    try {
+      const updated = updateTask(user.id, task.id, patch);
+      return {
+        text: `已改好「${updated.title}」：${describeSchedule(updated.schedule)}，${updated.enabled && updated.nextRunAt ? `下次 ${formatDateTime(updated.nextRunAt)}` : "已暂停"}。`,
+      };
+    } catch (err) {
+      return fail(err instanceof Error ? err.message : String(err));
+    }
+  }
+  return fail(`没有工具 ${tool}`);
+}
+
+let server: net.Server | null = null;
+
+export function startTasksBridge(): void {
+  if (server) return;
+  fs.mkdirSync(path.dirname(tasksSocketPath), { recursive: true, mode: 0o700 });
+  // 上次没收拾干净留下的 socket 文件：不删的话 listen 会报 EADDRINUSE
+  fs.rmSync(tasksSocketPath, { force: true });
+  server = net.createServer((sock) => {
+    let buf = "";
+    sock.setEncoding("utf8");
+    sock.on("error", () => {});
+    sock.on("data", (chunk: string) => {
+      buf += chunk;
+      const n = buf.indexOf("\n");
+      if (n < 0) {
+        if (buf.length > 64 * 1024) sock.destroy();
+        return;
+      }
+      const line = buf.slice(0, n);
+      buf = "";
+      void (async () => {
+        let reply: Reply;
+        try {
+          const req = JSON.parse(line) as { user?: string; conv?: string; sig?: string; tool?: string; args?: Record<string, unknown> };
+          const userId = String(req.user ?? "");
+          const convKey = String(req.conv ?? "");
+          if (!verifyTaskCaller(userId, convKey, String(req.sig ?? ""))) {
+            reply = fail("身份校验没通过（agent-loft 可能重启过），开个新会话再试。");
+          } else {
+            reply = await call(userId, convKey, String(req.tool ?? ""), req.args && typeof req.args === "object" ? req.args : {});
+          }
+        } catch (err) {
+          console.error("[定时任务] 处理工具调用出错:", err);
+          reply = fail(err instanceof Error ? err.message : String(err));
+        }
+        if (!sock.destroyed) sock.end(`${JSON.stringify(reply)}\n`);
+      })();
+    });
+  });
+  server.on("error", (err) => console.error(`[定时任务] 工具通道出错（agent 暂时用不了定时任务工具）：${err.message}`));
+  server.listen(tasksSocketPath, () => {
+    try {
+      fs.chmodSync(tasksSocketPath, 0o600);
+    } catch {
+      // 改不了权限也不影响：调用都要带签名
+    }
+  });
+}
+
+export function stopTasksBridge(): void {
+  server?.close();
+  server = null;
+  fs.rmSync(tasksSocketPath, { force: true });
+}

package/src/core/tasks-mcp.ts

@@ -0,0 +1,55 @@
+// 定时任务工具的 MCP 服务（mcp/tasks-server.ts）怎么拉起：Claude 和 Codex 的配置共用这一份。
+//
+// 和记忆工具不同，它自己不碰数据文件：每次工具调用都经本机的 unix socket 转给主进程（tasks-bridge.ts）——
+// 调度器在主进程里（新建的任务要马上排进去），创建 / 修改前要弹授权卡，也只有主进程弹得出来。
+//
+// 是谁、在哪条对话里，由拉起时的环境变量定死，并带着主进程签的名：工具参数里没有用户，
+// 子进程也伪造不了别人的身份（密钥只在主进程内存里，每次启动换一个）。
+import crypto from "node:crypto";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { home } from "../home.js";
+import { tsxLoader, type StdioSpawn } from "./memory-mcp.js";
+
+export const TASKS_MCP_NAME = "agent_loft_tasks";
+
+const serverPath = fileURLToPath(new URL("../mcp/tasks-server.ts", import.meta.url));
+
+/** unix socket 路径有长度限制（macOS 104 字节）：家目录太深就放到临时目录 */
+export const tasksSocketPath = (() => {
+  const inHome = path.join(home, "run", "tasks.sock");
+  if (inHome.length < 100) return inHome;
+  const tag = crypto.createHash("sha256").update(home).digest("hex").slice(0, 12);
+  return path.join(os.tmpdir(), `agent-loft-${tag}.sock`);
+})();
+
+const secret = crypto.randomBytes(32);
+
+export function signTaskCaller(userId: string, convKey: string): string {
+  return crypto.createHmac("sha256", secret).update(`${userId}\n${convKey}`).digest("hex");
+}
+
+export function verifyTaskCaller(userId: string, convKey: string, sig: string): boolean {
+  const want = Buffer.from(signTaskCaller(userId, convKey), "hex");
+  const got = Buffer.from(String(sig), "hex");
+  return got.length === want.length && crypto.timingSafeEqual(got, want);
+}
+
+export function tasksMcpSpawn(userId: string, convKey: string, via: string): StdioSpawn {
+  return {
+    command: process.execPath,
+    args: ["--import", tsxLoader, serverPath],
+    env: {
+      AGENT_LOFT_TASKS_SOCKET: tasksSocketPath,
+      AGENT_LOFT_TASKS_USER: userId,
+      AGENT_LOFT_TASKS_CONV: convKey,
+      AGENT_LOFT_TASKS_SIG: signTaskCaller(userId, convKey),
+      AGENT_LOFT_TASKS_VIA: via,
+      AGENT_LOFT_TZ: Intl.DateTimeFormat().resolvedOptions().timeZone || "",
+    },
+  };
+}
+
+/** 工具调用最多等多久（含等用户点授权卡）。Codex 默认 60 秒就超时，要显式放宽 */
+export const TASK_TOOL_TIMEOUT_SEC = 20 * 60;