@qwen-code/qwen-code 0.19.8 → 0.19.9-nightly.20260714.9dd8389eb

package/chunks/chunk-TV6K2FB4.js

@@ -0,0 +1,224 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  INBOXES_DIR,
+  LEADER_NAME,
+  TASKS_DIR,
+  TEAMMATE_COLORS,
+  TEAMS_DIR,
+  TEAM_CONFIG_FILENAME
+} from "./chunk-CPBF7KYF.js";
+import {
+  atomicWriteJSON
+} from "./chunk-WIEO4CWB.js";
+import {
+  Storage,
+  isNodeError
+} from "./chunk-7NFB7LBQ.js";
+import {
+  init_esbuild_shims
+} from "./chunk-5O2XNYP6.js";
+import {
+  __name
+} from "./chunk-J2S4EL5Y.js";
+
+// packages/core/src/agents/team/teamHelpers.ts
+init_esbuild_shims();
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+function getTeamsRootDir() {
+  return path.join(Storage.getGlobalQwenDir(), TEAMS_DIR);
+}
+__name(getTeamsRootDir, "getTeamsRootDir");
+function getTeamDir(teamName) {
+  return path.join(getTeamsRootDir(), teamName);
+}
+__name(getTeamDir, "getTeamDir");
+function getTeamFilePath(teamName) {
+  return path.join(getTeamDir(teamName), TEAM_CONFIG_FILENAME);
+}
+__name(getTeamFilePath, "getTeamFilePath");
+function getInboxesDir(teamName) {
+  return path.join(getTeamDir(teamName), INBOXES_DIR);
+}
+__name(getInboxesDir, "getInboxesDir");
+function getTasksDir(teamName) {
+  return path.join(Storage.getGlobalQwenDir(), TASKS_DIR, teamName);
+}
+__name(getTasksDir, "getTasksDir");
+function sanitizeName(name) {
+  return name.toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+}
+__name(sanitizeName, "sanitizeName");
+function formatAgentId(name, teamName) {
+  return `${sanitizeName(name)}@${sanitizeName(teamName)}`;
+}
+__name(formatAgentId, "formatAgentId");
+function generateUniqueTeammateName(baseName, existingMembers) {
+  const sanitized = sanitizeName(baseName);
+  if (!sanitized) {
+    throw new Error(
+      `Teammate name "${baseName}" sanitizes to an empty string. Choose a name with at least one alphanumeric character.`
+    );
+  }
+  if (sanitized === LEADER_NAME) {
+    throw new Error(
+      `"${LEADER_NAME}" is reserved for the team leader. Choose a different teammate name.`
+    );
+  }
+  const existingNames = new Set(existingMembers.map((m) => m.name));
+  if (existingNames.has(sanitized)) {
+    const existingList = [...existingNames].join(", ") || "<none>";
+    throw new Error(
+      `A teammate named "${sanitized}" already exists in this team (existing: ${existingList}). Choose a different name.`
+    );
+  }
+  return sanitized;
+}
+__name(generateUniqueTeammateName, "generateUniqueTeammateName");
+function assignTeammateColor(existingMembers) {
+  const usedColors = new Set(
+    existingMembers.map((m) => m.color).filter((c) => c !== void 0)
+  );
+  for (const color of TEAMMATE_COLORS) {
+    if (!usedColors.has(color)) {
+      return color;
+    }
+  }
+  return TEAMMATE_COLORS[existingMembers.length % TEAMMATE_COLORS.length];
+}
+__name(assignTeammateColor, "assignTeammateColor");
+function clearTeammateColors(members) {
+  return members.map((m) => {
+    const { color: _, ...rest } = m;
+    return rest;
+  });
+}
+__name(clearTeammateColors, "clearTeammateColors");
+function setMemberActive(members, agentId, isActive) {
+  return members.map((m) => m.agentId === agentId ? { ...m, isActive } : m);
+}
+__name(setMemberActive, "setMemberActive");
+function findMemberById(members, agentId) {
+  return members.find((m) => m.agentId === agentId);
+}
+__name(findMemberById, "findMemberById");
+function findMemberByName(members, name) {
+  const sanitized = sanitizeName(name);
+  return members.find((m) => m.name === sanitized);
+}
+__name(findMemberByName, "findMemberByName");
+function classifyShutdownResponse(message) {
+  const trimmed = message.trimStart();
+  if (/^shutdown_approved\b/i.test(trimmed)) return "shutdown_approved";
+  if (/^shutdown_rejected\b/i.test(trimmed)) return "shutdown_rejected";
+  return void 0;
+}
+__name(classifyShutdownResponse, "classifyShutdownResponse");
+async function readTeamFile(teamName) {
+  const filePath = getTeamFilePath(teamName);
+  try {
+    const raw = await fs.readFile(filePath, "utf-8");
+    return JSON.parse(raw);
+  } catch (err) {
+    if (isNodeError(err) && err.code === "ENOENT") {
+      return void 0;
+    }
+    throw err;
+  }
+}
+__name(readTeamFile, "readTeamFile");
+async function writeTeamFile(teamName, teamFile) {
+  const filePath = getTeamFilePath(teamName);
+  await fs.mkdir(path.dirname(filePath), { recursive: true });
+  await atomicWriteJSON(filePath, teamFile);
+}
+__name(writeTeamFile, "writeTeamFile");
+async function createTeamFile(teamName, teamFile) {
+  const filePath = getTeamFilePath(teamName);
+  await fs.mkdir(path.dirname(filePath), { recursive: true });
+  await fs.writeFile(filePath, JSON.stringify(teamFile, null, 2) + "\n", {
+    encoding: "utf-8",
+    flag: "wx"
+  });
+}
+__name(createTeamFile, "createTeamFile");
+function isPidAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    return isNodeError(err) && err.code === "EPERM";
+  }
+}
+__name(isPidAlive, "isPidAlive");
+async function tryReclaimStaleTeam(teamName) {
+  let existing;
+  try {
+    existing = await readTeamFile(teamName);
+  } catch {
+    return false;
+  }
+  if (!existing) {
+    await deleteTeamDirs(teamName);
+    return true;
+  }
+  if (typeof existing.leadPid !== "number" || existing.leadPid <= 0) {
+    return false;
+  }
+  if (existing.leadPid !== process.pid && isPidAlive(existing.leadPid)) {
+    return false;
+  }
+  await deleteTeamDirs(teamName);
+  return true;
+}
+__name(tryReclaimStaleTeam, "tryReclaimStaleTeam");
+async function deleteTeamDirs(teamName) {
+  const teamDir = getTeamDir(teamName);
+  const tasksDir = getTasksDir(teamName);
+  await Promise.allSettled([
+    fs.rm(teamDir, { recursive: true, force: true }),
+    fs.rm(tasksDir, { recursive: true, force: true })
+  ]);
+}
+__name(deleteTeamDirs, "deleteTeamDirs");
+async function listTeamNames() {
+  const teamsRoot = getTeamsRootDir();
+  try {
+    const entries = await fs.readdir(teamsRoot, {
+      withFileTypes: true
+    });
+    return entries.filter((e) => e.isDirectory()).map((e) => e.name);
+  } catch {
+    return [];
+  }
+}
+__name(listTeamNames, "listTeamNames");
+
+export {
+  getTeamsRootDir,
+  getTeamDir,
+  getTeamFilePath,
+  getInboxesDir,
+  getTasksDir,
+  sanitizeName,
+  formatAgentId,
+  generateUniqueTeammateName,
+  assignTeammateColor,
+  clearTeammateColors,
+  setMemberActive,
+  findMemberById,
+  findMemberByName,
+  classifyShutdownResponse,
+  readTeamFile,
+  writeTeamFile,
+  createTeamFile,
+  tryReclaimStaleTeam,
+  deleteTeamDirs,
+  listTeamNames
+};
+/**
+ * @license
+ * Copyright 2025 Qwen
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/chunks/{chunk-5MBO76SL.js → chunk-TXY2C3D2.js}

@@ -3,13 +3,13 @@
 import {
   getTeammateContext,
   isTeammate
-} from "./chunk-GO6LNQXT.js";
+} from "./chunk-6AM5D4ME.js";
 import {
   ToolNames
-} from "./chunk-X3YGAX7V.js";
+} from "./chunk-2UUAIFQO.js";
 import {
   init_esbuild_shims
-} from "./chunk-A4BMJM77.js";
+} from "./chunk-5O2XNYP6.js";
 import {
   __name
 } from "./chunk-J2S4EL5Y.js";

package/chunks/{chunk-H6BD2ELD.js → chunk-TYAMGABM.js}

@@ -9,10 +9,10 @@ import {
   require_subprotocol,
   require_websocket,
   require_websocket_server
-} from "./chunk-5IFG2VC4.js";
+} from "./chunk-FCMNKVXT.js";
 import {
   init_esbuild_shims
-} from "./chunk-A4BMJM77.js";
+} from "./chunk-5O2XNYP6.js";
 import {
   __toESM
 } from "./chunk-J2S4EL5Y.js";

package/chunks/{chunk-QYNNN7BK.js → chunk-TYLOFD2U.js}

@@ -2,10 +2,10 @@
 "use strict";
 import {
   createDebugLogger
-} from "./chunk-22MNNNXE.js";
+} from "./chunk-7NFB7LBQ.js";
 import {
   init_esbuild_shims
-} from "./chunk-A4BMJM77.js";
+} from "./chunk-5O2XNYP6.js";
 import {
   __name
 } from "./chunk-J2S4EL5Y.js";

package/chunks/{chunk-VRDMOSQS.js → chunk-UDXSXLER.js}

@@ -3,10 +3,10 @@
 import {
   external_exports,
   external_exports2
-} from "./chunk-K5PGHDBN.js";
+} from "./chunk-H6XPXXMH.js";
 import {
   init_esbuild_shims
-} from "./chunk-A4BMJM77.js";
+} from "./chunk-5O2XNYP6.js";
 import {
   __name
 } from "./chunk-J2S4EL5Y.js";

package/chunks/{chunk-UXEW557D.js → chunk-UI3W56WF.js}

@@ -2,10 +2,10 @@
 "use strict";
 import {
   getPackageJson
-} from "./chunk-43W4YSO6.js";
+} from "./chunk-VJNBRRZG.js";
 import {
   init_esbuild_shims
-} from "./chunk-A4BMJM77.js";
+} from "./chunk-5O2XNYP6.js";
 import {
   __name
 } from "./chunk-J2S4EL5Y.js";
@@ -14,7 +14,7 @@ import {
 init_esbuild_shims();
 async function getCliVersion() {
   const pkgJson = await getPackageJson();
-  return "0.19.8";
+  return "0.19.9-nightly.20260714.9dd8389eb";
 }
 __name(getCliVersion, "getCliVersion");
 

package/chunks/{chunk-CJCKDMWO.js → chunk-URK542T4.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   init_esbuild_shims
-} from "./chunk-A4BMJM77.js";
+} from "./chunk-5O2XNYP6.js";
 import {
   __commonJS,
   __name

package/chunks/{channel-worker-supervisor-NZQUOEFJ.js → chunk-URU5UEK6.js}

@@ -7,21 +7,31 @@ import {
   QWEN_DAEMON_URL_ENV,
   QWEN_DAEMON_WORKSPACE_ENV,
   QWEN_SERVER_TOKEN_ENV
-} from "./chunk-S6RLAIUR.js";
+} from "./chunk-GYTKQYDB.js";
 import {
   channelSelectionNames
-} from "./chunk-MX2YXRER.js";
-import {
-  sanitizeLogText
-} from "./chunk-IBY3Q3HG.js";
-import "./chunk-VRDMOSQS.js";
+} from "./chunk-TJTKSVIV.js";
 import {
   redactLogCredentials
-} from "./chunk-HLKG6CZN.js";
-import "./chunk-K5PGHDBN.js";
+} from "./chunk-M5GB774H.js";
+import {
+  CHANNEL_WORKER_KILL_GRACE_MS,
+  CHANNEL_WORKER_STARTUP_TIMEOUT_MS,
+  CHANNEL_WORKER_STOP_GRACE_MS
+} from "./chunk-5HBA2Z7V.js";
+import {
+  CHANNEL_WEBHOOK_TASK_IPC_TIMEOUT_MS,
+  ChannelWebhookEnqueueError,
+  createChannelWebhookTaskMessage,
+  isChannelWebhookEnqueueErrorCode,
+  isChannelWebhookTaskResultMessage
+} from "./chunk-OJAMDVF5.js";
+import {
+  sanitizeLogText
+} from "./chunk-SXU3KKNI.js";
 import {
   init_esbuild_shims
-} from "./chunk-A4BMJM77.js";
+} from "./chunk-5O2XNYP6.js";
 import {
   __name
 } from "./chunk-J2S4EL5Y.js";
@@ -30,7 +40,6 @@ import {
 init_esbuild_shims();
 import { fork } from "node:child_process";
 import { randomUUID } from "node:crypto";
-var DEFAULT_CHANNEL_WORKER_STARTUP_TIMEOUT_MS = 3e4;
 var DEFAULT_CHANNEL_WORKER_HEARTBEAT_TIMEOUT_MS = 45e3;
 var MAX_WORKER_LOG_LINE_LENGTH = 4096;
 var MAX_WORKER_LOG_BUFFER_LENGTH = 64 * 1024;
@@ -41,6 +50,15 @@ var ANSI_CSI_SEQUENCE_RE = new RegExp(
 );
 var WORKER_LOG_INVISIBLE_RE = new RegExp("[\\p{Cf}\\u2028\\u2029]|\\p{Variation_Selector}", "gu");
 var WORKER_LOG_CONTROL_RE = /[\x00-\x08\x0a-\x1f\x7f]/g;
+var ChannelWorkerStopError = class extends Error {
+  static {
+    __name(this, "ChannelWorkerStopError");
+  }
+  constructor(message = "Channel worker did not exit after SIGKILL.") {
+    super(message);
+    this.name = "ChannelWorkerStopError";
+  }
+};
 var DEFAULT_RESTART_POLICY = {
   maxRestarts: 3,
   windowMs: 5 * 6e4,
@@ -112,15 +130,17 @@ __name(notifyLog, "notifyLog");
 function waitForExit(child, timeoutMs) {
   return new Promise((resolve) => {
     let settled = false;
+    const onExit = /* @__PURE__ */ __name(() => done(true), "onExit");
     const done = /* @__PURE__ */ __name((exited) => {
       if (settled) return;
       settled = true;
-      if (timer) clearTimeout(timer);
+      clearTimeout(timer);
+      child.removeListener("exit", onExit);
       resolve(exited);
     }, "done");
     const timer = setTimeout(() => done(false), timeoutMs);
     timer.unref();
