weacpx 0.5.0 → 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: []
   };
 });
@@ -9832,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)) {
@@ -9985,10 +10009,13 @@ function parseChatContexts(raw, path3) {
 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);
+  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)
@@ -10080,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";
@@ -15552,7 +15888,11 @@ async function executeScheduledTurn(input, deps) {
         text: input.promptText,
         ...deliveryContextToken ? { replyContextToken: deliveryContextToken } : {},
         ...input.abortSignal ? { abortSignal: input.abortSignal } : {},
-        metadata: { channel: "weixin", scheduledSessionAlias: input.sessionAlias }
+        metadata: {
+          channel: "weixin",
+          scheduledSessionAlias: input.sessionAlias,
+          ...input.sessionDescriptor ? { scheduledSessionDescriptor: input.sessionDescriptor } : {}
+        }
       },
       onReplySegment: sendReplySegment
     });
@@ -15884,78 +16224,6 @@ var init_weixin_channel = __esm(() => {
   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] }));
@@ -18138,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;
@@ -18148,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", {
@@ -18158,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);
@@ -18183,23 +18460,36 @@ async function promptWithSession(context, session, chatKey, text, reply, replyCo
     throw error2;
   }
 }
-async function handlePromptWithSession(context, session, chatKey, text, reply, replyContextToken, accountId, media, abortSignal, onToolEvent, onThought, perfSpan) {
+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) {
+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);
+  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;
@@ -18962,12 +19252,6 @@ 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)
@@ -19105,83 +19389,24 @@ var init_parse_later_time = __esm(() => {
   ]);
 });
 
-// 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) {
+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: [
         "当前没有会话，无法创建定时任务。",
@@ -19193,11 +19418,11 @@ async function handleLaterCreate(tokens, scheduled, chatKey, currentSessionAlias
 `)
     };
   }
-  const result = parseLaterTime(tokens);
+  const result = parseLaterTime(rest);
   if (!result.ok) {
     return { text: renderTimeParseError(result.code, result.value) };
   }
-  const message = tokens.slice(result.messageStartIndex).join(" ").trim();
+  const message = rest.slice(result.messageStartIndex).join(" ").trim();
   if (message.startsWith("/")) {
     return {
       text: [
@@ -19211,13 +19436,15 @@ async function handleLaterCreate(tokens, scheduled, chatKey, currentSessionAlias
   }
   const task = await scheduled.createTask({
     chatKey,
-    sessionAlias: currentSessionAlias,
+    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(currentSessionAlias)) };
+  return { text: renderTaskCreated(task, toDisplaySessionAlias(currentSession.alias)) };
 }
 function handleLaterList(scheduled) {
   const tasks = scheduled.listPending();
@@ -19265,9 +19492,11 @@ var init_later_handler = __esm(() => {
   laterHelpMetadata = {
     topic: "later",
     aliases: ["lt"],
-    summary: "定时任务：延时发送消息到当前会话",
+    summary: "定时任务：到点在临时会话执行（或 --bind 发到当前会话）",
     commands: [
       { usage: "/lt <时间> <消息>", description: "创建定时任务" },
+      { usage: "/lt --bind <时间> <消息>", description: "改为发送到当前会话" },
+      { usage: "/lt --temp <时间> <消息>", description: "强制使用临时会话" },
       { usage: "/lt list", description: "查看待执行定时任务" },
       { usage: "/lt cancel <id>", description: "取消定时任务" }
     ],
@@ -19281,7 +19510,8 @@ var init_later_handler = __esm(() => {
     notes: [
       "只支持一次性任务，不支持重复执行",
       "时间必须在 10 秒之后、7 天之内",
-      "到点后会把消息发送到创建时绑定的会话（不随之后 /use 切换而改变）",
+      "默认在为本次任务新建的临时会话里执行，跑完即销毁",
+      "加 --bind 改为发送到创建时绑定的当前会话（默认模式可用 later.defaultMode 配置）",
       "/lt list 显示全局待执行任务；群聊中只有群主可取消",
       "不支持延迟执行 / 开头的 weacpx 命令",
       "完整时间格式与说明见 docs/later-command.md"
@@ -19566,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}」暂时不可用。`,
@@ -19642,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;
@@ -20171,7 +20413,7 @@ class CommandRouter {
             return { text: renderLaterUnsupportedChannel() };
           }
           const currentSession = await this.sessions.getCurrentSession(chatKey);
-          return await handleLaterCreate(command.tokens, this.scheduled, chatKey, currentSession?.alias ?? null, accountId, replyContextToken);
+          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)
@@ -20179,14 +20421,22 @@ class CommandRouter {
           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);
+            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);
+          return await handlePrompt(sessionContext, chatKey, command.text, reply, replyContextToken, accountId, media, abortSignal, onToolEvent, onThought, perfSpan, metadata);
         }
       }
     });
