weacpx 0.4.8 → 0.4.10

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,
@@ -2424,10 +2448,11 @@ function parseOrchestrationConfig(raw) {
     allowWorkerChainedRequests: raw.allowWorkerChainedRequests === true,
     allowedAgentRequestTargets: Array.isArray(raw.allowedAgentRequestTargets) ? raw.allowedAgentRequestTargets.filter((value) => typeof value === "string") : [...DEFAULT_ORCHESTRATION_CONFIG.allowedAgentRequestTargets],
     allowedAgentRequestRoles: Array.isArray(raw.allowedAgentRequestRoles) ? raw.allowedAgentRequestRoles.filter((value) => typeof value === "string") : [...DEFAULT_ORCHESTRATION_CONFIG.allowedAgentRequestRoles],
-    progressHeartbeatSeconds: typeof raw.progressHeartbeatSeconds === "number" && Number.isFinite(raw.progressHeartbeatSeconds) ? raw.progressHeartbeatSeconds : DEFAULT_ORCHESTRATION_CONFIG.progressHeartbeatSeconds
+    progressHeartbeatSeconds: typeof raw.progressHeartbeatSeconds === "number" && Number.isFinite(raw.progressHeartbeatSeconds) ? raw.progressHeartbeatSeconds : DEFAULT_ORCHESTRATION_CONFIG.progressHeartbeatSeconds,
+    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 = {
@@ -2452,7 +2477,8 @@ var init_load_config = __esm(() => {
     allowWorkerChainedRequests: false,
     allowedAgentRequestTargets: [],
     allowedAgentRequestRoles: [],
-    progressHeartbeatSeconds: 300
+    progressHeartbeatSeconds: 300,
+    maxParallelTasksPerAgent: 3
   };
 });
 
@@ -2727,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 {
@@ -2786,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 };
   }
@@ -2816,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 });
@@ -2916,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 {
@@ -9645,6 +9689,34 @@ var init_quota_errors = __esm(() => {
   };
 });
 
