weacpx 0.4.10 → 0.5.0

package/README.md

@@ -323,6 +323,30 @@ opencode, qoder, qwen, trae
 /cancel
 ```
 
+### 定时任务（/later）
+
+让 agent 在未来某个时间自动收到一条消息。任务绑定「创建时的当前会话」，到点后把这条消息作为普通 prompt 发给那个会话。
+
+| 命令 | 说明 |
+|------|------|
+| `/lt <时间> <消息>` | 创建一次性定时任务（`/later` 同义） |
+| `/lt list` | 查看全局待执行任务 |
+| `/lt cancel <id>` | 取消待执行任务 |
+
+最常见例子：
+
+```text
+/lt in 2h 检查 CI 是否通过
+/lt 明天 09:00 看 PR
+/lt list
+```
+
+说明：
+
+- 只支持一次性任务，时间必须在 10 秒之后、7 天之内
+- 时间格式是固定白名单（相对时间 / 今天·明天·后天 / 星期几 + 时刻），不支持自然语言
+- 完整时间格式、任务状态与限制见 [docs/later-command.md](./docs/later-command.md)
+
 ### 配置与权限
 
 | 命令 | 说明 |
@@ -514,6 +538,7 @@ bun run dev
 ### 日常使用
 
 - 想查看完整聊天命令参考：[docs/commands.md](./docs/commands.md)
+- 想用定时任务（`/later`）安排一次性的未来消息：[docs/later-command.md](./docs/later-command.md)
 - 想理解什么时候该用 delegate、什么时候该开 group：[docs/weacpx-group-usage-guide.md](./docs/weacpx-group-usage-guide.md)
 
 ### 排错与验证

package/dist/channels/types.d.ts

@@ -22,6 +22,16 @@ export interface CoordinatorMessageInput {
     replyContextToken?: string;
     text: string;
 }
+export interface ScheduledChannelMessageInput {
+    chatKey: string;
+    taskId?: string;
+    sessionAlias: string;
+    accountId?: string;
+    replyContextToken?: string;
+    noticeText: string;
+    promptText: string;
+    abortSignal?: AbortSignal;
+}
 export interface ChannelStartInput {
     agent: ChatAgent;
     abortSignal: AbortSignal;
@@ -60,6 +70,7 @@ export interface MessageChannelRuntime {
     notifyTaskCompletion(task: OrchestrationTaskRecord): Promise<void>;
     notifyTaskProgress(task: OrchestrationTaskRecord, text: string): Promise<void>;
     sendCoordinatorMessage(input: CoordinatorMessageInput): Promise<void>;
+    sendScheduledMessage?(input: ScheduledChannelMessageInput): Promise<void>;
 }
 export type ToolUseStatus = "running" | "success" | "error";
 export type ToolUseKind = "read" | "search" | "execute" | "edit" | "think" | "other";

package/dist/channels/weixin-channel.d.ts

@@ -1,8 +1,9 @@
-import type { MessageChannelRuntime, ChannelStartInput, CoordinatorMessageInput, OrchestrationDeliveryCallbacks, ConsumerLock, ConsumerLockOptions } from "./types.js";
+import type { MessageChannelRuntime, ChannelStartInput, CoordinatorMessageInput, OrchestrationDeliveryCallbacks, ConsumerLock, ConsumerLockOptions, ScheduledChannelMessageInput } from "./types.js";
 import type { RuntimeMediaStore } from "./media-store.js";
 import type { OrchestrationTaskRecord } from "../orchestration/orchestration-types.js";
 export declare class WeixinChannel implements MessageChannelRuntime {
     readonly id = "weixin";
+    private agent;
     private quota;
     private logger;
     private markDelivered;
@@ -19,4 +20,5 @@ export declare class WeixinChannel implements MessageChannelRuntime {
     notifyTaskCompletion(task: OrchestrationTaskRecord): Promise<void>;
     notifyTaskProgress(task: OrchestrationTaskRecord, text: string): Promise<void>;
     sendCoordinatorMessage(input: CoordinatorMessageInput): Promise<void>;
+    sendScheduledMessage(input: ScheduledChannelMessageInput): Promise<void>;
 }

package/dist/cli.js

@@ -9735,7 +9735,8 @@ function createEmptyState() {
   return {
     sessions: {},
     chat_contexts: {},
-    orchestration: createEmptyOrchestrationState()
+    orchestration: createEmptyOrchestrationState(),
+    scheduled_tasks: {}
   };
 }
 var init_types = () => {};
@@ -9981,6 +9982,29 @@ function parseChatContexts(raw, path3) {
   }
   return chatContexts;
 }
+function isScheduledTaskStatus(value) {
+  return value === "pending" || value === "triggering" || value === "executed" || value === "cancelled" || value === "missed" || value === "failed";
+}
+function isScheduledTaskRecord(value) {
+  if (!isRecord2(value))
+    return false;
+  return isString(value.id) && isString(value.chat_key) && isString(value.session_alias) && isString(value.execute_at) && isString(value.message) && isScheduledTaskStatus(value.status) && isString(value.created_at) && isOptionalString(value.account_id) && isOptionalString(value.reply_context_token) && isOptionalString(value.source_label) && isOptionalString(value.triggered_at) && isOptionalString(value.executed_at) && isOptionalString(value.cancelled_at) && isOptionalString(value.missed_at) && isOptionalString(value.failed_at) && isOptionalString(value.last_error);
+}
+function parseScheduledTasks(raw, path3) {
+  if (raw === undefined)
+    return {};
+  if (!isRecord2(raw)) {
+    throw new Error(`state file "${path3}" must contain an object field "scheduled_tasks"`);
+  }
+  const tasks = {};
+  for (const [id, value] of Object.entries(raw)) {
+    if (!isScheduledTaskRecord(value) || value.id !== id) {
+      throw new Error(`state file "${path3}" contains malformed scheduled task record "${id}"`);
+    }
+    tasks[id] = value;
+  }
+  return tasks;
+}
 function parseState(raw, path3) {
   if (!isRecord2(raw)) {
     throw new Error(`state file "${path3}" must contain a JSON object`);
@@ -9999,7 +10023,8 @@ function parseState(raw, path3) {
   return {
     sessions: parsedSessions,
     chat_contexts: parseChatContexts(chatContexts, path3),
-    orchestration
+    orchestration,
+    scheduled_tasks: parseScheduledTasks(raw.scheduled_tasks, path3)
   };
 }
 function validateExternalCoordinatorIdentityCollisions(sessions, orchestration, path3) {
@@ -15442,6 +15467,177 @@ var init_deliver_coordinator_message = __esm(() => {
   init_send();
 });
 
+// src/weixin/messaging/scheduled-turn.ts
+async function executeScheduledTurn(input, deps) {
+  const userId = normalizeWeixinUserIdFromChatKey(input.chatKey);
+  const quotaKey = userId;
+  const sendMessage2 = deps.sendMessage ?? sendMessageWeixin;
+  const candidateAccountIds = input.accountId ? [input.accountId] : deps.listAccountIds();
+  if (candidateAccountIds.length === 0) {
+    throw new Error(`no weixin account is available for scheduled message on chatKey: ${input.chatKey}`);
+  }
+  let noticeSent = false;
+  let lastNoticeError;
+  let deliveryAccountId;
+  let deliveryContextToken;
+  let deliverableAccountId;
+  let deliverableContextToken;
+  const resolveContextToken = (candidateAccountId) => deps.getContextToken(candidateAccountId, userId) ?? (candidateAccountId === input.accountId ? input.replyContextToken : undefined);
+  for (const candidateAccountId of candidateAccountIds) {
+    const contextToken = resolveContextToken(candidateAccountId);
+    if (!contextToken)
+      continue;
+    const account = deps.resolveAccount(candidateAccountId);
+    if (!account.token)
+      continue;
+    if (!deliverableAccountId) {
+      deliverableAccountId = candidateAccountId;
+      deliverableContextToken = contextToken;
+    }
+    try {
+      if (!deps.reserveMidSegment(quotaKey)) {
+        throw new Error("mid segment quota exhausted");
+      }
+      await sendMessage2({
+        to: userId,
+        text: input.noticeText,
+        opts: { baseUrl: account.baseUrl, token: account.token, contextToken }
+      });
+      noticeSent = true;
+      deliveryAccountId = candidateAccountId;
+      deliveryContextToken = contextToken;
+      break;
+    } catch (error2) {
+      lastNoticeError = error2;
+      await deps.logger.error("scheduled.notice_send_failed", "failed to send scheduled notice", { chatKey: input.chatKey, accountId: candidateAccountId, error: String(error2) });
+    }
+  }
+  if (!noticeSent) {
+    if (!deliverableAccountId || !deliverableContextToken) {
+      const message = lastNoticeError instanceof Error ? lastNoticeError.message : `no deliverable weixin context for scheduled message on chatKey: ${input.chatKey}`;
+      throw new Error(message);
+    }
+    deliveryAccountId = deliverableAccountId;
+    deliveryContextToken = deliverableContextToken;
+    await deps.logger.info("scheduled.notice_skipped", "scheduled trigger notice was not delivered; proceeding with agent turn", {
+      chatKey: input.chatKey,
+      accountId: deliveryAccountId,
+      reason: lastNoticeError instanceof Error ? lastNoticeError.message : "notice_undelivered"
+    });
+  }
+  const sendReplySegment = async (text) => {
+    const plainText = markdownToPlainText(text).trim();
+    if (plainText.length === 0)
+      return false;
+    return await sendTextViaAvailableAccount(plainText, "scheduled.mid_send_failed");
+  };
+  const sendReservedMidText = async (text) => {
+    const plainText = markdownToPlainText(text).trim();
+    if (plainText.length === 0)
+      return false;
+    if (!deps.reserveMidSegment(quotaKey)) {
+      await deps.logger.info("scheduled.mid_dropped", "scheduled turn intermediate response dropped due to quota", { chatKey: input.chatKey, reason: "quota_exhausted" });
+      return false;
+    }
+    return await sendTextViaAvailableAccount(plainText, "scheduled.mid_send_failed");
+  };
+  const resolvedAccountId = deliveryAccountId ?? input.accountId ?? candidateAccountIds[0];
+  let turn;
+  try {
+    turn = await executeChatTurn({
+      agent: deps.agent,
+      request: {
+        accountId: resolvedAccountId,
+        conversationId: input.chatKey,
+        text: input.promptText,
+        ...deliveryContextToken ? { replyContextToken: deliveryContextToken } : {},
+        ...input.abortSignal ? { abortSignal: input.abortSignal } : {},
+        metadata: { channel: "weixin", scheduledSessionAlias: input.sessionAlias }
+      },
+      onReplySegment: sendReplySegment
+    });
+  } catch (error2) {
+    await sendReservedMidText(`定时任务执行失败：${error2 instanceof Error ? error2.message : String(error2)}`).catch(() => false);
+    throw error2;
+  }
+  if (turn.text) {
+    const finalText = markdownToPlainText(turn.text).trim();
+    if (finalText.length > 0) {
+      await sendFinalText(finalText);
+    }
+  }
+  async function sendFinalText(finalText) {
+    const rawChunks = chunkFinalText(finalText, 1800);
+    if (rawChunks.length === 0)
+      return;
+    const total = rawChunks.length;
+    const chunks = total === 1 ? rawChunks : rawChunks.map((body, index) => `(${index + 1}/${total}) ${body}`);
+    const available = total === 1 ? 1 : Math.max(Math.min(deps.finalRemaining?.(quotaKey) ?? total, total), 0);
+    const wave = chunks.slice(0, available);
+    if (wave.length > 0 && wave.length < total) {
+      wave[wave.length - 1] = `${wave[wave.length - 1]}
+
+${buildFinalHeadsUp({
+        total,
+        sentSoFar: wave.length
+      })}`;
+    }
+    let sent = 0;
+    for (let index = 0;index < wave.length; index += 1) {
+      if (!deps.reserveFinal(quotaKey)) {
+        await deps.logger.info("scheduled.final_dropped", "scheduled turn final response dropped due to quota", { chatKey: input.chatKey, reason: "quota_exhausted", chunk: index + 1, total });
+        break;
+      }
+      const delivered = await sendTextViaAvailableAccount(wave[index], "scheduled.final_send_failed");
+      if (!delivered)
+        break;
+      sent += 1;
+    }
+    const restToPark = chunks.slice(sent);
+    if (total > 1 && restToPark.length > 0 && deps.enqueuePendingFinal) {
+      const pending = restToPark.map((text, index) => {
+        const entry = { text, seq: sent + index + 1, total };
+        if (deliveryContextToken)
+          entry.contextToken = deliveryContextToken;
+        if (deliveryAccountId)
+          entry.accountId = deliveryAccountId;
+        return entry;
+      });
+      deps.enqueuePendingFinal(quotaKey, pending);
+    }
+  }
+  async function sendTextViaAvailableAccount(text, errorEvent) {
+    const orderedAccountIds = [
+      ...deliveryAccountId ? [deliveryAccountId] : [],
+      ...candidateAccountIds.filter((accountId) => accountId !== deliveryAccountId)
+    ];
+    for (const candidateAccountId of orderedAccountIds) {
+      const contextToken = candidateAccountId === deliveryAccountId && deliveryContextToken ? deliveryContextToken : resolveContextToken(candidateAccountId);
+      if (!contextToken)
+        continue;
+      const account = deps.resolveAccount(candidateAccountId);
+      if (!account.token)
+        continue;
+      try {
+        await sendMessage2({
+          to: userId,
+          text,
+          opts: { baseUrl: account.baseUrl, token: account.token, contextToken }
+        });
+        return true;
+      } catch (error2) {
+        await deps.logger.error(errorEvent, "failed to send scheduled response text", { chatKey: input.chatKey, accountId: candidateAccountId, error: String(error2) });
+      }
+    }
+    return false;
+  }
+}
+var init_scheduled_turn = __esm(() => {
+  init_handle_weixin_message_turn();
+  init_send();
+  init_inbound();
+});
+
 // src/weixin/monitor/consumer-lock.ts
 import { mkdir as mkdir8, open as open3, readFile as readFile6, rm as rm6 } from "node:fs/promises";
 import { dirname as dirname8, join as join5 } from "node:path";
@@ -15568,6 +15764,7 @@ var init_consumer_lock = __esm(() => {
 // src/channels/weixin-channel.ts
 class WeixinChannel {
   id = "weixin";
+  agent = null;
   quota = null;
   logger = null;
   markDelivered = null;
@@ -15598,6 +15795,7 @@ class WeixinChannel {
     this.markFailed = callbacks.markTaskNoticeFailed;
   }
   async start(input) {
+    this.agent = input.agent;
     this.quota = input.quota;
     this.logger = input.logger;
     if (!this.isLoggedIn()) {
@@ -15658,6 +15856,23 @@ class WeixinChannel {
       logger: this.logger
     });
   }
+  async sendScheduledMessage(input) {
+    if (!this.agent || !this.quota || !this.logger) {
+      throw new Error("WeixinChannel.start() must be called before scheduled message delivery");
+    }
+    await executeScheduledTurn(input, {
+      agent: this.agent,
+      listAccountIds: () => listWeixinAccountIds(),
+      resolveAccount: (accountId) => resolveWeixinAccount(accountId),
+      getContextToken: (accountId, userId) => getContextToken(accountId, userId),
+      reserveMidSegment: (chatKey) => this.quota.reserveMidSegment(chatKey),
+      reserveFinal: (chatKey) => this.quota.reserveFinal(chatKey),
+      finalRemaining: (chatKey) => this.quota.finalRemaining(chatKey),
+      enqueuePendingFinal: (chatKey, chunks) => this.quota.enqueuePendingFinal(chatKey, chunks),
+      sendMessage: sendMessageWeixin,
+      logger: this.logger
+    });
+  }
 }
 var init_weixin_channel = __esm(() => {
   init_weixin();
@@ -15665,6 +15880,7 @@ var init_weixin_channel = __esm(() => {
   init_deliver_orchestration_task_notice();
   init_deliver_orchestration_task_progress();
   init_deliver_coordinator_message();
+  init_scheduled_turn();
   init_consumer_lock();
 });
 
@@ -16049,7 +16265,7 @@ function validatePluginCompatibility(metadata, context) {
     }
   }
 }
-var WEACPX_PLUGIN_API_VERSION = 1, WEACPX_PLUGIN_API_SUPPORTED_VERSIONS, WEACPX_PLUGIN_MIN_CORE_VERSION = "0.4.0", SEMVER_RE;
+var WEACPX_PLUGIN_API_VERSION = 1, WEACPX_PLUGIN_API_SUPPORTED_VERSIONS, WEACPX_PLUGIN_MIN_CORE_VERSION = "0.5.0", SEMVER_RE;
 var init_compatibility = __esm(() => {
   WEACPX_PLUGIN_API_SUPPORTED_VERSIONS = [1];
   SEMVER_RE = /^(\d+)\.(\d+)\.(\d+)$/;
@@ -16435,7 +16651,9 @@ var init_command_list = __esm(() => {
     "/dg",
     "/group",
     "/groups",
-    "/task"
+    "/task",
+    "/later",
+    "/lt"
   ];
   KNOWN_COMMAND_PREFIX_SET = new Set(WEACPX_KNOWN_COMMAND_PREFIXES);
 });
@@ -16603,6 +16821,16 @@ function parseCommand(input) {
   } else if (command === "/task" && parts[1] && parts.length === 2) {
     return { kind: "task.get", taskId: parts[1] };
   }
+  if (command === "/later") {
+    if (parts.length === 1)
+      return { kind: "later.help" };
+    if (parts[1] === "list" && parts.length === 2)
+      return { kind: "later.list" };
+    if (parts[1] === "cancel" && parts[2] && parts.length === 3) {
+      return { kind: "later.cancel", id: parts[2] };
+    }
+    return { kind: "later.create", tokens: parts.slice(1) };
+  }
   if (command === "/workspace" && parts[1] === "new" && parts[2]) {
     const name = parts[2];
     let cwd = "";
@@ -16771,6 +16999,8 @@ function normalizeCommand(command) {
     return "/permission";
   if (command === "/stop")
     return "/cancel";
+  if (command === "/lt")
+    return "/later";
   return command;
 }
 function isRecognizedCommand(command) {
@@ -16966,6 +17196,7 @@ var init_command_policy = __esm(() => {
     "group.get",
     "tasks",
     "task.get",
+    "later.help",
     "invalid",
     "prompt"
   ]);
@@ -16995,7 +17226,10 @@ var init_command_policy = __esm(() => {
     "session.new": "/session new",
     "session.shortcut": "/session",
     "session.shortcut.new": "/session",
-    "session.attach": "/session attach"
+    "session.attach": "/session attach",
+    "later.create": "/later",
+    "later.list": "/later list",
+    "later.cancel": "/later cancel"
   };
 });
 
@@ -17949,11 +18183,7 @@ async function promptWithSession(context, session, chatKey, text, reply, replyCo
     throw error2;
   }
 }
-async function handlePrompt(context, chatKey, text, reply, replyContextToken, accountId, media, abortSignal, onToolEvent, onThought, perfSpan) {
-  const session = await context.sessions.getCurrentSession(chatKey);
-  if (!session) {
-    return { text: NO_CURRENT_SESSION_TEXT };
-  }
+async function handlePromptWithSession(context, session, chatKey, text, reply, replyContextToken, accountId, media, abortSignal, onToolEvent, onThought, perfSpan) {
   try {
     return await promptWithSession(context, session, chatKey, text, reply, replyContextToken, accountId, media, abortSignal, onToolEvent, onThought, perfSpan);
   } catch (error2) {
@@ -17964,6 +18194,13 @@ async function handlePrompt(context, chatKey, text, reply, replyContextToken, ac
     return context.recovery.renderTransportError(session, error2);
   }
 }
+async function handlePrompt(context, chatKey, text, reply, replyContextToken, accountId, media, abortSignal, onToolEvent, onThought, perfSpan) {
+  const session = await context.sessions.getCurrentSession(chatKey);
+  if (!session) {
+    return { text: NO_CURRENT_SESSION_TEXT };
+  }
+  return await handlePromptWithSession(context, session, chatKey, text, reply, replyContextToken, accountId, media, abortSignal, onToolEvent, onThought, perfSpan);
+}
 async function preparePromptWithFallback(context, session, chatKey, text, replyContextToken, accountId) {
   const orchestration = context.orchestration;
   if (!orchestration) {
@@ -18725,6 +18962,333 @@ var init_workspace_handler = __esm(() => {
   };
 });
 
+// src/scheduled/scheduled-types.ts
+var LATER_MIN_DELAY_MS = 1e4, LATER_MAX_DELAY_MS, LATER_MESSAGE_PREVIEW_CHARS = 120;
+var init_scheduled_types = __esm(() => {
+  LATER_MAX_DELAY_MS = 7 * 24 * 60 * 60 * 1000;
+});
+
+// src/scheduled/parse-later-time.ts
+function parseLaterTime(tokens, now = new Date) {
+  if (tokens.length === 0)
+    return { ok: false, code: "missing_time" };
+  const relative = parseRelative(tokens, now);
+  if (relative)
+    return validateResult(relative.executeAt, relative.messageStartIndex, tokens, now);
+  const absolute = parseAbsolute(tokens, now);
+  if (absolute)
+    return validateResult(absolute.executeAt, absolute.messageStartIndex, tokens, now, absolute.pastTodayValue);
+  return { ok: false, code: "unrecognized_time" };
+}
+function parseRelative(tokens, now) {
+  if (tokens[0] === "in" && tokens[1]) {
+    const ms = parseDuration(tokens[1]);
+    if (ms !== null)
+      return { executeAt: new Date(now.getTime() + ms), messageStartIndex: 2 };
+  }
+  const zh = /^(\d+)(分钟|小时|天)后$/.exec(tokens[0] ?? "");
+  if (zh) {
+    const amount = Number(zh[1]);
+    const unit = zh[2];
+    const ms = unit === "分钟" ? amount * 60000 : unit === "小时" ? amount * 3600000 : amount * 86400000;
+    return { executeAt: new Date(now.getTime() + ms), messageStartIndex: 1 };
+  }
+  return null;
+}
+function parseDuration(value) {
+  const match = /^(\d+)(m|min|minute|minutes|h|hour|hours|d|day|days)$/.exec(value.toLowerCase());
+  if (!match)
+    return null;
+  const amount = Number(match[1]);
+  const unit = match[2];
+  if (unit === "m" || unit === "min" || unit === "minute" || unit === "minutes")
+    return amount * 60000;
+  if (unit === "h" || unit === "hour" || unit === "hours")
+    return amount * 3600000;
+  return amount * 86400000;
+}
+function parseAbsolute(tokens, now) {
+  if (tokens[0] === "at" && tokens[1]) {
+    const parsed = parseClock(tokens[1]);
+    if (!parsed)
+      return null;
+    const executeAt = atLocalDate(now, 0, parsed.hour, parsed.minute);
+    if (executeAt.getTime() <= now.getTime())
+      return { executeAt, messageStartIndex: 2, pastTodayValue: tokens[1] };
+    return { executeAt, messageStartIndex: 2 };
+  }
+  const dayWord = tokens[0]?.toLowerCase();
+  const dayOffset = dayWord === "today" || dayWord === "今天" ? 0 : dayWord === "tomorrow" || dayWord === "明天" ? 1 : dayWord === "后天" ? 2 : null;
+  if (dayOffset !== null && tokens[1]) {
+    const parsed = parseClock(tokens[1]);
+    if (!parsed)
+      return null;
+    const executeAt = atLocalDate(now, dayOffset, parsed.hour, parsed.minute);
+    if (dayOffset === 0 && executeAt.getTime() <= now.getTime())
+      return { executeAt, messageStartIndex: 2, pastTodayValue: tokens[1] };
+    return { executeAt, messageStartIndex: 2 };
+  }
+  const weekday = WEEKDAYS.get(tokens[0]?.toLowerCase() ?? "");
+  if (weekday !== undefined && tokens[1]) {
+    const parsed = parseClock(tokens[1]);
+    if (!parsed)
+      return null;
+    let days = (weekday - now.getDay() + 7) % 7;
+    let executeAt = atLocalDate(now, days, parsed.hour, parsed.minute);
+    if (days === 0 && executeAt.getTime() <= now.getTime()) {
+      days = 7;
+      executeAt = atLocalDate(now, days, parsed.hour, parsed.minute);
+    }
+    return { executeAt, messageStartIndex: 2 };
+  }
+  return null;
+}
+function parseClock(value) {
+  const match = /^(\d{1,2}):(\d{2})$/.exec(value);
+  if (!match)
+    return null;
+  const hour = Number(match[1]);
+  const minute = Number(match[2]);
+  if (hour < 0 || hour > 23 || minute < 0 || minute > 59)
+    return null;
+  return { hour, minute };
+}
+function atLocalDate(now, dayOffset, hour, minute) {
+  return new Date(now.getFullYear(), now.getMonth(), now.getDate() + dayOffset, hour, minute, 0, 0);
+}
+function validateResult(executeAt, messageStartIndex, tokens, now, pastTodayValue) {
+  if (pastTodayValue)
+    return { ok: false, code: "past_today_time", value: pastTodayValue };
+  if (tokens.slice(messageStartIndex).join(" ").trim().length === 0)
+    return { ok: false, code: "missing_message" };
+  const delta = executeAt.getTime() - now.getTime();
+  if (delta < LATER_MIN_DELAY_MS)
+    return { ok: false, code: "too_soon" };
+  if (delta > LATER_MAX_DELAY_MS)
+    return { ok: false, code: "out_of_range" };
+  return { ok: true, executeAt, messageStartIndex };
+}
+var WEEKDAYS;
+var init_parse_later_time = __esm(() => {
+  init_scheduled_types();
+  WEEKDAYS = new Map([
+    ["周日", 0],
+    ["周天", 0],
+    ["星期日", 0],
+    ["星期天", 0],
+    ["sun", 0],
+    ["sunday", 0],
+    ["周一", 1],
+    ["星期一", 1],
+    ["mon", 1],
+    ["monday", 1],
+    ["周二", 2],
+    ["星期二", 2],
+    ["tue", 2],
+    ["tuesday", 2],
+    ["周三", 3],
+    ["星期三", 3],
+    ["wed", 3],
+    ["wednesday", 3],
+    ["周四", 4],
+    ["星期四", 4],
+    ["thu", 4],
+    ["thursday", 4],
+    ["周五", 5],
+    ["星期五", 5],
+    ["fri", 5],
+    ["friday", 5],
+    ["周六", 6],
+    ["星期六", 6],
+    ["sat", 6],
+    ["saturday", 6]
+  ]);
+});
+
+// src/scheduled/scheduled-render.ts
+function renderLaterHelp() {
+  return [
+    "定时任务用法：",
+    "",
+    "创建：",
+    "/lt in 2h 检查 CI",
+    "/lt 30分钟后 总结进展",
+    "/lt tomorrow 09:00 看 PR",
+    "/lt 周五 09:00 继续处理",
+    "",
+    "查看：",
+    "/lt list",
+    "",
+    "取消：",
+    "/lt cancel <id>",
+    "",
+    "说明：",
+    "- 只支持一次性任务",
+    "- 时间必须在 10 秒之后、7 天之内",
+    "- 到点后会把消息发送到创建时绑定的会话",
+    "- 触发通知和 agent 回复复用现有频道路由；微信回复额度由现有路由控制",
+    "- 不支持延迟执行 / 开头的 weacpx 命令",
+    "- 完整时间格式与说明见 docs/later-command.md"
+  ].join(`
+`);
+}
+function renderLaterUnsupportedChannel() {
+  return [
+    "当前频道暂不支持定时任务，未创建任务。",
+    "",
+    "原因：这个频道还没有实现定时消息投递能力，任务到点后无法把结果发回原聊天。",
+    "请切换到支持定时任务的频道后再使用 /lt。"
+  ].join(`
+`);
+}
+function renderTaskCreated(task, displaySession) {
+  return [
+    `已创建定时任务 #${task.id}`,
+    `执行时间：${formatLocalDateTime(new Date(task.execute_at))}`,
+    `会话：${displaySession}`,
+    `内容：${preview(task.message)}`
+  ].join(`
+`);
+}
+function renderLaterList(tasks, displaySession) {
+  if (tasks.length === 0)
+    return "当前没有待执行定时任务。";
+  return [
+    "待执行定时任务：",
+    "",
+    ...tasks.flatMap((task) => [
+      `#${task.id}  ${formatLocalDateTime(new Date(task.execute_at))}  会话：${displaySession(task.session_alias)}`,
+      preview(task.message),
+      ""
+    ])
+  ].join(`
+`).trimEnd();
+}
+function preview(text) {
+  return text.length <= LATER_MESSAGE_PREVIEW_CHARS ? text : `${text.slice(0, LATER_MESSAGE_PREVIEW_CHARS - 1)}…`;
+}
+function formatLocalDateTime(date4) {
+  const weekdays = ["周日", "周一", "周二", "周三", "周四", "周五", "周六"];
+  const pad = (value) => String(value).padStart(2, "0");
+  return `${date4.getFullYear()}-${pad(date4.getMonth() + 1)}-${pad(date4.getDate())} ${weekdays[date4.getDay()]} ${pad(date4.getHours())}:${pad(date4.getMinutes())}`;
+}
+var init_scheduled_render = __esm(() => {
+  init_scheduled_types();
+});
+
+// src/commands/handlers/later-handler.ts
+function handleLaterHelp() {
+  return { text: renderLaterHelp() };
+}
+async function handleLaterCreate(tokens, scheduled, chatKey, currentSessionAlias, accountId, replyContextToken) {
+  if (!currentSessionAlias) {
+    return {
+      text: [
+        "当前没有会话，无法创建定时任务。",
+        "",
+        "请先创建或切换到一个会话：",
+        "- /ss codex --ws backend（新建并切换）",
+        "- /use backend-codex（切换到已有会话）"
+      ].join(`
+`)
+    };
+  }
+  const result = parseLaterTime(tokens);
+  if (!result.ok) {
+    return { text: renderTimeParseError(result.code, result.value) };
+  }
+  const message = tokens.slice(result.messageStartIndex).join(" ").trim();
+  if (message.startsWith("/")) {
+    return {
+      text: [
+        "不支持延迟执行 / 开头的命令。",
+        "",
+        "如果需要让 agent 解释命令，可以用自然语言描述：",
+        "例如：/lt in 1h 请解释 /status 的作用"
+      ].join(`
+`)
+    };
+  }
+  const task = await scheduled.createTask({
+    chatKey,
+    sessionAlias: currentSessionAlias,
+    executeAt: result.executeAt,
+    message,
+    ...accountId ? { accountId } : {},
+    ...replyContextToken ? { replyContextToken } : {}
+  });
+  return { text: renderTaskCreated(task, toDisplaySessionAlias(currentSessionAlias)) };
+}
+function handleLaterList(scheduled) {
+  const tasks = scheduled.listPending();
+  return { text: renderLaterList(tasks, (alias) => toDisplaySessionAlias(alias)) };
+}
+async function handleLaterCancel(id, scheduled) {
+  const ok = await scheduled.cancelPending(id);
+  if (ok) {
+    return { text: `已取消定时任务 #${id.replace(/^#/, "").toLowerCase()}` };
+  }
+  const displayId = id.replace(/^#/, "").toLowerCase();
+  return { text: [`未找到待执行的定时任务 #${displayId}。`, "可以用 /lt list 查看当前待执行任务。"].join(`
+`) };
+}
+function renderTimeParseError(code, value) {
+  switch (code) {
+    case "missing_message":
+      return "定时任务需要消息内容，请在时间后附上要发送的内容。";
+    case "too_soon":
+      return "定时任务执行时间必须在 10 秒之后。";
+    case "out_of_range":
+      return "定时任务执行时间不能超过 7 天。";
+    case "past_today_time":
+      return `今天 ${value} 已经过了，请指定一个未来的时间，或使用「明天」。`;
+    case "unrecognized_time":
+    case "missing_time":
+    default:
+      return [
+        "无法识别时间格式。",
+        "",
+        "支持的格式：",
+        "- /lt in 2h 消息（2小时后）",
+        "- /lt 30分钟后 消息",
+        "- /lt tomorrow 09:00 消息",
+        "- /lt 周五 09:00 消息"
+      ].join(`
+`);
+  }
+}
+var laterHelpMetadata;
+var init_later_handler = __esm(() => {
+  init_parse_later_time();
+  init_scheduled_render();
+  init_channel_scope();
+  laterHelpMetadata = {
+    topic: "later",
+    aliases: ["lt"],
+    summary: "定时任务：延时发送消息到当前会话",
+    commands: [
+      { usage: "/lt <时间> <消息>", description: "创建定时任务" },
+      { usage: "/lt list", description: "查看待执行定时任务" },
+      { usage: "/lt cancel <id>", description: "取消定时任务" }
+    ],
+    examples: [
+      "/lt in 2h 检查 CI",
+      "/lt 30分钟后 总结进展",
+      "/lt tomorrow 09:00 看 PR",
+      "/lt 今天 21:30 继续处理",
+      "/lt 周五 09:00 继续处理"
+    ],
+    notes: [
+      "只支持一次性任务，不支持重复执行",
+      "时间必须在 10 秒之后、7 天之内",
+      "到点后会把消息发送到创建时绑定的会话（不随之后 /use 切换而改变）",
+      "/lt list 显示全局待执行任务；群聊中只有群主可取消",
+      "不支持延迟执行 / 开头的 weacpx 命令",
+      "完整时间格式与说明见 docs/later-command.md"
+    ]
+  };
+});
+
 // src/commands/help/help-registry.ts
 function getHelpTopic(topic) {
   return HELP_TOPIC_MAP.get(topic) ?? null;
@@ -18740,6 +19304,7 @@ var init_help_registry = __esm(() => {
   init_permission_handler();
   init_session_handler();
   init_workspace_handler();
+  init_later_handler();
   HELP_TOPICS = [
     sessionHelp,
     workspaceHelp,
@@ -18750,7 +19315,8 @@ var init_help_registry = __esm(() => {
     modeHelp,
     replyModeHelp,
     statusHelp,
-    cancelHelp
+    cancelHelp,
+    laterHelpMetadata
   ];
   HELP_TOPIC_MAP = new Map;
   for (const topic of HELP_TOPICS) {
@@ -18797,7 +19363,8 @@ function renderHelpTopic(topic) {
     "",
     "命令：",
     ...topic.commands.map((command) => `- ${command.usage} - ${command.description}`),
-    ...topic.examples && topic.examples.length > 0 ? ["", "示例：", ...topic.examples.map((example) => `- ${example}`)] : []
+    ...topic.examples && topic.examples.length > 0 ? ["", "示例：", ...topic.examples.map((example) => `- ${example}`)] : [],
+    ...topic.notes && topic.notes.length > 0 ? ["", "注意：", ...topic.notes.map((note) => `- ${note}`)] : []
   ].join(`
 `);
 }
@@ -19448,6 +20015,8 @@ class CommandRouter {
   resolveSessionAgentCommand;
   orchestration;
   quota;
+  scheduled;
+  scheduledDelivery;
   logger;
   autoInstall = autoInstallOptionalDep;
   discoverPaths = discoverParentPackagePaths;
@@ -19457,7 +20026,7 @@ class CommandRouter {
   __setDiscoverPathsForTest(fn) {
     this.discoverPaths = fn;
   }
-  constructor(sessions, transport, config2, configStore, logger2, resolveSessionAgentCommand = resolveSessionAgentCommandFromIndex, orchestration, quota) {
+  constructor(sessions, transport, config2, configStore, logger2, resolveSessionAgentCommand = resolveSessionAgentCommandFromIndex, orchestration, quota, scheduled, scheduledDelivery) {
     this.sessions = sessions;
     this.transport = transport;
     this.config = config2;
@@ -19465,6 +20034,8 @@ class CommandRouter {
     this.resolveSessionAgentCommand = resolveSessionAgentCommand;
     this.orchestration = orchestration;
     this.quota = quota;
+    this.scheduled = scheduled;
+    this.scheduledDelivery = scheduledDelivery;
     this.logger = logger2 ?? createNoopAppLogger();
   }
   async handle(chatKey, input, reply, replyContextToken, accountId, media, metadata, abortSignal, onToolEvent, onThought, perfSpan) {
@@ -19585,8 +20156,38 @@ class CommandRouter {
           return await handleTaskReject(this.createHandlerContext(), chatKey, command.taskId);
         case "task.cancel":
           return await handleTaskCancel(this.createHandlerContext(), chatKey, command.taskId);
-        case "prompt":
-          return await handlePrompt(this.createSessionHandlerContext(undefined, perfSpan), chatKey, command.text, reply, replyContextToken, accountId, media, abortSignal, onToolEvent, onThought, perfSpan);
+        case "later.help":
+          if (!this.scheduled)
+            return { text: "定时任务服务未启用。" };
+          return handleLaterHelp();
+        case "later.list":
+          if (!this.scheduled)
+            return { text: "定时任务服务未启用。" };
+          return handleLaterList(this.scheduled);
+        case "later.create": {
+          if (!this.scheduled)
+            return { text: "定时任务服务未启用。" };
+          if (this.scheduledDelivery && !this.scheduledDelivery.supportsScheduledMessages(chatKey)) {
+            return { text: renderLaterUnsupportedChannel() };
+          }
+          const currentSession = await this.sessions.getCurrentSession(chatKey);
+          return await handleLaterCreate(command.tokens, this.scheduled, chatKey, currentSession?.alias ?? null, accountId, replyContextToken);
+        }
+        case "later.cancel":
+          if (!this.scheduled)
+            return { text: "定时任务服务未启用。" };
+          return await handleLaterCancel(command.id, this.scheduled);
+        case "prompt": {
+          const sessionContext = this.createSessionHandlerContext(undefined, perfSpan);
+          if (metadata?.scheduledSessionAlias) {
+            const scheduledSession = await this.sessions.getSession(metadata.scheduledSessionAlias);
+            if (!scheduledSession) {
+              throw new Error(`session "${metadata.scheduledSessionAlias}" not found for scheduled prompt`);
+            }
+            return await handlePromptWithSession(sessionContext, scheduledSession, chatKey, command.text, reply, replyContextToken, accountId, media, abortSignal, onToolEvent, onThought, perfSpan);
+          }
+          return await handlePrompt(sessionContext, chatKey, command.text, reply, replyContextToken, accountId, media, abortSignal, onToolEvent, onThought, perfSpan);
+        }
       }
     });
   }
@@ -19964,11 +20565,13 @@ var init_command_router = __esm(() => {
   init_agent_handler();
   init_workspace_handler();
   init_session_shortcut_handler();
+  init_later_handler();
   init_session_recovery_handler();
   init_auto_install_optional_dep();
   init_discover_parent_package_paths();
   init_errors();
   init_session_reset_handler();
+  init_scheduled_render();
 });
 
 // src/config/resolve-acpx-command.ts
@@ -23965,6 +24568,220 @@ function buildWorkerAnswerPrompt(answer) {
 `);
 }
 
+// src/scheduled/scheduled-scheduler.ts
+class ScheduledTaskScheduler {
+  service;
+  intervalMs;
+  dispatchTimeoutMs;
+  setIntervalFn;
+  clearIntervalFn;
+  dispatchTask;
+  logger;
+  intervalHandle = null;
+  ticking = false;
+  constructor(service, deps) {
+    this.service = service;
+    this.dispatchTask = deps.dispatchTask;
+    this.intervalMs = deps.intervalMs ?? 5000;
+    this.dispatchTimeoutMs = deps.dispatchTimeoutMs ?? DEFAULT_DISPATCH_TIMEOUT_MS;
+    this.setIntervalFn = deps.setIntervalFn ?? ((fn, delay) => setInterval(fn, delay));
+    this.clearIntervalFn = deps.clearIntervalFn ?? ((timer) => clearInterval(timer));
+    this.logger = deps.logger;
+  }
+  async start() {
+    if (this.intervalHandle !== null)
+      return;
+    await this.service.markStartupMissed();
+    this.intervalHandle = this.setIntervalFn(() => {
+      this.tick();
+    }, this.intervalMs);
+    await this.tick();
+  }
+  stop() {
+    if (this.intervalHandle !== null) {
+      this.clearIntervalFn(this.intervalHandle);
+      this.intervalHandle = null;
+    }
+  }
+  async tick() {
+    if (this.ticking)
+      return;
+    this.ticking = true;
+    try {
+      const dueTasks = await this.service.claimDueTasks();
+      for (const task of dueTasks) {
+        try {
+          await this.dispatchWithTimeout(task);
+          await this.service.markExecuted(task.id);
+        } catch (error2) {
+          const message = error2 instanceof Error ? error2.message : String(error2);
+          await this.logger?.error("scheduled.dispatch.failed", "failed to dispatch scheduled task", {
+            taskId: task.id,
+            message
+          });
+          await this.service.markFailed(task.id, error2);
+        }
+      }
+    } finally {
+      this.ticking = false;
+    }
+  }
+  async dispatchWithTimeout(task) {
+    const controller = new AbortController;
+    let timer;
+    const timeout = new Promise((_resolve, reject) => {
+      timer = setTimeout(() => {
+        reject(new Error(`scheduled task dispatch timed out after ${this.dispatchTimeoutMs}ms`));
+        controller.abort();
+      }, this.dispatchTimeoutMs);
+    });
+    const dispatch = this.dispatchTask(task, controller.signal);
+    dispatch.catch(() => {});
+    try {
+      await Promise.race([dispatch, timeout]);
+    } finally {
+      if (timer !== undefined)
+        clearTimeout(timer);
+    }
+  }
+}
+var DEFAULT_DISPATCH_TIMEOUT_MS;
+var init_scheduled_scheduler = __esm(() => {
+  DEFAULT_DISPATCH_TIMEOUT_MS = 10 * 60 * 1000;
+});
+
+// src/scheduled/scheduled-service.ts
+class ScheduledTaskService {
+  state;
+  stateStore;
+  now;
+  generateId;
+  stateMutex;
+  claimedInThisSession = new Set;
+  constructor(state, stateStore, options) {
+    this.state = state;
+    this.stateStore = stateStore;
+    this.now = options?.now ?? (() => new Date);
+    this.generateId = options?.generateId ?? (() => Math.random().toString(36).slice(2, 6));
+    this.stateMutex = options?.stateMutex ?? new AsyncMutex;
+  }
+  async createTask(input) {
+    return await this.mutate(async () => {
+      const id = this.nextId();
+      const task = {
+        id,
+        chat_key: input.chatKey,
+        session_alias: input.sessionAlias,
+        execute_at: input.executeAt.toISOString(),
+        message: input.message,
+        status: "pending",
+        created_at: this.now().toISOString(),
+        ...input.accountId ? { account_id: input.accountId } : {},
+        ...input.replyContextToken ? { reply_context_token: input.replyContextToken } : {},
+        ...input.sourceLabel ? { source_label: input.sourceLabel } : {}
+      };
+      this.state.scheduled_tasks[id] = task;
+      await this.save();
+      return task;
+    });
+  }
+  listPending() {
+    return Object.values(this.state.scheduled_tasks).filter((task) => task.status === "pending").sort((left, right) => left.execute_at.localeCompare(right.execute_at));
+  }
+  async cancelPending(inputId) {
+    return await this.mutate(async () => {
+      const id = normalizeId(inputId);
+      const task = this.state.scheduled_tasks[id];
+      if (!task || task.status !== "pending")
+        return false;
+      task.status = "cancelled";
+      task.cancelled_at = this.now().toISOString();
+      await this.save();
+      return true;
+    });
+  }
+  async markStartupMissed() {
+    await this.mutate(async () => {
+      const nowMs = this.now().getTime();
+      let changed = false;
+      for (const task of Object.values(this.state.scheduled_tasks)) {
+        if (task.status === "pending" && Date.parse(task.execute_at) < nowMs) {
+          task.status = "missed";
+          task.missed_at = this.now().toISOString();
+          changed = true;
+        }
+        if (task.status === "triggering" && !this.claimedInThisSession.has(task.id)) {
+          task.status = "failed";
+          task.failed_at = this.now().toISOString();
+          task.last_error = "process stopped while task was triggering";
+          changed = true;
+        }
+      }
+      if (changed)
+        await this.save();
+    });
+  }
+  async claimDueTasks() {
+    return await this.mutate(async () => {
+      const nowMs = this.now().getTime();
+      const due = this.listPending().filter((task) => Date.parse(task.execute_at) <= nowMs);
+      if (due.length === 0)
+        return [];
+      const at = this.now().toISOString();
+      for (const task of due) {
+        task.status = "triggering";
+        task.triggered_at = at;
+        this.claimedInThisSession.add(task.id);
+      }
+      await this.save();
+      return due.map((task) => ({ ...task }));
+    });
+  }
+  async markExecuted(id) {
+    await this.mutate(async () => {
+      const taskId = normalizeId(id);
+      const task = this.state.scheduled_tasks[taskId];
+      if (!task)
+        return;
+      task.status = "executed";
+      task.executed_at = this.now().toISOString();
+      this.claimedInThisSession.delete(taskId);
+      await this.save();
+    });
+  }
+  async markFailed(id, error2) {
+    await this.mutate(async () => {
+      const taskId = normalizeId(id);
+      const task = this.state.scheduled_tasks[taskId];
+      if (!task)
+        return;
+      task.status = "failed";
+      task.failed_at = this.now().toISOString();
+      task.last_error = error2 instanceof Error ? error2.message : String(error2);
+      this.claimedInThisSession.delete(taskId);
+      await this.save();
+    });
+  }
+  nextId() {
+    for (let attempt = 0;attempt < 20; attempt += 1) {
+      const id = normalizeId(this.generateId()).replace(/[^0-9a-z]/g, "").slice(0, 6);
+      if (id.length >= 4 && !this.state.scheduled_tasks[id])
+        return id;
+    }
+    throw new Error("failed to generate unique scheduled task id");
+  }
+  async mutate(critical) {
+    return await this.stateMutex.run(critical);
+  }
+  async save() {
+    await this.stateStore.save(this.state);
+  }
+}
+function normalizeId(input) {
+  return input.trim().replace(/^#/, "").toLowerCase();
+}
+var init_scheduled_service = () => {};
+
 // src/sessions/session-service.ts
 class SessionService {
   config;
@@ -24419,20 +25236,47 @@ async function runConsole(paths, deps) {
         runtimeForGc.orchestration.service.purgeExpiredResetCoordinators({ cutoffDays: 7, trigger: "interval" }).catch(() => {});
       }, 86400000);
     }
+    const channelStartPromise = deps.channels.startAll({
+      agent: runtime.agent,
+      abortSignal: shutdownController.signal,
+      quota: runtime.quota,
+      logger: runtime.logger,
+      perfTracer: runtime.perfTracer
+    });
+    channelStartPromise.catch(() => {});
+    let channelStartSettled = false;
+    let channelStartError;
+    channelStartPromise.then(() => {
+      channelStartSettled = true;
+    }, (error2) => {
+      channelStartSettled = true;
+      channelStartError = error2;
+    });
+    await Promise.resolve();
+    if (channelStartSettled && channelStartError) {
+      if (deps.channelStartupPolicy !== "best-effort") {
+        throw channelStartError;
+      }
+      await runtime.logger.error("daemon.channels.start_failed", "all channels failed to start; daemon remains alive for orchestration IPC", { error: channelStartError instanceof Error ? channelStartError.message : String(channelStartError) });
+      await waitForShutdown(shutdownController.signal);
+      return;
+    }
     try {
-      await deps.channels.startAll({
-        agent: runtime.agent,
-        abortSignal: shutdownController.signal,
-        quota: runtime.quota,
-        logger: runtime.logger,
-        perfTracer: runtime.perfTracer
-      });
+      await runtime.scheduled.scheduler.start();
+    } catch (error2) {
+      shutdownController.abort();
+      throw error2;
+    }
+    try {
+      await channelStartPromise;
     } catch (error2) {
+      runtime.scheduled.scheduler.stop();
       if (deps.channelStartupPolicy !== "best-effort") {
         throw error2;
       }
       await runtime.logger.error("daemon.channels.start_failed", "all channels failed to start; daemon remains alive for orchestration IPC", { error: error2 instanceof Error ? error2.message : String(error2) });
       await waitForShutdown(shutdownController.signal);
+      return;
     }
   } finally {
     await runCleanupSequence({
@@ -26435,6 +27279,21 @@ class MessageChannelRegistry {
   async sendCoordinatorMessage(input) {
     await this.requireByChatKey(input.chatKey).sendCoordinatorMessage(input);
   }
+  supportsScheduledMessages(chatKey) {
+    const [candidateChannelId] = chatKey.split(":", 1);
+    if (chatKey.includes(":") && candidateChannelId && !this.channels.has(candidateChannelId)) {
+      return false;
+    }
+    const channel = this.getByChatKey(chatKey);
+    return !!channel?.sendScheduledMessage;
+  }
+  async sendScheduledMessage(input) {
+    const channel = this.requireByChatKey(input.chatKey);
+    if (!channel.sendScheduledMessage) {
+      throw new Error(`channel '${channel.id}' does not support scheduled messages`);
+    }
+    await channel.sendScheduledMessage(input);
+  }
   createConsumerLocks() {
     const result = [];
     for (const channel of this.channels.values()) {
@@ -26649,6 +27508,7 @@ async function buildApp(paths, deps = {}) {
     }
   });
   const sessions = new SessionService(config2, debouncedStateStore, state, { stateMutex });
+  const scheduledService = new ScheduledTaskService(state, debouncedStateStore, { stateMutex });
   const pendingWorkerDispatches = new Set;
   const transport = config2.transport.type === "acpx-bridge" ? await (deps.createBridgeTransport?.() ?? Promise.resolve(new AcpxBridgeTransport(await spawnAcpxBridgeClient({
     acpxCommand,
@@ -27008,8 +27868,33 @@ async function buildApp(paths, deps = {}) {
   const progressHeartbeatInterval = startProgressHeartbeat(orchestration, config2, logger2, deps.channel ?? null);
   const orchestrationEndpoint = createOrchestrationEndpoint(paths.orchestrationSocketPath ?? resolveOrchestrationSocketPathFromConfigPath(paths.configPath));
   const orchestrationServer = new OrchestrationServer(orchestrationEndpoint, orchestration);
-  const router = new CommandRouter(sessions, transport, config2, configStore, logger2, undefined, orchestration, quota);
+  const router = new CommandRouter(sessions, transport, config2, configStore, logger2, undefined, orchestration, quota, scheduledService, deps.channel?.supportsScheduledMessages ? { supportsScheduledMessages: deps.channel.supportsScheduledMessages.bind(deps.channel) } : undefined);
   const agent = new ConsoleAgent(router, logger2);
+  const scheduledScheduler = new ScheduledTaskScheduler(scheduledService, {
+    dispatchTask: async (task, abortSignal) => {
+      const session = await sessions.getSession(task.session_alias);
+      if (!session) {
+        throw new Error(`session "${task.session_alias}" not found for scheduled task`);
+      }
+      const noticeText = `执行定时任务 #${task.id}
+会话：${toDisplaySessionAlias(task.session_alias)}
+内容：${preview(task.message)}`;
+      if (!deps.channel?.sendScheduledMessage) {
+        throw new Error("no channel runtime available for scheduled task dispatch");
+      }
+      await deps.channel.sendScheduledMessage({
+        chatKey: task.chat_key,
+        taskId: task.id,
+        sessionAlias: task.session_alias,
+        noticeText,
+        promptText: task.message,
+        abortSignal,
+        ...task.account_id ? { accountId: task.account_id } : {},
+        ...task.reply_context_token ? { replyContextToken: task.reply_context_token } : {}
+      });
+    },
+    logger: logger2
+  });
   return {
     agent,
     router,
@@ -27025,7 +27910,12 @@ async function buildApp(paths, deps = {}) {
       server: orchestrationServer,
       endpoint: orchestrationEndpoint
     },
+    scheduled: {
+      service: scheduledService,
+      scheduler: scheduledScheduler
+    },
     dispose: async () => {
+      scheduledScheduler.stop();
       if (progressHeartbeatInterval !== undefined) {
         clearInterval(progressHeartbeatInterval);
       }
@@ -27078,6 +27968,7 @@ function replaceRuntimeState(target, source) {
   target.sessions = source.sessions;
   target.chat_contexts = source.chat_contexts;
   target.orchestration = source.orchestration;
+  target.scheduled_tasks = source.scheduled_tasks;
 }
 function replaceRuntimeConfig(target, source) {
   Object.assign(target, source);
@@ -27172,6 +28063,10 @@ var init_main = __esm(async () => {
   init_orchestration_server();
   init_orchestration_service();
   init_build_coordinator_prompt();
+  init_scheduled_scheduler();
+  init_scheduled_service();
+  init_scheduled_render();
+  init_channel_scope();
   init_session_service();
   init_state_store();
   init_run_console();

package/dist/plugin-api.d.ts

@@ -1,6 +1,6 @@
 export type { ChannelPluginDefinition } from "./channels/plugin.js";
 export type { ChannelFactory, CreateChannelDeps } from "./channels/create-channel.js";
-export type { ChannelStartInput, ConsumerLock, ConsumerLockMetadata, ConsumerLockOptions, CoordinatorMessageInput, MessageChannelRuntime, OrchestrationDeliveryCallbacks, OutboundQuota, ToolUseEvent, ToolUseKind, ToolUseStatus, } from "./channels/types.js";
+export type { ChannelStartInput, ConsumerLock, ConsumerLockMetadata, ConsumerLockOptions, CoordinatorMessageInput, MessageChannelRuntime, ScheduledChannelMessageInput, OrchestrationDeliveryCallbacks, OutboundQuota, ToolUseEvent, ToolUseKind, ToolUseStatus, } from "./channels/types.js";
 export type { ChannelCliInput, ChannelCliIo, ChannelCliParseResult, ChannelCliProvider, ChannelCliValidationIssue, } from "./channels/cli/provider.js";
 export type { ChannelRuntimeConfig } from "./config/types.js";
 export type { AppLogger } from "./logging/app-logger.js";

package/dist/plugin-api.js

@@ -160,7 +160,7 @@ function validatePluginCompatibility(metadata, context) {
     }
   }
 }
-var WEACPX_PLUGIN_API_VERSION = 1, WEACPX_PLUGIN_API_SUPPORTED_VERSIONS, WEACPX_PLUGIN_MIN_CORE_VERSION = "0.4.0", SEMVER_RE;
+var WEACPX_PLUGIN_API_VERSION = 1, WEACPX_PLUGIN_API_SUPPORTED_VERSIONS, WEACPX_PLUGIN_MIN_CORE_VERSION = "0.5.0", SEMVER_RE;
 var init_compatibility = __esm(() => {
   WEACPX_PLUGIN_API_SUPPORTED_VERSIONS = [1];
   SEMVER_RE = /^(\d+)\.(\d+)\.(\d+)$/;

package/dist/plugins/compatibility.d.ts

@@ -1,6 +1,6 @@
 export declare const WEACPX_PLUGIN_API_VERSION: 1;
 export declare const WEACPX_PLUGIN_API_SUPPORTED_VERSIONS: readonly number[];
-export declare const WEACPX_PLUGIN_MIN_CORE_VERSION: "0.4.0";
+export declare const WEACPX_PLUGIN_MIN_CORE_VERSION: "0.5.0";
 export declare function normalizeCoreVersionForCompat(version: string): string;
 export declare function compareSemver(a: string, b: string): -1 | 0 | 1;
 export declare function isVersionSatisfied(current: string, requirement: string): boolean;

package/dist/weixin/agent/interface.d.ts

@@ -62,6 +62,8 @@ export interface ChatRequestMetadata {
     senderName?: string;
     groupId?: string;
     isOwner?: boolean;
+    /** Internal weacpx session alias to use for non-interactive scheduled prompts. */
+    scheduledSessionAlias?: string;
 }
 export interface ChatResponse {
     /**

package/dist/weixin/messaging/scheduled-turn.d.ts

@@ -0,0 +1,22 @@
+import type { AppLogger } from "../../logging/app-logger";
+import type { ScheduledChannelMessageInput } from "../../channels/types";
+import type { Agent } from "../agent/interface";
+import type { PendingFinalChunk } from "./quota-manager";
+import { sendMessageWeixin } from "./send";
+export interface ScheduledTurnDeps {
+    agent: Agent;
+    listAccountIds: () => string[];
+    resolveAccount: (accountId: string) => {
+        accountId: string;
+        baseUrl: string;
+        token?: string;
+    };
+    getContextToken: (accountId: string, userId: string) => string | undefined;
+    reserveMidSegment: (chatKey: string) => boolean;
+    reserveFinal: (chatKey: string) => boolean;
+    finalRemaining?: (chatKey: string) => number;
+    enqueuePendingFinal?: (chatKey: string, chunks: PendingFinalChunk[]) => void;
+    sendMessage?: typeof sendMessageWeixin;
+    logger: AppLogger;
+}
+export declare function executeScheduledTurn(input: ScheduledChannelMessageInput, deps: ScheduledTurnDeps): Promise<void>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "weacpx",
-  "version": "0.4.10",
+  "version": "0.5.0",
   "description": "使用微信 ClawBot 随时随地通过 `acpx` 控制 Claude Code、Codex 等 Agents。",
   "keywords": [
     "acpx",