weacpx 0.3.1 → 0.3.2

package/dist/cli.js

@@ -360,7 +360,7 @@ var init_config_store = __esm(() => {
 
 // src/config/ensure-config.ts
 import { readFile as readFile2 } from "node:fs/promises";
-async function ensureConfigExists(path2) {
+async function ensureConfigExists(path2, options = {}) {
   try {
     await loadConfig(path2);
   } catch (error) {
@@ -368,16 +368,24 @@ async function ensureConfigExists(path2) {
       throw error;
     }
     const store = new ConfigStore(path2);
-    await store.save(await loadDefaultConfigTemplate());
+    await store.save(await loadDefaultConfigTemplate(options));
   }
 }
-async function loadDefaultConfigTemplate() {
+async function loadDefaultConfigTemplate(options = {}) {
+  if (options.readDefaultConfigTemplate) {
+    try {
+      return normalizeDefaultConfigTemplate(await options.readDefaultConfigTemplate());
+    } catch (error) {
+      if (!isMissingFileError(error)) {
+        throw error;
+      }
+    }
+  }
   const candidates = [
     new URL("../../config.example.json", import.meta.url),
     new URL("../config.example.json", import.meta.url)
   ];
   let raw;
-  let lastError;
   for (const candidate of candidates) {
     try {
       raw = await readFile2(candidate, "utf8");
@@ -386,11 +394,10 @@ async function loadDefaultConfigTemplate() {
       if (!isMissingFileError(error)) {
         throw error;
       }
-      lastError = error;
     }
   }
   if (!raw) {
-    throw lastError;
+    return normalizeDefaultConfigTemplate(BUILTIN_DEFAULT_CONFIG_TEMPLATE);
   }
   return normalizeDefaultConfigTemplate(JSON.parse(raw));
 }
@@ -411,9 +418,32 @@ function normalizeDefaultConfigTemplate(raw) {
 function isMissingFileError(error) {
   return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
 }
+var BUILTIN_DEFAULT_CONFIG_TEMPLATE;
 var init_ensure_config = __esm(() => {
   init_config_store();
   init_load_config();
+  BUILTIN_DEFAULT_CONFIG_TEMPLATE = {
+    transport: {
+      type: "acpx-bridge",
+      sessionInitTimeoutMs: 120000,
+      permissionMode: "approve-all",
+      nonInteractivePermissions: "deny"
+    },
+    logging: {
+      level: "info",
+      maxSizeBytes: 2 * 1024 * 1024,
+      maxFiles: 5,
+      retentionDays: 7
+    },
+    wechat: {
+      replyMode: "stream"
+    },
+    agents: {
+      codex: { driver: "codex" },
+      claude: { driver: "claude" }
+    },
+    workspaces: {}
+  };
 });
 
 // src/daemon/daemon-status.ts
@@ -7518,6 +7548,13 @@ function renderTaskHeartbeat(task, elapsedSeconds) {
   return `⏳ 任务「${task.taskId}」已运行 ${minutes} 分钟，等待中...`;
 }
 
+// src/orchestration/task-wait-timeouts.ts
+var DEFAULT_TASK_WAIT_TIMEOUT_MS, MAX_TASK_WAIT_TIMEOUT_MS, DEFAULT_TASK_WAIT_POLL_INTERVAL_MS = 1000, MAX_TASK_WAIT_POLL_INTERVAL_MS = 1e4, TASK_WAIT_RPC_TIMEOUT_PADDING_MS = 5000;
+var init_task_wait_timeouts = __esm(() => {
+  DEFAULT_TASK_WAIT_TIMEOUT_MS = 5 * 60000;
+  MAX_TASK_WAIT_TIMEOUT_MS = 20 * 60000;
+});
+
 // src/weixin/messaging/quota-errors.ts
 function isQuotaDeferredError(error2) {
   return error2 instanceof QuotaDeferredError;
@@ -7534,8 +7571,337 @@ var init_quota_errors = __esm(() => {
   };
 });
 
+// src/orchestration/orchestration-types.ts
+function createEmptyOrchestrationState() {
+  return {
+    tasks: {},
+    workerBindings: {},
+    groups: {},
+    humanQuestionPackages: {},
+    coordinatorQuestionState: {},
+    coordinatorRoutes: {},
+    externalCoordinators: {}
+  };
+}
+
+// src/state/types.ts
+function createEmptyState() {
+  return {
+    sessions: {},
+    chat_contexts: {},
+    orchestration: createEmptyOrchestrationState()
+  };
+}
+var init_types = () => {};
+
+// src/state/state-store.ts
+import { readFile as readFile5 } from "node:fs/promises";
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isString(value) {
+  return typeof value === "string";
+}
+function isOptionalString(value) {
+  return value === undefined || typeof value === "string";
+}
+function isOptionalBoolean(value) {
+  return value === undefined || typeof value === "boolean";
+}
+function isTaskStatus(value) {
+  return value === "pending" || value === "needs_confirmation" || value === "running" || value === "blocked" || value === "waiting_for_human" || value === "completed" || value === "failed" || value === "cancelled";
+}
+function isSourceKind(value) {
+  return value === "human" || value === "coordinator" || value === "worker";
+}
+function isOpenQuestionRecord(value) {
+  if (!isRecord2(value)) {
+    return false;
+  }
+  return isString(value.questionId) && isString(value.question) && isString(value.whyBlocked) && isString(value.whatIsNeeded) && isString(value.askedAt) && (value.status === "open" || value.status === "answered" || value.status === "superseded") && isOptionalString(value.answeredAt) && (value.answerSource === undefined || value.answerSource === "coordinator" || value.answerSource === "human") && isOptionalString(value.answerText) && isOptionalString(value.packageId) && isOptionalString(value.lastWakeError) && isOptionalString(value.lastResumeError);
+}
+function isReviewPendingRecord(value) {
+  if (!isRecord2(value)) {
+    return false;
+  }
+  return isString(value.reviewId) && value.reason === "misrouted_answer" && isString(value.createdAt) && isString(value.resultId) && isString(value.resultText);
+}
+function isCorrectionPendingRecord(value) {
+  if (!isRecord2(value)) {
+    return false;
+  }
+  return isString(value.requestedAt) && value.reason === "misrouted_answer";
+}
+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.groupId) && (value.openQuestion === undefined || isOpenQuestionRecord(value.openQuestion)) && (value.reviewPending === undefined || isReviewPendingRecord(value.reviewPending)) && (value.correctionPending === undefined || isCorrectionPendingRecord(value.correctionPending));
+}
+function isExternalCoordinatorRecord(value) {
+  if (!isRecord2(value)) {
+    return false;
+  }
+  return isString(value.coordinatorSession) && isOptionalString(value.workspace) && isString(value.createdAt) && isString(value.updatedAt) && isOptionalString(value.defaultTargetAgent);
+}
+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);
+}
+function isGroupRecord(value) {
+  if (!isRecord2(value)) {
+    return false;
+  }
+  return isString(value.groupId) && isString(value.coordinatorSession) && isString(value.title) && isString(value.createdAt) && isString(value.updatedAt) && isOptionalString(value.coordinatorInjectedAt) && isOptionalBoolean(value.injectionPending) && isOptionalString(value.injectionAppliedAt) && isOptionalString(value.lastInjectionError);
+}
+function isQueuedQuestionRecord(value) {
+  if (!isRecord2(value)) {
+    return false;
+  }
+  return isString(value.taskId) && isString(value.questionId) && isString(value.enqueuedAt);
+}
+function isCoordinatorQuestionStateRecord(value) {
+  if (!isRecord2(value)) {
+    return false;
+  }
+  const queuedQuestions = value.queuedQuestions;
+  if (queuedQuestions !== undefined && !Array.isArray(queuedQuestions)) {
+    return false;
+  }
+  return (value.activePackageId === undefined || isString(value.activePackageId)) && (queuedQuestions === undefined || queuedQuestions.every(isQueuedQuestionRecord));
+}
+function isCoordinatorRouteContextRecord(value) {
+  if (!isRecord2(value)) {
+    return false;
+  }
+  return isString(value.coordinatorSession) && isString(value.chatKey) && isOptionalString(value.accountId) && isOptionalString(value.replyContextToken) && isString(value.updatedAt);
+}
+function isHumanQuestionPackageMessageRecord(value) {
+  if (!isRecord2(value)) {
+    return false;
+  }
+  return isString(value.messageId) && (value.kind === "initial" || value.kind === "follow_up") && isString(value.promptText) && isString(value.createdAt) && isOptionalString(value.deliveredAt) && isOptionalString(value.deliveredChatKey) && isOptionalString(value.deliveryAccountId) && isOptionalString(value.lastDeliveryError);
+}
+function isHumanQuestionPackageRecord(value) {
+  if (!isRecord2(value)) {
+    return false;
+  }
+  const initialTaskIds = value.initialTaskIds;
+  const openTaskIds = value.openTaskIds;
+  const resolvedTaskIds = value.resolvedTaskIds;
+  const messages = value.messages;
+  return isString(value.packageId) && isString(value.coordinatorSession) && (value.status === "active" || value.status === "closed") && isString(value.createdAt) && isString(value.updatedAt) && isOptionalString(value.closedAt) && Array.isArray(initialTaskIds) && initialTaskIds.every(isString) && Array.isArray(openTaskIds) && openTaskIds.every(isString) && Array.isArray(resolvedTaskIds) && resolvedTaskIds.every(isString) && Array.isArray(messages) && messages.every(isHumanQuestionPackageMessageRecord) && isOptionalString(value.awaitingReplyMessageId);
+}
+function parseOrchestrationState(raw, path3) {
+  if (raw === undefined) {
+    return createEmptyOrchestrationState();
+  }
+  if (!isRecord2(raw)) {
+    throw new Error(`state file "${path3}" must contain an object field "orchestration"`);
+  }
+  const tasks = raw.tasks;
+  if (tasks !== undefined && !isRecord2(tasks)) {
+    throw new Error(`state file "${path3}" must contain an object field "orchestration.tasks"`);
+  }
+  const workerBindings = raw.workerBindings;
+  if (workerBindings !== undefined && !isRecord2(workerBindings)) {
+    throw new Error(`state file "${path3}" must contain an object field "orchestration.workerBindings"`);
+  }
+  const groups = raw.groups;
+  if (groups !== undefined && !isRecord2(groups)) {
+    throw new Error(`state file "${path3}" must contain an object field "orchestration.groups"`);
+  }
+  const humanQuestionPackages = raw.humanQuestionPackages;
+  if (humanQuestionPackages !== undefined && !isRecord2(humanQuestionPackages)) {
+    throw new Error(`state file "${path3}" must contain an object field "orchestration.humanQuestionPackages"`);
+  }
+  const coordinatorQuestionState = raw.coordinatorQuestionState;
+  if (coordinatorQuestionState !== undefined && !isRecord2(coordinatorQuestionState)) {
+    throw new Error(`state file "${path3}" must contain an object field "orchestration.coordinatorQuestionState"`);
+  }
+  const coordinatorRoutes = raw.coordinatorRoutes;
+  if (coordinatorRoutes !== undefined && !isRecord2(coordinatorRoutes)) {
+    throw new Error(`state file "${path3}" must contain an object field "orchestration.coordinatorRoutes"`);
+  }
+  const externalCoordinators = raw.externalCoordinators;
+  if (externalCoordinators !== undefined && !isRecord2(externalCoordinators)) {
+    throw new Error(`state file "${path3}" must contain an object field "orchestration.externalCoordinators"`);
+  }
+  const parsedTasks = {};
+  for (const [taskId, task] of Object.entries(tasks ?? {})) {
+    if (!isTaskRecord(task)) {
+      throw new Error(`state file "${path3}" contains an invalid orchestration task at "${taskId}"`);
+    }
+    parsedTasks[taskId] = task;
+  }
+  const parsedWorkerBindings = {};
+  for (const [workerSession, binding] of Object.entries(workerBindings ?? {})) {
+    if (!isWorkerBindingRecord(binding)) {
+      throw new Error(`state file "${path3}" contains an invalid orchestration worker binding at "${workerSession}"`);
+    }
+    parsedWorkerBindings[workerSession] = binding;
+  }
+  const parsedGroups = {};
+  for (const [groupId, group] of Object.entries(groups ?? {})) {
+    if (!isGroupRecord(group)) {
+      throw new Error(`state file "${path3}" contains an invalid orchestration group at "${groupId}"`);
+    }
+    parsedGroups[groupId] = group;
+  }
+  const parsedHumanQuestionPackages = {};
+  for (const [packageId, packageRecord] of Object.entries(humanQuestionPackages ?? {})) {
+    if (!isHumanQuestionPackageRecord(packageRecord)) {
+      throw new Error(`state file "${path3}" contains an invalid human question package at "${packageId}"`);
+    }
+    parsedHumanQuestionPackages[packageId] = packageRecord;
+  }
+  const parsedCoordinatorQuestionState = {};
+  for (const [coordinatorSession, questionState] of Object.entries(coordinatorQuestionState ?? {})) {
+    if (!isCoordinatorQuestionStateRecord(questionState)) {
+      throw new Error(`state file "${path3}" contains an invalid coordinator question state at "${coordinatorSession}"`);
+    }
+    parsedCoordinatorQuestionState[coordinatorSession] = {
+      activePackageId: questionState.activePackageId,
+      queuedQuestions: (questionState.queuedQuestions ?? []).map((question) => ({ ...question }))
+    };
+  }
+  const parsedCoordinatorRoutes = {};
+  for (const [coordinatorSession, route] of Object.entries(coordinatorRoutes ?? {})) {
+    if (!isCoordinatorRouteContextRecord(route)) {
+      throw new Error(`state file "${path3}" contains an invalid coordinator route at "${coordinatorSession}"`);
+    }
+    parsedCoordinatorRoutes[coordinatorSession] = route;
+  }
+  const parsedExternalCoordinators = {};
+  for (const [coordinatorSession, externalCoordinator] of Object.entries(externalCoordinators ?? {})) {
+    if (!isExternalCoordinatorRecord(externalCoordinator)) {
+      throw new Error(`state file "${path3}" contains an invalid external coordinator at "${coordinatorSession}"`);
+    }
+    if (externalCoordinator.coordinatorSession !== coordinatorSession) {
+      throw new Error(`state file "${path3}" contains an external coordinator key mismatch at "${coordinatorSession}"`);
+    }
+    parsedExternalCoordinators[coordinatorSession] = externalCoordinator;
+  }
+  return {
+    tasks: parsedTasks,
+    workerBindings: parsedWorkerBindings,
+    groups: parsedGroups,
+    humanQuestionPackages: parsedHumanQuestionPackages,
+    coordinatorQuestionState: parsedCoordinatorQuestionState,
+    coordinatorRoutes: parsedCoordinatorRoutes,
+    externalCoordinators: parsedExternalCoordinators
+  };
+}
+function isReplyMode(value) {
+  return value === "stream" || value === "final" || value === "verbose";
+}
+function isSessionRecord(value) {
+  if (!isRecord2(value)) {
+    return false;
+  }
+  return isString(value.alias) && isString(value.agent) && isString(value.workspace) && isString(value.transport_session) && isOptionalString(value.transport_agent_command) && isOptionalString(value.mode_id) && (value.reply_mode === undefined || isReplyMode(value.reply_mode)) && isString(value.created_at) && isString(value.last_used_at);
+}
+function parseSessions(raw, path3) {
+  const sessions = {};
+  for (const [alias, value] of Object.entries(raw)) {
+    if (!isSessionRecord(value)) {
+      throw new Error(`state file "${path3}" contains malformed session record "${alias}"`);
+    }
+    sessions[alias] = value;
+  }
+  return sessions;
+}
+function isChatContextRecord(value) {
+  return isRecord2(value) && isString(value.current_session);
+}
+function parseChatContexts(raw, path3) {
+  const chatContexts = {};
+  for (const [chatKey, value] of Object.entries(raw)) {
+    if (!isChatContextRecord(value)) {
+      throw new Error(`state file "${path3}" contains malformed chat context record "${chatKey}"`);
+    }
+    chatContexts[chatKey] = value;
+  }
+  return chatContexts;
+}
+function parseState(raw, path3) {
+  if (!isRecord2(raw)) {
+    throw new Error(`state file "${path3}" must contain a JSON object`);
+  }
+  const sessions = raw.sessions;
+  if (!isRecord2(sessions)) {
+    throw new Error(`state file "${path3}" must contain an object field "sessions"`);
+  }
+  const chatContexts = raw.chat_contexts;
+  if (!isRecord2(chatContexts)) {
+    throw new Error(`state file "${path3}" must contain an object field "chat_contexts"`);
+  }
+  const parsedSessions = parseSessions(sessions, path3);
+  const orchestration = parseOrchestrationState(raw.orchestration, path3);
+  validateExternalCoordinatorIdentityCollisions(parsedSessions, orchestration, path3);
+  return {
+    sessions: parsedSessions,
+    chat_contexts: parseChatContexts(chatContexts, path3),
+    orchestration
+  };
+}
+function validateExternalCoordinatorIdentityCollisions(sessions, orchestration, path3) {
+  for (const coordinatorSession of Object.keys(orchestration.externalCoordinators)) {
+    if (Object.values(sessions).some((session) => session.transport_session === coordinatorSession)) {
+      throw new Error(`state file "${path3}" contains external coordinator "${coordinatorSession}" that conflicts with a logical session`);
+    }
+    if (orchestration.workerBindings[coordinatorSession]) {
+      throw new Error(`state file "${path3}" contains external coordinator "${coordinatorSession}" that conflicts with a worker binding`);
+    }
+    if (Object.values(orchestration.tasks).some((task) => task.workerSession === coordinatorSession && (!isTerminalTaskStatus(task.status) || task.reviewPending !== undefined))) {
+      throw new Error(`state file "${path3}" contains external coordinator "${coordinatorSession}" that conflicts with an active task worker session`);
+    }
+  }
+}
+function isTerminalTaskStatus(status) {
+  return status === "completed" || status === "failed" || status === "cancelled";
+}
+
+class StateStore {
+  path;
+  constructor(path3) {
+    this.path = path3;
+  }
+  async load() {
+    try {
+      const content = await readFile5(this.path, "utf8");
+      if (content.trim() === "") {
+        return createEmptyState();
+      }
+      let parsed;
+      try {
+        parsed = JSON.parse(content);
+      } catch (error2) {
+        throw new Error(`failed to parse state file "${this.path}"`, {
+          cause: error2
+        });
+      }
+      return parseState(parsed, this.path);
+    } catch (error2) {
+      if (error2.code === "ENOENT") {
+        return createEmptyState();
+      }
+      throw error2;
+    }
+  }
+  async save(state) {
+    await writePrivateFileAtomic(this.path, JSON.stringify(state, null, 2));
+  }
+}
+var init_state_store = __esm(() => {
+  init_private_file();
+  init_types();
+});
+
 // src/weixin/monitor/consumer-lock.ts
-import { mkdir as mkdir6, open as open2, readFile as readFile5, rm as rm4 } from "node:fs/promises";
+import { mkdir as mkdir6, open as open2, readFile as readFile6, rm as rm4 } from "node:fs/promises";
 import { dirname as dirname6, join as join4 } from "node:path";
 import { homedir as homedir3 } from "node:os";
 function createWeixinConsumerLock(options = {}) {
@@ -7617,7 +7983,7 @@ function createWeixinConsumerLock(options = {}) {
 }
 async function loadLockMetadata(path3) {
   try {
-    const raw = await readFile5(path3, "utf8");
+    const raw = await readFile6(path3, "utf8");
     const parsed = JSON.parse(raw);
     if (!parsed || typeof parsed.pid !== "number" || !parsed.mode || !parsed.configPath || !parsed.statePath) {
       return null;
@@ -9752,7 +10118,7 @@ function createConversationExecutor() {
 
 // src/weixin/api/types.ts
 var UploadMediaType, MessageType, MessageItemType, MessageState, TypingStatus;
-var init_types = __esm(() => {
+var init_types2 = __esm(() => {
   UploadMediaType = {
     IMAGE: 1,
     VIDEO: 2,
@@ -9871,7 +10237,7 @@ function buildCdnUploadUrl(params) {
 }
 
 // src/weixin/cdn/pic-decrypt.ts
-async function fetchCdnBytes(url, label) {
+async function fetchCdnBytes(url, label, maxBytes) {
   let res;
   try {
     res = await fetch(url);
@@ -9887,7 +10253,41 @@ async function fetchCdnBytes(url, label) {
     logger.error(msg);
     throw new Error(msg);
   }
-  return Buffer.from(await res.arrayBuffer());
+  const contentLength = res.headers.get("content-length");
+  if (maxBytes !== undefined && contentLength) {
+    const parsedLength = Number(contentLength);
+    if (Number.isFinite(parsedLength) && parsedLength > maxBytes) {
+      await res.body?.cancel().catch(() => {});
+      throw new Error(`${label}: CDN download exceeds ${maxBytes} bytes`);
+    }
+  }
+  if (!res.body) {
+    const buffer = Buffer.from(await res.arrayBuffer());
+    if (maxBytes !== undefined && buffer.byteLength > maxBytes) {
+      throw new Error(`${label}: CDN download exceeds ${maxBytes} bytes`);
+    }
+    return buffer;
+  }
+  const reader = res.body.getReader();
+  const chunks = [];
+  let total = 0;
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done)
+        break;
+      const chunk = Buffer.from(value);
+      total += chunk.byteLength;
+      if (maxBytes !== undefined && total > maxBytes) {
+        await reader.cancel().catch(() => {});
+        throw new Error(`${label}: CDN download exceeds ${maxBytes} bytes`);
+      }
+      chunks.push(chunk);
+    }
+  } finally {
+    reader.releaseLock();
+  }
+  return Buffer.concat(chunks, total);
 }
 function parseAesKey(aesKeyBase64, label) {
   const decoded = Buffer.from(aesKeyBase64, "base64");
@@ -9901,20 +10301,24 @@ function parseAesKey(aesKeyBase64, label) {
   logger.error(msg);
   throw new Error(msg);
 }
-async function downloadAndDecryptBuffer(encryptedQueryParam, aesKeyBase64, cdnBaseUrl, label, fullUrl) {
+async function downloadAndDecryptBuffer(encryptedQueryParam, aesKeyBase64, cdnBaseUrl, label, fullUrl, maxBytes) {
   const key = parseAesKey(aesKeyBase64, label);
   const url = fullUrl || buildCdnDownloadUrl(encryptedQueryParam, cdnBaseUrl);
   logger.debug(`${label}: fetching url=${url}`);
-  const encrypted = await fetchCdnBytes(url, label);
+  const encryptedMaxBytes = maxBytes === undefined ? undefined : maxBytes + 16;
+  const encrypted = await fetchCdnBytes(url, label, encryptedMaxBytes);
   logger.debug(`${label}: downloaded ${encrypted.byteLength} bytes, decrypting`);
   const decrypted = decryptAesEcb(encrypted, key);
+  if (maxBytes !== undefined && decrypted.byteLength > maxBytes) {
+    throw new Error(`${label}: decrypted media exceeds ${maxBytes} bytes`);
+  }
   logger.debug(`${label}: decrypted ${decrypted.length} bytes`);
   return decrypted;
 }
-async function downloadPlainCdnBuffer(encryptedQueryParam, cdnBaseUrl, label, fullUrl) {
+async function downloadPlainCdnBuffer(encryptedQueryParam, cdnBaseUrl, label, fullUrl, maxBytes) {
   const url = fullUrl || buildCdnDownloadUrl(encryptedQueryParam, cdnBaseUrl);
   logger.debug(`${label}: fetching url=${url}`);
-  return fetchCdnBytes(url, label);
+  return fetchCdnBytes(url, label, maxBytes);
 }
 var init_pic_decrypt = __esm(() => {
   init_aes_ecb();
@@ -9986,20 +10390,21 @@ async function downloadMediaFromItem(item, deps) {
     const aesKeyBase64 = img.aeskey ? Buffer.from(img.aeskey, "hex").toString("base64") : img.media.aes_key;
     logger.debug(`${label} image: encrypt_query_param=${(img.media.encrypt_query_param ?? "").slice(0, 40)}... hasAesKey=${Boolean(aesKeyBase64)} aeskeySource=${img.aeskey ? "image_item.aeskey" : "media.aes_key"} full_url=${Boolean(img.media.full_url)}`);
     try {
-      const buf = aesKeyBase64 ? await downloadAndDecryptBuffer(img.media.encrypt_query_param ?? "", aesKeyBase64, cdnBaseUrl, `${label} image`, img.media.full_url) : await downloadPlainCdnBuffer(img.media.encrypt_query_param ?? "", cdnBaseUrl, `${label} image-plain`, img.media.full_url);
+      const buf = aesKeyBase64 ? await downloadAndDecryptBuffer(img.media.encrypt_query_param ?? "", aesKeyBase64, cdnBaseUrl, `${label} image`, img.media.full_url, WEIXIN_MEDIA_MAX_BYTES) : await downloadPlainCdnBuffer(img.media.encrypt_query_param ?? "", cdnBaseUrl, `${label} image-plain`, img.media.full_url, WEIXIN_MEDIA_MAX_BYTES);
       const saved = await saveMedia(buf, undefined, "inbound", WEIXIN_MEDIA_MAX_BYTES);
       result.decryptedPicPath = saved.path;
       logger.debug(`${label} image saved: ${saved.path}`);
     } catch (err) {
       logger.error(`${label} image download/decrypt failed: ${String(err)}`);
       errLog(`weixin ${label} image download/decrypt failed: ${String(err)}`);
+      throw err;
     }
   } else if (item.type === MessageItemType.VOICE) {
     const voice = item.voice_item;
     if (!voice?.media?.encrypt_query_param && !voice?.media?.full_url || !voice?.media?.aes_key)
       return result;
     try {
-      const silkBuf = await downloadAndDecryptBuffer(voice.media.encrypt_query_param ?? "", voice.media.aes_key, cdnBaseUrl, `${label} voice`, voice.media.full_url);
+      const silkBuf = await downloadAndDecryptBuffer(voice.media.encrypt_query_param ?? "", voice.media.aes_key, cdnBaseUrl, `${label} voice`, voice.media.full_url, WEIXIN_MEDIA_MAX_BYTES);
       logger.debug(`${label} voice: decrypted ${silkBuf.length} bytes, attempting silk transcode`);
       const wavBuf = await silkToWav(silkBuf);
       if (wavBuf) {
@@ -10022,7 +10427,7 @@ async function downloadMediaFromItem(item, deps) {
     if (!fileItem?.media?.encrypt_query_param && !fileItem?.media?.full_url || !fileItem?.media?.aes_key)
       return result;
     try {
-      const buf = await downloadAndDecryptBuffer(fileItem.media.encrypt_query_param ?? "", fileItem.media.aes_key, cdnBaseUrl, `${label} file`, fileItem.media.full_url);
+      const buf = await downloadAndDecryptBuffer(fileItem.media.encrypt_query_param ?? "", fileItem.media.aes_key, cdnBaseUrl, `${label} file`, fileItem.media.full_url, WEIXIN_MEDIA_MAX_BYTES);
       const mime = getMimeFromFilename(fileItem.file_name ?? "file.bin");
       const saved = await saveMedia(buf, mime, "inbound", WEIXIN_MEDIA_MAX_BYTES, fileItem.file_name ?? undefined);
       result.decryptedFilePath = saved.path;
@@ -10037,7 +10442,7 @@ async function downloadMediaFromItem(item, deps) {
     if (!videoItem?.media?.encrypt_query_param && !videoItem?.media?.full_url || !videoItem?.media?.aes_key)
       return result;
     try {
-      const buf = await downloadAndDecryptBuffer(videoItem.media.encrypt_query_param ?? "", videoItem.media.aes_key, cdnBaseUrl, `${label} video`, videoItem.media.full_url);
+      const buf = await downloadAndDecryptBuffer(videoItem.media.encrypt_query_param ?? "", videoItem.media.aes_key, cdnBaseUrl, `${label} video`, videoItem.media.full_url, WEIXIN_MEDIA_MAX_BYTES);
       const saved = await saveMedia(buf, "video/mp4", "inbound", WEIXIN_MEDIA_MAX_BYTES);
       result.decryptedVideoPath = saved.path;
       logger.debug(`${label} video: saved to ${saved.path}`);
@@ -10054,7 +10459,7 @@ var init_media_download = __esm(() => {
   init_mime();
   init_pic_decrypt();
   init_silk_transcode();
-  init_types();
+  init_types2();
   WEIXIN_MEDIA_MAX_BYTES = 100 * 1024 * 1024;
 });
 
@@ -10144,7 +10549,7 @@ var contextTokenStore;
 var init_inbound = __esm(() => {
   init_logger();
   init_random();
-  init_types();
+  init_types2();
   contextTokenStore = new Map;
 });
 
@@ -10306,7 +10711,7 @@ var init_send = __esm(() => {
   init_api();
   init_logger();
   init_random();
-  init_types();
+  init_types2();
 });
 
 // src/weixin/messaging/error-notice.ts
@@ -10468,7 +10873,7 @@ var init_upload = __esm(() => {
   init_logger();
   init_mime();
   init_random();
-  init_types();
+  init_types2();
 });
 
 // src/weixin/messaging/send-media.ts
@@ -10819,7 +11224,10 @@ function isPathInside(candidate, root) {
   return relative === "" || !relative.startsWith("..") && !path9.isAbsolute(relative);
 }
 function createSaveMediaBuffer(mediaTempDir) {
-  return async function saveMediaBuffer(buffer, contentType, subdir, _maxBytes, originalFilename) {
+  return async function saveMediaBuffer(buffer, contentType, subdir, maxBytes, originalFilename) {
+    if (maxBytes !== undefined && buffer.byteLength > maxBytes) {
+      throw new Error(`media exceeds ${maxBytes} bytes`);
+    }
     const dir = path9.join(resolveMediaTempDir(mediaTempDir), subdir ?? "");
     await fs6.mkdir(dir, { recursive: true });
     let ext = ".bin";
@@ -10834,6 +11242,33 @@ function createSaveMediaBuffer(mediaTempDir) {
     return { path: filePath };
   };
 }
+function inboundMediaUnavailableMessage(item) {
+  if (item.type === MessageItemType.IMAGE) {
+    return "图片读取失败，请重试。";
+  }
+  return "暂不支持处理该类型消息，请发送文字或图片。";
+}
+function inboundImageFailureMessage(error2) {
+  const message = error2 instanceof Error ? error2.message : String(error2);
+  return message.includes("exceeds 104857600 bytes") || message.includes("exceeds 100MB") ? "图片超过 100MB，无法处理。" : "图片读取失败，请重试。";
+}
+async function sendInboundMediaUnavailableNotice(input) {
+  const { to, notice, contextToken, deps } = input;
+  const reserved = deps.reserveFinal ? deps.reserveFinal(to) : true;
+  if (!reserved) {
+    deps.errLog(`weixin.final.dropped reason=quota_exhausted kind=media_unavailable chatKey=${to}`);
+    return;
+  }
+  try {
+    await sendMessageWeixin({
+      to,
+      text: notice,
+      opts: { baseUrl: deps.baseUrl, token: deps.token, contextToken }
+    });
+  } catch (err) {
+    deps.errLog(`media unavailable notice failed: ${String(err)}`);
+  }
+}
 function extractTextBody(itemList) {
   if (!itemList?.length)
     return "";
@@ -10854,13 +11289,22 @@ function getWeixinMessageTurnLane(full) {
   const textBody = extractTextBody(full.item_list).trim().toLowerCase();
   return textBody === "/cancel" || textBody === "/stop" || textBody === "/jx" ? "control" : "normal";
 }
-function findMediaItem(itemList) {
+function findUnsupportedMediaItem(itemList) {
   if (!itemList?.length)
     return;
-  const direct = itemList.find((item) => item.type === MessageItemType.IMAGE && hasDownloadableMedia(item.image_item?.media)) ?? itemList.find((item) => item.type === MessageItemType.VIDEO && hasDownloadableMedia(item.video_item?.media)) ?? itemList.find((item) => item.type === MessageItemType.FILE && hasDownloadableMedia(item.file_item?.media)) ?? itemList.find((item) => item.type === MessageItemType.VOICE && hasDownloadableMedia(item.voice_item?.media) && !item.voice_item?.text);
+  const direct = itemList.find((item) => item.type === MessageItemType.VIDEO || item.type === MessageItemType.FILE || item.type === MessageItemType.VOICE);
   if (direct)
     return direct;
-  const refItem = itemList.find((item) => item.type === MessageItemType.TEXT && item.ref_msg?.message_item && isMediaItem(item.ref_msg.message_item));
+  const refItem = itemList.find((item) => item.type === MessageItemType.TEXT && item.ref_msg?.message_item && item.ref_msg.message_item.type !== MessageItemType.IMAGE && isMediaItem(item.ref_msg.message_item));
+  return refItem?.ref_msg?.message_item ?? undefined;
+}
+function findImageMediaItem(itemList) {
+  if (!itemList?.length)
+    return;
+  const direct = itemList.find((item) => item.type === MessageItemType.IMAGE);
+  if (direct)
+    return direct;
+  const refItem = itemList.find((item) => item.type === MessageItemType.TEXT && item.ref_msg?.message_item?.type === MessageItemType.IMAGE);
   return refItem?.ref_msg?.message_item ?? undefined;
 }
 async function handleWeixinMessageTurn(full, deps) {
@@ -10906,6 +11350,20 @@ async function handleWeixinMessageTurn(full, deps) {
       }
     }).catch(() => {});
   };
+  const contextToken = full.context_token;
+  if (contextToken) {
+    setContextToken(deps.accountId, full.from_user_id ?? "", contextToken);
+  }
+  const unsupportedMediaItem = findUnsupportedMediaItem(full.item_list);
+  if (unsupportedMediaItem) {
+    await sendInboundMediaUnavailableNotice({
+      to,
+      notice: inboundMediaUnavailableMessage(unsupportedMediaItem),
+      contextToken,
+      deps
+    });
+    return;
+  }
   if (textBody.startsWith("/")) {
     const shouldTypeForSlash = isClearSlashCommand(textBody);
     if (shouldTypeForSlash) {
@@ -10936,14 +11394,12 @@ async function handleWeixinMessageTurn(full, deps) {
       }
     }
   }
-  const contextToken = full.context_token;
-  if (contextToken) {
-    setContextToken(deps.accountId, full.from_user_id ?? "", contextToken);
-  }
   startTypingIndicator();
   let media;
-  const mediaItem = findMediaItem(full.item_list);
+  let inboundImagePath;
+  const mediaItem = findImageMediaItem(full.item_list);
   if (mediaItem) {
+    let mediaUnavailableNotice;
     try {
       const downloaded = await downloadMediaFromItem(mediaItem, {
         cdnBaseUrl: deps.cdnBaseUrl,
@@ -10953,24 +11409,24 @@ async function handleWeixinMessageTurn(full, deps) {
         label: "inbound"
       });
       if (downloaded.decryptedPicPath) {
+        inboundImagePath = downloaded.decryptedPicPath;
         media = { type: "image", filePath: downloaded.decryptedPicPath, mimeType: "image/*" };
-      } else if (downloaded.decryptedVideoPath) {
-        media = { type: "video", filePath: downloaded.decryptedVideoPath, mimeType: "video/mp4" };
-      } else if (downloaded.decryptedFilePath) {
-        media = {
-          type: "file",
-          filePath: downloaded.decryptedFilePath,
-          mimeType: downloaded.fileMediaType ?? "application/octet-stream"
-        };
-      } else if (downloaded.decryptedVoicePath) {
-        media = {
-          type: "audio",
-          filePath: downloaded.decryptedVoicePath,
-          mimeType: downloaded.voiceMediaType ?? "audio/wav"
-        };
+      } else {
+        mediaUnavailableNotice = inboundMediaUnavailableMessage(mediaItem);
       }
     } catch (err) {
       deps.errLog(`media download failed: ${String(err)}`);
+      mediaUnavailableNotice = inboundImageFailureMessage(err);
+    }
+    if (!media) {
+      await sendInboundMediaUnavailableNotice({
+        to,
+        notice: mediaUnavailableNotice ?? inboundMediaUnavailableMessage(mediaItem),
+        contextToken,
+        deps
+      });
+      stopTypingIndicator();
+      return;
     }
   }
   const sendReplySegment = async (text) => {
@@ -11108,13 +11564,18 @@ ${buildFinalHeadsUp({
       });
     }
   } finally {
+    if (inboundImagePath) {
+      await fs6.rm(inboundImagePath, { force: true }).catch((err) => {
+        deps.errLog(`inbound image cleanup failed: ${String(err)}`);
+      });
+    }
     stopTypingIndicator();
   }
 }
-var MAX_FINAL_CHUNK_BYTES = 1800, hasDownloadableMedia = (media) => media?.encrypt_query_param || media?.full_url;
+var MAX_FINAL_CHUNK_BYTES = 1800;
 var init_handle_weixin_message_turn = __esm(() => {
   init_api();
-  init_types();
+  init_types2();
   init_media_download();
   init_mime();
   init_inbound();
@@ -11344,7 +11805,7 @@ var init_monitor = __esm(() => {
   init_config_cache();
   init_session_guard();
   init_handle_weixin_message_turn();
-  init_types();
+  init_types2();
   init_sync_buf();
   init_logger();
 });
@@ -11630,7 +12091,7 @@ var init_app_logger = __esm(() => {
 });
 
 // src/transport/acpx-session-index.ts
-import { readFile as readFile6 } from "node:fs/promises";
+import { readFile as readFile7 } from "node:fs/promises";
 import { homedir as homedir4 } from "node:os";
 import { resolve } from "node:path";
 async function resolveSessionAgentCommandFromIndex(session) {
@@ -11639,7 +12100,7 @@ async function resolveSessionAgentCommandFromIndex(session) {
     return;
   }
   try {
-    const raw = await readFile6(resolve(home, ".acpx", "sessions", "index.json"), "utf8");
+    const raw = await readFile7(resolve(home, ".acpx", "sessions", "index.json"), "utf8");
     const parsed = JSON.parse(raw);
     const targetCwd = resolve(session.cwd);
     const match = parsed.entries?.find((entry) => entry.name === session.transportSession && entry.cwd === targetCwd && typeof entry.agentCommand === "string" && entry.agentCommand.trim().length > 0);
@@ -12853,50 +13314,60 @@ async function handleSessions(context, chatKey) {
 }
 async function handleSessionNew(context, chatKey, alias, agent, workspace) {
   const session = context.lifecycle.resolveSession(alias, agent, workspace, `${workspace}:${alias}`);
+  const releaseTransportReservation = await context.lifecycle.reserveTransportSession(session.transportSession);
   try {
-    await context.lifecycle.ensureTransportSession(session);
-    const exists = await context.lifecycle.checkTransportSession(session);
-    if (!exists) {
-      return context.recovery.renderSessionCreationVerificationError(session);
+    try {
+      await context.lifecycle.ensureTransportSession(session);
+      const exists = await context.lifecycle.checkTransportSession(session);
+      if (!exists) {
+        return context.recovery.renderSessionCreationVerificationError(session);
+      }
+    } catch (error2) {
+      return context.recovery.renderSessionCreationError(session, error2);
     }
-  } catch (error2) {
-    return context.recovery.renderSessionCreationError(session, error2);
+    await context.sessions.attachSession(alias, agent, workspace, session.transportSession);
+    await context.lifecycle.refreshSessionTransportAgentCommand(alias);
+    await context.sessions.useSession(chatKey, alias);
+    await context.logger.info("session.created", "created and selected logical session", {
+      alias,
+      agent,
+      workspace
+    });
+    return { text: `会话「${alias}」已创建并切换` };
+  } finally {
+    await releaseTransportReservation();
   }
-  await context.sessions.attachSession(alias, agent, workspace, session.transportSession);
-  await context.lifecycle.refreshSessionTransportAgentCommand(alias);
-  await context.sessions.useSession(chatKey, alias);
-  await context.logger.info("session.created", "created and selected logical session", {
-    alias,
-    agent,
-    workspace
-  });
-  return { text: `会话「${alias}」已创建并切换` };
 }
 async function handleSessionShortcut(context, chatKey, agent, target, createNew) {
   return await context.lifecycle.handleSessionShortcut(chatKey, agent, target, createNew);
 }
 async function handleSessionAttach(context, chatKey, alias, agent, workspace, transportSession) {
   const attached = context.lifecycle.resolveSession(alias, agent, workspace, transportSession);
-  const exists = await context.lifecycle.checkTransportSession(attached);
-  if (!exists) {
-    return {
-      text: [
-        "没有找到可绑定的已有会话。",
-        `请确认会话名是否正确，然后重新执行：/session attach ${alias} --agent ${agent} --ws ${workspace} --name <会话名>`
-      ].join(`
+  const releaseTransportReservation = await context.lifecycle.reserveTransportSession(attached.transportSession);
+  try {
+    const exists = await context.lifecycle.checkTransportSession(attached);
+    if (!exists) {
+      return {
+        text: [
+          "没有找到可绑定的已有会话。",
+          `请确认会话名是否正确，然后重新执行：/session attach ${alias} --agent ${agent} --ws ${workspace} --name <会话名>`
+        ].join(`
 `)
-    };
+      };
+    }
+    await context.sessions.attachSession(alias, agent, workspace, transportSession);
+    await context.lifecycle.refreshSessionTransportAgentCommand(alias);
+    await context.sessions.useSession(chatKey, alias);
+    await context.logger.info("session.attached", "attached existing transport session", {
+      alias,
+      agent,
+      workspace,
+      transportSession
+    });
+    return { text: `会话「${alias}」已绑定并切换` };
+  } finally {
+    await releaseTransportReservation();
   }
-  await context.sessions.attachSession(alias, agent, workspace, transportSession);
-  await context.lifecycle.refreshSessionTransportAgentCommand(alias);
-  await context.sessions.useSession(chatKey, alias);
-  await context.logger.info("session.attached", "attached existing transport session", {
-    alias,
-    agent,
-    workspace,
-    transportSession
-  });
-  return { text: `会话「${alias}」已绑定并切换` };
 }
 async function handleSessionUse(context, chatKey, alias) {
   await context.sessions.useSession(chatKey, alias);
@@ -13069,7 +13540,7 @@ async function handleSessionRemove(context, chatKey, alias) {
   return { text: lines.join(`
 `) };
 }
-async function promptWithSession(context, session, chatKey, text, reply, replyContextToken, accountId) {
+async function promptWithSession(context, session, chatKey, text, reply, replyContextToken, accountId, media) {
   const effectiveReplyMode = session.replyMode ?? context.config?.wechat.replyMode ?? "verbose";
   const transportReply = effectiveReplyMode !== "final" ? reply : undefined;
   if (context.orchestration) {
@@ -13092,7 +13563,7 @@ async function promptWithSession(context, session, chatKey, text, reply, replyCo
   const { promptText, taskIds, groupIds, claimHumanReply } = await preparePromptWithFallback(context, session, chatKey, text, replyContextToken, accountId);
   try {
     const replyContext = transportReply && context.quota ? { chatKey, quota: context.quota } : undefined;
-    const result = await context.interaction.promptTransportSession(session, promptText, transportReply, replyContext);
+    const result = await context.interaction.promptTransportSession(session, promptText, transportReply, replyContext, media);
     if (claimHumanReply) {
       try {
         await context.orchestration?.claimActiveHumanReply?.(claimHumanReply);
@@ -13112,17 +13583,17 @@ async function promptWithSession(context, session, chatKey, text, reply, replyCo
     throw error2;
   }
 }
-async function handlePrompt(context, chatKey, text, reply, replyContextToken, accountId) {
+async function handlePrompt(context, chatKey, text, reply, replyContextToken, accountId, media) {
   const session = await context.sessions.getCurrentSession(chatKey);
   if (!session) {
     return { text: NO_CURRENT_SESSION_TEXT };
   }
   try {
-    return await promptWithSession(context, session, chatKey, text, reply, replyContextToken, accountId);
+    return await promptWithSession(context, session, chatKey, text, reply, replyContextToken, accountId, media);
   } catch (error2) {
     const recovered = await context.recovery.tryRecoverMissingSession(session, error2);
     if (recovered) {
-      return await promptWithSession(context, recovered, chatKey, text, reply, replyContextToken, accountId);
+      return await promptWithSession(context, recovered, chatKey, text, reply, replyContextToken, accountId, media);
     }
     return context.recovery.renderTransportError(session, error2);
   }
@@ -13850,34 +14321,39 @@ async function handleSessionShortcutCommand(context, ops, chatKey, agent, target
     };
   }
   const session = ops.resolveSession(alias, agent, workspace.name, alias);
+  const releaseTransportReservation = await ops.reserveTransportSession(session.transportSession);
   try {
-    await ops.ensureTransportSession(session);
-    const exists = await ops.checkTransportSession(session);
-    if (!exists) {
+    try {
+      await ops.ensureTransportSession(session);
+      const exists = await ops.checkTransportSession(session);
+      if (!exists) {
+        return renderShortcutSessionCreationError(workspace, alias);
+      }
+    } catch (err) {
+      if (err instanceof AutoInstallFailedError)
+        throw err;
       return renderShortcutSessionCreationError(workspace, alias);
     }
-  } catch (err) {
-    if (err instanceof AutoInstallFailedError)
-      throw err;
-    return renderShortcutSessionCreationError(workspace, alias);
-  }
-  await context.sessions.attachSession(alias, agent, workspace.name, session.transportSession);
-  await ops.refreshSessionTransportAgentCommand(alias);
-  await context.sessions.useSession(chatKey, alias);
-  await context.logger.info("session.shortcut.created", "created new logical session from shortcut", {
-    alias,
-    workspace: workspace.name,
-    agent,
-    workspaceReused: workspace.reused
-  });
-  return {
-    text: [
-      `已创建并切换到会话「${alias}」`,
-      workspace.reused ? `- 复用工作区：${workspace.name}` : `- 新增工作区：${workspace.name} -> ${workspace.cwd}`,
-      `- 新增会话：${alias}`
-    ].join(`
+    await context.sessions.attachSession(alias, agent, workspace.name, session.transportSession);
+    await ops.refreshSessionTransportAgentCommand(alias);
+    await context.sessions.useSession(chatKey, alias);
+    await context.logger.info("session.shortcut.created", "created new logical session from shortcut", {
+      alias,
+      workspace: workspace.name,
+      agent,
+      workspaceReused: workspace.reused
+    });
+    return {
+      text: [
+        `已创建并切换到会话「${alias}」`,
+        workspace.reused ? `- 复用工作区：${workspace.name}` : `- 新增工作区：${workspace.name} -> ${workspace.cwd}`,
+        `- 新增会话：${alias}`
+      ].join(`
 `)
-  };
+    };
+  } finally {
+    await releaseTransportReservation();
+  }
 }
 async function resolveShortcutWorkspace(context, target) {
   if (target.workspace) {
@@ -14357,31 +14833,36 @@ async function handleSessionResetCommand(context, ops, chatKey) {
     return { text: NO_CURRENT_SESSION_TEXT3 };
   }
   const resetSession = ops.resolveSession(session.alias, session.agent, session.workspace, buildResetTransportSessionName(session, ops.now()));
+  const releaseTransportReservation = await ops.reserveTransportSession(resetSession.transportSession);
   try {
-    await ops.ensureTransportSession(resetSession);
-    const exists = await ops.checkTransportSession(resetSession);
-    if (!exists) {
-      return {
-        text: [
-          `会话「${session.alias}」重置失败。`,
-          "新的后端会话未创建成功，请稍后重试。"
-        ].join(`
+    try {
+      await ops.ensureTransportSession(resetSession);
+      const exists = await ops.checkTransportSession(resetSession);
+      if (!exists) {
+        return {
+          text: [
+            `会话「${session.alias}」重置失败。`,
+            "新的后端会话未创建成功，请稍后重试。"
+          ].join(`
 `)
-      };
-    }
-  } catch (error2) {
-    return renderTransportError(resetSession, error2);
-  }
-  await context.sessions.attachSession(resetSession.alias, resetSession.agent, resetSession.workspace, resetSession.transportSession);
-  await ops.refreshSessionTransportAgentCommand(resetSession.alias);
-  await context.sessions.useSession(chatKey, resetSession.alias);
-  await context.logger.info("session.reset", "reset current logical session", {
-    alias: resetSession.alias,
-    agent: resetSession.agent,
-    workspace: resetSession.workspace,
-    transportSession: resetSession.transportSession,
-    chatKey
-  });
+        };
+      }
+    } catch (error2) {
+      return renderTransportError(resetSession, error2);
+    }
+    await context.sessions.attachSession(resetSession.alias, resetSession.agent, resetSession.workspace, resetSession.transportSession);
+    await ops.refreshSessionTransportAgentCommand(resetSession.alias);
+    await context.sessions.useSession(chatKey, resetSession.alias);
+    await context.logger.info("session.reset", "reset current logical session", {
+      alias: resetSession.alias,
+      agent: resetSession.agent,
+      workspace: resetSession.workspace,
+      transportSession: resetSession.transportSession,
+      chatKey
+    });
+  } finally {
+    await releaseTransportReservation();
+  }
   return { text: `会话「${resetSession.alias}」已重置` };
 }
 function buildResetTransportSessionName(session, now) {
@@ -14420,7 +14901,7 @@ class CommandRouter {
     this.quota = quota;
     this.logger = logger2 ?? createNoopAppLogger();
   }
-  async handle(chatKey, input, reply, replyContextToken, accountId) {
+  async handle(chatKey, input, reply, replyContextToken, accountId, media) {
     const startedAt = Date.now();
     const command = parseCommand(input);
     await this.logger.debug("command.parsed", "parsed inbound command", {
@@ -14523,7 +15004,7 @@ class CommandRouter {
         case "task.cancel":
           return await handleTaskCancel(this.createHandlerContext(), chatKey, command.taskId);
         case "prompt":
-          return await handlePrompt(this.createSessionHandlerContext(), chatKey, command.text, reply, replyContextToken, accountId);
+          return await handlePrompt(this.createSessionHandlerContext(), chatKey, command.text, reply, replyContextToken, accountId, media);
       }
     });
   }
@@ -14555,6 +15036,7 @@ class CommandRouter {
       resolveSession: (alias, agent, workspace, transportSession) => this.sessions.resolveSession(alias, agent, workspace, transportSession),
       ensureTransportSession: (session, replyOverride) => this.ensureTransportSession(session, replyOverride ?? reply),
       checkTransportSession: (session) => this.checkTransportSession(session),
+      reserveTransportSession: (transportSession) => this.reserveLogicalTransportSession(transportSession),
       handleSessionShortcut: async (chatKey, agent, target, createNew, replyOverride) => {
         try {
           return await handleSessionShortcutCommand(this.createHandlerContext(), this.createSessionShortcutOps(replyOverride ?? reply), chatKey, agent, target, createNew);
@@ -14574,7 +15056,7 @@ class CommandRouter {
     return {
       setModeTransportSession: (session, modeId) => this.setModeTransportSession(session, modeId),
       cancelTransportSession: (session) => this.cancelTransportSession(session),
-      promptTransportSession: (session, text, reply, replyContext) => this.promptTransportSession(session, text, reply, replyContext)
+      promptTransportSession: (session, text, reply, replyContext, media) => this.promptTransportSession(session, text, reply, replyContext, media)
     };
   }
   createSessionRenderRecoveryOps() {
@@ -14589,6 +15071,7 @@ class CommandRouter {
     return {
       ensureTransportSession: (session, replyOverride) => this.ensureTransportSession(session, replyOverride ?? reply),
       checkTransportSession: (session) => this.checkTransportSession(session),
+      reserveTransportSession: (transportSession) => this.reserveLogicalTransportSession(transportSession),
       resolveSession: (alias, agent, workspace, transportSession) => this.sessions.resolveSession(alias, agent, workspace, transportSession),
       refreshSessionTransportAgentCommand: (alias) => this.refreshSessionTransportAgentCommand(alias),
       now: () => Date.now()
@@ -14606,9 +15089,16 @@ class CommandRouter {
       resolveSession: (alias, agent, workspace, transportSession) => this.sessions.resolveSession(alias, agent, workspace, transportSession),
       ensureTransportSession: (session, replyOverride) => this.ensureTransportSession(session, replyOverride ?? reply),
       checkTransportSession: (session) => this.checkTransportSession(session),
+      reserveTransportSession: (transportSession) => this.reserveLogicalTransportSession(transportSession),
       refreshSessionTransportAgentCommand: (alias) => this.refreshSessionTransportAgentCommand(alias)
     };
   }
+  async reserveLogicalTransportSession(transportSession) {
+    if (this.orchestration?.reserveLogicalTransportSession) {
+      return await this.orchestration.reserveLogicalTransportSession(transportSession);
+    }
+    return async () => {};
+  }
   replaceConfig(updated) {
     if (!this.config) {
       return;
@@ -14722,9 +15212,9 @@ class CommandRouter {
   async checkTransportSession(session) {
     return await this.measureTransportCall("has_session", session, () => this.transport.hasSession(session));
   }
-  async promptTransportSession(session, text, reply, replyContext) {
+  async promptTransportSession(session, text, reply, replyContext, media) {
     session.mcpCoordinatorSession ??= session.transportSession;
-    return await this.measureTransportCall("prompt", session, () => this.transport.prompt(session, text, reply, replyContext));
+    return await this.measureTransportCall("prompt", session, () => this.transport.prompt(session, text, reply, replyContext, media ? { media } : undefined));
   }
   async setModeTransportSession(session, modeId) {
     return await this.measureTransportCall("set_mode", session, () => this.transport.setMode(session, modeId));
@@ -14852,15 +15342,21 @@ class ConsoleAgent {
     this.logger = logger2 ?? createNoopAppLogger();
   }
   async chat(request) {
-    if (!request.text.trim()) {
+    const hasText = request.text.trim().length > 0;
+    if (!hasText && !request.media) {
       return { text: "消息内容为空。" };
     }
+    if (request.media && request.media.type !== "image") {
+      return {
+        text: hasText ? "暂不支持处理该类型附件；请发送文字或图片。" : "暂不支持处理该类型消息，请发送文字或图片。"
+      };
+    }
     await this.logger.info("chat.received", "received inbound chat message", {
       chatKey: request.conversationId,
       kind: request.text.trim().startsWith("/") ? "command" : "prompt",
       text: summarizeText(request.text)
     });
-    return await this.router.handle(request.conversationId, request.text, request.reply, request.replyContextToken, request.accountId);
+    return await this.router.handle(request.conversationId, request.text, request.reply, request.replyContextToken, request.accountId, request.media);
   }
   async clearSession(conversationId) {
     await this.router.clearSession?.(conversationId);
@@ -14877,6 +15373,24 @@ var init_console_agent = __esm(() => {
   init_app_logger();
 });
 
+// src/orchestration/async-mutex.ts
+class AsyncMutex {
+  tail = Promise.resolve();
+  async run(critical) {
+    const previous = this.tail;
+    let release;
+    this.tail = new Promise((resolve2) => {
+      release = resolve2;
+    });
+    await previous;
+    try {
+      return await critical();
+    } finally {
+      release();
+    }
+  }
+}
+
 // src/orchestration/orchestration-server.ts
 import { rm as rm6 } from "node:fs/promises";
 import { createConnection as createConnection2, createServer } from "node:net";
@@ -14976,37 +15490,52 @@ class OrchestrationServer {
   }
   async dispatch(method, params) {
     switch (method) {
+      case "coordinator.register_external":
+        return await this.handlers.registerExternalCoordinator(this.parseRegisterExternalCoordinatorInput(params));
       case "delegate.request":
-        return await this.handlers.requestDelegate(params);
+        return await this.handlers.requestDelegate(this.parseRequestDelegateRpcInput(params));
       case "task.get":
         return await this.dispatchTaskGet(params);
       case "task.list":
-        return await this.handlers.listTasks(requireOptionalObject(params, "filter"));
+        return await this.handlers.listTasks(this.parseTaskListFilter(params));
+      case "task.wait":
+        return await this.handlers.waitTask(this.parseWaitTaskInput(params));
       case "task.approve":
+        requireOnlyKeys(params, ["taskId", "coordinatorSession"], "params");
         return await this.handlers.approveTask({
           taskId: requireString(params, "taskId"),
           coordinatorSession: requireString(params, "coordinatorSession")
         });
       case "task.reject":
+        requireOnlyKeys(params, ["taskId", "coordinatorSession"], "params");
         return await this.handlers.rejectTask({
           taskId: requireString(params, "taskId"),
           coordinatorSession: requireString(params, "coordinatorSession")
         });
       case "task.cancel":
-        return await this.handlers.cancelTask(params);
+        return await this.handlers.cancelTask(this.parseCancelTaskInput(params));
       case "worker.reply":
-        await this.handlers.recordWorkerReply(params);
+        await this.handlers.recordWorkerReply(this.parseRecordWorkerReplyInput(params));
         return { accepted: true };
       case "worker.raise_question":
         return await this.handlers.workerRaiseQuestion(this.parseWorkerRaiseQuestionInput(params));
       case "coordinator.answer_question":
+        requireOnlyKeys(params, ["coordinatorSession", "taskId", "questionId", "answer"], "params");
         return await this.handlers.coordinatorAnswerQuestion({
           coordinatorSession: requireString(params, "coordinatorSession"),
           taskId: requireString(params, "taskId"),
           questionId: requireString(params, "questionId"),
           answer: requireString(params, "answer")
         });
+      case "coordinator.retract_answer":
+        requireOnlyKeys(params, ["coordinatorSession", "taskId", "questionId"], "params");
+        return await this.handlers.coordinatorRetractAnswer({
+          coordinatorSession: requireString(params, "coordinatorSession"),
+          taskId: requireString(params, "taskId"),
+          questionId: requireString(params, "questionId")
+        });
       case "coordinator.request_human_input": {
+        requireOnlyKeys(params, ["coordinatorSession", "taskQuestions", "promptText", "expectedActivePackageId"], "params");
         const expectedActivePackageId = requireOptionalString(params, "expectedActivePackageId");
         return await this.handlers.coordinatorRequestHumanInput({
           coordinatorSession: requireString(params, "coordinatorSession"),
@@ -15016,6 +15545,7 @@ class OrchestrationServer {
         });
       }
       case "coordinator.follow_up_human_package":
+        requireOnlyKeys(params, ["coordinatorSession", "packageId", "priorMessageId", "taskQuestions", "promptText"], "params");
         return await this.handlers.coordinatorFollowUpHumanPackage({
           coordinatorSession: requireString(params, "coordinatorSession"),
           packageId: requireString(params, "packageId"),
@@ -15024,6 +15554,7 @@ class OrchestrationServer {
           promptText: requireString(params, "promptText")
         });
       case "coordinator.review_contested_result":
+        requireOnlyKeys(params, ["coordinatorSession", "taskId", "reviewId", "decision"], "params");
         return await this.handlers.coordinatorReviewContestedResult({
           coordinatorSession: requireString(params, "coordinatorSession"),
           taskId: requireString(params, "taskId"),
@@ -15031,11 +15562,13 @@ class OrchestrationServer {
           decision: requireEnum(params, "decision", ["accept", "discard"])
         });
       case "group.new":
+        requireOnlyKeys(params, ["coordinatorSession", "title"], "params");
         return await this.handlers.createGroup({
           coordinatorSession: requireString(params, "coordinatorSession"),
           title: requireString(params, "title")
         });
       case "group.get":
+        requireOnlyKeys(params, ["coordinatorSession", "groupId"], "params");
         return await this.handlers.getGroupSummary({
           coordinatorSession: requireString(params, "coordinatorSession"),
           groupId: requireString(params, "groupId")
@@ -15043,6 +15576,7 @@ class OrchestrationServer {
       case "group.list":
         return await this.handlers.listGroupSummaries(this.parseGroupListFilter(params));
       case "group.cancel":
+        requireOnlyKeys(params, ["coordinatorSession", "groupId"], "params");
         return await this.handlers.cancelGroup({
           coordinatorSession: requireString(params, "coordinatorSession"),
           groupId: requireString(params, "groupId")
@@ -15051,19 +15585,110 @@ class OrchestrationServer {
         throw new OrchestrationInvalidRequestError(`unsupported orchestration method: ${method}`);
     }
   }
+  parseRegisterExternalCoordinatorInput(params) {
+    requireOnlyKeys(params, ["coordinatorSession", "workspace", "defaultTargetAgent"], "params");
+    const workspace = requireOptionalString(params, "workspace");
+    const defaultTargetAgent = requireOptionalString(params, "defaultTargetAgent");
+    return {
+      coordinatorSession: requireString(params, "coordinatorSession"),
+      ...workspace !== undefined ? { workspace } : {},
+      ...defaultTargetAgent !== undefined ? { defaultTargetAgent } : {}
+    };
+  }
   async dispatchTaskGet(params) {
+    requireOnlyKeys(params, ["taskId", "coordinatorSession"], "params");
     const taskId = requireString(params, "taskId");
-    const coordinatorSession = requireOptionalString(params, "coordinatorSession");
+    const coordinatorSession = requireString(params, "coordinatorSession");
     const task = await this.handlers.getTask(taskId);
     if (!task) {
       return null;
     }
-    if (coordinatorSession !== undefined && task.coordinatorSession !== coordinatorSession) {
+    if (task.coordinatorSession !== coordinatorSession) {
       return null;
     }
     return task;
   }
+  parseRequestDelegateRpcInput(params) {
+    requireOnlyKeys(params, ["sourceHandle", "targetAgent", "task", "cwd", "role", "groupId"], "params");
+    const cwd = requireOptionalString(params, "cwd");
+    const role = requireOptionalString(params, "role");
+    const groupId = requireOptionalString(params, "groupId");
+    return {
+      sourceHandle: requireString(params, "sourceHandle"),
+      targetAgent: requireString(params, "targetAgent"),
+      task: requireString(params, "task"),
+      ...cwd !== undefined ? { cwd } : {},
+      ...role !== undefined ? { role } : {},
+      ...groupId !== undefined ? { groupId } : {}
+    };
+  }
+  parseTaskListFilter(params) {
+    requireOnlyKeys(params, ["filter"], "params");
+    const filter = requireOptionalObject(params, "filter");
+    if (!filter) {
+      throw new OrchestrationInvalidRequestError("filter must include coordinatorSession");
+    }
+    requireOnlyKeys(filter, ["coordinatorSession", "status", "stuck", "sort", "order"], "filter");
+    const status = requireOptionalEnum(filter, "status", [
+      "pending",
+      "needs_confirmation",
+      "running",
+      "blocked",
+      "waiting_for_human",
+      "completed",
+      "failed",
+      "cancelled"
+    ]);
+    const stuck = requireOptionalBoolean(filter, "stuck");
+    const sort = requireOptionalEnum(filter, "sort", ["updatedAt", "createdAt"]);
+    const order = requireOptionalEnum(filter, "order", ["asc", "desc"]);
+    return {
+      coordinatorSession: requireString(filter, "coordinatorSession"),
+      ...status !== undefined ? { status } : {},
+      ...stuck !== undefined ? { stuck } : {},
+      ...sort !== undefined ? { sort } : {},
+      ...order !== undefined ? { order } : {}
+    };
+  }
+  parseCancelTaskInput(params) {
+    requireOnlyKeys(params, ["taskId", "sourceHandle", "coordinatorSession"], "params");
+    const sourceHandle = requireOptionalString(params, "sourceHandle");
+    const coordinatorSession = requireOptionalString(params, "coordinatorSession");
+    if (sourceHandle === undefined && coordinatorSession === undefined) {
+      throw new OrchestrationInvalidRequestError("task.cancel requires sourceHandle or coordinatorSession");
+    }
+    return {
+      taskId: requireString(params, "taskId"),
+      ...sourceHandle !== undefined ? { sourceHandle } : {},
+      ...coordinatorSession !== undefined ? { coordinatorSession } : {}
+    };
+  }
+  parseRecordWorkerReplyInput(params) {
+    requireOnlyKeys(params, ["taskId", "sourceHandle", "status", "summary", "resultText"], "params");
+    const status = requireOptionalEnum(params, "status", ["completed", "failed", "cancelled"]);
+    const summary = requireOptionalString(params, "summary");
+    const resultText = requireOptionalString(params, "resultText");
+    return {
+      taskId: requireString(params, "taskId"),
+      sourceHandle: requireString(params, "sourceHandle"),
+      ...status !== undefined ? { status } : {},
+      ...summary !== undefined ? { summary } : {},
+      ...resultText !== undefined ? { resultText } : {}
+    };
+  }
+  parseWaitTaskInput(params) {
+    requireOnlyKeys(params, ["coordinatorSession", "taskId", "timeoutMs", "pollIntervalMs"], "params");
+    const timeoutMs = requireOptionalIntegerInRange(params, "timeoutMs", 0, MAX_TASK_WAIT_TIMEOUT_MS);
+    const pollIntervalMs = requireOptionalIntegerInRange(params, "pollIntervalMs", 1, MAX_TASK_WAIT_POLL_INTERVAL_MS);
+    return {
+      coordinatorSession: requireString(params, "coordinatorSession"),
+      taskId: requireString(params, "taskId"),
+      ...timeoutMs !== undefined ? { timeoutMs } : {},
+      ...pollIntervalMs !== undefined ? { pollIntervalMs } : {}
+    };
+  }
   parseWorkerRaiseQuestionInput(params) {
+    requireOnlyKeys(params, ["taskId", "sourceHandle", "question", "whyBlocked", "whatIsNeeded"], "params");
     return {
       taskId: requireString(params, "taskId"),
       sourceHandle: requireString(params, "sourceHandle"),
@@ -15073,6 +15698,7 @@ class OrchestrationServer {
     };
   }
   parseGroupListFilter(params) {
+    requireOnlyKeys(params, ["coordinatorSession", "status", "stuck", "sort", "order"], "params");
     const status = requireOptionalEnum(params, "status", ["pending", "running", "terminal"]);
     const stuck = requireOptionalBoolean(params, "stuck");
     const sort = requireOptionalEnum(params, "sort", ["updatedAt", "createdAt"]);
@@ -15161,6 +15787,26 @@ function requireString(params, key) {
   }
   return value;
 }
+function requireOptionalNumber(params, key) {
+  const value = params[key];
+  if (value === undefined) {
+    return;
+  }
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    throw new OrchestrationInvalidRequestError(`${key} must be a finite number when provided`);
+  }
+  return value;
+}
+function requireOptionalIntegerInRange(params, key, min, max) {
+  const value = requireOptionalNumber(params, key);
+  if (value === undefined) {
+    return;
+  }
+  if (!Number.isInteger(value) || value < min || value > max) {
+    throw new OrchestrationInvalidRequestError(`${key} must be an integer between ${min} and ${max} when provided`);
+  }
+  return value;
+}
 function requireOptionalString(params, key) {
   const value = params[key];
   if (value === undefined) {
@@ -15208,6 +15854,14 @@ function requireOptionalObject(params, key) {
   }
   return value;
 }
+function requireOnlyKeys(params, allowed, label) {
+  const allowedSet = new Set(allowed);
+  for (const key of Object.keys(params)) {
+    if (!allowedSet.has(key)) {
+      throw new OrchestrationInvalidRequestError(`${label}.${key} is not supported`);
+    }
+  }
+}
 function requireTaskQuestions(params, key) {
   const value = params[key];
   if (!Array.isArray(value) || value.length === 0) {
@@ -15267,18 +15921,22 @@ function isServerNotRunningError(error2) {
 var OrchestrationInvalidRequestError, ORCHESTRATION_RPC_METHODS;
 var init_orchestration_server = __esm(() => {
   init_orchestration_ipc();
+  init_task_wait_timeouts();
   OrchestrationInvalidRequestError = class OrchestrationInvalidRequestError extends Error {
   };
   ORCHESTRATION_RPC_METHODS = new Set([
+    "coordinator.register_external",
     "delegate.request",
     "task.get",
     "task.list",
+    "task.wait",
     "task.approve",
     "task.reject",
     "task.cancel",
     "worker.reply",
     "worker.raise_question",
     "coordinator.answer_question",
+    "coordinator.retract_answer",
     "coordinator.request_human_input",
     "coordinator.follow_up_human_package",
     "coordinator.review_contested_result",
@@ -15289,24 +15947,6 @@ var init_orchestration_server = __esm(() => {
   ]);
 });
 
-// src/orchestration/async-mutex.ts
-class AsyncMutex {
-  tail = Promise.resolve();
-  async run(critical) {
-    const previous = this.tail;
-    let release;
-    this.tail = new Promise((resolve2) => {
-      release = resolve2;
-    });
-    await previous;
-    try {
-      return await critical();
-    } finally {
-      release();
-    }
-  }
-}
-
 // src/orchestration/progress-line-parser.ts
 class ProgressLineBuffer {
   feed(segment) {
@@ -15331,15 +15971,67 @@ function stripProgressLines(text) {
 var PROGRESS_PREFIX = "[PROGRESS]";
 
 // src/orchestration/orchestration-service.ts
+import { createHash as createHash2 } from "node:crypto";
+import { basename as basename3, isAbsolute, normalize } from "node:path";
+
 class OrchestrationService {
   deps;
-  stateMutex = new AsyncMutex;
+  stateMutex;
+  pendingWorkerSessions = new Map;
+  pendingLogicalTransportSessions = new Map;
   constructor(deps) {
     this.deps = deps;
+    this.stateMutex = deps.stateMutex ?? new AsyncMutex;
   }
   async mutate(critical) {
     return await this.stateMutex.run(critical);
   }
+  async registerExternalCoordinator(input) {
+    const coordinatorSession = input.coordinatorSession.trim();
+    const workspace = input.workspace?.trim();
+    const defaultTargetAgent = input.defaultTargetAgent?.trim();
+    if (!coordinatorSession) {
+      throw new Error("coordinatorSession must be a non-empty string");
+    }
+    if (workspace && !this.deps.config.workspaces[workspace]) {
+      throw new Error(`workspace "${workspace}" is not configured`);
+    }
+    return await this.mutate(async () => {
+      const state = await this.deps.loadState();
+      const externalCoordinators = this.ensureExternalCoordinators(state);
+      const existing = externalCoordinators[coordinatorSession];
+      if ((this.pendingWorkerSessions.get(coordinatorSession) ?? 0) > 0) {
+        throw new Error(`coordinatorSession "${coordinatorSession}" conflicts with an existing worker session`);
+      }
+      if (state.orchestration.workerBindings[coordinatorSession]) {
+        throw new Error(`coordinatorSession "${coordinatorSession}" conflicts with an existing worker session`);
+      }
+      if (this.hasActiveTaskWorkerSession(state, coordinatorSession)) {
+        throw new Error(`coordinatorSession "${coordinatorSession}" conflicts with an existing worker session`);
+      }
+      if ((this.pendingLogicalTransportSessions.get(coordinatorSession) ?? 0) > 0) {
+        throw new Error(`coordinatorSession "${coordinatorSession}" conflicts with an existing logical session`);
+      }
+      if (Object.values(state.sessions).some((session) => session.transport_session === coordinatorSession)) {
+        throw new Error(`coordinatorSession "${coordinatorSession}" conflicts with an existing logical session`);
+      }
+      if (existing?.workspace && workspace && existing.workspace !== workspace) {
+        throw new Error(`coordinatorSession "${coordinatorSession}" is already bound to workspace "${existing.workspace}"; use a new coordinator session for workspace "${workspace}"`);
+      }
+      const now = this.deps.now().toISOString();
+      const effectiveDefaultTargetAgent = defaultTargetAgent || existing?.defaultTargetAgent;
+      const record3 = {
+        coordinatorSession,
+        ...workspace ? { workspace } : existing?.workspace ? { workspace: existing.workspace } : {},
+        createdAt: existing?.createdAt ?? now,
+        updatedAt: now,
+        ...effectiveDefaultTargetAgent ? { defaultTargetAgent: effectiveDefaultTargetAgent } : {}
+      };
+      externalCoordinators[coordinatorSession] = record3;
+      await this.deps.saveState(state);
+      return { ...record3 };
+    });
+  }
   async createGroup(input) {
     if (input.coordinatorSession.trim().length === 0) {
       throw new Error("coordinatorSession must be a non-empty string");
@@ -15460,70 +16152,89 @@ class OrchestrationService {
     const normalizedGroupId = this.normalizeGroupId(input.groupId);
     const taskId = this.deps.createId();
     const workerSession = await this.resolveWorkerSession(input);
-    const ensuredWorkerSession = await this.deps.ensureWorkerSession({
-      workerSession,
-      sourceHandle: input.sourceHandle,
-      sourceKind: input.sourceKind,
-      coordinatorSession: input.coordinatorSession,
-      workspace: input.workspace,
-      targetAgent: input.targetAgent,
-      role
-    });
-    const 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,
+    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,
-        workerSession: ensuredWorkerSession,
-        workspace: input.workspace,
-        targetAgent: input.targetAgent,
-        ...role ? { role } : {},
-        ...normalizedGroupId ? { groupId: normalizedGroupId } : {},
-        task: input.task,
-        status: "running",
-        summary: "",
-        resultText: "",
-        createdAt: now,
-        updatedAt: now,
-        ...input.chatKey ? { chatKey: input.chatKey } : {},
-        ...input.replyContextToken ? { replyContextToken: input.replyContextToken } : {},
-        ...input.accountId ? { accountId: input.accountId } : {}
-      };
-      state.orchestration.tasks[taskId] = task;
-      if (normalizedGroupId) {
-        const group = this.ensureGroups(state)[normalizedGroupId];
-        group.updatedAt = now;
-        group.coordinatorInjectedAt = undefined;
-        group.injectionPending = undefined;
-        group.injectionAppliedAt = undefined;
-        group.lastInjectionError = undefined;
-      }
-      const previousBinding = state.orchestration.workerBindings[ensuredWorkerSession];
-      state.orchestration.workerBindings[ensuredWorkerSession] = {
-        sourceHandle: ensuredWorkerSession,
-        coordinatorSession: input.coordinatorSession,
         workspace: input.workspace,
+        ...input.cwd ? { cwd: input.cwd } : {},
         targetAgent: input.targetAgent,
         role
-      };
-      await this.deps.saveState(state);
-      return {
-        task: { ...task },
-        previousBinding
-      };
-    });
+      });
+      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,
+          ...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,
+          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) {
+      await releaseWorkerReservation();
+      throw error2;
+    }
+    await releaseWorkerReservation();
     try {
       await this.deps.dispatchWorkerTask({
         taskId,
         workerSession: ensuredWorkerSession,
         coordinatorSession: input.coordinatorSession,
         workspace: input.workspace,
+        ...input.cwd ? { cwd: input.cwd } : {},
         targetAgent: input.targetAgent,
         ...role ? { role } : {},
         task: input.task
@@ -15537,6 +16248,9 @@ class OrchestrationService {
         } else {
           delete state.orchestration.workerBindings[ensuredWorkerSession];
         }
+        if (prepared.normalizedGroupId && prepared.previousGroup) {
+          this.ensureGroups(state)[prepared.normalizedGroupId] = prepared.previousGroup;
+        }
         await this.deps.saveState(state);
       });
       throw error2;
@@ -15553,115 +16267,288 @@ class OrchestrationService {
     const preflight = await this.mutate(async () => {
       const state = await this.deps.loadState();
       const sourceContext = this.resolveRpcSourceContext(state, input.sourceHandle);
+      const targetLocation = this.resolveRpcTargetLocation(sourceContext, input.cwd);
       const role = this.normalizeRole(input.role);
       this.assertRpcRequestAllowed(state, sourceContext.sourceKind, sourceContext.coordinatorSession, input.targetAgent, role);
       const normalizedGroupId = this.normalizeGroupId(input.groupId);
       if (normalizedGroupId) {
         this.assertGroupOwnership(this.ensureGroups(state)[normalizedGroupId], normalizedGroupId, sourceContext.coordinatorSession);
       }
-      return { sourceContext, role, normalizedGroupId };
+      return { sourceContext, targetLocation, role, normalizedGroupId };
     });
     const autoRun = preflight.sourceContext.sourceKind === "coordinator";
     const workerSessionName = await this.resolveWorkerSession({
       sourceHandle: input.sourceHandle,
       sourceKind: preflight.sourceContext.sourceKind,
       coordinatorSession: preflight.sourceContext.coordinatorSession,
-      workspace: preflight.sourceContext.workspace,
+      workspace: preflight.targetLocation.workspace,
+      ...preflight.targetLocation.cwd ? { cwd: preflight.targetLocation.cwd } : {},
       targetAgent: input.targetAgent,
       task: input.task,
       ...preflight.role ? { role: preflight.role } : {}
     });
-    const ensuredWorkerSession = autoRun ? await this.deps.ensureWorkerSession({
-      workerSession: workerSessionName,
-      sourceHandle: input.sourceHandle,
-      sourceKind: preflight.sourceContext.sourceKind,
-      coordinatorSession: preflight.sourceContext.coordinatorSession,
-      workspace: preflight.sourceContext.workspace,
-      targetAgent: input.targetAgent,
-      role: preflight.role
-    }) : workerSessionName;
-    const prepared = await this.mutate(async () => {
-      const state = await this.deps.loadState();
-      const now = this.deps.now().toISOString();
-      const taskId = this.deps.createId();
-      const status = autoRun ? "running" : "needs_confirmation";
-      const task = {
-        taskId,
-        sourceHandle: input.sourceHandle,
-        sourceKind: preflight.sourceContext.sourceKind,
-        coordinatorSession: preflight.sourceContext.coordinatorSession,
-        workerSession: ensuredWorkerSession,
-        workspace: preflight.sourceContext.workspace,
-        targetAgent: input.targetAgent,
-        ...preflight.role ? { role: preflight.role } : {},
-        ...preflight.normalizedGroupId ? { groupId: preflight.normalizedGroupId } : {},
-        task: input.task,
-        status,
-        summary: "",
-        resultText: "",
-        createdAt: now,
-        updatedAt: now
-      };
-      state.orchestration.tasks[taskId] = task;
-      let previousGroup;
-      if (preflight.normalizedGroupId) {
-        const group = this.ensureGroups(state)[preflight.normalizedGroupId];
-        previousGroup = { ...group };
-        group.updatedAt = now;
-        group.coordinatorInjectedAt = undefined;
-        group.injectionPending = undefined;
-        group.injectionAppliedAt = undefined;
-        group.lastInjectionError = undefined;
-      }
-      let previousBinding;
-      if (autoRun) {
-        previousBinding = state.orchestration.workerBindings[ensuredWorkerSession];
-        state.orchestration.workerBindings[ensuredWorkerSession] = {
-          sourceHandle: ensuredWorkerSession,
+    const releaseWorkerReservation = await this.reserveProposedWorkerSession(workerSessionName);
+    let prepared;
+    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 taskId = this.deps.createId();
+        const status = autoRun ? "running" : "needs_confirmation";
+        const task = {
+          taskId,
+          sourceHandle: input.sourceHandle,
+          sourceKind: preflight.sourceContext.sourceKind,
           coordinatorSession: preflight.sourceContext.coordinatorSession,
-          workspace: preflight.sourceContext.workspace,
+          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
         };
-      }
-      await this.deps.saveState(state);
-      return { task: { ...task }, status, previousBinding, previousGroup, normalizedGroupId: preflight.normalizedGroupId };
-    });
+        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
+          };
+        } 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();
     if (autoRun) {
-      try {
-        await this.deps.dispatchWorkerTask({
-          taskId: prepared.task.taskId,
-          workerSession: ensuredWorkerSession,
-          coordinatorSession: prepared.task.coordinatorSession,
-          workspace: prepared.task.workspace,
-          targetAgent: prepared.task.targetAgent,
-          ...prepared.task.role ? { role: prepared.task.role } : {},
-          task: prepared.task.task
+      this.runAutoRunRpcWorkerTask({
+        task: prepared.task,
+        previousBinding: prepared.previousBinding
+      });
+    }
+    this.logEvent("orchestration.task.created", "delegated task created", this.taskContext(prepared.task));
+    return {
+      taskId: prepared.task.taskId,
+      status: prepared.status,
+      ...autoRun ? { workerSession: workerSessionName } : {}
+    };
+  }
+  async runAutoRunRpcWorkerTask(input) {
+    const { task } = input;
+    try {
+      const ensuredWorkerSession = await this.ensureReservedWorkerSession({
+        workerSession: task.workerSession,
+        sourceHandle: task.sourceHandle,
+        sourceKind: task.sourceKind,
+        coordinatorSession: task.coordinatorSession,
+        workspace: task.workspace,
+        ...task.cwd ? { cwd: task.cwd } : {},
+        targetAgent: task.targetAgent,
+        ...task.role ? { role: task.role } : {}
+      });
+      const startupAction = await this.mutate(async () => {
+        const state = await this.deps.loadState();
+        const current = state.orchestration.tasks[task.taskId];
+        if (current?.workerSession === ensuredWorkerSession && current.status === "running" && current.cancelRequestedAt !== undefined) {
+          return "completeCancellation";
+        }
+        return current !== undefined && current.workerSession === ensuredWorkerSession && current.status === "running" ? "dispatch" : "skip";
+      });
+      if (startupAction === "completeCancellation") {
+        const completed = await this.completeAutoRunStartupCancellation({
+          task,
+          previousBinding: input.previousBinding
         });
-      } catch (error2) {
-        await this.mutate(async () => {
-          const state = await this.deps.loadState();
-          delete state.orchestration.tasks[prepared.task.taskId];
-          if (prepared.previousBinding) {
-            state.orchestration.workerBindings[ensuredWorkerSession] = prepared.previousBinding;
-          } else {
-            delete state.orchestration.workerBindings[ensuredWorkerSession];
+        if (completed) {
+          this.logEvent("orchestration.task.cancel_completed", "task cancellation completed", {
+            ...this.taskContext(task),
+            status: "cancelled"
+          });
+        }
+        return;
+      }
+      if (startupAction !== "dispatch") {
+        await this.cleanupAutoRunStartupBinding({
+          task,
+          previousBinding: input.previousBinding
+        });
+        return;
+      }
+      const preDispatchAction = await this.mutate(async () => {
+        const state = await this.deps.loadState();
+        const current = state.orchestration.tasks[task.taskId];
+        if (current?.workerSession === ensuredWorkerSession && current.status === "running" && current.cancelRequestedAt !== undefined) {
+          return "completeCancellation";
+        }
+        return current !== undefined && current.workerSession === ensuredWorkerSession && current.status === "running" ? "dispatch" : "skip";
+      });
+      if (preDispatchAction === "completeCancellation") {
+        const completed = await this.completeAutoRunStartupCancellation({
+          task,
+          previousBinding: input.previousBinding
+        });
+        if (completed) {
+          this.logEvent("orchestration.task.cancel_completed", "task cancellation completed", {
+            ...this.taskContext(task),
+            status: "cancelled"
+          });
+        }
+        return;
+      }
+      if (preDispatchAction !== "dispatch") {
+        await this.cleanupAutoRunStartupBinding({
+          task,
+          previousBinding: input.previousBinding
+        });
+        return;
+      }
+      await this.deps.dispatchWorkerTask({
+        taskId: task.taskId,
+        workerSession: ensuredWorkerSession,
+        coordinatorSession: task.coordinatorSession,
+        workspace: task.workspace,
+        ...task.cwd ? { cwd: task.cwd } : {},
+        targetAgent: task.targetAgent,
+        ...task.role ? { role: task.role } : {},
+        task: task.task
+      });
+    } catch (error2) {
+      const message = error2 instanceof Error ? error2.message : String(error2);
+      const completedCancellation = await this.completeAutoRunStartupCancellation({
+        task,
+        previousBinding: input.previousBinding
+      });
+      if (completedCancellation) {
+        this.logEvent("orchestration.task.cancel_completed", "task cancellation completed", {
+          ...this.taskContext(task),
+          status: "cancelled"
+        });
+        return;
+      }
+      const taskMarkedFailed = await this.mutate(async () => {
+        const state = await this.deps.loadState();
+        const current = state.orchestration.tasks[task.taskId];
+        const workerSession = task.workerSession;
+        const taskStillOwnsWorkerSession = current?.workerSession === workerSession;
+        const currentBinding = state.orchestration.workerBindings[workerSession];
+        const bindingStillBelongsToThisStartup = currentBinding?.sourceHandle === workerSession && currentBinding.coordinatorSession === task.coordinatorSession && currentBinding.workspace === task.workspace && currentBinding.cwd === task.cwd && currentBinding.targetAgent === task.targetAgent && currentBinding.role === task.role;
+        const otherActiveOwner = Object.values(state.orchestration.tasks).some((candidate) => candidate.taskId !== task.taskId && candidate.workerSession === workerSession && (!this.isTerminalStatus(candidate.status) || candidate.reviewPending !== undefined));
+        const restoreOrDeleteBinding = () => {
+          if (!bindingStillBelongsToThisStartup || otherActiveOwner) {
+            return;
           }
-          if (prepared.normalizedGroupId && prepared.previousGroup) {
-            const groups = state.orchestration.groups ?? {};
-            groups[prepared.normalizedGroupId] = prepared.previousGroup;
+          if (input.previousBinding) {
+            state.orchestration.workerBindings[workerSession] = input.previousBinding;
+          } else {
+            delete state.orchestration.workerBindings[workerSession];
           }
+        };
+        if (current && taskStillOwnsWorkerSession && current.status === "cancelled") {
+          restoreOrDeleteBinding();
           await this.deps.saveState(state);
+          return false;
+        }
+        if (current && taskStillOwnsWorkerSession && current.cancelRequestedAt === undefined && !this.isTerminalStatus(current.status)) {
+          const now = this.deps.now().toISOString();
+          current.status = "failed";
+          current.summary = message;
+          current.resultText = "";
+          current.updatedAt = now;
+          restoreOrDeleteBinding();
+          await this.deps.saveState(state);
+          return true;
+        }
+        await this.deps.saveState(state);
+        return false;
+      });
+      if (taskMarkedFailed) {
+        this.logEvent("orchestration.task.failed", "task failed", {
+          ...this.taskContext(task),
+          error: message
         });
-        throw error2;
       }
     }
-    this.logEvent("orchestration.task.created", "delegated task created", this.taskContext(prepared.task));
-    return {
-      taskId: prepared.task.taskId,
-      status: prepared.status,
-      ...autoRun ? { workerSession: ensuredWorkerSession } : {}
-    };
+  }
+  async completeAutoRunStartupCancellation(input) {
+    const { task } = input;
+    return await this.mutate(async () => {
+      const state = await this.deps.loadState();
+      const workerSession = task.workerSession;
+      const current = state.orchestration.tasks[task.taskId];
+      if (!current || current.workerSession !== workerSession || current.status !== "running" || current.cancelRequestedAt === undefined) {
+        return false;
+      }
+      const now = this.deps.now().toISOString();
+      current.status = "cancelled";
+      current.cancelCompletedAt = now;
+      current.lastCancelError = undefined;
+      current.updatedAt = now;
+      this.bumpGroupUpdated(state, current.groupId, now);
+      const currentBinding = state.orchestration.workerBindings[workerSession];
+      const bindingStillBelongsToThisStartup = currentBinding?.sourceHandle === workerSession && currentBinding.coordinatorSession === task.coordinatorSession && currentBinding.workspace === task.workspace && currentBinding.cwd === task.cwd && currentBinding.targetAgent === task.targetAgent && currentBinding.role === task.role;
+      const otherActiveOwner = Object.values(state.orchestration.tasks).some((candidate) => candidate.taskId !== task.taskId && candidate.workerSession === workerSession && (!this.isTerminalStatus(candidate.status) || candidate.reviewPending !== undefined));
+      if (bindingStillBelongsToThisStartup && !otherActiveOwner) {
+        if (input.previousBinding) {
+          state.orchestration.workerBindings[workerSession] = input.previousBinding;
+        } else {
+          delete state.orchestration.workerBindings[workerSession];
+        }
+      }
+      await this.deps.saveState(state);
+      return true;
+    });
+  }
+  async cleanupAutoRunStartupBinding(input) {
+    const { task } = input;
+    return await this.mutate(async () => {
+      const state = await this.deps.loadState();
+      const workerSession = task.workerSession;
+      const currentBinding = state.orchestration.workerBindings[workerSession];
+      const bindingStillBelongsToThisStartup = currentBinding?.sourceHandle === workerSession && currentBinding.coordinatorSession === task.coordinatorSession && currentBinding.workspace === task.workspace && currentBinding.cwd === task.cwd && currentBinding.targetAgent === task.targetAgent && currentBinding.role === task.role;
+      if (!bindingStillBelongsToThisStartup) {
+        return false;
+      }
+      const otherActiveOwner = Object.values(state.orchestration.tasks).some((candidate) => candidate.taskId !== task.taskId && candidate.workerSession === workerSession && (!this.isTerminalStatus(candidate.status) || candidate.reviewPending !== undefined));
+      if (otherActiveOwner) {
+        return false;
+      }
+      if (input.previousBinding) {
+        state.orchestration.workerBindings[workerSession] = input.previousBinding;
+      } else {
+        delete state.orchestration.workerBindings[workerSession];
+      }
+      await this.deps.saveState(state);
+      return true;
+    });
   }
   async recordWorkerReply(input) {
     const task = await this.mutate(async () => {
@@ -15689,9 +16576,15 @@ class OrchestrationService {
       task2.summary = input.summary ?? "";
       task2.resultText = stripProgressLines(input.resultText ?? "");
       if (task2.status === "completed" || task2.status === "failed") {
-        task2.injectionPending = true;
-        task2.injectionAppliedAt = undefined;
-        task2.lastInjectionError = undefined;
+        if (!this.isExternalCoordinatorSession(state, task2.coordinatorSession)) {
+          task2.injectionPending = true;
+          task2.injectionAppliedAt = undefined;
+          task2.lastInjectionError = undefined;
+        } else {
+          task2.injectionPending = undefined;
+          task2.injectionAppliedAt = undefined;
+          task2.lastInjectionError = undefined;
+        }
         if (!isContestedResult && task2.chatKey && task2.replyContextToken) {
           task2.noticePending = true;
           task2.noticeSentAt = undefined;
@@ -15794,6 +16687,30 @@ class OrchestrationService {
     const task = state.orchestration.tasks[taskId];
     return task ? { ...task } : null;
   }
+  async waitTask(input) {
+    const timeoutMs = clampWaitTimeout(input.timeoutMs);
+    const pollIntervalMs = clampPollInterval(input.pollIntervalMs);
+    const deadline = Date.now() + timeoutMs;
+    while (true) {
+      const state = await this.deps.loadState();
+      const task = state.orchestration.tasks[input.taskId];
+      if (!task || task.coordinatorSession !== input.coordinatorSession) {
+        return { status: "not_found", task: null };
+      }
+      const snapshot = { ...task };
+      if (isTerminalTaskStatus2(task.status) && task.reviewPending === undefined) {
+        return { status: "terminal", task: snapshot };
+      }
+      if (isAttentionRequiredTask(task)) {
+        return { status: "attention_required", task: snapshot };
+      }
+      const remainingMs = deadline - Date.now();
+      if (remainingMs <= 0) {
+        return { status: "timeout", task: snapshot };
+      }
+      await sleep2(Math.min(pollIntervalMs, remainingMs));
+    }
+  }
   async recordCoordinatorRouteContext(input) {
     if (input.coordinatorSession.trim().length === 0) {
       throw new Error("coordinatorSession must be a non-empty string");
@@ -15878,13 +16795,16 @@ class OrchestrationService {
       return {
         taskId: task.taskId,
         questionId,
-        coordinatorSession: task.coordinatorSession
+        coordinatorSession: task.coordinatorSession,
+        externalCoordinator: this.isExternalCoordinatorSession(state, task.coordinatorSession)
       };
     });
     try {
-      await this.deps.wakeCoordinatorSession?.({
-        coordinatorSession: prepared.coordinatorSession
-      });
+      if (!prepared.externalCoordinator) {
+        await this.deps.wakeCoordinatorSession?.({
+          coordinatorSession: prepared.coordinatorSession
+        });
+      }
     } catch (error2) {
       await this.recordOpenQuestionWakeError(prepared.taskId, prepared.questionId, error2 instanceof Error ? error2.message : String(error2));
     }
@@ -15941,6 +16861,7 @@ class OrchestrationService {
         workerSession: prepared.task.workerSession,
         coordinatorSession: prepared.task.coordinatorSession,
         workspace: prepared.task.workspace,
+        ...prepared.task.cwd ? { cwd: prepared.task.cwd } : {},
         targetAgent: prepared.task.targetAgent,
         answer
       });
@@ -16026,6 +16947,9 @@ class OrchestrationService {
     }
     const prepared = await this.mutate(async () => {
       const state = await this.deps.loadState();
+      if (this.isExternalCoordinatorSession(state, input.coordinatorSession)) {
+        throw new Error("human input routing is not configured for external coordinator");
+      }
       const coordinatorState = this.ensureCoordinatorQuestionState(state, input.coordinatorSession);
       if (input.expectedActivePackageId !== undefined && coordinatorState.activePackageId !== input.expectedActivePackageId) {
         throw new Error(`coordinator "${input.coordinatorSession}" active package is "${coordinatorState.activePackageId ?? ""}", not "${input.expectedActivePackageId}"`);
@@ -16137,6 +17061,9 @@ class OrchestrationService {
     }
     const prepared = await this.mutate(async () => {
       const state = await this.deps.loadState();
+      if (this.isExternalCoordinatorSession(state, input.coordinatorSession)) {
+        throw new Error("human input routing is not configured for external coordinator");
+      }
       const coordinatorState = this.ensureCoordinatorQuestionState(state, input.coordinatorSession);
       if (coordinatorState.activePackageId !== input.packageId) {
         throw new Error(`package "${input.packageId}" is not the active package for coordinator "${input.coordinatorSession}"`);
@@ -16205,6 +17132,9 @@ class OrchestrationService {
   async retryHumanQuestionPackageDelivery(input) {
     const prepared = await this.mutate(async () => {
       const state = await this.deps.loadState();
+      if (this.isExternalCoordinatorSession(state, input.coordinatorSession)) {
+        throw new Error("human input routing is not configured for external coordinator");
+      }
       const coordinatorState = this.ensureCoordinatorQuestionState(state, input.coordinatorSession);
       if (coordinatorState.activePackageId !== input.packageId) {
         throw new Error(`package "${input.packageId}" is not the active package for coordinator "${input.coordinatorSession}"`);
@@ -16253,6 +17183,9 @@ class OrchestrationService {
   async claimActiveHumanReply(input) {
     return await this.mutate(async () => {
       const state = await this.deps.loadState();
+      if (this.isExternalCoordinatorSession(state, input.coordinatorSession)) {
+        return null;
+      }
       const coordinatorState = this.ensureCoordinatorQuestionState(state, input.coordinatorSession);
       if (!coordinatorState.activePackageId || coordinatorState.activePackageId !== input.packageId) {
         return null;
@@ -16291,6 +17224,9 @@ class OrchestrationService {
   }
   async getActiveHumanQuestionPackage(coordinatorSession) {
     const state = await this.deps.loadState();
+    if (this.isExternalCoordinatorSession(state, coordinatorSession)) {
+      return null;
+    }
     const coordinatorState = state.orchestration.coordinatorQuestionState[coordinatorSession];
     const activePackageId = coordinatorState?.activePackageId;
     if (!activePackageId) {
@@ -16368,10 +17304,11 @@ class OrchestrationService {
       await this.deps.saveState(state);
       return {
         task: { ...task },
-        replacementQuestionId
+        replacementQuestionId,
+        externalCoordinator: this.isExternalCoordinatorSession(state, task.coordinatorSession)
       };
     });
-    if (prepared.replacementQuestionId) {
+    if (prepared.replacementQuestionId && !prepared.externalCoordinator) {
       try {
         await this.deps.wakeCoordinatorSession?.({
           coordinatorSession: prepared.task.coordinatorSession
@@ -16478,20 +17415,32 @@ class OrchestrationService {
   }
   async listPendingCoordinatorResults(coordinatorSession) {
     const state = await this.deps.loadState();
+    if (this.isExternalCoordinatorSession(state, coordinatorSession)) {
+      return [];
+    }
     return Object.values(state.orchestration.tasks).filter((task) => task.coordinatorSession === coordinatorSession && this.canInjectTaskIntoCoordinator(state, task) && (task.injectionPending === true || task.coordinatorInjectedAt === undefined)).sort((left, right) => left.updatedAt.localeCompare(right.updatedAt)).map((task) => ({ ...task }));
   }
   async listPendingCoordinatorBlockers(coordinatorSession) {
     const state = await this.deps.loadState();
+    if (this.isExternalCoordinatorSession(state, coordinatorSession)) {
+      return [];
+    }
     const coordinatorState = state.orchestration.coordinatorQuestionState[coordinatorSession];
     const hiddenQueuedQuestionKeys = coordinatorState?.activePackageId ? new Set((coordinatorState.queuedQuestions ?? []).map((entry) => `${entry.taskId}:${entry.questionId}`)) : null;
     return Object.values(state.orchestration.tasks).filter((task) => task.coordinatorSession === coordinatorSession && task.status === "blocked" && task.openQuestion?.status === "open" && !hiddenQueuedQuestionKeys?.has(`${task.taskId}:${task.openQuestion.questionId}`)).sort((left, right) => left.updatedAt.localeCompare(right.updatedAt)).map((task) => ({ ...task }));
   }
   async listContestedCoordinatorResults(coordinatorSession) {
     const state = await this.deps.loadState();
+    if (this.isExternalCoordinatorSession(state, coordinatorSession)) {
+      return [];
+    }
     return Object.values(state.orchestration.tasks).filter((task) => task.coordinatorSession === coordinatorSession && task.reviewPending !== undefined).sort((left, right) => left.updatedAt.localeCompare(right.updatedAt)).map((task) => ({ ...task }));
   }
   async listPendingCoordinatorGroups(coordinatorSession) {
     const state = await this.deps.loadState();
+    if (this.isExternalCoordinatorSession(state, coordinatorSession)) {
+      return [];
+    }
     const groups = this.ensureGroups(state);
     const tasks = Object.values(state.orchestration.tasks);
     return Object.values(groups).filter((group) => group.coordinatorSession === coordinatorSession).filter((group) => {
@@ -16758,19 +17707,25 @@ class OrchestrationService {
       task.updatedAt = now;
       this.bumpGroupUpdated(state, task.groupId, now);
       await this.deps.saveState(state);
-      return { task: { ...task }, replacementQuestionId };
+      return {
+        task: { ...task },
+        replacementQuestionId,
+        externalCoordinator: this.isExternalCoordinatorSession(state, task.coordinatorSession)
+      };
     });
     if (prepared.replacementQuestionId) {
       this.logEvent("orchestration.task.correction_reopened", "task correction reopened blocker", {
         ...this.taskContext(prepared.task),
         replacement_question_id: prepared.replacementQuestionId
       });
-      try {
-        await this.deps.wakeCoordinatorSession?.({
-          coordinatorSession: prepared.task.coordinatorSession
-        });
-      } catch (error2) {
-        await this.recordOpenQuestionWakeError(prepared.task.taskId, prepared.replacementQuestionId, error2 instanceof Error ? error2.message : String(error2));
+      if (!prepared.externalCoordinator) {
+        try {
+          await this.deps.wakeCoordinatorSession?.({
+            coordinatorSession: prepared.task.coordinatorSession
+          });
+        } catch (error2) {
+          await this.recordOpenQuestionWakeError(prepared.task.taskId, prepared.replacementQuestionId, error2 instanceof Error ? error2.message : String(error2));
+        }
       }
       return prepared.task;
     }
@@ -16810,54 +17765,71 @@ class OrchestrationService {
       sourceKind: currentTask.sourceKind,
       coordinatorSession: currentTask.coordinatorSession,
       workspace: currentTask.workspace,
+      ...currentTask.cwd ? { cwd: currentTask.cwd } : {},
       targetAgent: currentTask.targetAgent,
       task: currentTask.task,
       ...currentTask.role ? { role: currentTask.role } : {}
     });
-    const ensuredWorkerSession = await this.deps.ensureWorkerSession({
-      workerSession,
-      sourceHandle: currentTask.sourceHandle,
-      sourceKind: currentTask.sourceKind,
-      coordinatorSession: currentTask.coordinatorSession,
-      workspace: currentTask.workspace,
-      targetAgent: currentTask.targetAgent,
-      role: currentTask.role
-    });
-    const prepared = 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);
-      const previousStatus = task.status;
-      const previousUpdatedAt = task.updatedAt;
-      const previousBinding = state.orchestration.workerBindings[ensuredWorkerSession];
-      task.workerSession = ensuredWorkerSession;
-      task.status = "running";
-      task.updatedAt = this.deps.now().toISOString();
-      state.orchestration.workerBindings[ensuredWorkerSession] = {
-        sourceHandle: ensuredWorkerSession,
-        coordinatorSession: task.coordinatorSession,
-        workspace: task.workspace,
-        targetAgent: task.targetAgent,
-        role: task.role
-      };
-      await this.deps.saveState(state);
-      return {
-        task: { ...task },
-        previousStatus,
-        previousUpdatedAt,
-        previousBinding
-      };
-    });
+    const releaseWorkerReservation = await this.reserveProposedWorkerSession(workerSession, input.taskId);
+    let ensuredWorkerSession = workerSession;
+    let prepared;
+    try {
+      ensuredWorkerSession = await this.ensureReservedWorkerSession({
+        workerSession,
+        sourceHandle: currentTask.sourceHandle,
+        sourceKind: currentTask.sourceKind,
+        coordinatorSession: currentTask.coordinatorSession,
+        workspace: currentTask.workspace,
+        ...currentTask.cwd ? { cwd: currentTask.cwd } : {},
+        targetAgent: currentTask.targetAgent,
+        role: currentTask.role
+      });
+      prepared = 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);
+        const previousStatus = task.status;
+        const previousUpdatedAt = task.updatedAt;
+        const previousWorkerSession = task.workerSession;
+        const previousBinding = state.orchestration.workerBindings[ensuredWorkerSession];
+        this.assertWorkerSessionDoesNotConflictExternalCoordinator(state, ensuredWorkerSession);
+        this.assertWorkerSessionAvailable(state, ensuredWorkerSession, input.taskId, { allowCurrentReservation: true });
+        task.workerSession = ensuredWorkerSession;
+        task.status = "running";
+        task.updatedAt = this.deps.now().toISOString();
+        state.orchestration.workerBindings[ensuredWorkerSession] = {
+          sourceHandle: ensuredWorkerSession,
+          coordinatorSession: task.coordinatorSession,
+          workspace: task.workspace,
+          ...task.cwd ? { cwd: task.cwd } : {},
+          targetAgent: task.targetAgent,
+          role: task.role
+        };
+        await this.deps.saveState(state);
+        return {
+          task: { ...task },
+          previousStatus,
+          previousUpdatedAt,
+          previousWorkerSession,
+          previousBinding
+        };
+      });
+    } catch (error2) {
+      await releaseWorkerReservation();
+      throw error2;
+    }
+    await releaseWorkerReservation();
     try {
       await this.deps.dispatchWorkerTask({
         taskId: prepared.task.taskId,
         workerSession: ensuredWorkerSession,
         coordinatorSession: prepared.task.coordinatorSession,
         workspace: prepared.task.workspace,
+        ...prepared.task.cwd ? { cwd: prepared.task.cwd } : {},
         targetAgent: prepared.task.targetAgent,
         ...prepared.task.role ? { role: prepared.task.role } : {},
         task: prepared.task.task
@@ -16869,6 +17841,11 @@ class OrchestrationService {
         if (task) {
           task.status = prepared.previousStatus;
           task.updatedAt = prepared.previousUpdatedAt;
+          if (prepared.previousWorkerSession === undefined) {
+            delete task.workerSession;
+          } else {
+            task.workerSession = prepared.previousWorkerSession;
+          }
         }
         if (prepared.previousBinding) {
           state.orchestration.workerBindings[ensuredWorkerSession] = prepared.previousBinding;
@@ -16907,13 +17884,68 @@ class OrchestrationService {
       sourceKind: input.sourceKind,
       coordinatorSession: input.coordinatorSession,
       workspace: input.workspace,
+      ...input.cwd ? { cwd: input.cwd } : {},
       targetAgent: input.targetAgent,
       role
     });
     if (reusable && reusable.trim().length > 0) {
       return reusable.trim();
     }
-    return [input.workspace, input.targetAgent, role, input.coordinatorSession].filter((part) => typeof part === "string" && part.trim().length > 0).map((part) => part.trim()).join(":");
+    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(":");
+  }
+  async reserveProposedWorkerSession(workerSession, excludingTaskId) {
+    await this.mutate(async () => {
+      const state = await this.deps.loadState();
+      this.assertWorkerSessionDoesNotConflictExternalCoordinator(state, workerSession);
+      this.assertWorkerSessionAvailable(state, workerSession, excludingTaskId);
+      this.pendingWorkerSessions.set(workerSession, (this.pendingWorkerSessions.get(workerSession) ?? 0) + 1);
+    });
+    let released = false;
+    return async () => {
+      if (released) {
+        return;
+      }
+      released = true;
+      await this.mutate(async () => {
+        const count = this.pendingWorkerSessions.get(workerSession) ?? 0;
+        if (count <= 1) {
+          this.pendingWorkerSessions.delete(workerSession);
+        } else {
+          this.pendingWorkerSessions.set(workerSession, count - 1);
+        }
+      });
+    };
+  }
+  async ensureReservedWorkerSession(request) {
+    const ensuredWorkerSession = await this.deps.ensureWorkerSession(request);
+    if (ensuredWorkerSession !== request.workerSession) {
+      throw new Error(`ensureWorkerSession returned "${ensuredWorkerSession}", expected "${request.workerSession}"`);
+    }
+    return ensuredWorkerSession;
+  }
+  async reserveLogicalTransportSession(transportSession) {
+    await this.mutate(async () => {
+      const state = await this.deps.loadState();
+      if (this.isExternalCoordinatorSession(state, transportSession)) {
+        throw new Error(`transport session "${transportSession}" conflicts with an external coordinator`);
+      }
+      this.pendingLogicalTransportSessions.set(transportSession, (this.pendingLogicalTransportSessions.get(transportSession) ?? 0) + 1);
+    });
+    let released = false;
+    return async () => {
+      if (released) {
+        return;
+      }
+      released = true;
+      await this.mutate(async () => {
+        const count = this.pendingLogicalTransportSessions.get(transportSession) ?? 0;
+        if (count <= 1) {
+          this.pendingLogicalTransportSessions.delete(transportSession);
+        } else {
+          this.pendingLogicalTransportSessions.set(transportSession, count - 1);
+        }
+      });
+    };
   }
   buildGroupSummary(group, tasks) {
     const sortedTasks = tasks.slice().sort((left, right) => left.createdAt.localeCompare(right.createdAt)).map((task) => ({ ...task }));
@@ -16939,6 +17971,9 @@ class OrchestrationService {
     if (!group) {
       return false;
     }
+    if (this.isExternalCoordinatorSession(state, group.coordinatorSession)) {
+      return false;
+    }
     if (groupTasks.length === 0) {
       return false;
     }
@@ -16951,6 +17986,9 @@ class OrchestrationService {
     return groupTasks.every((task) => task.status === "completed" || task.status === "failed");
   }
   canInjectTaskIntoCoordinator(state, task) {
+    if (this.isExternalCoordinatorSession(state, task.coordinatorSession)) {
+      return false;
+    }
     if (task.status !== "completed" && task.status !== "failed" || task.reviewPending !== undefined) {
       return false;
     }
@@ -16965,7 +18003,8 @@ class OrchestrationService {
       return {
         sourceKind: "worker",
         coordinatorSession: binding.coordinatorSession,
-        workspace: binding.workspace
+        workspace: binding.workspace,
+        ...binding.cwd ? { cwd: binding.cwd } : {}
       };
     }
     const coordinatorSession = Object.values(state.sessions).find((session) => session.transport_session === sourceHandle);
@@ -16976,8 +18015,29 @@ class OrchestrationService {
         workspace: coordinatorSession.workspace
       };
     }
+    const externalCoordinator = this.ensureExternalCoordinators(state)[sourceHandle];
+    if (externalCoordinator) {
+      return {
+        sourceKind: "coordinator",
+        coordinatorSession: externalCoordinator.coordinatorSession,
+        ...externalCoordinator.workspace ? { workspace: externalCoordinator.workspace } : {}
+      };
+    }
     throw new Error(`sourceHandle "${sourceHandle}" is not a registered coordinator or worker session`);
   }
+  resolveRpcTargetLocation(sourceContext, rawCwd) {
+    const cwd = rawCwd !== undefined ? this.normalizeWorkingDirectory(rawCwd) : sourceContext.cwd;
+    if (cwd) {
+      return {
+        workspace: sourceContext.workspace ?? this.workspaceLabelFromCwd(cwd),
+        cwd
+      };
+    }
+    if (sourceContext.workspace) {
+      return { workspace: sourceContext.workspace };
+    }
+    throw new Error("workingDirectory is required when the external coordinator has no default workspace");
+  }
   assertRpcRequestAllowed(state, sourceKind, coordinatorSession, targetAgent, role) {
     const policy = this.deps.config.orchestration;
     if (sourceKind === "worker" && !policy.allowWorkerChainedRequests) {
@@ -17022,6 +18082,25 @@ class OrchestrationService {
       throw new Error("task must be a non-empty string");
     }
   }
+  normalizeWorkingDirectory(cwd) {
+    const normalized = normalize(cwd.trim());
+    if (normalized.length === 0 || normalized === ".") {
+      throw new Error("workingDirectory must be a non-empty absolute path");
+    }
+    if (!isAbsolute(normalized)) {
+      throw new Error("workingDirectory must be an absolute path");
+    }
+    return normalized;
+  }
+  workspaceLabelFromCwd(cwd) {
+    const base = basename3(cwd).trim() || "cwd";
+    return base.replace(/[^a-zA-Z0-9._-]+/g, "_") || "cwd";
+  }
+  cwdWorkerSessionPart(cwd) {
+    const label = this.workspaceLabelFromCwd(cwd);
+    const hash = createHash2("sha256").update(cwd).digest("hex").slice(0, 8);
+    return `${label}-${hash}`;
+  }
   normalizeRole(role) {
     const normalized = role?.trim();
     return normalized && normalized.length > 0 ? normalized : undefined;
@@ -17114,6 +18193,37 @@ class OrchestrationService {
     }
     return state.orchestration.coordinatorRoutes;
   }
+  isExternalCoordinatorSession(state, coordinatorSession) {
+    return this.ensureExternalCoordinators(state)[coordinatorSession] !== undefined;
+  }
+  assertWorkerSessionDoesNotConflictExternalCoordinator(state, workerSession) {
+    if (this.isExternalCoordinatorSession(state, workerSession)) {
+      throw new Error(`worker session "${workerSession}" conflicts with an external coordinator`);
+    }
+  }
+  assertWorkerSessionAvailable(state, workerSession, excludingTaskId, options = {}) {
+    const pendingCount = this.pendingWorkerSessions.get(workerSession) ?? 0;
+    const allowedPendingCount = options.allowCurrentReservation ? 1 : 0;
+    if (pendingCount > allowedPendingCount) {
+      throw new Error(`worker session "${workerSession}" is already in use`);
+    }
+    if (this.hasActiveTaskWorkerSession(state, workerSession, excludingTaskId)) {
+      throw new Error(`worker session "${workerSession}" is already in use`);
+    }
+  }
+  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));
+  }
+  async assertProposedWorkerSessionDoesNotConflictExternalCoordinator(workerSession) {
+    const state = await this.deps.loadState();
+    this.assertWorkerSessionDoesNotConflictExternalCoordinator(state, workerSession);
+  }
+  ensureExternalCoordinators(state) {
+    if (!("externalCoordinators" in state.orchestration) || !state.orchestration.externalCoordinators) {
+      state.orchestration.externalCoordinators = {};
+    }
+    return state.orchestration.externalCoordinators;
+  }
   ensureGroups(state) {
     if (!("groups" in state.orchestration) || !state.orchestration.groups) {
       state.orchestration.groups = {};
@@ -17324,11 +18434,11 @@ class OrchestrationService {
     });
   }
   async handoffQueuedQuestions(coordinatorSession, closedPackageId) {
-    const queuedQuestions = await this.mutate(async () => {
+    const prepared = await this.mutate(async () => {
       const state = await this.deps.loadState();
       const coordinatorState = this.ensureCoordinatorQuestionState(state, coordinatorSession);
       if (coordinatorState.activePackageId === closedPackageId) {
-        return [];
+        return { externalCoordinator: this.isExternalCoordinatorSession(state, coordinatorSession), queuedQuestions: [] };
       }
       const validQueuedQuestions = coordinatorState.queuedQuestions.filter((entry) => {
         const task = state.orchestration.tasks[entry.taskId];
@@ -17338,9 +18448,12 @@ class OrchestrationService {
         coordinatorState.queuedQuestions = validQueuedQuestions;
         await this.deps.saveState(state);
       }
-      return validQueuedQuestions;
+      return {
+        externalCoordinator: this.isExternalCoordinatorSession(state, coordinatorSession),
+        queuedQuestions: validQueuedQuestions
+      };
     });
-    if (queuedQuestions.length === 0) {
+    if (prepared.queuedQuestions.length === 0 || prepared.externalCoordinator) {
       return;
     }
     try {
@@ -17350,12 +18463,12 @@ class OrchestrationService {
       await this.mutate(async () => {
         const state = await this.deps.loadState();
         const coordinatorState = this.ensureCoordinatorQuestionState(state, coordinatorSession);
-        coordinatorState.queuedQuestions = coordinatorState.queuedQuestions.filter((entry) => !queuedQuestions.some((queued) => queued.taskId === entry.taskId && queued.questionId === entry.questionId));
+        coordinatorState.queuedQuestions = coordinatorState.queuedQuestions.filter((entry) => !prepared.queuedQuestions.some((queued) => queued.taskId === entry.taskId && queued.questionId === entry.questionId));
         await this.deps.saveState(state);
       });
     } catch (error2) {
       const errorMessage = error2 instanceof Error ? error2.message : String(error2);
-      await Promise.all(queuedQuestions.map(async ({ taskId, questionId }) => {
+      await Promise.all(prepared.queuedQuestions.map(async ({ taskId, questionId }) => {
         const state = await this.deps.loadState();
         const task = state.orchestration.tasks[taskId];
         if (!task?.openQuestion || task.openQuestion.status !== "open" || task.openQuestion.questionId !== questionId) {
@@ -17581,6 +18694,7 @@ class OrchestrationService {
           taskId: task.taskId,
           workerSession: freshTask.workerSession,
           workspace: freshTask.workspace,
+          ...freshTask.cwd ? { cwd: freshTask.cwd } : {},
           targetAgent: freshTask.targetAgent
         });
         await this.completeTaskCancellation(task.taskId);
@@ -17590,11 +18704,39 @@ class OrchestrationService {
     })();
   }
 }
+function isTerminalTaskStatus2(status) {
+  return status === "completed" || status === "failed" || status === "cancelled";
+}
+function isAttentionRequiredTask(task) {
+  return task.reviewPending !== undefined || task.status === "pending" || task.status === "needs_confirmation" || task.status === "blocked" || task.status === "waiting_for_human";
+}
+function clampWaitTimeout(timeoutMs) {
+  if (timeoutMs === undefined) {
+    return DEFAULT_TASK_WAIT_TIMEOUT_MS;
+  }
+  if (!Number.isFinite(timeoutMs) || timeoutMs < 0) {
+    return 0;
+  }
+  return Math.min(Math.floor(timeoutMs), MAX_TASK_WAIT_TIMEOUT_MS);
+}
+function clampPollInterval(pollIntervalMs) {
+  if (pollIntervalMs === undefined) {
+    return DEFAULT_TASK_WAIT_POLL_INTERVAL_MS;
+  }
+  if (!Number.isFinite(pollIntervalMs) || pollIntervalMs <= 0) {
+    return 1;
+  }
+  return Math.min(Math.floor(pollIntervalMs), MAX_TASK_WAIT_POLL_INTERVAL_MS);
+}
+async function sleep2(ms) {
+  await new Promise((resolve2) => setTimeout(resolve2, ms));
+}
 function isRequestDelegateInput(input) {
   return "sourceKind" in input;
 }
 var init_orchestration_service = __esm(() => {
   init_quota_errors();
+  init_task_wait_timeouts();
 });
 
 // src/orchestration/worker-prompts.ts
@@ -17627,10 +18769,12 @@ class SessionService {
   config;
   stateStore;
   state;
-  constructor(config2, stateStore, state) {
+  stateMutex;
+  constructor(config2, stateStore, state, options = {}) {
     this.config = config2;
     this.stateStore = stateStore;
     this.state = state;
+    this.stateMutex = options.stateMutex ?? new AsyncMutex;
   }
   async createSession(alias, agent, workspace) {
     return await this.createLogicalSession(alias, agent, workspace, `${workspace}:${alias}`);
@@ -17665,61 +18809,69 @@ class SessionService {
     return preferred ? this.toResolvedSession(preferred) : null;
   }
   async useSession(chatKey, alias) {
-    const session = this.state.sessions[alias];
-    if (!session) {
-      throw new Error(`session "${alias}" does not exist`);
-    }
-    session.last_used_at = new Date().toISOString();
-    this.state.chat_contexts[chatKey] = { current_session: alias };
-    await this.persist();
+    await this.mutate(async () => {
+      const session = this.state.sessions[alias];
+      if (!session) {
+        throw new Error(`session "${alias}" does not exist`);
+      }
+      session.last_used_at = new Date().toISOString();
+      this.state.chat_contexts[chatKey] = { current_session: alias };
+      await this.persist();
+    });
   }
   async setCurrentSessionMode(chatKey, modeId) {
-    const currentAlias = this.state.chat_contexts[chatKey]?.current_session;
-    if (!currentAlias) {
-      throw new Error("no current session selected");
-    }
-    const session = this.state.sessions[currentAlias];
-    if (!session) {
-      throw new Error("no current session selected");
-    }
-    const normalizedModeId = modeId?.trim();
-    if (normalizedModeId) {
-      session.mode_id = normalizedModeId;
-    } else {
-      delete session.mode_id;
-    }
-    session.last_used_at = new Date().toISOString();
-    await this.persist();
+    await this.mutate(async () => {
+      const currentAlias = this.state.chat_contexts[chatKey]?.current_session;
+      if (!currentAlias) {
+        throw new Error("no current session selected");
+      }
+      const session = this.state.sessions[currentAlias];
+      if (!session) {
+        throw new Error("no current session selected");
+      }
+      const normalizedModeId = modeId?.trim();
+      if (normalizedModeId) {
+        session.mode_id = normalizedModeId;
+      } else {
+        delete session.mode_id;
+      }
+      session.last_used_at = new Date().toISOString();
+      await this.persist();
+    });
   }
   async setCurrentSessionReplyMode(chatKey, replyMode) {
-    const currentAlias = this.state.chat_contexts[chatKey]?.current_session;
-    if (!currentAlias) {
-      throw new Error("no current session selected");
-    }
-    const session = this.state.sessions[currentAlias];
-    if (!session) {
-      throw new Error("no current session selected");
-    }
-    if (replyMode) {
-      session.reply_mode = replyMode;
-    } else {
-      delete session.reply_mode;
-    }
-    session.last_used_at = new Date().toISOString();
-    await this.persist();
+    await this.mutate(async () => {
+      const currentAlias = this.state.chat_contexts[chatKey]?.current_session;
+      if (!currentAlias) {
+        throw new Error("no current session selected");
+      }
+      const session = this.state.sessions[currentAlias];
+      if (!session) {
+        throw new Error("no current session selected");
+      }
+      if (replyMode) {
+        session.reply_mode = replyMode;
+      } else {
+        delete session.reply_mode;
+      }
+      session.last_used_at = new Date().toISOString();
+      await this.persist();
+    });
   }
   async getCurrentSession(chatKey) {
-    const currentAlias = this.state.chat_contexts[chatKey]?.current_session;
-    if (!currentAlias) {
-      return null;
-    }
-    const session = this.state.sessions[currentAlias];
-    if (!session) {
-      return null;
-    }
-    session.last_used_at = new Date().toISOString();
-    await this.persist();
-    return this.toResolvedSession(session);
+    return await this.mutate(async () => {
+      const currentAlias = this.state.chat_contexts[chatKey]?.current_session;
+      if (!currentAlias) {
+        return null;
+      }
+      const session = this.state.sessions[currentAlias];
+      if (!session) {
+        return null;
+      }
+      session.last_used_at = new Date().toISOString();
+      await this.persist();
+      return this.toResolvedSession(session);
+    });
   }
   async listSessions(chatKey) {
     const currentAlias = this.state.chat_contexts[chatKey]?.current_session;
@@ -17744,19 +18896,21 @@ class SessionService {
     return count;
   }
   async removeSession(alias) {
-    const session = this.state.sessions[alias];
-    if (!session) {
-      throw new Error(`session "${alias}" does not exist`);
-    }
-    const wasActive = Object.values(this.state.chat_contexts).some((ctx) => ctx.current_session === alias);
-    delete this.state.sessions[alias];
-    for (const [chatKey, ctx] of Object.entries(this.state.chat_contexts)) {
-      if (ctx.current_session === alias) {
-        delete this.state.chat_contexts[chatKey];
+    return await this.mutate(async () => {
+      const session = this.state.sessions[alias];
+      if (!session) {
+        throw new Error(`session "${alias}" does not exist`);
       }
-    }
-    await this.persist();
-    return { wasActive };
+      const wasActive = Object.values(this.state.chat_contexts).some((ctx) => ctx.current_session === alias);
+      delete this.state.sessions[alias];
+      for (const [chatKey, ctx] of Object.entries(this.state.chat_contexts)) {
+        if (ctx.current_session === alias) {
+          delete this.state.chat_contexts[chatKey];
+        }
+      }
+      await this.persist();
+      return { wasActive };
+    });
   }
   toResolvedSession(session) {
     const agentConfig = this.config.agents[session.agent];
@@ -17779,41 +18933,51 @@ class SessionService {
     };
   }
   async setSessionTransportAgentCommand(alias, transportAgentCommand) {
-    const session = this.state.sessions[alias];
-    if (!session) {
-      throw new Error(`session "${alias}" does not exist`);
-    }
-    const normalized = transportAgentCommand?.trim();
-    if (normalized) {
-      session.transport_agent_command = normalized;
-    } else {
-      delete session.transport_agent_command;
-    }
-    session.last_used_at = new Date().toISOString();
-    await this.persist();
+    await this.mutate(async () => {
+      const session = this.state.sessions[alias];
+      if (!session) {
+        throw new Error(`session "${alias}" does not exist`);
+      }
+      const normalized = transportAgentCommand?.trim();
+      if (normalized) {
+        session.transport_agent_command = normalized;
+      } else {
+        delete session.transport_agent_command;
+      }
+      session.last_used_at = new Date().toISOString();
+      await this.persist();
+    });
+  }
+  async mutate(critical) {
+    return await this.stateMutex.run(critical);
   }
   async persist() {
     await this.stateStore.save(this.state);
   }
   async createLogicalSession(alias, agent, workspace, transportSession, transportAgentCommand) {
-    this.validateSession(alias, agent, workspace);
-    const existingSession = this.state.sessions[alias];
-    const now = new Date().toISOString();
-    const normalizedTransportAgentCommand = transportAgentCommand?.trim();
-    const session = {
-      alias,
-      agent,
-      workspace,
-      transport_session: transportSession,
-      ...normalizedTransportAgentCommand ? { transport_agent_command: normalizedTransportAgentCommand } : existingSession?.transport_agent_command ? { transport_agent_command: existingSession.transport_agent_command } : {},
-      mode_id: existingSession?.mode_id,
-      reply_mode: existingSession?.reply_mode,
-      created_at: existingSession?.created_at ?? now,
-      last_used_at: now
-    };
-    this.state.sessions[alias] = session;
-    await this.persist();
-    return this.toResolvedSession(session);
+    return await this.mutate(async () => {
+      this.validateSession(alias, agent, workspace);
+      if (this.state.orchestration.externalCoordinators[transportSession]) {
+        throw new Error(`transport session "${transportSession}" conflicts with an external coordinator`);
+      }
+      const existingSession = this.state.sessions[alias];
+      const now = new Date().toISOString();
+      const normalizedTransportAgentCommand = transportAgentCommand?.trim();
+      const session = {
+        alias,
+        agent,
+        workspace,
+        transport_session: transportSession,
+        ...normalizedTransportAgentCommand ? { transport_agent_command: normalizedTransportAgentCommand } : existingSession?.transport_agent_command ? { transport_agent_command: existingSession.transport_agent_command } : {},
+        mode_id: existingSession?.mode_id,
+        reply_mode: existingSession?.reply_mode,
+        created_at: existingSession?.created_at ?? now,
+        last_used_at: now
+      };
+      this.state.sessions[alias] = session;
+      await this.persist();
+      return this.toResolvedSession(session);
+    });
   }
   validateSession(alias, agent, workspace) {
     if (alias.trim().length === 0) {
@@ -17835,295 +18999,6 @@ class SessionService {
 }
 var init_session_service = () => {};
 
-// src/orchestration/orchestration-types.ts
-function createEmptyOrchestrationState() {
-  return {
-    tasks: {},
-    workerBindings: {},
-    groups: {},
-    humanQuestionPackages: {},
-    coordinatorQuestionState: {},
-    coordinatorRoutes: {}
-  };
-}
-
-// src/state/types.ts
-function createEmptyState() {
-  return {
-    sessions: {},
-    chat_contexts: {},
-    orchestration: createEmptyOrchestrationState()
-  };
-}
-var init_types2 = () => {};
-
-// src/state/state-store.ts
-import { readFile as readFile7 } from "node:fs/promises";
-function isRecord2(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function isString(value) {
-  return typeof value === "string";
-}
-function isOptionalString(value) {
-  return value === undefined || typeof value === "string";
-}
-function isOptionalBoolean(value) {
-  return value === undefined || typeof value === "boolean";
-}
-function isTaskStatus(value) {
-  return value === "pending" || value === "needs_confirmation" || value === "running" || value === "blocked" || value === "waiting_for_human" || value === "completed" || value === "failed" || value === "cancelled";
-}
-function isSourceKind(value) {
-  return value === "human" || value === "coordinator" || value === "worker";
-}
-function isOpenQuestionRecord(value) {
-  if (!isRecord2(value)) {
-    return false;
-  }
-  return isString(value.questionId) && isString(value.question) && isString(value.whyBlocked) && isString(value.whatIsNeeded) && isString(value.askedAt) && (value.status === "open" || value.status === "answered" || value.status === "superseded") && isOptionalString(value.answeredAt) && (value.answerSource === undefined || value.answerSource === "coordinator" || value.answerSource === "human") && isOptionalString(value.answerText) && isOptionalString(value.packageId) && isOptionalString(value.lastWakeError) && isOptionalString(value.lastResumeError);
-}
-function isReviewPendingRecord(value) {
-  if (!isRecord2(value)) {
-    return false;
-  }
-  return isString(value.reviewId) && value.reason === "misrouted_answer" && isString(value.createdAt) && isString(value.resultId) && isString(value.resultText);
-}
-function isCorrectionPendingRecord(value) {
-  if (!isRecord2(value)) {
-    return false;
-  }
-  return isString(value.requestedAt) && value.reason === "misrouted_answer";
-}
-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) && 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.groupId) && (value.openQuestion === undefined || isOpenQuestionRecord(value.openQuestion)) && (value.reviewPending === undefined || isReviewPendingRecord(value.reviewPending)) && (value.correctionPending === undefined || isCorrectionPendingRecord(value.correctionPending));
-}
-function isWorkerBindingRecord(value) {
-  if (!isRecord2(value)) {
-    return false;
-  }
-  return isString(value.sourceHandle) && isString(value.coordinatorSession) && isString(value.workspace) && isString(value.targetAgent) && isOptionalString(value.role);
-}
-function isGroupRecord(value) {
-  if (!isRecord2(value)) {
-    return false;
-  }
-  return isString(value.groupId) && isString(value.coordinatorSession) && isString(value.title) && isString(value.createdAt) && isString(value.updatedAt) && isOptionalString(value.coordinatorInjectedAt) && isOptionalBoolean(value.injectionPending) && isOptionalString(value.injectionAppliedAt) && isOptionalString(value.lastInjectionError);
-}
-function isQueuedQuestionRecord(value) {
-  if (!isRecord2(value)) {
-    return false;
-  }
-  return isString(value.taskId) && isString(value.questionId) && isString(value.enqueuedAt);
-}
-function isCoordinatorQuestionStateRecord(value) {
-  if (!isRecord2(value)) {
-    return false;
-  }
-  const queuedQuestions = value.queuedQuestions;
-  if (queuedQuestions !== undefined && !Array.isArray(queuedQuestions)) {
-    return false;
-  }
-  return (value.activePackageId === undefined || isString(value.activePackageId)) && (queuedQuestions === undefined || queuedQuestions.every(isQueuedQuestionRecord));
-}
-function isCoordinatorRouteContextRecord(value) {
-  if (!isRecord2(value)) {
-    return false;
-  }
-  return isString(value.coordinatorSession) && isString(value.chatKey) && isOptionalString(value.accountId) && isOptionalString(value.replyContextToken) && isString(value.updatedAt);
-}
-function isHumanQuestionPackageMessageRecord(value) {
-  if (!isRecord2(value)) {
-    return false;
-  }
-  return isString(value.messageId) && (value.kind === "initial" || value.kind === "follow_up") && isString(value.promptText) && isString(value.createdAt) && isOptionalString(value.deliveredAt) && isOptionalString(value.deliveredChatKey) && isOptionalString(value.deliveryAccountId) && isOptionalString(value.lastDeliveryError);
-}
-function isHumanQuestionPackageRecord(value) {
-  if (!isRecord2(value)) {
-    return false;
-  }
-  const initialTaskIds = value.initialTaskIds;
-  const openTaskIds = value.openTaskIds;
-  const resolvedTaskIds = value.resolvedTaskIds;
-  const messages = value.messages;
-  return isString(value.packageId) && isString(value.coordinatorSession) && (value.status === "active" || value.status === "closed") && isString(value.createdAt) && isString(value.updatedAt) && isOptionalString(value.closedAt) && Array.isArray(initialTaskIds) && initialTaskIds.every(isString) && Array.isArray(openTaskIds) && openTaskIds.every(isString) && Array.isArray(resolvedTaskIds) && resolvedTaskIds.every(isString) && Array.isArray(messages) && messages.every(isHumanQuestionPackageMessageRecord) && isOptionalString(value.awaitingReplyMessageId);
-}
-function parseOrchestrationState(raw, path11) {
-  if (raw === undefined) {
-    return createEmptyOrchestrationState();
-  }
-  if (!isRecord2(raw)) {
-    throw new Error(`state file "${path11}" must contain an object field "orchestration"`);
-  }
-  const tasks = raw.tasks;
-  if (tasks !== undefined && !isRecord2(tasks)) {
-    throw new Error(`state file "${path11}" must contain an object field "orchestration.tasks"`);
-  }
-  const workerBindings = raw.workerBindings;
-  if (workerBindings !== undefined && !isRecord2(workerBindings)) {
-    throw new Error(`state file "${path11}" must contain an object field "orchestration.workerBindings"`);
-  }
-  const groups = raw.groups;
-  if (groups !== undefined && !isRecord2(groups)) {
-    throw new Error(`state file "${path11}" must contain an object field "orchestration.groups"`);
-  }
-  const humanQuestionPackages = raw.humanQuestionPackages;
-  if (humanQuestionPackages !== undefined && !isRecord2(humanQuestionPackages)) {
-    throw new Error(`state file "${path11}" must contain an object field "orchestration.humanQuestionPackages"`);
-  }
-  const coordinatorQuestionState = raw.coordinatorQuestionState;
-  if (coordinatorQuestionState !== undefined && !isRecord2(coordinatorQuestionState)) {
-    throw new Error(`state file "${path11}" must contain an object field "orchestration.coordinatorQuestionState"`);
-  }
-  const coordinatorRoutes = raw.coordinatorRoutes;
-  if (coordinatorRoutes !== undefined && !isRecord2(coordinatorRoutes)) {
-    throw new Error(`state file "${path11}" must contain an object field "orchestration.coordinatorRoutes"`);
-  }
-  const parsedTasks = {};
-  for (const [taskId, task] of Object.entries(tasks ?? {})) {
-    if (!isTaskRecord(task)) {
-      throw new Error(`state file "${path11}" contains an invalid orchestration task at "${taskId}"`);
-    }
-    parsedTasks[taskId] = task;
-  }
-  const parsedWorkerBindings = {};
-  for (const [workerSession, binding] of Object.entries(workerBindings ?? {})) {
-    if (!isWorkerBindingRecord(binding)) {
-      throw new Error(`state file "${path11}" contains an invalid orchestration worker binding at "${workerSession}"`);
-    }
-    parsedWorkerBindings[workerSession] = binding;
-  }
-  const parsedGroups = {};
-  for (const [groupId, group] of Object.entries(groups ?? {})) {
-    if (!isGroupRecord(group)) {
-      throw new Error(`state file "${path11}" contains an invalid orchestration group at "${groupId}"`);
-    }
-    parsedGroups[groupId] = group;
-  }
-  const parsedHumanQuestionPackages = {};
-  for (const [packageId, packageRecord] of Object.entries(humanQuestionPackages ?? {})) {
-    if (!isHumanQuestionPackageRecord(packageRecord)) {
-      throw new Error(`state file "${path11}" contains an invalid human question package at "${packageId}"`);
-    }
-    parsedHumanQuestionPackages[packageId] = packageRecord;
-  }
-  const parsedCoordinatorQuestionState = {};
-  for (const [coordinatorSession, questionState] of Object.entries(coordinatorQuestionState ?? {})) {
-    if (!isCoordinatorQuestionStateRecord(questionState)) {
-      throw new Error(`state file "${path11}" contains an invalid coordinator question state at "${coordinatorSession}"`);
-    }
-    parsedCoordinatorQuestionState[coordinatorSession] = {
-      activePackageId: questionState.activePackageId,
-      queuedQuestions: (questionState.queuedQuestions ?? []).map((question) => ({ ...question }))
-    };
-  }
-  const parsedCoordinatorRoutes = {};
-  for (const [coordinatorSession, route] of Object.entries(coordinatorRoutes ?? {})) {
-    if (!isCoordinatorRouteContextRecord(route)) {
-      throw new Error(`state file "${path11}" contains an invalid coordinator route at "${coordinatorSession}"`);
-    }
-    parsedCoordinatorRoutes[coordinatorSession] = route;
-  }
-  return {
-    tasks: parsedTasks,
-    workerBindings: parsedWorkerBindings,
-    groups: parsedGroups,
-    humanQuestionPackages: parsedHumanQuestionPackages,
-    coordinatorQuestionState: parsedCoordinatorQuestionState,
-    coordinatorRoutes: parsedCoordinatorRoutes
-  };
-}
-function isReplyMode(value) {
-  return value === "stream" || value === "final" || value === "verbose";
-}
-function isSessionRecord(value) {
-  if (!isRecord2(value)) {
-    return false;
-  }
-  return isString(value.alias) && isString(value.agent) && isString(value.workspace) && isString(value.transport_session) && isOptionalString(value.transport_agent_command) && isOptionalString(value.mode_id) && (value.reply_mode === undefined || isReplyMode(value.reply_mode)) && isString(value.created_at) && isString(value.last_used_at);
-}
-function parseSessions(raw, path11) {
-  const sessions = {};
-  for (const [alias, value] of Object.entries(raw)) {
-    if (!isSessionRecord(value)) {
-      throw new Error(`state file "${path11}" contains malformed session record "${alias}"`);
-    }
-    sessions[alias] = value;
-  }
-  return sessions;
-}
-function isChatContextRecord(value) {
-  return isRecord2(value) && isString(value.current_session);
-}
-function parseChatContexts(raw, path11) {
-  const chatContexts = {};
-  for (const [chatKey, value] of Object.entries(raw)) {
-    if (!isChatContextRecord(value)) {
-      throw new Error(`state file "${path11}" contains malformed chat context record "${chatKey}"`);
-    }
-    chatContexts[chatKey] = value;
-  }
-  return chatContexts;
-}
-function parseState(raw, path11) {
-  if (!isRecord2(raw)) {
-    throw new Error(`state file "${path11}" must contain a JSON object`);
-  }
-  const sessions = raw.sessions;
-  if (!isRecord2(sessions)) {
-    throw new Error(`state file "${path11}" must contain an object field "sessions"`);
-  }
-  const chatContexts = raw.chat_contexts;
-  if (!isRecord2(chatContexts)) {
-    throw new Error(`state file "${path11}" must contain an object field "chat_contexts"`);
-  }
-  const orchestration = parseOrchestrationState(raw.orchestration, path11);
-  return {
-    sessions: parseSessions(sessions, path11),
-    chat_contexts: parseChatContexts(chatContexts, path11),
-    orchestration
-  };
-}
-
-class StateStore {
-  path;
-  constructor(path11) {
-    this.path = path11;
-  }
-  async load() {
-    try {
-      const content = await readFile7(this.path, "utf8");
-      if (content.trim() === "") {
-        return createEmptyState();
-      }
-      let parsed;
-      try {
-        parsed = JSON.parse(content);
-      } catch (error2) {
-        throw new Error(`failed to parse state file "${this.path}"`, {
-          cause: error2
-        });
-      }
-      return parseState(parsed, this.path);
-    } catch (error2) {
-      if (error2.code === "ENOENT") {
-        return createEmptyState();
-      }
-      throw error2;
-    }
-  }
-  async save(state) {
-    await writePrivateFileAtomic(this.path, JSON.stringify(state, null, 2));
-  }
-}
-var init_state_store = __esm(() => {
-  init_private_file();
-  init_types2();
-});
-
 // src/run-console.ts
 var exports_run_console = {};
 __export(exports_run_console, {
@@ -18700,19 +19575,30 @@ class AcpxBridgeTransport {
       }
     } : undefined);
   }
-  async prompt(session, text, reply, replyContext) {
+  async prompt(session, text, reply, replyContext, options) {
     const sink = reply ? createQuotaGatedReplySink({
       reply,
       ...replyContext ? { replyContext } : {}
     }) : null;
+    let segmentError;
+    let segmentChain = Promise.resolve();
     const result = await this.client.request("prompt", {
       ...this.toParams(session),
-      text
+      text,
+      ...options?.media ? { media: options.media } : {}
     }, (event) => {
       if (event.type === "prompt.segment") {
+        const onSegment = options?.onSegment;
+        if (onSegment) {
+          const segmentText = event.text;
+          segmentChain = segmentChain.then(() => onSegment(segmentText)).catch((error2) => {
+            segmentError ??= error2;
+          });
+        }
         sink?.feedSegment(event.text);
       }
     });
+    await segmentChain;
     if (sink) {
       const { overflowCount } = sink.finalize();
       await sink.drain({ timeoutMs: 30000 });
@@ -18721,10 +19607,16 @@ class AcpxBridgeTransport {
         throw deferred;
       }
       const summary = buildOverflowSummary(overflowCount);
+      if (segmentError) {
+        throw segmentError;
+      }
       return { text: summary ? `${summary}
 
 ${result.text}` : "" };
     }
+    if (segmentError) {
+      throw segmentError;
+    }
     return result;
   }
   async setMode(session, modeId) {
@@ -18780,6 +19672,115 @@ var init_spawn_command = __esm(() => {
   SCRIPT_FILE_PATTERN = /\.(c|m)?js$/i;
 });
 
+// src/transport/prompt-media.ts
+import { mkdtemp, open as open3, rm as rm7, writeFile as writeFile6 } from "node:fs/promises";
+import { tmpdir as defaultTmpdir } from "node:os";
+import path11 from "node:path";
+async function createStructuredPromptFile(text, media, deps = defaultStructuredPromptFileDeps) {
+  if (!media) {
+    return null;
+  }
+  if (media.type !== "image") {
+    throw new Error("prompt media type is not supported; only image media is supported");
+  }
+  const imageData = await deps.readImageFile(media.filePath, MAX_STRUCTURED_IMAGE_BYTES);
+  if (imageData.byteLength === 0) {
+    throw new Error("image prompt must not be empty");
+  }
+  if (imageData.byteLength > MAX_STRUCTURED_IMAGE_BYTES) {
+    throw new Error(`image prompt exceeds ${MAX_STRUCTURED_IMAGE_BYTES} bytes`);
+  }
+  const blocks = [];
+  if (text.trim().length > 0) {
+    blocks.push({ type: "text", text });
+  }
+  blocks.push({
+    type: "image",
+    mimeType: resolveImageMimeType(imageData, media.mimeType),
+    data: imageData.toString("base64")
+  });
+  let dir = "";
+  try {
+    dir = await deps.mkdtemp(path11.join(deps.tmpdir(), "weacpx-acp-prompt-"));
+    const filePath = path11.join(dir, "prompt.json");
+    await deps.writeFile(filePath, JSON.stringify(blocks), "utf8");
+    return {
+      filePath,
+      cleanup: async () => {
+        await deps.rm(dir, { recursive: true, force: true });
+      }
+    };
+  } catch (error2) {
+    if (dir) {
+      try {
+        await deps.rm(dir, { recursive: true, force: true });
+      } catch {}
+    }
+    throw error2;
+  }
+}
+async function readImageFileBounded(filePath, maxBytes) {
+  const handle = await open3(filePath, "r");
+  try {
+    const imageStats = await handle.stat();
+    if (!imageStats.isFile()) {
+      throw new Error("image prompt path must be a regular file");
+    }
+    if (imageStats.size > maxBytes) {
+      throw new Error(`image prompt exceeds ${maxBytes} bytes`);
+    }
+    const chunks = [];
+    let total = 0;
+    let position = 0;
+    const chunkSize = 1024 * 1024;
+    while (total <= maxBytes) {
+      const buffer = Buffer.allocUnsafe(Math.min(chunkSize, maxBytes + 1 - total));
+      const { bytesRead } = await handle.read(buffer, 0, buffer.length, position);
+      if (bytesRead === 0)
+        break;
+      chunks.push(buffer.subarray(0, bytesRead));
+      total += bytesRead;
+      position += bytesRead;
+    }
+    return Buffer.concat(chunks, total);
+  } finally {
+    await handle.close();
+  }
+}
+function resolveImageMimeType(buffer, declaredMimeType) {
+  if (/^image\/[A-Za-z0-9.+-]+$/.test(declaredMimeType) && declaredMimeType !== "image/*") {
+    return declaredMimeType;
+  }
+  if (buffer.subarray(0, 8).equals(Buffer.from("89504e470d0a1a0a", "hex"))) {
+    return "image/png";
+  }
+  if (buffer.length >= 3 && buffer[0] === 255 && buffer[1] === 216 && buffer[2] === 255) {
+    return "image/jpeg";
+  }
+  const header6 = buffer.subarray(0, 6).toString("ascii");
+  if (header6 === "GIF87a" || header6 === "GIF89a") {
+    return "image/gif";
+  }
+  if (buffer.length >= 12 && buffer.subarray(0, 4).toString("ascii") === "RIFF" && buffer.subarray(8, 12).toString("ascii") === "WEBP") {
+    return "image/webp";
+  }
+  if (buffer.length >= 2 && buffer.subarray(0, 2).toString("ascii") === "BM") {
+    return "image/bmp";
+  }
+  return "image/png";
+}
+var MAX_STRUCTURED_IMAGE_BYTES, defaultStructuredPromptFileDeps;
+var init_prompt_media = __esm(() => {
+  MAX_STRUCTURED_IMAGE_BYTES = 100 * 1024 * 1024;
+  defaultStructuredPromptFileDeps = {
+    readImageFile: readImageFileBounded,
+    mkdtemp,
+    writeFile: writeFile6,
+    rm: rm7,
+    tmpdir: defaultTmpdir
+  };
+});
+
 // src/transport/streaming-prompt.ts
 function createStreamingPromptState(formatToolCalls = false) {
   return {
@@ -18945,7 +19946,7 @@ async function ensureNodePtyHelperExecutable(helperPath, chmod2 = chmodFs) {
 var init_node_pty_helper = () => {};
 
 // src/transport/acpx-queue-owner-launcher.ts
-import { createHash as createHash2 } from "node:crypto";
+import { createHash as createHash3 } from "node:crypto";
 import { spawn as spawn6 } from "node:child_process";
 import { readFile as readFile8, unlink as unlink2 } from "node:fs/promises";
 import { homedir as homedir7 } from "node:os";
@@ -19114,7 +20115,7 @@ function queueLockFilePath(sessionId) {
   return join9(homedir7(), ".acpx", "queues", `${shortHash(sessionId, 24)}.lock`);
 }
 function shortHash(value, length) {
-  return createHash2("sha256").update(value).digest("hex").slice(0, length);
+  return createHash3("sha256").update(value).digest("hex").slice(0, length);
 }
 function resolveDefaultWeacpxCommand(env) {
   if (env.WEACPX_CLI_COMMAND?.trim()) {
@@ -19250,20 +20251,30 @@ class AcpxCliTransport {
       timeoutMs: this.sessionInitTimeoutMs
     });
   }
-  async prompt(session, text, reply, replyContext) {
+  async prompt(session, text, reply, replyContext, options) {
     await this.launchMcpQueueOwnerIfNeeded(session);
-    const args = this.buildPromptArgs(session, text);
-    if (reply) {
-      const formatToolCalls = session.replyMode === "verbose";
-      const { result: result2, overflowCount } = await this.runStreamingPrompt(this.command, args, reply, 30000, formatToolCalls, replyContext);
-      const baseText = getPromptText(result2);
-      const summary = buildOverflowSummary(overflowCount);
-      return { text: summary ? `${summary}
+    const structuredPrompt = await createStructuredPromptFile(text, options?.media);
+    const args = this.buildPromptArgs(session, text, structuredPrompt?.filePath);
+    try {
+      if (reply || options?.onSegment) {
+        const formatToolCalls = session.replyMode === "verbose";
+        const { result: result2, overflowCount } = await this.runStreamingPrompt(this.command, args, reply, 30000, formatToolCalls, replyContext, options?.onSegment);
+        const baseText = getPromptText(result2);
+        if (!reply) {
+          return { text: baseText };
+        }
+        const summary = buildOverflowSummary(overflowCount);
+        return { text: summary ? `${summary}
 
 ${baseText}` : "" };
+      }
+      const result = await this.runCommand(this.command, args);
+      return { text: getPromptText(result) };
+    } finally {
+      try {
+        await structuredPrompt?.cleanup();
+      } catch {}
     }
-    const result = await this.runCommand(this.command, args);
-    return { text: getPromptText(result) };
   }
   async setMode(session, modeId) {
     await this.run(this.buildArgs(session, [
@@ -19384,7 +20395,7 @@ ${baseText}` : "" };
       })
     ]);
   }
-  async runStreamingPrompt(command, args, reply, maxSegmentWaitMs = 30000, formatToolCalls = false, replyContext) {
+  async runStreamingPrompt(command, args, reply, maxSegmentWaitMs = 30000, formatToolCalls = false, replyContext, onSegment) {
     return await new Promise((resolve2, reject) => {
       const spawnSpec = resolveSpawnCommand(command, args);
       const child = spawn7(spawnSpec.command, spawnSpec.args, { stdio: ["ignore", "pipe", "pipe"] });
@@ -19392,16 +20403,26 @@ ${baseText}` : "" };
       let stderr = "";
       const state = createStreamingPromptState(formatToolCalls);
       let lastReplyAt = Date.now();
-      const sink = createQuotaGatedReplySink({
+      let segmentChain = Promise.resolve();
+      let segmentError;
+      const sink = reply ? createQuotaGatedReplySink({
         reply,
         ...replyContext ? { replyContext } : {}
-      });
+      }) : null;
+      const feedSegment = (segment) => {
+        if (onSegment) {
+          segmentChain = segmentChain.then(() => onSegment(segment)).catch((error2) => {
+            segmentError ??= error2;
+          });
+        }
+        sink?.feedSegment(segment);
+        lastReplyAt = Date.now();
+      };
       const flushBuffer = () => {
         const remaining = state.buffer.trim();
         if (remaining.length > 0) {
           state.buffer = "";
-          sink.feedSegment(remaining);
-          lastReplyAt = Date.now();
+          feedSegment(remaining);
         }
       };
       const timer = setInterval(() => {
@@ -19414,8 +20435,7 @@ ${baseText}` : "" };
         stdout2 += String(chunk);
         parseStreamingDataChunk(state, String(chunk));
         for (const segment of state.segments.splice(0)) {
-          sink.feedSegment(segment);
-          lastReplyAt = Date.now();
+          feedSegment(segment);
         }
       });
       child.stderr.on("data", (chunk) => {
@@ -19429,19 +20449,28 @@ ${baseText}` : "" };
         clearInterval(timer);
         const remaining = state.finalize();
         if (remaining.length > 0) {
-          sink.feedSegment(remaining);
-        }
-        const { overflowCount } = sink.finalize();
-        sink.drain({ timeoutMs: 30000 }).then(() => {
-          const deferred = sink.getPendingError();
+          feedSegment(remaining);
+        }
+        const { overflowCount } = sink?.finalize() ?? { overflowCount: 0 };
+        Promise.all([
+          sink?.drain({ timeoutMs: 30000 }) ?? Promise.resolve(),
+          segmentChain
+        ]).then(() => {
+          const deferred = sink?.getPendingError();
           if (deferred) {
             reject(deferred);
             return;
           }
+          if (segmentError) {
+            reject(segmentError);
+            return;
+          }
           resolve2({
             result: { code: code ?? 1, stdout: stdout2, stderr },
             overflowCount
           });
+        }).catch((error2) => {
+          reject(error2);
         });
       });
     });
@@ -19459,7 +20488,7 @@ ${baseText}` : "" };
     }
     return [...prefix, session.agent, ...tail2];
   }
-  buildPromptArgs(session, text) {
+  buildPromptArgs(session, text, promptFile) {
     const prefix = [
       "--format",
       "json",
@@ -19468,7 +20497,7 @@ ${baseText}` : "" };
       session.cwd,
       ...this.buildPermissionArgs()
     ];
-    const tail2 = ["prompt", "-s", session.transportSession, text];
+    const tail2 = promptFile ? ["prompt", "-s", session.transportSession, "--file", promptFile] : ["prompt", "-s", session.transportSession, text];
     if (session.agentCommand) {
       return [...prefix, "--agent", session.agentCommand, ...tail2];
     }
@@ -19507,6 +20536,7 @@ var require4;
 var init_acpx_cli_transport = __esm(() => {
   init_spawn_command();
   init_prompt_output();
+  init_prompt_media();
   init_streaming_prompt();
   init_quota_gated_reply_sink();
   init_node_pty_helper();
@@ -19908,8 +20938,9 @@ async function buildApp(paths, deps = {}) {
   await logger2.cleanup();
   const acpxCommand = resolveAcpxCommand({ configuredCommand: config2.transport.command });
   const stateStore = new StateStore(paths.statePath);
-  let state = await stateStore.load();
-  const sessions = new SessionService(config2, stateStore, state);
+  const state = await stateStore.load();
+  const stateMutex = new AsyncMutex;
+  const sessions = new SessionService(config2, stateStore, state, { stateMutex });
   const pendingWorkerDispatches = new Set;
   const transport = config2.transport.type === "acpx-bridge" ? await (deps.createBridgeTransport?.() ?? Promise.resolve(new AcpxBridgeTransport(await spawnAcpxBridgeClient({
     acpxCommand,
@@ -20058,34 +21089,53 @@ async function buildApp(paths, deps = {}) {
       return;
     }
   };
+  const resolveWorkerRuntimeSession = (input) => {
+    if (!input.cwd) {
+      return sessions.resolveSession(input.workerSession, input.targetAgent, input.workspace, input.workerSession);
+    }
+    const agentConfig = config2.agents[input.targetAgent];
+    if (!agentConfig) {
+      throw new Error(`agent "${input.targetAgent}" is not configured`);
+    }
+    return {
+      alias: input.workerSession,
+      agent: input.targetAgent,
+      agentCommand: resolveAgentCommand(agentConfig.driver, agentConfig.command),
+      workspace: input.workspace,
+      transportSession: input.workerSession,
+      cwd: input.cwd
+    };
+  };
   const launchWorkerTurn = (input) => {
-    const session = sessions.resolveSession(input.workerSession, input.targetAgent, input.workspace, input.workerSession);
+    const session = resolveWorkerRuntimeSession(input);
     session.mcpCoordinatorSession = input.coordinatorSession;
     session.mcpSourceHandle = input.workerSession;
     const workerDispatch = (async () => {
       let taskRecord;
       try {
         const progressBuffer = new ProgressLineBuffer;
-        const result = await transport.prompt(session, input.promptText, async (chunk) => {
-          const summaries = progressBuffer.feed(chunk);
-          for (const summary of summaries) {
-            try {
-              await orchestration.recordTaskProgress(input.taskId);
-              const taskState = await orchestration.getTask(input.taskId);
-              if (taskState?.chatKey && taskState.replyContextToken) {
-                await deliverOrchestrationTaskProgress(taskState, renderTaskProgress(taskState, summary), {
-                  listAccountIds: () => listWeixinAccountIds(),
-                  resolveAccount: (accountId) => resolveWeixinAccount(accountId),
-                  getContextToken: (accountId, userId) => getContextToken(accountId, userId),
-                  reserveMidSegment: (chatKey) => quota.reserveMidSegment(chatKey),
-                  logger: logger2
+        const result = await transport.prompt(session, input.promptText, undefined, undefined, {
+          onSegment: async (chunk) => {
+            const summaries = progressBuffer.feed(chunk);
+            for (const summary of summaries) {
+              try {
+                await orchestration.recordTaskProgress(input.taskId);
+                const taskState = await orchestration.getTask(input.taskId);
+                if (taskState?.chatKey && taskState.replyContextToken) {
+                  await deliverOrchestrationTaskProgress(taskState, renderTaskProgress(taskState, summary), {
+                    listAccountIds: () => listWeixinAccountIds(),
+                    resolveAccount: (accountId) => resolveWeixinAccount(accountId),
+                    getContextToken: (accountId, userId) => getContextToken(accountId, userId),
+                    reserveMidSegment: (chatKey) => quota.reserveMidSegment(chatKey),
+                    logger: logger2
+                  });
+                }
+              } catch (error2) {
+                await logger2.error("orchestration.progress.send_failed", "failed to send task progress", {
+                  taskId: input.taskId,
+                  message: error2 instanceof Error ? error2.message : String(error2)
                 });
               }
-            } catch (error2) {
-              await logger2.error("orchestration.progress.send_failed", "failed to send task progress", {
-                taskId: input.taskId,
-                message: error2 instanceof Error ? error2.message : String(error2)
-              });
             }
           }
         });
@@ -20121,7 +21171,7 @@ async function buildApp(paths, deps = {}) {
           });
         }
       }
-      if (taskRecord) {
+      if (taskRecord && !isRuntimeExternalCoordinator(taskRecord.coordinatorSession)) {
         try {
           await wakeCoordinator(taskRecord.coordinatorSession);
         } catch (wakeError) {
@@ -20138,6 +21188,9 @@ async function buildApp(paths, deps = {}) {
       pendingWorkerDispatches.delete(workerDispatch);
     });
   };
+  const isRuntimeExternalCoordinator = (coordinatorSession) => {
+    return Boolean(state.orchestration.externalCoordinators[coordinatorSession]);
+  };
   orchestration = new OrchestrationService({
     now: deps.loggerNow ?? (() => new Date),
     createId: () => randomUUID3(),
@@ -20145,39 +21198,42 @@ async function buildApp(paths, deps = {}) {
     loadState: async () => JSON.parse(JSON.stringify(state)),
     saveState: async (nextState) => {
       await stateStore.save(nextState);
-      state = nextState;
+      replaceRuntimeState(state, nextState);
     },
-    ensureWorkerSession: async ({ workerSession, targetAgent, workspace, coordinatorSession }) => {
-      const session = sessions.resolveSession(workerSession, targetAgent, workspace, workerSession);
+    stateMutex,
+    ensureWorkerSession: async ({ workerSession, targetAgent, workspace, cwd, coordinatorSession }) => {
+      const session = resolveWorkerRuntimeSession({ workerSession, targetAgent, workspace, ...cwd ? { cwd } : {} });
       session.mcpCoordinatorSession = coordinatorSession;
       session.mcpSourceHandle = workerSession;
       await transport.ensureSession(session);
       return workerSession;
     },
-    dispatchWorkerTask: async ({ workerSession, coordinatorSession, targetAgent, workspace, taskId, role, task }) => {
+    dispatchWorkerTask: async ({ workerSession, coordinatorSession, targetAgent, workspace, cwd, taskId, role, task }) => {
       launchWorkerTurn({
         taskId,
         workerSession,
         coordinatorSession,
         targetAgent,
         workspace,
+        ...cwd ? { cwd } : {},
         promptText: buildWorkerTaskPrompt({ taskId, workerSession, role, task })
       });
     },
-    cancelWorkerTask: async ({ workerSession, targetAgent, workspace }) => {
-      const session = sessions.resolveSession(workerSession, targetAgent, workspace, workerSession);
+    cancelWorkerTask: async ({ workerSession, targetAgent, workspace, cwd }) => {
+      const session = resolveWorkerRuntimeSession({ workerSession, targetAgent, workspace, ...cwd ? { cwd } : {} });
       const result = await transport.cancel(session);
       if (!result.cancelled) {
         throw new Error(result.message || "worker task cancel was not acknowledged");
       }
     },
-    resumeWorkerTask: async ({ taskId, workerSession, coordinatorSession, targetAgent, workspace, answer }) => {
+    resumeWorkerTask: async ({ taskId, workerSession, coordinatorSession, targetAgent, workspace, cwd, answer }) => {
       launchWorkerTurn({
         taskId,
         workerSession,
         coordinatorSession,
         targetAgent,
         workspace,
+        ...cwd ? { cwd } : {},
         promptText: buildWorkerAnswerPrompt(answer)
       });
     },
@@ -20187,15 +21243,15 @@ async function buildApp(paths, deps = {}) {
     deliverCoordinatorMessage: async (input) => {
       await sendCoordinatorMessage(input);
     },
-    interruptWorkerTask: async ({ workerSession, targetAgent, workspace }) => {
-      const session = sessions.resolveSession(workerSession, targetAgent, workspace, workerSession);
+    interruptWorkerTask: async ({ workerSession, targetAgent, workspace, cwd }) => {
+      const session = resolveWorkerRuntimeSession({ workerSession, targetAgent, workspace, ...cwd ? { cwd } : {} });
       const result = await transport.cancel(session);
       if (!result.cancelled) {
         throw new Error(result.message || "worker interrupt was not acknowledged");
       }
     },
-    findReusableWorkerSession: async ({ coordinatorSession, workspace, targetAgent, role }) => {
-      const binding = Object.entries(state.orchestration.workerBindings).find(([, current]) => current.coordinatorSession === coordinatorSession && current.workspace === workspace && current.targetAgent === targetAgent && current.role === role);
+    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);
       return binding?.[0] ?? null;
     },
     logger: logger2
@@ -20241,6 +21297,11 @@ async function buildApp(paths, deps = {}) {
     }
   };
 }
+function replaceRuntimeState(target, source) {
+  target.sessions = source.sessions;
+  target.chat_contexts = source.chat_contexts;
+  target.orchestration = source.orchestration;
+}
 async function main2() {
   const paths = resolveRuntimePaths();
   try {
@@ -20722,107 +21783,107 @@ async function checkRuntime(options = {}) {
 }
 function createRuntimeFsProbe() {
   return {
-    stat: async (path11) => await stat2(path11),
-    access: async (path11, mode) => await access3(path11, mode)
+    stat: async (path12) => await stat2(path12),
+    access: async (path12, mode) => await access3(path12, mode)
   };
 }
-async function checkDirectoryCreatable(label, path11, probe, platform) {
+async function checkDirectoryCreatable(label, path12, probe, platform) {
   try {
-    const stats = await probe.stat(path11);
+    const stats = await probe.stat(path12);
     if (!stats.isDirectory()) {
       return {
         ok: false,
-        detail: `${label}: ${path11} (exists but is not a directory)`
+        detail: `${label}: ${path12} (exists but is not a directory)`
       };
     }
-    await probe.access(path11, directoryAccessMode(platform));
+    await probe.access(path12, directoryAccessMode(platform));
     return {
       ok: true,
-      detail: `${label}: ${path11} (writable)`
+      detail: `${label}: ${path12} (writable)`
     };
   } catch (error2) {
     if (!isMissingPathError(error2)) {
       return {
         ok: false,
-        detail: `${label}: ${path11} (unusable: ${formatError6(error2)})`
+        detail: `${label}: ${path12} (unusable: ${formatError6(error2)})`
       };
     }
-    const parentCheck = await checkCreatableAncestorDirectory(path11, probe, platform);
+    const parentCheck = await checkCreatableAncestorDirectory(path12, probe, platform);
     if (!parentCheck.ok) {
       return {
         ok: false,
-        detail: `${label}: ${path11} (parent not writable: ${parentCheck.blockingPath})`
+        detail: `${label}: ${path12} (parent not writable: ${parentCheck.blockingPath})`
       };
     }
     return {
       ok: true,
-      detail: `${label}: ${path11} (creatable via ${parentCheck.creatableFrom})`
+      detail: `${label}: ${path12} (creatable via ${parentCheck.creatableFrom})`
     };
   }
 }
-async function checkFileCreatable(label, path11, probe, platform) {
+async function checkFileCreatable(label, path12, probe, platform) {
   try {
-    const stats = await probe.stat(path11);
+    const stats = await probe.stat(path12);
     if (stats.isDirectory()) {
       return {
         ok: false,
-        detail: `${label}: ${path11} (exists but is a directory)`
+        detail: `${label}: ${path12} (exists but is a directory)`
       };
     }
-    await probe.access(path11, constants.W_OK);
+    await probe.access(path12, constants.W_OK);
     return {
       ok: true,
-      detail: `${label}: ${path11} (writable)`
+      detail: `${label}: ${path12} (writable)`
     };
   } catch (error2) {
     if (!isMissingPathError(error2)) {
       return {
         ok: false,
-        detail: `${label}: ${path11} (unusable: ${formatError6(error2)})`
+        detail: `${label}: ${path12} (unusable: ${formatError6(error2)})`
       };
     }
-    const parentCheck = await checkCreatableAncestorDirectory(dirname11(path11), probe, platform);
+    const parentCheck = await checkCreatableAncestorDirectory(dirname11(path12), probe, platform);
     if (!parentCheck.ok) {
       return {
         ok: false,
-        detail: `${label}: ${path11} (parent not writable: ${parentCheck.blockingPath})`
+        detail: `${label}: ${path12} (parent not writable: ${parentCheck.blockingPath})`
       };
     }
     return {
       ok: true,
-      detail: `${label}: ${path11} (creatable via ${parentCheck.creatableFrom})`
+      detail: `${label}: ${path12} (creatable via ${parentCheck.creatableFrom})`
     };
   }
 }
-async function checkCreatableAncestorDirectory(path11, probe, platform) {
+async function checkCreatableAncestorDirectory(path12, probe, platform) {
   try {
-    const stats = await probe.stat(path11);
+    const stats = await probe.stat(path12);
     if (!stats.isDirectory()) {
       return {
         ok: false,
-        creatableFrom: path11,
-        blockingPath: path11
+        creatableFrom: path12,
+        blockingPath: path12
       };
     }
-    await probe.access(path11, directoryAccessMode(platform));
+    await probe.access(path12, directoryAccessMode(platform));
     return {
       ok: true,
-      creatableFrom: path11
+      creatableFrom: path12
     };
   } catch (error2) {
     if (!isMissingPathError(error2)) {
       return {
         ok: false,
-        creatableFrom: path11,
-        blockingPath: path11
+        creatableFrom: path12,
+        blockingPath: path12
       };
     }
-    const parent = dirname11(path11);
-    if (parent === path11) {
+    const parent = dirname11(path12);
+    if (parent === path12) {
       return {
         ok: false,
-        creatableFrom: path11,
-        blockingPath: path11
+        creatableFrom: path12,
+        blockingPath: path12
       };
     }
     const parentCheck = await checkCreatableAncestorDirectory(parent, probe, platform);
@@ -21393,9 +22454,11 @@ var init_doctor2 = __esm(async () => {
 
 // src/cli.ts
 init_config_store();
+init_load_config();
 init_ensure_config();
 init_create_daemon_controller();
 init_daemon_files();
+import { randomUUID as randomUUID4 } from "node:crypto";
 import { homedir as homedir12 } from "node:os";
 import { sep } from "node:path";
 import { fileURLToPath as fileURLToPath5 } from "node:url";
@@ -33832,6 +34895,7 @@ function requireHome(env) {
 }
 
 // src/mcp/weacpx-mcp-tools.ts
+init_task_wait_timeouts();
 init_quota_errors();
 var groupStatusSchema = exports_external.enum(["pending", "running", "terminal"]);
 var taskStatusSchema = exports_external.enum([
@@ -33860,6 +34924,7 @@ function buildWeacpxMcpToolRegistry(input) {
       inputSchema: exports_external.object({
         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(),
         groupId: exports_external.string().min(1).optional()
       }).strict(),
@@ -34013,6 +35078,22 @@ function buildWeacpxMcpToolRegistry(input) {
         return createSuccessResult(`任务「${task.taskId}」已请求取消。`, task);
       })
     },
+    {
+      name: "task_wait",
+      description: "Wait for an orchestration task to finish or require attention using a bounded timeout.",
+      inputSchema: exports_external.object({
+        taskId: exports_external.string().min(1),
+        timeoutMs: exports_external.number().int().min(0).max(MAX_TASK_WAIT_TIMEOUT_MS).optional(),
+        pollIntervalMs: exports_external.number().int().min(1).max(MAX_TASK_WAIT_POLL_INTERVAL_MS).optional()
+      }).strict(),
+      handler: async (args) => await asToolResult(async () => {
+        const result = await transport.waitTask({
+          coordinatorSession,
+          ...args
+        });
+        return createSuccessResult(renderTaskWaitResult(result), result);
+      })
+    },
     {
       name: "worker_raise_question",
       description: "Raise a blocker question for the current bound session.",
@@ -34129,6 +35210,21 @@ async function asToolResult(action) {
     return createErrorResult(formatToolError(error2));
   }
 }
+function renderTaskWaitResult(result) {
+  if (result.status === "not_found") {
+    return "Task not found.";
+  }
+  if (!result.task) {
+    return `Task wait ${result.status.replace("_", " ")}; current state is unavailable.`;
+  }
+  if (result.status === "timeout") {
+    return `Task ${result.task.taskId} wait timed out; current state is ${result.task.status}.`;
+  }
+  if (result.status === "attention_required") {
+    return `Task ${result.task.taskId} requires attention; current state is ${result.task.status}.`;
+  }
+  return `Task ${result.task.taskId} reached terminal state ${result.task.status}.`;
+}
 function createSuccessResult(text, structuredContent) {
   return {
     content: [{ type: "text", text }],
@@ -34151,6 +35247,7 @@ function formatToolError(error2) {
 
 // src/orchestration/orchestration-client.ts
 init_orchestration_ipc();
+init_task_wait_timeouts();
 import { randomUUID } from "node:crypto";
 import { createConnection } from "node:net";
 
@@ -34163,17 +35260,20 @@ class OrchestrationClient {
     this.createId = deps.createId ?? (() => randomUUID());
     this.timeoutMs = deps.timeoutMs ?? 30000;
   }
+  async registerExternalCoordinator(input) {
+    return await this.request("coordinator.register_external", input);
+  }
   async delegateRequest(input) {
     return await this.request("delegate.request", input);
   }
-  async getTask(taskId) {
-    return await this.request("task.get", { taskId });
-  }
   async getTaskForCoordinator(input) {
     return await this.request("task.get", input);
   }
   async listTasks(filter) {
-    return await this.request("task.list", filter ? { filter } : {});
+    return await this.request("task.list", { filter });
+  }
+  async waitTask(input) {
+    return await this.request("task.wait", input, getWaitRequestTimeoutMs(input.timeoutMs, this.timeoutMs));
   }
   async approveTask(input) {
     return await this.request("task.approve", input);
@@ -34220,7 +35320,7 @@ class OrchestrationClient {
   async cancelGroup(input) {
     return await this.request("group.cancel", input);
   }
-  async request(method, params) {
+  async request(method, params, timeoutMs = this.timeoutMs) {
     const id = this.createId();
     return await new Promise((resolve, reject) => {
       const socket = createConnection(this.endpoint.path);
@@ -34239,8 +35339,8 @@ class OrchestrationClient {
         reject(error2);
       };
       timer = setTimeout(() => {
-        fail(new Error(`orchestration RPC timeout after ${this.timeoutMs}ms: ${method}`));
-      }, this.timeoutMs);
+        fail(new Error(`orchestration RPC timeout after ${timeoutMs}ms: ${method}`));
+      }, timeoutMs);
       socket.setEncoding("utf8");
       socket.once("error", fail);
       socket.once("connect", () => {
@@ -34286,6 +35386,11 @@ class OrchestrationClient {
     });
   }
 }
+function getWaitRequestTimeoutMs(waitTimeoutMs, defaultTimeoutMs) {
+  const requestedWaitTimeoutMs = waitTimeoutMs === undefined ? undefined : Number.isFinite(waitTimeoutMs) ? waitTimeoutMs : 0;
+  const boundedWaitTimeoutMs = Math.min(Math.max(Math.floor(requestedWaitTimeoutMs ?? DEFAULT_TASK_WAIT_TIMEOUT_MS), 0), MAX_TASK_WAIT_TIMEOUT_MS);
+  return Math.max(defaultTimeoutMs, boundedWaitTimeoutMs + TASK_WAIT_RPC_TIMEOUT_PADDING_MS);
+}
 
 // src/mcp/weacpx-mcp-transport.ts
 function createOrchestrationTransport(endpoint, deps = {}) {
@@ -34295,6 +35400,7 @@ function createOrchestrationTransport(endpoint, deps = {}) {
       sourceHandle: input.sourceHandle ?? input.coordinatorSession,
       targetAgent: input.targetAgent,
       task: input.task,
+      ...input.workingDirectory ? { cwd: input.workingDirectory } : {},
       ...input.role ? { role: input.role } : {},
       ...input.groupId ? { groupId: input.groupId } : {}
     }),
@@ -34313,6 +35419,7 @@ function createOrchestrationTransport(endpoint, deps = {}) {
     approveTask: async (input) => await client.approveTask(input),
     rejectTask: async (input) => await client.rejectTask(input),
     cancelTask: async (input) => await client.cancelTaskForCoordinator(input),
+    waitTask: async (input) => await client.waitTask(input),
     workerRaiseQuestion: async (input) => {
       const sourceHandle = input.sourceHandle.trim();
       if (sourceHandle.length === 0) {
@@ -34343,16 +35450,39 @@ function createWeacpxMcpServer(options) {
       tools: {}
     }
   });
-  const tools = buildWeacpxMcpToolRegistry(options);
-  const toolMap = new Map(tools.map((tool) => [tool.name, tool]));
-  server.setRequestHandler(ListToolsRequestSchema, async () => ({
-    tools: tools.map((tool) => ({
-      name: tool.name,
-      description: tool.description,
-      inputSchema: normalizeInputSchemaJson(zodToJsonSchema(tool.inputSchema))
-    }))
-  }));
+  let toolState = null;
+  let toolStatePromise = null;
+  async function getToolState() {
+    if (toolState) {
+      return toolState;
+    }
+    if (toolStatePromise) {
+      return await toolStatePromise;
+    }
+    toolStatePromise = resolveMcpIdentity(server, options).then((identity) => {
+      toolState = buildToolState({
+        transport: options.transport,
+        coordinatorSession: identity.coordinatorSession,
+        ...identity.sourceHandle ? { sourceHandle: identity.sourceHandle } : {}
+      });
+      return toolState;
+    }).finally(() => {
+      toolStatePromise = null;
+    });
+    return await toolStatePromise;
+  }
+  server.setRequestHandler(ListToolsRequestSchema, async () => {
+    const tools = (await getToolState()).tools;
+    return {
+      tools: tools.map((tool) => ({
+        name: tool.name,
+        description: tool.description,
+        inputSchema: normalizeInputSchemaJson(zodToJsonSchema(tool.inputSchema))
+      }))
+    };
+  });
   server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const toolMap = (await getToolState()).toolMap;
     const tool = toolMap.get(request.params.name);
     if (!tool) {
       throw new McpError(ErrorCode.MethodNotFound, `Unknown tool: ${request.params.name}`);
@@ -34365,12 +35495,35 @@ function createWeacpxMcpServer(options) {
   });
   return server;
 }
+function buildToolState(options) {
+  const tools = buildWeacpxMcpToolRegistry(options);
+  return {
+    tools,
+    toolMap: new Map(tools.map((tool) => [tool.name, tool]))
+  };
+}
+async function resolveMcpIdentity(server, options) {
+  if (options.resolveIdentity) {
+    return await options.resolveIdentity({
+      clientName: server.getClientVersion()?.name,
+      listRoots: async () => (await server.listRoots()).roots
+    });
+  }
+  if (options.coordinatorSession) {
+    return {
+      coordinatorSession: options.coordinatorSession,
+      ...options.sourceHandle ? { sourceHandle: options.sourceHandle } : {}
+    };
+  }
+  throw new McpError(ErrorCode.InvalidRequest, "weacpx MCP identity is not configured; run through `weacpx mcp-stdio` or provide --coordinator-session");
+}
 async function runWeacpxMcpServer(options) {
   const transport = createOrchestrationTransport(options.endpoint ?? resolveDefaultOrchestrationEndpoint(process.env, process.platform));
   const server = createWeacpxMcpServer({
     transport,
-    coordinatorSession: options.coordinatorSession,
-    ...options.sourceHandle ? { sourceHandle: options.sourceHandle } : {}
+    ...options.coordinatorSession ? { coordinatorSession: options.coordinatorSession } : {},
+    ...options.sourceHandle ? { sourceHandle: options.sourceHandle } : {},
+    ...options.resolveIdentity ? { resolveIdentity: options.resolveIdentity } : {}
   });
   const stdio = new StdioServerTransport(stdin, stdout);
   await server.connect(stdio);
@@ -34387,12 +35540,55 @@ function formatZodError(error2) {
   }).join("; ");
 }
 
+// src/mcp/infer-coordinator-identity.ts
+init_workspace_path();
+function inferExternalCoordinatorSession(input) {
+  const suffix = input.workspace?.trim() || input.instanceId?.trim() || "instance";
+  return `external_${sanitizeMcpClientName(input.clientName)}:${suffix}`;
+}
+function sanitizeMcpClientName(input) {
+  const normalized = (input ?? "").trim().toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+  return normalized.length > 0 ? normalized : "mcp-host";
+}
+
+// src/mcp/parse-coordinator-workspace.ts
+function parseCoordinatorWorkspace(args, env = process.env) {
+  let fromFlag = null;
+  for (let index = 0;index < args.length; index += 1) {
+    if (args[index] === "--workspace") {
+      const value = args[index + 1];
+      if (value === undefined) {
+        throw new Error("--workspace requires a non-empty value");
+      }
+      const trimmedValue = value.trim();
+      if (trimmedValue.length === 0 || trimmedValue.startsWith("-")) {
+        throw new Error("--workspace requires a non-empty value");
+      }
+      fromFlag = value;
+    }
+  }
+  const trimmedFlag = fromFlag?.trim();
+  if (trimmedFlag && trimmedFlag.length > 0) {
+    return trimmedFlag;
+  }
+  const trimmedEnv = env.WEACPX_COORDINATOR_WORKSPACE?.trim();
+  return trimmedEnv && trimmedEnv.length > 0 ? trimmedEnv : null;
+}
+
 // src/mcp/parse-coordinator-session.ts
 function parseCoordinatorSession(args, env = process.env) {
   let fromFlag = null;
-  for (let index = 0;index < args.length - 1; index += 1) {
+  for (let index = 0;index < args.length; index += 1) {
     if (args[index] === "--coordinator-session") {
-      fromFlag = args[index + 1] ?? null;
+      const value = args[index + 1];
+      if (value === undefined) {
+        throw new Error("--coordinator-session requires a non-empty value");
+      }
+      const trimmedValue = value.trim();
+      if (trimmedValue.length === 0 || trimmedValue.startsWith("-")) {
+        throw new Error("--coordinator-session requires a non-empty value");
+      }
+      fromFlag = value;
     }
   }
   const trimmedFlag = fromFlag?.trim();
@@ -34406,9 +35602,17 @@ function parseCoordinatorSession(args, env = process.env) {
 // src/mcp/parse-source-handle.ts
 function parseSourceHandle(args, env = process.env) {
   let fromFlag = null;
-  for (let index = 0;index < args.length - 1; index += 1) {
+  for (let index = 0;index < args.length; index += 1) {
     if (args[index] === "--source-handle") {
-      fromFlag = args[index + 1] ?? null;
+      const value = args[index + 1];
+      if (value === undefined) {
+        throw new Error("--source-handle requires a non-empty value");
+      }
+      const trimmedValue = value.trim();
+      if (trimmedValue.length === 0 || trimmedValue.startsWith("-")) {
+        throw new Error("--source-handle requires a non-empty value");
+      }
+      fromFlag = value;
     }
   }
   const trimmedFlag = fromFlag?.trim();
@@ -34421,8 +35625,99 @@ function parseSourceHandle(args, env = process.env) {
 
 // src/cli.ts
 init_workspace_path();
+init_state_store();
 init_version();
 init_consumer_lock();
+async function prepareMcpCoordinatorStartup(input) {
+  const coordinatorSession = input.coordinatorSession.trim();
+  const existingSession = Object.values(input.state.sessions).find((session) => session.transport_session === coordinatorSession);
+  const workspace = input.workspace?.trim();
+  if (workspace) {
+    if (existingSession) {
+      throw new Error(`coordinatorSession "${coordinatorSession}" conflicts with an existing logical session`);
+    }
+    const existingExternalCoordinator2 = input.state.orchestration?.externalCoordinators?.[coordinatorSession];
+    if (existingExternalCoordinator2?.workspace && existingExternalCoordinator2.workspace !== workspace) {
+      throw new Error(`coordinatorSession "${coordinatorSession}" is already bound to workspace "${existingExternalCoordinator2.workspace}"; use a new coordinator session for workspace "${workspace}"`);
+    }
+    if (!input.config.workspaces[workspace]) {
+      if (existingExternalCoordinator2?.workspace === workspace) {
+        throw new Error(`workspace "${workspace}" is not configured for coordinatorSession "${coordinatorSession}"; restore that workspace config or use a new coordinator session for a different workspace`);
+      }
+      throw new Error(`workspace "${workspace}" is not configured`);
+    }
+    await registerExternalCoordinatorOrThrow(input.client, { coordinatorSession, workspace });
+    return { kind: "external-coordinator", workspace };
+  }
+  if (existingSession) {
+    return { kind: "existing-session" };
+  }
+  const existingExternalCoordinator = input.state.orchestration?.externalCoordinators?.[coordinatorSession];
+  if (existingExternalCoordinator) {
+    if (existingExternalCoordinator.workspace && !input.config.workspaces[existingExternalCoordinator.workspace]) {
+      throw new Error(`workspace "${existingExternalCoordinator.workspace}" is not configured for coordinatorSession "${coordinatorSession}"; restore that workspace config or use a new coordinator session for a different workspace`);
+    }
+    await registerExternalCoordinatorOrThrow(input.client, {
+      coordinatorSession,
+      ...existingExternalCoordinator.workspace ? { workspace: existingExternalCoordinator.workspace } : {}
+    });
+    return {
+      kind: "external-coordinator",
+      ...existingExternalCoordinator.workspace ? { workspace: existingExternalCoordinator.workspace } : {}
+    };
+  }
+  await registerExternalCoordinatorOrThrow(input.client, { coordinatorSession });
+  return { kind: "external-coordinator" };
+}
+function createMcpStdioIdentityResolver(input) {
+  const instanceId = randomUUID4().slice(0, 8);
+  return async (context) => {
+    const parsedCoordinatorSession = input.parsedCoordinatorSession?.trim() || null;
+    const workspace = input.workspace?.trim() || null;
+    const sourceHandle = input.sourceHandle?.trim() || null;
+    const resolvedWorkspace = workspace;
+    const resolvedCoordinatorSession = parsedCoordinatorSession ?? inferExternalCoordinatorSession({
+      clientName: context.clientName,
+      ...resolvedWorkspace ? { workspace: resolvedWorkspace } : { instanceId }
+    });
+    await prepareMcpCoordinatorStartup({
+      coordinatorSession: resolvedCoordinatorSession,
+      ...resolvedWorkspace ? { workspace: resolvedWorkspace } : {},
+      config: input.config,
+      state: input.state,
+      client: input.client
+    });
+    return {
+      coordinatorSession: resolvedCoordinatorSession,
+      ...sourceHandle ? { sourceHandle } : {}
+    };
+  };
+}
+async function registerExternalCoordinatorOrThrow(client, input) {
+  try {
+    await client.registerExternalCoordinator(input);
+  } catch (error2) {
+    if (isUnavailableOrchestrationIpcError(error2)) {
+      throw new Error("weacpx daemon orchestration IPC is unavailable; run `weacpx start` and check `weacpx status`");
+    }
+    if (input.workspace && isDaemonWorkspaceNotConfiguredError(error2, input.workspace)) {
+      throw new Error(`workspace "${input.workspace}" is not configured in the running daemon; restart it with \`weacpx stop && weacpx start\``);
+    }
+    throw error2;
+  }
+}
+function isDaemonWorkspaceNotConfiguredError(error2, workspace) {
+  const message = error2 instanceof Error ? error2.message : String(error2);
+  return message === `workspace "${workspace}" is not configured`;
+}
+function isUnavailableOrchestrationIpcError(error2) {
+  const code = typeof error2 === "object" && error2 !== null && "code" in error2 ? String(error2.code) : "";
+  if (code === "ENOENT" || code === "ECONNREFUSED" || code === "ECONNRESET") {
+    return true;
+  }
+  const message = error2 instanceof Error ? error2.message : String(error2);
+  return /connect (ENOENT|ECONNREFUSED|ECONNRESET)\b/.test(message);
+}
 var HELP_LINES = [
   "用法：",
   "weacpx login  - 微信登录",
@@ -34434,7 +35729,7 @@ var HELP_LINES = [
   "weacpx doctor - 运行诊断",
   "weacpx version - 查看版本",
   "weacpx workspace list|add|rm - 管理本机工作区（别名：ws）",
-  "weacpx mcp-stdio --coordinator-session <session> [--source-handle <handle>] - 启动 MCP stdio 服务"
+  "weacpx mcp-stdio [--coordinator-session <session>] [--source-handle <handle>] [--workspace <name>] - 启动 MCP stdio 服务"
 ];
 async function runCli(args, deps = {}) {
   const command = args[0];
@@ -34652,17 +35947,41 @@ async function defaultDoctor(options) {
   return await main4(options);
 }
 async function defaultMcpStdio(args, deps = {}) {
-  const coordinatorSession = parseCoordinatorSession(args, process.env);
-  const sourceHandle = parseSourceHandle(args, process.env);
-  if (!coordinatorSession) {
-    (deps.stderr ?? ((text) => process.stderr.write(text)))(`weacpx mcp-stdio 需要 --coordinator-session <handle> 或 WEACPX_COORDINATOR_SESSION 环境变量
+  let coordinatorSession;
+  let sourceHandle;
+  let endpoint;
+  let identityResolver;
+  try {
+    const parsedCoordinatorSession = parseCoordinatorSession(args, process.env);
+    sourceHandle = parseSourceHandle(args, process.env);
+    const workspace = parseCoordinatorWorkspace(args, process.env);
+    endpoint = resolveDefaultOrchestrationEndpoint(process.env, process.platform);
+    const client = new OrchestrationClient(endpoint);
+    const runtimePaths = (await init_main().then(() => exports_main)).resolveRuntimePaths();
+    await ensureConfigExists(runtimePaths.configPath);
+    const config2 = await loadConfig(runtimePaths.configPath);
+    const state = await new StateStore(runtimePaths.statePath).load();
+    const resolveIdentity = createMcpStdioIdentityResolver({
+      parsedCoordinatorSession,
+      sourceHandle,
+      workspace,
+      config: config2,
+      state,
+      client
+    });
+    const eagerIdentity = parsedCoordinatorSession && workspace ? await resolveIdentity({ clientName: undefined, listRoots: async () => [] }) : null;
+    coordinatorSession = eagerIdentity?.coordinatorSession ?? "";
+    identityResolver = eagerIdentity ? undefined : resolveIdentity;
+  } catch (error2) {
+    (deps.stderr ?? ((text) => process.stderr.write(text)))(`${error2 instanceof Error ? error2.message : String(error2)}
 `);
     return 2;
   }
   await runWeacpxMcpServer({
-    endpoint: resolveDefaultOrchestrationEndpoint(process.env, process.platform),
-    coordinatorSession,
-    ...sourceHandle ? { sourceHandle } : {}
+    endpoint,
+    ...coordinatorSession ? { coordinatorSession } : {},
+    ...sourceHandle ? { sourceHandle } : {},
+    ...identityResolver ? { resolveIdentity: identityResolver } : {}
   });
   return 0;
 }
@@ -34727,5 +36046,7 @@ if (__require.main == __require.module) {
   process.exitCode = await runCli(process.argv.slice(2));
 }
 export {
-  runCli
+  runCli,
+  prepareMcpCoordinatorStartup,
+  createMcpStdioIdentityResolver
 };