weacpx 0.4.3 → 0.4.5

package/dist/cli.js

@@ -2225,6 +2225,28 @@ function parseConfig(raw, options = {}) {
       throw new Error(`logging.${field} must be a positive number`);
     }
   }
+  if (isRecord(logging) && "perf" in logging) {
+    if (!isRecord(logging.perf)) {
+      throw new Error("logging.perf must be an object");
+    }
+    if ("enabled" in logging.perf && typeof logging.perf.enabled !== "boolean") {
+      throw new Error("logging.perf.enabled must be boolean");
+    }
+    for (const field of ["maxSizeBytes", "maxFiles", "retentionDays"]) {
+      if (field in logging.perf) {
+        const value = logging.perf[field];
+        if (typeof value !== "number" || !Number.isFinite(value)) {
+          throw new Error(`logging.perf.${field} must be a finite number`);
+        }
+        if (field === "maxFiles" && value < 0) {
+          throw new Error(`logging.perf.${field} must be non-negative`);
+        }
+        if (field !== "maxFiles" && value <= 0) {
+          throw new Error(`logging.perf.${field} must be a positive number`);
+        }
+      }
+    }
+  }
   for (const [name, agent] of Object.entries(raw.agents)) {
     if (!isRecord(agent) || typeof agent.driver !== "string" || agent.driver.length === 0) {
       throw new Error(`agent "${name}" must define a non-empty driver`);
@@ -2280,7 +2302,16 @@ function parseConfig(raw, options = {}) {
       level: resolvedLoggingLevel,
       maxSizeBytes: typeof logging?.maxSizeBytes === "number" ? logging.maxSizeBytes : DEFAULT_LOGGING_CONFIG.maxSizeBytes,
       maxFiles: typeof logging?.maxFiles === "number" ? logging.maxFiles : DEFAULT_LOGGING_CONFIG.maxFiles,
-      retentionDays: typeof logging?.retentionDays === "number" ? logging.retentionDays : DEFAULT_LOGGING_CONFIG.retentionDays
+      retentionDays: typeof logging?.retentionDays === "number" ? logging.retentionDays : DEFAULT_LOGGING_CONFIG.retentionDays,
+      perf: (() => {
+        const perfRaw = isRecord(logging?.perf) ? logging.perf : undefined;
+        return {
+          enabled: typeof perfRaw?.enabled === "boolean" ? perfRaw.enabled : DEFAULT_PERF_LOG_CONFIG.enabled,
+          maxSizeBytes: typeof perfRaw?.maxSizeBytes === "number" && Number.isFinite(perfRaw.maxSizeBytes) && perfRaw.maxSizeBytes > 0 ? perfRaw.maxSizeBytes : DEFAULT_PERF_LOG_CONFIG.maxSizeBytes,
+          maxFiles: typeof perfRaw?.maxFiles === "number" && Number.isFinite(perfRaw.maxFiles) && perfRaw.maxFiles >= 0 ? perfRaw.maxFiles : DEFAULT_PERF_LOG_CONFIG.maxFiles,
+          retentionDays: typeof perfRaw?.retentionDays === "number" && Number.isFinite(perfRaw.retentionDays) && perfRaw.retentionDays > 0 ? perfRaw.retentionDays : DEFAULT_PERF_LOG_CONFIG.retentionDays
+        };
+      })()
     },
     channel: channelConfig,
     channels: channelsConfig,
@@ -2390,14 +2421,21 @@ function parseOrchestrationConfig(raw) {
     progressHeartbeatSeconds: typeof raw.progressHeartbeatSeconds === "number" && Number.isFinite(raw.progressHeartbeatSeconds) ? raw.progressHeartbeatSeconds : DEFAULT_ORCHESTRATION_CONFIG.progressHeartbeatSeconds
   };
 }
-var DEFAULT_LOGGING_CONFIG, DEFAULT_PERMISSION_MODE = "approve-all", DEFAULT_NON_INTERACTIVE_PERMISSIONS = "deny", DEFAULT_CHANNEL_CONFIG, DEFAULT_ORCHESTRATION_CONFIG;
+var DEFAULT_PERF_LOG_CONFIG, DEFAULT_LOGGING_CONFIG, DEFAULT_PERMISSION_MODE = "approve-all", DEFAULT_NON_INTERACTIVE_PERMISSIONS = "deny", DEFAULT_CHANNEL_CONFIG, DEFAULT_ORCHESTRATION_CONFIG;
 var init_load_config = __esm(() => {
   init_workspace_path();
+  DEFAULT_PERF_LOG_CONFIG = {
+    enabled: false,
+    maxSizeBytes: 5 * 1024 * 1024,
+    maxFiles: 3,
+    retentionDays: 7
+  };
   DEFAULT_LOGGING_CONFIG = {
     level: "info",
     maxSizeBytes: 2 * 1024 * 1024,
     maxFiles: 5,
-    retentionDays: 7
+    retentionDays: 7,
+    perf: DEFAULT_PERF_LOG_CONFIG
   };
   DEFAULT_CHANNEL_CONFIG = {
     type: "weixin",
@@ -2552,7 +2590,13 @@ var init_ensure_config = __esm(() => {
       level: "info",
       maxSizeBytes: 2 * 1024 * 1024,
       maxFiles: 5,
-      retentionDays: 7
+      retentionDays: 7,
+      perf: {
+        enabled: false,
+        maxSizeBytes: 5242880,
+        maxFiles: 3,
+        retentionDays: 7
+      }
     },
     channel: {
       type: "weixin",
@@ -2567,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";
@@ -2837,6 +2957,7 @@ function buildSpawnRequest(paths, options, stdoutFd, stderrFd, spawnOptions = {}
           WEACPX_DAEMON_ARG0: options.cliEntryPath,
           WEACPX_DAEMON_ARG1: "run",
           WEACPX_DAEMON_CWD: options.cwd,
+          WEACPX_DAEMON_RUN: "1",
           WEACPX_DAEMON_STDOUT: paths.stdoutLog,
           WEACPX_DAEMON_STDERR: paths.stderrLog,
           ...spawnOptions.firstRunOnboarding ? { WEACPX_FIRST_RUN_ONBOARDING: spawnOptions.firstRunOnboarding } : {}
@@ -2855,6 +2976,7 @@ function buildSpawnRequest(paths, options, stdoutFd, stderrFd, spawnOptions = {}
       detached: true,
       env: {
         ...options.env,
+        WEACPX_DAEMON_RUN: "1",
         ...spawnOptions.firstRunOnboarding ? { WEACPX_FIRST_RUN_ONBOARDING: spawnOptions.firstRunOnboarding } : {}
       },
       stdio: ["ignore", stdoutFd, stderrFd]
@@ -2863,6 +2985,7 @@ function buildSpawnRequest(paths, options, stdoutFd, stderrFd, spawnOptions = {}
 }
 function buildWindowsLauncherScript() {
   const script = [
+    "$env:WEACPX_DAEMON_RUN = '1'",
     "$process = Start-Process -FilePath $env:WEACPX_DAEMON_COMMAND `",
     "  -ArgumentList @($env:WEACPX_DAEMON_ARG0, $env:WEACPX_DAEMON_ARG1) `",
     "  -WorkingDirectory $env:WEACPX_DAEMON_CWD `",
@@ -9495,10 +9618,11 @@ 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 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, 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_wait_timeouts = __esm(() => {
   DEFAULT_TASK_WAIT_TIMEOUT_MS = 5 * 60000;
   MAX_TASK_WAIT_TIMEOUT_MS = 20 * 60000;
+  MAX_TASK_WATCH_TIMEOUT_MS = 20 * 60000;
 });
 
 // src/weixin/messaging/quota-errors.ts
@@ -9560,6 +9684,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;
@@ -9582,7 +9715,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)) {
@@ -9846,37 +9979,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";
@@ -13147,6 +13249,296 @@ function normalizeMediaArray(media) {
   return Array.isArray(media) ? media : [media];
 }
 
+// src/logging/rotating-file-writer.ts
+import { readdir as readdir2, rename, rm as rm5, stat as stat2 } from "node:fs/promises";
+import { basename, dirname as dirname6, join as join4 } from "node:path";
+async function rotateIfNeeded(filePath, incomingSize, maxSizeBytes, maxFiles) {
+  let currentSize = 0;
+  try {
+    currentSize = (await stat2(filePath)).size;
+  } catch (error2) {
+    if (!isMissingFileError2(error2)) {
+      throw error2;
+    }
+  }
+  if (currentSize + incomingSize <= maxSizeBytes) {
+    return;
+  }
+  if (currentSize === 0) {
+    return;
+  }
+  if (maxFiles <= 0) {
+    await rm5(filePath, { force: true });
+    return;
+  }
+  await rm5(`${filePath}.${maxFiles}`, { force: true });
+  for (let index = maxFiles - 1;index >= 1; index -= 1) {
+    const source = `${filePath}.${index}`;
+    try {
+      await rename(source, `${filePath}.${index + 1}`);
+    } catch (error2) {
+      if (!isMissingFileError2(error2)) {
+        throw error2;
+      }
+    }
+  }
+  await rename(filePath, `${filePath}.1`);
+}
+async function cleanupExpiredRotatedLogs(filePath, retentionDays, now) {
+  const parentDir = dirname6(filePath);
+  const prefix = `${basename(filePath)}.`;
+  const cutoff = now().getTime() - retentionDays * 24 * 60 * 60 * 1000;
+  let files = [];
+  try {
+    files = await readdir2(parentDir);
+  } catch (error2) {
+    if (isMissingFileError2(error2)) {
+      return;
+    }
+    throw error2;
+  }
+  for (const file of files) {
+    if (!file.startsWith(prefix) || !/^\d+$/.test(file.slice(prefix.length))) {
+      continue;
+    }
+    const candidate = join4(parentDir, file);
+    const details = await stat2(candidate);
+    if (details.mtime.getTime() < cutoff) {
+      await rm5(candidate, { force: true });
+    }
+  }
+}
+function isMissingFileError2(error2) {
+  return typeof error2 === "object" && error2 !== null && "code" in error2 && error2.code === "ENOENT";
+}
+var init_rotating_file_writer = () => {};
+
+// src/perf/perf-log-writer.ts
+import { appendFile as fsAppendFile, mkdir as fsMkdir } from "node:fs/promises";
+import { dirname as dirname7 } from "node:path";
+function createPerfLogWriter(options) {
+  const append = options.appendImpl ?? ((p, d) => fsAppendFile(p, d, "utf8"));
+  const mkdir8 = options.mkdirImpl ?? ((p, o) => fsMkdir(p, o).then(() => {
+    return;
+  }));
+  const now = options.now ?? (() => new Date);
+  const threshold = options.failureThreshold ?? 5;
+  let pending = [];
+  let writeChain = Promise.resolve();
+  let consecutiveFailures = 0;
+  let disabled = false;
+  let notified = false;
+  const writer = {
+    enqueue(line) {
+      if (disabled)
+        return;
+      pending.push(line);
+      scheduleDrain();
+    },
+    async flush() {
+      await scheduleDrain();
+      await writeChain;
+    },
+    async cleanup() {
+      if (disabled)
+        return;
+      try {
+        await cleanupExpiredRotatedLogs(options.filePath, options.retentionDays ?? 7, now);
+      } catch {}
+    },
+    isDisabled() {
+      return disabled;
+    }
+  };
+  return writer;
+  function scheduleDrain() {
+    if (disabled || pending.length === 0) {
+      return writeChain;
+    }
+    const batch = pending;
+    pending = [];
+    writeChain = writeChain.catch(() => {}).then(() => drainBatch(batch));
+    return writeChain;
+  }
+  async function drainBatch(batch) {
+    if (disabled)
+      return;
+    const data = batch.join("");
+    try {
+      await mkdir8(dirname7(options.filePath), { recursive: true });
+      await rotateIfNeeded(options.filePath, Buffer.byteLength(data), options.maxSizeBytes, options.maxFiles);
+      await append(options.filePath, data);
+      consecutiveFailures = 0;
+    } catch (err) {
+      consecutiveFailures += 1;
+      if (consecutiveFailures >= threshold) {
+        disabled = true;
+        pending = [];
+        if (!notified) {
+          notified = true;
+          options.onPermanentFailure({
+            perfLogPath: options.filePath,
+            failureCount: consecutiveFailures,
+            lastError: err instanceof Error ? err.message : String(err)
+          });
+        }
+      }
+    }
+  }
+}
+var init_perf_log_writer = __esm(() => {
+  init_rotating_file_writer();
+});
+
+// src/perf/perf-tracer.ts
+import { randomBytes } from "node:crypto";
+function createNoopPerfTracer() {
+  return {
+    async wrapTurn(_seed, run) {
+      return run(NOOP_SPAN);
+    },
+    async flush() {},
+    async cleanup() {}
+  };
+}
+function createPerfTracer(options) {
+  const now = options.now ?? (() => performance.now());
+  const isoNow = options.isoNow ?? (() => new Date);
+  const randomId = options.randomId ?? defaultRandomId;
+  const formatLine = options.formatLine ?? defaultFormatLine;
+  const formatSummary = options.formatSummaryLine ?? defaultFormatSummaryLine;
+  let disabled = false;
+  const writer = createPerfLogWriter({
+    filePath: options.filePath,
+    maxSizeBytes: options.maxSizeBytes,
+    maxFiles: options.maxFiles,
+    retentionDays: options.retentionDays,
+    onPermanentFailure: (info) => {
+      disabled = true;
+      options.appLogger.error("perf.disabled_due_to_io_error", "perf logging disabled after repeated IO failures", {
+        perfLogPath: info.perfLogPath,
+        failureCount: info.failureCount,
+        lastError: info.lastError
+      }).catch(() => {});
+    }
+  });
+  return {
+    async wrapTurn(seed, run) {
+      if (disabled) {
+        return run(NOOP_SPAN);
+      }
+      const traceId = randomId();
+      let startTime;
+      const marks = [];
+      let lastMarkTime;
+      let explicitOutcome;
+      let outcomeContext;
+      const span = {
+        traceId,
+        mark(event, context) {
+          if (disabled)
+            return;
+          try {
+            const t = now();
+            if (startTime === undefined) {
+              startTime = t;
+              lastMarkTime = t;
+            }
+            const since = t - startTime;
+            const sinceLast = t - lastMarkTime;
+            lastMarkTime = t;
+            marks.push({ e: event, t: Math.round(since) });
+            const line = formatLine({
+              isoNow: isoNow(),
+              event,
+              traceId,
+              chatKey: seed.chatKey,
+              sinceStartMs: Math.round(since),
+              sinceLastMs: Math.round(sinceLast),
+              context
+            });
+            writer.enqueue(line);
+          } catch {}
+        },
+        setOutcome(outcome, context) {
+          explicitOutcome = outcome;
+          outcomeContext = context;
+        }
+      };
+      let thrown;
+      try {
+        return await run(span);
+      } catch (err) {
+        thrown = err;
+        throw err;
+      } finally {
+        try {
+          if (!disabled) {
+            let outcome;
+            if (explicitOutcome !== undefined) {
+              outcome = explicitOutcome;
+            } else if (thrown !== undefined) {
+              outcome = "error";
+            } else {
+              outcome = "ok";
+            }
+            const t = now();
+            const effectiveStart = startTime ?? t;
+            const summary = formatSummary({
+              isoNow: isoNow(),
+              traceId,
+              chatKey: seed.chatKey,
+              kind: seed.kind,
+              outcome,
+              totalMs: Math.round(t - effectiveStart),
+              marks,
+              outcomeContext
+            });
+            writer.enqueue(summary);
+          }
+        } catch {}
+      }
+    },
+    async flush() {
+      await writer.flush();
+    },
+    async cleanup() {
+      await writer.cleanup();
+    }
+  };
+}
+function defaultRandomId() {
+  return randomBytes(6).toString("hex");
+}
+function defaultFormatLine(args) {
+  const ctxFields = args.context ? Object.entries(args.context).filter(([, v]) => v !== undefined).map(([k, v]) => `${k}=${formatValue(v)}`).join(" ") : "";
+  const ctxPrefix = ctxFields ? ` ${ctxFields}` : "";
+  return `${args.isoNow.toISOString()} PERF ${args.event} trace=${args.traceId} chatKey=${formatValue(args.chatKey)}${ctxPrefix} sinceStartMs=${args.sinceStartMs} sinceLastMs=${args.sinceLastMs}
+`;
+}
+function defaultFormatSummaryLine(args) {
+  const extra = args.outcomeContext ? " " + Object.entries(args.outcomeContext).filter(([, v]) => v !== undefined).map(([k, v]) => `${k}=${formatValue(v)}`).join(" ") : "";
+  const marksJson = JSON.stringify(args.marks);
+  return `${args.isoNow.toISOString()} PERF turn.done trace=${args.traceId} chatKey=${formatValue(args.chatKey)} kind=${formatValue(args.kind)} outcome=${formatValue(args.outcome)} totalMs=${args.totalMs}${extra} marks=${JSON.stringify(marksJson)}
+`;
+}
+function formatValue(value) {
+  if (value === null)
+    return "null";
+  if (typeof value === "number" || typeof value === "boolean")
+    return String(value);
+  return JSON.stringify(value);
+}
+var NOOP_SPAN;
+var init_perf_tracer = __esm(() => {
+  init_perf_log_writer();
+  NOOP_SPAN = {
+    traceId: "-",
+    mark: () => {},
+    setOutcome: () => {}
+  };
+});
+
 // src/weixin/messaging/handle-weixin-message-turn.ts
 import crypto4 from "node:crypto";
 import fs8 from "node:fs/promises";
@@ -13278,6 +13670,9 @@ function isClearSlashCommand(textBody) {
   const command = spaceIdx === -1 ? trimmed.toLowerCase() : trimmed.slice(0, spaceIdx).toLowerCase();
   return command === "/clear";
 }
+function isSlashCommandText(textBody) {
+  return textBody.startsWith("/");
+}
 function getWeixinMessageTurnLane(full) {
   const textBody = extractTextBody(full.item_list).trim().toLowerCase();
   return textBody === "/cancel" || textBody === "/stop" || textBody === "/jx" ? "control" : "normal";
@@ -13343,230 +13738,300 @@ async function handleWeixinMessageTurn(full, deps) {
       }
     }).catch(() => {});
   };
-  const contextToken = full.context_token;
-  if (contextToken) {
-    setContextToken(deps.accountId, full.from_user_id ?? "", contextToken);
-  }
-  if (textBody.startsWith("/")) {
-    const shouldTypeForSlash = isClearSlashCommand(textBody);
-    if (shouldTypeForSlash) {
-      startTypingIndicator();
-    }
-    const chatKey = buildWeixinChatKey(deps.accountId, full.from_user_id ?? "");
-    try {
-      const slashResult = await handleSlashCommand(textBody, {
-        to,
-        contextToken: full.context_token,
-        baseUrl: deps.baseUrl,
-        token: deps.token,
-        accountId: deps.accountId,
-        log: deps.log,
-        errLog: deps.errLog,
-        onClear: () => deps.agent.clearSession?.(chatKey),
-        ...deps.hasPendingFinal ? { hasPendingFinal: deps.hasPendingFinal } : {},
-        ...deps.drainPendingFinal ? { drainPendingFinal: deps.drainPendingFinal } : {},
-        ...deps.prependPendingFinal ? { prependPendingFinal: deps.prependPendingFinal } : {},
-        ...deps.reserveFinal ? { reserveFinal: deps.reserveFinal } : {},
-        ...deps.finalRemaining ? { finalRemaining: deps.finalRemaining } : {}
-      }, receivedAt, full.create_time_ms);
-      if (slashResult.handled)
-        return;
-    } finally {
+  const chatKey = buildWeixinChatKey(deps.accountId, fromUserId);
+  const initialMediaCount = extractWeixinMediaDescriptors(full.item_list).length;
+  const isSlashCommand = isSlashCommandText(textBody);
+  const tracer = deps.perfTracer ?? createNoopPerfTracer();
+  return await tracer.wrapTurn({ chatKey, kind: isSlashCommand ? "command" : "prompt" }, async (perfSpan) => {
+    perfSpan.mark("turn.received", {
+      textLen: textBody.length,
+      hasMedia: initialMediaCount > 0,
+      mediaCount: initialMediaCount
+    });
+    const contextToken = full.context_token;
+    if (contextToken) {
+      setContextToken(deps.accountId, full.from_user_id ?? "", contextToken);
+    }
+    if (isSlashCommand) {
+      const shouldTypeForSlash = isClearSlashCommand(textBody);
       if (shouldTypeForSlash) {
-        stopTypingIndicator();
-      }
-    }
-  }
-  startTypingIndicator();
-  const mediaStore = deps.mediaStore ?? new RuntimeMediaStore({ rootDir: resolveMediaTempDir(deps.mediaTempDir) });
-  const media = [];
-  const attachmentNotes = [];
-  const descriptors = extractWeixinMediaDescriptors(full.item_list).slice(0, DEFAULT_MAX_ATTACHMENTS_PER_MESSAGE);
-  const download = deps.downloadMediaFromItemFn ?? downloadMediaFromItem;
-  for (const descriptor of descriptors) {
-    try {
-      const downloaded = await download(descriptor.item, {
-        cdnBaseUrl: deps.cdnBaseUrl,
-        saveMedia: createSaveMediaBuffer(deps.mediaTempDir),
-        log: deps.log,
-        errLog: deps.errLog,
-        label: "inbound"
-      });
-      const filePath = downloaded.decryptedPicPath ?? downloaded.decryptedVideoPath ?? downloaded.decryptedFilePath ?? downloaded.decryptedVoicePath;
-      if (!filePath) {
-        attachmentNotes.push(`Skipped ${descriptor.kind}: media was unavailable.`);
-        continue;
+        startTypingIndicator();
       }
       try {
-        const buffer = await fs8.readFile(filePath);
-        const mimeType = downloaded.fileMediaType ?? downloaded.voiceMediaType ?? defaultWeixinMime(descriptor.kind);
-        media.push(await mediaStore.saveMediaBuffer({
-          channelId: "weixin",
+        const slashResult = await handleSlashCommand(textBody, {
+          to,
+          contextToken: full.context_token,
+          baseUrl: deps.baseUrl,
+          token: deps.token,
           accountId: deps.accountId,
-          chatKey: buildWeixinChatKey(deps.accountId, full.from_user_id ?? ""),
-          messageId: full.message_id ? String(full.message_id) : full.context_token ?? String(full.create_time_ms ?? Date.now()),
-          fileName: descriptor.fileName,
-          mimeType,
-          kind: descriptor.kind,
-          buffer,
-          maxBytes: descriptor.kind === "image" ? DEFAULT_IMAGE_MAX_BYTES : DEFAULT_ATTACHMENT_MAX_BYTES
-        }));
+          log: deps.log,
+          errLog: deps.errLog,
+          onClear: () => deps.agent.clearSession?.(chatKey),
+          ...deps.hasPendingFinal ? { hasPendingFinal: deps.hasPendingFinal } : {},
+          ...deps.drainPendingFinal ? { drainPendingFinal: deps.drainPendingFinal } : {},
+          ...deps.prependPendingFinal ? { prependPendingFinal: deps.prependPendingFinal } : {},
+          ...deps.reserveFinal ? { reserveFinal: deps.reserveFinal } : {},
+          ...deps.finalRemaining ? { finalRemaining: deps.finalRemaining } : {}
+        }, receivedAt, full.create_time_ms);
+        if (slashResult.handled)
+          return;
       } finally {
-        await fs8.rm(filePath, { force: true }).catch(() => {});
+        if (shouldTypeForSlash) {
+          stopTypingIndicator();
+        }
       }
-    } catch (err) {
-      deps.errLog(`media download failed: ${String(err)}`);
-      attachmentNotes.push(`Skipped ${descriptor.kind}: ${err instanceof Error ? err.message : String(err)}`);
     }
-  }
-  const sendReplySegment = async (text) => {
-    const plainText = markdownToPlainText(text).trim();
-    if (plainText.length === 0) {
-      return false;
+    startTypingIndicator();
+    const mediaStore = deps.mediaStore ?? new RuntimeMediaStore({ rootDir: resolveMediaTempDir(deps.mediaTempDir) });
+    const media = [];
+    const attachmentNotes = [];
+    const descriptors = extractWeixinMediaDescriptors(full.item_list).slice(0, DEFAULT_MAX_ATTACHMENTS_PER_MESSAGE);
+    const download = deps.downloadMediaFromItemFn ?? downloadMediaFromItem;
+    for (const descriptor of descriptors) {
+      try {
+        const downloaded = await download(descriptor.item, {
+          cdnBaseUrl: deps.cdnBaseUrl,
+          saveMedia: createSaveMediaBuffer(deps.mediaTempDir),
+          log: deps.log,
+          errLog: deps.errLog,
+          label: "inbound"
+        });
+        const filePath = downloaded.decryptedPicPath ?? downloaded.decryptedVideoPath ?? downloaded.decryptedFilePath ?? downloaded.decryptedVoicePath;
+        if (!filePath) {
+          attachmentNotes.push(`Skipped ${descriptor.kind}: media was unavailable.`);
+          continue;
+        }
+        try {
+          const buffer = await fs8.readFile(filePath);
+          const mimeType = downloaded.fileMediaType ?? downloaded.voiceMediaType ?? defaultWeixinMime(descriptor.kind);
+          media.push(await mediaStore.saveMediaBuffer({
+            channelId: "weixin",
+            accountId: deps.accountId,
+            chatKey: buildWeixinChatKey(deps.accountId, full.from_user_id ?? ""),
+            messageId: full.message_id ? String(full.message_id) : full.context_token ?? String(full.create_time_ms ?? Date.now()),
+            fileName: descriptor.fileName,
+            mimeType,
+            kind: descriptor.kind,
+            buffer,
+            maxBytes: descriptor.kind === "image" ? DEFAULT_IMAGE_MAX_BYTES : DEFAULT_ATTACHMENT_MAX_BYTES
+          }));
+        } finally {
+          await fs8.rm(filePath, { force: true }).catch(() => {});
+        }
+      } catch (err) {
+        deps.errLog(`media download failed: ${String(err)}`);
+        attachmentNotes.push(`Skipped ${descriptor.kind}: ${err instanceof Error ? err.message : String(err)}`);
+      }
     }
+    let midFirstSent = false;
+    const sendReplySegment = async (text) => {
+      const plainText = markdownToPlainText(text).trim();
+      if (plainText.length === 0) {
+        return false;
+      }
+      try {
+        await sendMessageWeixin({
+          to,
+          text: plainText,
+          opts: { baseUrl: deps.baseUrl, token: deps.token, contextToken }
+        });
+        if (!midFirstSent) {
+          midFirstSent = true;
+          perfSpan.mark("reply.mid_first_sent", { bytes: utf8ByteLength(plainText) });
+        }
+        return true;
+      } catch (err) {
+        deps.errLog(`intermediate reply failed: ${String(err)}`);
+        return false;
+      }
+    };
+    const requestText = appendAttachmentNotes(bodyFromItemList(full.item_list), attachmentNotes);
+    const request = {
+      accountId: deps.accountId,
+      conversationId: buildWeixinChatKey(deps.accountId, full.from_user_id ?? ""),
+      text: requestText,
+      ...media.length > 0 ? { media } : {},
+      replyContextToken: contextToken,
+      perfSpan
+    };
     try {
-      await sendMessageWeixin({
-        to,
-        text: plainText,
-        opts: { baseUrl: deps.baseUrl, token: deps.token, contextToken }
+      const turn = await executeChatTurn({
+        agent: deps.agent,
+        request,
+        onReplySegment: sendReplySegment
       });
-      return true;
-    } catch (err) {
-      deps.errLog(`intermediate reply failed: ${String(err)}`);
-      return false;
-    }
-  };
-  const requestText = appendAttachmentNotes(bodyFromItemList(full.item_list), attachmentNotes);
-  const request = {
-    accountId: deps.accountId,
-    conversationId: buildWeixinChatKey(deps.accountId, full.from_user_id ?? ""),
-    text: requestText,
-    ...media.length > 0 ? { media } : {},
-    replyContextToken: contextToken
-  };
-  try {
-    const turn = await executeChatTurn({
-      agent: deps.agent,
-      request,
-      onReplySegment: sendReplySegment
-    });
-    const outboundMedia = normalizeMediaArray(turn.media);
-    if (turn.text) {
-      const finalText = markdownToPlainText(turn.text).trim();
-      if (finalText.length > 0) {
-        const rawChunks = chunkFinalText(finalText, MAX_FINAL_CHUNK_BYTES);
-        if (rawChunks.length > 0) {
-          const total = rawChunks.length;
-          if (total === 1) {
-            const reserved = deps.reserveFinal ? deps.reserveFinal(to) : true;
-            if (!reserved) {
-              deps.errLog(`weixin.final.dropped reason=quota_exhausted kind=text chatKey=${to}`);
-            } else {
-              await sendMessageWeixin({
-                to,
-                text: rawChunks[0],
-                opts: { baseUrl: deps.baseUrl, token: deps.token, contextToken }
-              });
-            }
-          } else {
-            const prefixed = rawChunks.map((body, i) => `(${i + 1}/${total}) ${body}`);
-            const available = deps.finalRemaining ? deps.finalRemaining(to) : total;
-            const waveSize = Math.max(Math.min(available, total), 0);
-            const wave = prefixed.slice(0, waveSize);
-            const rest = prefixed.slice(waveSize);
-            if (wave.length > 0 && rest.length > 0) {
-              const sentSoFar = wave.length;
-              wave[wave.length - 1] = `${wave[wave.length - 1]}
-
-${buildFinalHeadsUp({
-                total,
-                sentSoFar
-              })}`;
-            }
-            let sent = 0;
-            for (let i = 0;i < wave.length; i += 1) {
+      const outboundMedia = normalizeMediaArray(turn.media);
+      let finalFirstSent = false;
+      let finalChunksSent = 0;
+      let finalChunksPending = 0;
+      let finalDropped = false;
+      if (turn.text) {
+        const finalText = markdownToPlainText(turn.text).trim();
+        if (finalText.length > 0) {
+          const rawChunks = chunkFinalText(finalText, MAX_FINAL_CHUNK_BYTES);
+          if (rawChunks.length > 0) {
+            const total = rawChunks.length;
+            if (total === 1) {
               const reserved = deps.reserveFinal ? deps.reserveFinal(to) : true;
               if (!reserved) {
-                deps.errLog(`weixin.final.dropped reason=quota_exhausted kind=text_paginated chatKey=${to} chunk=${i + 1}/${total}`);
-                break;
-              }
-              try {
+                finalDropped = true;
+                deps.errLog(`weixin.final.dropped reason=quota_exhausted kind=text chatKey=${to}`);
+              } else {
                 await sendMessageWeixin({
                   to,
-                  text: wave[i],
+                  text: rawChunks[0],
                   opts: { baseUrl: deps.baseUrl, token: deps.token, contextToken }
                 });
-                sent += 1;
-              } catch (sendErr) {
-                deps.errLog(`weixin.final.dropped reason=send_failed kind=text_paginated chatKey=${to} chunk=${i + 1}/${total} err=${String(sendErr)}`);
-                break;
+                finalChunksSent += 1;
+                if (!finalFirstSent) {
+                  finalFirstSent = true;
+                  perfSpan.mark("reply.final_first_sent", { bytes: utf8ByteLength(rawChunks[0]), chunkIndex: 1 });
+                }
+              }
+            } else {
+              const prefixed = rawChunks.map((body, i) => `(${i + 1}/${total}) ${body}`);
+              const available = deps.finalRemaining ? deps.finalRemaining(to) : total;
+              const waveSize = Math.max(Math.min(available, total), 0);
+              const wave = prefixed.slice(0, waveSize);
+              const rest = prefixed.slice(waveSize);
+              if (wave.length > 0 && rest.length > 0) {
+                const sentSoFar = wave.length;
+                wave[wave.length - 1] = `${wave[wave.length - 1]}
+
+${buildFinalHeadsUp({
+                  total,
+                  sentSoFar
+                })}`;
+              }
+              let sent = 0;
+              for (let i = 0;i < wave.length; i += 1) {
+                const reserved = deps.reserveFinal ? deps.reserveFinal(to) : true;
+                if (!reserved) {
+                  finalDropped = true;
+                  deps.errLog(`weixin.final.dropped reason=quota_exhausted kind=text_paginated chatKey=${to} chunk=${i + 1}/${total}`);
+                  break;
+                }
+                try {
+                  await sendMessageWeixin({
+                    to,
+                    text: wave[i],
+                    opts: { baseUrl: deps.baseUrl, token: deps.token, contextToken }
+                  });
+                  sent += 1;
+                  finalChunksSent += 1;
+                  if (!finalFirstSent) {
+                    finalFirstSent = true;
+                    perfSpan.mark("reply.final_first_sent", { bytes: utf8ByteLength(wave[i]), chunkIndex: i + 1 });
+                  }
+                } catch (sendErr) {
+                  finalDropped = true;
+                  deps.errLog(`weixin.final.dropped reason=send_failed kind=text_paginated chatKey=${to} chunk=${i + 1}/${total} err=${String(sendErr)}`);
+                  break;
+                }
+              }
+              const restToPark = prefixed.slice(sent);
+              finalChunksPending = restToPark.length;
+              if (restToPark.length > 0 && deps.enqueuePendingFinal) {
+                const pending = restToPark.map((text, idx) => {
+                  const seq = sent + idx + 1;
+                  const entry = { text, seq, total };
+                  if (contextToken !== undefined)
+                    entry.contextToken = contextToken;
+                  if (deps.accountId !== undefined)
+                    entry.accountId = deps.accountId;
+                  return entry;
+                });
+                deps.enqueuePendingFinal(to, pending);
               }
-            }
-            const restToPark = prefixed.slice(sent);
-            if (restToPark.length > 0 && deps.enqueuePendingFinal) {
-              const pending = restToPark.map((text, idx) => {
-                const seq = sent + idx + 1;
-                const entry = { text, seq, total };
-                if (contextToken !== undefined)
-                  entry.contextToken = contextToken;
-                if (deps.accountId !== undefined)
-                  entry.accountId = deps.accountId;
-                return entry;
-              });
-              deps.enqueuePendingFinal(to, pending);
             }
           }
         }
+        perfSpan.mark("reply.final_done", {
+          chunksSent: finalChunksSent,
+          chunksPending: finalChunksPending,
+          dropped: finalDropped
+        });
       }
-    }
-    for (const mediaItem of outboundMedia) {
-      const filePath = await resolveSafeOutboundMediaPath(mediaItem.filePath, [mediaStore.rootDir, resolveMediaTempDir(deps.mediaTempDir), ...deps.allowedMediaRoots ?? []]);
-      if (!filePath) {
-        deps.errLog(`outbound media rejected: path=${mediaItem.filePath}`);
-        continue;
+      let mediaSent = 0;
+      let mediaFailed = 0;
+      let mediaRejected = 0;
+      let mediaDropped = 0;
+      for (const mediaItem of outboundMedia) {
+        const filePath = await resolveSafeOutboundMediaPath(mediaItem.filePath, [mediaStore.rootDir, resolveMediaTempDir(deps.mediaTempDir), ...deps.allowedMediaRoots ?? []]);
+        if (!filePath) {
+          mediaRejected += 1;
+          deps.errLog(`outbound media rejected: path=${mediaItem.filePath}`);
+          continue;
+        }
+        const caption = mediaItem.caption ? markdownToPlainText(mediaItem.caption) : "";
+        const captionReserve = caption && deps.reserveFinal ? deps.reserveFinal(to) : true;
+        if (!captionReserve) {
+          deps.errLog(`weixin.final.dropped reason=quota_exhausted kind=media_caption chatKey=${to}`);
+        }
+        const reservedMedia = deps.reserveFinal ? deps.reserveFinal(to) : true;
+        if (!reservedMedia) {
+          mediaDropped += 1;
+          deps.errLog(`weixin.final.dropped reason=quota_exhausted kind=media chatKey=${to}`);
+          continue;
+        }
+        try {
+          const sent = await sendWeixinMediaFile({
+            media: mediaItem,
+            filePath,
+            to,
+            text: captionReserve ? caption : "",
+            opts: { baseUrl: deps.baseUrl, token: deps.token, contextToken },
+            cdnBaseUrl: deps.cdnBaseUrl
+          });
+          mediaSent += 1;
+          perfSpan.mark("reply.media_sent", {
+            kind: mediaItem.kind,
+            index: mediaSent + mediaFailed + mediaRejected + mediaDropped,
+            messageId: sent.messageId
+          });
+        } catch (err) {
+          mediaFailed += 1;
+          deps.errLog(`outbound media send failed: ${String(err)}`);
+        }
       }
-      const caption = mediaItem.caption ? markdownToPlainText(mediaItem.caption) : "";
-      const captionReserve = caption && deps.reserveFinal ? deps.reserveFinal(to) : true;
-      if (!captionReserve) {
-        deps.errLog(`weixin.final.dropped reason=quota_exhausted kind=media_caption chatKey=${to}`);
+      if (outboundMedia.length > 0) {
+        perfSpan.mark("reply.media_done", {
+          mediaCount: outboundMedia.length,
+          sent: mediaSent,
+          failed: mediaFailed,
+          rejected: mediaRejected,
+          dropped: mediaDropped
+        });
       }
-      const reservedMedia = deps.reserveFinal ? deps.reserveFinal(to) : true;
-      if (!reservedMedia) {
-        deps.errLog(`weixin.final.dropped reason=quota_exhausted kind=media chatKey=${to}`);
-        continue;
+    } catch (err) {
+      if (isAbortError(err)) {
+        perfSpan.setOutcome("aborted", { reason: "user_cancel" });
+        deps.log(`handleWeixinMessageTurn: turn aborted: ${err.message}`);
+        return;
       }
-      try {
-        await sendWeixinMediaFile({
-          media: mediaItem,
-          filePath,
+      perfSpan.setOutcome("error", { reason: "turn_error" });
+      const errorText = err instanceof Error ? err.stack ?? err.message : JSON.stringify(err);
+      deps.errLog(`handleWeixinMessageTurn: agent or send failed: ${errorText}`);
+      const reservedErr = deps.reserveFinal ? deps.reserveFinal(to) : true;
+      if (!reservedErr) {
+        deps.errLog(`weixin.final.dropped reason=quota_exhausted kind=error_notice chatKey=${to}`);
+      } else {
+        sendWeixinErrorNotice({
           to,
-          text: captionReserve ? caption : "",
-          opts: { baseUrl: deps.baseUrl, token: deps.token, contextToken },
-          cdnBaseUrl: deps.cdnBaseUrl
+          contextToken,
+          message: `⚠️ 过程失败：${err instanceof Error ? err.message : JSON.stringify(err)}`,
+          baseUrl: deps.baseUrl,
+          token: deps.token,
+          errLog: deps.errLog
         });
-      } catch (err) {
-        deps.errLog(`outbound media send failed: ${String(err)}`);
       }
+    } finally {
+      stopTypingIndicator();
     }
-  } catch (err) {
-    const errorText = err instanceof Error ? err.stack ?? err.message : JSON.stringify(err);
-    deps.errLog(`handleWeixinMessageTurn: agent or send failed: ${errorText}`);
-    const reservedErr = deps.reserveFinal ? deps.reserveFinal(to) : true;
-    if (!reservedErr) {
-      deps.errLog(`weixin.final.dropped reason=quota_exhausted kind=error_notice chatKey=${to}`);
-    } else {
-      sendWeixinErrorNotice({
-        to,
-        contextToken,
-        message: `⚠️ 过程失败：${err instanceof Error ? err.message : JSON.stringify(err)}`,
-        baseUrl: deps.baseUrl,
-        token: deps.token,
-        errLog: deps.errLog
-      });
-    }
-  } finally {
-    stopTypingIndicator();
-  }
+  });
+}
+function isAbortError(error2) {
+  return error2 instanceof Error && error2.name === "AbortError";
 }
 var MAX_FINAL_CHUNK_BYTES = 1800;
 var init_handle_weixin_message_turn = __esm(() => {
@@ -13581,6 +14046,7 @@ var init_handle_weixin_message_turn = __esm(() => {
   init_send_media();
   init_send();
   init_slash_commands();
+  init_perf_tracer();
 });
 
 // src/weixin/storage/sync-buf.ts
@@ -13769,7 +14235,8 @@ async function monitorWeixinProvider(opts) {
           ...opts.drainPendingFinal ? { drainPendingFinal: opts.drainPendingFinal } : {},
           ...opts.prependPendingFinal ? { prependPendingFinal: opts.prependPendingFinal } : {},
           ...opts.mediaStore ? { mediaStore: opts.mediaStore } : {},
-          ...opts.allowedMediaRoots ? { allowedMediaRoots: opts.allowedMediaRoots } : {}
+          ...opts.allowedMediaRoots ? { allowedMediaRoots: opts.allowedMediaRoots } : {},
+          ...opts.perfTracer ? { perfTracer: opts.perfTracer } : {}
         })).catch((err) => {
           errLog(`[weixin] message turn failed: ${String(err)}`);
         });
@@ -13912,7 +14379,8 @@ async function start(agent, opts) {
     ...opts?.prependPendingFinal ? { prependPendingFinal: opts.prependPendingFinal } : {},
     ...opts?.enqueuePendingFinal ? { enqueuePendingFinal: opts.enqueuePendingFinal } : {},
     ...opts?.dropPendingFinal ? { dropPendingFinal: opts.dropPendingFinal } : {},
-    ...opts?.mediaStore ? { mediaStore: opts.mediaStore } : {}
+    ...opts?.mediaStore ? { mediaStore: opts.mediaStore } : {},
+    ...opts?.perfTracer ? { perfTracer: opts.perfTracer } : {}
   });
 }
 var init_bot = __esm(() => {
@@ -14168,16 +14636,16 @@ var init_deliver_coordinator_message = __esm(() => {
 });
 
 // src/weixin/monitor/consumer-lock.ts
-import { mkdir as mkdir8, open as open2, readFile as readFile6, rm as rm5 } from "node:fs/promises";
-import { dirname as dirname6, join as join4 } from "node:path";
+import { mkdir as mkdir8, open as open2, readFile as readFile6, rm as rm6 } from "node:fs/promises";
+import { dirname as dirname8, join as join5 } from "node:path";
 import { homedir as homedir4 } from "node:os";
 function createWeixinConsumerLock(options = {}) {
-  const lockFilePath = options.lockFilePath ?? join4(homedir4(), ".weacpx", "runtime", "weixin-consumer.lock.json");
+  const lockFilePath = options.lockFilePath ?? join5(homedir4(), ".weacpx", "runtime", "weixin-consumer.lock.json");
   const isProcessRunning = options.isProcessRunning ?? defaultIsProcessRunning4;
   const onDiagnostic = options.onDiagnostic;
   return {
     async acquire(meta2) {
-      await mkdir8(dirname6(lockFilePath), { recursive: true });
+      await mkdir8(dirname8(lockFilePath), { recursive: true });
       while (true) {
         try {
           const handle = await open2(lockFilePath, "wx");
@@ -14208,7 +14676,7 @@ function createWeixinConsumerLock(options = {}) {
           });
           const existing = await loadLockMetadata(lockFilePath);
           if (!existing) {
-            await rm5(lockFilePath, { force: true });
+            await rm6(lockFilePath, { force: true });
             await onDiagnostic?.("lock_invalid_removed", {
               lockFilePath,
               reason: "invalid_or_unreadable_metadata"
@@ -14216,7 +14684,7 @@ function createWeixinConsumerLock(options = {}) {
             continue;
           }
           if (!isProcessRunning(existing.pid)) {
-            await rm5(lockFilePath, { force: true });
+            await rm6(lockFilePath, { force: true });
             await onDiagnostic?.("lock_stale_removed", {
               lockFilePath,
               stalePid: existing.pid,
@@ -14241,7 +14709,7 @@ function createWeixinConsumerLock(options = {}) {
       }
     },
     async release() {
-      await rm5(lockFilePath, { force: true });
+      await rm6(lockFilePath, { force: true });
       await onDiagnostic?.("lock_released", {
         lockFilePath
       });
@@ -14340,7 +14808,8 @@ class WeixinChannel {
       drainPendingFinal: (chatKey, available) => input.quota.drainPendingFinalUpToBudget(chatKey, available),
       prependPendingFinal: (chatKey, chunks) => input.quota.prependPendingFinal(chatKey, chunks),
       enqueuePendingFinal: (chatKey, chunks) => input.quota.enqueuePendingFinal(chatKey, chunks),
-      dropPendingFinal: (chatKey) => input.quota.clearPendingFinal(chatKey)
+      dropPendingFinal: (chatKey) => input.quota.clearPendingFinal(chatKey),
+      ...input.perfTracer ? { perfTracer: input.perfTracer } : {}
     });
   }
   async notifyTaskCompletion(task) {
@@ -14849,9 +15318,9 @@ __export(exports_plugin_loader, {
 });
 import { createRequire as createRequire2 } from "node:module";
 import { pathToFileURL } from "node:url";
-import { join as join5 } from "node:path";
+import { join as join6 } from "node:path";
 async function importPluginFromHome(packageName, pluginHome) {
-  const requireFromHome = createRequire2(join5(pluginHome, "package.json"));
+  const requireFromHome = createRequire2(join6(pluginHome, "package.json"));
   const entry = requireFromHome.resolve(packageName);
   return await import(pathToFileURL(entry).href);
 }
@@ -14899,8 +15368,8 @@ var init_bootstrap = __esm(() => {
 });
 
 // src/logging/app-logger.ts
-import { appendFile, mkdir as mkdir9, readdir as readdir2, rename, rm as rm6, stat as stat2 } from "node:fs/promises";
-import { basename, dirname as dirname8, join as join9 } from "node:path";
+import { appendFile, mkdir as mkdir9 } from "node:fs/promises";
+import { dirname as dirname10 } from "node:path";
 function createNoopAppLogger() {
   return {
     debug: async () => {},
@@ -14940,74 +15409,18 @@ function createAppLogger(options) {
       return;
     }
     const line = formatLogLine(now(), level, event, message, context);
-    await mkdir9(dirname8(options.filePath), { recursive: true });
+    await mkdir9(dirname10(options.filePath), { recursive: true });
     await rotateIfNeeded(options.filePath, Buffer.byteLength(line), options.maxSizeBytes, options.maxFiles);
     await appendFile(options.filePath, line, "utf8");
   }
 }
-async function rotateIfNeeded(filePath, incomingSize, maxSizeBytes, maxFiles) {
-  let currentSize = 0;
-  try {
-    currentSize = (await stat2(filePath)).size;
-  } catch (error2) {
-    if (!isMissingFileError2(error2)) {
-      throw error2;
-    }
-  }
-  if (currentSize + incomingSize <= maxSizeBytes) {
-    return;
-  }
-  if (currentSize === 0) {
-    return;
-  }
-  if (maxFiles <= 0) {
-    await rm6(filePath, { force: true });
-    return;
-  }
-  await rm6(`${filePath}.${maxFiles}`, { force: true });
-  for (let index = maxFiles - 1;index >= 1; index -= 1) {
-    const source = `${filePath}.${index}`;
-    try {
-      await rename(source, `${filePath}.${index + 1}`);
-    } catch (error2) {
-      if (!isMissingFileError2(error2)) {
-        throw error2;
-      }
-    }
-  }
-  await rename(filePath, `${filePath}.1`);
-}
-async function cleanupExpiredRotatedLogs(filePath, retentionDays, now) {
-  const parentDir = dirname8(filePath);
-  const prefix = `${basename(filePath)}.`;
-  const cutoff = now().getTime() - retentionDays * 24 * 60 * 60 * 1000;
-  let files = [];
-  try {
-    files = await readdir2(parentDir);
-  } catch (error2) {
-    if (isMissingFileError2(error2)) {
-      return;
-    }
-    throw error2;
-  }
-  for (const file of files) {
-    if (!file.startsWith(prefix) || !/^\d+$/.test(file.slice(prefix.length))) {
-      continue;
-    }
-    const candidate = join9(parentDir, file);
-    const details = await stat2(candidate);
-    if (details.mtime.getTime() < cutoff) {
-      await rm6(candidate, { force: true });
-    }
-  }
-}
 function formatLogLine(time3, level, event, message, context) {
-  const fields = Object.entries(context).filter(([, value]) => value !== undefined).map(([key, value]) => `${key}=${formatValue(value)}`);
+  const fields = Object.entries(context).filter(([, value]) => value !== undefined).map(([key, value]) => `${key}=${formatValue2(value)}`);
   const suffix = fields.length > 0 ? ` ${fields.join(" ")}` : "";
-  return `${time3.toISOString()} ${level.toUpperCase()} ${event} message=${formatValue(message)}${suffix}
+  return `${time3.toISOString()} ${level.toUpperCase()} ${event} message=${formatValue2(message)}${suffix}
 `;
 }
-function formatValue(value) {
+function formatValue2(value) {
   if (value === null) {
     return "null";
   }
@@ -15016,11 +15429,9 @@ function formatValue(value) {
   }
   return JSON.stringify(value);
 }
-function isMissingFileError2(error2) {
-  return typeof error2 === "object" && error2 !== null && "code" in error2 && error2.code === "ENOENT";
-}
 var LEVEL_ORDER;
 var init_app_logger = __esm(() => {
+  init_rotating_file_writer();
   LEVEL_ORDER = {
     error: 0,
     info: 1,
@@ -15091,38 +15502,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
     };
   }
@@ -16440,6 +16837,7 @@ async function handleSessionAttach(context, chatKey, alias, agent, workspace, tr
 `)
       };
     }
+    context.lifecycle.markSessionReady?.(attached);
     await context.sessions.attachSession(internalAlias, agent, workspace, transportSession);
     await context.sessions.useSession(chatKey, internalAlias);
     await refreshSessionTransportAgentCommandBestEffort(context, internalAlias, "session.attach.agent_command_refresh_failed");
@@ -16636,7 +17034,7 @@ async function handleSessionRemove(context, chatKey, alias) {
   return { text: lines.join(`
 `) };
 }
-async function promptWithSession(context, session, chatKey, text, reply, replyContextToken, accountId, media, abortSignal, onToolEvent) {
+async function promptWithSession(context, session, chatKey, text, reply, replyContextToken, accountId, media, abortSignal, onToolEvent, perfSpan) {
   const effectiveReplyMode = session.replyMode ?? context.config?.channel.replyMode ?? "verbose";
   if (!session.replyMode)
     session.replyMode = effectiveReplyMode;
@@ -16661,7 +17059,7 @@ async function promptWithSession(context, session, chatKey, text, reply, replyCo
   const { promptText, taskIds, groupIds, claimHumanReply } = await preparePromptWithFallback(context, session, chatKey, text, replyContextToken, accountId);
   try {
     const replyContext = transportReply && context.quota && getChannelIdFromChatKey(chatKey) === "weixin" ? { chatKey, quota: context.quota } : undefined;
-    const result = await context.interaction.promptTransportSession(session, promptText, transportReply, replyContext, media, abortSignal, onToolEvent);
+    const result = await context.interaction.promptTransportSession(session, promptText, transportReply, replyContext, media, abortSignal, onToolEvent, perfSpan);
     if (claimHumanReply) {
       try {
         await context.orchestration?.claimActiveHumanReply?.(claimHumanReply);
@@ -16681,17 +17079,17 @@ async function promptWithSession(context, session, chatKey, text, reply, replyCo
     throw error2;
   }
 }
-async function handlePrompt(context, chatKey, text, reply, replyContextToken, accountId, media, abortSignal, onToolEvent) {
+async function handlePrompt(context, chatKey, text, reply, replyContextToken, accountId, media, abortSignal, onToolEvent, perfSpan) {
   const session = await context.sessions.getCurrentSession(chatKey);
   if (!session) {
     return { text: NO_CURRENT_SESSION_TEXT };
   }
   try {
-    return await promptWithSession(context, session, chatKey, text, reply, replyContextToken, accountId, media, abortSignal, onToolEvent);
+    return await promptWithSession(context, session, chatKey, text, reply, replyContextToken, accountId, media, abortSignal, onToolEvent, perfSpan);
   } catch (error2) {
     const recovered = await context.recovery.tryRecoverMissingSession(session, error2);
     if (recovered) {
-      return await promptWithSession(context, recovered, chatKey, text, reply, replyContextToken, accountId, media, abortSignal, onToolEvent);
+      return await promptWithSession(context, recovered, chatKey, text, reply, replyContextToken, accountId, media, abortSignal, onToolEvent, perfSpan);
     }
     return context.recovery.renderTransportError(session, error2);
   }
@@ -16921,6 +17319,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 = [];
@@ -17364,6 +17764,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}」已保存` };
@@ -17388,7 +17795,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"]
@@ -17955,7 +18362,7 @@ import { spawn as spawn6 } from "node:child_process";
 import { createRequire as createRequire3 } from "node:module";
 import { access as access3 } from "node:fs/promises";
 import { homedir as homedir7 } from "node:os";
-import { dirname as dirname9, join as join11 } from "node:path";
+import { dirname as dirname11, join as join11 } from "node:path";
 function deriveParentPackageName(platformPackage) {
   return platformPackage.replace(/-(?:linux|darwin|win32|windows|freebsd|openbsd|sunos|aix)(?:-(?:x64|arm64|ia32|arm|ppc64|s390x))?(?:-(?:baseline|musl|gnu|gnueabihf|musleabihf|msvc))?$/, "");
 }
@@ -18028,7 +18435,7 @@ function defaultResolveFromCwd(name, cwd) {
     const pkgJson = require2.resolve(`${name}/package.json`, {
       paths: [cwd, ...require2.resolve.paths(name) ?? []]
     });
-    return dirname9(pkgJson);
+    return dirname11(pkgJson);
   } catch {
     return null;
   }
@@ -18186,7 +18593,7 @@ class CommandRouter {
     this.quota = quota;
     this.logger = logger2 ?? createNoopAppLogger();
   }
-  async handle(chatKey, input, reply, replyContextToken, accountId, media, metadata, abortSignal, onToolEvent) {
+  async handle(chatKey, input, reply, replyContextToken, accountId, media, metadata, abortSignal, onToolEvent, perfSpan) {
     const startedAt = Date.now();
     const command = parseCommand(input);
     await this.logger.debug("command.parsed", "parsed inbound command", {
@@ -18194,6 +18601,7 @@ class CommandRouter {
       kind: command.kind
     });
     const access4 = authorizeCommandForChat(command, metadata);
+    perfSpan?.mark("router.authorized", { decision: access4.allowed ? "allow" : "deny" });
     if (!access4.allowed) {
       await this.logger.info("command.blocked", "blocked command by chat policy", {
         chatKey,
@@ -18205,6 +18613,7 @@ class CommandRouter {
       return { text: renderCommandAccessDenied(command) };
     }
     await this.refreshConfigFromStore();
+    perfSpan?.mark("router.config_refreshed");
     return await this.executeCommand(chatKey, command.kind, startedAt, async () => {
       switch (command.kind) {
         case "invalid":
@@ -18247,35 +18656,35 @@ class CommandRouter {
         case "workspace.rm":
           return await handleWorkspaceRemove(this.createHandlerContext(), command.name);
         case "sessions":
-          return await handleSessions(this.createSessionHandlerContext(), chatKey);
+          return await handleSessions(this.createSessionHandlerContext(undefined, perfSpan), chatKey);
         case "session.new":
-          return await handleSessionNew(this.createSessionHandlerContext(reply), chatKey, command.alias, command.agent, command.workspace);
+          return await handleSessionNew(this.createSessionHandlerContext(reply, perfSpan), chatKey, command.alias, command.agent, command.workspace);
         case "session.shortcut":
-          return await handleSessionShortcut(this.createSessionHandlerContext(reply), chatKey, command.agent, command, false);
+          return await handleSessionShortcut(this.createSessionHandlerContext(reply, perfSpan), chatKey, command.agent, command, false);
         case "session.shortcut.new":
-          return await handleSessionShortcut(this.createSessionHandlerContext(reply), chatKey, command.agent, command, true);
+          return await handleSessionShortcut(this.createSessionHandlerContext(reply, perfSpan), chatKey, command.agent, command, true);
         case "session.attach":
-          return await handleSessionAttach(this.createSessionHandlerContext(reply), chatKey, command.alias, command.agent, command.workspace, command.transportSession);
+          return await handleSessionAttach(this.createSessionHandlerContext(reply, perfSpan), chatKey, command.alias, command.agent, command.workspace, command.transportSession);
         case "session.use":
-          return await handleSessionUse(this.createSessionHandlerContext(), chatKey, command.alias);
+          return await handleSessionUse(this.createSessionHandlerContext(undefined, perfSpan), chatKey, command.alias);
         case "mode.show":
-          return await handleModeShow(this.createSessionHandlerContext(), chatKey);
+          return await handleModeShow(this.createSessionHandlerContext(undefined, perfSpan), chatKey);
         case "mode.set":
-          return await handleModeSet(this.createSessionHandlerContext(), chatKey, command.modeId);
+          return await handleModeSet(this.createSessionHandlerContext(undefined, perfSpan), chatKey, command.modeId);
         case "replymode.show":
-          return await handleReplyModeShow(this.createSessionHandlerContext(), chatKey);
+          return await handleReplyModeShow(this.createSessionHandlerContext(undefined, perfSpan), chatKey);
         case "replymode.set":
-          return await handleReplyModeSet(this.createSessionHandlerContext(), chatKey, command.replyMode);
+          return await handleReplyModeSet(this.createSessionHandlerContext(undefined, perfSpan), chatKey, command.replyMode);
         case "replymode.reset":
-          return await handleReplyModeReset(this.createSessionHandlerContext(), chatKey);
+          return await handleReplyModeReset(this.createSessionHandlerContext(undefined, perfSpan), chatKey);
         case "status":
-          return await handleStatus(this.createSessionHandlerContext(), chatKey);
+          return await handleStatus(this.createSessionHandlerContext(undefined, perfSpan), chatKey);
         case "cancel":
-          return await handleCancel(this.createSessionHandlerContext(), chatKey);
+          return await handleCancel(this.createSessionHandlerContext(undefined, perfSpan), chatKey);
         case "session.reset":
-          return await handleSessionReset(this.createSessionHandlerContext(reply), chatKey);
+          return await handleSessionReset(this.createSessionHandlerContext(reply, perfSpan), chatKey);
         case "session.rm":
-          return await handleSessionRemove(this.createSessionHandlerContext(), chatKey, command.alias);
+          return await handleSessionRemove(this.createSessionHandlerContext(undefined, perfSpan), chatKey, command.alias);
         case "groups":
           return await handleGroupList(this.createHandlerContext(), chatKey, command.filter);
         case "group.new":
@@ -18301,7 +18710,7 @@ class CommandRouter {
         case "task.cancel":
           return await handleTaskCancel(this.createHandlerContext(), chatKey, command.taskId);
         case "prompt":
-          return await handlePrompt(this.createSessionHandlerContext(), chatKey, command.text, reply, replyContextToken, accountId, media, abortSignal, onToolEvent);
+          return await handlePrompt(this.createSessionHandlerContext(undefined, perfSpan), chatKey, command.text, reply, replyContextToken, accountId, media, abortSignal, onToolEvent, perfSpan);
       }
     });
   }
@@ -18320,23 +18729,24 @@ class CommandRouter {
       ...this.quota ? { quota: this.quota } : {}
     };
   }
-  createSessionHandlerContext(reply) {
+  createSessionHandlerContext(reply, perfSpan) {
     return {
       ...this.createHandlerContext(),
-      lifecycle: this.createSessionLifecycleOps(reply),
-      interaction: this.createSessionInteractionOps(),
+      lifecycle: this.createSessionLifecycleOps(reply, perfSpan),
+      interaction: this.createSessionInteractionOps(perfSpan),
       recovery: this.createSessionRenderRecoveryOps()
     };
   }
-  createSessionLifecycleOps(reply) {
+  createSessionLifecycleOps(reply, perfSpan) {
     return {
       resolveSession: (alias, agent, workspace, transportSession) => this.sessions.resolveSession(alias, agent, workspace, transportSession),
-      ensureTransportSession: (session, replyOverride) => this.ensureTransportSession(session, replyOverride ?? reply),
+      ensureTransportSession: (session, replyOverride, perfSpanOverride) => this.ensureTransportSession(session, replyOverride ?? reply, perfSpanOverride ?? perfSpan),
       checkTransportSession: (session) => this.checkTransportSession(session),
+      markSessionReady: () => perfSpan?.mark("session.ready"),
       reserveTransportSession: (transportSession) => this.reserveLogicalTransportSession(transportSession),
       handleSessionShortcut: async (chatKey, agent, target, createNew, replyOverride) => {
         try {
-          return await handleSessionShortcutCommand(this.createHandlerContext(), this.createSessionShortcutOps(replyOverride ?? reply), chatKey, agent, target, createNew);
+          return await handleSessionShortcutCommand(this.createHandlerContext(), this.createSessionShortcutOps(replyOverride ?? reply, perfSpan), chatKey, agent, target, createNew);
         } catch (err) {
           if (err instanceof AutoInstallFailedError) {
             const session = this.sessions.resolveSession(`${agent}`, agent, target.workspace ?? "", `${agent}`);
@@ -18345,15 +18755,15 @@ class CommandRouter {
           throw err;
         }
       },
-      resetCurrentSession: (chatKey, replyOverride) => handleSessionResetCommand(this.createHandlerContext(), this.createSessionResetOps(replyOverride ?? reply), chatKey),
+      resetCurrentSession: (chatKey, replyOverride) => handleSessionResetCommand(this.createHandlerContext(), this.createSessionResetOps(replyOverride ?? reply, perfSpan), chatKey),
       refreshSessionTransportAgentCommand: (alias) => this.refreshSessionTransportAgentCommand(alias)
     };
   }
-  createSessionInteractionOps() {
+  createSessionInteractionOps(perfSpan) {
     return {
       setModeTransportSession: (session, modeId) => this.setModeTransportSession(session, modeId),
       cancelTransportSession: (session) => this.cancelTransportSession(session),
-      promptTransportSession: (session, text, reply, replyContext, media, abortSignal, onToolEvent) => this.promptTransportSession(session, text, reply, replyContext, media, abortSignal, onToolEvent)
+      promptTransportSession: (session, text, reply, replyContext, media, abortSignal, onToolEvent, perfSpanOverride) => this.promptTransportSession(session, text, reply, replyContext, media, abortSignal, onToolEvent, perfSpanOverride ?? perfSpan)
     };
   }
   createSessionRenderRecoveryOps() {
@@ -18364,9 +18774,9 @@ class CommandRouter {
       renderTransportError: (session, error2) => renderTransportError(session, error2)
     };
   }
-  createSessionResetOps(reply) {
+  createSessionResetOps(reply, perfSpan) {
     return {
-      ensureTransportSession: (session, replyOverride) => this.ensureTransportSession(session, replyOverride ?? reply),
+      ensureTransportSession: (session, replyOverride, perfSpanOverride) => this.ensureTransportSession(session, replyOverride ?? reply, perfSpanOverride ?? perfSpan),
       checkTransportSession: (session) => this.checkTransportSession(session),
       reserveTransportSession: (transportSession) => this.reserveLogicalTransportSession(transportSession),
       resolveSession: (alias, agent, workspace, transportSession) => this.sessions.resolveSession(alias, agent, workspace, transportSession),
@@ -18381,10 +18791,10 @@ class CommandRouter {
       getSession: (alias) => this.sessions.getSession(alias)
     };
   }
-  createSessionShortcutOps(reply) {
+  createSessionShortcutOps(reply, perfSpan) {
     return {
       resolveSession: (alias, agent, workspace, transportSession) => this.sessions.resolveSession(alias, agent, workspace, transportSession),
-      ensureTransportSession: (session, replyOverride) => this.ensureTransportSession(session, replyOverride ?? reply),
+      ensureTransportSession: (session, replyOverride, perfSpanOverride) => this.ensureTransportSession(session, replyOverride ?? reply, perfSpanOverride ?? perfSpan),
       checkTransportSession: (session) => this.checkTransportSession(session),
       reserveTransportSession: (transportSession) => this.reserveLogicalTransportSession(transportSession),
       refreshSessionTransportAgentCommand: (alias) => this.refreshSessionTransportAgentCommand(alias)
@@ -18445,13 +18855,14 @@ class CommandRouter {
       throw error2;
     }
   }
-  async ensureTransportSession(session, reply) {
+  async ensureTransportSession(session, reply, perfSpan) {
     const attemptSession = (operation) => {
       const { handler, dispose } = this.createProgressHandler(session, reply);
       return this.measureTransportCall(operation, session, () => this.transport.ensureSession(session, handler)).finally(dispose);
     };
     try {
       await attemptSession("ensure_session");
+      perfSpan?.mark("session.ready");
     } catch (err) {
       if (!(err instanceof MissingOptionalDepError))
         throw err;
@@ -18464,6 +18875,7 @@ class CommandRouter {
           await reply?.(`\uD83D\uDD04 安装完成，正在验证会话启动…`);
           try {
             await attemptSession("ensure_session.verify");
+            perfSpan?.mark("session.ready");
             return true;
           } catch (retryErr) {
             if (retryErr instanceof MissingOptionalDepError)
@@ -18529,11 +18941,13 @@ class CommandRouter {
   async checkTransportSession(session) {
     return await this.measureTransportCall("has_session", session, () => this.transport.hasSession(session));
   }
-  async promptTransportSession(session, text, reply, replyContext, media, abortSignal, onToolEvent) {
+  async promptTransportSession(session, text, reply, replyContext, media, abortSignal, onToolEvent, perfSpan) {
     session.mcpCoordinatorSession ??= session.transportSession;
     let done = false;
+    let abortRequested = false;
     let cancelOnAbort;
     const fireCancel = () => {
+      abortRequested = true;
       if (done)
         return;
       try {
@@ -18557,20 +18971,42 @@ class CommandRouter {
         });
       }
     };
+    let localOutcome = "ok";
     if (abortSignal) {
       if (abortSignal.aborted) {
-        done = true;
-        throw new DOMException("Aborted before prompt started", "AbortError");
+        abortRequested = true;
+      } else {
+        cancelOnAbort = fireCancel;
+        abortSignal.addEventListener("abort", cancelOnAbort, { once: true });
       }
-      cancelOnAbort = fireCancel;
-      abortSignal.addEventListener("abort", cancelOnAbort, { once: true });
     }
+    let firstChunkFired = false;
+    const onSegment = (_segment) => {
+      if (!firstChunkFired) {
+        firstChunkFired = true;
+        perfSpan?.mark("transport.first_chunk");
+      }
+    };
     try {
+      if (abortRequested) {
+        throw new DOMException("Aborted before prompt started", "AbortError");
+      }
+      perfSpan?.mark("transport.prompt_dispatched", {
+        transportKind: this.config?.transport.type ?? inferTransportKind(this.transport)
+      });
       return await this.measureTransportCall("prompt", session, () => this.transport.prompt(session, text, reply, replyContext, {
         ...media ? { media } : {},
+        ...reply ? { onSegment } : {},
         ...onToolEvent ? { onToolEvent } : {}
       }));
+    } catch (error2) {
+      localOutcome = isAbortError2(error2) || abortRequested ? "aborted" : "error";
+      throw error2;
     } finally {
+      if (abortRequested && localOutcome === "ok") {
+        localOutcome = "aborted";
+      }
+      perfSpan?.mark("transport.prompt_done", { localOutcome });
       done = true;
       if (cancelOnAbort && abortSignal) {
         abortSignal.removeEventListener("abort", cancelOnAbort);
@@ -18631,6 +19067,12 @@ class CommandRouter {
     }
   }
 }
+function isAbortError2(error2) {
+  return error2 instanceof Error && error2.name === "AbortError";
+}
+function inferTransportKind(transport) {
+  return transport.constructor.name.includes("Bridge") ? "acpx-bridge" : "acpx-cli";
+}
 var init_command_router = __esm(() => {
   init_app_logger();
   init_acpx_session_index();
@@ -18720,7 +19162,8 @@ class ConsoleAgent {
       mimeType: m.mimeType,
       ...m.fileName ? { fileName: m.fileName } : {}
     })) : undefined;
-    return await this.router.handle(request.conversationId, request.text, request.reply, request.replyContextToken, request.accountId, promptMedia, request.metadata, request.abortSignal, request.onToolEvent);
+    request.perfSpan?.mark("agent.dispatched");
+    return await this.router.handle(request.conversationId, request.text, request.reply, request.replyContextToken, request.accountId, promptMedia, request.metadata, request.abortSignal, request.onToolEvent, request.perfSpan);
   }
   isKnownCommand(text) {
     return isKnownWeacpxCommandText(text);
@@ -18868,6 +19311,8 @@ class OrchestrationServer {
         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({
@@ -19054,6 +19499,23 @@ class OrchestrationServer {
       ...pollIntervalMs !== undefined ? { pollIntervalMs } : {}
     };
   }
+  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 } : {}
+    };
+  }
   parseWorkerRaiseQuestionInput(params) {
     requireOnlyKeys(params, ["taskId", "sourceHandle", "question", "whyBlocked", "whatIsNeeded"], "params");
     return {
@@ -19297,6 +19759,7 @@ var init_orchestration_server = __esm(() => {
     "task.get",
     "task.list",
     "task.wait",
+    "task.watch",
     "task.approve",
     "task.reject",
     "task.cancel",
@@ -19316,30 +19779,92 @@ var init_orchestration_server = __esm(() => {
 
 // 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;
@@ -19556,6 +20081,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 } : {}
@@ -19679,7 +20206,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];
@@ -19850,6 +20379,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;
@@ -19942,6 +20476,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;
@@ -19970,6 +20509,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;
@@ -20078,6 +20621,64 @@ class OrchestrationService {
       await sleep2(Math.min(pollIntervalMs, remainingMs));
     }
   }
+  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, 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,
+          events: filteredEvents.map((event) => ({ ...event })),
+          nextAfterSeq,
+          ...historyTruncated ? { historyTruncated } : {}
+        };
+      }
+      if (isAttentionRequiredTask(task)) {
+        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,
+          events: filteredEvents.map((event) => ({ ...event })),
+          nextAfterSeq,
+          ...historyTruncated ? { historyTruncated } : {}
+        };
+      }
+      await sleep2(Math.min(pollIntervalMs, remainingMs));
+    }
+  }
   async recordCoordinatorRouteContext(input) {
     if (input.coordinatorSession.trim().length === 0) {
       throw new Error("coordinatorSession must be a non-empty string");
@@ -20157,6 +20758,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 {
@@ -20214,6 +20819,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 {
@@ -20268,6 +20877,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 {
@@ -20286,6 +20899,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 {
@@ -20392,6 +21009,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;
@@ -20479,6 +21100,10 @@ class OrchestrationService {
           packageId: input.packageId
         };
         task.updatedAt = now;
+        this.appendTaskEvent(task, now, "attention_required", {
+          status: "waiting_for_human",
+          message: task.openQuestion.question
+        });
         this.bumpGroupUpdated(state, task.groupId, now);
       }
       await this.deps.saveState(state);
@@ -20662,11 +21287,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 {
@@ -21044,7 +21679,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];
@@ -21052,6 +21687,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 };
@@ -21099,6 +21749,12 @@ 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 };
@@ -21110,6 +21766,10 @@ class OrchestrationService {
       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 };
@@ -21144,10 +21804,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);
@@ -21189,6 +21857,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 };
     });
@@ -21246,6 +21918,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,
@@ -21316,6 +21992,11 @@ class OrchestrationService {
       task2.status = "cancelled";
       task2.summary = "rejected";
       task2.updatedAt = this.deps.now().toISOString();
+      this.appendTaskEvent(task2, task2.updatedAt, "status_changed", {
+        status: "cancelled",
+        summary: "rejected",
+        message: "Task rejected"
+      });
       await this.deps.saveState(state);
       return { ...task2 };
     });
@@ -22244,6 +22925,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";
@@ -22275,6 +22970,7 @@ async function sleep2(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();
@@ -22738,12 +23434,21 @@ async function runConsole(paths, deps) {
         runtimeForGc.orchestration.service.purgeExpiredResetCoordinators({ cutoffDays: 7, trigger: "interval" }).catch(() => {});
       }, 86400000);
     }
-    await deps.channels.startAll({
-      agent: runtime.agent,
-      abortSignal: shutdownController.signal,
-      quota: runtime.quota,
-      logger: runtime.logger
-    });
+    try {
+      await deps.channels.startAll({
+        agent: runtime.agent,
+        abortSignal: shutdownController.signal,
+        quota: runtime.quota,
+        logger: runtime.logger,
+        perfTracer: runtime.perfTracer
+      });
+    } catch (error2) {
+      if (deps.channelStartupPolicy !== "best-effort") {
+        throw error2;
+      }
+      await runtime.logger.error("daemon.channels.start_failed", "all channels failed to start; daemon remains alive for orchestration IPC", { error: error2 instanceof Error ? error2.message : String(error2) });
+      await waitForShutdown(shutdownController.signal);
+    }
   } finally {
     await runCleanupSequence({
       removeProcessListener,
@@ -22761,6 +23466,14 @@ async function runConsole(paths, deps) {
     });
   }
 }
+async function waitForShutdown(signal) {
+  if (signal.aborted) {
+    return;
+  }
+  await new Promise((resolve3) => {
+    signal.addEventListener("abort", () => resolve3(), { once: true });
+  });
+}
 async function runCleanupSequence(input) {
   let cleanupError = null;
   input.removeProcessListener("SIGINT", input.signalHandler);
@@ -23782,12 +24495,12 @@ var init_streaming_prompt = __esm(() => {
 
 // src/transport/acpx-cli/node-pty-helper.ts
 import { chmod as chmodFs } from "node:fs/promises";
-import { dirname as dirname10, join as join12 } from "node:path";
+import { dirname as dirname12, join as join12 } from "node:path";
 function resolveNodePtyHelperPath(packageJsonPath, platform, arch) {
   if (platform === "win32") {
     return null;
   }
-  return join12(dirname10(packageJsonPath), "prebuilds", `${platform}-${arch}`, "spawn-helper");
+  return join12(dirname12(packageJsonPath), "prebuilds", `${platform}-${arch}`, "spawn-helper");
 }
 async function ensureNodePtyHelperExecutable(helperPath, chmod2 = chmodFs) {
   if (!helperPath) {
@@ -24622,7 +25335,7 @@ __export(exports_main, {
 });
 import { randomUUID as randomUUID3 } from "node:crypto";
 import { homedir as homedir9 } from "node:os";
-import { dirname as dirname11, join as join14 } from "node:path";
+import { dirname as dirname13, join as join14 } from "node:path";
 import { fileURLToPath as fileURLToPath4 } from "node:url";
 function startProgressHeartbeat(orchestration, config2, logger2, channel) {
   const thresholdSeconds = config2.orchestration.progressHeartbeatSeconds;
@@ -24660,6 +25373,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,
@@ -24669,6 +25387,15 @@ async function buildApp(paths, deps = {}) {
     now: deps.loggerNow
   });
   await logger2.cleanup();
+  const perfLogPath = paths.perfLogPath ?? resolvePerfLogPath(paths.configPath);
+  const perfTracer = config2.logging.perf.enabled ? createPerfTracer({
+    filePath: perfLogPath,
+    maxSizeBytes: config2.logging.perf.maxSizeBytes,
+    maxFiles: config2.logging.perf.maxFiles,
+    retentionDays: config2.logging.perf.retentionDays,
+    appLogger: logger2
+  }) : createNoopPerfTracer();
+  await perfTracer.cleanup();
   const acpxCommand = resolveAcpxCommand({ configuredCommand: config2.transport.command });
   const stateStore = new StateStore(paths.statePath);
   const state = await stateStore.load();
@@ -24849,32 +25576,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,
@@ -24938,6 +25672,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;
@@ -25027,6 +25762,7 @@ async function buildApp(paths, deps = {}) {
     stateStore,
     configStore,
     logger: logger2,
+    perfTracer,
     quota,
     transport,
     orchestration: {
@@ -25043,6 +25779,13 @@ async function buildApp(paths, deps = {}) {
       if ("dispose" in transport && typeof transport.dispose === "function") {
         await transport.dispose();
       }
+      try {
+        await perfTracer.flush();
+      } catch (err) {
+        await logger2.error("perf.flush_failed", "perf tracer flush failed during shutdown", {
+          error: err instanceof Error ? err.message : String(err)
+        }).catch(() => {});
+      }
       await logger2.flush();
     }
   };
@@ -25052,6 +25795,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 {
@@ -25078,7 +25824,7 @@ async function main() {
   }
 }
 async function prepareChannelMedia(configPath, config2) {
-  const runtimeDir = join14(dirname11(configPath), "runtime");
+  const runtimeDir = join14(dirname13(configPath), "runtime");
   const mediaRootDir = join14(runtimeDir, "media");
   const mediaStore = new RuntimeMediaStore({ rootDir: mediaRootDir });
   await mediaStore.cleanupExpired().catch((error2) => {
@@ -25093,10 +25839,11 @@ function resolveRuntimePaths() {
     throw new Error("Unable to resolve the current user home directory");
   }
   const configPath = process.env.WEACPX_CONFIG ?? `${home}/.weacpx/config.json`;
-  const runtimeDir = join14(dirname11(configPath), "runtime");
+  const runtimeDir = join14(dirname13(configPath), "runtime");
   return {
     configPath,
     statePath: process.env.WEACPX_STATE ?? `${home}/.weacpx/state.json`,
+    perfLogPath: join14(runtimeDir, "perf.log"),
     orchestrationSocketPath: process.env.WEACPX_ORCHESTRATION_SOCKET ?? resolveDaemonOrchestrationSocketPath(runtimeDir)
   };
 }
@@ -25107,10 +25854,15 @@ function resolveBridgeEntryPath() {
   return fileURLToPath4(new URL("./bridge/bridge-main.ts", import.meta.url));
 }
 function resolveAppLogPath(configPath) {
-  const rootDir = dirname11(configPath);
+  const rootDir = dirname13(configPath);
   const runtimeDir = join14(rootDir, "runtime");
   return join14(runtimeDir, "app.log");
 }
+function resolvePerfLogPath(configPath) {
+  const rootDir = dirname13(configPath);
+  const runtimeDir = join14(rootDir, "runtime");
+  return join14(runtimeDir, "perf.log");
+}
 function resolveOrchestrationSocketPathFromConfigPath(configPath) {
   const runtimeDir = resolveRuntimeDirFromConfigPath(configPath);
   return resolveDaemonOrchestrationSocketPath(runtimeDir);
@@ -25141,6 +25893,7 @@ var init_main = __esm(async () => {
   init_media_store();
   init_quota_errors();
   init_inbound();
+  init_perf_tracer();
   init_bootstrap();
   if (false) {}
 });
@@ -25483,7 +26236,7 @@ async function checkOrchestrationHealth(options) {
 // src/doctor/checks/runtime-check.ts
 import { constants } from "node:fs";
 import { access as access4, stat as stat3 } from "node:fs/promises";
-import { dirname as dirname12 } from "node:path";
+import { dirname as dirname14 } from "node:path";
 import { homedir as homedir11 } from "node:os";
 async function checkRuntime(options = {}) {
   const home = options.home ?? process.env.HOME ?? homedir11();
@@ -25580,7 +26333,7 @@ async function checkFileCreatable(label, path14, probe, platform) {
         detail: `${label}: ${path14} (unusable: ${formatError6(error2)})`
       };
     }
-    const parentCheck = await checkCreatableAncestorDirectory(dirname12(path14), probe, platform);
+    const parentCheck = await checkCreatableAncestorDirectory(dirname14(path14), probe, platform);
     if (!parentCheck.ok) {
       return {
         ok: false,
@@ -25616,7 +26369,7 @@ async function checkCreatableAncestorDirectory(path14, probe, platform) {
         blockingPath: path14
       };
     }
-    const parent = dirname12(path14);
+    const parent = dirname14(path14);
     if (parent === path14) {
       return {
         ok: false,
@@ -26194,11 +26947,12 @@ 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";
 import { homedir as homedir13 } from "node:os";
-import { dirname as dirname13, join as join16, sep } from "node:path";
+import { dirname as dirname15, join as join16, sep } from "node:path";
 import { fileURLToPath as fileURLToPath6 } from "node:url";
 
 // src/daemon/daemon-runtime.ts
@@ -38648,6 +39402,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)
@@ -38657,7 +39412,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. For legacy clients, after this returns status=running, keep the returned taskId and use task_get/task_list for non-blocking progress snapshots; call task_wait only when the user explicitly wants you to wait/block until completion or attention is required. 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(", ")}.` : ""}`,
+      execution: { taskSupport: "optional" },
       inputSchema: exports_external.object({
         targetAgent: exports_external.string().min(1),
         task: exports_external.string().min(1),
@@ -38740,7 +39496,7 @@ function buildWeacpxMcpToolRegistry(input) {
     },
     {
       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(),
@@ -38775,7 +39531,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 pending task under the current coordinator. Use when delegate_request returned status=needs_confirmation and the user has authorized it; after approval, use task_get/task_list for snapshots or task_wait only if intentionally blocking.",
       inputSchema: exports_external.object({
         taskId: exports_external.string().min(1)
       }).strict(),
@@ -38817,7 +39573,7 @@ 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.`,
+      description: `Wait for a task to finish or require attention. This is a blocking legacy compatibility tool; do not call it automatically after delegate_request when the user only asked to start/delegate work. Use task_get/task_list for non-blocking progress snapshots; call task_wait when the user explicitly asks to wait, or when your next step truly depends on completion. 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, use task_get/task_list snapshots or task_wait only if intentionally blocking), or status=timeout (still running; use task_get for a snapshot, or task_wait only if intentionally blocking). 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.`,
       inputSchema: exports_external.object({
         taskId: exports_external.string().min(1),
         timeoutMs: exports_external.number().int().min(0).max(MAX_TASK_WAIT_TIMEOUT_MS).optional(),
@@ -38831,9 +39587,29 @@ function buildWeacpxMcpToolRegistry(input) {
         return createSuccessResult(renderTaskWaitResult(result), result);
       })
     },
+    {
+      name: "task_watch",
+      description: `Long-poll a task for the next event, attention-required state, or terminal state. This is the recommended legacy way to watch a delegated task without repeatedly calling task_wait. 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),
+        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.watchTask({
+          coordinatorSession,
+          ...args
+        });
+        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. Coordinators waiting on a delegation should not call this; use task_get/task_list for snapshots, or task_wait only if intentionally blocking.",
       inputSchema: exports_external.object({
         taskId: exports_external.string().min(1),
         question: exports_external.string().min(1),
@@ -38853,7 +39629,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; after answering, use task_get/task_list for snapshots or task_wait only if intentionally blocking for the worker to finish.",
       inputSchema: exports_external.object({
         taskId: exports_external.string().min(1),
         questionId: exports_external.string().min(1),
@@ -38957,7 +39733,7 @@ function renderTaskWaitResult(result) {
   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.`
+      `Next: call task_get for a snapshot, or call task_wait again only if you intentionally want to keep blocking.`
     ].join(`
 `);
   }
@@ -38968,7 +39744,7 @@ function renderTaskWaitResult(result) {
       `  - 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.`
+      `After resolving, use task_get/task_list for snapshots, or call task_wait again only if you intentionally want to keep blocking.`
     ].join(`
 `);
   }
@@ -38978,6 +39754,26 @@ function renderTaskWaitResult(result) {
   ].join(`
 `);
 }
+function renderTaskWatchResult(result) {
+  if (result.status === "not_found" || !result.task) {
+    return "Task not found.";
+  }
+  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) {
   return {
     content: [{ type: "text", text }],
@@ -38991,7 +39787,7 @@ 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; do not call task_wait yet. Tell the user, then call task_approve or task_reject based on their response.` : `Next: task "${result.taskId}" is running. Return this taskId to the user, or call task_get/task_list for non-blocking progress snapshots (or task_watch to long-poll for the next event). Call task_wait only if the user explicitly asks you to wait/block until completion.`;
   return [`Delegation task "${result.taskId}" created.`, `- Status: ${result.status}`, next].join(`
 `);
 }
@@ -39096,6 +39892,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 = [];
@@ -39140,7 +39938,7 @@ 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 call task_wait only if you intentionally want to block until the worker finishes; then task_get to read the final result.`
   ].join(`
 `);
 }
@@ -39210,6 +40008,9 @@ class OrchestrationClient {
   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);
   }
@@ -39326,6 +40127,11 @@ function getWaitRequestTimeoutMs(waitTimeoutMs, defaultTimeoutMs) {
   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
 function createOrchestrationTransport(endpoint, deps = {}) {
@@ -39355,6 +40161,7 @@ function createOrchestrationTransport(endpoint, deps = {}) {
     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) {
@@ -39376,21 +40183,31 @@ function createOrchestrationTransport(endpoint, deps = {}) {
 }
 
 // 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:",
+  "Preferred MCP Tasks lifecycle (for clients that support task-augmented tools/call):",
+  "1. Call delegate_request with task execution requested. It returns a native MCP task handle immediately.",
+  "2. Use task_watch with MCP task execution to start a background watcher, or use tasks/get / tasks/list to poll status. Use tasks/result after terminal status, or on input_required to receive an actionable next-step package; use tasks/cancel to cancel.",
+  "   - When tasks/result returns input_required, that result stream is complete. Call the recommended tool, then resume polling with tasks/get / tasks/result.",
+  "3. Status mapping: working = running, input_required = needs_confirmation / blocked / waiting_for_human / contested review, completed / failed / cancelled are terminal.",
+  "",
+  "Legacy tool lifecycle for clients without MCP Tasks support:",
   "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=running: the worker has started. Return the taskId to the user, use task_get / task_list for non-blocking snapshots, or task_watch to long-poll for the next event; only go to step 2 when you intentionally want to block waiting.",
+  "   - status=needs_confirmation: tell the user, then call task_approve or task_reject based on their response. After task_approve, use task_get/task_list for snapshots or step 2 only if intentionally blocking. Do not call task_wait before approval.",
+  "2. Optional blocking wait: task_wait(taskId) → blocks until the task is done, needs attention, or times out. Do not call it automatically when the user asked to delegate and continue.",
   "   - 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)",
+  "       * needs_confirmation -> task_approve or task_reject (after approval, use snapshots or optional blocking wait only if needed)",
   "       * 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.",
+  "     After resolving, use task_get / task_list for snapshots, or step 2 only if intentionally blocking.",
+  "   - status=timeout: the task is still running. Use task_get for a snapshot, or call task_wait again only if you still intentionally want to block.",
   "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.",
   "",
   "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.",
@@ -39401,18 +40218,27 @@ var WEACPX_MCP_SERVER_INSTRUCTIONS = [
 ].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;
     }
@@ -39435,14 +40261,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 } : {}
       }))
     };
   });
@@ -39456,15 +40283,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_reject");
+  }
+  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) {
@@ -39743,7 +40954,7 @@ function sanitizeName(input, fallback) {
 init_plugin_home();
 import { spawn as spawn4 } from "node:child_process";
 import { readFile as readFile7 } from "node:fs/promises";
-import { dirname as dirname7, join as join6 } from "node:path";
+import { dirname as dirname9, join as join7 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 
 // src/plugins/package-manager.ts
@@ -40021,8 +41232,8 @@ async function runInherit(command, args) {
 }
 async function readPackageName() {
   try {
-    const here = dirname7(fileURLToPath2(import.meta.url));
-    for (const candidate of [join6(here, "..", "package.json"), join6(here, "..", "..", "package.json")]) {
+    const here = dirname9(fileURLToPath2(import.meta.url));
+    for (const candidate of [join7(here, "..", "package.json"), join7(here, "..", "..", "package.json")]) {
       try {
         const parsed = JSON.parse(await readFile7(candidate, "utf8"));
         if (typeof parsed.name === "string" && parsed.name.trim())
@@ -40648,7 +41859,7 @@ async function setChannelAccountEnabled(type, accountId, enabled, rawArgs, deps)
 // src/plugins/plugin-cli.ts
 init_plugin_home();
 import { readFile as readFile9 } from "node:fs/promises";
-import { isAbsolute, join as join8, resolve } from "node:path";
+import { isAbsolute, join as join9, resolve } from "node:path";
 init_plugin_loader();
 init_validate_plugin();
 
@@ -40658,13 +41869,13 @@ init_plugin_loader();
 init_validate_plugin();
 init_known_plugins();
 import { readFile as readFile8 } from "node:fs/promises";
-import { join as join7 } from "node:path";
+import { join as join8 } from "node:path";
 function suggestedPluginPackageForChannel(type) {
   return findKnownPluginByChannel(type)?.packageName ?? `<npm-package-that-provides-${type}>`;
 }
 async function readDependencyEntries(pluginHome) {
   try {
-    const raw = await readFile8(join7(pluginHome, "package.json"), "utf8");
+    const raw = await readFile8(join8(pluginHome, "package.json"), "utf8");
     const parsed = JSON.parse(raw);
     const out = {};
     for (const [name, value] of Object.entries(parsed.dependencies ?? {})) {
@@ -40766,7 +41977,7 @@ function looksLikePath(spec) {
 }
 async function readDependencyEntries2(pluginHome) {
   try {
-    const raw = await readFile9(join8(pluginHome, "package.json"), "utf8");
+    const raw = await readFile9(join9(pluginHome, "package.json"), "utf8");
     const parsed = JSON.parse(raw);
     const out = {};
     for (const [name, value] of Object.entries(parsed.dependencies ?? {})) {
@@ -40792,7 +42003,7 @@ async function resolveLocalPluginName(installSpec, pluginHome, namesBeforeInstal
       return name;
   }
   try {
-    const raw = await readFile9(join8(installSpec, "package.json"), "utf8");
+    const raw = await readFile9(join9(installSpec, "package.json"), "utf8");
     const parsed = JSON.parse(raw);
     if (typeof parsed.name === "string" && parsed.name.trim())
       return parsed.name.trim();
@@ -41400,6 +42611,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 服务"
 ];
@@ -41477,6 +42689,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,
@@ -41718,6 +42941,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);
@@ -41741,6 +43051,7 @@ async function defaultLoadConfiguredPluginsForChannelCli() {
   const { loadConfiguredPlugins: loadConfiguredPlugins2 } = await Promise.resolve().then(() => (init_plugin_loader(), exports_plugin_loader));
   await loadConfiguredPlugins2({ plugins: config2.plugins });
 }
+var DAEMON_RUN_ENV = "WEACPX_DAEMON_RUN";
 async function defaultRun(options = {}) {
   const [{ buildApp: buildApp2, resolveRuntimePaths: resolveRuntimePaths2, prepareChannelMedia: prepareChannelMedia2 }, { runConsole: runConsole2 }] = await Promise.all([
     init_main().then(() => exports_main),
@@ -41769,6 +43080,7 @@ async function defaultRun(options = {}) {
       await createFirstRunSession(runtime, firstRunOnboarding);
     } : undefined,
     channels: channelRegistry,
+    channelStartupPolicy: process.env[DAEMON_RUN_ENV] === "1" ? "best-effort" : "require-one",
     daemonRuntime,
     ...firstLockCreator ? {
       consumerLockFactory: (runtime) => firstLockCreator.create({
@@ -42063,7 +43375,7 @@ function safeDaemonLogPaths() {
     const configPath = process.env.WEACPX_CONFIG ?? `${requireHome2()}/.weacpx/config.json`;
     const paths = resolveDaemonPaths({ home: requireHome2() });
     return {
-      appLog: join16(dirname13(configPath), "runtime", "app.log"),
+      appLog: join16(dirname15(configPath), "runtime", "app.log"),
       stderrLog: paths.stderrLog
     };
   } catch {