@workclaw/openclaw-workclaw 1.0.341 → 1.0.343

package/dist/index-DLeHpawu.js

@@ -0,0 +1,1351 @@
+import { h as getRunIdByToolCallId, e as getToolContext, a as getWorkclawRuntime, l as logger } from "./runtime-api-DU-e2Pen.js";
+import { c as resolveWorkclawAccountWithCache, g as normalizeBaseUrl, h as getWorkclawAccessToken, d as doFetchJson } from "./workclaw-client-CMjcFjJx.js";
+function parseRelativeTime(timeStr) {
+  const s = timeStr.trim().toLowerCase();
+  if (/^\d+$/.test(s)) {
+    return Number.parseInt(s, 10) * 6e4;
+  }
+  let totalMs = 0;
+  let matched = false;
+  const regex = /(\d+(?:\.\d+)?)\s*([dhms])/g;
+  let match;
+  while ((match = regex.exec(s)) !== null) {
+    matched = true;
+    const value = Number.parseFloat(match[1]);
+    const unit = match[2];
+    switch (unit) {
+      case "d":
+        totalMs += value * 864e5;
+        break;
+      case "h":
+        totalMs += value * 36e5;
+        break;
+      case "m":
+        totalMs += value * 6e4;
+        break;
+      case "s":
+        totalMs += value * 1e3;
+        break;
+    }
+  }
+  return matched ? Math.round(totalMs) : null;
+}
+function isCronExpression(timeStr) {
+  const parts = timeStr.trim().split(/\s+/);
+  return parts.length >= 3 && parts.length <= 6;
+}
+function validateCronExpression(timeStr) {
+  const parts = timeStr.trim().split(/\s+/);
+  if (parts.length < 3 || parts.length > 6) {
+    return { valid: false, error: `无效的 cron 表达式：字段数量不正确（期望 3-6 个字段，实际 ${parts.length} 个）` };
+  }
+  const patterns = [
+    /^(\*|[0-5]?\d(-[0-5]?\d)?(\/[0-5]?\d)?|L(-[0-5]?\d)?|W?)$/,
+    /^(\*|[0-5]?\d(-[0-5]?\d)?(\/[0-5]?\d)?|L(-[0-5]?\d)?|W?)$/,
+    /^(\*|[01]?\d|2[0-3](-[01]?\d|2[0-3])?(\/\d|[01]?\d|2[0-3])?|L(-[01]?\d|2[0-3])?|W)?$/,
+    /^(\*|1[0-2]|0?[1-9](-[1-9]|0?[1-9])?(\/[1-9]|0?[1-9])?|L(-1[0-2]|0?[1-9])?|W)?$/,
+    /^([*LW]|[0-6](-[0-6])?(\/[0-6])?|L-[0-6])?$/,
+    /^(\*|L|(\*\/)?\d{1,2})?$/
+  ];
+  const fieldNames = ["秒", "分钟", "小时", "日期", "月份", "星期"];
+  for (let i = 0; i < parts.length && i < patterns.length; i++) {
+    const part = parts[i].trim();
+    const offset = parts.length - patterns.length;
+    if (i < offset)
+      continue;
+    if (!patterns[i].test(part)) {
+      return { valid: false, error: `无效的 cron 表达式：${fieldNames[i]}字段 "${part}" 格式不正确` };
+    }
+  }
+  return { valid: true };
+}
+function validateTimeFormat(timeStr) {
+  if (!timeStr || typeof timeStr !== "string" || timeStr.trim() === "") {
+    return { valid: false, error: "时间参数不能为空" };
+  }
+  const trimmed = timeStr.trim();
+  if (trimmed.startsWith("+") || /^\d+$/.test(trimmed) || /^\d+[dhms]/.test(trimmed)) {
+    const relativeMs = parseRelativeTime(trimmed);
+    if (relativeMs === null) {
+      return { valid: false, error: `无法解析相对时间 "${trimmed}"，支持的格式：5m、1h、1h30m、2d、30s 等` };
+    }
+    if (relativeMs < 3e4) {
+      return { valid: false, error: "提醒时间不能少于 30 秒" };
+    }
+    return { valid: true };
+  }
+  if (isCronExpression(trimmed)) {
+    return validateCronExpression(trimmed);
+  }
+  return { valid: false, error: `无法解析时间 "${trimmed}"，请使用相对时间（如 5m、1h）或 cron 表达式（如 0 8 * * *）` };
+}
+function relativeToCron(timeStr) {
+  const delayMs = parseRelativeTime(timeStr);
+  if (delayMs === null) {
+    return timeStr;
+  }
+  const futureTime = new Date(Date.now() + delayMs);
+  const seconds = futureTime.getSeconds();
+  const minutes = futureTime.getMinutes();
+  const hours = futureTime.getHours();
+  const dayOfMonth = futureTime.getDate();
+  const month = futureTime.getMonth() + 1;
+  return `${seconds} ${minutes} ${hours} ${dayOfMonth} ${month} *`;
+}
+function resolveCronToolExecutionContext(toolCallId) {
+  let toolCtx;
+  try {
+    const runId = getRunIdByToolCallId(toolCallId);
+    toolCtx = runId ? getToolContext(runId) : void 0;
+  } catch (e) {
+  }
+  const config = getWorkclawRuntime().config.loadConfig();
+  let agentAccountId = "default";
+  if (config?.bindings && Array.isArray(config.bindings) && config.bindings.length > 0) {
+    const matchedBinding = config.bindings.find((b) => b.agentId === toolCtx?.agentId);
+    if (matchedBinding?.match?.accountId) {
+      agentAccountId = matchedBinding.match.accountId;
+    } else if (config.bindings[0]?.match?.accountId) {
+      agentAccountId = config.bindings[0].match.accountId;
+    }
+  }
+  return {
+    agentAccountId,
+    agentId: toolCtx?.agentId,
+    From: toolCtx?.target,
+    taskId: toolCtx?.taskId,
+    config
+  };
+}
+const AddParamsSchema = {
+  type: "object",
+  properties: {
+    time: {
+      type: "string",
+      description: "⏰ 时间（核心！），支持相对时间和 cron 表达式，工具自动转换"
+    },
+    name: {
+      type: "string",
+      description: "任务名称"
+    },
+    message: {
+      type: "string",
+      description: "提醒内容"
+    },
+    taskId: {
+      type: "string",
+      description: "⚠️ 【关键！】taskId 必须从 WebSocket 消息的 taskId 字段获取， 如果data.taskId没有值，就不传taskId，禁止自行生成！taskId 格式为纯数字字符串（如 12919375446074181），不是时间戳！"
+    }
+  },
+  required: ["time", "name", "message"]
+};
+function json$a(data) {
+  return {
+    content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
+    details: data
+  };
+}
+function registerOpenclawWorkclawCronAddParamsTool(api) {
+  api.registerTool({
+    name: "openclaw-workclaw-cron-add-params",
+    label: "智小途生成创建提醒参数",
+    description: `【智小途提醒创建第一步】生成创建提醒的 cronParams 参数。
+
+📋 工作流程（必须按顺序执行）：
+1. 调用此工具获取 cronParams 参数
+2. 使用返回的 cronParams 调用 OpenClaw 的 cron 工具
+3. 从 cron 工具返回值中提取 jobId（返回格式：{"success": true, "jobId": "xxx"}）
+4. 必须调用 openclaw-workclaw-cron-add-sync 同步到后端
+
+🚫 禁止事项：
+- 禁止跳过本工具后直接手写 CLI 命令
+- 禁止自行拼接 cron 参数
+- 禁止在没有调用 openclaw-workclaw-cron-add-sync 的情况下宣布创建成功
+
+⏰ 时间格式（核心！）：
+- time 参数支持相对时间（如 "5m"、"1h"、"2d"）和 cron 表达式
+- 工具会自动将所有时间统一转换为 cron 表达式
+- 严禁使用 --at 参数或其他绝对时间格式
+- 下一步调用 OpenClaw cron 时必须使用本工具返回的 cron 表达式
+
+🔒 强制规则：
+- schedule.kind 必须是 "cron"
+- 必须沿用本工具返回的 cronParams 结果
+
+⚠️ taskId 来源（必须严格遵守！）：
+- taskId 必须从 WebSocket 消息的 data.taskId 字段获取， 如果data.taskId没有值，就不传taskId
+- taskId 格式为纯数字字符串（如 12919375446074181）
+- ❌ 禁止自行生成 taskId！禁止使用时间戳作为 taskId！
+- ❌ 禁止使用 messageId 或其他字段作为 taskId！
+
+⚠️ 必须从 cron 工具返回值中提取 jobId，不能凭空编造！`,
+    parameters: AddParamsSchema,
+    execute: async (toolCallId, params) => {
+      const p = params;
+      const ctx = resolveCronToolExecutionContext(toolCallId);
+      logger.info(`【智小途-生成参数】开始生成创建提醒参数11111 ctx.config = ${JSON.stringify(ctx.config)}`);
+      if (!p.time) {
+        logger.warn("【智小途-生成参数】缺少时间参数");
+        return json$a({ error: "time（时间）为必填参数" });
+      }
+      if (!p.name) {
+        logger.warn("【智小途-生成参数】缺少任务名称参数");
+        return json$a({ error: "name（任务名称）为必填参数" });
+      }
+      if (!p.message) {
+        logger.warn("【智小途-生成参数】缺少用户消息参数");
+        return json$a({ error: "message（用户消息）为必填参数" });
+      }
+      const taskId = String(ctx?.taskId || p.taskId || "").trim();
+      logger.info(`【智小途-生成参数】开始生成创建提醒参数 name=${p.name} time=${p.time}, rawTaskId=${p.taskId}, ctxTaskId=${ctx?.taskId}, resolvedTaskId=${taskId}`);
+      const accountId = ctx?.agentAccountId || "default";
+      logger.info(`【智小途-生成参数】accountId=${accountId} name=${p.name}`);
+      const timeValidation = validateTimeFormat(p.time);
+      if (!timeValidation.valid) {
+        logger.warn(`【智小途-生成参数】时间格式校验失败: ${timeValidation.error}`);
+        return json$a({ error: timeValidation.error });
+      }
+      const isCron = isCronExpression(p.time);
+      let isOneTime = false;
+      let cronExpr;
+      if (!isCron) {
+        isOneTime = true;
+        cronExpr = relativeToCron(p.time.trim());
+        logger.info(`【智小途-生成参数】相对时间转换为 cron 表达式 cronExpr=${cronExpr}`);
+      } else {
+        cronExpr = p.time.trim();
+      }
+      const cronParams = {
+        action: "add",
+        account: accountId,
+        job: {
+          name: p.name,
+          schedule: {
+            kind: "cron",
+            expr: cronExpr,
+            tz: "Asia/Shanghai"
+          },
+          sessionTarget: "current",
+          wakeMode: "now",
+          deleteAfterRun: isOneTime ? true : void 0,
+          payload: {
+            kind: "agentTurn",
+            message: p.message
+          },
+          delivery: {
+            mode: "announce",
+            channel: "openclaw-workclaw"
+          }
+        }
+      };
+      logger.info(`【智小途-生成参数】构建 cron 参数 cronParams=${JSON.stringify(cronParams)}`);
+      logger.info(`【智小途-生成参数】标准化后的参数 ${JSON.stringify({
+        ...p,
+        taskId
+      })}`);
+      return json$a({
+        cronParams,
+        meta: {
+          accountId,
+          taskId,
+          name: p.name,
+          kind: "cron",
+          expr: cronExpr,
+          message: p.message
+        },
+        summary: `⏰ 提醒已生成: "${p.name}" (${p.time})`
+      });
+    }
+  });
+}
+const DEFAULT_MAX_RETRIES = 3;
+const DEFAULT_RETRY_DELAY_MS = 1e3;
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function fetchWithRetry(fetchFn, options = {}) {
+  const maxRetries = options.maxRetries ?? DEFAULT_MAX_RETRIES;
+  const retryDelayMs = options.retryDelayMs ?? DEFAULT_RETRY_DELAY_MS;
+  const retryableErrors = options.retryableErrors ?? [
+    "ECONNREFUSED",
+    "ETIMEDOUT",
+    "ENOTFOUND",
+    "ENETUNREACH",
+    "EAI_AGAIN"
+  ];
+  let lastError = "";
+  let attempts = 0;
+  for (let i = 0; i <= maxRetries; i++) {
+    attempts = i + 1;
+    try {
+      const data = await fetchFn();
+      return { data, attempts };
+    } catch (error) {
+      lastError = error.message || String(error);
+      const isRetryable = retryableErrors.some(
+        (e) => lastError.toLowerCase().includes(e.toLowerCase())
+      );
+      if (i < maxRetries && isRetryable) {
+        const delay = retryDelayMs * 2 ** i;
+        await sleep(delay);
+        continue;
+      }
+      break;
+    }
+  }
+  return { error: lastError, attempts };
+}
+function sanitizePayload(payload) {
+  const sensitiveFields = [
+    "password",
+    "secret",
+    "token",
+    "authorization",
+    "appSecret",
+    "appSecret"
+  ];
+  const sanitized = {};
+  for (const [key, value] of Object.entries(payload)) {
+    const lowerKey = key.toLowerCase();
+    if (sensitiveFields.some((f) => lowerKey.includes(f))) {
+      sanitized[key] = "***";
+    } else if (typeof value === "object" && value !== null) {
+      sanitized[key] = sanitizePayload(value);
+    } else {
+      sanitized[key] = value;
+    }
+  }
+  return sanitized;
+}
+async function callBackendApi(api, accountId, path, payload, options = {}) {
+  try {
+    const account = resolveWorkclawAccountWithCache({
+      cfg: api.config,
+      accountId
+    });
+    if (!account.configured) {
+      logger.error(`【智小途-定时任务】账户未配置 accountId=${accountId}`);
+      return { success: false, error: "Account not configured" };
+    }
+    const accConfig = account.config;
+    const tokenCacheKey = accConfig.appKey || accountId;
+    const baseUrl = normalizeBaseUrl(accConfig.baseUrl);
+    logger.info(`【智小途-定时任务】正在获取认证 token，accountId=${accountId}`);
+    const token = await getWorkclawAccessToken(tokenCacheKey, {
+      baseUrl: accConfig.baseUrl,
+      appKey: accConfig.appKey,
+      appSecret: accConfig.appSecret,
+      allowInsecureTls: accConfig.allowInsecureTls,
+      requestTimeout: accConfig.requestTimeout
+    });
+    const requestUrl = `${baseUrl}/open-apis${path}`;
+    const sanitizedPayload = sanitizePayload(payload);
+    logger.info(`【智小途-定时任务】调用接口 ${requestUrl}`);
+    logger.info(`【智小途-定时任务】请求参数 ${JSON.stringify(sanitizedPayload)}`);
+    const maxRetries = options.maxRetries ?? DEFAULT_MAX_RETRIES;
+    const fetchResult = await fetchWithRetry(
+      () => doFetchJson(
+        requestUrl,
+        {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            "Authorization": `Bearer ${token}`
+          },
+          body: JSON.stringify(payload)
+        },
+        accConfig.allowInsecureTls,
+        accConfig.requestTimeout
+      ),
+      { maxRetries }
+    );
+    if (fetchResult.error) {
+      logger.error(`【智小途-定时任务】接口调用失败（已重试 ${fetchResult.attempts} 次）: ${fetchResult.error}`);
+      return { success: false, error: fetchResult.error, attempts: fetchResult.attempts };
+    }
+    const data = fetchResult.data;
+    logger.info(`【智小途-定时任务】接口响应（尝试 ${fetchResult.attempts} 次）: ${JSON.stringify(data)}`);
+    if (data?.code === 200 || data?.code === 0) {
+      return { success: true, data, attempts: fetchResult.attempts };
+    } else {
+      const errorMsg = data?.message || data?.msg || "Unknown error";
+      logger.error(`【智小途-定时任务】接口返回错误 ${errorMsg}`);
+      return { success: false, error: errorMsg };
+    }
+  } catch (error) {
+    logger.error(`【智小途-定时任务】接口调用异常 ${error.message}`);
+    return { success: false, error: error.message };
+  }
+}
+async function callCronJobAdd(api, accountId, payload) {
+  logger.info(`【智小途-定时任务】新增定时任务 jobId=${payload.jobId} name=${payload.name}`);
+  const result = await callBackendApi(api, accountId, "/cron/job/add", {
+    clawJobId: payload.jobId,
+    name: payload.name,
+    kind: payload.kind,
+    expr: payload.expr || "",
+    message: payload.message,
+    agentId: payload.messageId || "0",
+    taskId: payload.taskId
+  });
+  return { success: result.success, data: result.data, error: result.error };
+}
+async function callCronJobRemove(api, accountId, payload) {
+  logger.info(`【智小途-定时任务】删除定时任务 jobId=${payload.jobId}`);
+  const result = await callBackendApi(api, accountId, "/cron/job/del", {
+    clawJobId: payload.jobId
+  });
+  return { success: result.success, data: result.data, error: result.error };
+}
+async function callCronJobUpdate(api, accountId, payload) {
+  logger.info(`【智小途-定时任务】更新定时任务 jobId=${payload.jobId} name=${payload.name} agentId=${payload.agentId}`);
+  const result = await callBackendApi(api, accountId, "/cron/job/update", {
+    clawJobId: payload.jobId,
+    name: payload.name,
+    kind: payload.kind,
+    expr: payload.expr || "",
+    message: payload.message,
+    agentId: payload.agentId || "0"
+  });
+  return { success: result.success, data: result.data, error: result.error };
+}
+async function callCronJobEnabled(api, accountId, payload) {
+  logger.info(`【智小途-定时任务】启用定时任务 jobId=${payload.jobId}`);
+  const result = await callBackendApi(api, accountId, "/cron/job/enabled", {
+    clawJobId: payload.jobId
+  });
+  return { success: result.success, data: result.data, error: result.error };
+}
+async function callCronJobDisabled(api, accountId, payload) {
+  logger.info(`【智小途-定时任务】禁用定时任务 jobId=${payload.jobId}`);
+  const result = await callBackendApi(api, accountId, "/cron/job/disabled", {
+    clawJobId: payload.jobId
+  });
+  return { success: result.success, data: result.data, error: result.error };
+}
+async function callCronJobMessage(api, accountId, payload) {
+  logger.info(`【智小途-定时任务】定时任务触发通知 jobId=${payload.jobId} message=${payload.message} agentId=${payload.agentId}`);
+  const result = await callBackendApi(api, accountId, "/cron/job/message", {
+    clawJobId: payload.jobId,
+    message: payload.message,
+    agentId: payload.agentId || "0"
+  });
+  return { success: result.success, data: result.data, error: result.error };
+}
+const AddSyncSchema = {
+  type: "object",
+  properties: {
+    jobId: {
+      type: "string",
+      description: `⛔ 重要：jobId 必须从 OpenClaw cron 工具返回值中提取，格式：{"success": true, "jobId": "123456"}
+
+常见错误：
+- 把 cron 表达式（如 "31 12 11 31 3 *"）当作 jobId
+- 把 name 当作 jobId
+- 编造 jobId
+
+正确做法：
+1. 调用 openclaw-workclaw-cron-add-params
+2. 用返回的 cronParams 调用 cron 工具
+3. 从返回值提取 jobId（如 "7382945612345"）
+4. 用提取到的 jobId 调用此工具`
+    },
+    name: {
+      type: "string",
+      description: "任务名称，与 add-params 中传入的 name 一致"
+    },
+    kind: {
+      type: "string",
+      description: "任务类型",
+      enum: ["cron"]
+    },
+    expr: {
+      type: "string",
+      description: "Cron 表达式"
+    },
+    message: {
+      type: "string",
+      description: "提醒消息，与 add-params 中传入的 message 一致"
+    },
+    taskId: {
+      type: "string",
+      description: "⚠️ 【关键！】taskId 必须从 WebSocket 消息的 data.taskId 字段获取， 如果data.taskId没有值，就不传taskId，禁止自行生成！taskId 格式为纯数字字符串（如 12919375446074181），不是时间戳！"
+    }
+  },
+  required: ["jobId", "name", "kind", "message"]
+};
+function json$9(data) {
+  return {
+    content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
+    details: data
+  };
+}
+function registerOpenclawWorkclawCronAddSyncTool(api) {
+  api.registerTool({
+    name: "openclaw-workclaw-cron-add-sync",
+    label: "智小途同步创建提醒",
+    description: `【后端同步步骤】将创建定时任务同步到后端。必须在上一步 openclaw-workclaw-cron-add-params 执行后调用此工具完成同步。
+
+⚠️ jobId 必须是 cron 工具返回值 {"success": true, "jobId": "xxx"} 中的 jobId 字段！
+⚠️ taskId 必须沿用 add-params / 业务上下文里的 taskId，如果有值不能省略！ 如果data.taskId没有值，就不传taskId`,
+    parameters: AddSyncSchema,
+    execute: async (toolCallId, params) => {
+      const p = params;
+      const ctx = resolveCronToolExecutionContext(toolCallId);
+      logger.info(`【智小途-同步创建】开始同步 jobId=${p.jobId} name=${p.name}`);
+      if (!p.jobId) {
+        logger.warn("【智小途-同步创建】缺少 jobId 参数");
+        return json$9({ error: "jobId 为必填参数" });
+      }
+      const jobIdTrimmed = p.jobId.trim();
+      const parts = jobIdTrimmed.split(/\s+/);
+      const isCronExpression2 = parts.length >= 5 && parts.length <= 6 && jobIdTrimmed.includes("*");
+      if (isCronExpression2) {
+        logger.error(`【智小途-同步创建】jobId 格式错误！jobId=${p.jobId}，看起来像 cron 表达式`);
+        return json$9({
+          error: `jobId="${p.jobId}" 是 cron 表达式，不是任务 ID！jobId 应来自 cron 工具返回值，如 "123456" 或 "abc123"`
+        });
+      }
+      if (!p.name) {
+        logger.warn("【智小途-同步创建】缺少 name 参数");
+        return json$9({ error: "name 为必填参数" });
+      }
+      if (!p.message) {
+        logger.warn("【智小途-同步创建】缺少 message 参数");
+        return json$9({ error: "message 为必填参数" });
+      }
+      const taskId = String(ctx?.taskId || p.taskId || "").trim();
+      logger.info(`【智小途-同步创建】开始同步创建 name=${p.name}`);
+      const accountId = ctx?.agentAccountId;
+      if (!accountId) {
+        logger.warn("【智小途-同步创建】无法获取账户 ID");
+        return json$9({ error: "无法获取账户 ID（accountId），请确保已配置账户" });
+      }
+      const accountConfig = resolveWorkclawAccountWithCache({
+        cfg: ctx.config,
+        accountId
+      });
+      if (accountConfig.configured) {
+        try {
+          const channelAgentId = String(accountConfig.config.agentId);
+          const channelUserId = String(accountConfig.config.userId ?? "");
+          logger.info(`【智小途-同步通知】ctx=${JSON.stringify(ctx)} p=${JSON.stringify(p)}`);
+          logger.info(`【智小途-同步创建】accountId=${accountId} channelAgentId=${channelAgentId}`);
+          const result = await callCronJobAdd(api, accountId, {
+            jobId: p.jobId,
+            name: p.name,
+            kind: p.kind,
+            expr: p.expr,
+            message: p.message,
+            messageId: channelAgentId,
+            taskId
+          });
+          if (result.success) {
+            logger.info(`【智小途-同步创建】后端同步成功 jobId=${p.jobId}`);
+            return json$9({
+              code: 0,
+              message: "定时任务已创建并同步到后端",
+              data: {
+                jobId: p.jobId,
+                name: p.name,
+                message: p.message,
+                backendSynced: true
+              }
+            });
+          } else {
+            logger.error(`【智小途-同步创建】后端同步失败 ${result.error}`);
+            return json$9({
+              code: -1,
+              error: result.error || "后端同步失败",
+              data: { jobId: p.jobId, name: p.name }
+            });
+          }
+        } catch (error) {
+          logger.error(`【智小途-同步创建】后端同步异常 ${error.message}`);
+          return json$9({
+            code: -1,
+            error: error.message || "后端同步异常",
+            data: { jobId: p.jobId, name: p.name }
+          });
+        }
+      } else {
+        logger.error(`【智小途-同步创建】账户未配置 accountId=${accountId}`);
+        return json$9({
+          code: -1,
+          error: "账户未配置",
+          data: { jobId: p.jobId, name: p.name }
+        });
+      }
+    }
+  });
+}
+const DisableParamsSchema = {
+  type: "object",
+  properties: {
+    jobId: {
+      type: "string",
+      description: `OpenClaw 任务 ID（必须是数字或字符串，不是 cron 表达式）`
+    }
+  },
+  required: ["jobId"]
+};
+function json$8(data) {
+  return {
+    content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
+    details: data
+  };
+}
+function registerOpenclawWorkclawCronDisableParamsTool(api) {
+  api.registerTool({
+    name: "openclaw-workclaw-cron-disable-params",
+    label: "智小途生成禁用提醒参数",
+    description: `生成禁用提醒的 CLI 命令参数。
+
+📋 工作流程：
+1. 调用此工具获取 CLI 命令参数
+2. 使用返回的 cronParams 调用 OpenClaw 的 cron 工具
+3. 调用 openclaw-workclaw-cron-disable-sync 同步到后端`,
+    parameters: DisableParamsSchema,
+    execute: async (toolCallId, params) => {
+      const p = params;
+      const ctx = resolveCronToolExecutionContext(toolCallId);
+      logger.info(`【智小途-生成禁用参数】开始处理 jobId=${p.jobId}`);
+      if (!p.jobId) {
+        logger.warn("【智小途-生成禁用参数】缺少 jobId 参数");
+        return json$8({ error: "jobId 为必填参数" });
+      }
+      const accountId = ctx?.agentAccountId;
+      if (!accountId) {
+        logger.warn("【智小途-生成禁用参数】无法获取账户 ID");
+        return json$8({ error: "无法获取账户 ID（accountId），请确保已配置账户" });
+      }
+      logger.info(`【智小途-生成禁用参数】accountId=${accountId} jobId=${p.jobId}`);
+      const cronParams = {
+        action: "disable",
+        jobId: p.jobId
+      };
+      logger.info(`【智小途-生成禁用参数】构建 cron 参数 cronParams=${JSON.stringify(cronParams)}`);
+      return json$8({
+        cronParams,
+        meta: {
+          accountId,
+          jobId: p.jobId
+        },
+        summary: `⏸️ 提醒已禁用: jobId=${p.jobId}`
+      });
+    }
+  });
+}
+const DisableSyncSchema = {
+  type: "object",
+  properties: {
+    jobId: {
+      type: "string",
+      description: `OpenClaw 任务 ID（必须是数字或字符串，不是 cron 表达式）`
+    }
+  },
+  required: ["jobId"]
+};
+function json$7(data) {
+  return {
+    content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
+    details: data
+  };
+}
+function registerOpenclawWorkclawCronDisableSyncTool(api) {
+  api.registerTool({
+    name: "openclaw-workclaw-cron-disable-sync",
+    label: "智小途同步禁用提醒",
+    description: "将禁用定时任务同步到后端。在 cron 工具禁用任务后调用此工具同步后端。",
+    parameters: DisableSyncSchema,
+    execute: async (toolCallId, params) => {
+      const p = params;
+      const ctx = resolveCronToolExecutionContext(toolCallId);
+      logger.info(`【智小途-同步禁用】开始同步 jobId=${p.jobId}`);
+      if (!p.jobId) {
+        logger.warn("【智小途-同步禁用】缺少 jobId 参数");
+        return json$7({ error: "jobId 为必填参数" });
+      }
+      const accountId = ctx?.agentAccountId;
+      if (!accountId) {
+        logger.warn("【智小途-同步禁用】无法获取账户 ID");
+        return json$7({ error: "无法获取账户 ID（accountId），请确保已配置账户" });
+      }
+      const accountConfig = resolveWorkclawAccountWithCache({
+        cfg: ctx.config,
+        accountId
+      });
+      if (accountConfig.configured) {
+        try {
+          const channelAgentId = String(accountConfig.config.agentId);
+          logger.info(`【智小途-同步禁用】accountId=${accountId} channelAgentId=${channelAgentId}`);
+          const result = await callCronJobDisabled(api, accountId, {
+            jobId: p.jobId
+          });
+          if (result.success) {
+            logger.info(`【智小途-同步禁用】后端同步成功 jobId=${p.jobId}`);
+            return json$7({
+              code: 0,
+              message: "定时任务已禁用并同步到后端",
+              data: {
+                jobId: p.jobId,
+                backendSynced: true
+              }
+            });
+          } else {
+            logger.error(`【智小途-同步禁用】后端同步失败 ${result.error}`);
+            return json$7({
+              code: -1,
+              error: result.error || "后端同步失败",
+              data: { jobId: p.jobId }
+            });
+          }
+        } catch (error) {
+          logger.error(`【智小途-同步禁用】后端同步异常 ${error.message}`);
+          return json$7({
+            code: -1,
+            error: error.message,
+            data: { jobId: p.jobId }
+          });
+        }
+      } else {
+        logger.error(`【智小途-同步禁用】无法获取渠道配置，accountId=${accountId}`);
+        return json$7({ error: "无法获取渠道配置，请检查账户配置" });
+      }
+    }
+  });
+}
+const EnableParamsSchema = {
+  type: "object",
+  properties: {
+    jobId: {
+      type: "string",
+      description: `OpenClaw 任务 ID（必须是数字或字符串，不是 cron 表达式）`
+    }
+  },
+  required: ["jobId"]
+};
+function json$6(data) {
+  return {
+    content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
+    details: data
+  };
+}
+function registerOpenclawWorkclawCronEnableParamsTool(api) {
+  api.registerTool({
+    name: "openclaw-workclaw-cron-enable-params",
+    label: "智小途生成启用提醒参数",
+    description: `生成启用提醒的 CLI 命令参数。
+
+📋 工作流程：
+1. 调用此工具获取 CLI 命令参数
+2. 使用返回的 cronParams 调用 OpenClaw 的 cron 工具
+3. 调用 openclaw-workclaw-cron-enable-sync 同步到后端`,
+    parameters: EnableParamsSchema,
+    execute: async (toolCallId, params) => {
+      const p = params;
+      const ctx = resolveCronToolExecutionContext(toolCallId);
+      logger.info(`【智小途-生成启用参数】开始处理 jobId=${p.jobId}`);
+      if (!p.jobId) {
+        logger.warn("【智小途-生成启用参数】缺少 jobId 参数");
+        return json$6({ error: "jobId 为必填参数" });
+      }
+      const accountId = ctx?.agentAccountId;
+      if (!accountId) {
+        logger.warn("【智小途-生成启用参数】无法获取账户 ID");
+        return json$6({ error: "无法获取账户 ID（accountId），请确保已配置账户" });
+      }
+      logger.info(`【智小途-生成启用参数】accountId=${accountId} jobId=${p.jobId}`);
+      const cronParams = {
+        action: "enable",
+        jobId: p.jobId
+      };
+      logger.info(`【智小途-生成启用参数】构建 cron 参数 cronParams=${JSON.stringify(cronParams)}`);
+      return json$6({
+        cronParams,
+        meta: {
+          accountId,
+          jobId: p.jobId
+        },
+        summary: `✅ 提醒已启用: jobId=${p.jobId}`
+      });
+    }
+  });
+}
+const EnableSyncSchema = {
+  type: "object",
+  properties: {
+    jobId: {
+      type: "string",
+      description: `OpenClaw 任务 ID（必须是数字或字符串，不是 cron 表达式）`
+    }
+  },
+  required: ["jobId"]
+};
+function json$5(data) {
+  return {
+    content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
+    details: data
+  };
+}
+function registerOpenclawWorkclawCronEnableSyncTool(api) {
+  api.registerTool({
+    name: "openclaw-workclaw-cron-enable-sync",
+    label: "智小途同步启用提醒",
+    description: "将启用定时任务同步到后端。在 cron 工具启用任务后调用此工具同步后端。",
+    parameters: EnableSyncSchema,
+    execute: async (toolCallId, params) => {
+      const p = params;
+      const ctx = resolveCronToolExecutionContext(toolCallId);
+      logger.info(`【智小途-同步启用】开始同步 jobId=${p.jobId}`);
+      if (!p.jobId) {
+        logger.warn("【智小途-同步启用】缺少 jobId 参数");
+        return json$5({ error: "jobId 为必填参数" });
+      }
+      const accountId = ctx?.agentAccountId;
+      if (!accountId) {
+        logger.warn("【智小途-同步启用】无法获取账户 ID");
+        return json$5({ error: "无法获取账户 ID（accountId），请确保已配置账户" });
+      }
+      const accountConfig = resolveWorkclawAccountWithCache({
+        cfg: ctx.config,
+        accountId
+      });
+      if (accountConfig.configured) {
+        try {
+          const channelAgentId = String(accountConfig.config.agentId);
+          logger.info(`【智小途-同步启用】accountId=${accountId} channelAgentId=${channelAgentId}`);
+          const result = await callCronJobEnabled(api, accountId, {
+            jobId: p.jobId
+          });
+          if (result.success) {
+            logger.info(`【智小途-同步启用】后端同步成功 jobId=${p.jobId}`);
+            return json$5({
+              code: 0,
+              message: "定时任务已启用并同步到后端",
+              data: {
+                jobId: p.jobId,
+                backendSynced: true
+              }
+            });
+          } else {
+            logger.error(`【智小途-同步启用】后端同步失败 ${result.error}`);
+            return json$5({
+              code: -1,
+              error: result.error || "后端同步失败",
+              data: { jobId: p.jobId }
+            });
+          }
+        } catch (error) {
+          logger.error(`【智小途-同步启用】后端同步异常 ${error.message}`);
+          return json$5({
+            code: -1,
+            error: error.message,
+            data: { jobId: p.jobId }
+          });
+        }
+      } else {
+        logger.error(`【智小途-同步启用】无法获取渠道配置，accountId=${accountId}`);
+        return json$5({ error: "无法获取渠道配置，请检查账户配置" });
+      }
+    }
+  });
+}
+const NotifySchema = {
+  type: "object",
+  properties: {
+    jobId: {
+      type: "string",
+      description: "OpenClaw 任务 ID（从上下文获取）"
+    },
+    message: {
+      type: "string",
+      description: "要发送的提醒内容"
+    }
+  },
+  required: ["jobId", "message"]
+};
+function json$4(data) {
+  return {
+    content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
+    details: data
+  };
+}
+function registerOpenclawWorkclawCronNotifySyncTool(api) {
+  api.registerTool({
+    name: "openclaw-workclaw-cron-notify-sync",
+    label: "智小途定时任务触发通知",
+    description: `【系统最高优先级核心指令】当定时器时间到达时，必须立即调用此工具通知后端。`,
+    parameters: NotifySchema,
+    execute: async (toolCallId, params) => {
+      const p = params;
+      const ctx = resolveCronToolExecutionContext(toolCallId);
+      logger.info(`【智小途-定时触发】开始处理 jobId=${p.jobId} message=${p.message}`);
+      if (!p.jobId) {
+        logger.warn("【智小途-定时触发】缺少 jobId 参数");
+        return json$4({ error: "jobId 为必填参数" });
+      }
+      if (!p.message) {
+        logger.warn("【智小途-定时触发】缺少 message 参数");
+        return json$4({ error: "message 为必填参数" });
+      }
+      const accountId = ctx?.agentAccountId;
+      if (!accountId) {
+        logger.warn("【智小途-定时触发】无法获取账户 ID");
+        return json$4({ error: "无法获取账户 ID（accountId），请确保已配置账户" });
+      }
+      const accountConfig = resolveWorkclawAccountWithCache({
+        cfg: ctx.config,
+        accountId
+      });
+      if (accountConfig.configured) {
+        const channelAgentId = String(accountConfig.config.agentId);
+        logger.info(`【智小途-定时触发】accountId=${accountId} channelAgentId=${channelAgentId}`);
+        try {
+          const result = await callCronJobMessage(api, accountId, {
+            jobId: p.jobId,
+            message: p.message,
+            agentId: channelAgentId
+          });
+          if (result.success) {
+            logger.info(`【智小途-定时触发】通知后端成功`);
+            return json$4({
+              code: 0,
+              message: "定时任务触发通知已发送",
+              data: {
+                jobId: p.jobId,
+                message: p.message,
+                backendNotified: true
+              }
+            });
+          } else {
+            logger.error(`【智小途-定时触发】通知后端失败 ${result.error}`);
+            return json$4({
+              code: -1,
+              error: result.error || "通知后端失败",
+              data: {
+                jobId: p.jobId,
+                message: p.message
+              }
+            });
+          }
+        } catch (error) {
+          logger.error(`【智小途-定时触发】通知后端异常 ${error.message}`);
+          return json$4({
+            code: -1,
+            error: error.message || "通知后端异常",
+            data: {
+              jobId: p.jobId,
+              message: p.message
+            }
+          });
+        }
+      } else {
+        logger.error(`【智小途-定时触发】无法获取渠道配置，accountId=${accountId}`);
+        return json$4({ error: "无法获取渠道配置，请检查账户配置" });
+      }
+    }
+  });
+}
+const RemoveParamsSchema = {
+  type: "object",
+  properties: {
+    jobId: {
+      type: "string",
+      description: `OpenClaw 任务 ID（必须是数字或字符串，不是 cron 表达式）`
+    }
+  },
+  required: ["jobId"]
+};
+function json$3(data) {
+  return {
+    content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
+    details: data
+  };
+}
+function registerOpenclawWorkclawCronRemoveParamsTool(api) {
+  api.registerTool({
+    name: "openclaw-workclaw-cron-remove-params",
+    label: "智小途生成删除提醒参数",
+    description: `生成删除提醒的 CLI 命令。
+**必须**严格按照以下格式执行：
+openclaw cron remove <jobId>
+
+示例：openclaw cron remove 123456
+`,
+    parameters: RemoveParamsSchema,
+    execute: async (toolCallId, params) => {
+      const p = params;
+      const ctx = resolveCronToolExecutionContext(toolCallId);
+      logger.info(`【智小途-生成删除参数】开始处理 jobId=${p.jobId}`);
+      if (!p.jobId) {
+        logger.warn("【智小途-生成删除参数】缺少 jobId 参数");
+        return json$3({ error: "jobId 为必填参数" });
+      }
+      const accountId = ctx?.agentAccountId;
+      const agentId = ctx?.agentId;
+      if (!accountId) {
+        logger.warn("【智小途-生成删除参数】无法获取账户 ID");
+        return json$3({ error: "无法获取账户 ID（accountId），请确保已配置账户" });
+      }
+      if (!agentId) {
+        logger.warn("【智小途-生成删除参数】无法获取智能体 ID");
+        return json$3({ error: "无法获取智能体 ID（agentId），请确保已配置智能体" });
+      }
+      logger.info(`【智小途-生成删除参数】accountId=${accountId} agentId=${agentId} jobId=${p.jobId}`);
+      const cronParams = {
+        action: "remove",
+        jobId: p.jobId
+      };
+      logger.info(`【智小途-生成删除参数】构建 cron 参数 cronParams=${JSON.stringify(cronParams)}`);
+      return json$3({
+        cronParams,
+        meta: {
+          accountId,
+          agentId,
+          jobId: p.jobId
+        },
+        summary: `🗑️ 提醒已删除: jobId=${p.jobId}`
+      });
+    }
+  });
+}
+const RemoveSyncSchema = {
+  type: "object",
+  properties: {
+    jobId: {
+      type: "string",
+      description: `OpenClaw 任务 ID（必须是数字或字符串，不是 cron 表达式）`
+    }
+  },
+  required: ["jobId"]
+};
+function json$2(data) {
+  return {
+    content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
+    details: data
+  };
+}
+function registerOpenclawWorkclawCronRemoveSyncTool(api) {
+  api.registerTool({
+    name: "openclaw-workclaw-cron-remove-sync",
+    label: "智小途同步删除提醒",
+    description: "【后端同步步骤】将删除定时任务同步到后端。必须在上一步 openclaw-workclaw-cron-remove-params 执行后调用此工具完成同步。",
+    parameters: RemoveSyncSchema,
+    execute: async (toolCallId, params) => {
+      const p = params;
+      const ctx = resolveCronToolExecutionContext(toolCallId);
+      logger.info(`【智小途-同步删除】开始同步 jobId=${p.jobId}`);
+      if (!p.jobId) {
+        logger.warn("【智小途-同步删除】缺少 jobId 参数");
+        return json$2({ error: "jobId 为必填参数" });
+      }
+      const accountId = ctx?.agentAccountId;
+      if (!accountId) {
+        logger.warn("【智小途-同步删除】无法获取账户 ID");
+        return json$2({ error: "无法获取账户 ID（accountId），请确保已配置账户" });
+      }
+      const accountConfig = resolveWorkclawAccountWithCache({
+        cfg: ctx.config,
+        accountId
+      });
+      if (accountConfig.configured) {
+        try {
+          const channelAgentId = String(accountConfig.config.agentId);
+          logger.info(`【智小途-同步删除】accountId=${accountId} channelAgentId=${channelAgentId}`);
+          const result = await callCronJobRemove(api, accountId, {
+            jobId: p.jobId
+          });
+          if (result.success) {
+            logger.info(`【智小途-同步删除】后端同步成功 jobId=${p.jobId}`);
+            return json$2({
+              code: 0,
+              message: "定时任务已删除并同步到后端",
+              data: {
+                jobId: p.jobId,
+                backendSynced: true
+              }
+            });
+          } else {
+            logger.error(`【智小途-同步删除】后端同步失败 ${result.error}`);
+            return json$2({
+              code: -1,
+              error: result.error || "后端同步失败",
+              data: { jobId: p.jobId }
+            });
+          }
+        } catch (error) {
+          logger.error(`【智小途-同步删除】后端同步异常 ${error.message}`);
+          return json$2({
+            code: -1,
+            error: error.message,
+            data: { jobId: p.jobId }
+          });
+        }
+      } else {
+        logger.error(`【智小途-同步删除】无法获取渠道配置，accountId=${accountId}`);
+        return json$2({ error: "无法获取渠道配置，请检查账户配置" });
+      }
+    }
+  });
+}
+const UpdateParamsSchema = {
+  type: "object",
+  properties: {
+    jobId: {
+      type: "string",
+      description: `OpenClaw 任务 ID（必须是数字或字符串，不是 cron 表达式）`
+    },
+    time: {
+      type: "string",
+      description: "⏰ 时间（核心！），支持相对时间和 cron 表达式，工具自动转换"
+    },
+    name: {
+      type: "string",
+      description: "任务名称"
+    },
+    message: {
+      type: "string",
+      description: "提醒内容"
+    }
+  },
+  required: ["jobId", "time", "name", "message"]
+};
+function json$1(data) {
+  return {
+    content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
+    details: data
+  };
+}
+function registerOpenclawWorkclawCronUpdateParamsTool(api) {
+  api.registerTool({
+    name: "openclaw-workclaw-cron-update-params",
+    label: "智小途生成修改提醒参数",
+    description: `【核心工具】生成修改提醒的 cronParams 参数。
+
+📋 工作流程（必须按顺序执行）：
+1. 调用此工具获取 cronParams 参数
+2. 使用返回的 cronParams 调用 OpenClaw 的 cron 工具
+3. 必须调用 openclaw-workclaw-cron-update-sync 同步到后端
+
+⏰ 时间格式（核心！）：
+- time 参数支持相对时间（如 "10m"、"1h"、"2d"）和 cron 表达式
+- 工具会自动将所有时间统一转换为 cron 表达式
+- 严禁使用 --at 参数或其他绝对时间格式
+- 最终 CLI 命令必须使用 --cron 参数
+
+🔒 强制规则：
+- schedule.kind 必须是 "cron"
+- 必须使用 --cron 参数传递 cron 表达式
+
+⚠️ 必须从 cron 工具返回值中确认更新成功`,
+    parameters: UpdateParamsSchema,
+    execute: async (toolCallId, params) => {
+      const p = params;
+      const ctx = resolveCronToolExecutionContext(toolCallId);
+      logger.info(`【智小途-生成修改参数】开始处理 jobId=${p.jobId} name=${p.name} time=${p.time}`);
+      if (!p.jobId) {
+        logger.warn("【智小途-生成修改参数】缺少 jobId 参数");
+        return json$1({ error: "jobId 为必填参数" });
+      }
+      if (!p.time) {
+        logger.warn("【智小途-生成修改参数】缺少时间参数");
+        return json$1({ error: "time（时间）为必填参数" });
+      }
+      if (!p.name) {
+        logger.warn("【智小途-生成修改参数】缺少任务名称参数");
+        return json$1({ error: "name（任务名称）为必填参数" });
+      }
+      if (!p.message) {
+        logger.warn("【智小途-生成修改参数】缺少提醒内容参数");
+        return json$1({ error: "message（提醒内容）为必填参数" });
+      }
+      const accountId = ctx?.agentAccountId;
+      const name = p.name;
+      const message = p.message;
+      const time = p.time;
+      if (!accountId) {
+        logger.warn("【智小途-生成修改参数】无法获取账户 ID");
+        return json$1({ error: "无法获取账户 ID（accountId），请确保已配置账户" });
+      }
+      logger.info(`【智小途-生成修改参数】accountId=${accountId} jobId=${p.jobId}`);
+      const timeValidation = validateTimeFormat(time);
+      if (!timeValidation.valid) {
+        logger.warn(`【智小途-生成修改参数】时间格式校验失败: ${timeValidation.error}`);
+        return json$1({ error: timeValidation.error });
+      }
+      const isCron = isCronExpression(time);
+      let isOneTime = false;
+      let cronExpr;
+      if (!isCron) {
+        isOneTime = true;
+        cronExpr = relativeToCron(time.trim());
+        logger.info(`【智小途-生成修改参数】相对时间转换为绝对时间 cron 表达式 cronExpr=${cronExpr}`);
+      } else {
+        cronExpr = time.trim();
+      }
+      const cronParams = {
+        action: "update",
+        account: accountId,
+        jobId: p.jobId,
+        job: {
+          name,
+          schedule: {
+            kind: "cron",
+            expr: cronExpr,
+            tz: "Asia/Shanghai"
+          },
+          sessionTarget: "isolated",
+          wakeMode: "now",
+          deleteAfterRun: isOneTime ? true : void 0,
+          payload: {
+            kind: "agentTurn",
+            message
+          },
+          delivery: {
+            mode: "announce",
+            channel: "openclaw-workclaw"
+          }
+        }
+      };
+      logger.info(`【智小途-生成修改参数】构建 cron 参数 cronParams=${JSON.stringify(cronParams)}`);
+      return json$1({
+        cronParams,
+        meta: {
+          accountId,
+          jobId: p.jobId,
+          name,
+          kind: "cron",
+          expr: cronExpr,
+          message
+        },
+        summary: `✅ 提醒已修改: "${name}" (${time})`
+      });
+    }
+  });
+}
+const UpdateSyncSchema = {
+  type: "object",
+  properties: {
+    jobId: {
+      type: "string",
+      description: `OpenClaw 任务 ID（必须是数字或字符串，不是 cron 表达式）`
+    },
+    name: {
+      type: "string",
+      description: "任务名称"
+    },
+    kind: {
+      type: "string",
+      description: "任务类型（仅支持 cron）",
+      enum: ["cron"]
+    },
+    expr: {
+      type: "string",
+      description: "Cron 表达式（kind=cron 时必填）"
+    },
+    message: {
+      type: "string",
+      description: "提醒消息"
+    }
+  },
+  required: ["jobId", "name", "kind", "message"]
+};
+function json(data) {
+  return {
+    content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
+    details: data
+  };
+}
+function registerOpenclawWorkclawCronUpdateSyncTool(api) {
+  api.registerTool({
+    name: "openclaw-workclaw-cron-update-sync",
+    label: "智小途同步修改提醒",
+    description: "将修改定时任务同步到后端。在 cron 工具修改任务后调用此工具同步后端。",
+    parameters: UpdateSyncSchema,
+    execute: async (toolCallId, params) => {
+      const p = params;
+      const ctx = resolveCronToolExecutionContext(toolCallId);
+      logger.info(`【智小途-同步修改】开始同步 jobId=${p.jobId} name=${p.name}`);
+      if (!p.jobId) {
+        logger.warn("【智小途-同步修改】缺少 jobId 参数");
+        return json({ error: "jobId 为必填参数" });
+      }
+      if (!p.name) {
+        logger.warn("【智小途-同步修改】缺少 name 参数");
+        return json({ error: "name 为必填参数" });
+      }
+      if (!p.message) {
+        logger.warn("【智小途-同步修改】缺少 message 参数");
+        return json({ error: "message 为必填参数" });
+      }
+      const accountId = ctx?.agentAccountId;
+      const channelUserId = ctx?.From;
+      if (!accountId) {
+        logger.warn("【智小途-同步修改】无法获取账户 ID");
+        return json({ error: "无法获取账户 ID（accountId），请确保已配置账户" });
+      }
+      const accountConfig = resolveWorkclawAccountWithCache({
+        cfg: ctx.config,
+        accountId
+      });
+      const channelAgentId = accountConfig.configured ? String(accountConfig.config.agentId) : "0";
+      logger.info(`【智小途-同步修改】accountId=${accountId} channelUserId=${channelUserId} channelAgentId=${channelAgentId}`);
+      try {
+        const result = await callCronJobUpdate(api, accountId, {
+          jobId: p.jobId,
+          name: p.name,
+          kind: p.kind,
+          expr: p.expr,
+          message: p.message,
+          agentId: channelAgentId
+        });
+        if (result.success) {
+          logger.info(`【智小途-同步修改】后端同步成功 jobId=${p.jobId}`);
+          return json({
+            code: 0,
+            message: "定时任务已修改并同步到后端",
+            data: {
+              jobId: p.jobId,
+              name: p.name,
+              message: p.message,
+              backendSynced: true
+            }
+          });
+        } else {
+          logger.error(`【智小途-同步修改】后端同步失败 ${result.error}`);
+          return json({
+            code: -1,
+            error: result.error || "后端同步失败",
+            data: { jobId: p.jobId, name: p.name }
+          });
+        }
+      } catch (error) {
+        logger.error(`【智小途-同步修改】后端同步异常 ${error.message}`);
+        return json({
+          code: -1,
+          error: error.message,
+          data: { jobId: p.jobId, name: p.name }
+        });
+      }
+    }
+  });
+}
+function registerAllOpenclawWorkclawCronTools(api) {
+  logger.info("【智小途-定时任务】正在注册定时任务工具");
+  registerOpenclawWorkclawCronAddParamsTool(api);
+  registerOpenclawWorkclawCronRemoveParamsTool(api);
+  registerOpenclawWorkclawCronUpdateParamsTool(api);
+  registerOpenclawWorkclawCronEnableParamsTool(api);
+  registerOpenclawWorkclawCronDisableParamsTool(api);
+  registerOpenclawWorkclawCronAddSyncTool(api);
+  registerOpenclawWorkclawCronRemoveSyncTool(api);
+  registerOpenclawWorkclawCronUpdateSyncTool(api);
+  registerOpenclawWorkclawCronEnableSyncTool(api);
+  registerOpenclawWorkclawCronDisableSyncTool(api);
+  registerOpenclawWorkclawCronNotifySyncTool(api);
+  logger.info("【智小途-定时任务】定时任务工具注册完成");
+}
+export {
+  registerAllOpenclawWorkclawCronTools as r
+};