weacpx 0.4.10 → 0.5.1

package/dist/cli.js

@@ -2317,6 +2317,7 @@ function parseConfig(raw, options = {}) {
   const channelConfig = parseChannelConfig(channel, legacyWechat);
   const channelsConfig = parseRuntimeChannels(raw.channels, channelConfig);
   const orchestrationConfig = parseOrchestrationConfig(orchestration);
+  const laterConfig = parseLaterConfig(raw.later);
   const plugins = parsePlugins(raw.plugins);
   return {
     transport: {
@@ -2348,7 +2349,8 @@ function parseConfig(raw, options = {}) {
     plugins,
     agents,
     workspaces,
-    orchestration: orchestrationConfig
+    orchestration: orchestrationConfig,
+    later: laterConfig
   };
 }
 function parsePluginConfig(raw, index) {
@@ -2437,6 +2439,11 @@ function parseRuntimeChannels(rawChannels, channel) {
     }
   ];
 }
+function parseLaterConfig(raw) {
+  if (!isRecord(raw))
+    return { ...DEFAULT_LATER_CONFIG };
+  return raw.defaultMode === "bind" ? { defaultMode: "bind" } : { ...DEFAULT_LATER_CONFIG };
+}
 function parseOrchestrationConfig(raw) {
   if (!isRecord(raw)) {
     return {
@@ -2452,7 +2459,7 @@ function parseOrchestrationConfig(raw) {
     maxParallelTasksPerAgent: typeof raw.maxParallelTasksPerAgent === "number" && Number.isFinite(raw.maxParallelTasksPerAgent) && raw.maxParallelTasksPerAgent >= 1 ? Math.floor(raw.maxParallelTasksPerAgent) : DEFAULT_ORCHESTRATION_CONFIG.maxParallelTasksPerAgent
   };
 }
-var DEFAULT_PERF_LOG_CONFIG, DEFAULT_LOGGING_CONFIG, DEFAULT_PERMISSION_MODE = "approve-all", DEFAULT_NON_INTERACTIVE_PERMISSIONS = "deny", DEFAULT_QUEUE_OWNER_TTL_SECONDS = 1800, DEFAULT_CHANNEL_CONFIG, DEFAULT_ORCHESTRATION_CONFIG;
+var DEFAULT_PERF_LOG_CONFIG, DEFAULT_LOGGING_CONFIG, DEFAULT_PERMISSION_MODE = "approve-all", DEFAULT_NON_INTERACTIVE_PERMISSIONS = "deny", DEFAULT_QUEUE_OWNER_TTL_SECONDS = 1800, DEFAULT_CHANNEL_CONFIG, DEFAULT_ORCHESTRATION_CONFIG, DEFAULT_LATER_CONFIG;
 var init_load_config = __esm(() => {
   init_workspace_path();
   DEFAULT_PERF_LOG_CONFIG = {
@@ -2480,6 +2487,9 @@ var init_load_config = __esm(() => {
     progressHeartbeatSeconds: 300,
     maxParallelTasksPerAgent: 3
   };
+  DEFAULT_LATER_CONFIG = {
+    defaultMode: "temp"
+  };
 });
 
 // src/config/config-store.ts
@@ -2547,6 +2557,15 @@ var init_config_store = __esm(() => {
   init_load_config();
 });
 
+// src/config/default-workspace.ts
+var DEFAULT_HOME_WORKSPACE_NAME = "home", DEFAULT_HOME_WORKSPACE;
+var init_default_workspace = __esm(() => {
+  DEFAULT_HOME_WORKSPACE = {
+    cwd: "~",
+    description: "用户主目录"
+  };
+});
+
 // src/config/ensure-config.ts
 import { readFile as readFile2 } from "node:fs/promises";
 async function ensureConfigExists(path2, options = {}) {
@@ -2601,7 +2620,9 @@ function normalizeDefaultConfigTemplate(raw) {
         ...resolveAgentCommand(agent.driver, agent.command) ? { command: resolveAgentCommand(agent.driver, agent.command) } : {}
       }
     ])),
-    workspaces: {}
+    workspaces: {
+      [DEFAULT_HOME_WORKSPACE_NAME]: { ...DEFAULT_HOME_WORKSPACE }
+    }
   };
 }
 function isMissingFileError(error) {
@@ -2610,6 +2631,7 @@ function isMissingFileError(error) {
 var BUILTIN_DEFAULT_CONFIG_TEMPLATE;
 var init_ensure_config = __esm(() => {
   init_config_store();
+  init_default_workspace();
   init_load_config();
   BUILTIN_DEFAULT_CONFIG_TEMPLATE = {
     transport: {
@@ -2638,7 +2660,9 @@ var init_ensure_config = __esm(() => {
       codex: { driver: "codex" },
       claude: { driver: "claude" }
     },
-    workspaces: {},
+    workspaces: {
+      [DEFAULT_HOME_WORKSPACE_NAME]: { ...DEFAULT_HOME_WORKSPACE }
+    },
     plugins: []
   };
 });
@@ -9735,7 +9759,8 @@ function createEmptyState() {
   return {
     sessions: {},
     chat_contexts: {},
-    orchestration: createEmptyOrchestrationState()
+    orchestration: createEmptyOrchestrationState(),
+    scheduled_tasks: {}
   };
 }
 var init_types = () => {};
@@ -9831,7 +9856,7 @@ function isCoordinatorRouteContextRecord(value) {
   if (!isRecord2(value)) {
     return false;
   }
-  return isString(value.coordinatorSession) && isString(value.chatKey) && isOptionalString(value.accountId) && isOptionalString(value.replyContextToken) && isString(value.updatedAt);
+  return isString(value.coordinatorSession) && isString(value.chatKey) && isOptionalString(value.sessionAlias) && isOptionalString(value.accountId) && isOptionalString(value.replyContextToken) && isOptionalString(value.channel) && (value.chatType === undefined || value.chatType === "direct" || value.chatType === "group") && isOptionalString(value.senderId) && isOptionalString(value.senderName) && isOptionalString(value.groupId) && isOptionalBoolean(value.isOwner) && isString(value.updatedAt);
 }
 function isHumanQuestionPackageMessageRecord(value) {
   if (!isRecord2(value)) {
@@ -9981,6 +10006,32 @@ function parseChatContexts(raw, path3) {
   }
   return chatContexts;
 }
+function isScheduledTaskStatus(value) {
+  return value === "pending" || value === "triggering" || value === "executed" || value === "cancelled" || value === "missed" || value === "failed";
+}
+function isOptionalScheduledSessionMode(value) {
+  return value === undefined || value === "temp" || value === "bound";
+}
+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) && isOptionalScheduledSessionMode(value.session_mode) && isOptionalString(value.agent) && isOptionalString(value.workspace);
+}
+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 +10050,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) {
@@ -10055,6 +10107,315 @@ var init_state_store = __esm(() => {
   init_types();
 });
 
+// src/channels/channel-scope.ts
+function registerKnownChannelId(channelId) {
+  const normalized = channelId.trim();
+  if (!normalized || normalized.includes(":")) {
+    throw new Error("channel id must be non-empty and must not contain ':'");
+  }
+  KNOWN_CHANNEL_IDS.add(normalized);
+}
+function listKnownChannelIds() {
+  return Array.from(KNOWN_CHANNEL_IDS);
+}
+function getChannelIdFromChatKey(chatKey) {
+  const first = chatKey.split(":", 1)[0];
+  return first && KNOWN_CHANNEL_IDS.has(first) ? first : "weixin";
+}
+function toInternalSessionAlias(channelId, displayAlias) {
+  const normalized = displayAlias.trim();
+  if (normalized.length === 0) {
+    throw new Error("display session alias must be non-empty");
+  }
+  if (normalized.startsWith(`${channelId}:`)) {
+    return normalized;
+  }
+  return `${channelId}:${normalized}`;
+}
+function toDisplaySessionAlias(internalAlias) {
+  const [first, ...rest] = internalAlias.split(":");
+  if (first && KNOWN_CHANNEL_IDS.has(first) && rest.length > 0) {
+    return rest.join(":");
+  }
+  return internalAlias;
+}
+function isSessionAliasVisibleInChannel(alias, channelId) {
+  const [first] = alias.split(":", 1);
+  if (first && KNOWN_CHANNEL_IDS.has(first)) {
+    return first === channelId;
+  }
+  return channelId === "weixin";
+}
+function resolveSessionAliasForInput(channelId, displayAlias, existingAliases) {
+  const normalized = displayAlias.trim();
+  if (normalized.length === 0) {
+    throw new Error("display session alias must be non-empty");
+  }
+  if (normalized.startsWith(`${channelId}:`)) {
+    return normalized;
+  }
+  const scopedAlias = toInternalSessionAlias(channelId, normalized);
+  for (const alias of existingAliases) {
+    if (alias === scopedAlias)
+      return scopedAlias;
+  }
+  if (channelId === "weixin") {
+    for (const alias of existingAliases) {
+      if (alias === normalized)
+        return alias;
+    }
+  }
+  return scopedAlias;
+}
+function buildDefaultTransportSession(channelId, displayAlias) {
+  const normalized = displayAlias.trim();
+  if (normalized.length === 0) {
+    throw new Error("display session alias must be non-empty");
+  }
+  return channelId === "weixin" ? normalized : toInternalSessionAlias(channelId, normalized);
+}
+var KNOWN_CHANNEL_IDS;
+var init_channel_scope = __esm(() => {
+  KNOWN_CHANNEL_IDS = new Set(["weixin"]);
+});
+
+// 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/scheduled-render.ts
+function sessionLabel(task, displaySession) {
+  if (task.session_mode === "temp") {
+    return `临时会话（${task.workspace ?? "?"} · ${task.agent ?? "?"}）`;
+  }
+  return `会话：${displaySession}`;
+}
+function renderLaterHelp() {
+  return [
+    "定时任务用法：",
+    "",
+    "创建：",
+    "/lt in 2h 检查 CI",
+    "/lt 30分钟后 总结进展",
+    "/lt tomorrow 09:00 看 PR",
+    "/lt 周五 09:00 继续处理",
+    "",
+    "查看：",
+    "/lt list",
+    "",
+    "取消：",
+    "/lt cancel <id>",
+    "",
+    "说明：",
+    "- 只支持一次性任务",
+    "- 时间必须在 10 秒之后、7 天之内",
+    "- 默认在为本次任务新建的临时会话里执行（跑完即销毁）",
+    "- 加 --bind 改为发送到创建时绑定的当前会话",
+    "- 触发通知和 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))}`,
+    sessionLabel(task, 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))}  ${sessionLabel(task, 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/orchestration/async-mutex.ts
+class AsyncMutex {
+  tail = Promise.resolve();
+  async run(critical) {
+    const previous = this.tail;
+    let release;
+    this.tail = new Promise((resolve) => {
+      release = resolve;
+    });
+    await previous;
+    try {
+      return await critical();
+    } finally {
+      release();
+    }
+  }
+}
+
+// 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.sessionMode ? { session_mode: input.sessionMode } : {},
+        ...input.agent ? { agent: input.agent } : {},
+        ...input.workspace ? { workspace: input.workspace } : {},
+        ...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/plugins/plugin-home.ts
 import { mkdir as mkdir6, writeFile as writeFile4 } from "node:fs/promises";
 import { homedir as homedir3 } from "node:os";
@@ -15442,6 +15803,181 @@ 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,
+          ...input.sessionDescriptor ? { scheduledSessionDescriptor: input.sessionDescriptor } : {}
+        }
+      },
+      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 +16104,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 +16135,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 +16196,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,81 +16220,10 @@ 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();
 });
 
-// src/channels/channel-scope.ts
-function registerKnownChannelId(channelId) {
-  const normalized = channelId.trim();
-  if (!normalized || normalized.includes(":")) {
-    throw new Error("channel id must be non-empty and must not contain ':'");
-  }
-  KNOWN_CHANNEL_IDS.add(normalized);
-}
-function listKnownChannelIds() {
-  return Array.from(KNOWN_CHANNEL_IDS);
-}
-function getChannelIdFromChatKey(chatKey) {
-  const first = chatKey.split(":", 1)[0];
-  return first && KNOWN_CHANNEL_IDS.has(first) ? first : "weixin";
-}
-function toInternalSessionAlias(channelId, displayAlias) {
-  const normalized = displayAlias.trim();
-  if (normalized.length === 0) {
-    throw new Error("display session alias must be non-empty");
-  }
-  if (normalized.startsWith(`${channelId}:`)) {
-    return normalized;
-  }
-  return `${channelId}:${normalized}`;
-}
-function toDisplaySessionAlias(internalAlias) {
-  const [first, ...rest] = internalAlias.split(":");
-  if (first && KNOWN_CHANNEL_IDS.has(first) && rest.length > 0) {
-    return rest.join(":");
-  }
-  return internalAlias;
-}
-function isSessionAliasVisibleInChannel(alias, channelId) {
-  const [first] = alias.split(":", 1);
-  if (first && KNOWN_CHANNEL_IDS.has(first)) {
-    return first === channelId;
-  }
-  return channelId === "weixin";
-}
-function resolveSessionAliasForInput(channelId, displayAlias, existingAliases) {
-  const normalized = displayAlias.trim();
-  if (normalized.length === 0) {
-    throw new Error("display session alias must be non-empty");
-  }
-  if (normalized.startsWith(`${channelId}:`)) {
-    return normalized;
-  }
-  const scopedAlias = toInternalSessionAlias(channelId, normalized);
-  for (const alias of existingAliases) {
-    if (alias === scopedAlias)
-      return scopedAlias;
-  }
-  if (channelId === "weixin") {
-    for (const alias of existingAliases) {
-      if (alias === normalized)
-        return alias;
-    }
-  }
-  return scopedAlias;
-}
-function buildDefaultTransportSession(channelId, displayAlias) {
-  const normalized = displayAlias.trim();
-  if (normalized.length === 0) {
-    throw new Error("display session alias must be non-empty");
-  }
-  return channelId === "weixin" ? normalized : toInternalSessionAlias(channelId, normalized);
-}
-var KNOWN_CHANNEL_IDS;
-var init_channel_scope = __esm(() => {
-  KNOWN_CHANNEL_IDS = new Set(["weixin"]);
-});
-
 // src/plugins/known-plugins.ts
 function listKnownPlugins() {
   return KNOWN_PLUGINS.map((plugin) => ({ ...plugin, channels: [...plugin.channels] }));
@@ -16049,7 +16533,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 +16919,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 +17089,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 +17267,8 @@ function normalizeCommand(command) {
     return "/permission";
   if (command === "/stop")
     return "/cancel";
+  if (command === "/lt")
+    return "/later";
   return command;
 }
 function isRecognizedCommand(command) {
@@ -16966,6 +17464,7 @@ var init_command_policy = __esm(() => {
     "group.get",
     "tasks",
     "task.get",
+    "later.help",
     "invalid",
     "prompt"
   ]);
@@ -16995,7 +17494,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"
   };
 });
 
@@ -17904,7 +18406,7 @@ async function handleSessionRemove(context, chatKey, alias) {
   return { text: lines.join(`
 `) };
 }
-async function promptWithSession(context, session, chatKey, text, reply, replyContextToken, accountId, media, abortSignal, onToolEvent, onThought, perfSpan) {
+async function promptWithSession(context, session, chatKey, text, reply, replyContextToken, accountId, media, abortSignal, onToolEvent, onThought, perfSpan, metadata) {
   const effectiveReplyMode = session.replyMode ?? context.config?.channel.replyMode ?? "verbose";
   if (!session.replyMode)
     session.replyMode = effectiveReplyMode;
@@ -17914,8 +18416,10 @@ async function promptWithSession(context, session, chatKey, text, reply, replyCo
       await context.orchestration.recordCoordinatorRouteContext?.({
         coordinatorSession: session.transportSession,
         chatKey,
+        sessionAlias: session.alias,
         ...replyContextToken ? { replyContextToken } : {},
-        ...accountId ? { accountId } : {}
+        ...accountId ? { accountId } : {},
+        ...toCoordinatorRouteChatMetadata(metadata)
       });
     } catch (error2) {
       await context.logger.error("orchestration.coordinator_route_context.record_failed", "failed to record coordinator route context", {
@@ -17924,6 +18428,13 @@ async function promptWithSession(context, session, chatKey, text, reply, replyCo
         chatKey,
         error: error2 instanceof Error ? error2.message : String(error2)
       });
+      return {
+        text: [
+          "无法记录当前会话路由，已取消本次发送。",
+          "请稍后重试；如果问题持续存在，请检查 weacpx 运行日志和 state.json 写入权限。"
+        ].join(`
+`)
+      };
     }
   }
   const { promptText, taskIds, groupIds, claimHumanReply } = await preparePromptWithFallback(context, session, chatKey, text, replyContextToken, accountId);
@@ -17949,21 +18460,37 @@ 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, metadata) {
   try {
-    return await promptWithSession(context, session, chatKey, text, reply, replyContextToken, accountId, media, abortSignal, onToolEvent, onThought, perfSpan);
+    return await promptWithSession(context, session, chatKey, text, reply, replyContextToken, accountId, media, abortSignal, onToolEvent, onThought, perfSpan, metadata);
   } catch (error2) {
     const recovered = await context.recovery.tryRecoverMissingSession(session, error2);
     if (recovered) {
-      return await promptWithSession(context, recovered, chatKey, text, reply, replyContextToken, accountId, media, abortSignal, onToolEvent, onThought, perfSpan);
+      return await promptWithSession(context, recovered, chatKey, text, reply, replyContextToken, accountId, media, abortSignal, onToolEvent, onThought, perfSpan, metadata);
     }
     return context.recovery.renderTransportError(session, error2);
   }
 }
+async function handlePrompt(context, chatKey, text, reply, replyContextToken, accountId, media, abortSignal, onToolEvent, onThought, perfSpan, metadata) {
+  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, metadata);
+}
+function toCoordinatorRouteChatMetadata(metadata) {
+  if (!metadata) {
+    return {};
+  }
+  return {
+    ...metadata.channel ? { channel: metadata.channel } : {},
+    ...metadata.chatType ? { chatType: metadata.chatType } : {},
+    ...metadata.senderId ? { senderId: metadata.senderId } : {},
+    ...metadata.senderName ? { senderName: metadata.senderName } : {},
+    ...metadata.groupId ? { groupId: metadata.groupId } : {},
+    ...metadata.isOwner !== undefined ? { isOwner: metadata.isOwner } : {}
+  };
+}
 async function preparePromptWithFallback(context, session, chatKey, text, replyContextToken, accountId) {
   const orchestration = context.orchestration;
   if (!orchestration) {
@@ -18725,6 +19252,273 @@ var init_workspace_handler = __esm(() => {
   };
 });
 
+// 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/commands/handlers/later-handler.ts
+function handleLaterHelp() {
+  return { text: renderLaterHelp() };
+}
+async function handleLaterCreate(tokens, scheduled, chatKey, currentSession, defaultMode, accountId, replyContextToken) {
+  let rest = tokens;
+  const seenFlags = new Set;
+  let flagMode;
+  while (rest.length > 0 && (rest[0] === "--bind" || rest[0] === "--temp")) {
+    seenFlags.add(rest[0]);
+    flagMode = rest[0] === "--bind" ? "bound" : "temp";
+    rest = rest.slice(1);
+  }
+  if (seenFlags.size > 1) {
+    return { text: "定时任务的 --bind 与 --temp 不能同时使用。" };
+  }
+  const mode = flagMode ?? defaultMode;
+  if (!currentSession) {
+    return {
+      text: [
+        "当前没有会话，无法创建定时任务。",
+        "",
+        "请先创建或切换到一个会话：",
+        "- /ss codex --ws backend（新建并切换）",
+        "- /use backend-codex（切换到已有会话）"
+      ].join(`
+`)
+    };
+  }
+  const result = parseLaterTime(rest);
+  if (!result.ok) {
+    return { text: renderTimeParseError(result.code, result.value) };
+  }
+  const message = rest.slice(result.messageStartIndex).join(" ").trim();
+  if (message.startsWith("/")) {
+    return {
+      text: [
+        "不支持延迟执行 / 开头的命令。",
+        "",
+        "如果需要让 agent 解释命令，可以用自然语言描述：",
+        "例如：/lt in 1h 请解释 /status 的作用"
+      ].join(`
+`)
+    };
+  }
+  const task = await scheduled.createTask({
+    chatKey,
+    sessionAlias: currentSession.alias,
+    executeAt: result.executeAt,
+    message,
+    sessionMode: mode,
+    ...mode === "temp" ? { agent: currentSession.agent, workspace: currentSession.workspace } : {},
+    ...accountId ? { accountId } : {},
+    ...replyContextToken ? { replyContextToken } : {}
+  });
+  return { text: renderTaskCreated(task, toDisplaySessionAlias(currentSession.alias)) };
+}
+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: "定时任务：到点在临时会话执行（或 --bind 发到当前会话）",
+    commands: [
+      { usage: "/lt <时间> <消息>", description: "创建定时任务" },
+      { usage: "/lt --bind <时间> <消息>", description: "改为发送到当前会话" },
+      { usage: "/lt --temp <时间> <消息>", 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 天之内",
+      "默认在为本次任务新建的临时会话里执行，跑完即销毁",
+      "加 --bind 改为发送到创建时绑定的当前会话（默认模式可用 later.defaultMode 配置）",
+      "/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 +19534,7 @@ var init_help_registry = __esm(() => {
   init_permission_handler();
   init_session_handler();
   init_workspace_handler();
+  init_later_handler();
   HELP_TOPICS = [
     sessionHelp,
     workspaceHelp,
@@ -18750,7 +19545,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 +19593,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(`
 `);
 }
@@ -18999,6 +19796,15 @@ var init_session_shortcut_handler = __esm(() => {
 function renderTransportError(session, error2) {
   const message = error2 instanceof Error ? error2.message : String(error2);
   if (message.includes("No acpx session found")) {
+    if (session.transient) {
+      return {
+        text: [
+          "定时任务的临时会话启动失败，本次任务未能执行。",
+          "临时会话由系统在执行时自动创建，无需手动操作；如需重排，请用 /lt 重新安排。"
+        ].join(`
+`)
+      };
+    }
     return {
       text: [
         `当前会话「${session.alias}」暂时不可用。`,
@@ -19075,6 +19881,9 @@ async function tryRecoverMissingSession(ops, session, error2) {
   if (!message.includes("No acpx session found")) {
     return null;
   }
+  if (session.transient) {
+    return null;
+  }
   const transportAgentCommand = await ops.resolveSessionAgentCommand(session);
   if (!transportAgentCommand || transportAgentCommand === session.agentCommand) {
     return null;
@@ -19448,6 +20257,8 @@ class CommandRouter {
   resolveSessionAgentCommand;
   orchestration;
   quota;
+  scheduled;
+  scheduledDelivery;
   logger;
   autoInstall = autoInstallOptionalDep;
   discoverPaths = discoverParentPackagePaths;
@@ -19457,7 +20268,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 +20276,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 +20398,46 @@ 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: currentSession.alias, agent: currentSession.agent, workspace: currentSession.workspace } : null, this.config?.later?.defaultMode === "bind" ? "bound" : "temp", 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?.scheduledSessionDescriptor) {
+            const descriptor = metadata.scheduledSessionDescriptor;
+            const transientSession = {
+              ...this.sessions.resolveSession(descriptor.alias, descriptor.agent, descriptor.workspace, descriptor.transportSession),
+              transient: true
+            };
+            return await handlePromptWithSession(sessionContext, transientSession, chatKey, command.text, reply, replyContextToken, accountId, media, abortSignal, onToolEvent, onThought, perfSpan, metadata);
+          }
+          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, metadata);
+          }
+          return await handlePrompt(sessionContext, chatKey, command.text, reply, replyContextToken, accountId, media, abortSignal, onToolEvent, onThought, perfSpan, metadata);
+        }
       }
     });
   }
@@ -19964,11 +20815,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
@@ -20061,24 +20914,6 @@ var init_console_agent = __esm(() => {
   init_command_list();
 });
 
-// src/orchestration/async-mutex.ts
-class AsyncMutex {
-  tail = Promise.resolve();
-  async run(critical) {
-    const previous = this.tail;
-    let release;
-    this.tail = new Promise((resolve3) => {
-      release = resolve3;
-    });
-    await previous;
-    try {
-      return await critical();
-    } finally {
-      release();
-    }
-  }
-}
-
 // src/orchestration/orchestration-server.ts
 import { rm as rm7 } from "node:fs/promises";
 import { createConnection as createConnection2, createServer } from "node:net";
@@ -20234,6 +21069,12 @@ class OrchestrationServer {
           reviewId: requireString(params, "reviewId"),
           decision: requireEnum(params, "decision", ["accept", "discard"])
         });
+      case "scheduled.create":
+        return await this.dispatchScheduledCreate(params);
+      case "scheduled.list":
+        return await this.dispatchScheduledList(params);
+      case "scheduled.cancel":
+        return await this.dispatchScheduledCancel(params);
       case "group.new":
         requireOnlyKeys(params, ["coordinatorSession", "title"], "params");
         return await this.handlers.createGroup({
@@ -20244,6 +21085,47 @@ class OrchestrationServer {
         throw new OrchestrationInvalidRequestError(`unsupported orchestration method: ${method}`);
     }
   }
+  async dispatchScheduledCreate(params) {
+    const input = this.parseScheduledCreateInput(params);
+    const handler = this.deps.createScheduledTaskFromRoute ?? this.handlers.createScheduledTaskFromRoute;
+    if (!handler) {
+      throw new Error("scheduled task creation is not configured");
+    }
+    return await handler(input);
+  }
+  parseScheduledCreateInput(params) {
+    requireOnlyKeys(params, ["coordinatorSession", "timeText", "message", "mode"], "params");
+    const mode = requireOptionalEnum(params, "mode", ["temp", "bound"]);
+    return {
+      coordinatorSession: requireString(params, "coordinatorSession"),
+      timeText: requireString(params, "timeText"),
+      message: requireString(params, "message"),
+      ...mode !== undefined ? { mode } : {}
+    };
+  }
+  async dispatchScheduledList(params) {
+    requireOnlyKeys(params, ["coordinatorSession"], "params");
+    const input = {
+      coordinatorSession: requireString(params, "coordinatorSession")
+    };
+    const handler = this.deps.listScheduledTasksFromRoute ?? this.handlers.listScheduledTasksFromRoute;
+    if (!handler) {
+      throw new Error("scheduled task listing is not configured");
+    }
+    return await handler(input);
+  }
+  async dispatchScheduledCancel(params) {
+    requireOnlyKeys(params, ["coordinatorSession", "id"], "params");
+    const input = {
+      coordinatorSession: requireString(params, "coordinatorSession"),
+      id: requireString(params, "id")
+    };
+    const handler = this.deps.cancelScheduledTaskFromRoute ?? this.handlers.cancelScheduledTaskFromRoute;
+    if (!handler) {
+      throw new Error("scheduled task cancellation is not configured");
+    }
+    return await handler(input);
+  }
   parseRegisterExternalCoordinatorInput(params) {
     requireOnlyKeys(params, ["coordinatorSession", "workspace", "defaultTargetAgent"], "params");
     const workspace = requireOptionalString(params, "workspace");
@@ -20588,6 +21470,9 @@ var init_orchestration_server = __esm(() => {
     "coordinator.retract_answer",
     "coordinator.request_human_input",
     "coordinator.review_contested_result",
+    "scheduled.create",
+    "scheduled.list",
+    "scheduled.cancel",
     "group.new"
   ]);
 });
@@ -21581,10 +22466,11 @@ class OrchestrationService {
       const state = await this.deps.loadState();
       const now = this.deps.now().toISOString();
       const existing = this.ensureCoordinatorRoutes(state)[input.coordinatorSession];
+      const sameChat = existing?.chatKey === input.chatKey;
       const hasAccountId = input.accountId !== undefined;
       const hasReplyContextToken = input.replyContextToken !== undefined;
       const hasCompleteReplyRoute = hasAccountId && hasReplyContextToken;
-      const shouldPreserveExistingReplyRoute = !hasAccountId && !hasReplyContextToken && existing?.chatKey === input.chatKey;
+      const shouldPreserveExistingReplyRoute = !hasAccountId && !hasReplyContextToken && sameChat;
       const replyRoute = hasCompleteReplyRoute ? {
         accountId: input.accountId,
         replyContextToken: input.replyContextToken
@@ -21595,7 +22481,9 @@ class OrchestrationService {
       const route = {
         coordinatorSession: input.coordinatorSession,
         chatKey: input.chatKey,
+        ...input.sessionAlias ? { sessionAlias: input.sessionAlias } : {},
         ...replyRoute ? replyRoute : {},
+        ...buildCoordinatorRouteChatMetadata(input, sameChat ? existing : undefined),
         updatedAt: now
       };
       this.ensureCoordinatorRoutes(state)[input.coordinatorSession] = route;
@@ -23922,6 +24810,22 @@ class OrchestrationService {
     task.events = events.slice(-MAX_TASK_EVENTS_PER_TASK);
   }
 }
+function buildCoordinatorRouteChatMetadata(input, existing) {
+  const channel = input.channel ?? existing?.channel;
+  const chatType = input.chatType ?? existing?.chatType;
+  const senderId = input.senderId ?? existing?.senderId;
+  const senderName = input.senderName ?? existing?.senderName;
+  const groupId = input.groupId ?? existing?.groupId;
+  const isOwner = input.isOwner ?? existing?.isOwner;
+  return {
+    ...channel !== undefined ? { channel } : {},
+    ...chatType !== undefined ? { chatType } : {},
+    ...senderId !== undefined ? { senderId } : {},
+    ...senderName !== undefined ? { senderName } : {},
+    ...groupId !== undefined ? { groupId } : {},
+    ...isOwner !== undefined ? { isOwner } : {}
+  };
+}
 function isTerminalTaskStatus2(status) {
   return status === "completed" || status === "failed" || status === "cancelled";
 }
@@ -23965,6 +24869,269 @@ 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-dispatch.ts
+function buildScheduledDispatchTask(deps) {
+  return async (task, abortSignal) => {
+    if (task.session_mode === "temp") {
+      await dispatchTemp(task, abortSignal, deps);
+      return;
+    }
+    await dispatchBound(task, abortSignal, deps);
+  };
+}
+async function dispatchBound(task, abortSignal, deps) {
+  const session = await deps.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)}`;
+  await deps.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 } : {}
+  });
+}
+async function dispatchTemp(task, abortSignal, deps) {
+  if (!task.agent || !task.workspace) {
+    throw new Error(`temp scheduled task #${task.id} is missing its agent/workspace snapshot`);
+  }
+  const alias = `later-${task.id}`;
+  const transportSession = `${task.workspace}:${alias}`;
+  const session = deps.resolveSession(alias, task.agent, task.workspace, transportSession);
+  const noticeText = `执行定时任务 #${task.id}
+会话：临时会话（${task.workspace} · ${task.agent}）
+内容：${preview(task.message)}`;
+  try {
+    await deps.sendScheduledMessage({
+      chatKey: task.chat_key,
+      taskId: task.id,
+      sessionAlias: task.session_alias,
+      sessionDescriptor: { alias, agent: task.agent, workspace: task.workspace, transportSession },
+      noticeText,
+      promptText: task.message,
+      abortSignal,
+      ...task.account_id ? { accountId: task.account_id } : {},
+      ...task.reply_context_token ? { replyContextToken: task.reply_context_token } : {}
+    });
+  } finally {
+    if (deps.removeSession) {
+      try {
+        await deps.removeSession(session);
+      } catch (error2) {
+        await deps.logger?.error("scheduled.temp_session_close_failed", "failed to close temp scheduled session", { taskId: task.id, transportSession, error: String(error2) });
+      }
+    }
+  }
+}
+var init_scheduled_dispatch = __esm(() => {
+  init_channel_scope();
+  init_scheduled_render();
+});
+
+// src/scheduled/scheduled-route-create.ts
+async function createScheduledTaskFromRoute(input, deps) {
+  const coordinatorSession = input.coordinatorSession.trim();
+  if (coordinatorSession.length === 0) {
+    throw new Error("coordinatorSession must be a non-empty string");
+  }
+  const route = deps.state.orchestration.coordinatorRoutes[coordinatorSession];
+  if (!route) {
+    throw new Error(`no chat route is recorded for coordinator session "${coordinatorSession}"`);
+  }
+  if (route.chatType !== "direct" && route.chatType !== "group") {
+    throw new Error("scheduled_create requires current chat route metadata");
+  }
+  if (route.chatType === "group" && route.isOwner !== true) {
+    throw new Error("scheduled_create is owner-only in group chats");
+  }
+  if (deps.supportsScheduledMessages && !deps.supportsScheduledMessages(route.chatKey)) {
+    throw new Error("current channel does not support scheduled tasks");
+  }
+  const message = input.message.trim();
+  if (message.length === 0) {
+    throw new Error("message must be a non-empty string");
+  }
+  if (message.startsWith("/")) {
+    throw new Error("scheduled_create does not support slash-prefixed weacpx commands");
+  }
+  if (!route.sessionAlias) {
+    throw new Error("scheduled_create requires current session route metadata");
+  }
+  const session = await deps.sessions.getSession(route.sessionAlias);
+  if (!session) {
+    throw new Error(`session "${route.sessionAlias}" recorded for coordinator session "${coordinatorSession}" was not found`);
+  }
+  if (session.transportSession !== coordinatorSession) {
+    throw new Error(`session "${route.sessionAlias}" is no longer attached to coordinator session "${coordinatorSession}"`);
+  }
+  const executeAt = parseRouteScheduledTime(input.timeText, deps.now?.() ?? new Date);
+  const mode = input.mode ?? (deps.config.later?.defaultMode === "bind" ? "bound" : "temp");
+  return await deps.scheduled.createTask({
+    chatKey: route.chatKey,
+    sessionAlias: session.alias,
+    executeAt,
+    message,
+    sessionMode: mode,
+    ...mode === "temp" ? { agent: session.agent, workspace: session.workspace } : {},
+    ...route.accountId ? { accountId: route.accountId } : {},
+    ...route.replyContextToken ? { replyContextToken: route.replyContextToken } : {},
+    sourceLabel: "mcp:scheduled_create"
+  });
+}
+function parseRouteScheduledTime(timeText, now) {
+  const timeTokens = timeText.trim().split(/\s+/).filter((token) => token.length > 0);
+  if (timeTokens.length === 0) {
+    throw new Error(formatLaterTimeParseError("missing_time"));
+  }
+  const parsed = parseLaterTime([...timeTokens, "__scheduled_create_message__"], now);
+  if (!parsed.ok) {
+    throw new Error(formatLaterTimeParseError(parsed.code, parsed.value));
+  }
+  if (parsed.messageStartIndex !== timeTokens.length) {
+    throw new Error("timeText must contain only the time expression; put the scheduled content in message");
+  }
+  return parsed.executeAt;
+}
+function formatLaterTimeParseError(code, value) {
+  switch (code) {
+    case "missing_message":
+      return "message must be provided separately from timeText";
+    case "too_soon":
+      return "scheduled task time must be at least 10 seconds in the future";
+    case "out_of_range":
+      return "scheduled task time must be within 7 days";
+    case "past_today_time":
+      return `today at ${value} has already passed; choose a future time or use tomorrow`;
+    case "unrecognized_time":
+    case "missing_time":
+    default:
+      return "unrecognized timeText; supported examples: in 2h, 30分钟后, tomorrow 09:00, 周五 09:00";
+  }
+}
+var init_scheduled_route_create = __esm(() => {
+  init_parse_later_time();
+});
+
+// src/scheduled/scheduled-route-manage.ts
+async function listScheduledTasksFromRoute(input, deps) {
+  resolveOwnedCoordinatorRoute(input.coordinatorSession, deps.state, "scheduled_list");
+  return deps.scheduled.listPending();
+}
+async function cancelScheduledTaskFromRoute(input, deps) {
+  resolveOwnedCoordinatorRoute(input.coordinatorSession, deps.state, "scheduled_cancel");
+  const cancelled = await deps.scheduled.cancelPending(input.id);
+  return { id: normalizeId(input.id), cancelled };
+}
+function resolveOwnedCoordinatorRoute(coordinatorSession, state, label) {
+  const session = coordinatorSession.trim();
+  if (session.length === 0) {
+    throw new Error("coordinatorSession must be a non-empty string");
+  }
+  const route = state.orchestration.coordinatorRoutes[session];
+  if (!route) {
+    throw new Error(`no chat route is recorded for coordinator session "${session}"`);
+  }
+  if (route.chatType !== "direct" && route.chatType !== "group") {
+    throw new Error(`${label} requires current chat route metadata`);
+  }
+  if (route.chatType === "group" && route.isOwner !== true) {
+    throw new Error(`${label} is owner-only in group chats`);
+  }
+  return route;
+}
+var init_scheduled_route_manage = __esm(() => {
+  init_scheduled_service();
+});
+
 // src/sessions/session-service.ts
 class SessionService {
   config;
@@ -24419,20 +25586,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({
@@ -25573,7 +26767,7 @@ function buildWeacpxMcpServerSpec(input) {
       "mcp-stdio",
       "--coordinator-session",
       input.coordinatorSession,
-      ...input.sourceHandle ? ["--source-handle", input.sourceHandle] : []
+      ...input.sourceHandle ? ["--source-handle", input.sourceHandle] : ["--internal-session-tools"]
     ]
   };
 }
@@ -26435,6 +27629,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 +27858,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,
@@ -27007,9 +28217,34 @@ 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 orchestrationServer = new OrchestrationServer(orchestrationEndpoint, orchestration, {
+    createScheduledTaskFromRoute: async (input) => await createScheduledTaskFromRoute(input, {
+      state,
+      config: config2,
+      sessions,
+      scheduled: scheduledService,
+      ...deps.channel?.supportsScheduledMessages ? { supportsScheduledMessages: deps.channel.supportsScheduledMessages.bind(deps.channel) } : {}
+    }),
+    listScheduledTasksFromRoute: async (input) => await listScheduledTasksFromRoute(input, { state, scheduled: scheduledService }),
+    cancelScheduledTaskFromRoute: async (input) => await cancelScheduledTaskFromRoute(input, { state, scheduled: scheduledService })
+  });
+  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: buildScheduledDispatchTask({
+      getSession: (alias) => sessions.getSession(alias),
+      resolveSession: (alias, agent2, workspace, transportSession) => sessions.resolveSession(alias, agent2, workspace, transportSession),
+      sendScheduledMessage: async (input) => {
+        if (!deps.channel?.sendScheduledMessage) {
+          throw new Error("no channel runtime available for scheduled task dispatch");
+        }
+        await deps.channel.sendScheduledMessage(input);
+      },
+      ...transport.removeSession ? { removeSession: (session) => transport.removeSession(session) } : {},
+      logger: logger2
+    }),
+    logger: logger2
+  });
   return {
     agent,
     router,
@@ -27025,7 +28260,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 +28318,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 +28413,11 @@ var init_main = __esm(async () => {
   init_orchestration_server();
   init_orchestration_service();
   init_build_coordinator_prompt();
+  init_scheduled_scheduler();
+  init_scheduled_service();
+  init_scheduled_dispatch();
+  init_scheduled_route_create();
+  init_scheduled_route_manage();
   init_session_service();
   init_state_store();
   init_run_console();
@@ -40703,12 +41949,13 @@ var sortSchema = exports_external.enum(["updatedAt", "createdAt"]);
 var orderSchema = exports_external.enum(["asc", "desc"]);
 var contestedDecisionSchema = exports_external.enum(["accept", "discard"]);
 var taskWatchModeSchema = exports_external.enum(["next_event", "until_attention_or_terminal"]);
+var scheduledModeSchema = exports_external.enum(["temp", "bound"]);
 var taskQuestionSchema = exports_external.object({
   taskId: exports_external.string().min(1),
   questionId: exports_external.string().min(1)
 }).strict();
 function buildWeacpxMcpToolRegistry(input) {
-  const { transport, coordinatorSession, sourceHandle, isExternalCoordinator, availableAgents } = input;
+  const { transport, coordinatorSession, sourceHandle, isExternalCoordinator, internalSessionTools, availableAgents } = input;
   const tools = [
     {
       name: "delegate_request",
@@ -40926,6 +42173,63 @@ function buildWeacpxMcpToolRegistry(input) {
       })
     }
   ];
+  if (internalSessionTools && !isExternalCoordinator && !sourceHandle) {
+    tools.push({
+      name: "scheduled_create",
+      description: "Create a one-shot scheduled task for the current conversation session using the recorded chat route. Provide only the time expression and message; routing/session/account details are resolved by weacpx.",
+      inputSchema: exports_external.object({
+        timeText: exports_external.string().min(1).describe("Time expression, e.g. 'in 2h', '30分钟后', 'tomorrow 09:00', or '周五 09:00'."),
+        message: exports_external.string().min(1).describe("Natural-language message to send to the current session at the scheduled time."),
+        mode: scheduledModeSchema.describe("'temp' creates a temporary one-shot session; 'bound' sends to the current bound session.").optional()
+      }).strict(),
+      handler: async (args) => await asToolResult(async () => {
+        const input2 = args;
+        const task = await transport.scheduledCreate({
+          coordinatorSession,
+          timeText: input2.timeText,
+          message: input2.message,
+          ...input2.mode ? { mode: input2.mode } : {}
+        });
+        return createSuccessResult(`Scheduled task #${task.id} created for ${task.execute_at}.`, {
+          id: task.id,
+          status: task.status,
+          executeAt: task.execute_at,
+          sessionAlias: task.session_alias,
+          sessionMode: task.session_mode ?? "bound"
+        });
+      })
+    });
+    tools.push({
+      name: "scheduled_list",
+      description: "List pending one-shot scheduled tasks (global). Use to recover task ids before cancelling, or to see what is scheduled. Owner-only in group chats. Routing and account are resolved from the current session; pass no other arguments.",
+      inputSchema: exports_external.object({}).strict(),
+      handler: async () => await asToolResult(async () => {
+        const tasks = await transport.scheduledList({ coordinatorSession });
+        return createSuccessResult(renderScheduledList(tasks), {
+          tasks: tasks.map((task) => ({
+            id: task.id,
+            executeAt: task.execute_at,
+            message: task.message,
+            sessionAlias: task.session_alias,
+            sessionMode: task.session_mode ?? "bound",
+            chatKey: task.chat_key
+          }))
+        });
+      })
+    });
+    tools.push({
+      name: "scheduled_cancel",
+      description: "Cancel a pending scheduled task by id. Owner-only in group chats. Returns whether a pending task with that id was found and cancelled. Routing is resolved from the current session.",
+      inputSchema: exports_external.object({
+        id: exports_external.string().min(1).describe("The scheduled task id, e.g. 'k8f2' (a leading # is allowed).")
+      }).strict(),
+      handler: async (args) => await asToolResult(async () => {
+        const { id } = args;
+        const result = await transport.scheduledCancel({ coordinatorSession, id });
+        return createSuccessResult(renderScheduledCancel(result), { id: result.id, cancelled: result.cancelled });
+      })
+    });
+  }
   if (isExternalCoordinator) {
     const externalCoordinatorIncompatibleTools = new Set([
       "coordinator_request_human_input"
@@ -41005,6 +42309,19 @@ function renderTaskList(tasks) {
   return ["Tasks for the current coordinator:", ...tasks.map((task) => renderTaskListItem(task))].join(`
 `);
 }
+function renderScheduledList(tasks) {
+  if (tasks.length === 0) {
+    return "There are no pending scheduled tasks.";
+  }
+  return [
+    "Pending scheduled tasks:",
+    ...tasks.map((task) => `- #${task.id} at ${task.execute_at} [${task.session_mode ?? "bound"}] -> ${task.session_alias}: ${task.message}`)
+  ].join(`
+`);
+}
+function renderScheduledCancel(result) {
+  return result.cancelled ? `Scheduled task #${result.id} cancelled.` : `No pending scheduled task #${result.id} found.`;
+}
 function renderTaskListItem(task) {
   const role = task.role ? ` / ${task.role}` : "";
   const group = task.groupId ? `; group: ${task.groupId}` : "";
@@ -41175,6 +42492,15 @@ class OrchestrationClient {
   async createGroup(input) {
     return await this.request("group.new", input);
   }
+  async scheduledCreate(input) {
+    return await this.request("scheduled.create", input);
+  }
+  async scheduledList(input) {
+    return await this.request("scheduled.list", input);
+  }
+  async scheduledCancel(input) {
+    return await this.request("scheduled.cancel", input);
+  }
   async request(method, params, timeoutMs = this.timeoutMs) {
     const id = this.createId();
     return await new Promise((resolve, reject) => {
@@ -41287,7 +42613,25 @@ function createOrchestrationTransport(endpoint, deps = {}) {
     },
     coordinatorAnswerQuestion: async (input) => await client.coordinatorAnswerQuestion(input),
     coordinatorRequestHumanInput: async (input) => await client.coordinatorRequestHumanInput(input),
-    coordinatorReviewContestedResult: async (input) => await client.coordinatorReviewContestedResult(input)
+    coordinatorReviewContestedResult: async (input) => await client.coordinatorReviewContestedResult(input),
+    scheduledCreate: async (input) => {
+      if (!client.scheduledCreate) {
+        throw new Error("orchestration client scheduledCreate is not configured");
+      }
+      return await client.scheduledCreate(input);
+    },
+    scheduledList: async (input) => {
+      if (!client.scheduledList) {
+        throw new Error("orchestration client scheduledList is not configured");
+      }
+      return await client.scheduledList(input);
+    },
+    scheduledCancel: async (input) => {
+      if (!client.scheduledCancel) {
+        throw new Error("orchestration client scheduledCancel is not configured");
+      }
+      return await client.scheduledCancel(input);
+    }
   };
 }
 
@@ -41343,6 +42687,7 @@ function createWeacpxMcpServer(options) {
         coordinatorSession: identity.coordinatorSession,
         ...identity.sourceHandle ? { sourceHandle: identity.sourceHandle } : {},
         ...identity.isExternalCoordinator ? { isExternalCoordinator: true } : {},
+        ...identity.internalSessionTools ? { internalSessionTools: true } : {},
         ...options.availableAgents ? { availableAgents: options.availableAgents } : {}
       });
       return toolState;
@@ -41778,7 +43123,8 @@ async function resolveMcpIdentity(server, options) {
     return {
       coordinatorSession: options.coordinatorSession,
       ...options.sourceHandle ? { sourceHandle: options.sourceHandle } : {},
-      ...options.isExternalCoordinator ? { isExternalCoordinator: true } : {}
+      ...options.isExternalCoordinator ? { isExternalCoordinator: true } : {},
+      ...options.internalSessionTools ? { internalSessionTools: true } : {}
     };
   }
   throw new McpError(ErrorCode.InvalidRequest, "weacpx MCP identity is not configured; run through `weacpx mcp-stdio` or provide --coordinator-session");
@@ -41867,6 +43213,7 @@ async function runWeacpxMcpServer(options) {
     transport,
     ...options.coordinatorSession ? { coordinatorSession: options.coordinatorSession } : {},
     ...options.sourceHandle ? { sourceHandle: options.sourceHandle } : {},
+    ...options.internalSessionTools ? { internalSessionTools: true } : {},
     ...options.resolveIdentity ? { resolveIdentity: options.resolveIdentity } : {},
     ...options.availableAgents ? { availableAgents: options.availableAgents } : {}
   });
@@ -41961,6 +43308,11 @@ function parseCoordinatorSession(args, env = process.env) {
   });
 }
 
+// src/mcp/parse-internal-session-tools.ts
+function parseInternalSessionToolsFlag(args, _env = process.env) {
+  return args.includes("--internal-session-tools");
+}
+
 // src/mcp/parse-source-handle.ts
 function parseSourceHandle(args, env = process.env) {
   return parseStringFlag(args, env, {
@@ -41973,13 +43325,19 @@ function parseSourceHandle(args, env = process.env) {
 init_workspace_path();
 init_workspace_name();
 init_state_store();
+init_channel_scope();
+init_scheduled_render();
+init_scheduled_service();
 
 // src/onboarding.ts
 init_workspace_path();
 init_workspace_name();
+init_default_workspace();
 init_agent_templates();
 function isFirstUse(config2, state) {
-  return Object.keys(state.sessions ?? {}).length === 0 && Object.keys(config2.workspaces ?? {}).length === 0 && (config2.plugins ?? []).length === 0;
+  const workspaceNames = Object.keys(config2.workspaces ?? {});
+  const onlyDefaultOrEmpty = workspaceNames.length === 0 || workspaceNames.length === 1 && workspaceNames[0] === DEFAULT_HOME_WORKSPACE_NAME;
+  return Object.keys(state.sessions ?? {}).length === 0 && onlyDefaultOrEmpty && (config2.plugins ?? []).length === 0;
 }
 async function maybeRunFirstUseOnboarding(input) {
   if (!isFirstUse(input.config, input.state))
@@ -43647,7 +45005,8 @@ function createMcpStdioIdentityResolver(input) {
     return {
       coordinatorSession: resolvedCoordinatorSession,
       ...sourceHandle ? { sourceHandle } : {},
-      ...startup.kind === "external-coordinator" ? { isExternalCoordinator: true } : {}
+      ...startup.kind === "external-coordinator" ? { isExternalCoordinator: true } : {},
+      ...input.internalSessionTools && startup.kind === "existing-session" && !sourceHandle ? { internalSessionTools: true } : {}
     };
   };
 }
@@ -43692,6 +45051,7 @@ var HELP_LINES = [
   "weacpx version - 查看版本",
   "weacpx agent|agents list|add|rm|templates - 管理本机 Agent",
   "weacpx workspace list|add [name] [--raw]|rm <name> - 管理本机工作区（别名：ws）",
+  "weacpx later|lt list|cancel <id> - 管理本机待执行定时任务",
   "weacpx mcp-stdio [--coordinator-session <session>] [--source-handle <handle>] [--workspace <name>] - 启动 MCP stdio 服务"
 ];
 function getUsageText() {
@@ -43779,6 +45139,17 @@ async function runCli(args, deps = {}) {
       }
       return result;
     }
+    case "later":
+    case "lt": {
+      const result = await handleLaterCli(args.slice(1), { print });
+      if (result === null) {
+        for (const line of HELP_LINES) {
+          print(line);
+        }
+        return 1;
+      }
+      return result;
+    }
     case "plugin": {
       const result = await handlePluginCli(args.slice(1), await createPluginCliDeps({
         print,
@@ -44127,6 +45498,48 @@ async function agentRemove(rawName, print) {
   print(`Agent「${name}」已删除`);
   return 0;
 }
+async function handleLaterCli(args, deps) {
+  const subcommand = args[0];
+  switch (subcommand) {
+    case "list":
+      if (args.length !== 1)
+        return null;
+      return await laterList(deps.print);
+    case "cancel":
+      if (args.length !== 2 || !args[1])
+        return null;
+      return await laterCancel(args[1], deps.print);
+    default:
+      return null;
+  }
+}
+async function laterList(print) {
+  const scheduled = await createCliScheduledTaskService();
+  print(renderLaterList(scheduled.listPending(), (alias) => toDisplaySessionAlias(alias)));
+  return 0;
+}
+async function laterCancel(rawId, print) {
+  const id = normalizeId(rawId);
+  if (id.length === 0) {
+    print("定时任务 ID 不能为空。");
+    return 1;
+  }
+  const scheduled = await createCliScheduledTaskService();
+  const ok = await scheduled.cancelPending(id);
+  if (!ok) {
+    print(`未找到待执行的定时任务 #${id}。`);
+    print("可以用 weacpx later list 查看当前待执行任务。");
+    return 1;
+  }
+  print(`已取消定时任务 #${id}`);
+  return 0;
+}
+async function createCliScheduledTaskService() {
+  const runtimePaths = (await init_main().then(() => exports_main)).resolveRuntimePaths();
+  const stateStore = new StateStore(runtimePaths.statePath);
+  const state = await stateStore.load();
+  return new ScheduledTaskService(state, stateStore);
+}
 function resolveConfigPathForCurrentEnv() {
   return process.env.WEACPX_CONFIG ?? `${requireHome2()}/.weacpx/config.json`;
 }
@@ -44253,10 +45666,12 @@ async function defaultMcpStdio(args, deps = {}) {
   let transport;
   let identityResolver;
   let availableAgents;
+  let internalSessionTools = false;
   try {
     const parsedCoordinatorSession = parseCoordinatorSession(args, process.env);
     sourceHandle = parseSourceHandle(args, process.env);
     const workspace = parseCoordinatorWorkspace(args, process.env);
+    const requestedInternalSessionTools = parseInternalSessionToolsFlag(args, process.env);
     endpoint = resolveDefaultOrchestrationEndpoint(process.env, process.platform);
     const client = new OrchestrationClient(endpoint);
     transport = createOrchestrationTransport(endpoint, { client });
@@ -44271,10 +45686,12 @@ async function defaultMcpStdio(args, deps = {}) {
       workspace,
       config: config2,
       state,
-      client
+      client,
+      internalSessionTools: requestedInternalSessionTools
     });
     const eagerIdentity = parsedCoordinatorSession ? await resolveIdentity({ clientName: undefined, listRoots: async () => [] }) : null;
     coordinatorSession = eagerIdentity?.coordinatorSession ?? "";
+    internalSessionTools = eagerIdentity?.internalSessionTools ?? false;
     identityResolver = eagerIdentity ? undefined : resolveIdentity;
   } catch (error2) {
     (deps.stderr ?? ((text) => process.stderr.write(text)))(`${error2 instanceof Error ? error2.message : String(error2)}
@@ -44285,6 +45702,7 @@ async function defaultMcpStdio(args, deps = {}) {
     transport,
     ...coordinatorSession ? { coordinatorSession } : {},
     ...sourceHandle ? { sourceHandle } : {},
+    ...internalSessionTools ? { internalSessionTools: true } : {},
     ...identityResolver ? { resolveIdentity: identityResolver } : {},
     ...availableAgents ? { availableAgents } : {},
     onDiagnostic: (event, context) => {