weacpx 0.4.4 → 0.4.6

package/dist/cli.js

@@ -2611,6 +2611,82 @@ var init_ensure_config = __esm(() => {
   };
 });
 
+// src/config/agent-templates.ts
+function getAgentTemplate(name) {
+  const template = TEMPLATES[name];
+  if (!template) {
+    return null;
+  }
+  return {
+    ...template
+  };
+}
+function listAgentTemplates() {
+  return Object.keys(TEMPLATES);
+}
+function sameAgentConfig(left, right) {
+  return left.driver === right.driver && (left.command ?? "") === (right.command ?? "");
+}
+var TEMPLATES;
+var init_agent_templates = __esm(() => {
+  TEMPLATES = {
+    codex: {
+      driver: "codex"
+    },
+    claude: {
+      driver: "claude"
+    },
+    pi: {
+      driver: "pi"
+    },
+    openclaw: {
+      driver: "openclaw"
+    },
+    gemini: {
+      driver: "gemini"
+    },
+    cursor: {
+      driver: "cursor"
+    },
+    copilot: {
+      driver: "copilot"
+    },
+    droid: {
+      driver: "droid"
+    },
+    "factory-droid": {
+      driver: "factory-droid"
+    },
+    factorydroid: {
+      driver: "factorydroid"
+    },
+    iflow: {
+      driver: "iflow"
+    },
+    kilocode: {
+      driver: "kilocode"
+    },
+    kimi: {
+      driver: "kimi"
+    },
+    kiro: {
+      driver: "kiro"
+    },
+    opencode: {
+      driver: "opencode"
+    },
+    qoder: {
+      driver: "qoder"
+    },
+    qwen: {
+      driver: "qwen"
+    },
+    trae: {
+      driver: "trae"
+    }
+  };
+});
+
 // src/daemon/daemon-status.ts
 import { mkdir as mkdir2, readFile as readFile3, rm, writeFile as writeFile2 } from "node:fs/promises";
 import { dirname as dirname2 } from "node:path";