+// src/commands/workspace-name.ts
+function sanitizeWorkspaceName(input, fallback = "workspace") {
+  const sanitized = input.trim().replace(UNSAFE_RUN_RE, "-").replace(TRIM_DASHES_RE, "");
+  return sanitized.length > 0 ? sanitized : fallback;
+}
+function allocateWorkspaceName(base, existing) {
+  if (!Object.prototype.hasOwnProperty.call(existing, base))
+    return base;
+  let suffix = 2;
+  while (Object.prototype.hasOwnProperty.call(existing, `${base}-${suffix}`))
+    suffix += 1;
+  return `${base}-${suffix}`;
+}
+function isWorkspaceNameValid(input) {
+  return VALID_WORKSPACE_NAME_RE.test(input);
+}
+function quoteWorkspaceNameIfNeeded(input) {
+  if (isWorkspaceNameValid(input))
+    return input;
+  return `"${input.replace(/\\/g, "\\\\").replace(/"/g, "\\\"")}"`;
+}
+var VALID_WORKSPACE_NAME_RE, UNSAFE_RUN_RE, TRIM_DASHES_RE;
+var init_workspace_name = __esm(() => {
+  VALID_WORKSPACE_NAME_RE = /^[a-zA-Z0-9._-]+$/;
+  UNSAFE_RUN_RE = /[^a-zA-Z0-9._-]+/g;
+  TRIM_DASHES_RE = /^-+|-+$/g;
+});
+
 // src/orchestration/orchestration-types.ts
 function createEmptyOrchestrationState() {
   return {
@@ -9683,7 +9755,7 @@ function isOptionalBoolean(value) {
   return value === undefined || typeof value === "boolean";
 }
 function isTaskStatus(value) {
-  return value === "needs_confirmation" || value === "running" || value === "blocked" || value === "waiting_for_human" || value === "completed" || value === "failed" || value === "cancelled";
+  return value === "needs_confirmation" || value === "queued" || value === "running" || value === "blocked" || value === "waiting_for_human" || value === "completed" || value === "failed" || value === "cancelled";
 }
 function isSourceKind(value) {
   return value === "human" || value === "coordinator" || value === "worker";
@@ -9719,7 +9791,7 @@ function isTaskRecord(value) {
   if (!isRecord2(value)) {
     return false;
   }
-  return isString(value.taskId) && isString(value.sourceHandle) && isSourceKind(value.sourceKind) && isString(value.coordinatorSession) && isOptionalString(value.workerSession) && isString(value.workspace) && isOptionalString(value.cwd) && isString(value.targetAgent) && isOptionalString(value.role) && isString(value.task) && isTaskStatus(value.status) && isString(value.summary) && isString(value.resultText) && isString(value.createdAt) && isString(value.updatedAt) && isOptionalString(value.chatKey) && isOptionalString(value.replyContextToken) && isOptionalString(value.accountId) && isOptionalString(value.deliveryAccountId) && isOptionalString(value.coordinatorInjectedAt) && isOptionalString(value.cancelRequestedAt) && isOptionalString(value.cancelCompletedAt) && isOptionalString(value.lastCancelError) && isOptionalBoolean(value.noticePending) && isOptionalString(value.noticeSentAt) && isOptionalString(value.lastNoticeError) && isOptionalBoolean(value.injectionPending) && isOptionalString(value.injectionAppliedAt) && isOptionalString(value.lastInjectionError) && isOptionalString(value.lastProgressAt) && isOptionalString(value.lastProgressSummary) && isOptionalString(value.groupId) && (value.openQuestion === undefined || isOpenQuestionRecord(value.openQuestion)) && (value.reviewPending === undefined || isReviewPendingRecord(value.reviewPending)) && (value.correctionPending === undefined || isCorrectionPendingRecord(value.correctionPending)) && isOptionalNumber(value.eventSeq) && (value.events === undefined || Array.isArray(value.events) && value.events.every(isTaskEventRecord));
+  return isString(value.taskId) && isString(value.sourceHandle) && isSourceKind(value.sourceKind) && isString(value.coordinatorSession) && isOptionalString(value.workerSession) && isString(value.workspace) && isOptionalString(value.cwd) && isString(value.targetAgent) && isOptionalString(value.role) && isString(value.task) && isTaskStatus(value.status) && isString(value.summary) && isString(value.resultText) && isString(value.createdAt) && isString(value.updatedAt) && isOptionalString(value.chatKey) && isOptionalString(value.replyContextToken) && isOptionalString(value.accountId) && isOptionalString(value.deliveryAccountId) && isOptionalString(value.coordinatorInjectedAt) && isOptionalString(value.cancelRequestedAt) && isOptionalString(value.cancelCompletedAt) && isOptionalString(value.lastCancelError) && isOptionalBoolean(value.noticePending) && isOptionalString(value.noticeSentAt) && isOptionalString(value.lastNoticeError) && isOptionalBoolean(value.injectionPending) && isOptionalBoolean(value.ephemeralWorkerSession) && isOptionalBoolean(value.ephemeralWorkerSessionClosed) && isOptionalString(value.injectionAppliedAt) && isOptionalString(value.lastInjectionError) && isOptionalString(value.lastProgressAt) && isOptionalString(value.lastProgressSummary) && isOptionalString(value.groupId) && (value.openQuestion === undefined || isOpenQuestionRecord(value.openQuestion)) && (value.reviewPending === undefined || isReviewPendingRecord(value.reviewPending)) && (value.correctionPending === undefined || isCorrectionPendingRecord(value.correctionPending)) && isOptionalNumber(value.eventSeq) && (value.events === undefined || Array.isArray(value.events) && value.events.every(isTaskEventRecord));
 }
 function isExternalCoordinatorRecord(value) {
   if (!isRecord2(value)) {
@@ -9731,7 +9803,7 @@ function isWorkerBindingRecord(value) {
   if (!isRecord2(value)) {
     return false;
   }
-  return isString(value.sourceHandle) && isString(value.coordinatorSession) && isString(value.workspace) && isOptionalString(value.cwd) && isString(value.targetAgent) && isOptionalString(value.role);
+  return isString(value.sourceHandle) && isString(value.coordinatorSession) && isString(value.workspace) && isOptionalString(value.cwd) && isString(value.targetAgent) && isOptionalString(value.role) && isOptionalBoolean(value.ephemeral);
 }
 function isGroupRecord(value) {
   if (!isRecord2(value)) {
@@ -9984,20 +10056,33 @@ 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) {
+  if (value === undefined)
+    return;
+  const trimmed = value.trim();
+  if (!trimmed)
+    return;
+  const lower = trimmed.toLowerCase();
+  if (lower === "undefined" || lower === "null")
+    return;
+  return trimmed;
+}
 function resolvePluginHome(input = {}) {
-  if (input.pluginHome?.trim())
-    return input.pluginHome;
-  if (process.env.WEACPX_PLUGIN_HOME?.trim())
-    return process.env.WEACPX_PLUGIN_HOME;
-  const home = input.home ?? process.env.HOME ?? homedir3();
+  const explicit = coerceMissing(input.pluginHome);
+  if (explicit)
+    return explicit;
+  const envOverride = coerceMissing(process.env.WEACPX_PLUGIN_HOME);
+  if (envOverride)
+    return envOverride;
+  const home = coerceMissing(input.home) ?? coerceMissing(process.env.HOME) ?? homedir3();
   return join3(home, ".weacpx", "plugins");
 }
 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;
@@ -10136,8 +10221,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;
@@ -10147,11 +10230,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 {
@@ -10202,6 +10281,28 @@ function loadConfigRouteTag(accountId) {
     return;
   }
 }
+function loadConfigBotAgent(accountId) {
+  try {
+    const configPath = resolveConfigPath();
+    if (!fs3.existsSync(configPath))
+      return;
+    const raw = fs3.readFileSync(configPath, "utf-8");
+    const cfg = JSON.parse(raw);
+    const channels = cfg.channels;
+    const section = channels?.["openclaw-weixin"];
+    if (!section)
+      return;
+    if (accountId) {
+      const accounts = section.accounts;
+      const agent = accounts?.[accountId]?.botAgent;
+      if (typeof agent === "string" && agent.trim())
+        return agent.trim();
+    }
+    return typeof section.botAgent === "string" && section.botAgent.trim() ? section.botAgent.trim() : undefined;
+  } catch {
+    return;
+  }
+}
 function listWeixinAccountIds() {
   const indexed = listIndexedWeixinAccountIds();
   if (indexed.length > 0)
@@ -10230,6 +10331,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
@@ -10490,8 +10592,83 @@ var init_send_errors = __esm(() => {
 
 // src/weixin/api/api.ts
 import crypto from "node:crypto";
+function buildClientVersion(version2) {
+  const parts = version2.split(".").map((p) => parseInt(p, 10));
+  const major = parts[0] ?? 0;
+  const minor = parts[1] ?? 0;
+  const patch = parts[2] ?? 0;
+  return (major & 255) << 16 | (minor & 255) << 8 | patch & 255;
+}
+function sanitizeBotAgent(raw) {
+  if (!raw || typeof raw !== "string")
+    return DEFAULT_BOT_AGENT;
+  const trimmed = raw.trim();
+  if (!trimmed)
+    return DEFAULT_BOT_AGENT;
+  const productRe = /^[A-Za-z0-9_.\-]{1,32}\/[A-Za-z0-9_.+\-]{1,32}$/;
+  const commentCharRe = /^[\x20-\x27\x2A-\x7E]{1,64}$/;
+  const rawTokens = trimmed.split(/\s+/);
+  const tokens = [];
+  for (let i = 0;i < rawTokens.length; i += 1) {
+    const tok = rawTokens[i];
+    if (tok.startsWith("(") && !tok.endsWith(")")) {
+      let acc = tok;
+      while (i + 1 < rawTokens.length && !acc.endsWith(")")) {
+        i += 1;
+        acc += " " + rawTokens[i];
+      }
+      tokens.push(acc);
+    } else {
+      tokens.push(tok);
+    }
+  }
+  const accepted = [];
+  let pendingProduct = null;
+  for (const tok of tokens) {
+    if (tok.startsWith("(") && tok.endsWith(")")) {
+      const inner = tok.slice(1, -1);
+      if (pendingProduct && commentCharRe.test(inner)) {
+        accepted.push(`${pendingProduct} (${inner})`);
+        pendingProduct = null;
+      } else {
+        if (pendingProduct) {
+          accepted.push(pendingProduct);
+          pendingProduct = null;
+        }
+      }
+      continue;
+    }
+    if (pendingProduct) {
+      accepted.push(pendingProduct);
+      pendingProduct = null;
+    }
+    if (productRe.test(tok)) {
+      pendingProduct = tok;
+    }
+  }
+  if (pendingProduct)
+    accepted.push(pendingProduct);
+  if (accepted.length === 0)
+    return DEFAULT_BOT_AGENT;
+  const joined = accepted.join(" ");
+  if (Buffer.byteLength(joined, "utf-8") <= BOT_AGENT_MAX_LEN)
+    return joined;
+  const truncated = [];
+  let len = 0;
+  for (const t of accepted) {
+    const add = (truncated.length === 0 ? 0 : 1) + Buffer.byteLength(t, "utf-8");
+    if (len + add > BOT_AGENT_MAX_LEN)
+      break;
+    truncated.push(t);
+    len += add;
+  }
+  return truncated.length > 0 ? truncated.join(" ") : DEFAULT_BOT_AGENT;
+}
 function buildBaseInfo() {
-  return { channel_version: CHANNEL_VERSION };
+  return {
+    channel_version: CHANNEL_VERSION,
+    bot_agent: sanitizeBotAgent(loadConfigBotAgent())
+  };
 }
 function ensureTrailingSlash(url) {
   return url.endsWith("/") ? url : `${url}/`;
@@ -10502,6 +10679,9 @@ function randomWechatUin() {
 }
 function buildCommonHeaders() {
   const headers = {};
+  if (ILINK_APP_ID)
+    headers["iLink-App-Id"] = ILINK_APP_ID;
+  headers["iLink-App-ClientVersion"] = String(ILINK_APP_CLIENT_VERSION);
   const routeTag = loadConfigRouteTag();
   if (routeTag) {
     headers.SKRouteTag = routeTag;
@@ -10547,6 +10727,35 @@ async function apiGetFetch(params) {
     throw err;
   }
 }
+async function apiPostFetch(params) {
+  const base = ensureTrailingSlash(params.baseUrl);
+  const url = new URL(params.endpoint, base);
+  const hdrs = buildCommonHeaders();
+  hdrs["Content-Type"] = "application/json";
+  logger.debug(`POST ${redactUrl(url.toString())} body=${redactBody(params.body)}`);
+  const controller = new AbortController;
+  const t = params.timeoutMs !== undefined ? setTimeout(() => controller.abort(), params.timeoutMs) : undefined;
+  const onAbort = () => controller.abort();
+  params.abortSignal?.addEventListener("abort", onAbort, { once: true });
+  try {
+    const res = await fetch(url.toString(), {
+      method: "POST",
+      headers: hdrs,
+      body: params.body,
+      signal: controller.signal
+    });
+    const rawText = await res.text();
+    logger.debug(`${params.label} status=${res.status} raw=${redactBody(rawText)}`);
+    if (!res.ok) {
+      throw new Error(`${params.label} ${res.status}: ${rawText}`);
+    }
+    return rawText;
+  } finally {
+    if (t !== undefined)
+      clearTimeout(t);
+    params.abortSignal?.removeEventListener("abort", onAbort);
+  }
+}
 async function apiFetch(params) {
   const base = ensureTrailingSlash(params.baseUrl);
   const url = new URL(params.endpoint, base);
@@ -10705,7 +10914,7 @@ async function sendTyping(params) {
     label: "sendTyping"
   });
 }
-var CHANNEL_VERSION, DEFAULT_LONG_POLL_TIMEOUT_MS = 35000, DEFAULT_API_TIMEOUT_MS = 15000, DEFAULT_CONFIG_TIMEOUT_MS = 1e4;
+var CHANNEL_VERSION, ILINK_APP_CLIENT_VERSION, ILINK_APP_ID, DEFAULT_BOT_AGENT = "weacpx", BOT_AGENT_MAX_LEN = 256, DEFAULT_LONG_POLL_TIMEOUT_MS = 35000, DEFAULT_API_TIMEOUT_MS = 15000, DEFAULT_CONFIG_TIMEOUT_MS = 1e4;
 var init_api = __esm(() => {
   init_version();
   init_accounts();
@@ -10713,6 +10922,8 @@ var init_api = __esm(() => {
   init_redact();
   init_send_errors();
   CHANNEL_VERSION = readVersion();
+  ILINK_APP_CLIENT_VERSION = buildClientVersion(CHANNEL_VERSION);
+  ILINK_APP_ID = (process.env.WEACPX_ILINK_APP_ID ?? "").trim();
 });
 
 // node_modules/qrcode-terminal/vendor/QRCode/QRMode.js
@@ -11744,22 +11955,47 @@ function purgeExpiredLogins() {
     }
   }
 }
+function getLocalBotTokenList() {
+  const accountIds = listIndexedWeixinAccountIds();
+  const tokens = [];
+  for (let i = accountIds.length - 1;i >= 0 && tokens.length < 10; i--) {
+    const accountId = accountIds[i];
+    if (!accountId)
+      continue;
+    const data = loadWeixinAccount(accountId);
+    const token = data?.token?.trim();
+    if (token) {
+      tokens.push(token);
+    }
+  }
+  return tokens;
+}
 async function fetchQRCode(apiBaseUrl, botType) {
   logger.info(`Fetching QR code from: ${apiBaseUrl} bot_type=${botType}`);
-  const rawText = await apiGetFetch({
+  const localTokenList = getLocalBotTokenList();
+  logger.info(`fetchQRCode: local_token_list count=${localTokenList.length}`);
+  const rawText = await apiPostFetch({
     baseUrl: apiBaseUrl,
     endpoint: `ilink/bot/get_bot_qrcode?bot_type=${encodeURIComponent(botType)}`,
-    timeoutMs: GET_QRCODE_TIMEOUT_MS,
+    body: JSON.stringify({ local_token_list: localTokenList }),
     label: "fetchQRCode"
   });
   return JSON.parse(rawText);
 }
-async function pollQRStatus(apiBaseUrl, qrcode) {
-  logger.debug(`Long-poll QR status from: ${apiBaseUrl} qrcode=***`);
+function buildPollQRStatusEndpoint(qrcode, verifyCode) {
+  let endpoint = `ilink/bot/get_qrcode_status?qrcode=${encodeURIComponent(qrcode)}`;
+  if (verifyCode) {
+    endpoint += `&verify_code=${encodeURIComponent(verifyCode)}`;
+  }
+  return endpoint;
+}
+async function pollQRStatus(apiBaseUrl, qrcode, verifyCode) {
+  logger.debug(`Long-poll QR status from: ${apiBaseUrl} qrcode=*** hasVerifyCode=${Boolean(verifyCode)}`);
+  const endpoint = buildPollQRStatusEndpoint(qrcode, verifyCode);
   try {
     const rawText = await apiGetFetch({
       baseUrl: apiBaseUrl,
-      endpoint: `ilink/bot/get_qrcode_status?qrcode=${encodeURIComponent(qrcode)}`,
+      endpoint,
       timeoutMs: QR_LONG_POLL_TIMEOUT_MS,
       label: "pollQRStatus"
     });
@@ -11774,6 +12010,28 @@ async function pollQRStatus(apiBaseUrl, qrcode) {
     return { status: "wait" };
   }
 }
+async function readVerifyCodeFromStdin(prompt) {
+  if (!process.stdin.isTTY) {
+    throw new Error("verify code requested but stdin is not a TTY (running in daemon mode?)");
+  }
+  process.stdout.write(prompt);
+  return new Promise((resolve) => {
+    let input = "";
+    const onData = (chunk) => {
+      const str = chunk.toString();
+      input += str;
+      if (input.includes(`
+`)) {
+        process.stdin.removeListener("data", onData);
+        process.stdin.pause();
+        resolve(input.trim());
+      }
+    };
+    process.stdin.resume();
+    process.stdin.setEncoding("utf-8");
+    process.stdin.on("data", onData);
+  });
+}
 async function startWeixinLoginWithQr(opts) {
   const sessionKey = opts.accountId || randomUUID2();
   purgeExpiredLogins();
@@ -11812,6 +12070,36 @@ async function startWeixinLoginWithQr(opts) {
     };
   }
 }
+async function refreshQRCode(activeLogin, botType, qrRefreshCount, onScannedReset) {
+  try {
+    const qrResponse = await fetchQRCode(FIXED_BASE_URL, botType);
+    activeLogin.qrcode = qrResponse.qrcode;
+    activeLogin.qrcodeUrl = qrResponse.qrcode_img_content;
+    activeLogin.startedAt = Date.now();
+    onScannedReset();
+    logger.info(`refreshQRCode: new QR code obtained (${qrRefreshCount}/${MAX_QR_REFRESH_COUNT}) qrcode=${redactToken(qrResponse.qrcode)}`);
+    process.stdout.write(`\uD83D\uDD04 新二维码已生成，请重新扫描
+
+`);
+    try {
+      const qrterm = await Promise.resolve().then(() => __toESM(require_main(), 1));
+      qrterm.default.generate(qrResponse.qrcode_img_content, { small: true });
+      process.stdout.write(`如果二维码未能成功展示，请用浏览器打开以下链接扫码：
+`);
+      process.stdout.write(`${qrResponse.qrcode_img_content}
+`);
+    } catch {
+      process.stdout.write(`二维码未加载成功，请用浏览器打开以下链接扫码：
+`);
+      process.stdout.write(`${qrResponse.qrcode_img_content}
+`);
+    }
+    return { success: true };
+  } catch (refreshErr) {
+    logger.error(`refreshQRCode: failed to refresh QR code: ${String(refreshErr)}`);
+    return { success: false, message: `刷新二维码失败: ${String(refreshErr)}` };
+  }
+}
 async function waitForWeixinLogin(opts) {
   let activeLogin = activeLogins.get(opts.sessionKey);
   if (!activeLogin) {
@@ -11838,7 +12126,7 @@ async function waitForWeixinLogin(opts) {
   while (Date.now() < deadline) {
     try {
       const currentBaseUrl = activeLogin.currentApiBaseUrl ?? FIXED_BASE_URL;
-      const statusResponse = await pollQRStatus(currentBaseUrl, activeLogin.qrcode);
+      const statusResponse = await pollQRStatus(currentBaseUrl, activeLogin.qrcode, activeLogin.pendingVerifyCode);
       logger.debug(`pollQRStatus: status=${statusResponse.status} hasBotToken=${Boolean(statusResponse.bot_token)} hasBotId=${Boolean(statusResponse.ilink_bot_id)}`);
       activeLogin.status = statusResponse.status;
       switch (statusResponse.status) {
@@ -11848,6 +12136,10 @@ async function waitForWeixinLogin(opts) {
           }
           break;
         case "scaned":
+          if (activeLogin.pendingVerifyCode) {
+            logger.info("verify code accepted, resuming polling");
+            activeLogin.pendingVerifyCode = undefined;
+          }
           if (!scannedPrinted) {
             process.stdout.write(`
 \uD83D\uDC40 已扫码，在微信继续操作...
@@ -11856,6 +12148,7 @@ async function waitForWeixinLogin(opts) {
           }
           break;
         case "expired": {
+          activeLogin.pendingVerifyCode = undefined;
           qrRefreshCount++;
           if (qrRefreshCount > MAX_QR_REFRESH_COUNT) {
             logger.warn(`waitForWeixinLogin: QR expired ${MAX_QR_REFRESH_COUNT} times, giving up sessionKey=${opts.sessionKey}`);
@@ -11869,36 +12162,14 @@ async function waitForWeixinLogin(opts) {
 ⏳ 二维码已过期，正在刷新...(${qrRefreshCount}/${MAX_QR_REFRESH_COUNT})
 `);
           logger.info(`waitForWeixinLogin: QR expired, refreshing (${qrRefreshCount}/${MAX_QR_REFRESH_COUNT})`);
-          try {
-            const botType = opts.botType || DEFAULT_ILINK_BOT_TYPE;
-            const qrResponse = await fetchQRCode(FIXED_BASE_URL, botType);
-            activeLogin.qrcode = qrResponse.qrcode;
-            activeLogin.qrcodeUrl = qrResponse.qrcode_img_content;
-            activeLogin.startedAt = Date.now();
+          const expiredRefreshResult = await refreshQRCode(activeLogin, opts.botType || DEFAULT_ILINK_BOT_TYPE, qrRefreshCount, () => {
             scannedPrinted = false;
-            logger.info(`waitForWeixinLogin: new QR code obtained qrcode=${redactToken(qrResponse.qrcode)}`);
-            process.stdout.write(`\uD83D\uDD04 新二维码已生成，请重新扫描
-
-`);
-            try {
-              const qrterm = await Promise.resolve().then(() => __toESM(require_main(), 1));
-              qrterm.default.generate(qrResponse.qrcode_img_content, { small: true });
-              process.stdout.write(`如果二维码未能成功展示，请用浏览器打开以下链接扫码：
-`);
-              process.stdout.write(`${qrResponse.qrcode_img_content}
-`);
-            } catch {
-              process.stdout.write(`二维码未加载成功，请用浏览器打开以下链接扫码：
-`);
-              process.stdout.write(`${qrResponse.qrcode_img_content}
-`);
-            }
-          } catch (refreshErr) {
-            logger.error(`waitForWeixinLogin: failed to refresh QR code: ${String(refreshErr)}`);
+          });
+          if (!expiredRefreshResult.success) {
             activeLogins.delete(opts.sessionKey);
             return {
               connected: false,
-              message: `刷新二维码失败: ${String(refreshErr)}`
+              message: expiredRefreshResult.message
             };
           }
           break;
@@ -11914,6 +12185,49 @@ async function waitForWeixinLogin(opts) {
           }
           break;
         }
+        case "need_verifycode": {
+          const verifyPrompt = activeLogin.pendingVerifyCode ? "❌ 你输入的数字不匹配，请重新输入：" : "输入手机微信显示的数字，以继续连接：";
+          let code;
+          try {
+            code = await readVerifyCodeFromStdin(verifyPrompt);
+          } catch (err) {
+            logger.error(`waitForWeixinLogin: cannot read verify code (no TTY): ${String(err)}`);
+            activeLogins.delete(opts.sessionKey);
+            return {
+              connected: false,
+              message: "需要输入配对码，但当前环境没有交互式终端。请在前台运行 `weacpx login` 完成登录。"
+            };
+          }
+          activeLogin.pendingVerifyCode = code;
+          continue;
+        }
+        case "verify_code_blocked": {
+          logger.warn(`waitForWeixinLogin: verify code blocked, qrRefreshCount=${qrRefreshCount} sessionKey=${opts.sessionKey}`);
+          process.stdout.write(`
+⛔ 多次输入错误，请稍后再试。
+`);
+          activeLogin.pendingVerifyCode = undefined;
+          qrRefreshCount++;
+          if (qrRefreshCount > MAX_QR_REFRESH_COUNT) {
+            logger.warn(`waitForWeixinLogin: verify_code_blocked and QR refresh limit reached, giving up sessionKey=${opts.sessionKey}`);
+            activeLogins.delete(opts.sessionKey);
+            return {
+              connected: false,
+              message: "多次输入错误，连接流程已停止。请稍后再试。"
+            };
+          }
+          const blockedRefreshResult = await refreshQRCode(activeLogin, opts.botType || DEFAULT_ILINK_BOT_TYPE, qrRefreshCount, () => {
+            scannedPrinted = false;
+          });
+          if (!blockedRefreshResult.success) {
+            activeLogins.delete(opts.sessionKey);
+            return {
+              connected: false,
+              message: blockedRefreshResult.message
+            };
+          }
+          break;
+        }
         case "confirmed": {
           if (!statusResponse.ilink_bot_id) {
             activeLogins.delete(opts.sessionKey);
@@ -11953,140 +12267,22 @@ async function waitForWeixinLogin(opts) {
     message: "登录超时，请重试。"
   };
 }
-var ACTIVE_LOGIN_TTL_MS, GET_QRCODE_TIMEOUT_MS = 5000, QR_LONG_POLL_TIMEOUT_MS = 35000, DEFAULT_ILINK_BOT_TYPE = "3", FIXED_BASE_URL = "https://ilinkai.weixin.qq.com", activeLogins, MAX_QR_REFRESH_COUNT = 3;
+var ACTIVE_LOGIN_TTL_MS, QR_LONG_POLL_TIMEOUT_MS = 35000, DEFAULT_ILINK_BOT_TYPE = "3", FIXED_BASE_URL = "https://ilinkai.weixin.qq.com", activeLogins, MAX_QR_REFRESH_COUNT = 3;
 var init_login_qr = __esm(() => {
   init_api();
+  init_accounts();
   init_logger();
   init_redact();
   ACTIVE_LOGIN_TTL_MS = 5 * 60000;
   activeLogins = new Map;
 });
 
-// src/weixin/api/config-cache.ts
-class WeixinConfigManager {
-  apiOpts;
-  log;
-  cache = new Map;
-  constructor(apiOpts, log) {
-    this.apiOpts = apiOpts;
-    this.log = log;
-  }
-  async getForUser(userId, contextToken) {
-    const now = Date.now();
-    const entry = this.cache.get(userId);
-    const shouldFetch = !entry || now >= entry.nextFetchAt;
-    if (shouldFetch) {
-      let fetchOk = false;
-      try {
-        const resp = await getConfig({
-          baseUrl: this.apiOpts.baseUrl,
-          token: this.apiOpts.token,
-          ilinkUserId: userId,
-          contextToken
-        });
-        if (resp.ret === 0) {
-          this.cache.set(userId, {
-            config: { typingTicket: resp.typing_ticket ?? "" },
-            everSucceeded: true,
-            nextFetchAt: now + Math.random() * CONFIG_CACHE_TTL_MS,
-            retryDelayMs: CONFIG_CACHE_INITIAL_RETRY_MS
-          });
-          this.log(`[weixin] config ${entry?.everSucceeded ? "refreshed" : "cached"} for ${userId}`);
-          fetchOk = true;
-        }
-      } catch (err) {
-        this.log(`[weixin] getConfig failed for ${userId} (ignored): ${String(err)}`);
-      }
-      if (!fetchOk) {
-        const prevDelay = entry?.retryDelayMs ?? CONFIG_CACHE_INITIAL_RETRY_MS;
-        const nextDelay = Math.min(prevDelay * 2, CONFIG_CACHE_MAX_RETRY_MS);
-        if (entry) {
-          entry.nextFetchAt = now + nextDelay;
-          entry.retryDelayMs = nextDelay;
-        } else {
-          this.cache.set(userId, {
-            config: { typingTicket: "" },
-            everSucceeded: false,
-            nextFetchAt: now + CONFIG_CACHE_INITIAL_RETRY_MS,
-            retryDelayMs: CONFIG_CACHE_INITIAL_RETRY_MS
-          });
-        }
-      }
-    }
-    return this.cache.get(userId)?.config ?? { typingTicket: "" };
-  }
-}
-var CONFIG_CACHE_TTL_MS, CONFIG_CACHE_INITIAL_RETRY_MS = 2000, CONFIG_CACHE_MAX_RETRY_MS;
-var init_config_cache = __esm(() => {
-  init_api();
-  CONFIG_CACHE_TTL_MS = 24 * 60 * 60 * 1000;
-  CONFIG_CACHE_MAX_RETRY_MS = 60 * 60 * 1000;
-});
-
-// src/weixin/api/session-guard.ts
-function pauseSession(accountId) {
-  const until = Date.now() + SESSION_PAUSE_DURATION_MS;
-  pauseUntilMap.set(accountId, until);
-  logger.info(`session-guard: paused accountId=${accountId} until=${new Date(until).toISOString()} (${SESSION_PAUSE_DURATION_MS / 1000}s)`);
-}
-function getRemainingPauseMs(accountId) {
-  const until = pauseUntilMap.get(accountId);
-  if (until === undefined)
-    return 0;
-  const remaining = until - Date.now();
-  if (remaining <= 0) {
-    pauseUntilMap.delete(accountId);
-    return 0;
-  }
-  return remaining;
-}
-var SESSION_PAUSE_DURATION_MS, SESSION_EXPIRED_ERRCODE = -14, pauseUntilMap;
-var init_session_guard = __esm(() => {
-  init_logger();
-  SESSION_PAUSE_DURATION_MS = 60 * 60 * 1000;
-  pauseUntilMap = new Map;
-});
-
-// src/weixin/messaging/conversation-executor.ts
-function createConversationExecutor() {
-  const states = new Map;
-  const getState = (conversationId) => {
-    const existing = states.get(conversationId);
-    if (existing)
-      return existing;
-    const created = { activeControls: 0 };
-    states.set(conversationId, created);
-    return created;
-  };
-  const cleanupState = (conversationId, state) => {
-    if (!state.normalTail && state.activeControls === 0) {
-      states.delete(conversationId);
-    }
-  };
-  return {
-    run(conversationId, lane, task) {
-      const state = getState(conversationId);
-      if (lane === "control") {
-        state.activeControls += 1;
-        return Promise.resolve().then(task).finally(() => {
-          state.activeControls -= 1;
-          cleanupState(conversationId, state);
-        });
-      }
-      const previous = state.normalTail ?? Promise.resolve();
-      const next = previous.catch(() => {
-        return;
-      }).then(task);
-      state.normalTail = next;
-      return next.finally(() => {
-        if (state.normalTail === next) {
-          state.normalTail = undefined;
-        }
-        cleanupState(conversationId, state);
-      });
-    }
-  };
+// src/weixin/util/random.ts
+import crypto2 from "node:crypto";
+function generateId(prefix) {
+  return `${prefix}:${Date.now()}-${crypto2.randomBytes(4).toString("hex")}`;
 }
+var init_random = () => {};
 
 // src/weixin/api/types.ts
 var UploadMediaType, MessageType, MessageItemType, MessageState, TypingStatus;
@@ -12121,9 +12317,272 @@ var init_types2 = __esm(() => {
   };
 });
 
-// src/channels/media-store.ts
-import { access as access2, mkdir as mkdir7, readdir, rm as rm4, stat, writeFile as writeFile6 } from "node:fs/promises";
+// src/weixin/messaging/inbound.ts
+import fs5 from "node:fs";
 import path6 from "node:path";
+function contextTokenKey(accountId, userId) {
+  return `${accountId}:${userId}`;
+}
+function resolveContextTokenFilePath(accountId) {
+  return path6.join(resolveStateDir(), "openclaw-weixin", "accounts", `${accountId}.context-tokens.json`);
+}
+function persistContextTokens(accountId) {
+  const prefix = `${accountId}:`;
+  const tokens = {};
+  for (const [k, v] of contextTokenStore) {
+    if (k.startsWith(prefix))
+      tokens[k.slice(prefix.length)] = v;
+  }
+  const filePath = resolveContextTokenFilePath(accountId);
+  try {
+    writePrivateFileSync(filePath, JSON.stringify(tokens));
+  } catch (err) {
+    logger.warn(`persistContextTokens: failed to write ${filePath}: ${String(err)}`);
+  }
+}
+function restoreContextTokens(accountId) {
+  const filePath = resolveContextTokenFilePath(accountId);
+  try {
+    if (!fs5.existsSync(filePath))
+      return;
+    const raw = fs5.readFileSync(filePath, "utf-8");
+    const tokens = JSON.parse(raw);
+    let count = 0;
+    for (const [userId, token] of Object.entries(tokens)) {
+      if (typeof token === "string" && token) {
+        contextTokenStore.set(contextTokenKey(accountId, userId), token);
+        count++;
+      }
+    }
+    logger.info(`restoreContextTokens: restored ${count} tokens for account=${accountId}`);
+  } catch (err) {
+    logger.warn(`restoreContextTokens: failed to read ${filePath}: ${String(err)}`);
+  }
+}
+function clearContextTokensForAccount(accountId) {
+  const prefix = `${accountId}:`;
+  for (const k of [...contextTokenStore.keys()]) {
+    if (k.startsWith(prefix))
+      contextTokenStore.delete(k);
+  }
+  const filePath = resolveContextTokenFilePath(accountId);
+  try {
+    if (fs5.existsSync(filePath))
+      fs5.unlinkSync(filePath);
+  } catch (err) {
+    logger.warn(`clearContextTokensForAccount: failed to remove ${filePath}: ${String(err)}`);
+  }
+  logger.info(`clearContextTokensForAccount: cleared tokens for account=${accountId}`);
+}
+function setContextToken(accountId, userId, token) {
+  const k = contextTokenKey(accountId, userId);
+  logger.debug(`setContextToken: key=${k}`);
+  contextTokenStore.set(k, token);
+  persistContextTokens(accountId);
+}
+function getContextToken(accountId, userId) {
+  const k = contextTokenKey(accountId, normalizeWeixinUserIdFromChatKey(userId));
+  const val = contextTokenStore.get(k);
+  logger.debug(`getContextToken: key=${k} found=${val !== undefined} storeSize=${contextTokenStore.size}`);
+  return val;
+}
+function normalizeWeixinUserIdFromChatKey(chatKey) {
+  const parts = chatKey.split(":");
+  if (parts[0] === "weixin" && parts[2]) {
+    return parts.slice(2).join(":");
+  }
+  return chatKey;
+}
+function isMediaItem(item) {
+  return item.type === MessageItemType.IMAGE || item.type === MessageItemType.VIDEO || item.type === MessageItemType.FILE || item.type === MessageItemType.VOICE;
+}
+function bodyFromItemList(itemList) {
+  if (!itemList?.length)
+    return "";
+  for (const item of itemList) {
+    if (item.type === MessageItemType.TEXT && item.text_item?.text != null) {
+      const text = String(item.text_item.text);
+      const ref = item.ref_msg;
+      if (!ref)
+        return text;
+      if (ref.message_item && isMediaItem(ref.message_item))
+        return text;
+      const parts = [];
+      if (ref.title)
+        parts.push(ref.title);
+      if (ref.message_item) {
+        const refBody = bodyFromItemList([ref.message_item]);
+        if (refBody)
+          parts.push(refBody);
+      }
+      if (!parts.length)
+        return text;
+      return `[引用: ${parts.join(" | ")}]
+${text}`;
+    }
+    if (item.type === MessageItemType.VOICE && item.voice_item?.text) {
+      return item.voice_item.text;
+    }
+  }
+  return "";
+}
+function extractWeixinMediaDescriptors(itemList) {
+  const out = [];
+  for (const item of itemList ?? []) {
+    const descriptor = descriptorFromItem(item);
+    if (descriptor)
+      out.push(descriptor);
+    const ref = item.type === MessageItemType.TEXT ? item.ref_msg?.message_item : undefined;
+    const refDescriptor = descriptorFromItem(ref);
+    if (refDescriptor)
+      out.push(refDescriptor);
+  }
+  return out;
+}
+function descriptorFromItem(item) {
+  if (!item)
+    return;
+  if (item.type === MessageItemType.IMAGE)
+    return { item, kind: "image" };
+  if (item.type === MessageItemType.VIDEO)
+    return { item, kind: "video" };
+  if (item.type === MessageItemType.FILE)
+    return { item, kind: "file", fileName: item.file_item?.file_name };
+  if (item.type === MessageItemType.VOICE)
+    return { item, kind: "audio" };
+  return;
+}
+var contextTokenStore;
+var init_inbound = __esm(() => {
+  init_logger();
+  init_random();
+  init_types2();
+  init_state_dir();
+  init_private_file();
+  contextTokenStore = new Map;
+});
+
+// src/weixin/api/config-cache.ts
+class WeixinConfigManager {
+  apiOpts;
+  log;
+  cache = new Map;
+  constructor(apiOpts, log) {
+    this.apiOpts = apiOpts;
+    this.log = log;
+  }
+  async getForUser(userId, contextToken) {
+    const now = Date.now();
+    const entry = this.cache.get(userId);
+    const shouldFetch = !entry || now >= entry.nextFetchAt;
+    if (shouldFetch) {
+      let fetchOk = false;
+      try {
+        const resp = await getConfig({
+          baseUrl: this.apiOpts.baseUrl,
+          token: this.apiOpts.token,
+          ilinkUserId: userId,
+          contextToken
+        });
+        if (resp.ret === 0) {
+          this.cache.set(userId, {
+            config: { typingTicket: resp.typing_ticket ?? "" },
+            everSucceeded: true,
+            nextFetchAt: now + Math.random() * CONFIG_CACHE_TTL_MS,
+            retryDelayMs: CONFIG_CACHE_INITIAL_RETRY_MS
+          });
+          this.log(`[weixin] config ${entry?.everSucceeded ? "refreshed" : "cached"} for ${userId}`);
+          fetchOk = true;
+        }
+      } catch (err) {
+        this.log(`[weixin] getConfig failed for ${userId} (ignored): ${String(err)}`);
+      }
+      if (!fetchOk) {
+        const prevDelay = entry?.retryDelayMs ?? CONFIG_CACHE_INITIAL_RETRY_MS;
+        const nextDelay = Math.min(prevDelay * 2, CONFIG_CACHE_MAX_RETRY_MS);
+        if (entry) {
+          entry.nextFetchAt = now + nextDelay;
+          entry.retryDelayMs = nextDelay;
+        } else {
+          this.cache.set(userId, {
+            config: { typingTicket: "" },
+            everSucceeded: false,
+            nextFetchAt: now + CONFIG_CACHE_INITIAL_RETRY_MS,
+            retryDelayMs: CONFIG_CACHE_INITIAL_RETRY_MS
+          });
+        }
+      }
+    }
+    return this.cache.get(userId)?.config ?? { typingTicket: "" };
+  }
+}
+var CONFIG_CACHE_TTL_MS, CONFIG_CACHE_INITIAL_RETRY_MS = 2000, CONFIG_CACHE_MAX_RETRY_MS;
+var init_config_cache = __esm(() => {
+  init_api();
+  CONFIG_CACHE_TTL_MS = 24 * 60 * 60 * 1000;
+  CONFIG_CACHE_MAX_RETRY_MS = 60 * 60 * 1000;
+});
+
+// src/weixin/api/session-guard.ts
+function pauseSession(accountId) {
+  const until = Date.now() + SESSION_PAUSE_DURATION_MS;
+  pauseUntilMap.set(accountId, until);
+  logger.info(`session-guard: paused accountId=${accountId} until=${new Date(until).toISOString()} (${SESSION_PAUSE_DURATION_MS / 1000}s)`);
+}
+function resetSessionPause(accountId) {
+  pauseUntilMap.delete(accountId);
+}
+var SESSION_PAUSE_DURATION_MS, SESSION_EXPIRED_ERRCODE = -14, pauseUntilMap;
+var init_session_guard = __esm(() => {
+  init_logger();
+  SESSION_PAUSE_DURATION_MS = 60 * 60 * 1000;
+  pauseUntilMap = new Map;
+});
+
+// src/weixin/messaging/conversation-executor.ts
+function createConversationExecutor() {
+  const states = new Map;
+  const getState = (conversationId) => {
+    const existing = states.get(conversationId);
+    if (existing)
+      return existing;
+    const created = { activeControls: 0 };
+    states.set(conversationId, created);
+    return created;
+  };
+  const cleanupState = (conversationId, state) => {
+    if (!state.normalTail && state.activeControls === 0) {
+      states.delete(conversationId);
+    }
+  };
+  return {
+    run(conversationId, lane, task) {
+      const state = getState(conversationId);
+      if (lane === "control") {
+        state.activeControls += 1;
+        return Promise.resolve().then(task).finally(() => {
+          state.activeControls -= 1;
+          cleanupState(conversationId, state);
+        });
+      }
+      const previous = state.normalTail ?? Promise.resolve();
+      const next = previous.catch(() => {
+        return;
+      }).then(task);
+      state.normalTail = next;
+      return next.finally(() => {
+        if (state.normalTail === next) {
+          state.normalTail = undefined;
+        }
+        cleanupState(conversationId, state);
+      });
+    }
+  };
+}
+
+// src/channels/media-store.ts
+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 {
   rootDir;
@@ -12139,19 +12598,19 @@ class RuntimeMediaStore {
     const safeChatKey = safePathSegment(input.chatKey);
     const safeMessageId = safePathSegment(input.messageId || "message");
     const baseFileName = sanitizeMediaFileName(input.fileName ?? "attachment", input.mimeType);
-    const dir = path6.join(this.rootDir, input.channelId, safeChatKey, safeMessageId);
+    const dir = path7.join(this.rootDir, input.channelId, safeChatKey, safeMessageId);
     await mkdir7(dir, { recursive: true });
-    const resolvedRoot = path6.resolve(this.rootDir);
-    const resolvedFile = path6.resolve(path6.join(dir, await uniqueFileName(dir, baseFileName)));
+    const resolvedRoot = path7.resolve(this.rootDir);
+    const resolvedFile = path7.resolve(path7.join(dir, await uniqueFileName(dir, baseFileName)));
     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,
       mimeType: input.mimeType,
-      fileName: path6.basename(resolvedFile),
+      fileName: path7.basename(resolvedFile),
       sizeBytes: input.buffer.byteLength,
       source: {
         channelId: input.channelId,
@@ -12167,10 +12626,10 @@ class RuntimeMediaStore {
   }
 }
 function sanitizeMediaFileName(fileName, mimeType) {
-  const base = path6.basename(fileName.trim() || "attachment");
+  const base = path7.basename(fileName.trim() || "attachment");
   const replaced = base.replace(/[\\/:*?"<>|\s]+/g, "-").replace(/^-+|-+$/g, "");
   const safe = replaced || "attachment";
-  const ext = path6.extname(safe);
+  const ext = path7.extname(safe);
   if (ext)
     return safe;
   return `${safe}${extensionFromMime(mimeType)}`;
@@ -12180,13 +12639,13 @@ function safePathSegment(value) {
   return safe || "unknown";
 }
 async function uniqueFileName(dir, baseName) {
-  const ext = path6.extname(baseName);
+  const ext = path7.extname(baseName);
   const stem = ext ? baseName.slice(0, -ext.length) : baseName;
   let candidate = baseName;
   let counter = 2;
   while (true) {
     try {
-      await access2(path6.join(dir, candidate));
+      await access2(path7.join(dir, candidate));
       candidate = `${stem}-${counter}${ext}`;
       counter += 1;
     } catch {
@@ -12217,8 +12676,8 @@ function extensionFromMime(mimeType) {
   return ".bin";
 }
 function isPathInside(candidate, root) {
-  const relative = path6.relative(root, candidate);
-  return relative === "" || !relative.startsWith("..") && !path6.isAbsolute(relative);
+  const relative = path7.relative(root, candidate);
+  return relative === "" || !relative.startsWith("..") && !path7.isAbsolute(relative);
 }
 async function cleanupDir(dir, cutoffMs) {
   let entries;
@@ -12229,7 +12688,7 @@ async function cleanupDir(dir, cutoffMs) {
   }
   let empty = true;
   for (const entry of entries) {
-    const full = path6.join(dir, entry.name);
+    const full = path7.join(dir, entry.name);
     if (entry.isDirectory()) {
       const childEmpty = await cleanupDir(full, cutoffMs);
       if (childEmpty) {
@@ -12258,18 +12717,18 @@ var init_media_store = __esm(() => {
 });
 
 // src/channels/outbound-media-safety.ts
-import fs5 from "node:fs/promises";
-import path7 from "node:path";
+import fs6 from "node:fs/promises";
+import path8 from "node:path";
 async function resolveSafeOutboundMediaPath(mediaPath, allowedRoots) {
   if (mediaPath.startsWith("http://") || mediaPath.startsWith("https://")) {
     return null;
   }
-  const candidate = path7.isAbsolute(mediaPath) ? mediaPath : path7.resolve(mediaPath);
+  const candidate = path8.isAbsolute(mediaPath) ? mediaPath : path8.resolve(mediaPath);
   const realCandidate = await realpathOrNull(candidate);
   if (!realCandidate) {
     return null;
   }
-  const stat2 = await fs5.stat(realCandidate).catch(() => null);
+  const stat2 = await fs6.stat(realCandidate).catch(() => null);
   if (!stat2?.isFile()) {
     return null;
   }
@@ -12283,21 +12742,21 @@ async function resolveSafeOutboundMediaPath(mediaPath, allowedRoots) {
 }
 async function realpathOrNull(filePath) {
   try {
-    return await fs5.realpath(filePath);
+    return await fs6.realpath(filePath);
   } catch {
     return null;
   }
 }
 function isPathInside2(candidate, root) {
-  const relative = path7.relative(root, candidate);
-  return relative === "" || !relative.startsWith("..") && !path7.isAbsolute(relative);
+  const relative = path8.relative(root, candidate);
+  return relative === "" || !relative.startsWith("..") && !path8.isAbsolute(relative);
 }
 var init_outbound_media_safety = () => {};
 
 // src/weixin/media/mime.ts
-import path8 from "node:path";
+import path9 from "node:path";
 function getMimeFromFilename(filename) {
-  const ext = path8.extname(filename).toLowerCase();
+  const ext = path9.extname(filename).toLowerCase();
   return EXTENSION_TO_MIME[ext] ?? "application/octet-stream";
 }
 function getExtensionFromMime(mimeType) {
@@ -12635,115 +13094,361 @@ function buildFinalHeadsUp(input) {
 \uD83D\uDCC4 结果共 ${total} 段，已发 ${sentSoFar} 段。回复 /jx 续看后 ${remaining} 段。`;
 }
 
-// src/weixin/util/random.ts
-import crypto2 from "node:crypto";
-function generateId(prefix) {
-  return `${prefix}:${Date.now()}-${crypto2.randomBytes(4).toString("hex")}`;
-}
-var init_random = () => {};
-
-// src/weixin/messaging/inbound.ts
-function contextTokenKey(accountId, userId) {
-  return `${accountId}:${userId}`;
-}
-function setContextToken(accountId, userId, token) {
-  const k = contextTokenKey(accountId, userId);
-  logger.debug(`setContextToken: key=${k}`);
-  contextTokenStore.set(k, token);
-}
-function getContextToken(accountId, userId) {
-  const k = contextTokenKey(accountId, normalizeWeixinUserIdFromChatKey(userId));
-  const val = contextTokenStore.get(k);
-  logger.debug(`getContextToken: key=${k} found=${val !== undefined} storeSize=${contextTokenStore.size}`);
-  return val;
-}
-function normalizeWeixinUserIdFromChatKey(chatKey) {
-  const parts = chatKey.split(":");
-  if (parts[0] === "weixin" && parts[2]) {
-    return parts.slice(2).join(":");
+// src/weixin/messaging/markdown-filter.ts
+class StreamingMarkdownFilter {
+  buf = "";
+  fence = false;
+  sol = true;
+  inl = null;
+  feed(delta) {
+    this.buf += delta;
+    return this.pump(false);
   }
-  return chatKey;
-}
-function isMediaItem(item) {
-  return item.type === MessageItemType.IMAGE || item.type === MessageItemType.VIDEO || item.type === MessageItemType.FILE || item.type === MessageItemType.VOICE;
-}
-function bodyFromItemList(itemList) {
-  if (!itemList?.length)
+  flush() {
+    return this.pump(true);
+  }
+  pump(eof) {
+    let out = "";
+    while (this.buf) {
+      const sLen = this.buf.length;
+      const sSol = this.sol;
+      const sFence = this.fence;
+      const sInl = this.inl;
+      if (this.fence)
+        out += this.pumpFence(eof);
+      else if (this.inl)
+        out += this.pumpInline(eof);
+      else if (this.sol)
+        out += this.pumpSOL(eof);
+      else
+        out += this.pumpBody(eof);
+      if (this.buf.length === sLen && this.sol === sSol && this.fence === sFence && this.inl === sInl)
+        break;
+    }
+    if (eof && this.inl) {
+      const markers = { image: "![", bold3: "***", italic: "*", ubold3: "___", uitalic: "_" };
+      out += (markers[this.inl.type] ?? "") + this.inl.acc;
+      this.inl = null;
+    }
+    return out;
+  }
+  pumpFence(eof) {
+    if (this.sol) {
+      if (this.buf.length < 3 && !eof)
+        return "";
+      if (this.buf.startsWith("```")) {
+        const nl2 = this.buf.indexOf(`
+`, 3);
+        if (nl2 !== -1) {
+          this.fence = false;
+          const line = this.buf.slice(0, nl2 + 1);
+          this.buf = this.buf.slice(nl2 + 1);
+          this.sol = true;
+          return line;
+        }
+        if (eof) {
+          this.fence = false;
+          const line = this.buf;
+          this.buf = "";
+          return line;
+        }
+        return "";
+      }
+      this.sol = false;
+    }
+    const nl = this.buf.indexOf(`
+`);
+    if (nl !== -1) {
+      const chunk2 = this.buf.slice(0, nl + 1);
+      this.buf = this.buf.slice(nl + 1);
+      this.sol = true;
+      return chunk2;
+    }
+    const chunk = this.buf;
+    this.buf = "";
+    return chunk;
+  }
+  pumpSOL(eof) {
+    const b = this.buf;
+    if (b[0] === `
+`) {
+      this.buf = b.slice(1);
+      return `
+`;
+    }
+    if (b[0] === "`") {
+      if (b.length < 3 && !eof)
+        return "";
+      if (b.startsWith("```")) {
+        const nl = b.indexOf(`
+`, 3);
+        if (nl !== -1) {
+          this.fence = true;
+          const line = b.slice(0, nl + 1);
+          this.buf = b.slice(nl + 1);
+          this.sol = true;
+          return line;
+        }
+        if (eof) {
+          this.buf = "";
+          return b;
+        }
+        return "";
+      }
+      this.sol = false;
+      return "";
+    }
+    if (b[0] === ">") {
+      this.sol = false;
+      return "";
+    }
+    if (b[0] === "#") {
+      let n = 0;
+      while (n < b.length && b[n] === "#")
+        n++;
+      if (n === b.length && !eof)
+        return "";
+      if (n >= 5 && n <= 6 && n < b.length && b[n] === " ") {
+        this.buf = b.slice(n + 1);
+        this.sol = false;
+        return "";
+      }
+      this.sol = false;
+      return "";
+    }
+    if (b[0] === " " || b[0] === "\t") {
+      if (b.search(/[^ \t]/) === -1 && !eof)
+        return "";
+      this.sol = false;
+      return "";
+    }
+    if (b[0] === "-" || b[0] === "*" || b[0] === "_") {
+      const ch = b[0];
+      let j = 0;
+      while (j < b.length && (b[j] === ch || b[j] === " "))
+        j++;
+      if (j === b.length && !eof)
+        return "";
+      if (j === b.length || b[j] === `
+`) {
+        let count = 0;
+        for (let k = 0;k < j; k++)
+          if (b[k] === ch)
+            count++;
+        if (count >= 3) {
+          if (j < b.length) {
+            this.buf = b.slice(j + 1);
+            this.sol = true;
+            return b.slice(0, j + 1);
+          }
+          this.buf = "";
+          return b;
+        }
+      }
+      this.sol = false;
+      return "";
+    }
+    this.sol = false;
     return "";
-  for (const item of itemList) {
-    if (item.type === MessageItemType.TEXT && item.text_item?.text != null) {
-      const text = String(item.text_item.text);
-      const ref = item.ref_msg;
-      if (!ref)
-        return text;
-      if (ref.message_item && isMediaItem(ref.message_item))
-        return text;
-      const parts = [];
-      if (ref.title)
-        parts.push(ref.title);
-      if (ref.message_item) {
-        const refBody = bodyFromItemList([ref.message_item]);
-        if (refBody)
-          parts.push(refBody);
+  }
+  pumpBody(eof) {
+    let out = "";
+    let i = 0;
+    while (i < this.buf.length) {
+      const c = this.buf[i];
+      if (c === `
+`) {
+        out += this.buf.slice(0, i + 1);
+        this.buf = this.buf.slice(i + 1);
+        this.sol = true;
+        return out;
+      }
+      if (c === "!" && i + 1 < this.buf.length && this.buf[i + 1] === "[") {
+        out += this.buf.slice(0, i);
+        this.buf = this.buf.slice(i + 2);
+        this.inl = { type: "image", acc: "" };
+        return out;
+      }
+      if (c === "~") {
+        i++;
+        continue;
       }
-      if (!parts.length)
-        return text;
-      return `[引用: ${parts.join(" | ")}]
-${text}`;
+      if (c === "*") {
+        if (i + 2 < this.buf.length && this.buf[i + 1] === "*" && this.buf[i + 2] === "*") {
+          out += this.buf.slice(0, i);
+          this.buf = this.buf.slice(i + 3);
+          this.inl = { type: "bold3", acc: "" };
+          return out;
+        }
+        if (i + 1 < this.buf.length && this.buf[i + 1] === "*") {
+          i += 2;
+          continue;
+        }
+        if (i + 1 < this.buf.length && this.buf[i + 1] !== " " && this.buf[i + 1] !== `
+`) {
+          out += this.buf.slice(0, i);
+          this.buf = this.buf.slice(i + 1);
+          this.inl = { type: "italic", acc: "" };
+          return out;
+        }
+        i++;
+        continue;
+      }
+      if (c === "_") {
+        if (i + 2 < this.buf.length && this.buf[i + 1] === "_" && this.buf[i + 2] === "_") {
+          out += this.buf.slice(0, i);
+          this.buf = this.buf.slice(i + 3);
+          this.inl = { type: "ubold3", acc: "" };
+          return out;
+        }
+        if (i + 1 < this.buf.length && this.buf[i + 1] === "_") {
+          i += 2;
+          continue;
+        }
+        if (i + 1 < this.buf.length && this.buf[i + 1] !== " " && this.buf[i + 1] !== `
+`) {
+          out += this.buf.slice(0, i);
+          this.buf = this.buf.slice(i + 1);
+          this.inl = { type: "uitalic", acc: "" };
+          return out;
+        }
+        i++;
+        continue;
+      }
+      i++;
     }
-    if (item.type === MessageItemType.VOICE && item.voice_item?.text) {
-      return item.voice_item.text;
+    let hold = 0;
+    if (!eof) {
+      if (this.buf.endsWith("**"))
+        hold = 2;
+      else if (this.buf.endsWith("__"))
+        hold = 2;
+      else if (this.buf.endsWith("*"))
+        hold = 1;
+      else if (this.buf.endsWith("_"))
+        hold = 1;
+      else if (this.buf.endsWith("!"))
+        hold = 1;
+    }
+    out += this.buf.slice(0, this.buf.length - hold);
+    this.buf = hold > 0 ? this.buf.slice(-hold) : "";
+    return out;
+  }
+  pumpInline(_eof) {
+    if (!this.inl)
+      return "";
+    this.inl.acc += this.buf;
+    this.buf = "";
+    switch (this.inl.type) {
+      case "bold3": {
+        const idx = this.inl.acc.indexOf("***");
+        if (idx !== -1) {
+          const content = this.inl.acc.slice(0, idx);
+          this.buf = this.inl.acc.slice(idx + 3);
+          this.inl = null;
+          if (StreamingMarkdownFilter.containsCJK(content))
+            return content;
+          return `***${content}***`;
+        }
+        return "";
+      }
+      case "ubold3": {
+        const idx = this.inl.acc.indexOf("___");
+        if (idx !== -1) {
+          const content = this.inl.acc.slice(0, idx);
+          this.buf = this.inl.acc.slice(idx + 3);
+          this.inl = null;
+          if (StreamingMarkdownFilter.containsCJK(content))
+            return content;
+          return `___${content}___`;
+        }
+        return "";
+      }
+      case "italic": {
+        for (let j = 0;j < this.inl.acc.length; j++) {
+          if (this.inl.acc[j] === `
+`) {
+            const r = "*" + this.inl.acc.slice(0, j + 1);
+            this.buf = this.inl.acc.slice(j + 1);
+            this.inl = null;
+            this.sol = true;
+            return r;
+          }
+          if (this.inl.acc[j] === "*") {
+            if (j + 1 < this.inl.acc.length && this.inl.acc[j + 1] === "*") {
+              j++;
+              continue;
+            }
+            const content = this.inl.acc.slice(0, j);
+            this.buf = this.inl.acc.slice(j + 1);
+            this.inl = null;
+            if (StreamingMarkdownFilter.containsCJK(content))
+              return content;
+            return `*${content}*`;
+          }
+        }
+        return "";
+      }
+      case "uitalic": {
+        for (let j = 0;j < this.inl.acc.length; j++) {
+          if (this.inl.acc[j] === `
+`) {
+            const r = "_" + this.inl.acc.slice(0, j + 1);
+            this.buf = this.inl.acc.slice(j + 1);
+            this.inl = null;
+            this.sol = true;
+            return r;
+          }
+          if (this.inl.acc[j] === "_") {
+            if (j + 1 < this.inl.acc.length && this.inl.acc[j + 1] === "_") {
+              j++;
+              continue;
+            }
+            const content = this.inl.acc.slice(0, j);
+            this.buf = this.inl.acc.slice(j + 1);
+            this.inl = null;
+            if (StreamingMarkdownFilter.containsCJK(content))
+              return content;
+            return `_${content}_`;
+          }
+        }
+        return "";
+      }
+      case "image": {
+        const cb = this.inl.acc.indexOf("]");
+        if (cb === -1)
+          return "";
+        if (cb + 1 >= this.inl.acc.length)
+          return "";
+        if (this.inl.acc[cb + 1] !== "(") {
+          const r = "![" + this.inl.acc.slice(0, cb + 1);
+          this.buf = this.inl.acc.slice(cb + 1);
+          this.inl = null;
+          return r;
+        }
+        const cp = this.inl.acc.indexOf(")", cb + 2);
+        if (cp !== -1) {
+          this.buf = this.inl.acc.slice(cp + 1);
+          this.inl = null;
+          return "";
+        }
+        return "";
+      }
     }
+    return "";
   }
-  return "";
-}
-function extractWeixinMediaDescriptors(itemList) {
-  const out = [];
-  for (const item of itemList ?? []) {
-    const descriptor = descriptorFromItem(item);
-    if (descriptor)
-      out.push(descriptor);
-    const ref = item.type === MessageItemType.TEXT ? item.ref_msg?.message_item : undefined;
-    const refDescriptor = descriptorFromItem(ref);
-    if (refDescriptor)
-      out.push(refDescriptor);
+  static containsCJK(text) {
+    return /[\u2E80-\u9FFF\uAC00-\uD7AF\uF900-\uFAFF]/.test(text);
   }
-  return out;
 }
-function descriptorFromItem(item) {
-  if (!item)
-    return;
-  if (item.type === MessageItemType.IMAGE)
-    return { item, kind: "image" };
-  if (item.type === MessageItemType.VIDEO)
-    return { item, kind: "video" };
-  if (item.type === MessageItemType.FILE)
-    return { item, kind: "file", fileName: item.file_item?.file_name };
-  if (item.type === MessageItemType.VOICE)
-    return { item, kind: "audio" };
-  return;
-}
-var contextTokenStore;
-var init_inbound = __esm(() => {
-  init_logger();
-  init_random();
-  init_types2();
-  contextTokenStore = new Map;
-});
 
 // src/weixin/messaging/send.ts
 function generateClientId() {
   return generateId("openclaw-weixin");
 }
 function markdownToPlainText(text) {
-  let result = text;
-  result = result.replace(/```[^\n]*\n?([\s\S]*?)```/g, (_, code) => code.trim());
-  result = result.replace(/!\[[^\]]*\]\([^)]*\)/g, "");
-  result = result.replace(/\[([^\]]+)\]\([^)]*\)/g, "$1");
-  result = result.replace(/^\|[\s:|-]+\|$/gm, "");
-  result = result.replace(/^\|(.+)\|$/gm, (_, inner) => inner.split("|").map((cell) => cell.trim()).join("  "));
-  result = result.replace(/\*\*(.+?)\*\*/g, "$1").replace(/\*(.+?)\*/g, "$1").replace(/__(.+?)__/g, "$1").replace(/~~(.+?)~~/g, "$1").replace(/`(.+?)`/g, "$1");
-  return result;
+  const f = new StreamingMarkdownFilter;
+  return f.feed(text) + f.flush();
 }
 function buildTextMessageReq(params) {
   const { to, text, contextToken, clientId } = params;
@@ -12979,10 +13684,10 @@ var init_cdn_upload = __esm(() => {
 
 // src/weixin/cdn/upload.ts
 import crypto3 from "node:crypto";
-import fs6 from "node:fs/promises";
+import fs7 from "node:fs/promises";
 async function uploadMediaToCdn(params) {
   const { filePath, toUserId, opts, cdnBaseUrl, mediaType, label } = params;
-  const plaintext = await fs6.readFile(filePath);
+  const plaintext = await fs7.readFile(filePath);
   const rawsize = plaintext.length;
   const rawfilemd5 = crypto3.createHash("md5").update(plaintext).digest("hex");
   const filesize = aesEcbPaddedSize(rawsize);
@@ -13055,7 +13760,7 @@ var init_upload = __esm(() => {
 });
 
 // src/weixin/messaging/send-media.ts
-import path9 from "node:path";
+import path10 from "node:path";
 async function sendWeixinMediaFile(params) {
   const { media, filePath, to, text, opts, cdnBaseUrl } = params;
   const mime = media?.mimeType ?? getMimeFromFilename(filePath);
@@ -13082,7 +13787,7 @@ async function sendWeixinMediaFile(params) {
     logger.info(`[weixin] sendWeixinMediaFile: image upload done filekey=${uploaded2.filekey} size=${uploaded2.fileSize}`);
     return sendImageMessageWeixin({ to, text, uploaded: uploaded2, opts });
   }
-  const fileName = media?.fileName ?? path9.basename(filePath);
+  const fileName = media?.fileName ?? path10.basename(filePath);
   logger.info(`[weixin] sendWeixinMediaFile: uploading file attachment filePath=${filePath} name=${fileName} to=${to}`);
   const uploaded = await uploadFileAttachmentToWeixin({
     filePath,
@@ -13102,14 +13807,14 @@ var init_send_media = __esm(() => {
 });
 
 // src/weixin/messaging/debug-mode.ts
-import fs7 from "node:fs";
-import path10 from "node:path";
+import fs8 from "node:fs";
+import path11 from "node:path";
 function resolveDebugModePath() {
-  return path10.join(resolveStateDir(), "openclaw-weixin", "debug-mode.json");
+  return path11.join(resolveStateDir(), "openclaw-weixin", "debug-mode.json");
 }
 function loadState() {
   try {
-    const raw = fs7.readFileSync(resolveDebugModePath(), "utf-8");
+    const raw = fs8.readFileSync(resolveDebugModePath(), "utf-8");
     const parsed = JSON.parse(raw);
     if (parsed && typeof parsed.accounts === "object")
       return parsed;
@@ -13118,8 +13823,8 @@ function loadState() {
 }
 function saveState(state) {
   const filePath = resolveDebugModePath();
-  ensureDirSync(path10.dirname(filePath));
-  fs7.writeFileSync(filePath, JSON.stringify(state, null, 2), "utf-8");
+  ensureDirSync(path11.dirname(filePath));
+  fs8.writeFileSync(filePath, JSON.stringify(state, null, 2), "utf-8");
 }
 function toggleDebugMode(accountId) {
   const state = loadState();
@@ -13576,9 +14281,9 @@ var init_perf_tracer = __esm(() => {
 
 // src/weixin/messaging/handle-weixin-message-turn.ts
 import crypto4 from "node:crypto";
-import fs8 from "node:fs/promises";
+import fs9 from "node:fs/promises";
 import { tmpdir } from "node:os";
-import path11 from "node:path";
+import path12 from "node:path";
 function utf8ByteLength(s) {
   return Buffer.byteLength(s, "utf8");
 }
@@ -13668,24 +14373,24 @@ function hardCutByCodepoint(s, maxBytes) {
   return out;
 }
 function resolveMediaTempDir(customRoot) {
-  return customRoot ?? path11.join(tmpdir(), "weacpx", "media");
+  return customRoot ?? path12.join(tmpdir(), "weacpx", "media");
 }
 function createSaveMediaBuffer(mediaTempDir) {
   return async function saveMediaBuffer(buffer, contentType, subdir, maxBytes, originalFilename) {
     if (maxBytes !== undefined && buffer.byteLength > maxBytes) {
       throw new Error(`media exceeds ${maxBytes} bytes`);
     }
-    const dir = path11.join(resolveMediaTempDir(mediaTempDir), subdir ?? "");
-    await fs8.mkdir(dir, { recursive: true });
+    const dir = path12.join(resolveMediaTempDir(mediaTempDir), subdir ?? "");
+    await fs9.mkdir(dir, { recursive: true });
     let ext = ".bin";
     if (originalFilename) {
-      ext = path11.extname(originalFilename) || ".bin";
+      ext = path12.extname(originalFilename) || ".bin";
     } else if (contentType) {
       ext = getExtensionFromMime(contentType);
     }
     const name = `${Date.now()}-${crypto4.randomBytes(4).toString("hex")}${ext}`;
-    const filePath = path11.join(dir, name);
-    await fs8.writeFile(filePath, buffer);
+    const filePath = path12.join(dir, name);
+    await fs9.writeFile(filePath, buffer);
     return { path: filePath };
   };
 }
@@ -13837,7 +14542,7 @@ async function handleWeixinMessageTurn(full, deps) {
           continue;
         }
         try {
-          const buffer = await fs8.readFile(filePath);
+          const buffer = await fs9.readFile(filePath);
           const mimeType = downloaded.fileMediaType ?? downloaded.voiceMediaType ?? defaultWeixinMime(descriptor.kind);
           media.push(await mediaStore.saveMediaBuffer({
             channelId: "weixin",
@@ -13851,7 +14556,7 @@ async function handleWeixinMessageTurn(full, deps) {
             maxBytes: descriptor.kind === "image" ? DEFAULT_IMAGE_MAX_BYTES : DEFAULT_ATTACHMENT_MAX_BYTES
           }));
         } finally {
-          await fs8.rm(filePath, { force: true }).catch(() => {});
+          await fs9.rm(filePath, { force: true }).catch(() => {});
         }
       } catch (err) {
         deps.errLog(`media download failed: ${String(err)}`);
@@ -14085,20 +14790,20 @@ var init_handle_weixin_message_turn = __esm(() => {
 });
 
 // src/weixin/storage/sync-buf.ts
-import fs9 from "node:fs";
-import path12 from "node:path";
+import fs10 from "node:fs";
+import path13 from "node:path";
 function resolveAccountsDir2() {
-  return path12.join(resolveStateDir(), "openclaw-weixin", "accounts");
+  return path13.join(resolveStateDir(), "openclaw-weixin", "accounts");
 }
 function getSyncBufFilePath(accountId) {
-  return path12.join(resolveAccountsDir2(), `${accountId}.sync.json`);
+  return path13.join(resolveAccountsDir2(), `${accountId}.sync.json`);
 }
 function getLegacySyncBufDefaultJsonPath() {
-  return path12.join(resolveStateDir(), "agents", "default", "sessions", ".openclaw-weixin-sync", "default.json");
+  return path13.join(resolveStateDir(), "agents", "default", "sessions", ".openclaw-weixin-sync", "default.json");
 }
 function readSyncBufFile(filePath) {
   try {
-    const raw = fs9.readFileSync(filePath, "utf-8");
+    const raw = fs10.readFileSync(filePath, "utf-8");
     const data = JSON.parse(raw);
     if (typeof data.get_updates_buf === "string") {
       return data.get_updates_buf;
@@ -14110,10 +14815,10 @@ function loadGetUpdatesBuf(filePath) {
   const value = readSyncBufFile(filePath);
   if (value !== undefined)
     return value;
-  const accountId = path12.basename(filePath, ".sync.json");
+  const accountId = path13.basename(filePath, ".sync.json");
   const rawId = deriveRawAccountId(accountId);
   if (rawId) {
-    const compatPath = path12.join(resolveAccountsDir2(), `${rawId}.sync.json`);
+    const compatPath = path13.join(resolveAccountsDir2(), `${rawId}.sync.json`);
     const compatValue = readSyncBufFile(compatPath);
     if (compatValue !== undefined)
       return compatValue;
@@ -14121,13 +14826,11 @@ function loadGetUpdatesBuf(filePath) {
   return readSyncBufFile(getLegacySyncBufDefaultJsonPath());
 }
 function saveGetUpdatesBuf(filePath, getUpdatesBuf) {
-  const dir = path12.dirname(filePath);
-  ensureDirSync(dir);
-  fs9.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();
 });
 
@@ -14157,23 +14860,23 @@ function shouldFetchTypingConfig(textBody) {
 }
 async function monitorWeixinProvider(opts) {
   const {
-    baseUrl,
-    cdnBaseUrl,
-    token,
-    accountId,
     agent,
     abortSignal,
     longPollTimeoutMs
   } = opts;
+  let baseUrl = opts.baseUrl;
+  let cdnBaseUrl = opts.cdnBaseUrl;
+  let token = opts.token;
+  let accountId = opts.accountId;
   const log = opts.log ?? ((msg) => console.log(msg));
   const errLog = (msg) => {
     log(msg);
     logger.error(msg);
   };
-  const aLog = logger.withAccount(accountId);
+  let aLog = logger.withAccount(accountId);
   log(`[weixin] monitor started (${baseUrl}, account=${accountId})`);
   aLog.info(`Monitor started: baseUrl=${baseUrl}`);
-  const syncFilePath = getSyncBufFilePath(accountId);
+  let syncFilePath = getSyncBufFilePath(accountId);
   const previousGetUpdatesBuf = loadGetUpdatesBuf(syncFilePath);
   let getUpdatesBuf = previousGetUpdatesBuf ?? "";
   if (previousGetUpdatesBuf) {
@@ -14181,7 +14884,7 @@ async function monitorWeixinProvider(opts) {
   } else {
     log(`[weixin] no previous sync buf, starting fresh`);
   }
-  const configManager = new WeixinConfigManager({ baseUrl, token }, log);
+  let configManager = new WeixinConfigManager({ baseUrl, token }, log);
   const conversationExecutor = createConversationExecutor();
   const seenMessageIds = new Set;
   const messageIdOrder = [];
@@ -14204,11 +14907,37 @@ async function monitorWeixinProvider(opts) {
       if (isApiError) {
         const isSessionExpired = resp.errcode === SESSION_EXPIRED_ERRCODE || resp.ret === SESSION_EXPIRED_ERRCODE;
         if (isSessionExpired) {
+          const staleToken = token;
+          const staleAccountId = accountId;
+          errLog(`[weixin] session expired (errcode ${SESSION_EXPIRED_ERRCODE}), entering credential recovery. Please run \`weacpx login\` to re-login.`);
           pauseSession(accountId);
-          const pauseMs = getRemainingPauseMs(accountId);
-          errLog(`[weixin] session expired (errcode ${SESSION_EXPIRED_ERRCODE}), pausing for ${Math.ceil(pauseMs / 60000)} min. Please run \`npx weixin-acp login\` to re-login.`);
           consecutiveFailures = 0;
-          await sleep(pauseMs, abortSignal);
+          const recovered = await pollForFreshCredentials(staleAccountId, staleToken, log, abortSignal);
+          if (recovered === null) {
+            aLog.info("Monitor stopped (aborted during credential recovery)");
+            return;
+          }
+          const oldAccountId = accountId;
+          accountId = recovered.accountId;
+          baseUrl = recovered.baseUrl;
+          cdnBaseUrl = recovered.cdnBaseUrl;
+          token = recovered.token;
+          aLog = logger.withAccount(accountId);
+          syncFilePath = getSyncBufFilePath(accountId);
+          const previousBuf = loadGetUpdatesBuf(syncFilePath);
+          getUpdatesBuf = previousBuf ?? "";
+          configManager = new WeixinConfigManager({ baseUrl, token }, log);
+          seenMessageIds.clear();
+          messageIdOrder.length = 0;
+          consecutiveFailures = 0;
+          nextTimeoutMs = longPollTimeoutMs ?? DEFAULT_LONG_POLL_TIMEOUT_MS2;
+          resetSessionPause(oldAccountId);
+          resetSessionPause(accountId);
+          if (oldAccountId !== accountId) {
+            clearContextTokensForAccount(oldAccountId);
+            restoreContextTokens(accountId);
+          }
+          log(`[weixin] credential recovered, resuming monitor with account=${accountId}`);
           continue;
         }
         consecutiveFailures += 1;
@@ -14302,7 +15031,43 @@ function sleep(ms, signal) {
     }, { once: true });
   });
 }
-var DEFAULT_LONG_POLL_TIMEOUT_MS2 = 35000, MAX_CONSECUTIVE_FAILURES = 3, BACKOFF_DELAY_MS = 30000, RETRY_DELAY_MS = 2000;
+async function pollForFreshCredentials(staleAccountId, staleToken, log, abortSignal) {
+  let attempt = 0;
+  while (!abortSignal?.aborted) {
+    attempt += 1;
+    const currentAccount = resolveWeixinAccount(staleAccountId);
+    if (currentAccount.token && currentAccount.token !== staleToken) {
+      log(`[weixin] credential recovery: fresh token detected for account=${staleAccountId}`);
+      return {
+        accountId: currentAccount.accountId,
+        baseUrl: currentAccount.baseUrl,
+        cdnBaseUrl: currentAccount.cdnBaseUrl,
+        token: currentAccount.token
+      };
+    }
+    const ids = listWeixinAccountIds();
+    for (const id of ids) {
+      if (id === staleAccountId)
+        continue;
+      const account = resolveWeixinAccount(id);
+      if (account.configured && account.token) {
+        log(`[weixin] credential recovery: new account detected, switching to account=${id}`);
+        return {
+          accountId: account.accountId,
+          baseUrl: account.baseUrl,
+          cdnBaseUrl: account.cdnBaseUrl,
+          token: account.token
+        };
+      }
+    }
+    if (attempt % 10 === 0) {
+      log(`[weixin] credential recovery: still waiting for fresh credentials (checked ${attempt} times)`);
+    }
+    await sleep(CREDENTIAL_RECOVERY_POLL_INTERVAL_MS, abortSignal);
+  }
+  return null;
+}
+var DEFAULT_LONG_POLL_TIMEOUT_MS2 = 35000, MAX_CONSECUTIVE_FAILURES = 3, BACKOFF_DELAY_MS = 30000, RETRY_DELAY_MS = 2000, CREDENTIAL_RECOVERY_POLL_INTERVAL_MS = 30000;
 var init_monitor = __esm(() => {
   init_api();
   init_config_cache();
@@ -14311,6 +15076,9 @@ var init_monitor = __esm(() => {
   init_types2();
   init_sync_buf();
   init_logger();
+  init_accounts();
+  init_session_guard();
+  init_inbound();
 });
 
 // src/weixin/bot.ts
@@ -14369,6 +15137,8 @@ function logout(opts) {
     log("当前没有已登录的账号");
     return;
   }
+  for (const id of ids)
+    clearContextTokensForAccount(id);
   clearAllWeixinAccounts();
   log("✅ 已退出登录");
 }
@@ -14396,6 +15166,7 @@ async function start(agent, opts) {
   if (!account.configured) {
     throw new Error(`账号 ${accountId} 未配置 (缺少 token)，请先运行 login`);
   }
+  restoreContextTokens(account.accountId);
   log(`[weixin] 启动 bot, account=${account.accountId}`);
   await monitorWeixinProvider({
     baseUrl: account.baseUrl,
@@ -14421,6 +15192,7 @@ async function start(agent, opts) {
 var init_bot = __esm(() => {
   init_accounts();
   init_login_qr();
+  init_inbound();
   init_monitor();
 });
 
@@ -14671,7 +15443,7 @@ var init_deliver_coordinator_message = __esm(() => {
 });
 
 // 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 = {}) {
@@ -14683,7 +15455,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");
@@ -14751,9 +15523,9 @@ function createWeixinConsumerLock(options = {}) {
     }
   };
 }
-async function loadLockMetadata(path13) {
+async function loadLockMetadata(path14) {
   try {
-    const raw = await readFile6(path13, "utf8");
+    const raw = await readFile6(path14, "utf8");
     const parsed = JSON.parse(raw);
     if (!parsed || typeof parsed.pid !== "number" || !parsed.mode || !parsed.configPath || !parsed.statePath) {
       return null;
@@ -15368,21 +16140,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;
 }
@@ -15403,7 +16181,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 {
@@ -15417,6 +16195,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);
@@ -15445,8 +16224,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) {
@@ -15823,6 +16606,7 @@ function parseCommand(input) {
   if (command === "/workspace" && parts[1] === "new" && parts[2]) {
     const name = parts[2];
     let cwd = "";
+    let raw = false;
     let invalid = false;
     for (let index = 3;index < parts.length; index += 1) {
       if (parts[index] === "--cwd" || parts[index] === "-d") {
@@ -15834,11 +16618,19 @@ function parseCommand(input) {
         index += 1;
         continue;
       }
+      if (parts[index] === "--raw") {
+        if (raw) {
+          invalid = true;
+          break;
+        }
+        raw = true;
+        continue;
+      }
       invalid = true;
       break;
     }
     if (!invalid && name.trim().length > 0 && cwd.trim().length > 0) {
-      return { kind: "workspace.new", name, cwd };
+      return { kind: "workspace.new", name, cwd, ...raw ? { raw: true } : {} };
     }
   }
   if (command === "/workspace" && parts[1] === "rm" && parts[2]) {
@@ -16298,26 +17090,26 @@ var init_permission_handler = __esm(() => {
 
 // src/commands/handlers/config-handler.ts
 function handleConfigShow(context) {
-  const lines = ["支持修改的配置字段：", ...SUPPORTED_CONFIG_PATHS.map((path13) => `- ${path13}`)];
-  lines.push("", "兼容旧配置：", ...LEGACY_CONFIG_PATHS.map((path13) => `- ${path13}`));
+  const lines = ["支持修改的配置字段：", ...SUPPORTED_CONFIG_PATHS.map((path14) => `- ${path14}`)];
+  lines.push("", "兼容旧配置：", ...LEGACY_CONFIG_PATHS.map((path14) => `- ${path14}`));
   if (context.config) {
     lines.push("", "示例：", "- /config set channel.replyMode final", "- /config set logging.level debug");
   }
   return { text: lines.join(`
 `) };
 }
-async function handleConfigSet(context, path13, rawValue) {
+async function handleConfigSet(context, path14, rawValue) {
   if (!context.config || !context.configStore) {
     return { text: "当前没有加载可写入的配置。" };
   }
   const previous = cloneAppConfig(context.config);
   const updated = cloneAppConfig(context.config);
-  const result = applySupportedConfigUpdate(updated, path13, rawValue);
+  const result = applySupportedConfigUpdate(updated, path14, rawValue);
   if ("error" in result) {
     return { text: result.error };
   }
   await context.configStore.save(updated);
-  if (path13 === "transport.permissionMode" || path13 === "transport.nonInteractivePermissions" || path13 === "transport.permissionPolicy") {
+  if (path14 === "transport.permissionMode" || path14 === "transport.nonInteractivePermissions" || path14 === "transport.permissionPolicy") {
     try {
       await context.transport.updatePermissionPolicy?.(updated.transport);
     } catch (error2) {
@@ -16327,10 +17119,10 @@ async function handleConfigSet(context, path13, rawValue) {
     }
   }
   context.replaceConfig(updated);
-  return { text: `配置已更新：${path13} = ${result.renderedValue}` };
+  return { text: `配置已更新：${path14} = ${result.renderedValue}` };
 }
-function applySupportedConfigUpdate(config2, path13, rawValue) {
-  switch (path13) {
+function applySupportedConfigUpdate(config2, path14, rawValue) {
+  switch (path14) {
     case "transport.type": {
       const parsed = parseEnum(rawValue, ["acpx-cli", "acpx-bridge"]);
       if (!parsed)
@@ -16418,18 +17210,18 @@ function applySupportedConfigUpdate(config2, path13, rawValue) {
       };
     }
   }
-  const agentMatch = path13.match(/^agents\.([^.]+)\.(driver|command)$/);
+  const agentMatch = path14.match(/^agents\.([^.]+)\.(driver|command)$/);
   if (agentMatch) {
     const [, name, field] = agentMatch;
     if (!name || !field) {
-      return { error: `不支持修改这个配置路径：${path13}` };
+      return { error: `不支持修改这个配置路径：${path14}` };
     }
     const agent = config2.agents[name];
     if (!agent) {
       return { error: `Agent「${name}」不存在，请先创建。` };
     }
     if (!rawValue.trim()) {
-      return { error: `${path13} 不能为空。` };
+      return { error: `${path14} 不能为空。` };
     }
     if (field === "driver") {
       agent.driver = rawValue;
@@ -16438,18 +17230,18 @@ function applySupportedConfigUpdate(config2, path13, rawValue) {
     }
     return { renderedValue: rawValue };
   }
-  const workspaceMatch = path13.match(/^workspaces\.([^.]+)\.(cwd|description)$/);
+  const workspaceMatch = path14.match(/^workspaces\.([^.]+)\.(cwd|description)$/);
   if (workspaceMatch) {
     const [, name, field] = workspaceMatch;
     if (!name || !field) {
-      return { error: `不支持修改这个配置路径：${path13}` };
+      return { error: `不支持修改这个配置路径：${path14}` };
     }
     const workspace = config2.workspaces[name];
     if (!workspace) {
       return { error: `工作区「${name}」不存在，请先创建。` };
     }
     if (!rawValue.trim()) {
-      return { error: `${path13} 不能为空。` };
+      return { error: `${path14} 不能为空。` };
     }
     if (field === "cwd") {
       workspace.cwd = rawValue;
@@ -16458,15 +17250,15 @@ function applySupportedConfigUpdate(config2, path13, rawValue) {
     }
     return { renderedValue: rawValue };
   }
-  return { error: `不支持修改这个配置路径：${path13}` };
+  return { error: `不支持修改这个配置路径：${path14}` };
 }
 function parseEnum(value, allowed) {
   return allowed.includes(value) ? value : null;
 }
-function parsePositiveNumber(rawValue, path13) {
+function parsePositiveNumber(rawValue, path14) {
   const value = Number(rawValue);
   if (!Number.isFinite(value) || value <= 0) {
-    return { error: `${path13} 必须是正数。` };
+    return { error: `${path14} 必须是正数。` };
   }
   return { value };
 }
@@ -16901,7 +17693,7 @@ async function handleSessionAttach(context, chatKey, alias, agent, workspace, tr
       return {
         text: [
           "没有找到可绑定的已有会话。",
-          `请确认会话名是否正确，然后重新执行：/session attach ${alias} --agent ${agent} --ws ${workspace} --name <会话名>`
+          `请确认会话名是否正确，然后重新执行：/session attach ${alias} --agent ${agent} --ws ${quoteWorkspaceNameIfNeeded(workspace)} --name <会话名>`
         ].join(`
 `)
       };
@@ -17238,6 +18030,7 @@ var NO_CURRENT_SESSION_TEXT = "当前还没有选中的会话。请先执行 /se
 var init_session_handler = __esm(() => {
   init_build_coordinator_prompt();
   init_channel_scope();
+  init_workspace_name();
   sessionHelp = {
     topic: "session",
     aliases: ["ss", "sessions"],
@@ -17885,7 +18678,7 @@ var init_agent_handler = __esm(() => {
 function handleWorkspaces(context) {
   return { text: context.config ? renderWorkspaces(context.config) : "No config loaded." };
 }
-async function handleWorkspaceCreate(context, workspaceName, cwd) {
+async function handleWorkspaceCreate(context, workspaceName, cwd, options = {}) {
   if (!context.config || !context.configStore) {
     return { text: "当前没有加载可写入的配置。" };
   }
@@ -17893,9 +18686,18 @@ async function handleWorkspaceCreate(context, workspaceName, cwd) {
   if (!await pathExists(normalizedCwd)) {
     return { text: `工作区路径不存在：${cwd}` };
   }
-  const updated = await context.configStore.upsertWorkspace(workspaceName, normalizedCwd);
+  let name = workspaceName;
+  let notice;
+  if (!options.raw && !isWorkspaceNameValid(workspaceName)) {
+    const base = sanitizeWorkspaceName(workspaceName);
+    name = allocateWorkspaceName(base, context.config.workspaces);
+    notice = `名称 ${JSON.stringify(workspaceName)} 含有特殊字符，已保存为「${name}」。如需保留原名请加 --raw。`;
+  }
+  const updated = await context.configStore.upsertWorkspace(name, normalizedCwd);
   context.replaceConfig(updated);
-  return { text: `工作区「${workspaceName}」已保存` };
+  const savedLine = `工作区「${name}」已保存`;
+  return { text: notice ? `${notice}
+${savedLine}` : savedLine };
 }
 async function handleWorkspaceRemove(context, workspaceName) {
   if (!context.config || !context.configStore) {
@@ -17907,6 +18709,7 @@ async function handleWorkspaceRemove(context, workspaceName) {
 }
 var workspaceHelp;
 var init_workspace_handler = __esm(() => {
+  init_workspace_name();
   init_workspace_path();
   workspaceHelp = {
     topic: "workspace",
@@ -17915,7 +18718,7 @@ var init_workspace_handler = __esm(() => {
     commands: [
       { usage: "/workspaces", description: "查看当前已注册的工作区" },
       { usage: "/workspace 或 /ws", description: "查看工作区列表" },
-      { usage: "/ws new <name> -d <path>", description: "添加工作区" },
+      { usage: "/ws new <name> -d <path> [--raw]", description: "添加工作区；含特殊字符的名称会被自动规范化，--raw 保留原名" },
       { usage: "/workspace rm <name>", description: "删除工作区" }
     ],
     examples: ['/ws new backend -d "/tmp/backend"', "/workspace rm backend"]
@@ -18152,7 +18955,7 @@ async function resolveShortcutWorkspace(context, target) {
       reused: true
     };
   }
-  const workspaceName = allocateWorkspaceName(context, basenameForWorkspacePath(cwd));
+  const workspaceName = allocateWorkspaceName(sanitizeWorkspaceName(basenameForWorkspacePath(cwd)), context.config?.workspaces ?? {});
   const updated = await context.configStore.upsertWorkspace(workspaceName, cwd);
   context.replaceConfig(updated);
   return {
@@ -18161,16 +18964,6 @@ async function resolveShortcutWorkspace(context, target) {
     reused: false
   };
 }
-function allocateWorkspaceName(context, baseName) {
-  if (!context.config?.workspaces[baseName]) {
-    return baseName;
-  }
-  let suffix = 2;
-  while (context.config.workspaces[`${baseName}-${suffix}`]) {
-    suffix += 1;
-  }
-  return `${baseName}-${suffix}`;
-}
 async function allocateUniqueSessionAlias(context, baseAlias, chatKey) {
   if (!await hasLogicalSession(context, baseAlias, chatKey)) {
     return baseAlias;
@@ -18196,6 +18989,7 @@ function renderShortcutSessionCreationError(workspace, alias) {
   };
 }
 var init_session_shortcut_handler = __esm(() => {
+  init_workspace_name();
   init_workspace_path();
   init_errors();
   init_channel_scope();
@@ -18208,8 +19002,8 @@ function renderTransportError(session, error2) {
     return {
       text: [
         `当前会话「${session.alias}」暂时不可用。`,
-        `请先在微信里重新执行：/session new ${session.alias} --agent ${session.agent} --ws ${session.workspace}`,
-        `如果你要绑定一个已有会话，再执行：/session attach ${session.alias} --agent ${session.agent} --ws ${session.workspace} --name <会话名>`
+        `请先在微信里重新执行：/session new ${session.alias} --agent ${session.agent} --ws ${quoteWorkspaceNameIfNeeded(session.workspace)}`,
+        `如果你要绑定一个已有会话，再执行：/session attach ${session.alias} --agent ${session.agent} --ws ${quoteWorkspaceNameIfNeeded(session.workspace)} --name <会话名>`
       ].join(`
 `)
     };
@@ -18271,7 +19065,7 @@ function renderSessionCreationFailure(session, detail) {
     text: [
       "会话创建失败。",
       `错误信息：${summarizeTransportError(detail)}`,
-      `如果你要先绑定一个已有会话，可以执行：/session attach ${session.alias} --agent ${session.agent} --ws ${session.workspace} --name <会话名>`
+      `如果你要先绑定一个已有会话，可以执行：/session attach ${session.alias} --agent ${session.agent} --ws ${quoteWorkspaceNameIfNeeded(session.workspace)} --name <会话名>`
     ].join(`
 `)
   };
@@ -18290,6 +19084,7 @@ async function tryRecoverMissingSession(ops, session, error2) {
 }
 var init_session_recovery_handler = __esm(() => {
   init_errors();
+  init_workspace_name();
 });
 
 // src/recovery/auto-install-optional-dep.ts
@@ -18415,10 +19210,10 @@ ${err.message}`, reason: "spawn" });
   const dir = join10(homedir6(), ".weacpx", "logs");
   await mkdir10(dir, { recursive: true });
   const timestamp = new Date().toISOString().replace(/[:.]/g, "").replace(/-/g, "");
-  const path13 = join10(dir, `auto-install-${timestamp}.log`);
-  const stream = createWriteStream(path13, { flags: "a" });
+  const path14 = join10(dir, `auto-install-${timestamp}.log`);
+  const stream = createWriteStream(path14, { flags: "a" });
   return {
-    path: path13,
+    path: path14,
     append: async (chunk) => {
       await new Promise((resolve3, reject) => stream.write(chunk, (err) => err ? reject(err) : resolve3()));
     },
@@ -18501,9 +19296,9 @@ function isUnder(child, parent) {
   const p = parent.replace(/[\\/]+$/, "");
   return c === p || c.startsWith(p + "/") || c.startsWith(p + "\\");
 }
-async function defaultFsExists(path13) {
+async function defaultFsExists(path14) {
   try {
-    await access3(path13);
+    await access3(path14);
     return true;
   } catch {
     return false;
@@ -18731,7 +19526,7 @@ class CommandRouter {
         case "workspaces":
           return handleWorkspaces(this.createHandlerContext());
         case "workspace.new":
-          return await handleWorkspaceCreate(this.createHandlerContext(), command.name, command.cwd);
+          return await handleWorkspaceCreate(this.createHandlerContext(), command.name, command.cwd, command.raw ? { raw: true } : {});
         case "workspace.rm":
           return await handleWorkspaceRemove(this.createHandlerContext(), command.name);
         case "sessions":
@@ -19193,7 +19988,7 @@ function resolveAcpxCommandMetadata(options = {}) {
   }
   const platform = options.platform ?? process.platform;
   const resolvePackageJson = options.resolvePackageJson ?? ((id) => require3.resolve(id));
-  const readPackageJson = options.readPackageJson ?? ((path13) => JSON.parse(readFileSync(path13, "utf8")));
+  const readPackageJson = options.readPackageJson ?? ((path14) => JSON.parse(readFileSync(path14, "utf8")));
   try {
     const packageJsonPath = resolvePackageJson("acpx/package.json");
     const pkg = readPackageJson(packageJsonPath);
@@ -19570,8 +20365,8 @@ class OrchestrationServer {
     if (this.endpoint.kind !== "unix") {
       return;
     }
-    const removeFile = this.deps.removeFile ?? (async (path13) => {
-      await rm7(path13, { force: true });
+    const removeFile = this.deps.removeFile ?? (async (path14) => {
+      await rm7(path14, { force: true });
     });
     await removeFile(this.endpoint.path);
   }
@@ -19732,9 +20527,9 @@ function requireTaskQuestions(params, key) {
     };
   });
 }
-async function canConnectToEndpoint(path13) {
+async function canConnectToEndpoint(path14) {
   return await new Promise((resolve3) => {
-    const socket = createConnection2(path13);
+    const socket = createConnection2(path14);
     let settled = false;
     const finish = (result) => {
       if (settled) {
@@ -19755,7 +20550,7 @@ async function canConnectToEndpoint(path13) {
     });
   });
 }
-async function listen(server, path13) {
+async function listen(server, path14) {
   await new Promise((resolve3, reject) => {
     const onError = (error2) => {
       server.off("listening", onListening);
@@ -19767,7 +20562,7 @@ async function listen(server, path13) {
     };
     server.once("error", onError);
     server.once("listening", onListening);
-    server.listen(path13);
+    server.listen(path14);
   });
 }
 function isServerNotRunningError(error2) {
@@ -19891,6 +20686,7 @@ class OrchestrationService {
   stateMutex;
   pendingWorkerSessions = new Map;
   pendingLogicalTransportSessions = new Map;
+  pendingParallelStarts = new Map;
   constructor(deps) {
     this.deps = deps;
     this.stateMutex = deps.stateMutex ?? new AsyncMutex;
@@ -20055,84 +20851,139 @@ class OrchestrationService {
     const normalizedGroupId = this.normalizeGroupId(input.groupId);
     const taskId = this.deps.createId();
     const workerSession = await this.resolveWorkerSession(input);
-    const releaseWorkerReservation = await this.reserveProposedWorkerSession(workerSession);
-    let ensuredWorkerSession = workerSession;
-    let prepared;
-    try {
-      ensuredWorkerSession = await this.ensureReservedWorkerSession({
-        workerSession,
-        sourceHandle: input.sourceHandle,
-        sourceKind: input.sourceKind,
-        coordinatorSession: input.coordinatorSession,
-        workspace: input.workspace,
-        ...input.cwd ? { cwd: input.cwd } : {},
-        targetAgent: input.targetAgent,
-        role
-      });
-      prepared = await this.mutate(async () => {
+    if (input.parallel) {
+      const queuedResult = await this.mutate(async () => {
         const state = await this.deps.loadState();
-        const now = this.deps.now().toISOString();
-        if (normalizedGroupId) {
-          this.assertGroupOwnership(this.ensureGroups(state)[normalizedGroupId], normalizedGroupId, input.coordinatorSession);
+        if (this.canStartParallelTask(state, input.targetAgent)) {
+          this.pendingParallelStarts.set(input.targetAgent, (this.pendingParallelStarts.get(input.targetAgent) ?? 0) + 1);
+          return null;
         }
-        const task = {
+        const now = this.deps.now().toISOString();
+        const queuedTask = {
           taskId,
           sourceHandle: input.sourceHandle,
           sourceKind: input.sourceKind,
           coordinatorSession: input.coordinatorSession,
-          workerSession: ensuredWorkerSession,
+          workerSession,
           workspace: input.workspace,
           ...input.cwd ? { cwd: input.cwd } : {},
           targetAgent: input.targetAgent,
           ...role ? { role } : {},
           ...normalizedGroupId ? { groupId: normalizedGroupId } : {},
           task: input.task,
-          status: "running",
+          status: "queued",
+          ephemeralWorkerSession: true,
           summary: "",
           resultText: "",
           createdAt: now,
           updatedAt: now,
           eventSeq: 1,
-          events: [{ seq: 1, at: now, type: "created", status: "running", message: "Task created" }],
+          events: [{ seq: 1, at: now, type: "created", status: "queued", message: "Task queued at parallel capacity" }],
           ...input.chatKey ? { chatKey: input.chatKey } : {},
           ...input.replyContextToken ? { replyContextToken: input.replyContextToken } : {},
           ...input.accountId ? { accountId: input.accountId } : {}
         };
-        let previousGroup;
-        if (normalizedGroupId) {
-          const group = this.ensureGroups(state)[normalizedGroupId];
-          previousGroup = { ...group };
-          group.updatedAt = now;
-          group.coordinatorInjectedAt = undefined;
-          group.injectionPending = undefined;
-          group.injectionAppliedAt = undefined;
-          group.lastInjectionError = undefined;
-        }
-        const previousBinding = state.orchestration.workerBindings[ensuredWorkerSession];
-        this.assertWorkerSessionDoesNotConflictExternalCoordinator(state, ensuredWorkerSession);
-        this.assertWorkerSessionAvailable(state, ensuredWorkerSession, undefined, { allowCurrentReservation: true });
-        state.orchestration.tasks[taskId] = task;
-        state.orchestration.workerBindings[ensuredWorkerSession] = {
-          sourceHandle: ensuredWorkerSession,
+        state.orchestration.tasks[taskId] = queuedTask;
+        await this.deps.saveState(state);
+        return { taskId, status: "queued", workerSession };
+      });
+      if (queuedResult) {
+        this.logEvent("orchestration.task.queued", "parallel task queued at capacity", { taskId, targetAgent: input.targetAgent });
+        return queuedResult;
+      }
+    }
+    const releasePendingParallelStart = input.parallel ? () => {
+      const count = this.pendingParallelStarts.get(input.targetAgent) ?? 0;
+      if (count <= 1) {
+        this.pendingParallelStarts.delete(input.targetAgent);
+      } else {
+        this.pendingParallelStarts.set(input.targetAgent, count - 1);
+      }
+    } : undefined;
+    let ensuredWorkerSession = workerSession;
+    let prepared;
+    const releaseWorkerReservation = await this.reserveProposedWorkerSession(workerSession);
+    try {
+      try {
+        ensuredWorkerSession = await this.ensureReservedWorkerSession({
+          workerSession,
+          sourceHandle: input.sourceHandle,
+          sourceKind: input.sourceKind,
           coordinatorSession: input.coordinatorSession,
           workspace: input.workspace,
           ...input.cwd ? { cwd: input.cwd } : {},
           targetAgent: input.targetAgent,
           role
-        };
-        await this.deps.saveState(state);
-        return {
-          task: { ...task },
-          previousBinding,
-          previousGroup,
-          normalizedGroupId
-        };
-      });
-    } catch (error2) {
+        });
+        prepared = await this.mutate(async () => {
+          const state = await this.deps.loadState();
+          const now = this.deps.now().toISOString();
+          if (normalizedGroupId) {
+            this.assertGroupOwnership(this.ensureGroups(state)[normalizedGroupId], normalizedGroupId, input.coordinatorSession);
+          }
+          const task = {
+            taskId,
+            sourceHandle: input.sourceHandle,
+            sourceKind: input.sourceKind,
+            coordinatorSession: input.coordinatorSession,
+            workerSession: ensuredWorkerSession,
+            workspace: input.workspace,
+            ...input.cwd ? { cwd: input.cwd } : {},
+            targetAgent: input.targetAgent,
+            ...role ? { role } : {},
+            ...normalizedGroupId ? { groupId: normalizedGroupId } : {},
+            task: input.task,
+            status: "running",
+            summary: "",
+            resultText: "",
+            createdAt: now,
+            updatedAt: now,
+            eventSeq: 1,
+            events: [{ seq: 1, at: now, type: "created", status: "running", message: "Task created" }],
+            ...input.chatKey ? { chatKey: input.chatKey } : {},
+            ...input.replyContextToken ? { replyContextToken: input.replyContextToken } : {},
+            ...input.accountId ? { accountId: input.accountId } : {},
+            ...input.parallel ? { ephemeralWorkerSession: true } : {}
+          };
+          let previousGroup;
+          if (normalizedGroupId) {
+            const group = this.ensureGroups(state)[normalizedGroupId];
+            previousGroup = { ...group };
+            group.updatedAt = now;
+            group.coordinatorInjectedAt = undefined;
+            group.injectionPending = undefined;
+            group.injectionAppliedAt = undefined;
+            group.lastInjectionError = undefined;
+          }
+          const previousBinding = state.orchestration.workerBindings[ensuredWorkerSession];
+          this.assertWorkerSessionDoesNotConflictExternalCoordinator(state, ensuredWorkerSession);
+          this.assertWorkerSessionAvailable(state, ensuredWorkerSession, undefined, { allowCurrentReservation: true });
+          state.orchestration.tasks[taskId] = task;
+          state.orchestration.workerBindings[ensuredWorkerSession] = {
+            sourceHandle: ensuredWorkerSession,
+            coordinatorSession: input.coordinatorSession,
+            workspace: input.workspace,
+            ...input.cwd ? { cwd: input.cwd } : {},
+            targetAgent: input.targetAgent,
+            role,
+            ...input.parallel ? { ephemeral: true } : {}
+          };
+          await this.deps.saveState(state);
+          return {
+            task: { ...task },
+            previousBinding,
+            previousGroup,
+            normalizedGroupId
+          };
+        });
+      } catch (error2) {
+        await releaseWorkerReservation();
+        throw error2;
+      }
       await releaseWorkerReservation();
-      throw error2;
+    } finally {
+      releasePendingParallelStart?.();
     }
-    await releaseWorkerReservation();
     try {
       await this.deps.dispatchWorkerTask({
         taskId,
@@ -20182,6 +21033,7 @@ class OrchestrationService {
       return { sourceContext, targetLocation, role, normalizedGroupId };
     });
     const autoRun = preflight.sourceContext.sourceKind === "coordinator";
+    const taskId = this.deps.createId();
     const workerSessionName = await this.resolveWorkerSession({
       sourceHandle: input.sourceHandle,
       sourceKind: preflight.sourceContext.sourceKind,
@@ -20190,18 +21042,18 @@ class OrchestrationService {
       ...preflight.targetLocation.cwd ? { cwd: preflight.targetLocation.cwd } : {},
       targetAgent: input.targetAgent,
       task: input.task,
-      ...preflight.role ? { role: preflight.role } : {}
+      ...preflight.role ? { role: preflight.role } : {},
+      ...input.parallel ? { parallel: true } : {}
     });
-    const releaseWorkerReservation = await this.reserveProposedWorkerSession(workerSessionName);
-    let prepared;
-    try {
-      prepared = await this.mutate(async () => {
+    if (input.parallel && autoRun) {
+      const queuedResult = await this.mutate(async () => {
         const state = await this.deps.loadState();
-        this.assertRpcRequestAllowed(state, preflight.sourceContext.sourceKind, preflight.sourceContext.coordinatorSession, input.targetAgent, preflight.role);
+        if (this.canStartParallelTask(state, input.targetAgent)) {
+          this.pendingParallelStarts.set(input.targetAgent, (this.pendingParallelStarts.get(input.targetAgent) ?? 0) + 1);
+          return null;
+        }
         const now = this.deps.now().toISOString();
-        const taskId = this.deps.createId();
-        const status = autoRun ? "running" : "needs_confirmation";
-        const task = {
+        const queuedTask = {
           taskId,
           sourceHandle: input.sourceHandle,
           sourceKind: preflight.sourceContext.sourceKind,
@@ -20213,49 +21065,101 @@ class OrchestrationService {
           ...preflight.role ? { role: preflight.role } : {},
           ...preflight.normalizedGroupId ? { groupId: preflight.normalizedGroupId } : {},
           task: input.task,
-          status,
+          status: "queued",
+          ephemeralWorkerSession: true,
           summary: "",
           resultText: "",
           createdAt: now,
           updatedAt: now,
           eventSeq: 1,
-          events: [{ seq: 1, at: now, type: "created", status, message: "Task created" }]
+          events: [{ seq: 1, at: now, type: "created", status: "queued", message: "Task queued at parallel capacity" }]
         };
-        if (preflight.normalizedGroupId) {
-          const group = this.ensureGroups(state)[preflight.normalizedGroupId];
-          group.updatedAt = now;
-          group.coordinatorInjectedAt = undefined;
-          group.injectionPending = undefined;
-          group.injectionAppliedAt = undefined;
-          group.lastInjectionError = undefined;
-        }
-        let previousBinding;
-        if (autoRun) {
-          previousBinding = state.orchestration.workerBindings[workerSessionName];
-          this.assertWorkerSessionDoesNotConflictExternalCoordinator(state, workerSessionName);
-          this.assertWorkerSessionAvailable(state, workerSessionName, undefined, { allowCurrentReservation: true });
-          state.orchestration.tasks[taskId] = task;
-          state.orchestration.workerBindings[workerSessionName] = {
-            sourceHandle: workerSessionName,
+        state.orchestration.tasks[taskId] = queuedTask;
+        await this.deps.saveState(state);
+        return { taskId, status: "queued", workerSession: workerSessionName };
+      });
+      if (queuedResult) {
+        this.logEvent("orchestration.task.queued", "parallel task queued at capacity", { taskId, targetAgent: input.targetAgent });
+        return queuedResult;
+      }
+    }
+    const releasePendingParallelStart = input.parallel && autoRun ? () => {
+      const count = this.pendingParallelStarts.get(input.targetAgent) ?? 0;
+      if (count <= 1) {
+        this.pendingParallelStarts.delete(input.targetAgent);
+      } else {
+        this.pendingParallelStarts.set(input.targetAgent, count - 1);
+      }
+    } : undefined;
+    let prepared;
+    const releaseWorkerReservation = await this.reserveProposedWorkerSession(workerSessionName);
+    try {
+      try {
+        prepared = await this.mutate(async () => {
+          const state = await this.deps.loadState();
+          this.assertRpcRequestAllowed(state, preflight.sourceContext.sourceKind, preflight.sourceContext.coordinatorSession, input.targetAgent, preflight.role);
+          const now = this.deps.now().toISOString();
+          const status = autoRun ? "running" : "needs_confirmation";
+          const task = {
+            taskId,
+            sourceHandle: input.sourceHandle,
+            sourceKind: preflight.sourceContext.sourceKind,
             coordinatorSession: preflight.sourceContext.coordinatorSession,
+            workerSession: workerSessionName,
             workspace: preflight.targetLocation.workspace,
             ...preflight.targetLocation.cwd ? { cwd: preflight.targetLocation.cwd } : {},
             targetAgent: input.targetAgent,
-            role: preflight.role
+            ...preflight.role ? { role: preflight.role } : {},
+            ...preflight.normalizedGroupId ? { groupId: preflight.normalizedGroupId } : {},
+            task: input.task,
+            status,
+            summary: "",
+            resultText: "",
+            createdAt: now,
+            updatedAt: now,
+            eventSeq: 1,
+            events: [{ seq: 1, at: now, type: "created", status, message: "Task created" }],
+            ...input.parallel ? { ephemeralWorkerSession: true } : {}
           };
-        } else {
-          this.assertWorkerSessionDoesNotConflictExternalCoordinator(state, workerSessionName);
-          this.assertWorkerSessionAvailable(state, workerSessionName, undefined, { allowCurrentReservation: true });
-          state.orchestration.tasks[taskId] = task;
-        }
-        await this.deps.saveState(state);
-        return { task: { ...task }, status, previousBinding, normalizedGroupId: preflight.normalizedGroupId };
-      });
-    } catch (error2) {
+          if (preflight.normalizedGroupId) {
+            const group = this.ensureGroups(state)[preflight.normalizedGroupId];
+            group.updatedAt = now;
+            group.coordinatorInjectedAt = undefined;
+            group.injectionPending = undefined;
+            group.injectionAppliedAt = undefined;
+            group.lastInjectionError = undefined;
+          }
+          let previousBinding;
+          if (autoRun) {
+            previousBinding = state.orchestration.workerBindings[workerSessionName];
+            this.assertWorkerSessionDoesNotConflictExternalCoordinator(state, workerSessionName);
+            this.assertWorkerSessionAvailable(state, workerSessionName, undefined, { allowCurrentReservation: true });
+            state.orchestration.tasks[taskId] = task;
+            state.orchestration.workerBindings[workerSessionName] = {
+              sourceHandle: workerSessionName,
+              coordinatorSession: preflight.sourceContext.coordinatorSession,
+              workspace: preflight.targetLocation.workspace,
+              ...preflight.targetLocation.cwd ? { cwd: preflight.targetLocation.cwd } : {},
+              targetAgent: input.targetAgent,
+              role: preflight.role,
+              ...input.parallel ? { ephemeral: true } : {}
+            };
+          } else {
+            this.assertWorkerSessionDoesNotConflictExternalCoordinator(state, workerSessionName);
+            this.assertWorkerSessionAvailable(state, workerSessionName, undefined, { allowCurrentReservation: true });
+            state.orchestration.tasks[taskId] = task;
+          }
+          await this.deps.saveState(state);
+          return { task: { ...task }, status, previousBinding, normalizedGroupId: preflight.normalizedGroupId };
+        });
+      } catch (error2) {
+        await releaseWorkerReservation();
+        throw error2;
+      }
       await releaseWorkerReservation();
-      throw error2;
+    } finally {
+      releasePendingParallelStart?.();
     }
-    await releaseWorkerReservation();
     if (autoRun) {
       this.runAutoRunRpcWorkerTask({
         task: prepared.task,
@@ -21224,6 +22128,16 @@ class OrchestrationService {
         await this.recordOpenQuestionWakeError(prepared.task.taskId, prepared.replacementQuestionId, error2 instanceof Error ? error2.message : String(error2));
       }
     }
+    if (input.decision === "accept") {
+      try {
+        await this.reconcileParallelSlots();
+      } catch (error2) {
+        this.logEvent("orchestration.parallel.reconcile_failed", "reconcile failed after contested result accepted", {
+          taskId: prepared.task.taskId,
+          message: error2 instanceof Error ? error2.message : String(error2)
+        });
+      }
+    }
     return prepared.task;
   }
   async listTasks(filter) {
@@ -21690,6 +22604,16 @@ class OrchestrationService {
     if (prepared.closedPackageId) {
       await this.handoffQueuedQuestions(prepared.task.coordinatorSession, prepared.closedPackageId);
     }
+    if (!prepared.shouldPropagate && this.isTerminalStatus(prepared.task.status)) {
+      try {
+        await this.reconcileParallelSlots();
+      } catch (error2) {
+        this.logEvent("orchestration.parallel.reconcile_failed", "reconcile failed after non-running cancel", {
+          taskId: prepared.task.taskId,
+          message: error2 instanceof Error ? error2.message : String(error2)
+        });
+      }
+    }
     return prepared.task;
   }
   async completeTaskCancellation(taskId) {
@@ -21752,6 +22676,14 @@ class OrchestrationService {
       return prepared.task;
     }
     this.logEvent("orchestration.task.cancel_completed", "task cancellation completed", this.taskContext(prepared.task));
+    try {
+      await this.reconcileParallelSlots();
+    } catch (error2) {
+      this.logEvent("orchestration.parallel.reconcile_failed", "reconcile failed after cancel completion", {
+        taskId: prepared.task.taskId,
+        message: error2 instanceof Error ? error2.message : String(error2)
+      });
+    }
     return prepared.task;
   }
   async failTaskCancellation(taskId, errorMessage) {
@@ -21796,6 +22728,34 @@ class OrchestrationService {
       task: currentTask.task,
       ...currentTask.role ? { role: currentTask.role } : {}
     });
+    if (currentTask.ephemeralWorkerSession === true) {
+      const queuedResult = await this.mutate(async () => {
+        const state = await this.deps.loadState();
+        const task = state.orchestration.tasks[input.taskId];
+        if (!task) {
+          throw new Error(`task "${input.taskId}" does not exist`);
+        }
+        this.assertCoordinatorOwnership(task, input.coordinatorSession);
+        this.assertNeedsConfirmation(task);
+        if (this.canStartParallelTask(state, task.targetAgent)) {
+          return null;
+        }
+        const now = this.deps.now().toISOString();
+        task.workerSession = workerSession;
+        task.status = "queued";
+        task.updatedAt = now;
+        this.appendTaskEvent(task, now, "status_changed", {
+          status: "queued",
+          message: "Task queued at parallel capacity"
+        });
+        await this.deps.saveState(state);
+        return { ...task };
+      });
+      if (queuedResult) {
+        this.logEvent("orchestration.task.queued", "parallel task queued at capacity on approve", { taskId: input.taskId, targetAgent: currentTask.targetAgent });
+        return queuedResult;
+      }
+    }
     const releaseWorkerReservation = await this.reserveProposedWorkerSession(workerSession, input.taskId);
     let ensuredWorkerSession = workerSession;
     let prepared;
@@ -21837,7 +22797,8 @@ class OrchestrationService {
           workspace: task.workspace,
           ...task.cwd ? { cwd: task.cwd } : {},
           targetAgent: task.targetAgent,
-          role: task.role
+          role: task.role,
+          ...task.ephemeralWorkerSession ? { ephemeral: true } : {}
         };
         await this.deps.saveState(state);
         return {
@@ -21891,6 +22852,10 @@ class OrchestrationService {
   }
   async resolveWorkerSession(input) {
     const role = this.normalizeRole(input.role);
+    const baseName = [input.workspace, input.cwd ? this.cwdWorkerSessionPart(input.cwd) : undefined, input.targetAgent, role, input.coordinatorSession].filter((part) => typeof part === "string" && part.trim().length > 0).map((part) => part.trim()).join(":");
+    if (input.parallel) {
+      return `${baseName}:p-${this.deps.createId()}`;
+    }
     const reusable = await this.deps.findReusableWorkerSession?.({
       sourceHandle: input.sourceHandle,
       sourceKind: input.sourceKind,
@@ -21903,7 +22868,7 @@ class OrchestrationService {
     if (reusable && reusable.trim().length > 0) {
       return reusable.trim();
     }
-    return [input.workspace, input.cwd ? this.cwdWorkerSessionPart(input.cwd) : undefined, input.targetAgent, role, input.coordinatorSession].filter((part) => typeof part === "string" && part.trim().length > 0).map((part) => part.trim()).join(":");
+    return baseName;
   }
   async reserveProposedWorkerSession(workerSession, excludingTaskId) {
     await this.mutate(async () => {
@@ -22061,7 +23026,7 @@ class OrchestrationService {
     if (role && policy.allowedAgentRequestRoles.length > 0 && !policy.allowedAgentRequestRoles.includes(role)) {
       throw new Error(`role "${role}" is not allowed for agent-requested delegation`);
     }
-    const outstandingRequests = Object.values(state.orchestration.tasks).filter((task) => task.coordinatorSession === coordinatorSession && task.sourceKind !== "human" && (task.status === "needs_confirmation" || task.status === "running"));
+    const outstandingRequests = Object.values(state.orchestration.tasks).filter((task) => task.coordinatorSession === coordinatorSession && task.sourceKind !== "human" && (task.status === "needs_confirmation" || task.status === "running" || task.status === "queued"));
     if (outstandingRequests.length >= policy.maxPendingAgentRequestsPerCoordinator) {
       throw new Error("agent-requested delegation quota exceeded for this coordinator");
     }
@@ -22226,6 +23191,137 @@ class OrchestrationService {
   hasActiveTaskWorkerSession(state, workerSession, excludingTaskId) {
     return Object.values(state.orchestration.tasks).some((task) => task.taskId !== excludingTaskId && task.workerSession === workerSession && (!this.isTerminalStatus(task.status) || task.reviewPending !== undefined));
   }
+  countActiveParallelSlots(state, targetAgent) {
+    const persisted = Object.values(state.orchestration.tasks).filter((task) => task.ephemeralWorkerSession === true && task.targetAgent === targetAgent && (task.status === "running" || task.status === "blocked" || task.status === "waiting_for_human")).length;
+    const pending = this.pendingParallelStarts.get(targetAgent) ?? 0;
+    return persisted + pending;
+  }
+  canStartParallelTask(state, targetAgent) {
+    const cap = this.deps.config.orchestration.maxParallelTasksPerAgent;
+    return this.countActiveParallelSlots(state, targetAgent) < cap;
+  }
+  async reconcileParallelSlots() {
+    const toClose = await this.mutate(async () => {
+      const state = await this.deps.loadState();
+      const collected = [];
+      for (const task of Object.values(state.orchestration.tasks)) {
+        if (task.ephemeralWorkerSession === true && task.ephemeralWorkerSessionClosed !== true && task.workerSession && task.reviewPending === undefined && this.isTerminalStatus(task.status)) {
+          task.ephemeralWorkerSessionClosed = true;
+          if (state.orchestration.workerBindings[task.workerSession] !== undefined) {
+            delete state.orchestration.workerBindings[task.workerSession];
+            collected.push({
+              workerSession: task.workerSession,
+              coordinatorSession: task.coordinatorSession,
+              workspace: task.workspace,
+              ...task.cwd ? { cwd: task.cwd } : {},
+              targetAgent: task.targetAgent,
+              ...task.role ? { role: task.role } : {}
+            });
+          }
+        }
+      }
+      if (collected.length > 0) {
+        await this.deps.saveState(state);
+      }
+      return collected;
+    });
+    for (const req of toClose) {
+      try {
+        await this.deps.closeWorkerSession?.(req);
+      } catch (error2) {
+        this.logEvent("orchestration.parallel.close_failed", "failed to close ephemeral worker session", {
+          workerSession: req.workerSession,
+          message: error2 instanceof Error ? error2.message : String(error2)
+        });
+      }
+    }
+    for (;; ) {
+      const next = await this.mutate(async () => {
+        const state = await this.deps.loadState();
+        const queued = Object.values(state.orchestration.tasks).filter((t) => t.status === "queued" && t.ephemeralWorkerSession === true).sort((a, b) => a.createdAt.localeCompare(b.createdAt));
+        for (const task of queued) {
+          if (!this.canStartParallelTask(state, task.targetAgent)) {
+            continue;
+          }
+          task.status = "running";
+          task.updatedAt = this.deps.now().toISOString();
+          state.orchestration.workerBindings[task.workerSession] = {
+            sourceHandle: task.workerSession,
+            coordinatorSession: task.coordinatorSession,
+            workspace: task.workspace,
+            ...task.cwd ? { cwd: task.cwd } : {},
+            targetAgent: task.targetAgent,
+            ...task.role ? { role: task.role } : {},
+            ephemeral: true
+          };
+          await this.deps.saveState(state);
+          return { ...task };
+        }
+        return null;
+      });
+      if (!next) {
+        break;
+      }
+      try {
+        await this.ensureReservedWorkerSession({
+          workerSession: next.workerSession,
+          sourceHandle: next.sourceHandle,
+          sourceKind: next.sourceKind,
+          coordinatorSession: next.coordinatorSession,
+          workspace: next.workspace,
+          ...next.cwd ? { cwd: next.cwd } : {},
+          targetAgent: next.targetAgent,
+          ...next.role ? { role: next.role } : {}
+        });
+        await this.deps.dispatchWorkerTask({
+          taskId: next.taskId,
+          workerSession: next.workerSession,
+          coordinatorSession: next.coordinatorSession,
+          workspace: next.workspace,
+          ...next.cwd ? { cwd: next.cwd } : {},
+          targetAgent: next.targetAgent,
+          ...next.role ? { role: next.role } : {},
+          task: next.task
+        });
+      } catch (error2) {
+        await this.mutate(async () => {
+          const state = await this.deps.loadState();
+          const task = state.orchestration.tasks[next.taskId];
+          if (task && task.status === "running") {
+            task.status = "queued";
+            task.updatedAt = this.deps.now().toISOString();
+            delete state.orchestration.workerBindings[next.workerSession];
+            this.appendTaskEvent(task, task.updatedAt, "status_changed", {
+              status: "queued",
+              message: "Task re-queued after drain failure"
+            });
+            await this.deps.saveState(state);
+          }
+        });
+        this.logEvent("orchestration.parallel.drain_failed", "failed to drain queued parallel task", {
+          taskId: next.taskId,
+          workerSession: next.workerSession,
+          message: error2 instanceof Error ? error2.message : String(error2)
+        });
+        break;
+      }
+      await this.mutate(async () => {
+        const state = await this.deps.loadState();
+        const task = state.orchestration.tasks[next.taskId];
+        if (task && task.status === "running") {
+          this.appendTaskEvent(task, task.updatedAt, "status_changed", {
+            status: "running",
+            message: "Task drained from parallel queue"
+          });
+          await this.deps.saveState(state);
+        }
+      });
+      this.logEvent("orchestration.task.drained", "parallel task drained from queue", {
+        taskId: next.taskId,
+        targetAgent: next.targetAgent
+      });
+    }
+  }
   async assertProposedWorkerSessionDoesNotConflictExternalCoordinator(workerSession) {
     const state = await this.deps.loadState();
     this.assertWorkerSessionDoesNotConflictExternalCoordinator(state, workerSession);
@@ -22884,6 +23980,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({
@@ -23236,6 +24346,13 @@ async function runConsole(paths, deps) {
         trigger: "startup"
       });
     } catch {}
+    try {
+      await runtime.orchestration.service.reconcileParallelSlots();
+    } catch (reconcileError) {
+      await runtime.logger.error("orchestration.parallel.reconcile_failed", "failed to reconcile parallel slots at startup", {
+        message: reconcileError instanceof Error ? reconcileError.message : String(reconcileError)
+      });
+    }
     consumerLock = deps.consumerLock ?? deps.consumerLockFactory?.(runtime);
     if (consumerLock) {
       const lockMeta = {
@@ -23564,7 +24681,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"]
   });
@@ -23992,9 +25110,9 @@ 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 path13 from "node:path";
+import path14 from "node:path";
 import { pathToFileURL as pathToFileURL2 } from "node:url";
 async function createStructuredPromptFile(text, media, deps = defaultStructuredPromptFileDeps) {
   const mediaList = normalizePromptMedia(media);
@@ -24028,7 +25146,7 @@ async function createStructuredPromptFile(text, media, deps = defaultStructuredP
       type: "resource",
       resource: {
         uri: pathToFileURL2(item.filePath).toString(),
-        text: `${item.fileName ?? path13.basename(item.filePath)} ${item.mimeType} ${item.type}`
+        text: `${item.fileName ?? path14.basename(item.filePath)} ${item.mimeType} ${item.type}`
       }
     });
   }
@@ -24042,7 +25160,7 @@ function normalizePromptMedia(media) {
 function buildAttachmentSummary(items) {
   const lines = ["Attachments available as local files:"];
   for (const [index, item] of items.entries()) {
-    lines.push(`${index + 1}. ${item.type} ${item.fileName ?? path13.basename(item.filePath)} ${item.mimeType} ${item.filePath}`);
+    lines.push(`${index + 1}. ${item.type} ${item.fileName ?? path14.basename(item.filePath)} ${item.mimeType} ${item.filePath}`);
   }
   return lines.join(`
 `);
@@ -24050,8 +25168,8 @@ function buildAttachmentSummary(items) {
 async function writeStructuredPromptBlocks(blocks, deps) {
   let dir = "";
   try {
-    dir = await deps.mkdtemp(path13.join(deps.tmpdir(), "weacpx-acp-prompt-"));
-    const filePath = path13.join(dir, "prompt.json");
+    dir = await deps.mkdtemp(path14.join(deps.tmpdir(), "weacpx-acp-prompt-"));
+    const filePath = path14.join(dir, "prompt.json");
     await deps.writeFile(filePath, JSON.stringify(blocks), "utf8");
     return { filePath, cleanup: async () => deps.rm(dir, { recursive: true, force: true }) };
   } catch (error2) {
@@ -24061,7 +25179,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()) {
@@ -24116,7 +25234,7 @@ var init_prompt_media = __esm(() => {
   defaultStructuredPromptFileDeps = {
     readImageFile: readImageFileBounded,
     mkdtemp,
-    writeFile: writeFile8,
+    writeFile: writeFile7,
     rm: rm8,
     tmpdir: defaultTmpdir
   };
@@ -24423,12 +25541,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;
@@ -24721,6 +25839,7 @@ class AcpxCliTransport {
   permissionMode;
   nonInteractivePermissions;
   permissionPolicy;
+  queueOwnerTtlSeconds;
   runCommand;
   runPtyCommand;
   queueOwnerLauncher;
@@ -24731,10 +25850,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;
   }
@@ -25058,7 +26179,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) {
@@ -25066,6 +26188,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];
@@ -25112,6 +26240,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, {
@@ -25307,7 +26575,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) {
@@ -25328,6 +26600,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);
 }
@@ -25380,7 +26654,8 @@ async function buildApp(paths, deps = {}) {
     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) => {
@@ -25595,6 +26870,14 @@ async function buildApp(paths, deps = {}) {
           resultText: ""
         });
       }
+      try {
+        await orchestration.reconcileParallelSlots();
+      } catch (reconcileError) {
+        await logger2.error("orchestration.parallel.reconcile_failed", "failed to reconcile parallel slots after worker turn", {
+          taskId: input.taskId,
+          message: reconcileError instanceof Error ? reconcileError.message : String(reconcileError)
+        });
+      }
       if (taskRecord && shouldNotifyTaskCompletion(taskRecord)) {
         try {
           await sendCompletionNotice(taskRecord);
@@ -25662,6 +26945,13 @@ async function buildApp(paths, deps = {}) {
         throw new Error(result.message || "worker task cancel was not acknowledged");
       }
     },
+    closeWorkerSession: async ({ workerSession, targetAgent, workspace, cwd }) => {
+      if (!transport.removeSession) {
+        return;
+      }
+      const session = resolveWorkerRuntimeSession({ workerSession, targetAgent, workspace, ...cwd ? { cwd } : {} });
+      await transport.removeSession(session);
+    },
     resumeWorkerTask: async ({ taskId, workerSession, coordinatorSession, targetAgent, workspace, cwd, answer }) => {
       launchWorkerTurn({
         taskId,
@@ -25687,7 +26977,7 @@ async function buildApp(paths, deps = {}) {
       }
     },
     findReusableWorkerSession: async ({ coordinatorSession, workspace, cwd, targetAgent, role }) => {
-      const binding = Object.entries(state.orchestration.workerBindings).find(([, current]) => current.coordinatorSession === coordinatorSession && current.workspace === workspace && current.cwd === cwd && current.targetAgent === targetAgent && current.role === role);
+      const binding = Object.entries(state.orchestration.workerBindings).find(([, current]) => current.ephemeral !== true && current.coordinatorSession === coordinatorSession && current.workspace === workspace && current.cwd === cwd && current.targetAgent === targetAgent && current.role === role);
       return binding?.[0] ?? null;
     },
     logger: logger2
@@ -25740,6 +27030,35 @@ async function buildApp(paths, deps = {}) {
         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();
@@ -25770,7 +27089,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, {
@@ -25854,6 +27178,8 @@ var init_main = __esm(async () => {
   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();
@@ -25864,7 +27190,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 {
@@ -25911,7 +27237,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 = "";
@@ -26247,107 +27573,107 @@ async function checkRuntime(options = {}) {
 }
 function createRuntimeFsProbe() {
   return {
-    stat: async (path14) => await stat3(path14),
-    access: async (path14, mode) => await access4(path14, mode)
+    stat: async (path15) => await stat3(path15),
+    access: async (path15, mode) => await access4(path15, mode)
   };
 }
-async function checkDirectoryCreatable(label, path14, probe, platform) {
+async function checkDirectoryCreatable(label, path15, probe, platform) {
   try {
-    const stats = await probe.stat(path14);
+    const stats = await probe.stat(path15);
     if (!stats.isDirectory()) {
       return {
         ok: false,
-        detail: `${label}: ${path14} (exists but is not a directory)`
+        detail: `${label}: ${path15} (exists but is not a directory)`
       };
     }
-    await probe.access(path14, directoryAccessMode(platform));
+    await probe.access(path15, directoryAccessMode(platform));
     return {
       ok: true,
-      detail: `${label}: ${path14} (writable)`
+      detail: `${label}: ${path15} (writable)`
     };
   } catch (error2) {
     if (!isMissingPathError(error2)) {
       return {
         ok: false,
-        detail: `${label}: ${path14} (unusable: ${formatError6(error2)})`
+        detail: `${label}: ${path15} (unusable: ${formatError6(error2)})`
       };
     }
-    const parentCheck = await checkCreatableAncestorDirectory(path14, probe, platform);
+    const parentCheck = await checkCreatableAncestorDirectory(path15, probe, platform);
     if (!parentCheck.ok) {
       return {
         ok: false,
-        detail: `${label}: ${path14} (parent not writable: ${parentCheck.blockingPath})`
+        detail: `${label}: ${path15} (parent not writable: ${parentCheck.blockingPath})`
       };
     }
     return {
       ok: true,
-      detail: `${label}: ${path14} (creatable via ${parentCheck.creatableFrom})`
+      detail: `${label}: ${path15} (creatable via ${parentCheck.creatableFrom})`
     };
   }
 }
-async function checkFileCreatable(label, path14, probe, platform) {
+async function checkFileCreatable(label, path15, probe, platform) {
   try {
-    const stats = await probe.stat(path14);
+    const stats = await probe.stat(path15);
     if (stats.isDirectory()) {
       return {
         ok: false,
-        detail: `${label}: ${path14} (exists but is a directory)`
+        detail: `${label}: ${path15} (exists but is a directory)`
       };
     }
-    await probe.access(path14, constants.W_OK);
+    await probe.access(path15, constants.W_OK);
     return {
       ok: true,
-      detail: `${label}: ${path14} (writable)`
+      detail: `${label}: ${path15} (writable)`
     };
   } catch (error2) {
     if (!isMissingPathError(error2)) {
       return {
         ok: false,
-        detail: `${label}: ${path14} (unusable: ${formatError6(error2)})`
+        detail: `${label}: ${path15} (unusable: ${formatError6(error2)})`
       };
     }
-    const parentCheck = await checkCreatableAncestorDirectory(dirname14(path14), probe, platform);
+    const parentCheck = await checkCreatableAncestorDirectory(dirname14(path15), probe, platform);
     if (!parentCheck.ok) {
       return {
         ok: false,
-        detail: `${label}: ${path14} (parent not writable: ${parentCheck.blockingPath})`
+        detail: `${label}: ${path15} (parent not writable: ${parentCheck.blockingPath})`
       };
     }
     return {
       ok: true,
-      detail: `${label}: ${path14} (creatable via ${parentCheck.creatableFrom})`
+      detail: `${label}: ${path15} (creatable via ${parentCheck.creatableFrom})`
     };
   }
 }
-async function checkCreatableAncestorDirectory(path14, probe, platform) {
+async function checkCreatableAncestorDirectory(path15, probe, platform) {
   try {
-    const stats = await probe.stat(path14);
+    const stats = await probe.stat(path15);
     if (!stats.isDirectory()) {
       return {
         ok: false,
-        creatableFrom: path14,
-        blockingPath: path14
+        creatableFrom: path15,
+        blockingPath: path15
       };
     }
-    await probe.access(path14, directoryAccessMode(platform));
+    await probe.access(path15, directoryAccessMode(platform));
     return {
       ok: true,
-      creatableFrom: path14
+      creatableFrom: path15
     };
   } catch (error2) {
     if (!isMissingPathError(error2)) {
       return {
         ok: false,
-        creatableFrom: path14,
-        blockingPath: path14
+        creatableFrom: path15,
+        blockingPath: path15
       };
     }
-    const parent = dirname14(path14);
-    if (parent === path14) {
+    const parent = dirname14(path15);
+    if (parent === path15) {
       return {
         ok: false,
-        creatableFrom: path14,
-        blockingPath: path14
+        creatableFrom: path15,
+        blockingPath: path15
       };
     }
     const parentCheck = await checkCreatableAncestorDirectory(parent, probe, platform);
@@ -26932,7 +28258,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 {
@@ -26960,7 +28286,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);
   }
@@ -39393,7 +40719,8 @@ function buildWeacpxMcpToolRegistry(input) {
         task: exports_external.string().min(1),
         workingDirectory: exports_external.string().min(1).optional(),
         role: exports_external.string().min(1).optional(),
-        groupId: exports_external.string().min(1).optional()
+        groupId: exports_external.string().min(1).optional(),
+        parallel: exports_external.boolean().describe("Set to true to run this task in its own ephemeral session, concurrently with other in-flight tasks for the same agent.").optional()
       }).strict(),
       handler: async (args) => await asToolResult(async () => {
         const input2 = args;
@@ -39414,7 +40741,8 @@ function buildWeacpxMcpToolRegistry(input) {
           targetAgent: exports_external.string().min(1),
           task: exports_external.string().min(1),
           workingDirectory: exports_external.string().min(1).optional(),
-          role: exports_external.string().min(1).optional()
+          role: exports_external.string().min(1).optional(),
+          parallel: exports_external.boolean().describe("Set to true to run this task in its own ephemeral session, concurrently with other in-flight tasks for the same agent.").optional()
         }).strict()).min(1)
       }).strict(),
       handler: async (args) => await asToolResult(async () => {
@@ -39433,7 +40761,8 @@ function buildWeacpxMcpToolRegistry(input) {
               task: entry.task,
               ...entry.workingDirectory ? { workingDirectory: entry.workingDirectory } : {},
               ...entry.role ? { role: entry.role } : {},
-              ...groupId ? { groupId } : {}
+              ...groupId ? { groupId } : {},
+              ...entry.parallel !== undefined ? { parallel: entry.parallel } : {}
             });
             results.push({ index, taskId: result.taskId, status: result.status });
           } catch (error2) {
@@ -39657,7 +40986,7 @@ function createErrorResult(message) {
   };
 }
 function renderDelegateSuccess(result) {
-  const next = result.status === "needs_confirmation" ? `Next: this delegation requires user approval. Tell the user, then call task_approve or task_cancel based on their response.` : `Next: task "${result.taskId}" is running. Return this taskId to the user, call task_get/task_list for non-blocking progress snapshots, or task_watch to long-poll for the next event or terminal state.`;
+  const next = result.status === "needs_confirmation" ? `Next: this delegation requires user approval. Tell the user, then call task_approve or task_cancel based on their response.` : result.status === "queued" ? `Next: task "${result.taskId}" is queued (agent at parallel capacity). It will start automatically when a slot frees. Call task_watch to long-poll for the transition to running, or task_get/task_list for non-blocking snapshots.` : `Next: task "${result.taskId}" is running. Return this taskId to the user, call task_get/task_list for non-blocking progress snapshots, or task_watch to long-poll for the next event or terminal state.`;
   return [`Delegation task "${result.taskId}" created.`, `- Status: ${result.status}`, next].join(`
 `);
 }
@@ -39928,7 +41257,8 @@ function createOrchestrationTransport(endpoint, deps = {}) {
       task: input.task,
       ...input.workingDirectory !== undefined ? { cwd: input.workingDirectory } : {},
       ...input.role !== undefined ? { role: input.role } : {},
-      ...input.groupId !== undefined ? { groupId: input.groupId } : {}
+      ...input.groupId !== undefined ? { groupId: input.groupId } : {},
+      ...input.parallel !== undefined ? { parallel: input.parallel } : {}
     }),
     createGroup: async (input) => await client.createGroup(input),
     getTask: async (input) => await client.getTaskForCoordinator(input),
@@ -40641,10 +41971,12 @@ function parseSourceHandle(args, env = process.env) {
 
 // src/cli.ts
 init_workspace_path();
+init_workspace_name();
 init_state_store();
 
 // src/onboarding.ts
 init_workspace_path();
+init_workspace_name();
 init_agent_templates();
 function isFirstUse(config2, state) {
   return Object.keys(state.sessions ?? {}).length === 0 && Object.keys(config2.workspaces ?? {}).length === 0 && (config2.plugins ?? []).length === 0;
@@ -40655,7 +41987,7 @@ async function maybeRunFirstUseOnboarding(input) {
   if (!input.deps.isInteractive())
     return { created: false };
   const cwd = normalizeWorkspacePath(input.deps.cwd());
-  const workspaceName = allocateName(sanitizeName(basenameForWorkspacePath(cwd), "workspace"), input.config.workspaces);
+  const workspaceName = allocateWorkspaceName(sanitizeWorkspaceName(basenameForWorkspacePath(cwd)), input.config.workspaces);
   const yes = (await input.deps.promptText(`检测到首次使用 weacpx。是否将当前目录创建为工作区「${workspaceName}」？[Y/n] `)).trim().toLowerCase();
   if (yes === "n" || yes === "no")
     return { created: false };
@@ -40696,18 +42028,6 @@ function resolveTemplateChoice(answer, names) {
     return names[index - 1];
   return names.includes(answer) ? answer : null;
 }
-function allocateName(base, existing) {
-  if (!existing[base])
-    return base;
-  let suffix = 2;
-  while (existing[`${base}-${suffix}`])
-    suffix += 1;
-  return `${base}-${suffix}`;
-}
-function sanitizeName(input, fallback) {
-  const sanitized = input.trim().replace(/[^a-zA-Z0-9._-]+/g, "-").replace(/^-+|-+$/g, "");
-  return sanitized || fallback;
-}
 
 // src/cli-update.ts
 init_plugin_home();
@@ -42371,7 +43691,7 @@ var HELP_LINES = [
   "weacpx doctor - 运行诊断",
   "weacpx version - 查看版本",
   "weacpx agent|agents list|add|rm|templates - 管理本机 Agent",
-  "weacpx workspace list|add|rm - 管理本机工作区（别名：ws）",
+  "weacpx workspace list|add [name] [--raw]|rm <name> - 管理本机工作区（别名：ws）",
   "weacpx mcp-stdio [--coordinator-session <session>] [--source-handle <handle>] [--workspace <name>] - 启动 MCP stdio 服务"
 ];
 function getUsageText() {
@@ -42635,10 +43955,23 @@ async function handleWorkspaceCli(args, deps) {
       if (args.length !== 1)
         return null;
       return await workspaceList(deps.print);
-    case "add":
-      if (args.length > 2)
-        return null;
-      return await workspaceAdd(args[1], deps);
+    case "add": {
+      const rest = args.slice(1);
+      let rawFlag = false;
+      let explicit;
+      for (const token of rest) {
+        if (token === "--raw") {
+          if (rawFlag)
+            return null;
+          rawFlag = true;
+          continue;
+        }
+        if (explicit !== undefined)
+          return null;
+        explicit = token;
+      }
+      return await workspaceAdd(explicit, { ...deps, raw: rawFlag });
+    }
     case "rm":
       if (args.length !== 2 || !args[1])
         return null;
@@ -42663,13 +43996,20 @@ async function workspaceList(print) {
 }
 async function workspaceAdd(rawName, deps) {
   const cwd = normalizeWorkspacePath(deps.cwd());
-  const name = rawName === undefined ? basenameForWorkspacePath(cwd) : rawName.trim();
-  if (name.trim().length === 0) {
+  const input = rawName === undefined ? basenameForWorkspacePath(cwd) : rawName.trim();
+  if (input.length === 0) {
     deps.print("工作区名称不能为空。");
     return 1;
   }
   const store = await createCliConfigStore();
   const config2 = await store.load();
+  let name = input;
+  if (!deps.raw && !isWorkspaceNameValid(input)) {
+    const base = sanitizeWorkspaceName(input);
+    name = allocateWorkspaceName(base, config2.workspaces);
+    const sourceLabel = rawName === undefined ? "目录名" : "名称";
+    deps.print(`${sourceLabel} ${JSON.stringify(input)} 含有特殊字符，已保存为「${name}」。如需保留原名请加 --raw。`);
+  }
   const existing = config2.workspaces[name];
   if (existing) {
     if (sameWorkspacePath(existing.cwd, cwd)) {
@@ -42677,7 +44017,7 @@ async function workspaceAdd(rawName, deps) {
       return 0;
     }
     deps.print(`工作区「${name}」已存在，但路径不同：${existing.cwd}`);
-    deps.print(`请换一个名称，或先执行：weacpx workspace rm ${name}`);
+    deps.print(`请换一个名称，或先执行：weacpx workspace rm ${quoteWorkspaceNameIfNeeded(name)}`);
     return 1;
   }
   await store.upsertWorkspace(name, cwd);
@@ -42830,7 +44170,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();