-    child.once("exit", () => done(true));
+    child.once("exit", onExit);
   });
 }
 __name(waitForExit, "waitForExit");
@@ -129,7 +149,7 @@ function hasObservedExit(snapshot) {
 }
 __name(hasObservedExit, "hasObservedExit");
 function createWorkerEnv(opts) {
-  const env = { ...process.env };
+  const env = { ...opts.baseEnv ?? process.env };
   env["QWEN_CODE_NO_RELAUNCH"] = "true";
   env[CHANNEL_DAEMON_WORKER_SENTINEL] = randomUUID();
   env[QWEN_DAEMON_URL_ENV] = opts.daemonUrl;
@@ -268,6 +288,9 @@ function createChannelWorkerSupervisor(opts) {
   let restartTimer;
   let staleHeartbeatTimer;
   let restartAttemptTimes = [];
+  const pendingWebhookTasks = /* @__PURE__ */ new Map();
+  let restarting;
+  let disposed = false;
   const snapshotCopy = /* @__PURE__ */ __name(() => ({
     ...snapshot,
     channels: [...snapshot.channels],
@@ -289,6 +312,40 @@ function createChannelWorkerSupervisor(opts) {
     clearTimeout(staleHeartbeatTimer);
     staleHeartbeatTimer = void 0;
   }, "clearStaleHeartbeatTimer");
+  const rejectPendingWebhookTasks = /* @__PURE__ */ __name((code, message) => {
+    for (const pending of pendingWebhookTasks.values()) {
+      clearTimeout(pending.timer);
+      pending.reject(new ChannelWebhookEnqueueError(code, message));
+    }
+    pendingWebhookTasks.clear();
+  }, "rejectPendingWebhookTasks");
+  const rejectPendingWebhookTask = /* @__PURE__ */ __name((id, err) => {
+    const pending = pendingWebhookTasks.get(id);
+    if (!pending) return;
+    pendingWebhookTasks.delete(id);
+    clearTimeout(pending.timer);
+    pending.reject(err);
+  }, "rejectPendingWebhookTask");
+  const settleWebhookTask = /* @__PURE__ */ __name((message) => {
+    if (!isChannelWebhookTaskResultMessage(message)) return false;
+    const pending = pendingWebhookTasks.get(message.id);
+    if (!pending) return true;
+    if (message.ok) {
+      pendingWebhookTasks.delete(message.id);
+      clearTimeout(pending.timer);
+      pending.resolve({ accepted: true });
+    } else {
+      const code = isChannelWebhookEnqueueErrorCode(message.code) ? message.code : "channel_webhook_enqueue_failed";
+      rejectPendingWebhookTask(
+        message.id,
+        new ChannelWebhookEnqueueError(
+          code,
+          message.error || "Channel webhook task failed."
+        )
+      );
+    }
+    return true;
+  }, "settleWebhookTask");
   const pruneRestartAttempts = /* @__PURE__ */ __name((nowMs) => {
     restartAttemptTimes = restartAttemptTimes.filter(
       (attemptMs) => nowMs - attemptMs < restartPolicy.windowMs
@@ -385,7 +442,8 @@ function createChannelWorkerSupervisor(opts) {
     const env = createWorkerEnv({
       daemonUrl: opts.daemonUrl,
       workspace: opts.workspace,
-      ...opts.daemonToken ? { daemonToken: opts.daemonToken } : {}
+      ...opts.daemonToken ? { daemonToken: opts.daemonToken } : {},
+      ...opts.workerBaseEnv ? { baseEnv: opts.workerBaseEnv } : {}
     });
     const redaction = workerLogRedactionOptions(opts.daemonToken, env);
     const requestedChannels = requestedChannelNames(opts.selection);
@@ -464,18 +522,27 @@ function createChannelWorkerSupervisor(opts) {
         cleanupLaunch();
         if (terminatingBeforeReady) return;
         terminatingBeforeReady = true;
-        const exited = waitForExit(startedChild, 2e3);
+        const exited = waitForExit(startedChild, CHANNEL_WORKER_KILL_GRACE_MS);
         startedChild.kill("SIGTERM");
         void exited.then(async (didExit) => {
           if (!didExit && child === startedChild && !exitObserved) {
-            const killed = waitForExit(startedChild, 2e3);
+            const killed = waitForExit(
+              startedChild,
+              CHANNEL_WORKER_KILL_GRACE_MS
+            );
             startedChild.kill("SIGKILL");
             if (!await killed && child === startedChild && !exitObserved) {
-              child = void 0;
-              if (kind === "restart" && !stopping) {
-                scheduleRestart();
-                notifyExit(opts.onExit, snapshotCopy());
-              }
+              stopping = true;
+              notifyLog(opts.onLog, {
+                stream: "stderr",
+                line: "Channel worker did not exit after SIGKILL; automatic restart is disabled."
+              });
+              snapshot = {
+                ...snapshot,
+                state: "failed",
+                error: snapshot.error ?? "Channel worker did not exit after SIGKILL."
+              };
+              notifyExit(opts.onExit, snapshotCopy());
             }
           }
         });
@@ -527,6 +594,9 @@ function createChannelWorkerSupervisor(opts) {
       }, "handleHeartbeat");
       function handleMessage(message) {
         if (child !== startedChild) return;
+        if (settleWebhookTask(message)) {
+          return;
+        }
         if (!ready && isReadyMessage(message)) {
           completeReady(message);
         } else if (isHeartbeatMessage(message)) {
@@ -546,6 +616,10 @@ function createChannelWorkerSupervisor(opts) {
           signal,
           snapshot.error ?? (ready ? void 0 : sanitizeWorkerError(message, redaction))
         );
+        rejectPendingWebhookTasks(
+          "channel_worker_unavailable",
+          "Channel worker exited."
+        );
         child = void 0;
         if ((ready || kind === "restart") && !stopping) {
           scheduleRestart();
@@ -578,7 +652,7 @@ function createChannelWorkerSupervisor(opts) {
       }
       __name(settleError, "settleError");
       startupTimer = setTimeout(() => {
-        const timeoutMs = opts.startupTimeoutMs ?? DEFAULT_CHANNEL_WORKER_STARTUP_TIMEOUT_MS;
+        const timeoutMs = opts.startupTimeoutMs ?? CHANNEL_WORKER_STARTUP_TIMEOUT_MS;
         const error = `Channel worker did not become ready within ${timeoutMs}ms.`;
         snapshot = {
           ...snapshot,
@@ -589,16 +663,24 @@ function createChannelWorkerSupervisor(opts) {
         if (child === startedChild) {
           terminateBeforeReady();
         }
-      }, opts.startupTimeoutMs ?? DEFAULT_CHANNEL_WORKER_STARTUP_TIMEOUT_MS);
+      }, opts.startupTimeoutMs ?? CHANNEL_WORKER_STARTUP_TIMEOUT_MS);
       startupTimer.unref();
       startedChild.on("message", handleMessage);
       startedChild.once("exit", settleExit);
       startedChild.once("error", settleError);
     });
   }, "launch");
-  return {
+  const supervisor = {
     async start() {
-      if (child) return;
+      if (disposed) return;
+      if (child) {
+        if (stopping) {
+          throw new ChannelWorkerStopError(
+            "Channel worker stop is not yet confirmed."
+          );
+        }
+        return;
+      }
       stopping = false;
       clearRestartTimer();
       restartAttemptTimes = [];
@@ -607,34 +689,54 @@ function createChannelWorkerSupervisor(opts) {
     async stop() {
       clearRestartTimer();
       clearStaleHeartbeatTimer();
+      rejectPendingWebhookTasks(
+        "channel_worker_unavailable",
+        "Channel worker stopped."
+      );
       if (!child || snapshot.state === "exited" || snapshot.state === "failed" && hasObservedExit(snapshot) || snapshot.state === "stopped") {
         child = void 0;
         snapshot = { ...snapshot, state: "stopped" };
         return;
       }
-      const exited = waitForExit(child, 5e3);
+      const stoppingChild = child;
+      const exited = waitForExit(stoppingChild, CHANNEL_WORKER_STOP_GRACE_MS);
       stopping = true;
-      child.kill("SIGTERM");
-      if (!await exited) {
-        const killed = waitForExit(child, 2e3);
-        child.kill("SIGKILL");
+      stoppingChild.kill("SIGTERM");
+      if (!await exited && child === stoppingChild) {
+        const killed = waitForExit(stoppingChild, CHANNEL_WORKER_KILL_GRACE_MS);
+        stoppingChild.kill("SIGKILL");
         if (!await killed) {
-          child = void 0;
-          stopping = false;
           snapshot = {
             ...snapshot,
             state: "failed",
-            signal: "SIGKILL",
             error: "Channel worker did not exit after SIGKILL."
           };
-          return;
+          throw new ChannelWorkerStopError();
         }
       }
       child = void 0;
       stopping = false;
       snapshot = { ...snapshot, state: "stopped" };
     },
+    async restart() {
+      if (disposed) return snapshotCopy();
+      restarting ??= (async () => {
+        try {
+          await supervisor.stop();
+          await supervisor.start();
+          return snapshotCopy();
+        } finally {
+          restarting = void 0;
+        }
+      })();
+      return restarting;
+    },
     killAllSync() {
+      disposed = true;
+      rejectPendingWebhookTasks(
+        "channel_worker_unavailable",
+        "Channel worker stopped."
+      );
       if (!child || snapshot.state === "exited" || snapshot.state === "failed" && hasObservedExit(snapshot) || snapshot.state === "stopped") {
         clearRestartTimer();
         clearStaleHeartbeatTimer();
@@ -656,10 +758,64 @@ function createChannelWorkerSupervisor(opts) {
     },
     snapshot() {
       return snapshotCopy();
+    },
+    async enqueueWebhookTask(task) {
+      const startedChild = child;
+      if (!startedChild || snapshot.state !== "running") {
+        throw new ChannelWebhookEnqueueError(
+          "channel_worker_unavailable",
+          "Channel worker is not running."
+        );
+      }
+      const send = startedChild.send;
+      if (!send) {
+        throw new ChannelWebhookEnqueueError(
+          "channel_worker_unavailable",
+          "Channel worker IPC send failed."
+        );
+      }
+      const message = createChannelWebhookTaskMessage(task);
+      return await new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+          pendingWebhookTasks.delete(message.id);
+          reject(
+            new ChannelWebhookEnqueueError(
+              "channel_webhook_enqueue_timeout",
+              "Channel webhook task IPC timed out."
+            )
+          );
+        }, CHANNEL_WEBHOOK_TASK_IPC_TIMEOUT_MS);
+        timer.unref();
+        pendingWebhookTasks.set(message.id, { resolve, reject, timer });
+        try {
+          send.call(startedChild, message, (err) => {
+            if (err) {
+              rejectPendingWebhookTask(
+                message.id,
+                new ChannelWebhookEnqueueError(
+                  "channel_worker_unavailable",
+                  `Channel worker IPC send failed: ${err.message}`
+                )
+              );
+            }
+          });
+        } catch (err) {
+          rejectPendingWebhookTask(
+            message.id,
+            new ChannelWebhookEnqueueError(
+              "channel_worker_unavailable",
+              `Channel worker IPC send failed: ${err instanceof Error ? err.message : String(err)}`
+            )
+          );
+        }
+      });
     }
   };
+  return supervisor;
 }
 __name(createChannelWorkerSupervisor, "createChannelWorkerSupervisor");
+
 export {
+  ChannelWorkerStopError,
   createChannelWorkerSupervisor
 };

package/chunks/{chunk-AHNXYU4O.js → chunk-V6WHFGST.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   init_esbuild_shims
-} from "./chunk-A4BMJM77.js";
+} from "./chunk-5O2XNYP6.js";
 import {
   __name
 } from "./chunk-J2S4EL5Y.js";