weacpx 0.4.9 → 0.5.0

package/dist/cli.js

@@ -1999,6 +1999,7 @@ var require_lib = __commonJS((exports, module) => {
 
 // src/util/private-file.ts
 import { chmod, mkdir, writeFile } from "node:fs/promises";
+import { chmodSync, mkdirSync, writeFileSync } from "node:fs";
 import { dirname } from "node:path";
 async function writePrivateFileAtomic(path, content) {
   await mkdir(dirname(path), { recursive: true });
@@ -2031,6 +2032,25 @@ async function writePrivateFileAtomic(path, content) {
     await release();
   }
 }
+function writePrivateFileSync(path, content, deps = {}) {
+  mkdirSync(dirname(path), { recursive: true });
+  const platform = deps.platform ?? process.platform;
+  const atomicWrite = deps.atomicWrite ?? ((p, c) => import_write_file_atomic.default.sync(p, c, { mode: PRIVATE_FILE_MODE, encoding: "utf8", fsync: true }));
+  try {
+    atomicWrite(path, content);
+  } catch (error) {
+    if (!isTransientWriteError(error, platform)) {
+      throw error;
+    }
+    const directWrite = deps.directWrite ?? ((p, c) => {
+      writeFileSync(p, c, { encoding: "utf8", mode: PRIVATE_FILE_MODE });
+      try {
+        chmodSync(p, PRIVATE_FILE_MODE);
+      } catch {}
+    });
+    directWrite(path, content);
+  }
+}
 async function retryTransientWriteErrors(run, options = {}) {
   const platform = options.platform ?? process.platform;
   const maxAttempts = options.maxAttempts ?? WRITE_RETRY_MAX_ATTEMPTS;
@@ -2206,6 +2226,9 @@ function parseConfig(raw, options = {}) {
       throw new Error("transport.permissionPolicy must be a non-empty string");
     }
   }
+  if ("queueOwnerTtlSeconds" in transport && (typeof transport.queueOwnerTtlSeconds !== "number" || !Number.isFinite(transport.queueOwnerTtlSeconds) || transport.queueOwnerTtlSeconds < 0)) {
+    throw new Error("transport.queueOwnerTtlSeconds must be a non-negative number (0 = keep alive forever)");
+  }
   if (!isRecord(raw.agents)) {
     throw new Error("agents must be an object");
   }
@@ -2302,7 +2325,8 @@ function parseConfig(raw, options = {}) {
       ...typeof transport.permissionPolicy === "string" ? { permissionPolicy: transport.permissionPolicy } : {},
       type: transportType,
       permissionMode,
-      nonInteractivePermissions
+      nonInteractivePermissions,
+      queueOwnerTtlSeconds: typeof transport.queueOwnerTtlSeconds === "number" ? transport.queueOwnerTtlSeconds : DEFAULT_QUEUE_OWNER_TTL_SECONDS
     },
     logging: {
       level: resolvedLoggingLevel,
@@ -2428,7 +2452,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_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;
 var init_load_config = __esm(() => {
   init_workspace_path();
   DEFAULT_PERF_LOG_CONFIG = {
@@ -2729,7 +2753,7 @@ class DaemonStatusStore {
 var init_daemon_status = () => {};
 
 // src/daemon/daemon-controller.ts
-import { mkdir as mkdir3, readFile as readFile4, rm as rm2, writeFile as writeFile3 } from "node:fs/promises";
+import { mkdir as mkdir3, open, readFile as readFile4, rm as rm2 } from "node:fs/promises";
 import { dirname as dirname3 } from "node:path";
 
 class DaemonController {
@@ -2788,9 +2812,19 @@ class DaemonController {
     if (current.state === "indeterminate") {
       throw new Error(`weacpx daemon process is already running (pid ${current.pid}) but status metadata is missing`);
     }
-    await this.statusStore.clear();
-    const pid = await this.deps.spawnDetached(options);
-    await this.writePid(pid);
+    const pidHandle = await this.openPidFileExclusive();
+    let pid;
+    try {
+      await this.statusStore.clear();
+      pid = await this.deps.spawnDetached(options);
+      await pidHandle.write(`${pid}
+`);
+    } catch (error) {
+      await pidHandle.close().catch(() => {});
+      await rm2(this.paths.pidFile, { force: true }).catch(() => {});
+      throw error;
+    }
+    await pidHandle.close();
     await this.waitForStartupMetadata(pid, options.firstRunOnboarding ? this.onboardingStartupTimeoutMs : this.startupTimeoutMs, options.startupWait);
     return { state: "started", pid };
   }
@@ -2818,10 +2852,16 @@ class DaemonController {
       throw error;
     }
   }
-  async writePid(pid) {
+  async openPidFileExclusive() {
     await mkdir3(dirname3(this.paths.pidFile), { recursive: true });
-    await writeFile3(this.paths.pidFile, `${pid}
-`);
+    try {
+      return await open(this.paths.pidFile, "wx", 384);
+    } catch (error) {
+      if (error.code === "EEXIST") {
+        throw new Error(`weacpx daemon pid file already exists (${this.paths.pidFile}); another start may be in progress`);
+      }
+      throw error;
+    }
   }
   async clearRuntimeFiles() {
     await rm2(this.paths.pidFile, { force: true });
@@ -2918,15 +2958,17 @@ async function defaultRunProcessCommand(command, args) {
 var init_terminate_process_tree = () => {};
 
 // src/daemon/create-daemon-controller.ts
-import { mkdir as mkdir4, open } from "node:fs/promises";
+import { mkdir as mkdir4, open as open2 } from "node:fs/promises";
 import { spawn as spawn2 } from "node:child_process";
 function createDaemonController(paths, options) {
   return new DaemonController(paths, {
     isProcessRunning: options.isProcessRunning ?? defaultIsProcessRunning2,
     spawnDetached: async (spawnOptions) => {
       await mkdir4(paths.runtimeDir, { recursive: true });
-      const stdoutHandle = await open(paths.stdoutLog, "a");
-      const stderrHandle = await open(paths.stderrLog, "a");
+      const stdoutHandle = await open2(paths.stdoutLog, "a", 384);
+      const stderrHandle = await open2(paths.stderrLog, "a", 384);
+      await stdoutHandle.chmod(384).catch(() => {});
+      await stderrHandle.chmod(384).catch(() => {});
       try {
         return await (options.spawnProcess ?? defaultSpawnProcess)(buildSpawnRequest(paths, options, stdoutHandle.fd, stderrHandle.fd, spawnOptions));
       } finally {
@@ -9693,7 +9735,8 @@ function createEmptyState() {
   return {
     sessions: {},
     chat_contexts: {},
-    orchestration: createEmptyOrchestrationState()
+    orchestration: createEmptyOrchestrationState(),
+    scheduled_tasks: {}
   };
 }
 var init_types = () => {};
@@ -9939,6 +9982,29 @@ function parseChatContexts(raw, path3) {
   }
   return chatContexts;
 }
+function isScheduledTaskStatus(value) {
+  return value === "pending" || value === "triggering" || value === "executed" || value === "cancelled" || value === "missed" || value === "failed";
+}
+function isScheduledTaskRecord(value) {
+  if (!isRecord2(value))
+    return false;
+  return isString(value.id) && isString(value.chat_key) && isString(value.session_alias) && isString(value.execute_at) && isString(value.message) && isScheduledTaskStatus(value.status) && isString(value.created_at) && isOptionalString(value.account_id) && isOptionalString(value.reply_context_token) && isOptionalString(value.source_label) && isOptionalString(value.triggered_at) && isOptionalString(value.executed_at) && isOptionalString(value.cancelled_at) && isOptionalString(value.missed_at) && isOptionalString(value.failed_at) && isOptionalString(value.last_error);
+}
+function parseScheduledTasks(raw, path3) {
+  if (raw === undefined)
+    return {};
+  if (!isRecord2(raw)) {
+    throw new Error(`state file "${path3}" must contain an object field "scheduled_tasks"`);
+  }
+  const tasks = {};
+  for (const [id, value] of Object.entries(raw)) {
+    if (!isScheduledTaskRecord(value) || value.id !== id) {
+      throw new Error(`state file "${path3}" contains malformed scheduled task record "${id}"`);
+    }
+    tasks[id] = value;
+  }
+  return tasks;
+}
 function parseState(raw, path3) {
   if (!isRecord2(raw)) {
     throw new Error(`state file "${path3}" must contain a JSON object`);
@@ -9957,7 +10023,8 @@ function parseState(raw, path3) {
   return {
     sessions: parsedSessions,
     chat_contexts: parseChatContexts(chatContexts, path3),
-    orchestration
+    orchestration,
+    scheduled_tasks: parseScheduledTasks(raw.scheduled_tasks, path3)
   };
 }
 function validateExternalCoordinatorIdentityCollisions(sessions, orchestration, path3) {
@@ -10014,7 +10081,7 @@ var init_state_store = __esm(() => {
 });
 
 // src/plugins/plugin-home.ts
-import { mkdir as mkdir6, writeFile as writeFile5 } from "node:fs/promises";
+import { mkdir as mkdir6, writeFile as writeFile4 } from "node:fs/promises";
 import { homedir as homedir3 } from "node:os";
 import { join as join3 } from "node:path";
 function coerceMissing(value) {
@@ -10040,7 +10107,7 @@ function resolvePluginHome(input = {}) {
 }
 async function ensurePluginHome(pluginHome) {
   await mkdir6(pluginHome, { recursive: true, mode: 448 });
-  await writeFile5(join3(pluginHome, "package.json"), JSON.stringify({ private: true, type: "module" }, null, 2) + `
+  await writeFile4(join3(pluginHome, "package.json"), JSON.stringify({ private: true, type: "module" }, null, 2) + `
 `, { flag: "wx" }).catch((error2) => {
     if (error2.code !== "EEXIST")
       throw error2;
@@ -10179,8 +10246,6 @@ function loadWeixinAccount(accountId) {
   return null;
 }
 function saveWeixinAccount(accountId, update) {
-  const dir = resolveAccountsDir();
-  ensureDirSync(dir);
   const existing = loadWeixinAccount(accountId) ?? {};
   const token = update.token?.trim() || existing.token;
   const baseUrl = update.baseUrl?.trim() || existing.baseUrl;
@@ -10190,11 +10255,7 @@ function saveWeixinAccount(accountId, update) {
     ...baseUrl ? { baseUrl } : {},
     ...userId ? { userId } : {}
   };
-  const filePath = resolveAccountPath(accountId);
-  fs3.writeFileSync(filePath, JSON.stringify(data, null, 2), "utf-8");
-  try {
-    fs3.chmodSync(filePath, 384);
-  } catch {}
+  writePrivateFileSync(resolveAccountPath(accountId), JSON.stringify(data, null, 2));
 }
 function clearWeixinAccount(accountId) {
   try {
@@ -10295,6 +10356,7 @@ var DEFAULT_BASE_URL = "https://ilinkai.weixin.qq.com", CDN_BASE_URL = "https://
 var init_accounts = __esm(() => {
   init_ensure_dir();
   init_state_dir();
+  init_private_file();
 });
 
 // src/weixin/util/logger.ts
@@ -12298,8 +12360,7 @@ function persistContextTokens(accountId) {
   }
   const filePath = resolveContextTokenFilePath(accountId);
   try {
-    fs5.mkdirSync(path6.dirname(filePath), { recursive: true });
-    fs5.writeFileSync(filePath, JSON.stringify(tokens), "utf-8");
+    writePrivateFileSync(filePath, JSON.stringify(tokens));
   } catch (err) {
     logger.warn(`persistContextTokens: failed to write ${filePath}: ${String(err)}`);
   }
@@ -12422,6 +12483,7 @@ var init_inbound = __esm(() => {
   init_random();
   init_types2();
   init_state_dir();
+  init_private_file();
   contextTokenStore = new Map;
 });
 
@@ -12544,7 +12606,7 @@ function createConversationExecutor() {
 }
 
 // src/channels/media-store.ts
-import { access as access2, mkdir as mkdir7, readdir, rm as rm4, stat, writeFile as writeFile6 } from "node:fs/promises";
+import { access as access2, mkdir as mkdir7, readdir, rm as rm4, stat, writeFile as writeFile5 } from "node:fs/promises";
 import path7 from "node:path";
 
 class RuntimeMediaStore {
@@ -12568,7 +12630,7 @@ class RuntimeMediaStore {
     if (!isPathInside(resolvedFile, resolvedRoot)) {
       throw new Error("media path escapes runtime media root");
     }
-    await writeFile6(resolvedFile, input.buffer);
+    await writeFile5(resolvedFile, input.buffer);
     return {
       kind: input.kind,
       filePath: resolvedFile,
@@ -14789,13 +14851,11 @@ function loadGetUpdatesBuf(filePath) {
   return readSyncBufFile(getLegacySyncBufDefaultJsonPath());
 }
 function saveGetUpdatesBuf(filePath, getUpdatesBuf) {
-  const dir = path13.dirname(filePath);
-  ensureDirSync(dir);
-  fs10.writeFileSync(filePath, JSON.stringify({ get_updates_buf: getUpdatesBuf }, null, 0), "utf-8");
+  writePrivateFileSync(filePath, JSON.stringify({ get_updates_buf: getUpdatesBuf }, null, 0));
 }
 var init_sync_buf = __esm(() => {
   init_accounts();
-  init_ensure_dir();
+  init_private_file();
   init_state_dir();
 });
 
@@ -15407,8 +15467,179 @@ var init_deliver_coordinator_message = __esm(() => {
   init_send();
 });
 
+// src/weixin/messaging/scheduled-turn.ts
+async function executeScheduledTurn(input, deps) {
+  const userId = normalizeWeixinUserIdFromChatKey(input.chatKey);
+  const quotaKey = userId;
+  const sendMessage2 = deps.sendMessage ?? sendMessageWeixin;
+  const candidateAccountIds = input.accountId ? [input.accountId] : deps.listAccountIds();
+  if (candidateAccountIds.length === 0) {
+    throw new Error(`no weixin account is available for scheduled message on chatKey: ${input.chatKey}`);
+  }
+  let noticeSent = false;
+  let lastNoticeError;
+  let deliveryAccountId;
+  let deliveryContextToken;
+  let deliverableAccountId;
+  let deliverableContextToken;
+  const resolveContextToken = (candidateAccountId) => deps.getContextToken(candidateAccountId, userId) ?? (candidateAccountId === input.accountId ? input.replyContextToken : undefined);
+  for (const candidateAccountId of candidateAccountIds) {
+    const contextToken = resolveContextToken(candidateAccountId);
+    if (!contextToken)
+      continue;
+    const account = deps.resolveAccount(candidateAccountId);
+    if (!account.token)
+      continue;
+    if (!deliverableAccountId) {
+      deliverableAccountId = candidateAccountId;
+      deliverableContextToken = contextToken;
+    }
+    try {
+      if (!deps.reserveMidSegment(quotaKey)) {
+        throw new Error("mid segment quota exhausted");
+      }
+      await sendMessage2({
+        to: userId,
+        text: input.noticeText,
+        opts: { baseUrl: account.baseUrl, token: account.token, contextToken }
+      });
+      noticeSent = true;
+      deliveryAccountId = candidateAccountId;
+      deliveryContextToken = contextToken;
+      break;
+    } catch (error2) {
+      lastNoticeError = error2;
+      await deps.logger.error("scheduled.notice_send_failed", "failed to send scheduled notice", { chatKey: input.chatKey, accountId: candidateAccountId, error: String(error2) });
+    }
+  }
+  if (!noticeSent) {
+    if (!deliverableAccountId || !deliverableContextToken) {
+      const message = lastNoticeError instanceof Error ? lastNoticeError.message : `no deliverable weixin context for scheduled message on chatKey: ${input.chatKey}`;
+      throw new Error(message);
+    }
+    deliveryAccountId = deliverableAccountId;
+    deliveryContextToken = deliverableContextToken;
+    await deps.logger.info("scheduled.notice_skipped", "scheduled trigger notice was not delivered; proceeding with agent turn", {
+      chatKey: input.chatKey,
+      accountId: deliveryAccountId,
+      reason: lastNoticeError instanceof Error ? lastNoticeError.message : "notice_undelivered"
+    });
+  }
+  const sendReplySegment = async (text) => {
+    const plainText = markdownToPlainText(text).trim();
+    if (plainText.length === 0)
+      return false;
+    return await sendTextViaAvailableAccount(plainText, "scheduled.mid_send_failed");
+  };
+  const sendReservedMidText = async (text) => {
+    const plainText = markdownToPlainText(text).trim();
+    if (plainText.length === 0)
+      return false;
+    if (!deps.reserveMidSegment(quotaKey)) {
+      await deps.logger.info("scheduled.mid_dropped", "scheduled turn intermediate response dropped due to quota", { chatKey: input.chatKey, reason: "quota_exhausted" });
+      return false;
+    }
+    return await sendTextViaAvailableAccount(plainText, "scheduled.mid_send_failed");
+  };
+  const resolvedAccountId = deliveryAccountId ?? input.accountId ?? candidateAccountIds[0];
+  let turn;
+  try {
+    turn = await executeChatTurn({
+      agent: deps.agent,
+      request: {
+        accountId: resolvedAccountId,
+        conversationId: input.chatKey,
+        text: input.promptText,
+        ...deliveryContextToken ? { replyContextToken: deliveryContextToken } : {},
+        ...input.abortSignal ? { abortSignal: input.abortSignal } : {},
+        metadata: { channel: "weixin", scheduledSessionAlias: input.sessionAlias }
+      },
+      onReplySegment: sendReplySegment
+    });
+  } catch (error2) {
+    await sendReservedMidText(`定时任务执行失败：${error2 instanceof Error ? error2.message : String(error2)}`).catch(() => false);
+    throw error2;
+  }
+  if (turn.text) {
+    const finalText = markdownToPlainText(turn.text).trim();
+    if (finalText.length > 0) {
+      await sendFinalText(finalText);
+    }
+  }
+  async function sendFinalText(finalText) {
+    const rawChunks = chunkFinalText(finalText, 1800);
+    if (rawChunks.length === 0)
+      return;
+    const total = rawChunks.length;
+    const chunks = total === 1 ? rawChunks : rawChunks.map((body, index) => `(${index + 1}/${total}) ${body}`);
+    const available = total === 1 ? 1 : Math.max(Math.min(deps.finalRemaining?.(quotaKey) ?? total, total), 0);
+    const wave = chunks.slice(0, available);
+    if (wave.length > 0 && wave.length < total) {
+      wave[wave.length - 1] = `${wave[wave.length - 1]}
+
+${buildFinalHeadsUp({
+        total,
+        sentSoFar: wave.length
+      })}`;
+    }
+    let sent = 0;
+    for (let index = 0;index < wave.length; index += 1) {
+      if (!deps.reserveFinal(quotaKey)) {
+        await deps.logger.info("scheduled.final_dropped", "scheduled turn final response dropped due to quota", { chatKey: input.chatKey, reason: "quota_exhausted", chunk: index + 1, total });
+        break;
+      }
+      const delivered = await sendTextViaAvailableAccount(wave[index], "scheduled.final_send_failed");
+      if (!delivered)
+        break;
+      sent += 1;
+    }
+    const restToPark = chunks.slice(sent);
+    if (total > 1 && restToPark.length > 0 && deps.enqueuePendingFinal) {
+      const pending = restToPark.map((text, index) => {
+        const entry = { text, seq: sent + index + 1, total };
+        if (deliveryContextToken)
+          entry.contextToken = deliveryContextToken;
+        if (deliveryAccountId)
+          entry.accountId = deliveryAccountId;
+        return entry;
+      });
+      deps.enqueuePendingFinal(quotaKey, pending);
+    }
+  }
+  async function sendTextViaAvailableAccount(text, errorEvent) {
+    const orderedAccountIds = [
+      ...deliveryAccountId ? [deliveryAccountId] : [],
+      ...candidateAccountIds.filter((accountId) => accountId !== deliveryAccountId)
+    ];
+    for (const candidateAccountId of orderedAccountIds) {
+      const contextToken = candidateAccountId === deliveryAccountId && deliveryContextToken ? deliveryContextToken : resolveContextToken(candidateAccountId);
+      if (!contextToken)
+        continue;
+      const account = deps.resolveAccount(candidateAccountId);
+      if (!account.token)
+        continue;
+      try {
+        await sendMessage2({
+          to: userId,
+          text,
+          opts: { baseUrl: account.baseUrl, token: account.token, contextToken }
+        });
+        return true;
+      } catch (error2) {
+        await deps.logger.error(errorEvent, "failed to send scheduled response text", { chatKey: input.chatKey, accountId: candidateAccountId, error: String(error2) });
+      }
+    }
+    return false;
+  }
+}
+var init_scheduled_turn = __esm(() => {
+  init_handle_weixin_message_turn();
+  init_send();
+  init_inbound();
+});
+
 // src/weixin/monitor/consumer-lock.ts
-import { mkdir as mkdir8, open as open2, readFile as readFile6, rm as rm6 } from "node:fs/promises";
+import { mkdir as mkdir8, open as open3, readFile as readFile6, rm as rm6 } from "node:fs/promises";
 import { dirname as dirname8, join as join5 } from "node:path";
 import { homedir as homedir4 } from "node:os";
 function createWeixinConsumerLock(options = {}) {
@@ -15420,7 +15651,7 @@ function createWeixinConsumerLock(options = {}) {
       await mkdir8(dirname8(lockFilePath), { recursive: true });
       while (true) {
         try {
-          const handle = await open2(lockFilePath, "wx");
+          const handle = await open3(lockFilePath, "wx");
           try {
             await handle.writeFile(`${JSON.stringify(meta2, null, 2)}
 `, "utf8");
@@ -15533,6 +15764,7 @@ var init_consumer_lock = __esm(() => {
 // src/channels/weixin-channel.ts
 class WeixinChannel {
   id = "weixin";
+  agent = null;
   quota = null;
   logger = null;
   markDelivered = null;
@@ -15563,6 +15795,7 @@ class WeixinChannel {
     this.markFailed = callbacks.markTaskNoticeFailed;
   }
   async start(input) {
+    this.agent = input.agent;
     this.quota = input.quota;
     this.logger = input.logger;
     if (!this.isLoggedIn()) {
@@ -15623,6 +15856,23 @@ class WeixinChannel {
       logger: this.logger
     });
   }
+  async sendScheduledMessage(input) {
+    if (!this.agent || !this.quota || !this.logger) {
+      throw new Error("WeixinChannel.start() must be called before scheduled message delivery");
+    }
+    await executeScheduledTurn(input, {
+      agent: this.agent,
+      listAccountIds: () => listWeixinAccountIds(),
+      resolveAccount: (accountId) => resolveWeixinAccount(accountId),
+      getContextToken: (accountId, userId) => getContextToken(accountId, userId),
+      reserveMidSegment: (chatKey) => this.quota.reserveMidSegment(chatKey),
+      reserveFinal: (chatKey) => this.quota.reserveFinal(chatKey),
+      finalRemaining: (chatKey) => this.quota.finalRemaining(chatKey),
+      enqueuePendingFinal: (chatKey, chunks) => this.quota.enqueuePendingFinal(chatKey, chunks),
+      sendMessage: sendMessageWeixin,
+      logger: this.logger
+    });
+  }
 }
 var init_weixin_channel = __esm(() => {
   init_weixin();
@@ -15630,6 +15880,7 @@ var init_weixin_channel = __esm(() => {
   init_deliver_orchestration_task_notice();
   init_deliver_orchestration_task_progress();
   init_deliver_coordinator_message();
+  init_scheduled_turn();
   init_consumer_lock();
 });
 
@@ -16014,7 +16265,7 @@ function validatePluginCompatibility(metadata, context) {
     }
   }
 }
-var WEACPX_PLUGIN_API_VERSION = 1, WEACPX_PLUGIN_API_SUPPORTED_VERSIONS, WEACPX_PLUGIN_MIN_CORE_VERSION = "0.4.0", SEMVER_RE;
+var WEACPX_PLUGIN_API_VERSION = 1, WEACPX_PLUGIN_API_SUPPORTED_VERSIONS, WEACPX_PLUGIN_MIN_CORE_VERSION = "0.5.0", SEMVER_RE;
 var init_compatibility = __esm(() => {
   WEACPX_PLUGIN_API_SUPPORTED_VERSIONS = [1];
   SEMVER_RE = /^(\d+)\.(\d+)\.(\d+)$/;
@@ -16105,21 +16356,27 @@ async function loadConfiguredPlugins(input) {
   const importPlugin = input.importPlugin ?? importPluginFromHome;
   const loaded = [];
   for (const config2 of enabled) {
-    let moduleValue;
     try {
-      moduleValue = await importPlugin(config2.name, pluginHome);
+      let moduleValue;
+      try {
+        moduleValue = await importPlugin(config2.name, pluginHome);
+      } catch (error2) {
+        const message = error2 instanceof Error ? error2.message : String(error2);
+        throw new Error(`failed to load plugin ${config2.name}: ${message}`);
+      }
+      const plugin = validateWeacpxPlugin(moduleValue, config2.name, {
+        ...input.currentWeacpxVersion !== undefined ? { currentWeacpxVersion: input.currentWeacpxVersion } : {}
+      });
+      const channels = plugin.channels ?? [];
+      for (const channel of channels) {
+        registerChannelPlugin(channel);
+      }
+      loaded.push({ name: config2.name, channels: channels.map((channel) => channel.type) });
     } catch (error2) {
-      const message = error2 instanceof Error ? error2.message : String(error2);
-      throw new Error(`failed to load plugin ${config2.name}: ${message}`);
-    }
-    const plugin = validateWeacpxPlugin(moduleValue, config2.name, {
-      ...input.currentWeacpxVersion !== undefined ? { currentWeacpxVersion: input.currentWeacpxVersion } : {}
-    });
-    const channels = plugin.channels ?? [];
-    for (const channel of channels) {
-      registerChannelPlugin(channel);
+      if (!input.onPluginError)
+        throw error2;
+      input.onPluginError({ name: config2.name, error: error2 });
     }
-    loaded.push({ name: config2.name, channels: channels.map((channel) => channel.type) });
   }
   return loaded;
 }
@@ -16140,7 +16397,7 @@ var init_bootstrap = __esm(() => {
 });
 
 // src/logging/app-logger.ts
-import { appendFile, mkdir as mkdir9 } from "node:fs/promises";
+import { appendFile, chmod as chmod2, mkdir as mkdir9 } from "node:fs/promises";
 import { dirname as dirname10 } from "node:path";
 function createNoopAppLogger() {
   return {
@@ -16154,6 +16411,7 @@ function createNoopAppLogger() {
 function createAppLogger(options) {
   const now = options.now ?? (() => new Date);
   let writeChain = Promise.resolve();
+  let modeEnsured = false;
   return {
     debug: async (event, message, context) => {
       await enqueueWrite("debug", event, message, context);
@@ -16182,8 +16440,12 @@ function createAppLogger(options) {
     }
     const line = formatLogLine(now(), level, event, message, context);
     await mkdir9(dirname10(options.filePath), { recursive: true });
+    if (!modeEnsured) {
+      modeEnsured = true;
+      await chmod2(options.filePath, 384).catch(() => {});
+    }
     await rotateIfNeeded(options.filePath, Buffer.byteLength(line), options.maxSizeBytes, options.maxFiles);
-    await appendFile(options.filePath, line, "utf8");
+    await appendFile(options.filePath, line, { encoding: "utf8", mode: 384 });
   }
 }
 function formatLogLine(time3, level, event, message, context) {
@@ -16389,7 +16651,9 @@ var init_command_list = __esm(() => {
     "/dg",
     "/group",
     "/groups",
-    "/task"
+    "/task",
+    "/later",
+    "/lt"
   ];
   KNOWN_COMMAND_PREFIX_SET = new Set(WEACPX_KNOWN_COMMAND_PREFIXES);
 });
@@ -16557,6 +16821,16 @@ function parseCommand(input) {
   } else if (command === "/task" && parts[1] && parts.length === 2) {
     return { kind: "task.get", taskId: parts[1] };
   }
+  if (command === "/later") {
+    if (parts.length === 1)
+      return { kind: "later.help" };
+    if (parts[1] === "list" && parts.length === 2)
+      return { kind: "later.list" };
+    if (parts[1] === "cancel" && parts[2] && parts.length === 3) {
+      return { kind: "later.cancel", id: parts[2] };
+    }
+    return { kind: "later.create", tokens: parts.slice(1) };
+  }
   if (command === "/workspace" && parts[1] === "new" && parts[2]) {
     const name = parts[2];
     let cwd = "";
@@ -16725,6 +16999,8 @@ function normalizeCommand(command) {
     return "/permission";
   if (command === "/stop")
     return "/cancel";
+  if (command === "/lt")
+    return "/later";
   return command;
 }
 function isRecognizedCommand(command) {
@@ -16920,6 +17196,7 @@ var init_command_policy = __esm(() => {
     "group.get",
     "tasks",
     "task.get",
+    "later.help",
     "invalid",
     "prompt"
   ]);
@@ -16949,7 +17226,10 @@ var init_command_policy = __esm(() => {
     "session.new": "/session new",
     "session.shortcut": "/session",
     "session.shortcut.new": "/session",
-    "session.attach": "/session attach"
+    "session.attach": "/session attach",
+    "later.create": "/later",
+    "later.list": "/later list",
+    "later.cancel": "/later cancel"
   };
 });
 
@@ -17903,11 +18183,7 @@ async function promptWithSession(context, session, chatKey, text, reply, replyCo
     throw error2;
   }
 }
-async function handlePrompt(context, chatKey, text, reply, replyContextToken, accountId, media, abortSignal, onToolEvent, onThought, perfSpan) {
-  const session = await context.sessions.getCurrentSession(chatKey);
-  if (!session) {
-    return { text: NO_CURRENT_SESSION_TEXT };
-  }
+async function handlePromptWithSession(context, session, chatKey, text, reply, replyContextToken, accountId, media, abortSignal, onToolEvent, onThought, perfSpan) {
   try {
     return await promptWithSession(context, session, chatKey, text, reply, replyContextToken, accountId, media, abortSignal, onToolEvent, onThought, perfSpan);
   } catch (error2) {
@@ -17918,6 +18194,13 @@ async function handlePrompt(context, chatKey, text, reply, replyContextToken, ac
     return context.recovery.renderTransportError(session, error2);
   }
 }
+async function handlePrompt(context, chatKey, text, reply, replyContextToken, accountId, media, abortSignal, onToolEvent, onThought, perfSpan) {
+  const session = await context.sessions.getCurrentSession(chatKey);
+  if (!session) {
+    return { text: NO_CURRENT_SESSION_TEXT };
+  }
+  return await handlePromptWithSession(context, session, chatKey, text, reply, replyContextToken, accountId, media, abortSignal, onToolEvent, onThought, perfSpan);
+}
 async function preparePromptWithFallback(context, session, chatKey, text, replyContextToken, accountId) {
   const orchestration = context.orchestration;
   if (!orchestration) {
@@ -18679,6 +18962,333 @@ var init_workspace_handler = __esm(() => {
   };
 });
 
+// src/scheduled/scheduled-types.ts
+var LATER_MIN_DELAY_MS = 1e4, LATER_MAX_DELAY_MS, LATER_MESSAGE_PREVIEW_CHARS = 120;
+var init_scheduled_types = __esm(() => {
+  LATER_MAX_DELAY_MS = 7 * 24 * 60 * 60 * 1000;
+});
+
+// src/scheduled/parse-later-time.ts
+function parseLaterTime(tokens, now = new Date) {
+  if (tokens.length === 0)
+    return { ok: false, code: "missing_time" };
+  const relative = parseRelative(tokens, now);
+  if (relative)
+    return validateResult(relative.executeAt, relative.messageStartIndex, tokens, now);
+  const absolute = parseAbsolute(tokens, now);
+  if (absolute)
+    return validateResult(absolute.executeAt, absolute.messageStartIndex, tokens, now, absolute.pastTodayValue);
+  return { ok: false, code: "unrecognized_time" };
+}
+function parseRelative(tokens, now) {
+  if (tokens[0] === "in" && tokens[1]) {
+    const ms = parseDuration(tokens[1]);
+    if (ms !== null)
+      return { executeAt: new Date(now.getTime() + ms), messageStartIndex: 2 };
+  }
+  const zh = /^(\d+)(分钟|小时|天)后$/.exec(tokens[0] ?? "");
+  if (zh) {
+    const amount = Number(zh[1]);
+    const unit = zh[2];
+    const ms = unit === "分钟" ? amount * 60000 : unit === "小时" ? amount * 3600000 : amount * 86400000;
+    return { executeAt: new Date(now.getTime() + ms), messageStartIndex: 1 };
+  }
+  return null;
+}
+function parseDuration(value) {
+  const match = /^(\d+)(m|min|minute|minutes|h|hour|hours|d|day|days)$/.exec(value.toLowerCase());
+  if (!match)
+    return null;
+  const amount = Number(match[1]);
+  const unit = match[2];
+  if (unit === "m" || unit === "min" || unit === "minute" || unit === "minutes")
+    return amount * 60000;
+  if (unit === "h" || unit === "hour" || unit === "hours")
+    return amount * 3600000;
+  return amount * 86400000;
+}
+function parseAbsolute(tokens, now) {
+  if (tokens[0] === "at" && tokens[1]) {
+    const parsed = parseClock(tokens[1]);
+    if (!parsed)
+      return null;
+    const executeAt = atLocalDate(now, 0, parsed.hour, parsed.minute);
+    if (executeAt.getTime() <= now.getTime())
+      return { executeAt, messageStartIndex: 2, pastTodayValue: tokens[1] };
+    return { executeAt, messageStartIndex: 2 };
+  }
+  const dayWord = tokens[0]?.toLowerCase();
+  const dayOffset = dayWord === "today" || dayWord === "今天" ? 0 : dayWord === "tomorrow" || dayWord === "明天" ? 1 : dayWord === "后天" ? 2 : null;
+  if (dayOffset !== null && tokens[1]) {
+    const parsed = parseClock(tokens[1]);
+    if (!parsed)
+      return null;
+    const executeAt = atLocalDate(now, dayOffset, parsed.hour, parsed.minute);
+    if (dayOffset === 0 && executeAt.getTime() <= now.getTime())
+      return { executeAt, messageStartIndex: 2, pastTodayValue: tokens[1] };
+    return { executeAt, messageStartIndex: 2 };
+  }
+  const weekday = WEEKDAYS.get(tokens[0]?.toLowerCase() ?? "");
+  if (weekday !== undefined && tokens[1]) {
+    const parsed = parseClock(tokens[1]);
+    if (!parsed)
+      return null;
+    let days = (weekday - now.getDay() + 7) % 7;
+    let executeAt = atLocalDate(now, days, parsed.hour, parsed.minute);
+    if (days === 0 && executeAt.getTime() <= now.getTime()) {
+      days = 7;
+      executeAt = atLocalDate(now, days, parsed.hour, parsed.minute);
+    }
+    return { executeAt, messageStartIndex: 2 };
+  }
+  return null;
+}
+function parseClock(value) {
+  const match = /^(\d{1,2}):(\d{2})$/.exec(value);
+  if (!match)
+    return null;
+  const hour = Number(match[1]);
+  const minute = Number(match[2]);
+  if (hour < 0 || hour > 23 || minute < 0 || minute > 59)
+    return null;
+  return { hour, minute };
+}
+function atLocalDate(now, dayOffset, hour, minute) {
+  return new Date(now.getFullYear(), now.getMonth(), now.getDate() + dayOffset, hour, minute, 0, 0);
+}
+function validateResult(executeAt, messageStartIndex, tokens, now, pastTodayValue) {
+  if (pastTodayValue)
+    return { ok: false, code: "past_today_time", value: pastTodayValue };
+  if (tokens.slice(messageStartIndex).join(" ").trim().length === 0)
+    return { ok: false, code: "missing_message" };
+  const delta = executeAt.getTime() - now.getTime();
+  if (delta < LATER_MIN_DELAY_MS)
+    return { ok: false, code: "too_soon" };
+  if (delta > LATER_MAX_DELAY_MS)
+    return { ok: false, code: "out_of_range" };
+  return { ok: true, executeAt, messageStartIndex };
+}
+var WEEKDAYS;
+var init_parse_later_time = __esm(() => {
+  init_scheduled_types();
+  WEEKDAYS = new Map([
+    ["周日", 0],
+    ["周天", 0],
+    ["星期日", 0],
+    ["星期天", 0],
+    ["sun", 0],
+    ["sunday", 0],
+    ["周一", 1],
+    ["星期一", 1],
+    ["mon", 1],
+    ["monday", 1],
+    ["周二", 2],
+    ["星期二", 2],
+    ["tue", 2],
+    ["tuesday", 2],
+    ["周三", 3],
+    ["星期三", 3],
+    ["wed", 3],
+    ["wednesday", 3],
+    ["周四", 4],
+    ["星期四", 4],
+    ["thu", 4],
+    ["thursday", 4],
+    ["周五", 5],
+    ["星期五", 5],
+    ["fri", 5],
+    ["friday", 5],
+    ["周六", 6],
+    ["星期六", 6],
+    ["sat", 6],
+    ["saturday", 6]
+  ]);
+});
+
+// src/scheduled/scheduled-render.ts
+function renderLaterHelp() {
+  return [
+    "定时任务用法：",
+    "",
+    "创建：",
+    "/lt in 2h 检查 CI",
+    "/lt 30分钟后 总结进展",
+    "/lt tomorrow 09:00 看 PR",
+    "/lt 周五 09:00 继续处理",
+    "",
+    "查看：",
+    "/lt list",
+    "",
+    "取消：",
+    "/lt cancel <id>",
+    "",
+    "说明：",
+    "- 只支持一次性任务",
+    "- 时间必须在 10 秒之后、7 天之内",
+    "- 到点后会把消息发送到创建时绑定的会话",
+    "- 触发通知和 agent 回复复用现有频道路由；微信回复额度由现有路由控制",
+    "- 不支持延迟执行 / 开头的 weacpx 命令",
+    "- 完整时间格式与说明见 docs/later-command.md"
+  ].join(`
+`);
+}
+function renderLaterUnsupportedChannel() {
+  return [
+    "当前频道暂不支持定时任务，未创建任务。",
+    "",
+    "原因：这个频道还没有实现定时消息投递能力，任务到点后无法把结果发回原聊天。",
+    "请切换到支持定时任务的频道后再使用 /lt。"
+  ].join(`
+`);
+}
+function renderTaskCreated(task, displaySession) {
+  return [
+    `已创建定时任务 #${task.id}`,
+    `执行时间：${formatLocalDateTime(new Date(task.execute_at))}`,
+    `会话：${displaySession}`,
+    `内容：${preview(task.message)}`
+  ].join(`
+`);
+}
+function renderLaterList(tasks, displaySession) {
+  if (tasks.length === 0)
+    return "当前没有待执行定时任务。";
+  return [
+    "待执行定时任务：",
+    "",
+    ...tasks.flatMap((task) => [
+      `#${task.id}  ${formatLocalDateTime(new Date(task.execute_at))}  会话：${displaySession(task.session_alias)}`,
+      preview(task.message),
+      ""
+    ])
+  ].join(`
+`).trimEnd();
+}
+function preview(text) {
+  return text.length <= LATER_MESSAGE_PREVIEW_CHARS ? text : `${text.slice(0, LATER_MESSAGE_PREVIEW_CHARS - 1)}…`;
+}
+function formatLocalDateTime(date4) {
+  const weekdays = ["周日", "周一", "周二", "周三", "周四", "周五", "周六"];
+  const pad = (value) => String(value).padStart(2, "0");
+  return `${date4.getFullYear()}-${pad(date4.getMonth() + 1)}-${pad(date4.getDate())} ${weekdays[date4.getDay()]} ${pad(date4.getHours())}:${pad(date4.getMinutes())}`;
+}
+var init_scheduled_render = __esm(() => {
+  init_scheduled_types();
+});
+
+// src/commands/handlers/later-handler.ts
+function handleLaterHelp() {
+  return { text: renderLaterHelp() };
+}
+async function handleLaterCreate(tokens, scheduled, chatKey, currentSessionAlias, accountId, replyContextToken) {
+  if (!currentSessionAlias) {
+    return {
+      text: [
+        "当前没有会话，无法创建定时任务。",
+        "",
+        "请先创建或切换到一个会话：",
+        "- /ss codex --ws backend（新建并切换）",
+        "- /use backend-codex（切换到已有会话）"
+      ].join(`
+`)
+    };
+  }
+  const result = parseLaterTime(tokens);
+  if (!result.ok) {
+    return { text: renderTimeParseError(result.code, result.value) };
+  }
+  const message = tokens.slice(result.messageStartIndex).join(" ").trim();
+  if (message.startsWith("/")) {
+    return {
+      text: [
+        "不支持延迟执行 / 开头的命令。",
+        "",
+        "如果需要让 agent 解释命令，可以用自然语言描述：",
+        "例如：/lt in 1h 请解释 /status 的作用"
+      ].join(`
+`)
+    };
+  }
+  const task = await scheduled.createTask({
+    chatKey,
+    sessionAlias: currentSessionAlias,
+    executeAt: result.executeAt,
+    message,
+    ...accountId ? { accountId } : {},
+    ...replyContextToken ? { replyContextToken } : {}
+  });
+  return { text: renderTaskCreated(task, toDisplaySessionAlias(currentSessionAlias)) };
+}
+function handleLaterList(scheduled) {
+  const tasks = scheduled.listPending();
+  return { text: renderLaterList(tasks, (alias) => toDisplaySessionAlias(alias)) };
+}
+async function handleLaterCancel(id, scheduled) {
+  const ok = await scheduled.cancelPending(id);
+  if (ok) {
+    return { text: `已取消定时任务 #${id.replace(/^#/, "").toLowerCase()}` };
+  }
+  const displayId = id.replace(/^#/, "").toLowerCase();
+  return { text: [`未找到待执行的定时任务 #${displayId}。`, "可以用 /lt list 查看当前待执行任务。"].join(`
+`) };
+}
+function renderTimeParseError(code, value) {
+  switch (code) {
+    case "missing_message":
+      return "定时任务需要消息内容，请在时间后附上要发送的内容。";
+    case "too_soon":
+      return "定时任务执行时间必须在 10 秒之后。";
+    case "out_of_range":
+      return "定时任务执行时间不能超过 7 天。";
+    case "past_today_time":
+      return `今天 ${value} 已经过了，请指定一个未来的时间，或使用「明天」。`;
+    case "unrecognized_time":
+    case "missing_time":
+    default:
+      return [
+        "无法识别时间格式。",
+        "",
+        "支持的格式：",
+        "- /lt in 2h 消息（2小时后）",
+        "- /lt 30分钟后 消息",
+        "- /lt tomorrow 09:00 消息",
+        "- /lt 周五 09:00 消息"
+      ].join(`
+`);
+  }
+}
+var laterHelpMetadata;
+var init_later_handler = __esm(() => {
+  init_parse_later_time();
+  init_scheduled_render();
+  init_channel_scope();
+  laterHelpMetadata = {
+    topic: "later",
+    aliases: ["lt"],
+    summary: "定时任务：延时发送消息到当前会话",
+    commands: [
+      { usage: "/lt <时间> <消息>", description: "创建定时任务" },
+      { usage: "/lt list", description: "查看待执行定时任务" },
+      { usage: "/lt cancel <id>", description: "取消定时任务" }
+    ],
+    examples: [
+      "/lt in 2h 检查 CI",
+      "/lt 30分钟后 总结进展",
+      "/lt tomorrow 09:00 看 PR",
+      "/lt 今天 21:30 继续处理",
+      "/lt 周五 09:00 继续处理"
+    ],
+    notes: [
+      "只支持一次性任务，不支持重复执行",
+      "时间必须在 10 秒之后、7 天之内",
+      "到点后会把消息发送到创建时绑定的会话（不随之后 /use 切换而改变）",
+      "/lt list 显示全局待执行任务；群聊中只有群主可取消",
+      "不支持延迟执行 / 开头的 weacpx 命令",
+      "完整时间格式与说明见 docs/later-command.md"
+    ]
+  };
+});
+
 // src/commands/help/help-registry.ts
 function getHelpTopic(topic) {
   return HELP_TOPIC_MAP.get(topic) ?? null;
@@ -18694,6 +19304,7 @@ var init_help_registry = __esm(() => {
   init_permission_handler();
   init_session_handler();
   init_workspace_handler();
+  init_later_handler();
   HELP_TOPICS = [
     sessionHelp,
     workspaceHelp,
@@ -18704,7 +19315,8 @@ var init_help_registry = __esm(() => {
     modeHelp,
     replyModeHelp,
     statusHelp,
-    cancelHelp
+    cancelHelp,
+    laterHelpMetadata
   ];
   HELP_TOPIC_MAP = new Map;
   for (const topic of HELP_TOPICS) {
@@ -18751,7 +19363,8 @@ function renderHelpTopic(topic) {
     "",
     "命令：",
     ...topic.commands.map((command) => `- ${command.usage} - ${command.description}`),
-    ...topic.examples && topic.examples.length > 0 ? ["", "示例：", ...topic.examples.map((example) => `- ${example}`)] : []
+    ...topic.examples && topic.examples.length > 0 ? ["", "示例：", ...topic.examples.map((example) => `- ${example}`)] : [],
+    ...topic.notes && topic.notes.length > 0 ? ["", "注意：", ...topic.notes.map((note) => `- ${note}`)] : []
   ].join(`
 `);
 }
@@ -19402,6 +20015,8 @@ class CommandRouter {
   resolveSessionAgentCommand;
   orchestration;
   quota;
+  scheduled;
+  scheduledDelivery;
   logger;
   autoInstall = autoInstallOptionalDep;
   discoverPaths = discoverParentPackagePaths;
@@ -19411,7 +20026,7 @@ class CommandRouter {
   __setDiscoverPathsForTest(fn) {
     this.discoverPaths = fn;
   }
-  constructor(sessions, transport, config2, configStore, logger2, resolveSessionAgentCommand = resolveSessionAgentCommandFromIndex, orchestration, quota) {
+  constructor(sessions, transport, config2, configStore, logger2, resolveSessionAgentCommand = resolveSessionAgentCommandFromIndex, orchestration, quota, scheduled, scheduledDelivery) {
     this.sessions = sessions;
     this.transport = transport;
     this.config = config2;
@@ -19419,6 +20034,8 @@ class CommandRouter {
     this.resolveSessionAgentCommand = resolveSessionAgentCommand;
     this.orchestration = orchestration;
     this.quota = quota;
+    this.scheduled = scheduled;
+    this.scheduledDelivery = scheduledDelivery;
     this.logger = logger2 ?? createNoopAppLogger();
   }
   async handle(chatKey, input, reply, replyContextToken, accountId, media, metadata, abortSignal, onToolEvent, onThought, perfSpan) {
@@ -19539,8 +20156,38 @@ class CommandRouter {
           return await handleTaskReject(this.createHandlerContext(), chatKey, command.taskId);
         case "task.cancel":
           return await handleTaskCancel(this.createHandlerContext(), chatKey, command.taskId);
-        case "prompt":
-          return await handlePrompt(this.createSessionHandlerContext(undefined, perfSpan), chatKey, command.text, reply, replyContextToken, accountId, media, abortSignal, onToolEvent, onThought, perfSpan);
+        case "later.help":
+          if (!this.scheduled)
+            return { text: "定时任务服务未启用。" };
+          return handleLaterHelp();
+        case "later.list":
+          if (!this.scheduled)
+            return { text: "定时任务服务未启用。" };
+          return handleLaterList(this.scheduled);
+        case "later.create": {
+          if (!this.scheduled)
+            return { text: "定时任务服务未启用。" };
+          if (this.scheduledDelivery && !this.scheduledDelivery.supportsScheduledMessages(chatKey)) {
+            return { text: renderLaterUnsupportedChannel() };
+          }
+          const currentSession = await this.sessions.getCurrentSession(chatKey);
+          return await handleLaterCreate(command.tokens, this.scheduled, chatKey, currentSession?.alias ?? null, accountId, replyContextToken);
+        }
+        case "later.cancel":
+          if (!this.scheduled)
+            return { text: "定时任务服务未启用。" };
+          return await handleLaterCancel(command.id, this.scheduled);
+        case "prompt": {
+          const sessionContext = this.createSessionHandlerContext(undefined, perfSpan);
+          if (metadata?.scheduledSessionAlias) {
+            const scheduledSession = await this.sessions.getSession(metadata.scheduledSessionAlias);
+            if (!scheduledSession) {
+              throw new Error(`session "${metadata.scheduledSessionAlias}" not found for scheduled prompt`);
+            }
+            return await handlePromptWithSession(sessionContext, scheduledSession, chatKey, command.text, reply, replyContextToken, accountId, media, abortSignal, onToolEvent, onThought, perfSpan);
+          }
+          return await handlePrompt(sessionContext, chatKey, command.text, reply, replyContextToken, accountId, media, abortSignal, onToolEvent, onThought, perfSpan);
+        }
       }
     });
   }
@@ -19918,11 +20565,13 @@ var init_command_router = __esm(() => {
   init_agent_handler();
   init_workspace_handler();
   init_session_shortcut_handler();
+  init_later_handler();
   init_session_recovery_handler();
   init_auto_install_optional_dep();
   init_discover_parent_package_paths();
   init_errors();
   init_session_reset_handler();
+  init_scheduled_render();
 });
 
 // src/config/resolve-acpx-command.ts
@@ -23919,6 +24568,220 @@ function buildWorkerAnswerPrompt(answer) {
 `);
 }
 
+// src/scheduled/scheduled-scheduler.ts
+class ScheduledTaskScheduler {
+  service;
+  intervalMs;
+  dispatchTimeoutMs;
+  setIntervalFn;
+  clearIntervalFn;
+  dispatchTask;
+  logger;
+  intervalHandle = null;
+  ticking = false;
+  constructor(service, deps) {
+    this.service = service;
+    this.dispatchTask = deps.dispatchTask;
+    this.intervalMs = deps.intervalMs ?? 5000;
+    this.dispatchTimeoutMs = deps.dispatchTimeoutMs ?? DEFAULT_DISPATCH_TIMEOUT_MS;
+    this.setIntervalFn = deps.setIntervalFn ?? ((fn, delay) => setInterval(fn, delay));
+    this.clearIntervalFn = deps.clearIntervalFn ?? ((timer) => clearInterval(timer));
+    this.logger = deps.logger;
+  }
+  async start() {
+    if (this.intervalHandle !== null)
+      return;
+    await this.service.markStartupMissed();
+    this.intervalHandle = this.setIntervalFn(() => {
+      this.tick();
+    }, this.intervalMs);
+    await this.tick();
+  }
+  stop() {
+    if (this.intervalHandle !== null) {
+      this.clearIntervalFn(this.intervalHandle);
+      this.intervalHandle = null;
+    }
+  }
+  async tick() {
+    if (this.ticking)
+      return;
+    this.ticking = true;
+    try {
+      const dueTasks = await this.service.claimDueTasks();
+      for (const task of dueTasks) {
+        try {
+          await this.dispatchWithTimeout(task);
+          await this.service.markExecuted(task.id);
+        } catch (error2) {
+          const message = error2 instanceof Error ? error2.message : String(error2);
+          await this.logger?.error("scheduled.dispatch.failed", "failed to dispatch scheduled task", {
+            taskId: task.id,
+            message
+          });
+          await this.service.markFailed(task.id, error2);
+        }
+      }
+    } finally {
+      this.ticking = false;
+    }
+  }
+  async dispatchWithTimeout(task) {
+    const controller = new AbortController;
+    let timer;
+    const timeout = new Promise((_resolve, reject) => {
+      timer = setTimeout(() => {
+        reject(new Error(`scheduled task dispatch timed out after ${this.dispatchTimeoutMs}ms`));
+        controller.abort();
+      }, this.dispatchTimeoutMs);
+    });
+    const dispatch = this.dispatchTask(task, controller.signal);
+    dispatch.catch(() => {});
+    try {
+      await Promise.race([dispatch, timeout]);
+    } finally {
+      if (timer !== undefined)
+        clearTimeout(timer);
+    }
+  }
+}
+var DEFAULT_DISPATCH_TIMEOUT_MS;
+var init_scheduled_scheduler = __esm(() => {
+  DEFAULT_DISPATCH_TIMEOUT_MS = 10 * 60 * 1000;
+});
+
+// src/scheduled/scheduled-service.ts
+class ScheduledTaskService {
+  state;
+  stateStore;
+  now;
+  generateId;
+  stateMutex;
+  claimedInThisSession = new Set;
+  constructor(state, stateStore, options) {
+    this.state = state;
+    this.stateStore = stateStore;
+    this.now = options?.now ?? (() => new Date);
+    this.generateId = options?.generateId ?? (() => Math.random().toString(36).slice(2, 6));
+    this.stateMutex = options?.stateMutex ?? new AsyncMutex;
+  }
+  async createTask(input) {
+    return await this.mutate(async () => {
+      const id = this.nextId();
+      const task = {
+        id,
+        chat_key: input.chatKey,
+        session_alias: input.sessionAlias,
+        execute_at: input.executeAt.toISOString(),
+        message: input.message,
+        status: "pending",
+        created_at: this.now().toISOString(),
+        ...input.accountId ? { account_id: input.accountId } : {},
+        ...input.replyContextToken ? { reply_context_token: input.replyContextToken } : {},
+        ...input.sourceLabel ? { source_label: input.sourceLabel } : {}
+      };
+      this.state.scheduled_tasks[id] = task;
+      await this.save();
+      return task;
+    });
+  }
+  listPending() {
+    return Object.values(this.state.scheduled_tasks).filter((task) => task.status === "pending").sort((left, right) => left.execute_at.localeCompare(right.execute_at));
+  }
+  async cancelPending(inputId) {
+    return await this.mutate(async () => {
+      const id = normalizeId(inputId);
+      const task = this.state.scheduled_tasks[id];
+      if (!task || task.status !== "pending")
+        return false;
+      task.status = "cancelled";
+      task.cancelled_at = this.now().toISOString();
+      await this.save();
+      return true;
+    });
+  }
+  async markStartupMissed() {
+    await this.mutate(async () => {
+      const nowMs = this.now().getTime();
+      let changed = false;
+      for (const task of Object.values(this.state.scheduled_tasks)) {
+        if (task.status === "pending" && Date.parse(task.execute_at) < nowMs) {
+          task.status = "missed";
+          task.missed_at = this.now().toISOString();
+          changed = true;
+        }
+        if (task.status === "triggering" && !this.claimedInThisSession.has(task.id)) {
+          task.status = "failed";
+          task.failed_at = this.now().toISOString();
+          task.last_error = "process stopped while task was triggering";
+          changed = true;
+        }
+      }
+      if (changed)
+        await this.save();
+    });
+  }
+  async claimDueTasks() {
+    return await this.mutate(async () => {
+      const nowMs = this.now().getTime();
+      const due = this.listPending().filter((task) => Date.parse(task.execute_at) <= nowMs);
+      if (due.length === 0)
+        return [];
+      const at = this.now().toISOString();
+      for (const task of due) {
+        task.status = "triggering";
+        task.triggered_at = at;
+        this.claimedInThisSession.add(task.id);
+      }
+      await this.save();
+      return due.map((task) => ({ ...task }));
+    });
+  }
+  async markExecuted(id) {
+    await this.mutate(async () => {
+      const taskId = normalizeId(id);
+      const task = this.state.scheduled_tasks[taskId];
+      if (!task)
+        return;
+      task.status = "executed";
+      task.executed_at = this.now().toISOString();
+      this.claimedInThisSession.delete(taskId);
+      await this.save();
+    });
+  }
+  async markFailed(id, error2) {
+    await this.mutate(async () => {
+      const taskId = normalizeId(id);
+      const task = this.state.scheduled_tasks[taskId];
+      if (!task)
+        return;
+      task.status = "failed";
+      task.failed_at = this.now().toISOString();
+      task.last_error = error2 instanceof Error ? error2.message : String(error2);
+      this.claimedInThisSession.delete(taskId);
+      await this.save();
+    });
+  }
+  nextId() {
+    for (let attempt = 0;attempt < 20; attempt += 1) {
+      const id = normalizeId(this.generateId()).replace(/[^0-9a-z]/g, "").slice(0, 6);
+      if (id.length >= 4 && !this.state.scheduled_tasks[id])
+        return id;
+    }
+    throw new Error("failed to generate unique scheduled task id");
+  }
+  async mutate(critical) {
+    return await this.stateMutex.run(critical);
+  }
+  async save() {
+    await this.stateStore.save(this.state);
+  }
+}
+function normalizeId(input) {
+  return input.trim().replace(/^#/, "").toLowerCase();
+}
+var init_scheduled_service = () => {};
+
 // src/sessions/session-service.ts
 class SessionService {
   config;
@@ -23934,6 +24797,20 @@ class SessionService {
   async createSession(alias, agent, workspace) {
     return await this.createLogicalSession(alias, agent, workspace, `${workspace}:${alias}`);
   }
+  listAllResolvedSessions() {
+    const seen = new Set;
+    const resolved = [];
+    for (const session of Object.values(this.state.sessions)) {
+      if (seen.has(session.transport_session)) {
+        continue;
+      }
+      seen.add(session.transport_session);
+      try {
+        resolved.push(this.toResolvedSession(session));
+      } catch {}
+    }
+    return resolved;
+  }
   resolveSession(alias, agent, workspace, transportSession) {
     this.validateSession(alias, agent, workspace);
     return this.toResolvedSession({
@@ -24359,20 +25236,47 @@ async function runConsole(paths, deps) {
         runtimeForGc.orchestration.service.purgeExpiredResetCoordinators({ cutoffDays: 7, trigger: "interval" }).catch(() => {});
       }, 86400000);
     }
+    const channelStartPromise = deps.channels.startAll({
+      agent: runtime.agent,
+      abortSignal: shutdownController.signal,
+      quota: runtime.quota,
+      logger: runtime.logger,
+      perfTracer: runtime.perfTracer
+    });
+    channelStartPromise.catch(() => {});
+    let channelStartSettled = false;
+    let channelStartError;
+    channelStartPromise.then(() => {
+      channelStartSettled = true;
+    }, (error2) => {
+      channelStartSettled = true;
+      channelStartError = error2;
+    });
+    await Promise.resolve();
+    if (channelStartSettled && channelStartError) {
+      if (deps.channelStartupPolicy !== "best-effort") {
+        throw channelStartError;
+      }
+      await runtime.logger.error("daemon.channels.start_failed", "all channels failed to start; daemon remains alive for orchestration IPC", { error: channelStartError instanceof Error ? channelStartError.message : String(channelStartError) });
+      await waitForShutdown(shutdownController.signal);
+      return;
+    }
     try {
-      await deps.channels.startAll({
-        agent: runtime.agent,
-        abortSignal: shutdownController.signal,
-        quota: runtime.quota,
-        logger: runtime.logger,
-        perfTracer: runtime.perfTracer
-      });
+      await runtime.scheduled.scheduler.start();
+    } catch (error2) {
+      shutdownController.abort();
+      throw error2;
+    }
+    try {
+      await channelStartPromise;
     } catch (error2) {
+      runtime.scheduled.scheduler.stop();
       if (deps.channelStartupPolicy !== "best-effort") {
         throw error2;
       }
       await runtime.logger.error("daemon.channels.start_failed", "all channels failed to start; daemon remains alive for orchestration IPC", { error: error2 instanceof Error ? error2.message : String(error2) });
       await waitForShutdown(shutdownController.signal);
+      return;
     }
   } finally {
     await runCleanupSequence({
@@ -24621,7 +25525,8 @@ async function spawnAcpxBridgeClient(options = {}) {
       ...process.env,
       WEACPX_BRIDGE_ACPX_COMMAND: options.acpxCommand ?? "acpx",
       WEACPX_BRIDGE_PERMISSION_MODE: options.permissionMode ?? "approve-all",
-      WEACPX_BRIDGE_NON_INTERACTIVE_PERMISSIONS: options.nonInteractivePermissions ?? "deny"
+      WEACPX_BRIDGE_NON_INTERACTIVE_PERMISSIONS: options.nonInteractivePermissions ?? "deny",
+      ...typeof options.queueOwnerTtlSeconds === "number" && Number.isFinite(options.queueOwnerTtlSeconds) ? { WEACPX_BRIDGE_QUEUE_OWNER_TTL_SECONDS: String(options.queueOwnerTtlSeconds) } : {}
     },
     stdio: ["pipe", "pipe", "inherit"]
   });
@@ -25049,7 +25954,7 @@ var init_spawn_command = __esm(() => {
 });
 
 // src/transport/prompt-media.ts
-import { mkdtemp, open as open3, rm as rm8, writeFile as writeFile8 } from "node:fs/promises";
+import { mkdtemp, open as open4, rm as rm8, writeFile as writeFile7 } from "node:fs/promises";
 import { tmpdir as defaultTmpdir } from "node:os";
 import path14 from "node:path";
 import { pathToFileURL as pathToFileURL2 } from "node:url";
@@ -25118,7 +26023,7 @@ async function writeStructuredPromptBlocks(blocks, deps) {
   }
 }
 async function readImageFileBounded(filePath, maxBytes) {
-  const handle = await open3(filePath, "r");
+  const handle = await open4(filePath, "r");
   try {
     const imageStats = await handle.stat();
     if (!imageStats.isFile()) {
@@ -25173,7 +26078,7 @@ var init_prompt_media = __esm(() => {
   defaultStructuredPromptFileDeps = {
     readImageFile: readImageFileBounded,
     mkdtemp,
-    writeFile: writeFile8,
+    writeFile: writeFile7,
     rm: rm8,
     tmpdir: defaultTmpdir
   };
@@ -25480,12 +26385,12 @@ function resolveNodePtyHelperPath(packageJsonPath, platform, arch) {
   }
   return join12(dirname12(packageJsonPath), "prebuilds", `${platform}-${arch}`, "spawn-helper");
 }
-async function ensureNodePtyHelperExecutable(helperPath, chmod2 = chmodFs) {
+async function ensureNodePtyHelperExecutable(helperPath, chmod3 = chmodFs) {
   if (!helperPath) {
     return;
   }
   try {
-    await chmod2(helperPath, 493);
+    await chmod3(helperPath, 493);
   } catch (error2) {
     if (error2.code === "ENOENT") {
       return;
@@ -25778,6 +26683,7 @@ class AcpxCliTransport {
   permissionMode;
   nonInteractivePermissions;
   permissionPolicy;
+  queueOwnerTtlSeconds;
   runCommand;
   runPtyCommand;
   queueOwnerLauncher;
@@ -25788,10 +26694,12 @@ class AcpxCliTransport {
     this.permissionMode = options.permissionMode ?? "approve-all";
     this.nonInteractivePermissions = options.nonInteractivePermissions ?? "deny";
     this.permissionPolicy = options.permissionPolicy;
+    this.queueOwnerTtlSeconds = options.queueOwnerTtlSeconds;
     this.runCommand = runCommand;
     this.runPtyCommand = runPtyCommand;
     this.queueOwnerLauncher = queueOwnerLauncher ?? new AcpxQueueOwnerLauncher({
-      acpxCommand: this.command
+      acpxCommand: this.command,
+      ...typeof this.queueOwnerTtlSeconds === "number" && Number.isFinite(this.queueOwnerTtlSeconds) ? { ttlMs: this.queueOwnerTtlSeconds * 1000 } : {}
     });
     this.streamingHooks = streamingHooks;
   }
@@ -26115,7 +27023,8 @@ ${baseText}` : "" };
       "--json-strict",
       "--cwd",
       session.cwd,
-      ...this.buildPermissionArgs()
+      ...this.buildPermissionArgs(),
+      ...this.buildQueueOwnerTtlArgs()
     ];
     const tail2 = promptFile ? ["prompt", "-s", session.transportSession, "--file", promptFile] : ["prompt", "-s", session.transportSession, text];
     if (session.agentCommand) {
@@ -26123,6 +27032,12 @@ ${baseText}` : "" };
     }
     return [...prefix, session.agent, ...tail2];
   }
+  buildQueueOwnerTtlArgs() {
+    if (typeof this.queueOwnerTtlSeconds !== "number" || !Number.isFinite(this.queueOwnerTtlSeconds)) {
+      return [];
+    }
+    return ["--ttl", String(this.queueOwnerTtlSeconds)];
+  }
   buildPermissionArgs() {
     const modeFlag = permissionModeToFlag(this.permissionMode);
     const args = [modeFlag, "--non-interactive-permissions", this.nonInteractivePermissions];
@@ -26169,6 +27084,146 @@ var init_acpx_cli_transport = __esm(() => {
   require4 = createRequire5(import.meta.url);
 });
 
+// src/transport/queue-owner-reaper.ts
+import { spawn as spawn10 } from "node:child_process";
+async function reapQueueOwners(acpxCommand, targets, deps = {}) {
+  const resolveRecordId = deps.resolveRecordId ?? defaultResolveRecordId;
+  const terminate = deps.terminate ?? terminateAcpxQueueOwner;
+  const timeoutMs = deps.timeoutMs ?? 5000;
+  const seen = new Set;
+  const unique = targets.filter((target) => {
+    if (seen.has(target.transportSession)) {
+      return false;
+    }
+    seen.add(target.transportSession);
+    return true;
+  });
+  let terminated = 0;
+  const reapOne = async (target) => {
+    try {
+      const recordId = await resolveRecordId(acpxCommand, target);
+      if (!recordId) {
+        return;
+      }
+      await terminate(recordId);
+      terminated += 1;
+    } catch (error2) {
+      deps.onError?.(target, error2);
+    }
+  };
+  await settleWithinTimeout(Promise.all(unique.map(reapOne)), timeoutMs);
+  return { terminated, attempted: unique.length };
+}
+function settleWithinTimeout(work, timeoutMs) {
+  return new Promise((resolve3) => {
+    let settled = false;
+    const finish = () => {
+      if (!settled) {
+        settled = true;
+        resolve3();
+      }
+    };
+    const timer = setTimeout(finish, timeoutMs);
+    if (typeof timer.unref === "function") {
+      timer.unref();
+    }
+    work.then(() => {
+      clearTimeout(timer);
+      finish();
+    }, () => {
+      clearTimeout(timer);
+      finish();
+    });
+  });
+}
+async function defaultResolveRecordId(acpxCommand, target) {
+  const args = [
+    "--format",
+    "quiet",
+    "--cwd",
+    target.cwd,
+    ...target.agentCommand ? ["--agent", target.agentCommand] : [target.agent],
+    "sessions",
+    "show",
+    target.transportSession
+  ];
+  const spawnSpec = resolveSpawnCommand(acpxCommand, args);
+  const result = await runCapture2(spawnSpec.command, spawnSpec.args, 4000);
+  if (result.code !== 0) {
+    return null;
+  }
+  return parseRecordId(result.stdout);
+}
+function parseRecordId(stdout2) {
+  try {
+    const parsed = JSON.parse(stdout2);
+    if (typeof parsed.acpxRecordId === "string") {
+      return parsed.acpxRecordId;
+    }
+    if (typeof parsed.id === "string") {
+      return parsed.id;
+    }
+  } catch {
+    const firstLine = stdout2.trim().split(/\r?\n/, 1)[0];
+    if (firstLine && /^[\w.:-]+$/.test(firstLine) && firstLine.length >= 8) {
+      return firstLine;
+    }
+  }
+  return null;
+}
+function runCapture2(command, args, timeoutMs) {
+  return new Promise((resolve3) => {
+    const child = spawn10(command, args, { stdio: ["ignore", "pipe", "ignore"] });
+    let stdout2 = "";
+    let done = false;
+    const finish = (code) => {
+      if (done) {
+        return;
+      }
+      done = true;
+      clearTimeout(timer);
+      resolve3({ code, stdout: stdout2 });
+    };
+    const timer = setTimeout(() => {
+      child.kill("SIGKILL");
+      finish(1);
+    }, timeoutMs);
+    child.stdout?.on("data", (chunk) => {
+      stdout2 += String(chunk);
+    });
+    child.once("error", () => finish(1));
+    child.once("close", (code) => finish(code ?? 1));
+  });
+}
+var init_queue_owner_reaper = __esm(() => {
+  init_spawn_command();
+  init_acpx_queue_owner_launcher();
+});
+
+// src/transport/collect-reap-targets.ts
+function workerBindingReapTargets(orchestration, config2) {
+  const targets = [];
+  for (const [workerSession, binding] of Object.entries(orchestration.workerBindings)) {
+    const agentConfig = config2.agents[binding.targetAgent];
+    if (!agentConfig) {
+      continue;
+    }
+    const cwd = binding.cwd ?? config2.workspaces[binding.workspace]?.cwd;
+    if (!cwd) {
+      continue;
+    }
+    const agentCommand = resolveAgentCommand(agentConfig.driver, agentConfig.command);
+    targets.push({
+      agent: binding.targetAgent,
+      ...agentCommand ? { agentCommand } : {},
+      cwd,
+      transportSession: workerSession
+    });
+  }
+  return targets;
+}
+var init_collect_reap_targets = () => {};
+
 // src/channels/channel-registry.ts
 var exports_channel_registry = {};
 __export(exports_channel_registry, {
@@ -26224,6 +27279,21 @@ class MessageChannelRegistry {
   async sendCoordinatorMessage(input) {
     await this.requireByChatKey(input.chatKey).sendCoordinatorMessage(input);
   }
+  supportsScheduledMessages(chatKey) {
+    const [candidateChannelId] = chatKey.split(":", 1);
+    if (chatKey.includes(":") && candidateChannelId && !this.channels.has(candidateChannelId)) {
+      return false;
+    }
+    const channel = this.getByChatKey(chatKey);
+    return !!channel?.sendScheduledMessage;
+  }
+  async sendScheduledMessage(input) {
+    const channel = this.requireByChatKey(input.chatKey);
+    if (!channel.sendScheduledMessage) {
+      throw new Error(`channel '${channel.id}' does not support scheduled messages`);
+    }
+    await channel.sendScheduledMessage(input);
+  }
   createConsumerLocks() {
     const result = [];
     for (const channel of this.channels.values()) {
@@ -26364,7 +27434,11 @@ function startProgressHeartbeat(orchestration, config2, logger2, channel) {
   if (thresholdSeconds <= 0) {
     return;
   }
+  let ticking = false;
   return setInterval(async () => {
+    if (ticking)
+      return;
+    ticking = true;
     try {
       const tasks = await orchestration.listHeartbeatTasks(thresholdSeconds);
       for (const task of tasks) {
@@ -26385,6 +27459,8 @@ function startProgressHeartbeat(orchestration, config2, logger2, channel) {
       await logger2.error("orchestration.heartbeat.check_failed", "heartbeat check failed", {
         message: error2 instanceof Error ? error2.message : String(error2)
       });
+    } finally {
+      ticking = false;
     }
   }, 60000);
 }
@@ -26432,12 +27508,14 @@ async function buildApp(paths, deps = {}) {
     }
   });
   const sessions = new SessionService(config2, debouncedStateStore, state, { stateMutex });
+  const scheduledService = new ScheduledTaskService(state, debouncedStateStore, { stateMutex });
   const pendingWorkerDispatches = new Set;
   const transport = config2.transport.type === "acpx-bridge" ? await (deps.createBridgeTransport?.() ?? Promise.resolve(new AcpxBridgeTransport(await spawnAcpxBridgeClient({
     acpxCommand,
     bridgeEntryPath: resolveBridgeEntryPath(),
     permissionMode: config2.transport.permissionMode,
-    nonInteractivePermissions: config2.transport.nonInteractivePermissions
+    nonInteractivePermissions: config2.transport.nonInteractivePermissions,
+    ...typeof config2.transport.queueOwnerTtlSeconds === "number" ? { queueOwnerTtlSeconds: config2.transport.queueOwnerTtlSeconds } : {}
   })))) : deps.createCliTransport?.(acpxCommand) ?? new AcpxCliTransport({ ...config2.transport, command: acpxCommand });
   const quota = new QuotaManager({
     onInbound: (chatKey) => {
@@ -26790,8 +27868,33 @@ async function buildApp(paths, deps = {}) {
   const progressHeartbeatInterval = startProgressHeartbeat(orchestration, config2, logger2, deps.channel ?? null);
   const orchestrationEndpoint = createOrchestrationEndpoint(paths.orchestrationSocketPath ?? resolveOrchestrationSocketPathFromConfigPath(paths.configPath));
   const orchestrationServer = new OrchestrationServer(orchestrationEndpoint, orchestration);
-  const router = new CommandRouter(sessions, transport, config2, configStore, logger2, undefined, orchestration, quota);
+  const router = new CommandRouter(sessions, transport, config2, configStore, logger2, undefined, orchestration, quota, scheduledService, deps.channel?.supportsScheduledMessages ? { supportsScheduledMessages: deps.channel.supportsScheduledMessages.bind(deps.channel) } : undefined);
   const agent = new ConsoleAgent(router, logger2);
+  const scheduledScheduler = new ScheduledTaskScheduler(scheduledService, {
+    dispatchTask: async (task, abortSignal) => {
+      const session = await sessions.getSession(task.session_alias);
+      if (!session) {
+        throw new Error(`session "${task.session_alias}" not found for scheduled task`);
+      }
+      const noticeText = `执行定时任务 #${task.id}
+会话：${toDisplaySessionAlias(task.session_alias)}
+内容：${preview(task.message)}`;
+      if (!deps.channel?.sendScheduledMessage) {
+        throw new Error("no channel runtime available for scheduled task dispatch");
+      }
+      await deps.channel.sendScheduledMessage({
+        chatKey: task.chat_key,
+        taskId: task.id,
+        sessionAlias: task.session_alias,
+        noticeText,
+        promptText: task.message,
+        abortSignal,
+        ...task.account_id ? { accountId: task.account_id } : {},
+        ...task.reply_context_token ? { replyContextToken: task.reply_context_token } : {}
+      });
+    },
+    logger: logger2
+  });
   return {
     agent,
     router,
@@ -26807,11 +27910,45 @@ async function buildApp(paths, deps = {}) {
       server: orchestrationServer,
       endpoint: orchestrationEndpoint
     },
+    scheduled: {
+      service: scheduledService,
+      scheduler: scheduledScheduler
+    },
     dispose: async () => {
+      scheduledScheduler.stop();
       if (progressHeartbeatInterval !== undefined) {
         clearInterval(progressHeartbeatInterval);
       }
       await Promise.allSettled([...pendingWorkerDispatches]);
+      try {
+        const targets = [
+          ...sessions.listAllResolvedSessions().map((session) => ({
+            agent: session.agent,
+            ...session.agentCommand ? { agentCommand: session.agentCommand } : {},
+            cwd: session.cwd,
+            transportSession: session.transportSession
+          })),
+          ...workerBindingReapTargets(state.orchestration, config2)
+        ];
+        if (targets.length > 0) {
+          const { terminated, attempted } = await reapQueueOwners(acpxCommand, targets, {
+            onError: (target, error2) => {
+              logger2.info("transport.queue_owner_reap.failed", "failed to reap queue owner on shutdown", {
+                transport_session: target.transportSession,
+                error: error2 instanceof Error ? error2.message : String(error2)
+              }).catch(() => {});
+            }
+          });
+          await logger2.info("transport.queue_owner_reap.completed", "reaped warm queue owners on shutdown", {
+            terminated,
+            attempted
+          }).catch(() => {});
+        }
+      } catch (err) {
+        await logger2.error("transport.queue_owner_reap.error", "queue owner reap failed during shutdown", {
+          error: err instanceof Error ? err.message : String(err)
+        }).catch(() => {});
+      }
       await debouncedStateStore.dispose();
       if ("dispose" in transport && typeof transport.dispose === "function") {
         await transport.dispose();
@@ -26831,6 +27968,7 @@ function replaceRuntimeState(target, source) {
   target.sessions = source.sessions;
   target.chat_contexts = source.chat_contexts;
   target.orchestration = source.orchestration;
+  target.scheduled_tasks = source.scheduled_tasks;
 }
 function replaceRuntimeConfig(target, source) {
   Object.assign(target, source);
@@ -26842,7 +27980,12 @@ async function main() {
     await ensureConfigExists(paths.configPath);
     const startupConfig = await loadConfig(paths.configPath);
     const { loadConfiguredPlugins: loadConfiguredPlugins2 } = await Promise.resolve().then(() => (init_plugin_loader(), exports_plugin_loader));
-    await loadConfiguredPlugins2({ plugins: startupConfig.plugins });
+    await loadConfiguredPlugins2({
+      plugins: startupConfig.plugins,
+      onPluginError: ({ name, error: error2 }) => {
+        console.error(`[weacpx] skipping plugin ${name}: ${error2 instanceof Error ? error2.message : String(error2)}`);
+      }
+    });
     const { channelDeps } = await prepareChannelMedia(paths.configPath, startupConfig);
     const channelRegistry = new MessageChannelRegistry(createMessageChannels2(startupConfig.channels, channelDeps));
     await runConsole(paths, {
@@ -26920,12 +28063,18 @@ var init_main = __esm(async () => {
   init_orchestration_server();
   init_orchestration_service();
   init_build_coordinator_prompt();
+  init_scheduled_scheduler();
+  init_scheduled_service();
+  init_scheduled_render();
+  init_channel_scope();
   init_session_service();
   init_state_store();
   init_run_console();
   init_acpx_bridge_client();
   init_acpx_bridge_transport();
   init_acpx_cli_transport();
+  init_queue_owner_reaper();
+  init_collect_reap_targets();
   init_channel_registry();
   init_media_store();
   init_quota_errors();
@@ -26936,7 +28085,7 @@ var init_main = __esm(async () => {
 });
 
 // src/doctor/checks/acpx-check.ts
-import { spawn as spawn10 } from "node:child_process";
+import { spawn as spawn11 } from "node:child_process";
 async function checkAcpx(options = {}) {
   const runtimePaths = (options.resolveRuntimePaths ?? resolveRuntimePaths)();
   try {
@@ -26983,7 +28132,7 @@ function buildDetails(metadata, version2, verbose) {
 async function defaultRunVersion(command) {
   const spawnSpec = resolveSpawnCommand(command, ["--version"]);
   return await new Promise((resolve3, reject) => {
-    const child = spawn10(spawnSpec.command, spawnSpec.args, {
+    const child = spawn11(spawnSpec.command, spawnSpec.args, {
       stdio: ["ignore", "pipe", "pipe"]
     });
     let stdout2 = "";
@@ -28004,7 +29153,7 @@ import { fileURLToPath as fileURLToPath6 } from "node:url";
 
 // src/daemon/daemon-runtime.ts
 init_daemon_status();
-import { mkdir as mkdir5, rm as rm3, writeFile as writeFile4 } from "node:fs/promises";
+import { mkdir as mkdir5, rm as rm3, writeFile as writeFile3 } from "node:fs/promises";
 import { dirname as dirname5 } from "node:path";
 
 class DaemonRuntime {
@@ -28032,7 +29181,7 @@ class DaemonRuntime {
       stderr_log: this.paths.stderrLog
     };
     await mkdir5(dirname5(this.paths.pidFile), { recursive: true });
-    await writeFile4(this.paths.pidFile, `${this.options.pid}
+    await writeFile3(this.paths.pidFile, `${this.options.pid}
 `);
     await this.statusStore.save(this.currentStatus);
   }
@@ -43916,7 +45065,12 @@ async function defaultRun(options = {}) {
   await ensureConfigExists(runtimePaths.configPath);
   const config2 = await loadConfig(runtimePaths.configPath);
   const { loadConfiguredPlugins: loadConfiguredPlugins2 } = await Promise.resolve().then(() => (init_plugin_loader(), exports_plugin_loader));
-  await loadConfiguredPlugins2({ plugins: config2.plugins });
+  await loadConfiguredPlugins2({
+    plugins: config2.plugins,
+    onPluginError: ({ name, error: error2 }) => {
+      console.error(`[weacpx] skipping plugin ${name}: ${error2 instanceof Error ? error2.message : String(error2)}`);
+    }
+  });
   const { createMessageChannels: createMessageChannels2 } = await Promise.resolve().then(() => (init_create_channel(), exports_create_channel));
   const { MessageChannelRegistry: MessageChannelRegistry2 } = await Promise.resolve().then(() => (init_channel_registry(), exports_channel_registry));
   const daemonPaths = resolveDaemonPathsForCurrentConfig();