weacpx 0.5.0 → 0.5.2

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";
@@ -14617,6 +14953,12 @@ async function handleWeixinMessageTurn(full, deps) {
       text: requestText,
       ...media.length > 0 ? { media } : {},
       replyContextToken: contextToken,
+      metadata: {
+        channel: "weixin",
+        chatType: full.group_id ? "group" : "direct",
+        ...full.from_user_id ? { senderId: full.from_user_id } : {},
+        ...full.group_id ? { groupId: full.group_id } : {}
+      },
       perfSpan
     };
     try {
@@ -15552,7 +15894,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 +16230,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 +18412,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 +18422,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 +18434,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 +18466,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 +19258,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 +19395,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 +19424,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 +19442,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 +19498,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 +19516,8 @@ var init_later_handler = __esm(() => {
     notes: [
       "只支持一次性任务，不支持重复执行",
       "时间必须在 10 秒之后、7 天之内",
-      "到点后会把消息发送到创建时绑定的会话（不随之后 /use 切换而改变）",
+      "默认在为本次任务新建的临时会话里执行，跑完即销毁",
+      "加 --bind 改为发送到创建时绑定的当前会话（默认模式可用 later.defaultMode 配置）",
       "/lt list 显示全局待执行任务；群聊中只有群主可取消",
       "不支持延迟执行 / 开头的 weacpx 命令",
       "完整时间格式与说明见 docs/later-command.md"
@@ -19566,6 +19802,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 +19887,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 +20419,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 +20427,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 +20920,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 +21075,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 +21091,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 +21476,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 +22472,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 +22487,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 +24816,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 +24957,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 {
@@ -26409,7 +26765,7 @@ import { join as join13 } from "node:path";
 function buildWeacpxMcpServerSpec(input) {
   const { command, args } = splitCommandLine(input.weacpxCommand);
   return {
-    name: "weacpx-orchestration",
+    name: "weacpx",
     type: "stdio",
     command,
     args: [
@@ -26417,7 +26773,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 +28223,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 +28421,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 +41955,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 +42179,63 @@ function buildWeacpxMcpToolRegistry(input) {
       })
     }
   ];
+  if (internalSessionTools && !isExternalCoordinator && !sourceHandle) {
+    tools.push({
+      name: "scheduled_create",
+      description: "Schedule a one-shot task to run a natural-language message at a future time, using the recorded chat route. By default — and like /later — the task runs in a FRESH TEMPORARY session (it snapshots the current agent and workspace but starts with brand-new history and is destroyed after running, so it does not pollute this conversation); the reply is still pushed back to this chat. Provide only timeText and message and OMIT mode to get this default. Routing, session, and account 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 run at the scheduled time."),
+        mode: scheduledModeSchema.describe("Optional; leave UNSET for the default temporary session (recommended). Set 'bound' ONLY when the user explicitly asks for the task to run inside this conversation's current session and share its context. 'temp' forces the temporary 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 +42315,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 +42498,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 +42619,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);
+    }
   };
 }
 
@@ -42206,7 +42661,7 @@ function createWeacpxMcpServer(options) {
   const taskOptionsById = new Map;
   const watchTasksById = new Map;
   const server = new Server({
-    name: "weacpx-orchestration",
+    name: "weacpx",
     version: readVersion()
   }, {
     capabilities: {
@@ -42238,6 +42693,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 +43129,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 +43219,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 +43314,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 +43331,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 +45011,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 +45057,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 +45145,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 +45504,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 +45672,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 +45692,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 +45708,7 @@ async function defaultMcpStdio(args, deps = {}) {
     transport,
     ...coordinatorSession ? { coordinatorSession } : {},
     ...sourceHandle ? { sourceHandle } : {},
+    ...internalSessionTools ? { internalSessionTools: true } : {},
     ...identityResolver ? { resolveIdentity: identityResolver } : {},
     ...availableAgents ? { availableAgents } : {},
     onDiagnostic: (event, context) => {