@@ -9541,11 +9617,10 @@ function readVersion(moduleUrl = import.meta.url) {
 var PACKAGE_NAME = "weacpx";
 var init_version = () => {};
 
-// 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/orchestration/task-watch-timeouts.ts
+var DEFAULT_TASK_WATCH_TIMEOUT_MS = 60000, MAX_TASK_WATCH_TIMEOUT_MS, DEFAULT_TASK_WATCH_POLL_INTERVAL_MS = 1000, MAX_TASK_WATCH_POLL_INTERVAL_MS = 1e4, TASK_WATCH_RPC_TIMEOUT_PADDING_MS = 5000;
+var init_task_watch_timeouts = __esm(() => {
+  MAX_TASK_WATCH_TIMEOUT_MS = 20 * 60000;
 });
 
 // src/weixin/messaging/quota-errors.ts
@@ -9607,6 +9682,15 @@ function isTaskStatus(value) {
 function isSourceKind(value) {
   return value === "human" || value === "coordinator" || value === "worker";
 }
+function isOptionalNumber(value) {
+  return value === undefined || typeof value === "number";
+}
+function isTaskEventRecord(value) {
+  if (!isRecord2(value)) {
+    return false;
+  }
+  return typeof value.seq === "number" && isString(value.at) && (value.type === "created" || value.type === "progress" || value.type === "status_changed" || value.type === "attention_required" || value.type === "cancel_requested") && (value.status === undefined || isTaskStatus(value.status)) && isOptionalString(value.summary) && isOptionalString(value.message);
+}
 function isOpenQuestionRecord(value) {
   if (!isRecord2(value)) {
     return false;
@@ -9629,7 +9713,7 @@ function isTaskRecord(value) {
   if (!isRecord2(value)) {
     return false;
   }
-  return isString(value.taskId) && isString(value.sourceHandle) && isSourceKind(value.sourceKind) && isString(value.coordinatorSession) && isOptionalString(value.workerSession) && isString(value.workspace) && isOptionalString(value.cwd) && isString(value.targetAgent) && isOptionalString(value.role) && isString(value.task) && isTaskStatus(value.status) && isString(value.summary) && isString(value.resultText) && isString(value.createdAt) && isString(value.updatedAt) && isOptionalString(value.chatKey) && isOptionalString(value.replyContextToken) && isOptionalString(value.accountId) && isOptionalString(value.deliveryAccountId) && isOptionalString(value.coordinatorInjectedAt) && isOptionalString(value.cancelRequestedAt) && isOptionalString(value.cancelCompletedAt) && isOptionalString(value.lastCancelError) && isOptionalBoolean(value.noticePending) && isOptionalString(value.noticeSentAt) && isOptionalString(value.lastNoticeError) && isOptionalBoolean(value.injectionPending) && isOptionalString(value.injectionAppliedAt) && isOptionalString(value.lastInjectionError) && isOptionalString(value.lastProgressAt) && isOptionalString(value.groupId) && (value.openQuestion === undefined || isOpenQuestionRecord(value.openQuestion)) && (value.reviewPending === undefined || isReviewPendingRecord(value.reviewPending)) && (value.correctionPending === undefined || isCorrectionPendingRecord(value.correctionPending));
+  return isString(value.taskId) && isString(value.sourceHandle) && isSourceKind(value.sourceKind) && isString(value.coordinatorSession) && isOptionalString(value.workerSession) && isString(value.workspace) && isOptionalString(value.cwd) && isString(value.targetAgent) && isOptionalString(value.role) && isString(value.task) && isTaskStatus(value.status) && isString(value.summary) && isString(value.resultText) && isString(value.createdAt) && isString(value.updatedAt) && isOptionalString(value.chatKey) && isOptionalString(value.replyContextToken) && isOptionalString(value.accountId) && isOptionalString(value.deliveryAccountId) && isOptionalString(value.coordinatorInjectedAt) && isOptionalString(value.cancelRequestedAt) && isOptionalString(value.cancelCompletedAt) && isOptionalString(value.lastCancelError) && isOptionalBoolean(value.noticePending) && isOptionalString(value.noticeSentAt) && isOptionalString(value.lastNoticeError) && isOptionalBoolean(value.injectionPending) && isOptionalString(value.injectionAppliedAt) && isOptionalString(value.lastInjectionError) && isOptionalString(value.lastProgressAt) && isOptionalString(value.lastProgressSummary) && isOptionalString(value.groupId) && (value.openQuestion === undefined || isOpenQuestionRecord(value.openQuestion)) && (value.reviewPending === undefined || isReviewPendingRecord(value.reviewPending)) && (value.correctionPending === undefined || isCorrectionPendingRecord(value.correctionPending)) && isOptionalNumber(value.eventSeq) && (value.events === undefined || Array.isArray(value.events) && value.events.every(isTaskEventRecord));
 }
 function isExternalCoordinatorRecord(value) {
   if (!isRecord2(value)) {
@@ -9893,37 +9977,6 @@ var init_state_store = __esm(() => {
   init_types();
 });
 
-// src/config/agent-templates.ts
-function getAgentTemplate(name) {
-  const template = TEMPLATES[name];
-  if (!template) {
-    return null;
-  }
-  return {
-    ...template
-  };
-}
-function listAgentTemplates() {
-  return Object.keys(TEMPLATES);
-}
-var TEMPLATES;
-var init_agent_templates = __esm(() => {
-  TEMPLATES = {
-    codex: {
-      driver: "codex"
-    },
-    claude: {
-      driver: "claude"
-    },
-    opencode: {
-      driver: "opencode"
-    },
-    gemini: {
-      driver: "gemini"
-    }
-  };
-});
-
 // src/plugins/plugin-home.ts
 import { mkdir as mkdir6, writeFile as writeFile5 } from "node:fs/promises";
 import { homedir as homedir3 } from "node:os";
@@ -13964,7 +14017,7 @@ ${buildFinalHeadsUp({
         sendWeixinErrorNotice({
           to,
           contextToken,
-          message: `⚠️ 过程失败：${err instanceof Error ? err.message : JSON.stringify(err)}`,
+          message: `⚠️ 执行出错：${err instanceof Error ? err.message : JSON.stringify(err)}`,
           baseUrl: deps.baseUrl,
           token: deps.token,
           errLog: deps.errLog
@@ -15447,38 +15500,24 @@ function extractPromptFailureMessage(result) {
 function extractPromptOutput(output) {
   const lines = output.split(`
 `).map((line) => line.trim()).filter((line) => line.length > 0);
-  const messageSegments = [];
-  let currentSegment = "";
+  let text = "";
   let hasAgentMessage = false;
   for (const line of lines) {
+    let event;
     try {
-      const event = JSON.parse(line);
-      const isMessageChunk = event.method === "session/update" && event.params?.update?.sessionUpdate === "agent_message_chunk" && event.params.update.content?.type === "text" && typeof event.params.update.content.text === "string";
-      if (isMessageChunk) {
-        hasAgentMessage = true;
-        const chunk = event.params.update.content.text ?? "";
-        if (chunk.length > 0) {
-          currentSegment += chunk;
-        }
-        continue;
-      }
-      if (currentSegment.trim().length > 0) {
-        messageSegments.push(currentSegment.trim());
-      }
-      currentSegment = "";
+      event = JSON.parse(line);
     } catch {
-      if (currentSegment.trim().length > 0) {
-        messageSegments.push(currentSegment.trim());
-        currentSegment = "";
-      }
+      continue;
+    }
+    const isMessageChunk = event.method === "session/update" && event.params?.update?.sessionUpdate === "agent_message_chunk" && event.params.update.content?.type === "text" && typeof event.params.update.content.text === "string";
+    if (isMessageChunk) {
+      hasAgentMessage = true;
+      text += event.params.update.content.text ?? "";
     }
   }
-  if (currentSegment.trim().length > 0) {
-    messageSegments.push(currentSegment.trim());
-  }
-  if (messageSegments.length > 0) {
+  if (hasAgentMessage && text.trim().length > 0) {
     return {
-      text: messageSegments[messageSegments.length - 1],
+      text: text.trim(),
       hasAgentMessage
     };
   }
@@ -15512,8 +15551,12 @@ function extractJsonRpcErrorMessages(output) {
 `).map((line) => line.trim()).filter((line) => line.length > 0).flatMap((line) => {
     try {
       const payload = JSON.parse(line);
-      if (typeof payload.error?.message === "string" && payload.error.message.length > 0) {
-        return [payload.error.message];
+      const err = payload.error;
+      const dataMsg = typeof err?.data?.message === "string" && err.data.message.length > 0 ? err.data.message : undefined;
+      const baseMsg = typeof err?.message === "string" && err.message.length > 0 ? err.message : undefined;
+      const chosen = dataMsg && dataMsg !== baseMsg ? dataMsg : baseMsg;
+      if (chosen) {
+        return [chosen];
       }
     } catch {
       return [];
@@ -17202,18 +17245,18 @@ function renderDelegateSuccess2(taskId, workerSession) {
   return [`已创建委派任务「${taskId}」`, `worker 会话：${workerSession}`].join(`
 `);
 }
-function renderGroupCreated2(group) {
+function renderGroupCreated(group) {
   return [`已创建任务组「${group.groupId}」`, `- 标题：${group.title}`].join(`
 `);
 }
-function renderGroupList2(groups) {
+function renderGroupList(groups) {
   if (groups.length === 0) {
     return "当前协调会话下还没有任务组。";
   }
-  return ["当前协调会话的任务组：", ...groups.map((group) => renderGroupListItem2(group))].join(`
+  return ["当前协调会话的任务组：", ...groups.map((group) => renderGroupListItem(group))].join(`
 `);
 }
-function renderGroupSummary2(summary) {
+function renderGroupSummary(summary) {
   const { group, tasks } = summary;
   const lines = [
     `任务组「${group.groupId}」`,
@@ -17245,7 +17288,7 @@ function renderGroupSummary2(summary) {
   return lines.join(`
 `);
 }
-function renderGroupCancelSuccess2(input) {
+function renderGroupCancelSuccess(input) {
   return [
     `任务组「${input.summary.group.groupId}」已发起取消`,
     `- 已请求取消：${input.cancelledTaskIds.length}`,
@@ -17278,6 +17321,8 @@ function renderTaskSummary2(task) {
   header.push(`- 任务：${task.task}`);
   if (task.summary.trim().length > 0)
     header.push(`- 摘要：${task.summary}`);
+  if (task.lastProgressSummary)
+    header.push(`- 最新进展：${task.lastProgressSummary}`);
   if (task.resultText.trim().length > 0)
     header.push(`- 结果：${task.resultText}`);
   const events = [];
@@ -17326,7 +17371,7 @@ function renderTaskApprovalSuccess2(task) {
   return [`已批准任务「${task.taskId}」。`, `- 当前状态：${task.status}`].join(`
 `);
 }
-function renderTaskRejectionSuccess2(task) {
+function renderTaskRejectSuccess(task) {
   return [`已拒绝任务「${task.taskId}」。`, `- 当前状态：${task.status}`].join(`
 `);
 }
@@ -17360,7 +17405,7 @@ function renderTaskListItem2(task) {
   ].filter(Boolean).map((item) => `；${item}`).join("");
   return `- ${task.taskId} [${task.status}] ${task.targetAgent}${role} -> ${task.workerSession ?? "未分配"}${group}${source}${summary}${reliability}`;
 }
-function renderGroupListItem2(group) {
+function renderGroupListItem(group) {
   const reliability = [
     group.group.injectionPending ? "注入待重试" : ""
   ].filter(Boolean).map((item) => `；${item}`).join("");
@@ -17421,7 +17466,7 @@ async function handleGroupCreate(context, chatKey, title) {
     coordinatorSession: session.transportSession,
     title
   });
-  return { text: renderGroupCreated2(group) };
+  return { text: renderGroupCreated(group) };
 }
 async function handleGroupList(context, chatKey, filter) {
   const session = await getCurrentSession(context, chatKey);
@@ -17436,7 +17481,7 @@ async function handleGroupList(context, chatKey, filter) {
     coordinatorSession: session.transportSession,
     ...filter ?? {}
   });
-  return { text: renderGroupList2(groups) };
+  return { text: renderGroupList(groups) };
 }
 async function handleGroupGet(context, chatKey, groupId) {
   const session = await getCurrentSession(context, chatKey);
@@ -17454,7 +17499,7 @@ async function handleGroupGet(context, chatKey, groupId) {
   if (!group) {
     return { text: GROUP_NOT_FOUND_TEXT };
   }
-  return { text: renderGroupSummary2(group) };
+  return { text: renderGroupSummary(group) };
 }
 async function handleGroupCancel(context, chatKey, groupId) {
   const session = await getCurrentSession(context, chatKey);
@@ -17476,7 +17521,7 @@ async function handleGroupCancel(context, chatKey, groupId) {
     groupId,
     coordinatorSession: session.transportSession
   });
-  return { text: renderGroupCancelSuccess2(cancelled) };
+  return { text: renderGroupCancelSuccess(cancelled) };
 }
 async function handleGroupDelegate(context, chatKey, groupId, targetAgent, task, role, replyContextToken, accountId) {
   const session = await getCurrentSession(context, chatKey);
@@ -17564,11 +17609,11 @@ async function handleTaskReject(context, chatKey, taskId) {
   if (task.status !== "needs_confirmation") {
     return { text: renderTaskConfirmationUnavailable(task) };
   }
-  const rejected = await orchestration.rejectTask({
+  const rejected = await orchestration.cancelTask({
     taskId,
     coordinatorSession: session.transportSession
   });
-  return { text: renderTaskRejectionSuccess2(rejected) };
+  return { text: renderTaskRejectSuccess(rejected) };
 }
 async function handleTaskCancel(context, chatKey, taskId) {
   const session = await getCurrentSession(context, chatKey);
@@ -17721,6 +17766,13 @@ async function handleAgentAdd(context, templateName) {
   if (!template) {
     return { text: `暂不支持这个 Agent 模板。当前可用：${listAgentTemplates().join("、")}` };
   }
+  const existing = context.config.agents[templateName];
+  if (existing) {
+    if (sameAgentConfig(existing, template)) {
+      return { text: `Agent「${templateName}」已存在` };
+    }
+    return { text: `Agent「${templateName}」已存在且配置不同。请先执行 /agent rm ${templateName}` };
+  }
   const updated = await context.configStore.upsertAgent(templateName, template);
   context.replaceConfig(updated);
   return { text: `Agent「${templateName}」已保存` };
@@ -17745,7 +17797,7 @@ var init_agent_handler = __esm(() => {
     summary: "管理已注册的 Agent。",
     commands: [
       { usage: "/agents", description: "查看当前已注册的 Agent" },
-      { usage: "/agent add <codex|claude|opencode|gemini>", description: "添加内置 Agent 模板" },
+      { usage: `/agent add <${listAgentTemplates().join("|")}>`, description: "添加内置 Agent 模板" },
       { usage: "/agent rm <name>", description: "删除一个 Agent" }
     ],
     examples: ["/agent add claude", "/agent rm codex"]
@@ -19259,20 +19311,14 @@ class OrchestrationServer {
         return await this.dispatchTaskGet(params);
       case "task.list":
         return await this.handlers.listTasks(this.parseTaskListFilter(params));
-      case "task.wait":
-        return await this.handlers.waitTask(this.parseWaitTaskInput(params));
+      case "task.watch":
+        return await this.handlers.watchTask(this.parseWatchTaskInput(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(this.parseCancelTaskInput(params));
       case "worker.reply":
@@ -19305,15 +19351,6 @@ class OrchestrationServer {
           ...expectedActivePackageId !== undefined ? { expectedActivePackageId } : {}
         });
       }
-      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"),
-          priorMessageId: requireString(params, "priorMessageId"),
-          taskQuestions: requireTaskQuestions(params, "taskQuestions"),
-          promptText: requireString(params, "promptText")
-        });
       case "coordinator.review_contested_result":
         requireOnlyKeys(params, ["coordinatorSession", "taskId", "reviewId", "decision"], "params");
         return await this.handlers.coordinatorReviewContestedResult({
@@ -19328,20 +19365,6 @@ class OrchestrationServer {
           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")
-        });
-      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")
-        });
       default:
         throw new OrchestrationInvalidRequestError(`unsupported orchestration method: ${method}`);
     }
@@ -19436,13 +19459,19 @@ class OrchestrationServer {
       ...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);
+  parseWatchTaskInput(params) {
+    requireOnlyKeys(params, ["coordinatorSession", "taskId", "afterSeq", "mode", "includeProgress", "timeoutMs", "pollIntervalMs"], "params");
+    const afterSeq = requireOptionalIntegerInRange(params, "afterSeq", 0, Number.MAX_SAFE_INTEGER);
+    const mode = requireOptionalEnum(params, "mode", ["next_event", "until_attention_or_terminal"]);
+    const includeProgress = requireOptionalBoolean(params, "includeProgress");
+    const timeoutMs = requireOptionalIntegerInRange(params, "timeoutMs", 0, MAX_TASK_WATCH_TIMEOUT_MS);
+    const pollIntervalMs = requireOptionalIntegerInRange(params, "pollIntervalMs", 1, MAX_TASK_WATCH_POLL_INTERVAL_MS);
     return {
       coordinatorSession: requireString(params, "coordinatorSession"),
       taskId: requireString(params, "taskId"),
+      ...afterSeq !== undefined ? { afterSeq } : {},
+      ...mode !== undefined ? { mode } : {},
+      ...includeProgress !== undefined ? { includeProgress } : {},
       ...timeoutMs !== undefined ? { timeoutMs } : {},
       ...pollIntervalMs !== undefined ? { pollIntervalMs } : {}
     };
@@ -19457,20 +19486,6 @@ class OrchestrationServer {
       whatIsNeeded: requireString(params, "whatIsNeeded")
     };
   }
-  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"]);
-    const order = requireOptionalEnum(params, "order", ["asc", "desc"]);
-    return {
-      coordinatorSession: requireString(params, "coordinatorSession"),
-      ...status !== undefined ? { status } : {},
-      ...stuck !== undefined ? { stuck } : {},
-      ...sort !== undefined ? { sort } : {},
-      ...order !== undefined ? { order } : {}
-    };
-  }
   async cleanupEndpoint() {
     if (this.endpoint.kind !== "unix") {
       return;
@@ -19681,7 +19696,7 @@ function isServerNotRunningError(error2) {
 var OrchestrationInvalidRequestError, ORCHESTRATION_RPC_METHODS;
 var init_orchestration_server = __esm(() => {
   init_orchestration_ipc();
-  init_task_wait_timeouts();
+  init_task_watch_timeouts();
   OrchestrationInvalidRequestError = class OrchestrationInvalidRequestError extends Error {
   };
   ORCHESTRATION_RPC_METHODS = new Set([
@@ -19689,50 +19704,107 @@ var init_orchestration_server = __esm(() => {
     "delegate.request",
     "task.get",
     "task.list",
-    "task.wait",
+    "task.watch",
     "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",
-    "group.new",
-    "group.get",
-    "group.list",
-    "group.cancel"
+    "group.new"
   ]);
 });
 
 // src/orchestration/progress-line-parser.ts
 class ProgressLineBuffer {
-  feed(segment) {
+  pending = "";
+  feed(segment, options = {}) {
+    const hadPending = this.pending.length > 0;
+    this.pending += segment;
     const summaries = [];
-    for (const line of segment.split(`
-`)) {
-      if (line.startsWith(PROGRESS_PREFIX)) {
-        const summary = line.slice(PROGRESS_PREFIX.length).trim();
-        if (summary.length > 0) {
-          summaries.push(summary);
-        }
-      }
+    let newlineIndex = this.pending.indexOf(`
+`);
+    while (newlineIndex !== -1) {
+      const line = this.pending.slice(0, newlineIndex).replace(/\r$/, "");
+      this.pending = this.pending.slice(newlineIndex + 1);
+      this.extractLine(line, summaries);
+      newlineIndex = this.pending.indexOf(`
+`);
+    }
+    if (options.segmentComplete === true && !hadPending && this.pending.startsWith(PROGRESS_PREFIX)) {
+      this.extractLine(this.pending.replace(/\r$/, ""), summaries);
+      this.pending = "";
+      return summaries;
+    }
+    this.trimPendingIfHopeless();
+    return summaries;
+  }
+  flush() {
+    const summaries = [];
+    if (this.pending.length > 0) {
+      this.extractLine(this.pending.replace(/\r$/, ""), summaries);
+      this.pending = "";
     }
     return summaries;
   }
+  extractLine(line, summaries) {
+    if (line.startsWith(PROGRESS_PREFIX)) {
+      const summary = sanitizeProgressSummary(line.slice(PROGRESS_PREFIX.length));
+      if (summary.length > 0) {
+        summaries.push(summary);
+      }
+    }
+  }
+  trimPendingIfHopeless() {
+    if (this.pending.length === 0)
+      return;
+    if (PROGRESS_PREFIX.startsWith(this.pending) || this.pending.startsWith(PROGRESS_PREFIX)) {
+      if (this.pending.length > MAX_PENDING_LINE_LENGTH) {
+        this.pending = "";
+      }
+      return;
+    }
+    this.pending = "";
+  }
+}
+function sanitizeProgressSummary(summary) {
+  const cleaned = summary.replace(/[\u0000-\u0008\u000B\u000C\u000E-\u001F\u007F]/g, "").trim();
+  if (cleaned.length <= MAX_PROGRESS_SUMMARY_LENGTH) {
+    return cleaned;
+  }
+  return `${cleaned.slice(0, MAX_PROGRESS_SUMMARY_LENGTH - 3)}...`;
 }
 function stripProgressLines(text) {
-  return text.split(`
-`).filter((line) => !line.startsWith(PROGRESS_PREFIX)).join(`
+  return text.split(/\r\n|\n|\r/).filter((line) => {
+    const normalized = normalizeProgressLinePrefix(line);
+    return !normalized.startsWith(PROGRESS_PREFIX) && !(line.length > 0 && normalized.length === 0);
+  }).join(`
 `).trim();
 }
-var PROGRESS_PREFIX = "[PROGRESS]";
+function normalizeProgressLinePrefix(line) {
+  return line.replace(/^(?:\r+|\u001B\[[0-?]*[ -/]*[@-~])+/, "");
+}
+var PROGRESS_PREFIX = "[PROGRESS]", MAX_PROGRESS_SUMMARY_LENGTH = 500, MAX_PENDING_LINE_LENGTH = 4096;
 
 // src/orchestration/orchestration-service.ts
 import { createHash as createHash2 } from "node:crypto";
 import { basename as basename2, isAbsolute as isAbsolute2, normalize } from "node:path";
+function clampWatchTimeout(value) {
+  if (value === undefined)
+    return DEFAULT_TASK_WATCH_TIMEOUT_MS;
+  if (!Number.isFinite(value) || value < 0)
+    return 0;
+  return Math.min(Math.floor(value), MAX_TASK_WATCH_TIMEOUT_MS);
+}
+function clampWatchPollInterval(value) {
+  if (value === undefined)
+    return DEFAULT_TASK_WATCH_POLL_INTERVAL_MS;
+  if (!Number.isFinite(value) || value < 1)
+    return DEFAULT_TASK_WATCH_POLL_INTERVAL_MS;
+  return Math.min(value, MAX_TASK_WATCH_POLL_INTERVAL_MS);
+}
 
 class OrchestrationService {
   deps;
@@ -19818,15 +19890,6 @@ class OrchestrationService {
     this.logEvent("orchestration.group.created", "group created", this.groupContext(group));
     return group;
   }
-  async getGroup(groupId) {
-    const state = await this.deps.loadState();
-    const group = this.ensureGroups(state)[groupId];
-    return group ? { ...group } : null;
-  }
-  async listGroups(coordinatorSession) {
-    const state = await this.deps.loadState();
-    return Object.values(this.ensureGroups(state)).filter((group) => coordinatorSession === undefined || group.coordinatorSession === coordinatorSession).sort((left, right) => left.createdAt.localeCompare(right.createdAt)).map((group) => ({ ...group }));
-  }
   async getGroupSummary(input) {
     const state = await this.deps.loadState();
     const group = this.ensureGroups(state)[input.groupId];
@@ -19949,6 +20012,8 @@ class OrchestrationService {
           resultText: "",
           createdAt: now,
           updatedAt: now,
+          eventSeq: 1,
+          events: [{ seq: 1, at: now, type: "created", status: "running", message: "Task created" }],
           ...input.chatKey ? { chatKey: input.chatKey } : {},
           ...input.replyContextToken ? { replyContextToken: input.replyContextToken } : {},
           ...input.accountId ? { accountId: input.accountId } : {}
@@ -20072,7 +20137,9 @@ class OrchestrationService {
           summary: "",
           resultText: "",
           createdAt: now,
-          updatedAt: now
+          updatedAt: now,
+          eventSeq: 1,
+          events: [{ seq: 1, at: now, type: "created", status, message: "Task created" }]
         };
         if (preflight.normalizedGroupId) {
           const group = this.ensureGroups(state)[preflight.normalizedGroupId];
@@ -20243,6 +20310,11 @@ class OrchestrationService {
           current.summary = message;
           current.resultText = "";
           current.updatedAt = now;
+          this.appendTaskEvent(current, now, "status_changed", {
+            status: "failed",
+            summary: message,
+            message: "Task failed during startup"
+          });
           restoreOrDeleteBinding();
           await this.deps.saveState(state);
           return true;
@@ -20335,6 +20407,11 @@ class OrchestrationService {
       task2.status = input.status ?? "completed";
       task2.summary = input.summary ?? "";
       task2.resultText = stripProgressLines(input.resultText ?? "");
+      this.appendTaskEvent(task2, updatedAt, "status_changed", {
+        status: task2.status,
+        summary: task2.summary,
+        message: task2.status === "completed" ? "Task completed" : task2.status === "failed" ? "Task failed" : "Task cancelled"
+      });
       if (task2.status === "completed" || task2.status === "failed") {
         if (!this.isExternalCoordinatorSession(state, task2.coordinatorSession)) {
           task2.injectionPending = true;
@@ -20363,6 +20440,10 @@ class OrchestrationService {
           resultId: this.deps.createId(),
           resultText: task2.resultText
         };
+        this.appendTaskEvent(task2, updatedAt, "attention_required", {
+          status: task2.status,
+          message: "Task result requires contested review"
+        });
         task2.correctionPending = undefined;
         task2.cancelRequestedAt = undefined;
         task2.cancelCompletedAt = undefined;
@@ -20447,26 +20528,60 @@ 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);
+  async watchTask(input) {
+    const timeoutMs = clampWatchTimeout(input.timeoutMs);
+    const pollIntervalMs = clampWatchPollInterval(input.pollIntervalMs);
+    const afterSeq = Math.max(0, Math.floor(input.afterSeq ?? 0));
+    const mode = input.mode ?? "until_attention_or_terminal";
+    const includeProgress = input.includeProgress ?? true;
     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 };
+        return { status: "not_found", task: null, events: [], nextAfterSeq: afterSeq };
       }
       const snapshot = { ...task };
+      const allEvents = task.events ?? [];
+      const filteredEvents = allEvents.filter((event) => event.seq > afterSeq).filter((event) => includeProgress || event.type !== "progress");
+      const nextAfterSeq = task.eventSeq ?? allEvents.at(-1)?.seq ?? afterSeq;
+      const historyTruncated = allEvents.length > 0 && afterSeq < allEvents[0].seq - 1;
       if (isTerminalTaskStatus2(task.status) && task.reviewPending === undefined) {
-        return { status: "terminal", task: snapshot };
+        return {
+          status: "terminal",
+          task: snapshot,
+          events: filteredEvents.map((event) => ({ ...event })),
+          nextAfterSeq,
+          ...historyTruncated ? { historyTruncated } : {}
+        };
       }
       if (isAttentionRequiredTask(task)) {
-        return { status: "attention_required", task: snapshot };
+        return {
+          status: "attention_required",
+          task: snapshot,
+          events: filteredEvents.map((event) => ({ ...event })),
+          nextAfterSeq,
+          ...historyTruncated ? { historyTruncated } : {}
+        };
+      }
+      if (filteredEvents.length > 0 && mode === "next_event") {
+        return {
+          status: "event",
+          task: snapshot,
+          events: filteredEvents.map((event) => ({ ...event })),
+          nextAfterSeq,
+          ...historyTruncated ? { historyTruncated } : {}
+        };
       }
       const remainingMs = deadline - Date.now();
       if (remainingMs <= 0) {
-        return { status: "timeout", task: snapshot };
+        return {
+          status: "timeout",
+          task: snapshot,
+          events: filteredEvents.map((event) => ({ ...event })),
+          nextAfterSeq,
+          ...historyTruncated ? { historyTruncated } : {}
+        };
       }
       await sleep2(Math.min(pollIntervalMs, remainingMs));
     }
@@ -20550,6 +20665,10 @@ class OrchestrationService {
         status: "open"
       };
       task.updatedAt = now;
+      this.appendTaskEvent(task, now, "attention_required", {
+        status: "blocked",
+        message: input.question.trim()
+      });
       this.bumpGroupUpdated(state, task.groupId, now);
       await this.deps.saveState(state);
       return {
@@ -20607,6 +20726,10 @@ class OrchestrationService {
         lastResumeError: undefined
       };
       task.updatedAt = now;
+      this.appendTaskEvent(task, now, "status_changed", {
+        status: "running",
+        message: "Blocker question answered"
+      });
       this.bumpGroupUpdated(state, task.groupId, now);
       await this.deps.saveState(state);
       return {
@@ -20661,6 +20784,10 @@ class OrchestrationService {
         };
         task.cancelRequestedAt = task.cancelRequestedAt ?? now;
         task.updatedAt = now;
+        this.appendTaskEvent(task, now, "cancel_requested", {
+          status: task.status,
+          message: "Correction requested for misrouted answer"
+        });
         this.bumpGroupUpdated(state, task.groupId, now);
         await this.deps.saveState(state);
         return {
@@ -20679,6 +20806,10 @@ class OrchestrationService {
         task.noticePending = false;
         task.lastNoticeError = undefined;
         task.updatedAt = now;
+        this.appendTaskEvent(task, now, "attention_required", {
+          status: task.status,
+          message: "Task result requires contested review"
+        });
         this.bumpGroupUpdated(state, task.groupId, now);
         await this.deps.saveState(state);
         return {
@@ -20785,6 +20916,10 @@ class OrchestrationService {
           packageId
         };
         task.updatedAt = now;
+        this.appendTaskEvent(task, now, "attention_required", {
+          status: "waiting_for_human",
+          message: task.openQuestion.question
+        });
         this.bumpGroupUpdated(state, task.groupId, now);
       }
       this.ensureHumanQuestionPackages(state)[packageId] = packageRecord;
@@ -20811,84 +20946,6 @@ class OrchestrationService {
       queuedTaskIds: prepared.queuedTaskIds
     };
   }
-  async coordinatorFollowUpHumanPackage(input) {
-    const promptText = input.promptText.trim();
-    if (promptText.length === 0) {
-      throw new Error("promptText must be a non-empty string");
-    }
-    if (input.taskQuestions.length === 0) {
-      throw new Error("taskQuestions must contain at least one question");
-    }
-    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}"`);
-      }
-      const packageRecord = this.ensureHumanQuestionPackages(state)[input.packageId];
-      if (!packageRecord || packageRecord.status !== "active") {
-        throw new Error(`package "${input.packageId}" is not active`);
-      }
-      const latestMessage = packageRecord.messages.at(-1);
-      if (!latestMessage || latestMessage.messageId !== input.priorMessageId) {
-        throw new Error(`package "${input.packageId}" latest message is "${latestMessage?.messageId ?? ""}", not "${input.priorMessageId}"`);
-      }
-      if (!latestMessage.deliveredAt) {
-        throw new Error(`package "${input.packageId}" latest message "${latestMessage.messageId}" is not delivered yet`);
-      }
-      const tasks = input.taskQuestions.map(({ taskId, questionId }) => {
-        const task = state.orchestration.tasks[taskId];
-        if (!task) {
-          throw new Error(`task "${taskId}" does not exist`);
-        }
-        this.assertCoordinatorOwnership(task, input.coordinatorSession);
-        if (!packageRecord.openTaskIds.includes(taskId)) {
-          throw new Error(`task "${taskId}" does not belong to active package "${input.packageId}"`);
-        }
-        this.assertCoordinatorQuestionMatch(task, questionId);
-        return task;
-      });
-      const now = this.deps.now().toISOString();
-      const route = this.resolveFrozenPackageMessageRoute(latestMessage);
-      const messageId = this.deps.createId();
-      const message = {
-        messageId,
-        kind: "follow_up",
-        promptText,
-        createdAt: now,
-        taskQuestions: input.taskQuestions.map((entry) => ({ ...entry })),
-        ...route ? this.serializeFrozenDeliveryRoute(route) : {}
-      };
-      packageRecord.messages.push(message);
-      packageRecord.awaitingReplyMessageId = undefined;
-      packageRecord.updatedAt = now;
-      for (const task of tasks) {
-        task.status = "waiting_for_human";
-        task.openQuestion = {
-          ...task.openQuestion,
-          packageId: input.packageId
-        };
-        task.updatedAt = now;
-        this.bumpGroupUpdated(state, task.groupId, now);
-      }
-      await this.deps.saveState(state);
-      return {
-        coordinatorSession: input.coordinatorSession,
-        packageId: input.packageId,
-        messageId,
-        promptText,
-        route
-      };
-    });
-    await this.deliverHumanQuestionPackageMessage(prepared);
-    return {
-      packageId: prepared.packageId,
-      messageId: prepared.messageId
-    };
-  }
   async retryHumanQuestionPackageDelivery(input) {
     const prepared = await this.mutate(async () => {
       const state = await this.deps.loadState();
@@ -21055,11 +21112,21 @@ class OrchestrationService {
         task.summary = "";
         task.resultText = "";
         task.openQuestion = this.buildReplacementOpenQuestion(task, replacementQuestionId, now, packageId);
+        this.appendTaskEvent(task, now, "attention_required", {
+          status: task.status,
+          message: task.openQuestion.question
+        });
       } else if ((task.status === "completed" || task.status === "failed") && task.chatKey && task.replyContextToken && task.noticeSentAt === undefined) {
         task.noticePending = true;
         task.lastNoticeError = undefined;
       }
       task.updatedAt = now;
+      if (input.decision === "accept") {
+        this.appendTaskEvent(task, now, "status_changed", {
+          status: task.status,
+          message: "Contested result accepted"
+        });
+      }
       this.bumpGroupUpdated(state, task.groupId, now);
       await this.deps.saveState(state);
       return {
@@ -21437,7 +21504,7 @@ class OrchestrationService {
       });
     }
   }
-  async recordTaskProgress(taskId) {
+  async recordTaskProgress(taskId, summary) {
     return await this.mutate(async () => {
       const state = await this.deps.loadState();
       const task = state.orchestration.tasks[taskId];
@@ -21445,6 +21512,21 @@ class OrchestrationService {
         throw new Error(`task "${taskId}" does not exist`);
       }
       task.lastProgressAt = this.deps.now().toISOString();
+      if (summary !== undefined) {
+        const cleaned = sanitizeProgressSummary(summary);
+        if (cleaned.length > 0) {
+          task.lastProgressSummary = cleaned;
+          this.appendTaskEvent(task, task.lastProgressAt, "progress", {
+            status: task.status,
+            summary: cleaned
+          });
+        }
+      } else {
+        this.appendTaskEvent(task, task.lastProgressAt, "progress", {
+          status: task.status,
+          message: "heartbeat"
+        });
+      }
       task.updatedAt = task.lastProgressAt;
       await this.deps.saveState(state);
       return { ...task };
@@ -21492,17 +21574,31 @@ class OrchestrationService {
         const shouldPropagate = task.cancelRequestedAt === undefined;
         task.cancelRequestedAt = task.cancelRequestedAt ?? now;
         task.updatedAt = now;
+        if (shouldPropagate) {
+          this.appendTaskEvent(task, now, "cancel_requested", {
+            status: task.status,
+            message: "Cancellation requested"
+          });
+        }
         this.bumpGroupUpdated(state, task.groupId, now);
         await this.deps.saveState(state);
         return { task: { ...task }, shouldPropagate, closedPackageId: undefined };
       }
       const closedPackageId = this.detachTaskFromQuestionFlows(state, task, now);
+      const wasNeedsConfirmation = task.status === "needs_confirmation";
       task.status = "cancelled";
+      if (wasNeedsConfirmation && task.summary.trim().length === 0) {
+        task.summary = "rejected";
+      }
       task.openQuestion = undefined;
       task.cancelRequestedAt = task.cancelRequestedAt ?? now;
       task.cancelCompletedAt = now;
       task.lastCancelError = undefined;
       task.updatedAt = now;
+      this.appendTaskEvent(task, now, "status_changed", {
+        status: "cancelled",
+        message: "Task cancelled"
+      });
       this.bumpGroupUpdated(state, task.groupId, now);
       await this.deps.saveState(state);
       return { task: { ...task }, shouldPropagate: false, closedPackageId };
@@ -21537,10 +21633,18 @@ class OrchestrationService {
         task.cancelRequestedAt = undefined;
         task.cancelCompletedAt = undefined;
         task.lastCancelError = undefined;
+        this.appendTaskEvent(task, now, "attention_required", {
+          status: task.status,
+          message: task.openQuestion.question
+        });
       } else {
         task.status = "cancelled";
         task.cancelCompletedAt = now;
         task.lastCancelError = undefined;
+        this.appendTaskEvent(task, now, "status_changed", {
+          status: "cancelled",
+          message: "Task cancelled"
+        });
       }
       task.updatedAt = now;
       this.bumpGroupUpdated(state, task.groupId, now);
@@ -21582,6 +21686,10 @@ class OrchestrationService {
       }
       task2.lastCancelError = errorMessage;
       task2.updatedAt = this.deps.now().toISOString();
+      this.appendTaskEvent(task2, task2.updatedAt, "progress", {
+        status: task2.status,
+        message: `Cancellation failed: ${errorMessage}`
+      });
       await this.deps.saveState(state);
       return { ...task2 };
     });
@@ -21639,6 +21747,10 @@ class OrchestrationService {
         task.workerSession = ensuredWorkerSession;
         task.status = "running";
         task.updatedAt = this.deps.now().toISOString();
+        this.appendTaskEvent(task, task.updatedAt, "status_changed", {
+          status: "running",
+          message: "Task approved"
+        });
         state.orchestration.workerBindings[ensuredWorkerSession] = {
           sourceHandle: ensuredWorkerSession,
           coordinatorSession: task.coordinatorSession,
@@ -21697,24 +21809,6 @@ class OrchestrationService {
     this.logEvent("orchestration.task.approved", "task approved", this.taskContext(prepared.task));
     return prepared.task;
   }
-  async rejectTask(input) {
-    const task = await this.mutate(async () => {
-      const state = await this.deps.loadState();
-      const task2 = state.orchestration.tasks[input.taskId];
-      if (!task2) {
-        throw new Error(`task "${input.taskId}" does not exist`);
-      }
-      this.assertCoordinatorOwnership(task2, input.coordinatorSession);
-      this.assertNeedsConfirmation(task2);
-      task2.status = "cancelled";
-      task2.summary = "rejected";
-      task2.updatedAt = this.deps.now().toISOString();
-      await this.deps.saveState(state);
-      return { ...task2 };
-    });
-    this.logEvent("orchestration.task.rejected", "task rejected", this.taskContext(task));
-    return task;
-  }
   async resolveWorkerSession(input) {
     const role = this.normalizeRole(input.role);
     const reusable = await this.deps.findReusableWorkerSession?.({
@@ -22637,6 +22731,20 @@ class OrchestrationService {
       }
     })();
   }
+  appendTaskEvent(task, at, type, details = {}) {
+    const nextSeq = (task.eventSeq ?? 0) + 1;
+    task.eventSeq = nextSeq;
+    const events = task.events ?? [];
+    events.push({
+      seq: nextSeq,
+      at,
+      type,
+      ...details.status ? { status: details.status } : {},
+      ...details.summary ? { summary: details.summary } : {},
+      ...details.message ? { message: details.message } : {}
+    });
+    task.events = events.slice(-MAX_TASK_EVENTS_PER_TASK);
+  }
 }
 function isTerminalTaskStatus2(status) {
   return status === "completed" || status === "failed" || status === "cancelled";
@@ -22644,33 +22752,16 @@ function isTerminalTaskStatus2(status) {
 function isAttentionRequiredTask(task) {
   return task.reviewPending !== undefined || 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((resolve3) => setTimeout(resolve3, ms));
 }
 function isRequestDelegateInput(input) {
   return "sourceKind" in input;
 }
+var MAX_TASK_EVENTS_PER_TASK = 200;
 var init_orchestration_service = __esm(() => {
   init_quota_errors();
-  init_task_wait_timeouts();
+  init_task_watch_timeouts();
 });
 
 // src/orchestration/worker-prompts.ts
@@ -25070,6 +25161,11 @@ async function buildApp(paths, deps = {}) {
   const config2 = await loadConfig(paths.configPath, {
     defaultLoggingLevel: deps.defaultLoggingLevel
   });
+  const reloadRuntimeConfig = async () => {
+    const updated = await configStore.load();
+    replaceRuntimeConfig(config2, updated);
+    return config2;
+  };
   const logger2 = createAppLogger({
     filePath: resolveAppLogPath(paths.configPath),
     level: config2.logging.level,
@@ -25268,32 +25364,39 @@ async function buildApp(paths, deps = {}) {
     };
   };
   const launchWorkerTurn = (input) => {
-    const session = resolveWorkerRuntimeSession(input);
-    session.mcpCoordinatorSession = input.coordinatorSession;
-    session.mcpSourceHandle = input.workerSession;
     const workerDispatch = (async () => {
       let taskRecord;
       try {
+        await reloadRuntimeConfig();
+        const session = resolveWorkerRuntimeSession(input);
+        session.mcpCoordinatorSession = input.coordinatorSession;
+        session.mcpSourceHandle = input.workerSession;
         const progressBuffer = new ProgressLineBuffer;
+        const recordProgress = async (summary) => {
+          try {
+            await orchestration.recordTaskProgress(input.taskId, summary);
+            const taskState = await orchestration.getTask(input.taskId);
+            if (taskState?.chatKey && taskState.replyContextToken && deps.channel) {
+              await deps.channel.notifyTaskProgress(taskState, renderTaskProgress(taskState, summary));
+            }
+          } 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)
+            });
+          }
+        };
         const result = await transport.prompt(session, input.promptText, undefined, undefined, {
           onSegment: async (chunk) => {
-            const summaries = progressBuffer.feed(chunk);
+            const summaries = progressBuffer.feed(chunk, { segmentComplete: true });
             for (const summary of summaries) {
-              try {
-                await orchestration.recordTaskProgress(input.taskId);
-                const taskState = await orchestration.getTask(input.taskId);
-                if (taskState?.chatKey && taskState.replyContextToken && deps.channel) {
-                  await deps.channel.notifyTaskProgress(taskState, renderTaskProgress(taskState, summary));
-                }
-              } 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)
-                });
-              }
+              await recordProgress(summary);
             }
           }
         });
+        for (const summary of progressBuffer.flush()) {
+          await recordProgress(summary);
+        }
         taskRecord = await finalizeWorkerTurn({
           taskId: input.taskId,
           workerSession: input.workerSession,
@@ -25357,6 +25460,7 @@ async function buildApp(paths, deps = {}) {
     },
     stateMutex,
     ensureWorkerSession: async ({ workerSession, targetAgent, workspace, cwd, coordinatorSession }) => {
+      await reloadRuntimeConfig();
       const session = resolveWorkerRuntimeSession({ workerSession, targetAgent, workspace, ...cwd ? { cwd } : {} });
       session.mcpCoordinatorSession = coordinatorSession;
       session.mcpSourceHandle = workerSession;
@@ -25479,6 +25583,9 @@ function replaceRuntimeState(target, source) {
   target.chat_contexts = source.chat_contexts;
   target.orchestration = source.orchestration;
 }
+function replaceRuntimeConfig(target, source) {
+  Object.assign(target, source);
+}
 async function main() {
   const paths = resolveRuntimePaths();
   try {
@@ -26628,6 +26735,7 @@ var init_doctor2 = __esm(async () => {
 init_config_store();
 init_load_config();
 init_ensure_config();
+init_agent_templates();
 init_create_daemon_controller();
 init_daemon_files();
 import { randomUUID as randomUUID4 } from "node:crypto";
@@ -39067,9 +39175,8 @@ function requireHome(env) {
 }
 
 // src/mcp/weacpx-mcp-tools.ts
-init_task_wait_timeouts();
+init_task_watch_timeouts();
 init_quota_errors();
-var groupStatusSchema = exports_external.enum(["pending", "running", "terminal"]);
 var taskStatusSchema = exports_external.enum([
   "needs_confirmation",
   "running",
@@ -39082,6 +39189,7 @@ var taskStatusSchema = exports_external.enum([
 var sortSchema = exports_external.enum(["updatedAt", "createdAt"]);
 var orderSchema = exports_external.enum(["asc", "desc"]);
 var contestedDecisionSchema = exports_external.enum(["accept", "discard"]);
+var taskWatchModeSchema = exports_external.enum(["next_event", "until_attention_or_terminal"]);
 var taskQuestionSchema = exports_external.object({
   taskId: exports_external.string().min(1),
   questionId: exports_external.string().min(1)
@@ -39091,7 +39199,8 @@ function buildWeacpxMcpToolRegistry(input) {
   const tools = [
     {
       name: "delegate_request",
-      description: `Delegate a subtask to another agent under the current coordinator. Pass an absolute workingDirectory for the worker. After this returns status=running, call task_wait with the returned taskId to wait for completion before reporting back to the user; if status=needs_confirmation, wait for the user to approve (task_approve / task_reject) and do not call task_wait yet.${availableAgents && availableAgents.length > 0 ? ` Available agents: ${availableAgents.join(", ")}.` : ""}`,
+      description: `Delegate a subtask to another agent under the current coordinator. Pass an absolute workingDirectory for the worker. Supports MCP Tasks when the client requests task execution: the tool can return a native task handle immediately, then clients can use tasks/get, tasks/result, tasks/list, and tasks/cancel.${availableAgents && availableAgents.length > 0 ? ` Available agents: ${availableAgents.join(", ")}.` : ""}`,
+      execution: { taskSupport: "optional" },
       inputSchema: exports_external.object({
         targetAgent: exports_external.string().min(1),
         task: exports_external.string().min(1),
@@ -39110,71 +39219,46 @@ function buildWeacpxMcpToolRegistry(input) {
       })
     },
     {
-      name: "group_new",
-      description: "Create a new task group under the current coordinator. Use to batch multiple delegate_request calls together; pass the resulting groupId on each delegate so they share lifecycle and cancellation.",
-      inputSchema: exports_external.object({
-        title: exports_external.string().min(1)
-      }).strict(),
-      handler: async (args) => await asToolResult(async () => {
-        const group = await transport.createGroup({
-          coordinatorSession,
-          title: args.title
-        });
-        return createSuccessResult(renderGroupCreated(group), group);
-      })
-    },
-    {
-      name: "group_get",
-      description: "Fetch a single task-group summary under the current coordinator. Use to check aggregate progress when waiting on a batch of delegations.",
-      inputSchema: exports_external.object({
-        groupId: exports_external.string().min(1)
-      }).strict(),
-      handler: async (args) => await asToolResult(async () => {
-        const summary = await transport.getGroup({
-          coordinatorSession,
-          groupId: args.groupId
-        });
-        return createSuccessResult(summary ? renderGroupSummary(summary) : "Group not found.", { group: summary });
-      })
-    },
-    {
-      name: "group_list",
-      description: "List task groups under the current coordinator. Use to recover groupIds for an earlier batch.",
-      inputSchema: exports_external.object({
-        status: groupStatusSchema.optional(),
-        stuck: exports_external.boolean().optional(),
-        sort: sortSchema.optional(),
-        order: orderSchema.optional()
-      }).strict(),
-      handler: async (args) => await asToolResult(async () => {
-        const { status, stuck, sort, order } = args;
-        const summaries = await transport.listGroups({
-          coordinatorSession,
-          ...status !== undefined ? { status } : {},
-          ...stuck !== undefined ? { stuck } : {},
-          ...sort !== undefined ? { sort } : {},
-          ...order !== undefined ? { order } : {}
-        });
-        return createSuccessResult(renderGroupList(summaries), { groups: summaries });
-      })
-    },
-    {
-      name: "group_cancel",
-      description: "Cancel all unfinished tasks in a task group under the current coordinator. Use to abort a batch started via group_new + delegate_request.",
+      name: "delegate_batch",
+      description: `Delegate several subtasks at once. Pass a "tasks" array; when it holds 2+ tasks they are bound to one auto-created group, so their results are reported back to you together when the whole batch finishes — one handoff instead of one interruption per task. Use this whenever you have multiple parallel delegations. Returns one result per task in input order; a task that fails to start carries an "error" field and does not abort the rest. Legacy-style only: it does not support MCP task execution — use delegate_request for a single native task handle.`,
       inputSchema: exports_external.object({
-        groupId: exports_external.string().min(1)
+        title: exports_external.string().min(1).optional(),
+        tasks: exports_external.array(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()
+        }).strict()).min(1)
       }).strict(),
       handler: async (args) => await asToolResult(async () => {
-        const result = await transport.cancelGroup({
+        const { title, tasks } = args;
+        const groupId = tasks.length >= 2 ? (await transport.createGroup({
           coordinatorSession,
-          groupId: args.groupId
-        });
-        return createSuccessResult(renderGroupCancelSuccess(result), result);
+          title: title ?? `Batch delegation (${tasks.length} tasks)`
+        })).groupId : undefined;
+        const results = [];
+        for (const [index, entry] of tasks.entries()) {
+          try {
+            const result = await transport.delegateRequest({
+              coordinatorSession,
+              ...sourceHandle ? { sourceHandle } : {},
+              targetAgent: entry.targetAgent,
+              task: entry.task,
+              ...entry.workingDirectory ? { workingDirectory: entry.workingDirectory } : {},
+              ...entry.role ? { role: entry.role } : {},
+              ...groupId ? { groupId } : {}
+            });
+            results.push({ index, taskId: result.taskId, status: result.status });
+          } catch (error2) {
+            results.push({ index, error: formatToolError(error2) });
+          }
+        }
+        return createSuccessResult(renderDelegateBatchSuccess(groupId, results), { ...groupId ? { groupId } : {}, tasks: results });
       })
     },
     {
       name: "task_get",
-      description: "Fetch a single task under the current coordinator, including the worker's final result and any pending question. Use after task_wait returns to read the actual output before summarizing it for the user, or to inspect a task that requires attention.",
+      description: "Fetch a single task under the current coordinator, including the worker's final result and any pending question. Use to inspect a task snapshot non-blockingly, read the actual output after completion, or inspect a task that requires attention.",
       inputSchema: exports_external.object({
         taskId: exports_external.string().min(1)
       }).strict(),
@@ -39209,7 +39293,7 @@ function buildWeacpxMcpToolRegistry(input) {
     },
     {
       name: "task_approve",
-      description: "Approve a pending task under the current coordinator. Use when delegate_request returned status=needs_confirmation and the user has authorized it; after approval, call task_wait.",
+      description: "Approve a task that delegate_request returned as needs_confirmation, once the user has authorized it. The task then starts running.",
       inputSchema: exports_external.object({
         taskId: exports_external.string().min(1)
       }).strict(),
@@ -39221,23 +39305,9 @@ function buildWeacpxMcpToolRegistry(input) {
         return createSuccessResult(renderTaskApprovalSuccess(task), task);
       })
     },
-    {
-      name: "task_reject",
-      description: "Reject a pending task under the current coordinator. Use when delegate_request returned status=needs_confirmation and the user declined; no task_wait is needed afterwards.",
-      inputSchema: exports_external.object({
-        taskId: exports_external.string().min(1)
-      }).strict(),
-      handler: async (args) => await asToolResult(async () => {
-        const task = await transport.rejectTask({
-          coordinatorSession,
-          taskId: args.taskId
-        });
-        return createSuccessResult(renderTaskRejectionSuccess(task), task);
-      })
-    },
     {
       name: "task_cancel",
-      description: "Request cancellation for a task under the current coordinator. Use to abort a running delegation; the task transitions to a terminal state shortly after.",
+      description: "Cancel a task under the current coordinator. Works in any non-terminal state: a running delegation is aborted, and a task still waiting for approval (needs_confirmation) is rejected. The task transitions to a terminal state shortly after.",
       inputSchema: exports_external.object({
         taskId: exports_external.string().min(1)
       }).strict(),
@@ -39250,24 +39320,28 @@ function buildWeacpxMcpToolRegistry(input) {
       })
     },
     {
-      name: "task_wait",
-      description: `Wait for a task to finish or require attention. Call this immediately after delegate_request (when status=running) unless you intend a fire-and-forget. Returns status=terminal (done; call task_get for the result), status=attention_required (call task_get first to read the task's current status, then branch: needs_confirmation -> task_approve or task_reject; blocked or waiting_for_human -> coordinator_answer_question; reviewPending set -> coordinator_review_contested_result; after resolving, call task_wait again), or status=timeout (still running; call task_wait again or task_get for a snapshot). Defaults: timeout ${DEFAULT_TASK_WAIT_TIMEOUT_MS} ms, poll interval ${DEFAULT_TASK_WAIT_POLL_INTERVAL_MS} ms. Maximums: timeout ${MAX_TASK_WAIT_TIMEOUT_MS} ms, poll interval ${MAX_TASK_WAIT_POLL_INTERVAL_MS} ms.`,
+      name: "task_watch",
+      description: `Long-poll a task for the next event, attention-required state, or terminal state. For MCP-task-capable clients, request task execution for this tool to create a background watcher: the call returns a native task handle immediately, and tasks/result returns when the watch condition is met. The native watcher is single-shot: it runs one watch cycle then terminates, so to keep watching start another task_watch with afterSeq set to the returned nextAfterSeq. Defaults: timeout ${DEFAULT_TASK_WATCH_TIMEOUT_MS} ms, poll interval ${DEFAULT_TASK_WATCH_POLL_INTERVAL_MS} ms. Maximums: timeout ${MAX_TASK_WATCH_TIMEOUT_MS} ms, poll interval ${MAX_TASK_WATCH_POLL_INTERVAL_MS} ms.`,
+      execution: { taskSupport: "optional" },
       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()
+        afterSeq: exports_external.number().int().min(0).optional(),
+        mode: taskWatchModeSchema.optional(),
+        includeProgress: exports_external.boolean().optional(),
+        timeoutMs: exports_external.number().int().min(0).max(MAX_TASK_WATCH_TIMEOUT_MS).optional(),
+        pollIntervalMs: exports_external.number().int().min(1).max(MAX_TASK_WATCH_POLL_INTERVAL_MS).optional()
       }).strict(),
       handler: async (args) => await asToolResult(async () => {
-        const result = await transport.waitTask({
+        const result = await transport.watchTask({
           coordinatorSession,
           ...args
         });
-        return createSuccessResult(renderTaskWaitResult(result), result);
+        return createSuccessResult(renderTaskWatchResult(result), result);
       })
     },
     {
       name: "worker_raise_question",
-      description: "Raise a blocker question for the current bound worker session. Worker-side only: call this from inside a delegated task when you are blocked and need the coordinator's input. Coordinators waiting on a delegation should not call this; use task_wait instead.",
+      description: "Raise a blocker question for the current bound worker session. Worker-side only: call this from inside a delegated task when you are blocked and need the coordinator's input.",
       inputSchema: exports_external.object({
         taskId: exports_external.string().min(1),
         question: exports_external.string().min(1),
@@ -39287,7 +39361,7 @@ function buildWeacpxMcpToolRegistry(input) {
     },
     {
       name: "coordinator_answer_question",
-      description: "Answer a blocked worker question under the current coordinator. Use after task_wait returns status=attention_required and task_get shows a pending question; after answering, call task_wait again to keep waiting for the worker to finish.",
+      description: "Answer a blocked worker question under the current coordinator. Use when task_get shows a pending question.",
       inputSchema: exports_external.object({
         taskId: exports_external.string().min(1),
         questionId: exports_external.string().min(1),
@@ -39317,23 +39391,6 @@ function buildWeacpxMcpToolRegistry(input) {
         return createSuccessResult(renderCoordinatorRequestHumanInputSuccess(result), result);
       })
     },
-    {
-      name: "coordinator_follow_up_human_package",
-      description: "Append a follow-up message to the active human question package under the current coordinator. Use to clarify or add context to an in-flight package created via coordinator_request_human_input.",
-      inputSchema: exports_external.object({
-        packageId: exports_external.string().min(1),
-        priorMessageId: exports_external.string().min(1),
-        taskQuestions: exports_external.array(taskQuestionSchema).min(1),
-        promptText: exports_external.string().min(1)
-      }).strict(),
-      handler: async (args) => await asToolResult(async () => {
-        const result = await transport.coordinatorFollowUpHumanPackage({
-          coordinatorSession,
-          ...args
-        });
-        return createSuccessResult(renderCoordinatorFollowUpHumanPackageSuccess(result), result);
-      })
-    },
     {
       name: "coordinator_review_contested_result",
       description: "Review a contested result under the current coordinator. Use when a worker's result has been challenged and the coordinator must decide accept or discard.",
@@ -39355,8 +39412,7 @@ function buildWeacpxMcpToolRegistry(input) {
   ];
   if (isExternalCoordinator) {
     const externalCoordinatorIncompatibleTools = new Set([
-      "coordinator_request_human_input",
-      "coordinator_follow_up_human_package"
+      "coordinator_request_human_input"
     ]);
     return tools.filter((tool) => !externalCoordinatorIncompatibleTools.has(tool.name));
   }
@@ -39381,35 +39437,24 @@ async function asToolResult(action) {
     return createErrorResult(formatToolError(error2));
   }
 }
-function renderTaskWaitResult(result) {
-  if (result.status === "not_found") {
+function renderTaskWatchResult(result) {
+  if (result.status === "not_found" || !result.task) {
     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}.`,
-      `Next: call task_wait again with this taskId to keep waiting, or task_get for a snapshot.`
-    ].join(`
-`);
-  }
-  if (result.status === "attention_required") {
-    return [
-      `Task ${result.task.taskId} requires attention; current state is ${result.task.status}.`,
-      `Next: call task_get to read the task's current status and any reviewPending / openQuestion fields, then branch by what you see:`,
-      `  - status=needs_confirmation -> task_approve or task_reject`,
-      `  - status=blocked or waiting_for_human -> coordinator_answer_question`,
-      `  - reviewPending set -> coordinator_review_contested_result`,
-      `After resolving, call task_wait again to keep waiting for the worker to finish.`
-    ].join(`
-`);
-  }
-  return [
-    `Task ${result.task.taskId} reached terminal state ${result.task.status}.`,
-    `Next: call task_get to read the worker's final result before reporting back to the user.`
-  ].join(`
+  const header = [
+    `Task ${result.task.taskId} watch ${result.status.replace("_", " ")}; current state is ${result.task.status}.`,
+    `- nextAfterSeq: ${result.nextAfterSeq}`,
+    result.historyTruncated ? "- historyTruncated: true" : ""
+  ].filter((line) => line.length > 0);
+  const events = result.events.length > 0 ? [
+    "- Events:",
+    ...result.events.map((event) => {
+      const detail = event.summary ?? event.message ?? event.status ?? "";
+      return `  - #${event.seq} ${event.type} at ${event.at}${detail ? `: ${detail}` : ""}`;
+    })
+  ] : ["- Events: none"];
+  const next = result.status === "terminal" ? "Next: call task_get to read the final result." : result.status === "attention_required" ? "Next: call task_get to inspect openQuestion / reviewPending, then resolve it with the recommended action tool." : `Next: call task_watch again with afterSeq=${result.nextAfterSeq} to keep watching, preferably as an MCP task if your client supports background task execution.`;
+  return [...header, ...events, next].join(`
 `);
 }
 function createSuccessResult(text, structuredContent) {
@@ -39425,72 +39470,16 @@ function createErrorResult(message) {
   };
 }
 function renderDelegateSuccess(result) {
-  const next = result.status === "needs_confirmation" ? `Next: this delegation requires user approval; do not call task_wait yet. Tell the user, then call task_approve or task_reject based on their response.` : `Next: call task_wait with taskId="${result.taskId}" to wait for the worker to finish, then task_get to read the result before reporting back.`;
+  const next = result.status === "needs_confirmation" ? `Next: this delegation requires user approval. Tell the user, then call task_approve or task_cancel based on their response.` : `Next: task "${result.taskId}" is running. Return this taskId to the user, call task_get/task_list for non-blocking progress snapshots, or task_watch to long-poll for the next event or terminal state.`;
   return [`Delegation task "${result.taskId}" created.`, `- Status: ${result.status}`, next].join(`
 `);
 }
-function renderGroupCreated(group) {
-  return [`Task group "${group.groupId}" created.`, `- Title: ${group.title}`].join(`
-`);
-}
-function renderGroupSummary(summary) {
-  const { group, tasks } = summary;
-  const lines = [
-    `Task group "${group.groupId}"`,
-    `- Title: ${group.title}`,
-    `- Coordinator session: ${group.coordinatorSession}`,
-    `- Total tasks: ${summary.totalTasks}`,
-    `- Pending approval: ${summary.pendingApprovalTasks}`,
-    `- Running: ${summary.runningTasks}`,
-    `- Completed: ${summary.completedTasks}`,
-    `- Failed: ${summary.failedTasks}`,
-    `- Cancelled: ${summary.cancelledTasks}`,
-    `- Terminal: ${summary.terminal ? "yes" : "no"}`
-  ];
-  if (group.injectionPending !== undefined) {
-    lines.push(`- Injection pending: ${group.injectionPending ? "yes" : "no"}`);
-  }
-  if (group.injectionAppliedAt) {
-    lines.push(`- Injection completed at: ${group.injectionAppliedAt}`);
-  }
-  if (group.lastInjectionError) {
-    lines.push(`- Last injection error: ${group.lastInjectionError}`);
-  }
-  if (tasks.length > 0) {
-    lines.push("- Members:");
-    for (const task of tasks) {
-      lines.push(`  - ${task.taskId} [${task.status}] ${task.targetAgent}`);
-    }
-  }
-  return lines.join(`
-`);
-}
-function renderGroupList(groups) {
-  if (groups.length === 0) {
-    return "There are no task groups under the current coordinator.";
-  }
-  return ["Task groups for the current coordinator:", ...groups.map((group) => renderGroupListItem(group))].join(`
-`);
-}
-function renderGroupListItem(group) {
-  const reliability = group.group.injectionPending ? " | injection pending" : "";
-  return [
-    `- ${group.group.groupId}`,
-    group.group.title,
-    `total ${group.totalTasks}`,
-    `pending ${group.pendingApprovalTasks}`,
-    `running ${group.runningTasks}`,
-    `completed ${group.completedTasks}`,
-    `failed ${group.failedTasks}`,
-    `cancelled ${group.cancelledTasks}${reliability}`
-  ].join(" | ");
-}
-function renderGroupCancelSuccess(input) {
-  return [
-    `Task group "${input.summary.group.groupId}" cancellation requested.`,
-    `- Cancel requested: ${input.cancelledTaskIds.length}`,
-    `- Skipped terminal tasks: ${input.skippedTaskIds.length}`
-  ].join(`
+function renderDelegateBatchSuccess(groupId, results) {
+  const lines = results.map((entry) => entry.error ? `  - #${entry.index}: failed to start — ${entry.error}` : `  - #${entry.index}: task "${entry.taskId}" (${entry.status})`);
+  const started = results.filter((entry) => entry.taskId).length;
+  const header = groupId ? `Batch delegation created group "${groupId}" with ${started}/${results.length} tasks started.` : `Delegation: ${started}/${results.length} task started.`;
+  const next = started > 0 ? "Next: track the started tasks with task_get/task_list, or task_watch to long-poll. The group reports all results back together once every task is terminal." : "Next: every task failed to start — fix the errors above and retry.";
+  return [header, "- Tasks:", ...lines, next].join(`
 `);
 }
 function renderTaskList(tasks) {
@@ -39530,6 +39519,8 @@ function renderTaskSummary(task) {
   header.push(`- Task: ${task.task}`);
   if (task.summary.trim().length > 0)
     header.push(`- Summary: ${task.summary}`);
+  if (task.lastProgressSummary)
+    header.push(`- Latest progress: ${task.lastProgressSummary}`);
   if (task.resultText.trim().length > 0)
     header.push(`- Result: ${task.resultText}`);
   const events = [];
@@ -39559,7 +39550,9 @@ function renderTaskSummary(task) {
     events.push({ at: task.updatedAt, event: "injection failed", detail: task.lastInjectionError });
   events.sort((a, b) => a.at.localeCompare(b.at));
   const timeline = events.length > 0 ? ["- Timeline:", ...events.map((e) => `  - [${e.at}] ${e.event}${e.detail ? `: ${e.detail}` : ""}`)] : [];
-  return [...header, ...timeline].join(`
+  const isTerminal2 = task.status === "completed" || task.status === "failed" || task.status === "cancelled";
+  const next = isTerminal2 ? ["Next: summarize this result for the user."] : [];
+  return [...header, ...timeline, ...next].join(`
 `);
 }
 function renderTaskCancelRequest(task) {
@@ -39574,14 +39567,10 @@ function renderTaskApprovalSuccess(task) {
   return [
     `Task "${task.taskId}" approved.`,
     `- Current status: ${task.status}`,
-    `Next: call task_wait with taskId="${task.taskId}" to wait for the worker to finish, then task_get to read the result before reporting back.`
+    `Next: use task_get/task_list for non-blocking progress snapshots, or task_watch to long-poll until the worker finishes; then task_get to read the final result.`
   ].join(`
 `);
 }
-function renderTaskRejectionSuccess(task) {
-  return [`Task "${task.taskId}" rejected.`, `- Current status: ${task.status}`].join(`
-`);
-}
 function renderWorkerRaiseQuestionSuccess(task) {
   return [`Blocker question submitted for task "${task.taskId}".`, `- questionId: ${task.questionId}`].join(`
 `);
@@ -39595,10 +39584,6 @@ function renderCoordinatorRequestHumanInputSuccess(result) {
 `) : [`Queued the question in the current human question queue.`, `- Queued tasks: ${result.queuedTaskIds.length}`].join(`
 `);
 }
-function renderCoordinatorFollowUpHumanPackageSuccess(result) {
-  return [`Appended follow-up to human package "${result.packageId}".`, `- messageId: ${result.messageId}`].join(`
-`);
-}
 function renderCoordinatorReviewContestedResultSuccess(task, decision) {
   const actionText = decision === "accept" ? "Accepted" : "Discarded";
   return [`${actionText} contested result for task "${task.taskId}".`, `- Current status: ${task.status}`].join(`
@@ -39616,7 +39601,7 @@ function formatToolError(error2) {
 
 // src/orchestration/orchestration-client.ts
 init_orchestration_ipc();
-init_task_wait_timeouts();
+init_task_watch_timeouts();
 import { randomUUID } from "node:crypto";
 import { createConnection } from "node:net";
 
@@ -39641,15 +39626,12 @@ class OrchestrationClient {
   async listTasks(filter) {
     return await this.request("task.list", { filter });
   }
-  async waitTask(input) {
-    return await this.request("task.wait", input, getWaitRequestTimeoutMs(input.timeoutMs, this.timeoutMs));
+  async watchTask(input) {
+    return await this.request("task.watch", input, getWatchRequestTimeoutMs(input.timeoutMs, this.timeoutMs));
   }
   async approveTask(input) {
     return await this.request("task.approve", input);
   }
-  async rejectTask(input) {
-    return await this.request("task.reject", input);
-  }
   async cancelTask(input) {
     return await this.request("task.cancel", input);
   }
@@ -39671,24 +39653,12 @@ class OrchestrationClient {
   async coordinatorRequestHumanInput(input) {
     return await this.request("coordinator.request_human_input", input);
   }
-  async coordinatorFollowUpHumanPackage(input) {
-    return await this.request("coordinator.follow_up_human_package", input);
-  }
   async coordinatorReviewContestedResult(input) {
     return await this.request("coordinator.review_contested_result", input);
   }
   async createGroup(input) {
     return await this.request("group.new", input);
   }
-  async getGroup(input) {
-    return await this.request("group.get", input);
-  }
-  async listGroups(input) {
-    return await this.request("group.list", input);
-  }
-  async cancelGroup(input) {
-    return await this.request("group.cancel", input);
-  }
   async request(method, params, timeoutMs = this.timeoutMs) {
     const id = this.createId();
     return await new Promise((resolve, reject) => {
@@ -39755,10 +39725,10 @@ 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);
+function getWatchRequestTimeoutMs(watchTimeoutMs, defaultTimeoutMs) {
+  const requestedWatchTimeoutMs = watchTimeoutMs === undefined ? undefined : Number.isFinite(watchTimeoutMs) ? watchTimeoutMs : 0;
+  const boundedWatchTimeoutMs = Math.min(Math.max(Math.floor(requestedWatchTimeoutMs ?? DEFAULT_TASK_WATCH_TIMEOUT_MS), 0), MAX_TASK_WATCH_TIMEOUT_MS);
+  return Math.max(defaultTimeoutMs, boundedWatchTimeoutMs + TASK_WATCH_RPC_TIMEOUT_PADDING_MS);
 }
 
 // src/mcp/weacpx-mcp-transport.ts
@@ -39774,9 +39744,6 @@ function createOrchestrationTransport(endpoint, deps = {}) {
       ...input.groupId !== undefined ? { groupId: input.groupId } : {}
     }),
     createGroup: async (input) => await client.createGroup(input),
-    getGroup: async (input) => await client.getGroup(input),
-    listGroups: async (input) => await client.listGroups(input),
-    cancelGroup: async (input) => await client.cancelGroup(input),
     getTask: async (input) => await client.getTaskForCoordinator(input),
     listTasks: async (input) => await client.listTasks({
       coordinatorSession: input.coordinatorSession,
@@ -39786,9 +39753,8 @@ function createOrchestrationTransport(endpoint, deps = {}) {
       ...input.order !== undefined ? { order: input.order } : {}
     }),
     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),
+    watchTask: async (input) => await client.watchTask(input),
     workerRaiseQuestion: async (input) => {
       const sourceHandle = input.sourceHandle.trim();
       if (sourceHandle.length === 0) {
@@ -39804,49 +39770,47 @@ function createOrchestrationTransport(endpoint, deps = {}) {
     },
     coordinatorAnswerQuestion: async (input) => await client.coordinatorAnswerQuestion(input),
     coordinatorRequestHumanInput: async (input) => await client.coordinatorRequestHumanInput(input),
-    coordinatorFollowUpHumanPackage: async (input) => await client.coordinatorFollowUpHumanPackage(input),
     coordinatorReviewContestedResult: async (input) => await client.coordinatorReviewContestedResult(input)
   };
 }
 
 // src/mcp/weacpx-mcp-server.ts
+var TASK_OPTIONS_CACHE_LIMIT = 1000;
+var TASKS_LIST_PAGE_SIZE = 100;
+var WATCH_TASKS_CACHE_LIMIT = 256;
 var WEACPX_MCP_SERVER_INSTRUCTIONS = [
   "Use these tools to orchestrate work across other agents under your coordinator session.",
   "",
-  "Typical lifecycle for a single delegation:",
-  "1. delegate_request → returns { taskId, status }.",
-  "   - status=running: the worker has started; go to step 2.",
-  "   - status=needs_confirmation: tell the user, then call task_approve or task_reject based on their response. After task_approve, return to step 2 to wait for the worker. Do not call task_wait before approval.",
-  "2. task_wait(taskId) → blocks until the task is done, needs attention, or times out.",
-  "   - status=terminal: go to step 3.",
-  "   - status=attention_required: the task is in needs_confirmation / blocked / waiting_for_human, or has reviewPending set. Call task_get(taskId) to read the actual status and any openQuestion / reviewPending fields, then branch:",
-  "       * needs_confirmation -> task_approve or task_reject (after approval, go back to step 2)",
-  "       * blocked or waiting_for_human -> coordinator_answer_question (the answer can come from you or be relayed from a human you consulted)",
-  "       * reviewPending set -> coordinator_review_contested_result with accept or discard",
-  "     After resolving, call task_wait again to keep waiting.",
-  "   - status=timeout: the task is still running. Call task_wait again to keep waiting, or task_get for a snapshot.",
-  "3. The task is terminal. Call task_get(taskId) to read the worker's final result, then summarize it for the user. Do not invent results that did not come from task_get.",
+  "Delegate with delegate_request (one task) or delegate_batch (several at once). Each returns a taskId and a status.",
+  "Then follow the task: clients that support MCP Tasks should request task execution on delegate_request / task_watch and poll with tasks/get / tasks/list / tasks/result; other clients use task_get / task_list for snapshots or task_watch to long-poll.",
   "",
-  "Batching: use group_new before a wave of delegate_request calls and pass groupId on each, then group_get / group_list / group_cancel to manage the batch.",
-  "Cancellation: task_cancel aborts a single running task; group_cancel aborts the whole batch.",
-  "Discovery: task_list / group_list recover taskIds and groupIds from earlier in the session.",
+  "Most tool results end with a 'Next:' line telling you the concrete next step — follow it when present. In short: status=needs_confirmation needs task_approve or task_cancel; a task that needs attention (blocked / waiting_for_human / a contested review) is resolved with coordinator_answer_question or coordinator_review_contested_result; a terminal task is read with task_get. Never report a result you did not read from task_get.",
   "",
-  "worker_raise_question is worker-side only — call it from inside a delegated task when you are blocked, not from the coordinator that is waiting on a delegation."
+  "worker_raise_question is worker-side only — call it from inside a delegated task when you are blocked, not from the coordinator waiting on a delegation."
 ].join(`
 `);
 function createWeacpxMcpServer(options) {
+  let getToolState;
+  const taskOptionsById = new Map;
+  const watchTasksById = new Map;
   const server = new Server({
     name: "weacpx-orchestration",
     version: readVersion()
   }, {
     capabilities: {
-      tools: {}
+      tools: {},
+      tasks: {
+        list: {},
+        cancel: {},
+        requests: { tools: { call: {} } }
+      }
     },
-    instructions: WEACPX_MCP_SERVER_INSTRUCTIONS
+    instructions: WEACPX_MCP_SERVER_INSTRUCTIONS,
+    taskStore: createWeacpxTaskStore(async () => await getToolState(), taskOptionsById, watchTasksById)
   });
   let toolState = null;
   let toolStatePromise = null;
-  async function getToolState() {
+  getToolState = async function getToolState2() {
     if (toolState) {
       return toolState;
     }
@@ -39869,14 +39833,15 @@ function createWeacpxMcpServer(options) {
       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))
+        inputSchema: normalizeInputSchemaJson(zodToJsonSchema(tool.inputSchema)),
+        ...tool.execution ? { execution: tool.execution } : {}
       }))
     };
   });
@@ -39890,15 +39855,399 @@ function createWeacpxMcpServer(options) {
     if (!parsed.success) {
       throw new McpError(ErrorCode.InvalidParams, formatZodError(parsed.error));
     }
+    if (request.params.task) {
+      if (tool.name !== "delegate_request" && tool.name !== "task_watch") {
+        throw new McpError(ErrorCode.InvalidParams, `Tool ${tool.name} does not support MCP task execution`);
+      }
+      if (tool.name === "delegate_request") {
+        return await createDelegationMcpTask({
+          state: await getToolState(),
+          args: parsed.data,
+          taskParams: request.params.task,
+          taskOptionsById
+        });
+      }
+      return await createWatchMcpTask({
+        state: await getToolState(),
+        args: parsed.data,
+        taskParams: request.params.task,
+        taskOptionsById,
+        watchTasksById
+      });
+    }
     return await tool.handler(parsed.data);
   });
+  server.setRequestHandler(GetTaskPayloadRequestSchema, async (request) => {
+    const watchTask = watchTasksById.get(request.params.taskId);
+    if (watchTask) {
+      if (!watchTask.result) {
+        throw new McpError(ErrorCode.InvalidRequest, `Task ${request.params.taskId} is still ${watchTask.task.status}`);
+      }
+      watchTasksById.delete(request.params.taskId);
+      return watchTask.result;
+    }
+    const state = await getToolState();
+    const task = await state.transport.getTask({
+      coordinatorSession: state.coordinatorSession,
+      taskId: request.params.taskId
+    });
+    if (!task) {
+      throw new McpError(ErrorCode.InvalidParams, `Task not found: ${request.params.taskId}`);
+    }
+    return withRelatedTaskMeta(renderNativeTaskPayloadResult(task), task.taskId);
+  });
   return server;
 }
 function buildToolState(options) {
   const tools = buildWeacpxMcpToolRegistry(options);
   return {
     tools,
-    toolMap: new Map(tools.map((tool) => [tool.name, tool]))
+    toolMap: new Map(tools.map((tool) => [tool.name, tool])),
+    transport: options.transport,
+    coordinatorSession: options.coordinatorSession,
+    sourceHandle: options.sourceHandle
+  };
+}
+async function createDelegationMcpTask(input) {
+  const delegateTool = input.state.toolMap.get("delegate_request");
+  if (!delegateTool) {
+    throw new McpError(ErrorCode.MethodNotFound, "delegate_request is not registered");
+  }
+  const result = await delegateTool.handler(input.args);
+  if (result.isError) {
+    throw new McpError(ErrorCode.InvalidRequest, result.content.map((item) => item.type === "text" ? item.text : "").filter(Boolean).join(`
+`) || "Delegation failed");
+  }
+  const structured = result.structuredContent;
+  const taskId = typeof structured?.taskId === "string" ? structured.taskId : undefined;
+  if (!taskId) {
+    throw new McpError(ErrorCode.InternalError, "delegate_request did not return a taskId");
+  }
+  rememberTaskOptions(input.taskOptionsById, taskId, input.taskParams);
+  const task = await input.state.transport.getTask({
+    coordinatorSession: input.state.coordinatorSession,
+    taskId
+  });
+  if (!task) {
+    throw new McpError(ErrorCode.InternalError, `delegate_request created task "${taskId}" but it was not readable from orchestration state`);
+  }
+  return {
+    task: toMcpTask(task, input.taskParams)
+  };
+}
+async function createWatchMcpTask(input) {
+  const taskId = input.args.taskId;
+  if (typeof taskId !== "string" || taskId.length === 0) {
+    throw new McpError(ErrorCode.InvalidParams, "task_watch requires taskId");
+  }
+  const baseTask = await input.state.transport.getTask({
+    coordinatorSession: input.state.coordinatorSession,
+    taskId
+  });
+  if (!baseTask) {
+    throw new McpError(ErrorCode.InvalidParams, `Task not found: ${taskId}`);
+  }
+  const now = new Date().toISOString();
+  const watchTaskId = `watch:${taskId}:${Date.now()}:${Math.random().toString(36).slice(2, 10)}`;
+  rememberTaskOptions(input.taskOptionsById, watchTaskId, input.taskParams);
+  const watchTask = toMcpTask({
+    taskId: watchTaskId,
+    status: "running",
+    summary: `Watching task ${taskId}`,
+    createdAt: now,
+    updatedAt: now
+  }, input.taskParams);
+  registerWatchTask(input.watchTasksById, watchTaskId, { task: watchTask });
+  runWatchMcpTask({
+    state: input.state,
+    args: input.args,
+    watchTaskId,
+    taskOptions: input.taskParams,
+    watchTasksById: input.watchTasksById
+  });
+  return {
+    task: watchTask
+  };
+}
+async function runWatchMcpTask(input) {
+  const args = input.args;
+  try {
+    const result = await input.state.transport.watchTask({
+      coordinatorSession: input.state.coordinatorSession,
+      ...args
+    });
+    if (!input.watchTasksById.has(input.watchTaskId))
+      return;
+    const now = new Date().toISOString();
+    const mcpStatus = result.status === "attention_required" ? "input_required" : result.status === "not_found" ? "failed" : "completed";
+    input.watchTasksById.set(input.watchTaskId, {
+      task: {
+        taskId: input.watchTaskId,
+        status: mcpStatus,
+        ttl: input.taskOptions.ttl ?? null,
+        createdAt: input.watchTasksById.get(input.watchTaskId)?.task.createdAt ?? now,
+        lastUpdatedAt: now,
+        ...input.taskOptions.pollInterval !== undefined ? { pollInterval: input.taskOptions.pollInterval } : {},
+        statusMessage: renderWatchTaskStatusMessage(result)
+      },
+      result: withRelatedTaskMeta(renderWatchMcpTaskResult(result, input.watchTaskId), result.task?.taskId ?? input.watchTaskId)
+    });
+  } catch (error2) {
+    if (!input.watchTasksById.has(input.watchTaskId))
+      return;
+    const now = new Date().toISOString();
+    const message = error2 instanceof Error ? error2.message : String(error2);
+    input.watchTasksById.set(input.watchTaskId, {
+      task: {
+        taskId: input.watchTaskId,
+        status: "failed",
+        ttl: input.taskOptions.ttl ?? null,
+        createdAt: input.watchTasksById.get(input.watchTaskId)?.task.createdAt ?? now,
+        lastUpdatedAt: now,
+        statusMessage: message
+      },
+      result: {
+        content: [{ type: "text", text: `Task watch "${input.watchTaskId}" failed: ${message}` }],
+        structuredContent: { watchTaskId: input.watchTaskId, error: message },
+        isError: true
+      }
+    });
+  }
+}
+function renderWatchTaskStatusMessage(result) {
+  if (!result.task)
+    return `Watch finished: ${result.status}`;
+  return `Watch finished for ${result.task.taskId}: ${result.status}; task status ${result.task.status}; events ${result.events?.length ?? 0}`;
+}
+function renderWatchMcpTaskResult(result, watchTaskId) {
+  if (result.status === "not_found" || !result.task) {
+    return {
+      content: [{ type: "text", text: `Task watch "${watchTaskId}" finished: watched task not found.` }],
+      structuredContent: { watchTaskId, ...result },
+      isError: true
+    };
+  }
+  const header = [
+    `Task watch "${watchTaskId}" finished with ${result.status.replace("_", " ")}.`,
+    `Watched task ${result.task.taskId} is ${result.task.status}.`,
+    `nextAfterSeq: ${result.nextAfterSeq}`,
+    result.historyTruncated ? "historyTruncated: true" : ""
+  ].filter((line) => line.length > 0);
+  const events = result.events.length > 0 ? [
+    "Events:",
+    ...result.events.map((event) => {
+      const detail = event.summary ?? event.message ?? event.status ?? "";
+      return `- #${event.seq} ${event.type} at ${event.at}${detail ? `: ${detail}` : ""}`;
+    })
+  ] : ["Events: none"];
+  const next = result.status === "terminal" ? "Next: call task_get on the watched task to read the final result." : result.status === "attention_required" ? "Next: call task_get on the watched task, then resolve openQuestion / reviewPending with the recommended action tool." : `Next: call task_watch again with afterSeq=${result.nextAfterSeq} to keep watching.`;
+  return {
+    content: [{ type: "text", text: [...header, ...events, next].join(`
+`) }],
+    structuredContent: { watchTaskId, ...result }
+  };
+}
+function createWeacpxTaskStore(resolveState, taskOptionsById, watchTasksById) {
+  return {
+    createTask: async () => {
+      throw new Error("weacpx native MCP tasks are created by delegate_request");
+    },
+    getTask: async (taskId) => {
+      const watchTask = watchTasksById.get(taskId);
+      if (watchTask)
+        return watchTask.task;
+      const state = await resolveState();
+      const task = await state.transport.getTask({ coordinatorSession: state.coordinatorSession, taskId });
+      return task ? toMcpTask(task, taskOptionsById.get(taskId)) : null;
+    },
+    storeTaskResult: async () => {
+      throw new Error("weacpx native MCP task results are stored by orchestration");
+    },
+    getTaskResult: async (taskId) => {
+      const watchTask = watchTasksById.get(taskId);
+      if (watchTask) {
+        if (!watchTask.result) {
+          throw new Error(`Task ${taskId} is still ${watchTask.task.status}`);
+        }
+        watchTasksById.delete(taskId);
+        return watchTask.result;
+      }
+      const state = await resolveState();
+      const task = await state.transport.getTask({ coordinatorSession: state.coordinatorSession, taskId });
+      if (!task) {
+        throw new Error(`Task not found: ${taskId}`);
+      }
+      return renderNativeTaskPayloadResult(task);
+    },
+    updateTaskStatus: async (taskId, status, statusMessage) => {
+      const state = await resolveState();
+      if (status === "cancelled") {
+        await state.transport.cancelTask({ coordinatorSession: state.coordinatorSession, taskId });
+        return;
+      }
+      throw new Error(`weacpx MCP task status is read-only (${status}${statusMessage ? `: ${statusMessage}` : ""})`);
+    },
+    listTasks: async (cursor) => {
+      const state = await resolveState();
+      const tasks = await state.transport.listTasks({
+        coordinatorSession: state.coordinatorSession,
+        sort: "updatedAt",
+        order: "desc"
+      });
+      const watchTasks = Array.from(watchTasksById.values()).map((record3) => record3.task);
+      pruneTaskOptions(taskOptionsById, new Set([...tasks.map((task) => task.taskId), ...watchTasks.map((task) => task.taskId)]));
+      const offset = parseTaskListCursor(cursor);
+      const allTasks = [
+        ...watchTasks,
+        ...tasks.map((task) => toMcpTask(task, taskOptionsById.get(task.taskId)))
+      ].sort((a, b) => b.lastUpdatedAt.localeCompare(a.lastUpdatedAt));
+      const page = allTasks.slice(offset, offset + TASKS_LIST_PAGE_SIZE);
+      const nextOffset = offset + page.length;
+      return {
+        tasks: page,
+        ...nextOffset < allTasks.length ? { nextCursor: String(nextOffset) } : {}
+      };
+    }
+  };
+}
+function rememberTaskOptions(taskOptionsById, taskId, options) {
+  taskOptionsById.set(taskId, normalizeCreateTaskOptions(options));
+  while (taskOptionsById.size > TASK_OPTIONS_CACHE_LIMIT) {
+    const oldestKey = taskOptionsById.keys().next().value;
+    if (oldestKey === undefined)
+      break;
+    taskOptionsById.delete(oldestKey);
+  }
+}
+function registerWatchTask(watchTasksById, watchTaskId, record3) {
+  watchTasksById.set(watchTaskId, record3);
+  while (watchTasksById.size > WATCH_TASKS_CACHE_LIMIT) {
+    const oldestKey = watchTasksById.keys().next().value;
+    if (oldestKey === undefined || oldestKey === watchTaskId)
+      break;
+    watchTasksById.delete(oldestKey);
+  }
+}
+function pruneTaskOptions(taskOptionsById, taskIds) {
+  for (const taskId of taskOptionsById.keys()) {
+    if (!taskIds.has(taskId)) {
+      taskOptionsById.delete(taskId);
+    }
+  }
+}
+function parseTaskListCursor(cursor) {
+  if (!cursor)
+    return 0;
+  const offset = Number(cursor);
+  if (!Number.isInteger(offset) || offset < 0) {
+    throw new McpError(ErrorCode.InvalidParams, `Invalid tasks/list cursor: ${cursor}`);
+  }
+  return offset;
+}
+function renderNativeTaskPayloadResult(task) {
+  if (toMcpTaskStatus(task) === "input_required") {
+    return renderInputRequiredTaskResult(task);
+  }
+  if (task.status === "completed" || task.status === "failed" || task.status === "cancelled") {
+    return renderNativeTaskResult(task);
+  }
+  throw new McpError(ErrorCode.InvalidRequest, `Task ${task.taskId} is still ${task.status}; use tasks/get until it is terminal or input_required`);
+}
+function withRelatedTaskMeta(result, taskId) {
+  return {
+    ...result,
+    _meta: {
+      ...result._meta,
+      [RELATED_TASK_META_KEY]: { taskId }
+    }
+  };
+}
+function renderNativeTaskResult(task) {
+  const isError = task.status === "failed" || task.status === "cancelled";
+  const text = [
+    `Task "${task.taskId}" finished with status ${task.status}.`,
+    task.resultText.trim().length > 0 ? task.resultText : task.summary
+  ].filter((line) => line.trim().length > 0).join(`
+`);
+  return {
+    content: [{ type: "text", text }],
+    structuredContent: { task },
+    ...isError ? { isError: true } : {}
+  };
+}
+function renderInputRequiredTaskResult(task) {
+  const actions = inputRequiredActions(task);
+  const text = [
+    `Task "${task.taskId}" requires input before it can continue.`,
+    task.summary.trim().length > 0 ? task.summary : "",
+    task.openQuestion ? `Open question: ${task.openQuestion.question}` : "",
+    `Next: call task_get("${task.taskId}") to inspect details, then ${actions.join(" or ")}.`
+  ].filter((line) => line.trim().length > 0).join(`
+`);
+  return {
+    content: [{ type: "text", text }],
+    structuredContent: {
+      task,
+      nextAction: {
+        kind: "input_required",
+        taskId: task.taskId,
+        recommendedTools: actions
+      }
+    }
+  };
+}
+function inputRequiredActions(task) {
+  const actions = [];
+  if (task.status === "needs_confirmation") {
+    actions.push("task_approve", "task_cancel");
+  }
+  if (task.status === "blocked" || task.status === "waiting_for_human" || task.openQuestion) {
+    actions.push("coordinator_answer_question");
+  }
+  if (task.reviewPending) {
+    actions.push("coordinator_review_contested_result");
+  }
+  return actions.length > 0 ? actions : ["task_get"];
+}
+function toMcpTask(task, options = {}) {
+  const statusMessage = mcpTaskStatusMessage(task);
+  return {
+    taskId: task.taskId,
+    status: toMcpTaskStatus(task),
+    ttl: options.ttl ?? null,
+    createdAt: task.createdAt,
+    lastUpdatedAt: task.updatedAt,
+    ...options.pollInterval !== undefined ? { pollInterval: options.pollInterval } : {},
+    ...statusMessage ? { statusMessage } : {}
+  };
+}
+function mcpTaskStatusMessage(task) {
+  const lines = [
+    task.summary.trim().length > 0 ? task.summary : "",
+    task.lastProgressSummary ? `Latest progress: ${task.lastProgressSummary}` : "",
+    task.lastProgressAt ? `Last progress at: ${task.lastProgressAt}` : ""
+  ].filter((line) => line.trim().length > 0);
+  return lines.length > 0 ? lines.join(`
+`) : undefined;
+}
+function toMcpTaskStatus(task) {
+  if (task.reviewPending !== undefined)
+    return "input_required";
+  if (task.status === "completed")
+    return "completed";
+  if (task.status === "failed")
+    return "failed";
+  if (task.status === "cancelled")
+    return "cancelled";
+  if (task.status === "needs_confirmation" || task.status === "blocked" || task.status === "waiting_for_human") {
+    return "input_required";
+  }
+  return "working";
+}
+function normalizeCreateTaskOptions(options) {
+  return {
+    ttl: options.ttl ?? null,
+    ...options.pollInterval !== undefined ? { pollInterval: options.pollInterval } : {}
   };
 }
 async function resolveMcpIdentity(server, options) {
@@ -41834,6 +42183,7 @@ var HELP_LINES = [
   "weacpx plugin list|add|update|remove|enable|disable|doctor|known - 管理插件",
   "weacpx doctor - 运行诊断",
   "weacpx version - 查看版本",
+  "weacpx agent|agents list|add|rm|templates - 管理本机 Agent",
   "weacpx workspace list|add|rm - 管理本机工作区（别名：ws）",
   "weacpx mcp-stdio [--coordinator-session <session>] [--source-handle <handle>] [--workspace <name>] - 启动 MCP stdio 服务"
 ];
@@ -41911,6 +42261,17 @@ async function runCli(args, deps = {}) {
       }
       return result;
     }
+    case "agent":
+    case "agents": {
+      const result = await handleAgentCli(args.slice(1), { print });
+      if (result === null) {
+        for (const line of HELP_LINES) {
+          print(line);
+        }
+        return 1;
+      }
+      return result;
+    }
     case "plugin": {
       const result = await handlePluginCli(args.slice(1), await createPluginCliDeps({
         print,
@@ -42152,6 +42513,93 @@ async function workspaceRemove(rawName, print) {
   print(`工作区「${name}」已删除`);
   return 0;
 }
+async function handleAgentCli(args, deps) {
+  const subcommand = args[0];
+  switch (subcommand) {
+    case "list":
+      if (args.length !== 1)
+        return null;
+      return await agentList(deps.print);
+    case "templates":
+      if (args.length !== 1)
+        return null;
+      return agentTemplates(deps.print);
+    case "add":
+      if (args.length !== 2 || !args[1])
+        return null;
+      return await agentAdd(args[1], deps.print);
+    case "rm":
+      if (args.length !== 2 || !args[1])
+        return null;
+      return await agentRemove(args[1], deps.print);
+    default:
+      return null;
+  }
+}
+async function agentList(print) {
+  const store = await createCliConfigStore();
+  const config2 = await store.load();
+  const entries = Object.entries(config2.agents);
+  if (entries.length === 0) {
+    print("还没有 Agent。");
+    return 0;
+  }
+  print("Agent 列表：");
+  for (const [name, agent] of entries) {
+    const command = agent.command ? ` command=${agent.command}` : "";
+    print(`- ${name}: driver=${agent.driver}${command}`);
+  }
+  return 0;
+}
+function agentTemplates(print) {
+  print("可用 Agent 模板：");
+  for (const name of listAgentTemplates()) {
+    print(`- ${name}`);
+  }
+  return 0;
+}
+async function agentAdd(rawName, print) {
+  const name = rawName.trim();
+  if (name.length === 0) {
+    print("Agent 名称不能为空。");
+    return 1;
+  }
+  const template = getAgentTemplate(name);
+  if (!template) {
+    print(`暂不支持这个 Agent 模板。当前可用：${listAgentTemplates().join("、")}`);
+    return 1;
+  }
+  const store = await createCliConfigStore();
+  const config2 = await store.load();
+  const existing = config2.agents[name];
+  if (existing) {
+    if (sameAgentConfig(existing, template)) {
+      print(`Agent「${name}」已存在`);
+      return 0;
+    }
+    print(`Agent「${name}」已存在且配置不同。请先执行：weacpx agent rm ${name}`);
+    return 1;
+  }
+  await store.upsertAgent(name, template);
+  print(`Agent「${name}」已保存`);
+  return 0;
+}
+async function agentRemove(rawName, print) {
+  const name = rawName.trim();
+  if (name.length === 0) {
+    print("Agent 名称不能为空。");
+    return 1;
+  }
+  const store = await createCliConfigStore();
+  const config2 = await store.load();
+  if (!config2.agents[name]) {
+    print(`没有找到 Agent「${name}」。`);
+    return 1;
+  }
+  await store.removeAgent(name);
+  print(`Agent「${name}」已删除`);
+  return 0;
+}
 async function createCliConfigStore() {
   const configPath = process.env.WEACPX_CONFIG ?? `${requireHome2()}/.weacpx/config.json`;
   await ensureConfigExists(configPath);