@@ -20664,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";
@@ -20837,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({
@@ -20847,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");
@@ -21191,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"
   ]);
 });
@@ -22184,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
@@ -22198,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;
@@ -24525,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";
 }
@@ -24650,137 +24951,186 @@ 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;
+// 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`);
   }
-  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;
+  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) });
+      }
+    }
   }
-  listPending() {
-    return Object.values(this.state.scheduled_tasks).filter((task) => task.status === "pending").sort((left, right) => left.execute_at.localeCompare(right.execute_at));
+}
+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");
   }
-  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;
-    });
+  const route = deps.state.orchestration.coordinatorRoutes[coordinatorSession];
+  if (!route) {
+    throw new Error(`no chat route is recorded for coordinator session "${coordinatorSession}"`);
   }
-  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();
-    });
+  if (route.chatType !== "direct" && route.chatType !== "group") {
+    throw new Error("scheduled_create requires current chat route metadata");
   }
-  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 }));
-    });
+  if (route.chatType === "group" && route.isOwner !== true) {
+    throw new Error("scheduled_create is owner-only in group chats");
   }
-  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();
-    });
+  if (deps.supportsScheduledMessages && !deps.supportsScheduledMessages(route.chatKey)) {
+    throw new Error("current channel does not support scheduled tasks");
   }
-  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();
-    });
+  const message = input.message.trim();
+  if (message.length === 0) {
+    throw new Error("message must be a non-empty string");
   }
-  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");
+  if (message.startsWith("/")) {
+    throw new Error("scheduled_create does not support slash-prefixed weacpx commands");
   }
-  async mutate(critical) {
-    return await this.stateMutex.run(critical);
+  if (!route.sessionAlias) {
+    throw new Error("scheduled_create requires current session route metadata");
   }
-  async save() {
-    await this.stateStore.save(this.state);
+  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 normalizeId(input) {
-  return input.trim().replace(/^#/, "").toLowerCase();
+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;
 }
-var init_scheduled_service = () => {};
+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 {
@@ -26417,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"]
     ]
   };
 }
@@ -27867,32 +28217,32 @@ 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 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: 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 } : {}
-      });
-    },
+    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 {
@@ -28065,8 +28415,9 @@ var init_main = __esm(async () => {
   init_build_coordinator_prompt();
   init_scheduled_scheduler();
   init_scheduled_service();
-  init_scheduled_render();
-  init_channel_scope();
+  init_scheduled_dispatch();
+  init_scheduled_route_create();
+  init_scheduled_route_manage();
   init_session_service();
   init_state_store();
   init_run_console();
@@ -41598,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",
@@ -41821,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"
@@ -41900,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}` : "";
@@ -42070,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) => {
@@ -42182,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);
+    }
   };
 }
 
@@ -42238,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;
@@ -42673,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");
@@ -42762,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 } : {}
   });
@@ -42856,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, {
@@ -42868,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))
@@ -44542,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 } : {}
     };
   };
 }
@@ -44587,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() {
@@ -44674,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,
@@ -45022,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`;
 }
@@ -45148,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 });
@@ -45166,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)}
@@ -45180,6 +45702,7 @@ async function defaultMcpStdio(args, deps = {}) {
     transport,
     ...coordinatorSession ? { coordinatorSession } : {},
     ...sourceHandle ? { sourceHandle } : {},
+    ...internalSessionTools ? { internalSessionTools: true } : {},
     ...identityResolver ? { resolveIdentity: identityResolver } : {},
     ...availableAgents ? { availableAgents } : {},
     onDiagnostic: (event, context) => {