@dhfpub/clawpool-openclaw 0.4.1

package/dist/index.js

@@ -0,0 +1,4667 @@
+// index.ts
+import { emptyPluginConfigSchema } from "openclaw/plugin-sdk/core";
+
+// src/channel.ts
+import {
+  applyAccountNameToChannelSection as applyAccountNameToChannelSection2,
+  deleteAccountFromConfigSection,
+  formatPairingApproveHint,
+  setAccountEnabledInConfigSection
+} from "openclaw/plugin-sdk/core";
+import { waitUntilAbort } from "openclaw/plugin-sdk/channel-lifecycle";
+
+// src/account-id.ts
+var DEFAULT_ACCOUNT_ID = "default";
+function normalizeOptionalAccountId(raw) {
+  const value = String(raw ?? "").trim();
+  if (!value) {
+    return void 0;
+  }
+  return value;
+}
+function normalizeAccountId(raw) {
+  return normalizeOptionalAccountId(raw) ?? DEFAULT_ACCOUNT_ID;
+}
+
+// src/actions.ts
+import {
+  jsonResult,
+  readStringParam
+} from "openclaw/plugin-sdk/channel-runtime";
+
+// src/accounts.ts
+function rawAibotConfig(cfg) {
+  return cfg.channels?.clawpool ?? {};
+}
+function listConfiguredAccountIds(cfg) {
+  const accounts = rawAibotConfig(cfg).accounts;
+  if (!accounts || typeof accounts !== "object") {
+    return [];
+  }
+  return Object.keys(accounts).filter(Boolean);
+}
+function listAibotAccountIds(cfg) {
+  const ids = listConfiguredAccountIds(cfg);
+  if (ids.length === 0) {
+    return [DEFAULT_ACCOUNT_ID];
+  }
+  return ids.toSorted((a, b) => a.localeCompare(b));
+}
+function resolveDefaultAibotAccountId(cfg) {
+  const aibotCfg = rawAibotConfig(cfg);
+  const preferred = normalizeOptionalAccountId(aibotCfg.defaultAccount);
+  if (preferred && listAibotAccountIds(cfg).some((accountId) => normalizeAccountId(accountId) === preferred)) {
+    return preferred;
+  }
+  const ids = listAibotAccountIds(cfg);
+  if (ids.includes(DEFAULT_ACCOUNT_ID)) {
+    return DEFAULT_ACCOUNT_ID;
+  }
+  return ids[0] ?? DEFAULT_ACCOUNT_ID;
+}
+function resolveAccountRawConfig(cfg, accountId) {
+  const aibotCfg = rawAibotConfig(cfg);
+  const { accounts: _ignoredAccounts, defaultAccount: _ignoredDefault, ...base } = aibotCfg;
+  const account = aibotCfg.accounts?.[accountId] ?? {};
+  return {
+    ...base,
+    ...account
+  };
+}
+function normalizeNonEmpty(value) {
+  const s = String(value ?? "").trim();
+  return s;
+}
+function normalizeAgentId(value) {
+  return normalizeNonEmpty(value);
+}
+function appendAgentIdToWsUrl(rawWsUrl, agentId) {
+  if (!rawWsUrl) {
+    return "";
+  }
+  const direct = rawWsUrl.replaceAll("{agent_id}", encodeURIComponent(agentId));
+  if (!agentId) {
+    return direct;
+  }
+  try {
+    const parsed = new URL(direct);
+    if (!parsed.searchParams.get("agent_id")) {
+      parsed.searchParams.set("agent_id", agentId);
+    }
+    return parsed.toString();
+  } catch {
+    if (direct.includes("agent_id=")) {
+      return direct;
+    }
+    return direct.includes("?") ? `${direct}&agent_id=${encodeURIComponent(agentId)}` : `${direct}?agent_id=${encodeURIComponent(agentId)}`;
+  }
+}
+function resolveWsUrl(merged, agentId) {
+  const envWs = normalizeNonEmpty(process.env.CLAWPOOL_WS_URL);
+  const cfgWs = normalizeNonEmpty(merged.wsUrl);
+  const ws = cfgWs || envWs;
+  if (ws) {
+    return appendAgentIdToWsUrl(ws, agentId);
+  }
+  if (!agentId) {
+    return "";
+  }
+  return `ws://127.0.0.1:27189/v1/agent-api/ws?agent_id=${encodeURIComponent(agentId)}`;
+}
+function redactAibotWsUrl(wsUrl) {
+  if (!wsUrl) {
+    return "";
+  }
+  try {
+    const parsed = new URL(wsUrl);
+    if (parsed.searchParams.has("agent_id")) {
+      parsed.searchParams.set("agent_id", "***");
+    }
+    return parsed.toString();
+  } catch {
+    return wsUrl.replace(/(agent_id=)[^&]+/g, "$1***");
+  }
+}
+function resolveAibotAccount(params) {
+  const accountId = normalizeAccountId(params.accountId);
+  const merged = resolveAccountRawConfig(params.cfg, accountId);
+  const baseEnabled = rawAibotConfig(params.cfg).enabled !== false;
+  const accountEnabled = merged.enabled !== false;
+  const enabled = baseEnabled && accountEnabled;
+  const agentId = normalizeAgentId(merged.agentId || process.env.CLAWPOOL_AGENT_ID);
+  const apiKey = normalizeNonEmpty(merged.apiKey || process.env.CLAWPOOL_API_KEY);
+  const wsUrl = resolveWsUrl(merged, agentId);
+  const configured = Boolean(wsUrl && agentId && apiKey);
+  return {
+    accountId,
+    name: normalizeNonEmpty(merged.name) || void 0,
+    enabled,
+    configured,
+    wsUrl,
+    agentId,
+    apiKey,
+    config: merged
+  };
+}
+function normalizeAibotSessionTarget(raw) {
+  const trimmed = String(raw ?? "").trim();
+  if (!trimmed) {
+    return "";
+  }
+  return trimmed.replace(/^clawpool:/i, "").replace(/^session:/i, "").trim();
+}
+
+// src/client.ts
+import { randomUUID } from "node:crypto";
+
+// src/protocol-send.ts
+var AIBOT_PROTOCOL_SEND_RATE_LIMIT = 8;
+var AIBOT_PROTOCOL_SEND_RATE_WINDOW_MS = 1e4;
+var AIBOT_PROTOCOL_SEND_RETRYABLE_CODE = 4008;
+var AIBOT_PROTOCOL_SEND_RETRY_MAX_ATTEMPTS = 3;
+var AIBOT_PROTOCOL_SEND_RETRY_BASE_DELAY_MS = 600;
+var AIBOT_PROTOCOL_SEND_RETRY_MAX_DELAY_MS = 2e3;
+var AIBOT_PROTOCOL_SEND_RATE_SAFETY_DELAY_MS = 100;
+function isRetryableAibotSendCode(code) {
+  return Number(code) === AIBOT_PROTOCOL_SEND_RETRYABLE_CODE;
+}
+function resolveAibotSendRetryMaxAttempts() {
+  return AIBOT_PROTOCOL_SEND_RETRY_MAX_ATTEMPTS;
+}
+function resolveAibotSendRetryDelayMs(attempt) {
+  const normalizedAttempt = Math.max(1, Math.floor(attempt));
+  const multiplier = 2 ** Math.max(0, normalizedAttempt - 1);
+  return Math.min(
+    AIBOT_PROTOCOL_SEND_RETRY_MAX_DELAY_MS,
+    AIBOT_PROTOCOL_SEND_RETRY_BASE_DELAY_MS * multiplier
+  );
+}
+function pruneAibotSendWindow(sentAtMs, nowMs) {
+  return sentAtMs.filter((value) => nowMs - value < AIBOT_PROTOCOL_SEND_RATE_WINDOW_MS);
+}
+function computeAibotSendThrottleDelayMs(sentAtMs, nowMs) {
+  const recent = pruneAibotSendWindow(sentAtMs, nowMs);
+  if (recent.length < AIBOT_PROTOCOL_SEND_RATE_LIMIT) {
+    return 0;
+  }
+  const earliest = recent[0] ?? nowMs;
+  return Math.max(1, earliest + AIBOT_PROTOCOL_SEND_RATE_WINDOW_MS - nowMs + AIBOT_PROTOCOL_SEND_RATE_SAFETY_DELAY_MS);
+}
+
+// src/protocol-text.ts
+var AIBOT_PROTOCOL_MAX_RUNES = 2e3;
+var AIBOT_PROTOCOL_MAX_BYTES = 12 * 1024;
+var DEFAULT_OUTBOUND_TEXT_CHUNK_LIMIT = 1200;
+var DEFAULT_STREAM_CHUNK_LIMIT = 48;
+function clampPositiveInt(value, fallback) {
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed)) {
+    return fallback;
+  }
+  return Math.max(1, Math.floor(parsed));
+}
+function resolveOutboundTextChunkLimit(value) {
+  return Math.min(
+    AIBOT_PROTOCOL_MAX_RUNES,
+    clampPositiveInt(value, DEFAULT_OUTBOUND_TEXT_CHUNK_LIMIT)
+  );
+}
+function resolveStreamTextChunkLimit(value) {
+  return Math.min(
+    AIBOT_PROTOCOL_MAX_RUNES,
+    clampPositiveInt(value, DEFAULT_STREAM_CHUNK_LIMIT)
+  );
+}
+function splitTextForAibotProtocol(text, preferredRunes) {
+  const source = String(text ?? "");
+  if (!source) {
+    return [];
+  }
+  const runeLimit = Math.min(AIBOT_PROTOCOL_MAX_RUNES, Math.max(1, Math.floor(preferredRunes)));
+  const chunks = [];
+  let current = "";
+  let currentRunes = 0;
+  let currentBytes = 0;
+  for (const rune of source) {
+    const runeBytes = Buffer.byteLength(rune, "utf8");
+    const nextRunes = currentRunes + 1;
+    const nextBytes = currentBytes + runeBytes;
+    const exceedPreferredRunes = nextRunes > runeLimit;
+    const exceedProtocolBytes = nextBytes > AIBOT_PROTOCOL_MAX_BYTES;
+    if (current && (exceedPreferredRunes || exceedProtocolBytes)) {
+      chunks.push(current);
+      current = "";
+      currentRunes = 0;
+      currentBytes = 0;
+    }
+    current += rune;
+    currentRunes += 1;
+    currentBytes += runeBytes;
+  }
+  if (current) {
+    chunks.push(current);
+  }
+  return chunks;
+}
+
+// src/client.ts
+var DEFAULT_RECONNECT_BASE_MS = 2e3;
+var DEFAULT_RECONNECT_MAX_MS = 3e4;
+var DEFAULT_RECONNECT_STABLE_MS = 3e4;
+var DEFAULT_CONNECT_TIMEOUT_MS = 1e4;
+var DEFAULT_HEARTBEAT_SEC = 30;
+function buildAuthPayload(account) {
+  return {
+    agent_id: account.agentId,
+    api_key: account.apiKey,
+    client: "openclaw-clawpool",
+    client_type: "openclaw"
+  };
+}
+var AibotPacketError = class extends Error {
+  cmd;
+  code;
+  constructor(cmd, code, message) {
+    super(`clawpool ${cmd}: code=${code} msg=${message}`);
+    this.name = "AibotPacketError";
+    this.cmd = cmd;
+    this.code = code;
+  }
+};
+function clampInt(value, fallback, min, max) {
+  const n = Number(value);
+  if (!Number.isFinite(n)) {
+    return fallback;
+  }
+  return Math.max(min, Math.min(max, Math.floor(n)));
+}
+function buildFastRetryDelays(baseDelayMs) {
+  const first = Math.max(100, Math.min(300, Math.floor(baseDelayMs / 4)));
+  const second = Math.max(first, Math.min(1e3, Math.floor(baseDelayMs / 2)));
+  return [first, second];
+}
+function randomIntInclusive(min, max) {
+  const boundedMin = Math.floor(min);
+  const boundedMax = Math.floor(max);
+  if (boundedMax <= boundedMin) {
+    return boundedMin;
+  }
+  return boundedMin + Math.floor(Math.random() * (boundedMax - boundedMin + 1));
+}
+function normalizeCloseReason(value) {
+  const reason = String(value ?? "").replace(/\s+/g, " ").trim();
+  if (!reason) {
+    return void 0;
+  }
+  return reason.slice(0, 160);
+}
+function redactWsUrlForLog(wsUrl) {
+  if (!wsUrl) {
+    return "";
+  }
+  try {
+    const parsed = new URL(wsUrl);
+    if (parsed.searchParams.has("agent_id")) {
+      parsed.searchParams.set("agent_id", "***");
+    }
+    return parsed.toString();
+  } catch {
+    return wsUrl.replace(/(agent_id=)[^&]+/g, "$1***");
+  }
+}
+function parseHeartbeatSec(payload) {
+  return clampInt(payload.heartbeat_sec, DEFAULT_HEARTBEAT_SEC, 5, 300);
+}
+async function sleepWithAbort(ms, abortSignal) {
+  if (ms <= 0 || abortSignal.aborted) {
+    return;
+  }
+  await new Promise((resolve) => {
+    let settled = false;
+    let timer = null;
+    function finish() {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      if (timer) {
+        clearTimeout(timer);
+      }
+      abortSignal.removeEventListener("abort", onAbort);
+      resolve();
+    }
+    function onAbort() {
+      finish();
+    }
+    timer = setTimeout(finish, ms);
+    abortSignal.addEventListener("abort", onAbort, { once: true });
+  });
+}
+async function sleep(ms) {
+  if (ms <= 0) {
+    return;
+  }
+  await new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+}
+function resolveReconnectPolicy(account) {
+  const baseDelayMs = clampInt(account.config.reconnectMs, DEFAULT_RECONNECT_BASE_MS, 100, 6e4);
+  const fallbackMaxMs = Math.max(DEFAULT_RECONNECT_MAX_MS, baseDelayMs * 8);
+  const maxDelayMs = clampInt(account.config.reconnectMaxMs, fallbackMaxMs, baseDelayMs, 3e5);
+  const stableConnectionMs = clampInt(
+    account.config.reconnectStableMs,
+    DEFAULT_RECONNECT_STABLE_MS,
+    1e3,
+    6e5
+  );
+  const connectTimeoutMs = clampInt(
+    account.config.connectTimeoutMs,
+    DEFAULT_CONNECT_TIMEOUT_MS,
+    1e3,
+    6e4
+  );
+  const fastRetryDelaysMs = buildFastRetryDelays(baseDelayMs);
+  return {
+    baseDelayMs,
+    maxDelayMs,
+    stableConnectionMs,
+    fastRetryDelaysMs,
+    authPenaltyAttemptFloor: fastRetryDelaysMs.length + 4,
+    connectTimeoutMs
+  };
+}
+var AuthRejectedError = class extends Error {
+  code;
+  constructor(code, message) {
+    super(`clawpool auth failed: code=${code}, msg=${message}`);
+    this.name = "AuthRejectedError";
+    this.code = code;
+  }
+};
+function parseCode(payload) {
+  const n = Number(payload.code ?? 0);
+  if (Number.isFinite(n)) {
+    return n;
+  }
+  return 0;
+}
+function parseMessage(payload) {
+  const s = String(payload.msg ?? "").trim();
+  return s || "unknown error";
+}
+function parseKickedReason(payload) {
+  const reason = String(payload.reason ?? payload.msg ?? "").trim();
+  return reason || "unknown";
+}
+async function wsDataToText(data) {
+  if (typeof data === "string") {
+    return data;
+  }
+  if (data instanceof ArrayBuffer) {
+    return Buffer.from(data).toString("utf8");
+  }
+  if (ArrayBuffer.isView(data)) {
+    return Buffer.from(data.buffer, data.byteOffset, data.byteLength).toString("utf8");
+  }
+  if (data && typeof data.text === "function") {
+    return data.text();
+  }
+  return String(data ?? "");
+}
+var AibotWsClient = class {
+  account;
+  callbacks;
+  reconnectPolicy;
+  ws = null;
+  running = false;
+  seq = Date.now();
+  loopPromise = null;
+  pending = /* @__PURE__ */ new Map();
+  pendingStreamHighSurrogate = /* @__PURE__ */ new Map();
+  sendMsgWindowBySession = /* @__PURE__ */ new Map();
+  reconnectPenaltyAttemptFloor = 0;
+  connectionSerial = 0;
+  activeConnectionSerial = 0;
+  keepaliveTimer = null;
+  keepaliveInFlight = false;
+  lastConnectionError = "";
+  lastConnectionErrorLogAt = 0;
+  suppressedConnectionErrors = 0;
+  lastReconnectLogAt = 0;
+  suppressedReconnectLogs = 0;
+  status = {
+    running: false,
+    connected: false,
+    authed: false,
+    lastError: null,
+    lastConnectAt: null,
+    lastDisconnectAt: null
+  };
+  constructor(account, callbacks = {}) {
+    this.account = account;
+    this.callbacks = callbacks;
+    this.reconnectPolicy = resolveReconnectPolicy(account);
+  }
+  logInfo(message) {
+    this.callbacks.logger?.info?.(`[clawpool] [${this.account.accountId}] ${message}`);
+  }
+  logWarn(message) {
+    this.callbacks.logger?.warn?.(`[clawpool] [${this.account.accountId}] ${message}`);
+  }
+  logError(message) {
+    this.callbacks.logger?.error?.(`[clawpool] [${this.account.accountId}] ${message}`);
+  }
+  logConnectionError(message) {
+    const now = Date.now();
+    const sameAsLast = this.lastConnectionError === message;
+    const shouldLog = !sameAsLast || now - this.lastConnectionErrorLogAt >= 3e4 || this.suppressedConnectionErrors >= 10;
+    if (!shouldLog) {
+      this.suppressedConnectionErrors += 1;
+      return;
+    }
+    const repeats = this.suppressedConnectionErrors;
+    this.lastConnectionError = message;
+    this.lastConnectionErrorLogAt = now;
+    this.suppressedConnectionErrors = 0;
+    if (repeats > 0) {
+      this.logWarn(`connection error: ${message} (suppressed=${repeats})`);
+      return;
+    }
+    this.logWarn(`connection error: ${message}`);
+  }
+  logReconnectPlan(params) {
+    const now = Date.now();
+    const important = params.attempt <= 3 || params.authRejected || params.penaltyFloor > 0 || params.stable || params.attempt % 10 === 0;
+    const shouldLog = important || now - this.lastReconnectLogAt >= 3e4;
+    if (!shouldLog) {
+      this.suppressedReconnectLogs += 1;
+      return;
+    }
+    const suppressed = this.suppressedReconnectLogs;
+    this.suppressedReconnectLogs = 0;
+    this.lastReconnectLogAt = now;
+    this.logInfo(
+      `reconnect scheduled in ${params.delayMs}ms attempt=${params.attempt} stable=${params.stable} authRejected=${params.authRejected} penaltyFloor=${params.penaltyFloor} suppressed=${suppressed}`
+    );
+  }
+  getStatus() {
+    return { ...this.status };
+  }
+  async start(abortSignal) {
+    if (this.running) {
+      return;
+    }
+    this.running = true;
+    this.updateStatus({ running: true, lastError: null });
+    this.logInfo(
+      `client start ws=${redactWsUrlForLog(this.account.wsUrl)} reconnectBaseMs=${this.reconnectPolicy.baseDelayMs} reconnectMaxMs=${this.reconnectPolicy.maxDelayMs} reconnectStableMs=${this.reconnectPolicy.stableConnectionMs} connectTimeoutMs=${this.reconnectPolicy.connectTimeoutMs}`
+    );
+    this.loopPromise = this.runLoop(abortSignal);
+    void this.loopPromise.catch((err) => {
+      const msg = err instanceof Error ? err.message : String(err);
+      this.updateStatus({
+        running: false,
+        connected: false,
+        authed: false,
+        lastError: msg,
+        lastDisconnectAt: Date.now()
+      });
+      this.logError(`run loop crashed: ${msg}`);
+    });
+  }
+  stop() {
+    this.running = false;
+    this.stopKeepalive();
+    this.rejectAllPending(new Error("clawpool client stopped"));
+    this.safeCloseWs("client_stopped");
+    this.updateStatus({
+      running: false,
+      connected: false,
+      authed: false,
+      lastDisconnectAt: Date.now()
+    });
+  }
+  async waitUntilStopped() {
+    await this.loopPromise;
+  }
+  async sendText(sessionId, text, opts = {}) {
+    this.ensureReady();
+    const clientMsgId = opts.clientMsgId || `clawpool_${randomUUID()}`;
+    const payload = this.buildSendTextPayload(sessionId, text, clientMsgId, opts);
+    try {
+      return await this.sendMessageWithRetry(sessionId, payload, opts.timeoutMs ?? 2e4, "sendText");
+    } catch (err) {
+      if (!this.isMessageTooLargeError(err)) {
+        throw err;
+      }
+      return this.sendSplitTextAfterSizeError(sessionId, text, clientMsgId, opts);
+    }
+  }
+  async sendMedia(sessionId, mediaUrl, caption = "", opts = {}) {
+    this.ensureReady();
+    const clientMsgId = opts.clientMsgId || `clawpool_${randomUUID()}`;
+    const payload = this.buildSendMediaPayload(sessionId, mediaUrl, caption, clientMsgId, opts);
+    try {
+      return await this.sendMessageWithRetry(sessionId, payload, opts.timeoutMs ?? 3e4, "sendMedia");
+    } catch (err) {
+      if (!this.isMessageTooLargeError(err) || !caption) {
+        throw err;
+      }
+      return this.sendMediaCaptionAfterSizeError(sessionId, mediaUrl, caption, clientMsgId, opts);
+    }
+  }
+  async bindSessionRoute(channel, accountId, routeSessionKey, sessionId, opts = {}) {
+    this.ensureReady();
+    const normalizedChannel = String(channel ?? "").trim().toLowerCase();
+    const normalizedAccountID = String(accountId ?? "").trim();
+    const normalizedRouteSessionKey = String(routeSessionKey ?? "").trim();
+    const normalizedSessionID = String(sessionId ?? "").trim();
+    if (!normalizedChannel || !normalizedAccountID || !normalizedRouteSessionKey || !normalizedSessionID) {
+      throw new Error("clawpool session_route_bind requires channel/account_id/route_session_key/session_id");
+    }
+    this.logInfo(
+      `session_route_bind request channel=${normalizedChannel} accountId=${normalizedAccountID} routeSessionKey=${normalizedRouteSessionKey} sessionId=${normalizedSessionID}`
+    );
+    const packet = await this.request(
+      "session_route_bind",
+      {
+        channel: normalizedChannel,
+        account_id: normalizedAccountID,
+        route_session_key: normalizedRouteSessionKey,
+        session_id: normalizedSessionID
+      },
+      {
+        expected: ["send_ack", "send_nack", "error"],
+        timeoutMs: opts.timeoutMs ?? 1e4
+      }
+    );
+    if (packet.cmd !== "send_ack") {
+      this.logWarn(
+        `session_route_bind nack channel=${normalizedChannel} accountId=${normalizedAccountID} routeSessionKey=${normalizedRouteSessionKey} sessionId=${normalizedSessionID}`
+      );
+      throw this.packetError(packet);
+    }
+    this.logInfo(
+      `session_route_bind ack channel=${normalizedChannel} accountId=${normalizedAccountID} routeSessionKey=${normalizedRouteSessionKey} sessionId=${normalizedSessionID}`
+    );
+    return packet.payload;
+  }
+  async resolveSessionRoute(channel, accountId, routeSessionKey, opts = {}) {
+    this.ensureReady();
+    const normalizedChannel = String(channel ?? "").trim().toLowerCase();
+    const normalizedAccountID = String(accountId ?? "").trim();
+    const normalizedRouteSessionKey = String(routeSessionKey ?? "").trim();
+    if (!normalizedChannel || !normalizedAccountID || !normalizedRouteSessionKey) {
+      throw new Error("clawpool session_route_resolve requires channel/account_id/route_session_key");
+    }
+    this.logInfo(
+      `session_route_resolve request channel=${normalizedChannel} accountId=${normalizedAccountID} routeSessionKey=${normalizedRouteSessionKey}`
+    );
+    const packet = await this.request(
+      "session_route_resolve",
+      {
+        channel: normalizedChannel,
+        account_id: normalizedAccountID,
+        route_session_key: normalizedRouteSessionKey
+      },
+      {
+        expected: ["send_ack", "send_nack", "error"],
+        timeoutMs: opts.timeoutMs ?? 1e4
+      }
+    );
+    if (packet.cmd !== "send_ack") {
+      this.logWarn(
+        `session_route_resolve nack channel=${normalizedChannel} accountId=${normalizedAccountID} routeSessionKey=${normalizedRouteSessionKey}`
+      );
+      throw this.packetError(packet);
+    }
+    const payload = packet.payload;
+    const normalizedSessionID = String(payload.session_id ?? "").trim();
+    if (!normalizedSessionID) {
+      throw new Error("clawpool session_route_resolve ack missing session_id");
+    }
+    this.logInfo(
+      `session_route_resolve ack channel=${normalizedChannel} accountId=${normalizedAccountID} routeSessionKey=${normalizedRouteSessionKey} sessionId=${normalizedSessionID}`
+    );
+    return {
+      ...payload,
+      channel: String(payload.channel ?? normalizedChannel),
+      account_id: String(payload.account_id ?? normalizedAccountID),
+      route_session_key: String(payload.route_session_key ?? normalizedRouteSessionKey),
+      session_id: normalizedSessionID
+    };
+  }
+  async sendStreamChunk(sessionId, deltaContent, opts) {
+    this.ensureReady();
+    const normalizedDeltaContent = this.normalizeStreamDeltaContent(
+      opts.clientMsgId,
+      deltaContent,
+      opts.isFinish === true
+    );
+    if (!normalizedDeltaContent && !opts.isFinish) {
+      return;
+    }
+    const payload = {
+      session_id: sessionId,
+      client_msg_id: opts.clientMsgId,
+      delta_content: normalizedDeltaContent,
+      is_finish: opts.isFinish ?? false
+    };
+    const eventId = String(opts.eventId ?? "").trim();
+    if (eventId) {
+      payload.event_id = eventId;
+    }
+    if (opts.quotedMessageId) {
+      payload.quoted_message_id = opts.quotedMessageId;
+    }
+    if (opts.isFinish) {
+      const packet = await this.request("client_stream_chunk", payload, {
+        expected: ["send_ack", "send_nack", "error"],
+        timeoutMs: opts.timeoutMs ?? 2e4
+      });
+      if (packet.cmd !== "send_ack") {
+        throw this.packetError(packet);
+      }
+      return packet.payload;
+    }
+    this.sendPacket("client_stream_chunk", payload);
+  }
+  async deleteMessage(sessionId, msgId, opts = {}) {
+    this.ensureReady();
+    const normalizedSessionId = String(sessionId ?? "").trim();
+    if (!normalizedSessionId) {
+      throw new Error("clawpool delete_msg requires session_id");
+    }
+    const normalizedMsgId = String(msgId ?? "").trim();
+    if (!/^\d+$/.test(normalizedMsgId)) {
+      throw new Error("clawpool delete_msg requires numeric msg_id");
+    }
+    const packet = await this.request(
+      "delete_msg",
+      {
+        session_id: normalizedSessionId,
+        msg_id: normalizedMsgId
+      },
+      {
+        expected: ["send_ack", "send_nack", "error"],
+        timeoutMs: opts.timeoutMs ?? 2e4
+      }
+    );
+    if (packet.cmd !== "send_ack") {
+      throw this.packetError(packet);
+    }
+    return packet.payload;
+  }
+  ackEvent(eventId, payload = {}) {
+    this.ensureReady();
+    const normalizedEventId = String(eventId ?? "").trim();
+    if (!normalizedEventId) {
+      throw new Error("clawpool event_ack requires event_id");
+    }
+    const ackPayload = {
+      event_id: normalizedEventId,
+      received_at: Math.floor(payload.receivedAt ?? Date.now())
+    };
+    const sessionId = String(payload.sessionId ?? "").trim();
+    if (sessionId) {
+      ackPayload.session_id = sessionId;
+    }
+    const msgId = String(payload.msgId ?? "").trim();
+    if (/^\d+$/.test(msgId)) {
+      ackPayload.msg_id = msgId;
+    }
+    this.sendPacket("event_ack", ackPayload);
+  }
+  sendEventResult(payload) {
+    this.ensureReady();
+    const eventId = String(payload.event_id ?? "").trim();
+    const status = String(payload.status ?? "").trim();
+    if (!eventId) {
+      throw new Error("clawpool event_result requires event_id");
+    }
+    if (!status) {
+      throw new Error("clawpool event_result requires status");
+    }
+    const packet = {
+      event_id: eventId,
+      status
+    };
+    const code = String(payload.code ?? "").trim();
+    if (code) {
+      packet.code = code;
+    }
+    const msg = String(payload.msg ?? "").trim();
+    if (msg) {
+      packet.msg = msg;
+    }
+    const updatedAt = Number(payload.updated_at);
+    if (Number.isFinite(updatedAt) && updatedAt > 0) {
+      packet.updated_at = Math.floor(updatedAt);
+    }
+    this.sendPacket("event_result", packet);
+  }
+  sendEventStopAck(payload) {
+    this.ensureReady();
+    const eventId = String(payload.event_id ?? "").trim();
+    if (!eventId) {
+      throw new Error("clawpool event_stop_ack requires event_id");
+    }
+    const packet = {
+      event_id: eventId,
+      accepted: payload.accepted === true
+    };
+    const stopId = String(payload.stop_id ?? "").trim();
+    if (stopId) {
+      packet.stop_id = stopId;
+    }
+    const updatedAt = Number(payload.updated_at);
+    if (Number.isFinite(updatedAt) && updatedAt > 0) {
+      packet.updated_at = Math.floor(updatedAt);
+    }
+    this.sendPacket("event_stop_ack", packet);
+  }
+  sendEventStopResult(payload) {
+    this.ensureReady();
+    const eventId = String(payload.event_id ?? "").trim();
+    const status = String(payload.status ?? "").trim();
+    if (!eventId) {
+      throw new Error("clawpool event_stop_result requires event_id");
+    }
+    if (!status) {
+      throw new Error("clawpool event_stop_result requires status");
+    }
+    const packet = {
+      event_id: eventId,
+      status
+    };
+    const stopId = String(payload.stop_id ?? "").trim();
+    if (stopId) {
+      packet.stop_id = stopId;
+    }
+    const code = String(payload.code ?? "").trim();
+    if (code) {
+      packet.code = code;
+    }
+    const msg = String(payload.msg ?? "").trim();
+    if (msg) {
+      packet.msg = msg;
+    }
+    const updatedAt = Number(payload.updated_at);
+    if (Number.isFinite(updatedAt) && updatedAt > 0) {
+      packet.updated_at = Math.floor(updatedAt);
+    }
+    this.sendPacket("event_stop_result", packet);
+  }
+  setSessionComposing(sessionId, active, opts = {}) {
+    this.ensureReady();
+    const normalizedSessionId = String(sessionId ?? "").trim();
+    if (!normalizedSessionId) {
+      throw new Error("clawpool session_activity_set requires session_id");
+    }
+    const payload = {
+      session_id: normalizedSessionId,
+      kind: "composing",
+      active
+    };
+    const refEventId = String(opts.refEventId ?? "").trim();
+    if (refEventId) {
+      payload.ref_event_id = refEventId;
+    }
+    const refMsgId = String(opts.refMsgId ?? "").trim();
+    if (/^\d+$/.test(refMsgId)) {
+      payload.ref_msg_id = refMsgId;
+    }
+    this.sendPacket("session_activity_set", payload);
+  }
+  async runLoop(abortSignal) {
+    let attempt = 0;
+    while (this.running && !abortSignal.aborted) {
+      let uptimeMs = 0;
+      let authRejected = false;
+      let shouldReconnect = true;
+      const cycle = attempt + 1;
+      try {
+        const outcome = await this.connectOnce(abortSignal, cycle);
+        uptimeMs = outcome.uptimeMs;
+        shouldReconnect = !outcome.aborted;
+        if (!outcome.aborted) {
+          const codeText = outcome.closeCode != null ? String(outcome.closeCode) : "-";
+          const reasonText = outcome.closeReason ? ` reason=${outcome.closeReason}` : "";
+          this.logWarn(
+            `websocket closed cause=${outcome.cause} code=${codeText}${reasonText} uptimeMs=${uptimeMs}`
+          );
+        }
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        authRejected = err instanceof AuthRejectedError;
+        this.updateStatus({
+          connected: false,
+          authed: false,
+          lastError: msg,
+          lastDisconnectAt: Date.now()
+        });
+        this.logConnectionError(msg);
+      }
+      if (!this.running || abortSignal.aborted || !shouldReconnect) {
+        break;
+      }
+      const stable = uptimeMs >= this.reconnectPolicy.stableConnectionMs;
+      if (stable) {
+        attempt = 0;
+      }
+      attempt += 1;
+      if (authRejected) {
+        attempt = Math.max(attempt, this.reconnectPolicy.authPenaltyAttemptFloor);
+      }
+      const penaltyFloor = this.consumeReconnectPenaltyAttemptFloor();
+      if (penaltyFloor > 0) {
+        attempt = Math.max(attempt, penaltyFloor);
+      }
+      const delay = this.resolveReconnectDelayMs(attempt);
+      this.logReconnectPlan({
+        delayMs: delay,
+        attempt,
+        stable,
+        authRejected,
+        penaltyFloor
+      });
+      await sleepWithAbort(delay, abortSignal);
+    }
+    this.stop();
+  }
+  async connectOnce(abortSignal, cycle) {
+    const connSerial = this.nextConnectionSerial();
+    this.logInfo(`websocket connect begin conn=${connSerial} cycle=${cycle}`);
+    const ws = await this.openWebSocket(this.account.wsUrl, abortSignal);
+    this.ws = ws;
+    this.activeConnectionSerial = connSerial;
+    const connectedAt = Date.now();
+    this.updateStatus({
+      connected: true,
+      authed: false,
+      lastError: null,
+      lastConnectAt: connectedAt
+    });
+    this.logInfo(`websocket connected conn=${connSerial}`);
+    const onMessage = (event) => {
+      void this.handleMessageEvent(event.data, connSerial).catch((err) => {
+        const message = err instanceof Error ? err.message : String(err);
+        this.logError(`handle message failed conn=${connSerial}: ${message}`);
+      });
+    };
+    const onClose = () => {
+      this.stopKeepalive();
+      this.updateStatus({
+        connected: false,
+        authed: false,
+        lastDisconnectAt: Date.now()
+      });
+      this.rejectAllPending(new Error("clawpool websocket closed"));
+      if (this.ws === ws && ws.readyState !== WebSocket.OPEN) {
+        this.ws = null;
+        if (this.activeConnectionSerial === connSerial) {
+          this.activeConnectionSerial = 0;
+        }
+      }
+    };
+    const onError = () => {
+      this.stopKeepalive();
+      this.updateStatus({
+        connected: false,
+        authed: false,
+        lastDisconnectAt: Date.now()
+      });
+      this.rejectAllPending(new Error("clawpool websocket error"));
+    };
+    ws.addEventListener("message", onMessage);
+    ws.addEventListener("close", onClose);
+    ws.addEventListener("error", onError);
+    try {
+      const auth = await this.authenticate(connSerial);
+      this.startKeepalive(ws, connSerial, auth.heartbeatSec);
+      const outcome = await this.waitForCloseOrAbort(ws, abortSignal);
+      return {
+        ...outcome,
+        uptimeMs: Math.max(0, Date.now() - connectedAt)
+      };
+    } catch (err) {
+      this.safeCloseSpecificWs(ws, "connect_once_error");
+      throw err;
+    } finally {
+      ws.removeEventListener("message", onMessage);
+      ws.removeEventListener("close", onClose);
+      ws.removeEventListener("error", onError);
+      this.stopKeepalive();
+      this.safeCloseSpecificWs(ws, "connect_once_finally");
+      if (this.activeConnectionSerial === connSerial) {
+        this.activeConnectionSerial = 0;
+      }
+      this.logInfo(`websocket connect end conn=${connSerial}`);
+    }
+  }
+  async openWebSocket(url, abortSignal) {
+    return new Promise((resolve, reject) => {
+      const ws = new WebSocket(url);
+      let done = false;
+      const timeoutMs = this.reconnectPolicy.connectTimeoutMs;
+      let timer = null;
+      const closeWs = () => {
+        try {
+          ws.close();
+        } catch {
+        }
+      };
+      const onOpen = () => {
+        finish(() => resolve(ws));
+      };
+      const onError = () => {
+        finish(() => reject(new Error("clawpool websocket connect failed")));
+      };
+      const onAbort = () => {
+        finish(() => {
+          closeWs();
+          reject(new Error("aborted"));
+        });
+      };
+      const finish = (fn) => {
+        if (done) {
+          return;
+        }
+        done = true;
+        if (timer) {
+          clearTimeout(timer);
+        }
+        ws.removeEventListener("open", onOpen);
+        ws.removeEventListener("error", onError);
+        abortSignal.removeEventListener("abort", onAbort);
+        fn();
+      };
+      timer = setTimeout(() => {
+        finish(() => {
+          closeWs();
+          reject(new Error("clawpool websocket connect timeout"));
+        });
+      }, timeoutMs);
+      ws.addEventListener("open", onOpen);
+      ws.addEventListener("error", onError);
+      abortSignal.addEventListener("abort", onAbort, { once: true });
+    });
+  }
+  async waitForCloseOrAbort(ws, abortSignal) {
+    return new Promise((resolve) => {
+      let settled = false;
+      const closeWs = () => {
+        this.safeCloseSpecificWs(ws);
+      };
+      function finish(result) {
+        if (settled) {
+          return;
+        }
+        settled = true;
+        ws.removeEventListener("close", onClose);
+        ws.removeEventListener("error", onError);
+        abortSignal.removeEventListener("abort", onAbort);
+        resolve(result);
+      }
+      function onClose(event) {
+        const close = event;
+        const code = Number(close.code);
+        finish({
+          cause: "close",
+          aborted: false,
+          closeCode: Number.isFinite(code) ? code : void 0,
+          closeReason: normalizeCloseReason(close.reason)
+        });
+      }
+      function onError() {
+        finish({
+          cause: "error",
+          aborted: false
+        });
+      }
+      function onAbort() {
+        closeWs();
+        finish({
+          cause: "abort",
+          aborted: true
+        });
+      }
+      ws.addEventListener("close", onClose);
+      ws.addEventListener("error", onError);
+      abortSignal.addEventListener("abort", onAbort, { once: true });
+    });
+  }
+  async authenticate(connSerial) {
+    this.logInfo(`auth begin conn=${connSerial}`);
+    const packet = await this.request(
+      "auth",
+      buildAuthPayload(this.account),
+      {
+        expected: ["auth_ack"],
+        timeoutMs: 1e4,
+        requireAuthed: false
+      }
+    );
+    const payload = packet.payload ?? {};
+    const code = parseCode(payload);
+    if (code !== 0) {
+      throw new AuthRejectedError(code, parseMessage(payload));
+    }
+    const heartbeatSec = parseHeartbeatSec(payload);
+    const protocol = String(payload.protocol ?? "").trim() || void 0;
+    this.updateStatus({ authed: true, lastError: null });
+    this.logInfo(
+      `auth success conn=${connSerial} heartbeatSec=${heartbeatSec} protocol=${protocol ?? "-"}`
+    );
+    return {
+      heartbeatSec,
+      protocol
+    };
+  }
+  async handleMessageEvent(data, connSerial) {
+    const text = await wsDataToText(data);
+    if (!text) {
+      return;
+    }
+    const resolvedConnSerial = (connSerial ?? this.activeConnectionSerial) || 0;
+    let packet;
+    try {
+      packet = JSON.parse(text);
+    } catch {
+      this.logWarn(
+        `ignored non-json message conn=${resolvedConnSerial} bytes=${text.length} preview=${JSON.stringify(text.slice(0, 200))}`
+      );
+      return;
+    }
+    const cmd = String(packet.cmd ?? "").trim();
+    const seq = Number(packet.seq ?? 0);
+    if (cmd !== "ping") {
+      this.logInfo(
+        `inbound packet conn=${resolvedConnSerial} cmd=${cmd || "-"} seq=${seq} bytes=${text.length}`
+      );
+    }
+    if (cmd === "event_stop") {
+      const payload = packet.payload;
+      this.logInfo(
+        `received stop-related packet cmd=${cmd} eventId=${String(payload.event_id ?? "").trim() || "-"} sessionId=${String(payload.session_id ?? "").trim() || "-"} stopId=${String(payload.stop_id ?? "").trim() || "-"} seq=${seq} bytes=${text.length}`
+      );
+    }
+    if (cmd === "ping") {
+      this.sendPacket("pong", { ts: Date.now() }, seq > 0 ? seq : void 0, false);
+      return;
+    }
+    if (cmd === "event_msg") {
+      this.callbacks.onEventMsg?.(packet.payload);
+      return;
+    }
+    if (cmd === "event_react") {
+      this.callbacks.onEventReact?.(packet.payload);
+      return;
+    }
+    if (cmd === "event_revoke") {
+      this.callbacks.onEventRevoke?.(packet.payload);
+      return;
+    }
+    if (cmd === "event_stop") {
+      const payload = packet.payload;
+      this.logInfo(
+        `received event_stop eventId=${String(payload.event_id ?? "").trim() || "-"} sessionId=${String(payload.session_id ?? "").trim() || "-"} stopId=${String(payload.stop_id ?? "").trim() || "-"} seq=${seq}`
+      );
+      this.callbacks.onEventStop?.(packet.payload);
+      return;
+    }
+    if (cmd === "kicked") {
+      const payload = packet.payload ?? {};
+      const reason = parseKickedReason(payload);
+      if (reason === "replaced_by_new_connection") {
+        this.reconnectPenaltyAttemptFloor = Math.max(
+          this.reconnectPenaltyAttemptFloor,
+          this.reconnectPolicy.fastRetryDelaysMs.length + 5
+        );
+        this.logWarn(
+          `apply reconnect penalty for kicked replacement penaltyFloor=${this.reconnectPenaltyAttemptFloor}`
+        );
+      }
+      this.logWarn(`connection kicked by server reason=${reason}`);
+      this.safeCloseWs("kicked_by_server");
+      return;
+    }
+    const pending = this.pending.get(seq);
+    if (pending && pending.expected.has(cmd)) {
+      this.pending.delete(seq);
+      clearTimeout(pending.timer);
+      pending.resolve(packet);
+      return;
+    }
+  }
+  ensureReady(requireAuthed = true) {
+    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+      throw new Error("clawpool websocket is not open");
+    }
+    if (requireAuthed && !this.status.authed) {
+      throw new Error("clawpool websocket is not authed");
+    }
+  }
+  nextSeq() {
+    this.seq += 1;
+    return this.seq;
+  }
+  sendPacket(cmd, payload, seq, requireAuthed = true) {
+    this.ensureReady(requireAuthed);
+    const outSeq = seq ?? this.nextSeq();
+    const packet = {
+      cmd,
+      seq: outSeq,
+      payload
+    };
+    if (cmd === "event_stop_ack" || cmd === "event_stop_result") {
+      this.logInfo(
+        `send stop-related packet cmd=${cmd} eventId=${String(payload.event_id ?? "").trim() || "-"} stopId=${String(payload.stop_id ?? "").trim() || "-"} status=${String(payload.status ?? "").trim() || "-"} accepted=${String(payload.accepted ?? "").trim() || "-"} seq=${outSeq}`
+      );
+    }
+    this.ws?.send(JSON.stringify(packet));
+    return outSeq;
+  }
+  async request(cmd, payload, opts) {
+    this.ensureReady(opts.requireAuthed ?? true);
+    const seq = this.nextSeq();
+    const expected = new Set(opts.expected);
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.pending.delete(seq);
+        reject(new Error(`${cmd} timeout`));
+      }, opts.timeoutMs);
+      this.pending.set(seq, {
+        expected,
+        resolve,
+        reject,
+        timer
+      });
+      try {
+        const packet = {
+          cmd,
+          seq,
+          payload
+        };
+        this.ws?.send(JSON.stringify(packet));
+      } catch (err) {
+        this.pending.delete(seq);
+        clearTimeout(timer);
+        reject(err instanceof Error ? err : new Error(String(err)));
+      }
+    });
+  }
+  rejectAllPending(err) {
+    const pendingCount = this.pending.size;
+    if (pendingCount > 0) {
+      this.logWarn(`reject pending requests count=${pendingCount} reason=${err.message}`);
+    }
+    for (const [seq, pending] of this.pending.entries()) {
+      this.pending.delete(seq);
+      clearTimeout(pending.timer);
+      pending.reject(err);
+    }
+  }
+  buildSendTextPayload(sessionId, text, clientMsgId, opts) {
+    const payload = {
+      session_id: sessionId,
+      client_msg_id: clientMsgId,
+      msg_type: 1,
+      content: text
+    };
+    const eventId = String(opts.eventId ?? "").trim();
+    if (eventId) {
+      payload.event_id = eventId;
+    }
+    if (opts.quotedMessageId) {
+      payload.quoted_message_id = opts.quotedMessageId;
+    }
+    if (opts.extra && Object.keys(opts.extra).length > 0) {
+      payload.extra = opts.extra;
+    }
+    return payload;
+  }
+  buildSendMediaPayload(sessionId, mediaUrl, caption, clientMsgId, opts) {
+    const payload = {
+      session_id: sessionId,
+      client_msg_id: clientMsgId,
+      msg_type: opts.msgType ?? 2,
+      content: caption || "[media]",
+      media_url: mediaUrl
+    };
+    const eventId = String(opts.eventId ?? "").trim();
+    if (eventId) {
+      payload.event_id = eventId;
+    }
+    if (opts.quotedMessageId) {
+      payload.quoted_message_id = opts.quotedMessageId;
+    }
+    if (opts.extra && Object.keys(opts.extra).length > 0) {
+      payload.extra = opts.extra;
+    }
+    return payload;
+  }
+  async sendMessageWithRetry(sessionId, payload, timeoutMs, action) {
+    const maxAttempts = resolveAibotSendRetryMaxAttempts();
+    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+      await this.awaitSendMsgSlot(sessionId);
+      const packet = await this.request("send_msg", payload, {
+        expected: ["send_ack", "send_nack", "error"],
+        timeoutMs
+      });
+      if (packet.cmd === "send_ack") {
+        return packet.payload;
+      }
+      const err = this.packetError(packet);
+      if (this.isRetryableSendError(err) && attempt < maxAttempts) {
+        const delayMs = resolveAibotSendRetryDelayMs(attempt);
+        this.logWarn(
+          `${action} rate limited sessionId=${sessionId} attempt=${attempt}/${maxAttempts} delayMs=${delayMs}`
+        );
+        await sleep(delayMs);
+        continue;
+      }
+      throw err;
+    }
+    throw new Error(`clawpool ${action} exhausted retry attempts`);
+  }
+  async sendSplitTextAfterSizeError(sessionId, text, clientMsgId, opts) {
+    const chunks = splitTextForAibotProtocol(text, DEFAULT_OUTBOUND_TEXT_CHUNK_LIMIT);
+    if (chunks.length <= 1) {
+      throw new Error(`clawpool sendText size recovery failed clientMsgId=${clientMsgId}`);
+    }
+    this.logWarn(
+      `sendText size recovery sessionId=${sessionId} clientMsgId=${clientMsgId} chunkCount=${chunks.length}`
+    );
+    let lastAck = null;
+    for (let index = 0; index < chunks.length; index++) {
+      const chunkClientMsgId = this.buildChunkClientMsgId(clientMsgId, index + 1);
+      lastAck = await this.sendMessageWithRetry(
+        sessionId,
+        this.buildSendTextPayload(sessionId, chunks[index] ?? "", chunkClientMsgId, opts),
+        opts.timeoutMs ?? 2e4,
+        "sendText"
+      );
+    }
+    if (lastAck == null) {
+      throw new Error(`clawpool sendText size recovery produced no outbound chunks clientMsgId=${clientMsgId}`);
+    }
+    return lastAck;
+  }
+  async sendMediaCaptionAfterSizeError(sessionId, mediaUrl, caption, clientMsgId, opts) {
+    const chunks = splitTextForAibotProtocol(caption, DEFAULT_OUTBOUND_TEXT_CHUNK_LIMIT);
+    if (chunks.length <= 1) {
+      throw new Error(`clawpool sendMedia size recovery failed clientMsgId=${clientMsgId}`);
+    }
+    this.logWarn(
+      `sendMedia size recovery sessionId=${sessionId} clientMsgId=${clientMsgId} chunkCount=${chunks.length}`
+    );
+    const mediaAck = await this.sendMessageWithRetry(
+      sessionId,
+      this.buildSendMediaPayload(
+        sessionId,
+        mediaUrl,
+        chunks[0] ?? "",
+        `${clientMsgId}_media`,
+        opts
+      ),
+      opts.timeoutMs ?? 3e4,
+      "sendMedia"
+    );
+    for (let index = 1; index < chunks.length; index++) {
+      const chunkClientMsgId = this.buildChunkClientMsgId(clientMsgId, index);
+      await this.sendMessageWithRetry(
+        sessionId,
+        this.buildSendTextPayload(sessionId, chunks[index] ?? "", chunkClientMsgId, opts),
+        opts.timeoutMs ?? 2e4,
+        "sendText"
+      );
+    }
+    return mediaAck;
+  }
+  async awaitSendMsgSlot(sessionId) {
+    const normalizedSessionId = String(sessionId ?? "").trim();
+    if (!normalizedSessionId) {
+      return;
+    }
+    for (; ; ) {
+      const now = Date.now();
+      const recent = pruneAibotSendWindow(this.sendMsgWindowBySession.get(normalizedSessionId) ?? [], now);
+      const waitMs = computeAibotSendThrottleDelayMs(recent, now);
+      this.sendMsgWindowBySession.set(normalizedSessionId, recent);
+      if (waitMs <= 0) {
+        recent.push(now);
+        this.sendMsgWindowBySession.set(normalizedSessionId, recent);
+        return;
+      }
+      this.logWarn(
+        `send_msg pacing sessionId=${normalizedSessionId} queued=${recent.length} waitMs=${waitMs}`
+      );
+      await sleep(waitMs);
+    }
+  }
+  isRetryableSendError(err) {
+    return err instanceof AibotPacketError && isRetryableAibotSendCode(err.code);
+  }
+  isMessageTooLargeError(err) {
+    return err instanceof AibotPacketError && err.code === 4004;
+  }
+  buildChunkClientMsgId(clientMsgId, chunkIndex) {
+    return `${clientMsgId}_chunk${chunkIndex}`;
+  }
+  packetError(packet) {
+    const payload = packet.payload;
+    const code = Number(payload.code ?? 0);
+    const msg = String(payload.msg ?? packet.cmd ?? "unknown error");
+    return new AibotPacketError(packet.cmd, code, msg);
+  }
+  normalizeStreamDeltaContent(clientMsgId, deltaContent, isFinish) {
+    const carry = this.pendingStreamHighSurrogate.get(clientMsgId) ?? "";
+    this.pendingStreamHighSurrogate.delete(clientMsgId);
+    let normalized = `${carry}${String(deltaContent ?? "")}`;
+    if (!normalized) {
+      return "";
+    }
+    if (isFinish && !deltaContent && carry) {
+      this.logWarn(`dropping dangling high surrogate at stream finish clientMsgId=${clientMsgId}`);
+      return "";
+    }
+    if (!isFinish && this.endsWithHighSurrogate(normalized)) {
+      this.pendingStreamHighSurrogate.set(clientMsgId, normalized.slice(-1));
+      normalized = normalized.slice(0, -1);
+    } else if (isFinish && this.endsWithHighSurrogate(normalized)) {
+      this.logWarn(`dropping dangling high surrogate at stream finish clientMsgId=${clientMsgId}`);
+      normalized = normalized.slice(0, -1);
+    }
+    return normalized;
+  }
+  endsWithHighSurrogate(value) {
+    if (!value) {
+      return false;
+    }
+    const code = value.charCodeAt(value.length - 1);
+    return code >= 55296 && code <= 56319;
+  }
+  nextConnectionSerial() {
+    this.connectionSerial += 1;
+    return this.connectionSerial;
+  }
+  resolveKeepalivePolicy(heartbeatSec) {
+    const defaultIntervalMs = Math.max(5e3, Math.min(2e4, Math.floor(heartbeatSec * 1e3 / 2)));
+    const intervalMs = clampInt(
+      this.account.config.keepalivePingMs,
+      defaultIntervalMs,
+      2e3,
+      6e4
+    );
+    const defaultTimeoutMs = Math.max(3e3, Math.min(15e3, Math.floor(intervalMs * 0.8)));
+    const timeoutMs = clampInt(
+      this.account.config.keepaliveTimeoutMs,
+      defaultTimeoutMs,
+      1e3,
+      6e4
+    );
+    return {
+      intervalMs,
+      timeoutMs
+    };
+  }
+  startKeepalive(ws, connSerial, heartbeatSec) {
+    this.stopKeepalive();
+    const policy = this.resolveKeepalivePolicy(heartbeatSec);
+    this.logInfo(
+      `keepalive start conn=${connSerial} intervalMs=${policy.intervalMs} timeoutMs=${policy.timeoutMs} serverHeartbeatSec=${heartbeatSec}`
+    );
+    this.keepaliveTimer = setInterval(() => {
+      void this.runKeepaliveProbe(ws, connSerial, policy.timeoutMs);
+    }, policy.intervalMs);
+  }
+  stopKeepalive() {
+    if (this.keepaliveTimer) {
+      clearInterval(this.keepaliveTimer);
+      this.keepaliveTimer = null;
+    }
+    this.keepaliveInFlight = false;
+  }
+  async runKeepaliveProbe(ws, connSerial, timeoutMs) {
+    if (!this.running || this.ws !== ws || ws.readyState !== WebSocket.OPEN || !this.status.authed) {
+      return;
+    }
+    if (this.keepaliveInFlight) {
+      this.logWarn(`keepalive overlap detected conn=${connSerial}, force reconnect`);
+      this.safeCloseSpecificWs(ws, "keepalive_overlap");
+      return;
+    }
+    this.keepaliveInFlight = true;
+    const startedAt = Date.now();
+    try {
+      await this.request(
+        "ping",
+        {
+          ts: startedAt,
+          source: "clawpool_keepalive"
+        },
+        {
+          expected: ["pong"],
+          timeoutMs
+        }
+      );
+      const latencyMs = Math.max(0, Date.now() - startedAt);
+      if (latencyMs >= 2e3) {
+        this.logWarn(`keepalive high latency conn=${connSerial} latencyMs=${latencyMs}`);
+      }
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      this.logWarn(`keepalive failed conn=${connSerial} err=${msg}, force reconnect`);
+      if (this.ws === ws) {
+        this.safeCloseSpecificWs(ws, "keepalive_probe_failed");
+      }
+    } finally {
+      this.keepaliveInFlight = false;
+    }
+  }
+  resolveReconnectDelayMs(attempt) {
+    if (attempt <= 0) {
+      return 0;
+    }
+    const fastRetryDelays = this.reconnectPolicy.fastRetryDelaysMs;
+    if (attempt <= fastRetryDelays.length) {
+      return fastRetryDelays[attempt - 1] ?? this.reconnectPolicy.baseDelayMs;
+    }
+    const exponent = attempt - fastRetryDelays.length - 1;
+    const uncapped = this.reconnectPolicy.baseDelayMs * 2 ** exponent;
+    const capped = Math.min(this.reconnectPolicy.maxDelayMs, Math.floor(uncapped));
+    const jitterFloor = Math.max(100, Math.floor(capped * 0.5));
+    return randomIntInclusive(jitterFloor, capped);
+  }
+  consumeReconnectPenaltyAttemptFloor() {
+    const floor = this.reconnectPenaltyAttemptFloor;
+    this.reconnectPenaltyAttemptFloor = 0;
+    return floor;
+  }
+  safeCloseSpecificWs(ws, reason = "") {
+    try {
+      ws.close();
+    } catch {
+    }
+    if (this.ws === ws) {
+      this.ws = null;
+    }
+  }
+  safeCloseWs(reason = "") {
+    if (!this.ws) {
+      return;
+    }
+    this.safeCloseSpecificWs(this.ws, reason);
+  }
+  updateStatus(patch) {
+    this.status = {
+      ...this.status,
+      ...patch
+    };
+    this.callbacks.onStatus?.(this.getStatus());
+  }
+};
+var activeClients = /* @__PURE__ */ new Map();
+function setActiveAibotClient(accountId, client) {
+  if (!accountId) {
+    return;
+  }
+  if (!client) {
+    activeClients.delete(accountId);
+    return;
+  }
+  activeClients.set(accountId, client);
+}
+function clearActiveAibotClient(accountId, client) {
+  if (!accountId) {
+    return;
+  }
+  if (activeClients.get(accountId) !== client) {
+    return;
+  }
+  activeClients.delete(accountId);
+}
+function getActiveAibotClient(accountId) {
+  if (!accountId) {
+    return null;
+  }
+  return activeClients.get(accountId) ?? null;
+}
+function requireActiveAibotClient(accountId) {
+  const client = getActiveAibotClient(accountId);
+  if (!client) {
+    throw new Error(
+      `clawpool account "${accountId}" is not connected; start the gateway channel runtime first`
+    );
+  }
+  return client;
+}
+
+// src/silent-unsend-completion.ts
+var COMPLETION_TTL_MS = 5 * 60 * 1e3;
+var completedAtByMessageId = /* @__PURE__ */ new Map();
+function normalizeMessageId(value) {
+  const normalized = String(value ?? "").trim();
+  if (!/^\d+$/.test(normalized)) {
+    return "";
+  }
+  return normalized;
+}
+function pruneExpired(now) {
+  for (const [messageId, completedAt] of completedAtByMessageId) {
+    if (now - completedAt > COMPLETION_TTL_MS) {
+      completedAtByMessageId.delete(messageId);
+    }
+  }
+}
+function markSilentUnsendCompleted(messageId) {
+  const normalizedMessageId = normalizeMessageId(messageId);
+  if (!normalizedMessageId) {
+    return;
+  }
+  const now = Date.now();
+  pruneExpired(now);
+  completedAtByMessageId.set(normalizedMessageId, now);
+}
+function consumeSilentUnsendCompleted(messageId) {
+  const normalizedMessageId = normalizeMessageId(messageId);
+  if (!normalizedMessageId) {
+    return false;
+  }
+  pruneExpired(Date.now());
+  const hadCompletion = completedAtByMessageId.has(normalizedMessageId);
+  if (hadCompletion) {
+    completedAtByMessageId.delete(normalizedMessageId);
+  }
+  return hadCompletion;
+}
+
+// src/target-resolver.ts
+var aibotSessionIDPattern = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+function isAibotSessionID(value) {
+  const normalized = String(value ?? "").trim();
+  if (!normalized) {
+    return false;
+  }
+  return aibotSessionIDPattern.test(normalized);
+}
+function normalizeAibotSessionTarget2(raw) {
+  const trimmed = String(raw ?? "").trim();
+  if (!trimmed) {
+    return "";
+  }
+  return trimmed.replace(/^clawpool:/i, "").replace(/^session:/i, "").trim();
+}
+function buildRouteSessionKeyCandidates(rawTarget, normalizedTarget) {
+  if (rawTarget === normalizedTarget) {
+    return [rawTarget];
+  }
+  return [rawTarget, normalizedTarget].filter((candidate) => candidate.length > 0);
+}
+async function resolveAibotOutboundTarget(params) {
+  const rawTarget = String(params.to ?? "").trim();
+  if (!rawTarget) {
+    throw new Error("clawpool outbound target must be non-empty");
+  }
+  const normalizedTarget = normalizeAibotSessionTarget2(rawTarget);
+  if (!normalizedTarget) {
+    throw new Error("clawpool outbound target must contain session_id or route_session_key");
+  }
+  if (isAibotSessionID(normalizedTarget)) {
+    return {
+      sessionId: normalizedTarget,
+      rawTarget,
+      normalizedTarget,
+      resolveSource: "direct"
+    };
+  }
+  if (/^\d+$/.test(normalizedTarget)) {
+    throw new Error(
+      `clawpool outbound target "${rawTarget}" is numeric; expected session_id(UUID) or route.sessionKey`
+    );
+  }
+  const routeSessionKeyCandidates = buildRouteSessionKeyCandidates(rawTarget, normalizedTarget);
+  let lastResolveError = null;
+  for (const routeSessionKey of routeSessionKeyCandidates) {
+    try {
+      const ack = await params.client.resolveSessionRoute("clawpool", params.accountId, routeSessionKey);
+      const sessionId = String(ack.session_id ?? "").trim();
+      if (!isAibotSessionID(sessionId)) {
+        throw new Error(
+          `session_route_resolve returned invalid session_id for route_session_key="${routeSessionKey}"`
+        );
+      }
+      return {
+        sessionId,
+        rawTarget,
+        normalizedTarget,
+        resolveSource: "sessionRouteMap"
+      };
+    } catch (err) {
+      lastResolveError = err instanceof Error ? err : new Error(String(err));
+    }
+  }
+  if (lastResolveError) {
+    throw new Error(
+      `clawpool outbound target resolve failed target="${rawTarget}" accountId=${params.accountId}: ${lastResolveError.message}`
+    );
+  }
+  throw new Error(`clawpool outbound target resolve failed target="${rawTarget}" accountId=${params.accountId}`);
+}
+
+// src/delete-target-resolver.ts
+async function resolveAibotDeleteTarget(params) {
+  const rawTarget = String(params.sessionId ?? "").trim() || String(params.to ?? "").trim() || String(params.topic ?? "").trim() || String(params.currentChannelId ?? "").trim();
+  if (!rawTarget) {
+    return "";
+  }
+  const resolved = await resolveAibotOutboundTarget({
+    client: params.client,
+    accountId: params.accountId,
+    to: rawTarget
+  });
+  return resolved.sessionId;
+}
+
+// src/silent-unsend-plan.ts
+function normalizeMessageId2(value) {
+  const normalized = String(value ?? "").trim();
+  if (!/^\d+$/.test(normalized)) {
+    return "";
+  }
+  return normalized;
+}
+async function resolveSilentUnsendPlan(params) {
+  const targetMessageId = normalizeMessageId2(params.messageId);
+  if (!targetMessageId) {
+    throw new Error("Clawpool unsend requires numeric messageId.");
+  }
+  const targetSessionId = await resolveAibotDeleteTarget({
+    client: params.client,
+    accountId: params.accountId,
+    sessionId: params.targetSessionId,
+    to: params.targetTo,
+    topic: params.targetTopic,
+    currentChannelId: params.currentChannelId
+  });
+  if (!targetSessionId) {
+    throw new Error(
+      "Clawpool unsend requires sessionId or to, or must be used inside an active Clawpool conversation."
+    );
+  }
+  const targetDelete = {
+    sessionId: targetSessionId,
+    messageId: targetMessageId
+  };
+  const currentMessageId = normalizeMessageId2(params.currentMessageId);
+  if (!currentMessageId) {
+    return { targetDelete };
+  }
+  if (currentMessageId === targetMessageId) {
+    return {
+      targetDelete,
+      completionMessageId: currentMessageId
+    };
+  }
+  const currentChannelId = String(params.currentChannelId ?? "").trim();
+  if (!currentChannelId) {
+    return { targetDelete };
+  }
+  const currentSessionId = await resolveAibotDeleteTarget({
+    client: params.client,
+    accountId: params.accountId,
+    currentChannelId
+  });
+  if (!currentSessionId) {
+    throw new Error("Clawpool unsend could not resolve the current command message session.");
+  }
+  return {
+    targetDelete,
+    commandDelete: {
+      sessionId: currentSessionId,
+      messageId: currentMessageId
+    },
+    completionMessageId: currentMessageId
+  };
+}
+
+// src/actions.ts
+var WS_ACTIONS = /* @__PURE__ */ new Set(["unsend", "delete"]);
+var DISCOVERABLE_ACTIONS = ["unsend", "delete"];
+function toSnakeCaseKey(key) {
+  return key.replace(/([A-Z]+)([A-Z][a-z])/g, "$1_$2").replace(/([a-z0-9])([A-Z])/g, "$1_$2").toLowerCase();
+}
+function readStringishParam(params, key) {
+  const value = readStringParam(params, key);
+  if (value) {
+    return value;
+  }
+  const snakeKey = toSnakeCaseKey(key);
+  const raw = (Object.hasOwn(params, key) ? params[key] : void 0) ?? (snakeKey !== key && Object.hasOwn(params, snakeKey) ? params[snakeKey] : void 0);
+  if (typeof raw === "number" && Number.isFinite(raw)) {
+    return String(raw);
+  }
+  return void 0;
+}
+var aibotMessageActions = {
+  listActions: ({ cfg }) => {
+    const hasConfiguredAccount = listAibotAccountIds(cfg).map((accountId) => resolveAibotAccount({ cfg, accountId })).some((account) => account.enabled && account.configured);
+    if (!hasConfiguredAccount) {
+      return [];
+    }
+    return DISCOVERABLE_ACTIONS;
+  },
+  supportsAction: ({ action }) => {
+    const normalizedAction = String(action ?? "").trim();
+    return WS_ACTIONS.has(normalizedAction);
+  },
+  handleAction: async ({ action, params, cfg, accountId, toolContext }) => {
+    const normalizedAction = String(action ?? "").trim();
+    if (!WS_ACTIONS.has(normalizedAction)) {
+      throw new Error(`Clawpool action ${normalizedAction} is not supported`);
+    }
+    const account = resolveAibotAccount({ cfg, accountId });
+    if (!account.enabled) {
+      throw new Error(`Clawpool account "${account.accountId}" is disabled.`);
+    }
+    if (!account.configured) {
+      throw new Error(`Clawpool account "${account.accountId}" is not configured.`);
+    }
+    const client = requireActiveAibotClient(account.accountId);
+    const messageId = readStringishParam(params, "messageId") ?? readStringishParam(params, "msgId");
+    if (!messageId) {
+      throw new Error("Clawpool unsend requires messageId.");
+    }
+    const plan = await resolveSilentUnsendPlan({
+      client,
+      accountId: account.accountId,
+      messageId,
+      targetSessionId: readStringishParam(params, "sessionId"),
+      targetTo: readStringishParam(params, "to"),
+      targetTopic: readStringishParam(params, "topic"),
+      currentChannelId: toolContext?.currentChannelId,
+      currentMessageId: toolContext?.currentMessageId
+    });
+    const ack = await client.deleteMessage(plan.targetDelete.sessionId, plan.targetDelete.messageId);
+    if (plan.commandDelete) {
+      await client.deleteMessage(plan.commandDelete.sessionId, plan.commandDelete.messageId);
+    }
+    if (plan.completionMessageId) {
+      markSilentUnsendCompleted(plan.completionMessageId);
+    }
+    return jsonResult({
+      ok: true,
+      deleted: true,
+      unsent: normalizedAction === "unsend",
+      messageId: String(ack.msg_id ?? messageId),
+      sessionId: String(ack.session_id ?? plan.targetDelete.sessionId)
+    });
+  }
+};
+
+// src/exec-approval-adapter-payload.ts
+var DEFAULT_ALLOWED_DECISIONS = ["allow-once", "allow-always", "deny"];
+function normalizeText(value) {
+  return String(value ?? "").replace(/\r\n/g, "\n").trim();
+}
+function stripUndefinedFields(record) {
+  const next = {};
+  for (const [key, value] of Object.entries(record)) {
+    if (value !== void 0) {
+      next[key] = value;
+    }
+  }
+  return next;
+}
+function buildFence(text, language) {
+  let fence = "```";
+  while (text.includes(fence)) {
+    fence += "`";
+  }
+  return `${fence}${language ?? ""}
+${text}
+${fence}`;
+}
+function resolveHost(value) {
+  return normalizeText(value) === "node" ? "node" : "gateway";
+}
+function resolveApprovalSlug(approvalId) {
+  return approvalId.length <= 8 ? approvalId : approvalId.slice(0, 8);
+}
+function resolveCommandText(params) {
+  return normalizeText(params.commandPreview) || normalizeText(params.command);
+}
+function buildPendingApprovalText(params) {
+  const lines = [];
+  const warningText = params.warningText?.trim();
+  if (warningText) {
+    lines.push(warningText);
+  }
+  lines.push("Approval required.");
+  lines.push("Run:");
+  lines.push(buildFence(`/approve ${params.approvalCommandId} allow-once`, "txt"));
+  lines.push("Pending command:");
+  lines.push(buildFence(params.command, "sh"));
+  lines.push("Other options:");
+  lines.push(
+    buildFence(
+      `/approve ${params.approvalCommandId} allow-always
+/approve ${params.approvalCommandId} deny`,
+      "txt"
+    )
+  );
+  const info = [];
+  info.push(`Host: ${params.host}`);
+  if (params.nodeId) {
+    info.push(`Node: ${params.nodeId}`);
+  }
+  if (params.cwd) {
+    info.push(`CWD: ${params.cwd}`);
+  }
+  if (params.expiresInSeconds !== void 0) {
+    info.push(`Expires in: ${params.expiresInSeconds}s`);
+  }
+  info.push(`Full id: \`${params.approvalId}\``);
+  lines.push(info.join("\n"));
+  return lines.join("\n\n");
+}
+function decisionLabel(decision) {
+  if (decision === "allow-once") {
+    return "allowed once";
+  }
+  if (decision === "allow-always") {
+    return "allowed always";
+  }
+  return "denied";
+}
+function mapResolvedStatus(decision) {
+  if (decision === "allow-once") {
+    return "resolved-allow-once";
+  }
+  if (decision === "allow-always") {
+    return "resolved-allow-always";
+  }
+  return "resolved-deny";
+}
+function buildResolvedApprovalText(params) {
+  const by = params.resolvedBy ? ` Resolved by ${params.resolvedBy}.` : "";
+  return `\u2705 Exec approval ${decisionLabel(params.decision)}.${by} ID: ${params.approvalId}`;
+}
+function buildClawpoolPendingExecApprovalPayload(params) {
+  const approvalId = normalizeText(params.request.id);
+  const command = resolveCommandText(params.request.request);
+  if (!approvalId || !command) {
+    return null;
+  }
+  const approvalSlug = resolveApprovalSlug(approvalId);
+  const approvalCommandId = approvalId;
+  const host = resolveHost(params.request.request.host);
+  const nodeId = normalizeText(params.request.request.nodeId) || void 0;
+  const cwd = normalizeText(params.request.request.cwd) || void 0;
+  const expiresInSeconds = Math.max(
+    0,
+    Math.round((params.request.expiresAtMs - params.nowMs) / 1e3)
+  );
+  return {
+    text: buildPendingApprovalText({
+      approvalId,
+      approvalCommandId,
+      command,
+      host,
+      nodeId,
+      cwd,
+      expiresInSeconds
+    }),
+    channelData: {
+      execApproval: {
+        approvalId,
+        approvalSlug,
+        allowedDecisions: [...DEFAULT_ALLOWED_DECISIONS]
+      },
+      clawpool: {
+        execApproval: stripUndefinedFields({
+          approval_command_id: approvalCommandId,
+          command,
+          host,
+          node_id: nodeId,
+          cwd,
+          expires_in_seconds: expiresInSeconds
+        })
+      }
+    }
+  };
+}
+function buildClawpoolResolvedExecApprovalPayload(params) {
+  const approvalId = normalizeText(params.resolved.id);
+  if (!approvalId) {
+    return null;
+  }
+  const decision = params.resolved.decision;
+  const resolvedBy = normalizeText(params.resolved.resolvedBy) || void 0;
+  const host = params.resolved.request?.host ? resolveHost(params.resolved.request.host) : void 0;
+  const nodeId = normalizeText(params.resolved.request?.nodeId) || void 0;
+  const approvalCommandId = approvalId;
+  const summary = `Exec approval ${decisionLabel(decision)}.`;
+  const detailText = resolvedBy ? `Resolved by ${resolvedBy}.` : void 0;
+  const structuredStatus = stripUndefinedFields({
+    status: mapResolvedStatus(decision),
+    summary,
+    detail_text: detailText,
+    approval_id: approvalId,
+    approval_command_id: approvalCommandId,
+    host,
+    node_id: nodeId,
+    decision,
+    resolved_by_id: resolvedBy
+  });
+  return {
+    text: buildResolvedApprovalText({
+      approvalId,
+      decision,
+      resolvedBy
+    }),
+    channelData: {
+      clawpool: {
+        execStatus: structuredStatus
+      }
+    }
+  };
+}
+
+// src/channel-exec-approvals.ts
+function hasConfiguredApprovers(values) {
+  return values?.some((value) => {
+    const normalized = String(value ?? "").trim();
+    return normalized.length > 0;
+  }) ?? false;
+}
+function isClawpoolExecApprovalClientEnabled(params) {
+  const account = resolveAibotAccount(params);
+  return Boolean(
+    account.config.execApprovals?.enabled && hasConfiguredApprovers(account.config.execApprovals.approvers)
+  );
+}
+var clawpoolExecApprovalAdapter = {
+  getInitiatingSurfaceState: ({ cfg, accountId }) => isClawpoolExecApprovalClientEnabled({ cfg, accountId }) ? { kind: "enabled" } : { kind: "disabled" },
+  shouldSuppressLocalPrompt: ({ cfg, accountId, payload }) => {
+    if (!isClawpoolExecApprovalClientEnabled({ cfg, accountId })) {
+      return false;
+    }
+    const channelData = payload.channelData;
+    if (!channelData || typeof channelData !== "object" || Array.isArray(channelData)) {
+      return false;
+    }
+    const execApproval = channelData.execApproval;
+    return Boolean(execApproval) && typeof execApproval === "object" && !Array.isArray(execApproval);
+  },
+  hasConfiguredDmRoute: () => false,
+  shouldSuppressForwardingFallback: () => false,
+  buildPendingPayload: (params) => buildClawpoolPendingExecApprovalPayload(params),
+  buildResolvedPayload: (params) => buildClawpoolResolvedExecApprovalPayload(params),
+  beforeDeliverPending: () => void 0
+};
+
+// src/monitor.ts
+import {
+  createReplyPrefixOptions
+} from "openclaw/plugin-sdk/channel-runtime";
+
+// src/active-reply-runs.ts
+var runsByEvent = /* @__PURE__ */ new Map();
+var eventKeyBySession = /* @__PURE__ */ new Map();
+function buildEventKey(accountId, eventId) {
+  return `${String(accountId ?? "").trim()}:${String(eventId ?? "").trim()}`;
+}
+function buildSessionKey(accountId, sessionId) {
+  return `${String(accountId ?? "").trim()}:${String(sessionId ?? "").trim()}`;
+}
+function registerActiveReplyRun(params) {
+  const accountId = String(params.accountId ?? "").trim();
+  const eventId = String(params.eventId ?? "").trim();
+  const sessionId = String(params.sessionId ?? "").trim();
+  if (!accountId || !eventId || !sessionId) {
+    return null;
+  }
+  const eventKey = buildEventKey(accountId, eventId);
+  const sessionKey = buildSessionKey(accountId, sessionId);
+  const existingEventKey = eventKeyBySession.get(sessionKey);
+  if (existingEventKey && existingEventKey !== eventKey) {
+    const existing = runsByEvent.get(existingEventKey);
+    if (existing) {
+      existing.abortReason = existing.abortReason || "superseded_by_new_event";
+      existing.controller.abort(existing.abortReason);
+      runsByEvent.delete(existingEventKey);
+    }
+  }
+  const run = {
+    accountId,
+    eventId,
+    sessionId,
+    controller: params.controller,
+    stopRequested: false
+  };
+  runsByEvent.set(eventKey, run);
+  eventKeyBySession.set(sessionKey, eventKey);
+  return run;
+}
+function resolveActiveReplyRun(params) {
+  const accountId = String(params.accountId ?? "").trim();
+  if (!accountId) {
+    return null;
+  }
+  const eventId = String(params.eventId ?? "").trim();
+  if (eventId) {
+    return runsByEvent.get(buildEventKey(accountId, eventId)) ?? null;
+  }
+  const sessionId = String(params.sessionId ?? "").trim();
+  if (!sessionId) {
+    return null;
+  }
+  const eventKey = eventKeyBySession.get(buildSessionKey(accountId, sessionId));
+  if (!eventKey) {
+    return null;
+  }
+  return runsByEvent.get(eventKey) ?? null;
+}
+function clearActiveReplyRun(run) {
+  if (!run) {
+    return;
+  }
+  const eventKey = buildEventKey(run.accountId, run.eventId);
+  const sessionKey = buildSessionKey(run.accountId, run.sessionId);
+  const current = runsByEvent.get(eventKey);
+  if (current === run) {
+    runsByEvent.delete(eventKey);
+  }
+  if (eventKeyBySession.get(sessionKey) === eventKey) {
+    eventKeyBySession.delete(sessionKey);
+  }
+}
+
+// src/reply-text-guard.ts
+var NETWORK_ERROR_MESSAGE = "\u4E0A\u6E38\u670D\u52A1\u7F51\u7EDC\u5F02\u5E38\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5\u3002";
+var TIMEOUT_MESSAGE = "\u4E0A\u6E38\u670D\u52A1\u54CD\u5E94\u8D85\u65F6\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5\u3002";
+var CONTEXT_OVERFLOW_MESSAGE = "\u5F53\u524D\u4F1A\u8BDD\u4E0A\u4E0B\u6587\u8FC7\u957F\uFF0C\u8BF7\u65B0\u5F00\u4F1A\u8BDD\u540E\u91CD\u8BD5\u3002";
+var GENERIC_STOP_MESSAGE = "\u4E0A\u6E38\u670D\u52A1\u5F02\u5E38\u4E2D\u65AD\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5\u3002";
+function guardInternalReplyText(rawText) {
+  const normalized = String(rawText ?? "").trim();
+  if (!normalized) {
+    return null;
+  }
+  if (/^Unhandled stop reason:\s*network_error$/i.test(normalized)) {
+    return {
+      code: "upstream_network_error",
+      rawText: normalized,
+      userText: NETWORK_ERROR_MESSAGE
+    };
+  }
+  if (/^LLM request timed out\.?$/i.test(normalized)) {
+    return {
+      code: "upstream_timeout",
+      rawText: normalized,
+      userText: TIMEOUT_MESSAGE
+    };
+  }
+  if (normalized.startsWith("Context overflow: prompt too large for the model.")) {
+    return {
+      code: "upstream_context_overflow",
+      rawText: normalized,
+      userText: CONTEXT_OVERFLOW_MESSAGE
+    };
+  }
+  if (/^Unhandled stop reason:\s*[a-z0-9_]+$/i.test(normalized)) {
+    return {
+      code: "upstream_stop_reason",
+      rawText: normalized,
+      userText: GENERIC_STOP_MESSAGE
+    };
+  }
+  return null;
+}
+
+// src/upstream-retry.ts
+var DEFAULT_UPSTREAM_RETRY_MAX_ATTEMPTS = 3;
+var DEFAULT_UPSTREAM_RETRY_BASE_DELAY_MS = 300;
+var DEFAULT_UPSTREAM_RETRY_MAX_DELAY_MS = 2e3;
+function clampInt2(value, fallback, min, max) {
+  const n = Number(value);
+  if (!Number.isFinite(n)) {
+    return fallback;
+  }
+  return Math.max(min, Math.min(max, Math.floor(n)));
+}
+function resolveUpstreamRetryPolicy(account) {
+  const maxAttempts = clampInt2(
+    account.config.upstreamRetryMaxAttempts,
+    DEFAULT_UPSTREAM_RETRY_MAX_ATTEMPTS,
+    1,
+    5
+  );
+  const baseDelayMs = clampInt2(
+    account.config.upstreamRetryBaseDelayMs,
+    DEFAULT_UPSTREAM_RETRY_BASE_DELAY_MS,
+    0,
+    1e4
+  );
+  const maxDelayMs = clampInt2(
+    account.config.upstreamRetryMaxDelayMs,
+    DEFAULT_UPSTREAM_RETRY_MAX_DELAY_MS,
+    baseDelayMs,
+    3e4
+  );
+  return {
+    maxAttempts,
+    baseDelayMs,
+    maxDelayMs
+  };
+}
+function isRetryableGuardedReply(guarded) {
+  if (!guarded) {
+    return false;
+  }
+  return guarded.code === "upstream_network_error" || guarded.code === "upstream_timeout";
+}
+function resolveUpstreamRetryDelayMs(policy, attempt) {
+  if (attempt <= 0) {
+    return 0;
+  }
+  const exponent = Math.max(0, attempt - 1);
+  const delay = policy.baseDelayMs * 2 ** exponent;
+  return Math.min(policy.maxDelayMs, Math.floor(delay));
+}
+
+// src/runtime.ts
+var runtime = null;
+function setAibotRuntime(next) {
+  runtime = next;
+}
+function getAibotRuntime() {
+  if (!runtime) {
+    throw new Error("Aibot runtime not initialized");
+  }
+  return runtime;
+}
+
+// src/quoted-reply-body.ts
+function buildBodyWithQuotedReplyId(rawBody, quotedMessageId) {
+  if (!quotedMessageId) {
+    return rawBody;
+  }
+  return `[quoted_message_id=${quotedMessageId}]
+${rawBody}`;
+}
+
+// src/inbound-event-dedupe.ts
+var DEFAULT_INBOUND_EVENT_TTL_MS = 10 * 60 * 1e3;
+var recentInboundEvents = /* @__PURE__ */ new Map();
+function normalizeKeyPart(value) {
+  return String(value ?? "").trim();
+}
+function resolveInboundEventKey(params) {
+  const accountId = normalizeKeyPart(params.accountId);
+  const eventId = normalizeKeyPart(params.eventId);
+  if (eventId) {
+    return `account:${accountId}:event:${eventId}`;
+  }
+  const sessionId = normalizeKeyPart(params.sessionId);
+  const messageSid = normalizeKeyPart(params.messageSid);
+  return `account:${accountId}:message:${sessionId}:${messageSid}`;
+}
+function resolveTTL(ttlMs) {
+  const normalized = Number(ttlMs);
+  if (!Number.isFinite(normalized) || normalized <= 0) {
+    return DEFAULT_INBOUND_EVENT_TTL_MS;
+  }
+  return Math.floor(normalized);
+}
+function pruneExpiredInboundEvents(nowMs) {
+  for (const [key, record] of recentInboundEvents.entries()) {
+    if (record.expiresAt <= nowMs) {
+      recentInboundEvents.delete(key);
+    }
+  }
+}
+function claimInboundEvent(params) {
+  const nowMs = Number.isFinite(Number(params.nowMs)) ? Math.floor(Number(params.nowMs)) : Date.now();
+  const ttlMs = resolveTTL(params.ttlMs);
+  pruneExpiredInboundEvents(nowMs);
+  const key = resolveInboundEventKey(params);
+  const existing = recentInboundEvents.get(key);
+  if (existing && existing.expiresAt > nowMs) {
+    return {
+      duplicate: true,
+      confirmed: existing.confirmed,
+      claim: {
+        key,
+        confirmed: existing.confirmed
+      }
+    };
+  }
+  recentInboundEvents.set(key, {
+    expiresAt: nowMs + ttlMs,
+    confirmed: false
+  });
+  return {
+    duplicate: false,
+    confirmed: false,
+    claim: {
+      key,
+      confirmed: false
+    }
+  };
+}
+function confirmInboundEvent(claim, params) {
+  const key = normalizeKeyPart(claim.key);
+  if (!key) {
+    return;
+  }
+  const nowMs = Number.isFinite(Number(params?.nowMs)) ? Math.floor(Number(params?.nowMs)) : Date.now();
+  const ttlMs = resolveTTL(params?.ttlMs);
+  pruneExpiredInboundEvents(nowMs);
+  recentInboundEvents.set(key, {
+    expiresAt: nowMs + ttlMs,
+    confirmed: true
+  });
+  claim.confirmed = true;
+}
+function releaseInboundEvent(claim) {
+  const key = normalizeKeyPart(claim.key);
+  if (!key || claim.confirmed) {
+    return;
+  }
+  const current = recentInboundEvents.get(key);
+  if (current && !current.confirmed) {
+    recentInboundEvents.delete(key);
+  }
+}
+
+// src/exec-approval-card.ts
+var BIZ_CARD_EXTRA_KEY = "biz_card";
+var BIZ_CARD_VERSION = 1;
+var EXEC_APPROVAL_CARD_TYPE = "exec_approval";
+function normalizeDecision(value) {
+  const normalized = String(value ?? "").trim();
+  if (normalized === "allow-once" || normalized === "allow-always" || normalized === "deny") {
+    return normalized;
+  }
+  return void 0;
+}
+function normalizeText2(value) {
+  return String(value ?? "").replace(/\r\n/g, "\n").trim();
+}
+function summarizeTextPrefix(text) {
+  const normalized = normalizeText2(text);
+  if (!normalized) {
+    return "";
+  }
+  const firstLine = normalized.split("\n", 1)[0]?.trim() ?? "";
+  if (!firstLine) {
+    return "";
+  }
+  return firstLine.length > 120 ? `${firstLine.slice(0, 117)}...` : firstLine;
+}
+function getExecApprovalReplyMetadata(payload) {
+  const channelData = payload.channelData;
+  if (!channelData || typeof channelData !== "object" || Array.isArray(channelData)) {
+    return null;
+  }
+  const execApproval = channelData.execApproval;
+  if (!execApproval || typeof execApproval !== "object" || Array.isArray(execApproval)) {
+    return null;
+  }
+  const record = execApproval;
+  const approvalId = normalizeText2(record.approvalId);
+  const approvalSlug = normalizeText2(record.approvalSlug);
+  if (!approvalId || !approvalSlug) {
+    return null;
+  }
+  const allowedDecisions = Array.isArray(record.allowedDecisions) ? record.allowedDecisions.map(normalizeDecision).filter((value) => Boolean(value)) : [];
+  return {
+    approvalId,
+    approvalSlug,
+    allowedDecisions: allowedDecisions.length > 0 ? allowedDecisions : ["allow-once", "allow-always", "deny"]
+  };
+}
+function getStructuredClawpoolExecApproval(payload) {
+  const channelData = payload.channelData;
+  if (!channelData || typeof channelData !== "object" || Array.isArray(channelData)) {
+    return null;
+  }
+  const clawpool = channelData.clawpool;
+  if (!clawpool || typeof clawpool !== "object" || Array.isArray(clawpool)) {
+    return null;
+  }
+  const execApproval = clawpool.execApproval;
+  if (!execApproval || typeof execApproval !== "object" || Array.isArray(execApproval)) {
+    return null;
+  }
+  const record = execApproval;
+  const approvalCommandId = normalizeText2(record.approval_command_id);
+  const command = normalizeText2(record.command);
+  const host = normalizeText2(record.host);
+  if (!approvalCommandId || !command || !host) {
+    return null;
+  }
+  const expiresValue = Number(record.expires_in_seconds);
+  return {
+    approvalCommandId,
+    command,
+    host,
+    nodeId: normalizeText2(record.node_id) || void 0,
+    cwd: normalizeText2(record.cwd) || void 0,
+    expiresInSeconds: Number.isFinite(expiresValue) && expiresValue >= 0 ? Math.floor(expiresValue) : void 0,
+    warningText: normalizeText2(record.warning_text) || void 0
+  };
+}
+function diagnoseExecApprovalPayload(payload) {
+  const rawText = String(payload.text ?? "");
+  const textPrefix = summarizeTextPrefix(rawText);
+  const channelData = payload.channelData;
+  const hasChannelData = Boolean(channelData) && typeof channelData === "object" && !Array.isArray(channelData);
+  const execApproval = hasChannelData ? channelData.execApproval : void 0;
+  const hasExecApprovalField = Boolean(execApproval) && typeof execApproval === "object" && !Array.isArray(execApproval);
+  const execApprovalRecord = hasExecApprovalField ? execApproval : void 0;
+  const approvalId = normalizeText2(execApprovalRecord?.approvalId);
+  const approvalSlug = normalizeText2(execApprovalRecord?.approvalSlug);
+  const allowedDecisionCount = Array.isArray(execApprovalRecord?.allowedDecisions) ? execApprovalRecord.allowedDecisions.length : 0;
+  const structured = getStructuredClawpoolExecApproval(payload);
+  const hasClawpoolApprovalField = Boolean(structured);
+  const isCandidate = hasExecApprovalField || hasClawpoolApprovalField;
+  if (!isCandidate) {
+    return {
+      isCandidate: false,
+      matched: false,
+      reason: "non-approval-payload",
+      hasChannelData,
+      hasExecApprovalField,
+      hasClawpoolApprovalField,
+      allowedDecisionCount,
+      commandDetected: false,
+      textPrefix
+    };
+  }
+  if (!hasChannelData) {
+    return {
+      isCandidate: true,
+      matched: false,
+      reason: "missing-channel-data",
+      hasChannelData,
+      hasExecApprovalField,
+      hasClawpoolApprovalField,
+      allowedDecisionCount,
+      commandDetected: false,
+      textPrefix
+    };
+  }
+  if (!hasExecApprovalField) {
+    return {
+      isCandidate: true,
+      matched: false,
+      reason: "missing-exec-approval-channel-data",
+      hasChannelData,
+      hasExecApprovalField,
+      hasClawpoolApprovalField,
+      allowedDecisionCount,
+      commandDetected: Boolean(structured?.command),
+      approvalCommandId: structured?.approvalCommandId,
+      host: structured?.host,
+      nodeId: structured?.nodeId,
+      cwd: structured?.cwd,
+      expiresInSeconds: structured?.expiresInSeconds,
+      textPrefix
+    };
+  }
+  if (!structured) {
+    return {
+      isCandidate: true,
+      matched: false,
+      reason: "missing-clawpool-channel-data",
+      hasChannelData,
+      hasExecApprovalField,
+      hasClawpoolApprovalField,
+      approvalId: approvalId || void 0,
+      approvalSlug: approvalSlug || void 0,
+      allowedDecisionCount,
+      commandDetected: false,
+      textPrefix
+    };
+  }
+  if (!approvalId || !approvalSlug) {
+    return {
+      isCandidate: true,
+      matched: false,
+      reason: "missing-approval-identifiers",
+      hasChannelData,
+      hasExecApprovalField,
+      hasClawpoolApprovalField,
+      approvalId: approvalId || void 0,
+      approvalSlug: approvalSlug || void 0,
+      allowedDecisionCount,
+      approvalCommandId: structured.approvalCommandId,
+      commandDetected: Boolean(structured.command),
+      host: structured.host || void 0,
+      nodeId: structured.nodeId,
+      cwd: structured.cwd,
+      expiresInSeconds: structured.expiresInSeconds,
+      textPrefix
+    };
+  }
+  if (!structured.approvalCommandId) {
+    return {
+      isCandidate: true,
+      matched: false,
+      reason: "missing-approval-command-id",
+      hasChannelData,
+      hasExecApprovalField,
+      hasClawpoolApprovalField,
+      approvalId,
+      approvalSlug,
+      allowedDecisionCount,
+      commandDetected: Boolean(structured.command),
+      host: structured.host || void 0,
+      nodeId: structured.nodeId,
+      cwd: structured.cwd,
+      expiresInSeconds: structured.expiresInSeconds,
+      textPrefix
+    };
+  }
+  if (!structured.command) {
+    return {
+      isCandidate: true,
+      matched: false,
+      reason: "missing-pending-command",
+      hasChannelData,
+      hasExecApprovalField,
+      hasClawpoolApprovalField,
+      approvalId,
+      approvalSlug,
+      allowedDecisionCount,
+      approvalCommandId: structured.approvalCommandId,
+      commandDetected: false,
+      host: structured.host || void 0,
+      nodeId: structured.nodeId,
+      cwd: structured.cwd,
+      expiresInSeconds: structured.expiresInSeconds,
+      textPrefix
+    };
+  }
+  if (!structured.host) {
+    return {
+      isCandidate: true,
+      matched: false,
+      reason: "missing-host",
+      hasChannelData,
+      hasExecApprovalField,
+      hasClawpoolApprovalField,
+      approvalId,
+      approvalSlug,
+      allowedDecisionCount,
+      approvalCommandId: structured.approvalCommandId,
+      commandDetected: true,
+      nodeId: structured.nodeId,
+      cwd: structured.cwd,
+      expiresInSeconds: structured.expiresInSeconds,
+      textPrefix
+    };
+  }
+  return {
+    isCandidate: true,
+    matched: true,
+    reason: "ok",
+    hasChannelData,
+    hasExecApprovalField,
+    hasClawpoolApprovalField,
+    approvalId,
+    approvalSlug,
+    allowedDecisionCount,
+    approvalCommandId: structured.approvalCommandId,
+    commandDetected: true,
+    host: structured.host,
+    nodeId: structured.nodeId,
+    cwd: structured.cwd,
+    expiresInSeconds: structured.expiresInSeconds,
+    textPrefix
+  };
+}
+function buildExecApprovalFallbackText(params) {
+  const compactCommand = params.command.replace(/\s+/g, " ").trim();
+  const summaryCommand = compactCommand.length > 160 ? `${compactCommand.slice(0, 157)}...` : compactCommand;
+  return `[Exec Approval] ${summaryCommand} (${params.host})
+/approve ${params.approvalCommandId} allow-once`;
+}
+function buildExecApprovalCardEnvelope(payload) {
+  const metadata = getExecApprovalReplyMetadata(payload);
+  const structured = getStructuredClawpoolExecApproval(payload);
+  if (!metadata || !structured) {
+    return void 0;
+  }
+  const cardPayload = {
+    approval_id: metadata.approvalId,
+    approval_slug: metadata.approvalSlug,
+    approval_command_id: structured.approvalCommandId,
+    command: structured.command,
+    host: structured.host,
+    allowed_decisions: metadata.allowedDecisions
+  };
+  if (structured.nodeId) {
+    cardPayload.node_id = structured.nodeId;
+  }
+  if (structured.cwd) {
+    cardPayload.cwd = structured.cwd;
+  }
+  if (structured.warningText) {
+    cardPayload.warning_text = structured.warningText;
+  }
+  if (structured.expiresInSeconds !== void 0) {
+    cardPayload.expires_in_seconds = structured.expiresInSeconds;
+  }
+  return {
+    extra: {
+      [BIZ_CARD_EXTRA_KEY]: {
+        version: BIZ_CARD_VERSION,
+        type: EXEC_APPROVAL_CARD_TYPE,
+        payload: cardPayload
+      },
+      channel_data: payload.channelData ?? {}
+    },
+    fallbackText: buildExecApprovalFallbackText({
+      approvalCommandId: structured.approvalCommandId,
+      command: structured.command,
+      host: structured.host
+    })
+  };
+}
+
+// src/exec-status-card.ts
+var BIZ_CARD_EXTRA_KEY2 = "biz_card";
+var BIZ_CARD_VERSION2 = 1;
+var EXEC_STATUS_CARD_TYPE = "exec_status";
+function normalizeText3(value) {
+  return String(value ?? "").replace(/\r\n/g, "\n").trim();
+}
+function stripUndefinedFields2(record) {
+  const next = {};
+  for (const [key, value] of Object.entries(record)) {
+    if (value !== void 0) {
+      next[key] = value;
+    }
+  }
+  return next;
+}
+function buildExecStatusFallbackText(parsed) {
+  const summary = parsed.summary.replace(/\s+/g, " ").trim();
+  const compactSummary = summary.length > 180 ? `${summary.slice(0, 177)}...` : summary;
+  return `[Exec Status] ${compactSummary}`;
+}
+function buildExecStatusExtra(parsed) {
+  return {
+    [BIZ_CARD_EXTRA_KEY2]: {
+      version: BIZ_CARD_VERSION2,
+      type: EXEC_STATUS_CARD_TYPE,
+      payload: stripUndefinedFields2(parsed)
+    },
+    channel_data: {
+      clawpool: {
+        execStatus: stripUndefinedFields2(parsed)
+      }
+    }
+  };
+}
+function parseStructuredExecStatus(payload) {
+  const channelData = payload.channelData;
+  if (!channelData || typeof channelData !== "object" || Array.isArray(channelData)) {
+    return null;
+  }
+  const clawpool = channelData.clawpool;
+  if (!clawpool || typeof clawpool !== "object" || Array.isArray(clawpool)) {
+    return null;
+  }
+  const execStatus = clawpool.execStatus;
+  if (!execStatus || typeof execStatus !== "object" || Array.isArray(execStatus)) {
+    return null;
+  }
+  const record = execStatus;
+  const status = normalizeText3(record.status);
+  const summary = normalizeText3(record.summary);
+  const allowedStatuses = /* @__PURE__ */ new Set([
+    "approval-expired",
+    "approval-forwarded",
+    "approval-unavailable",
+    "resolved-allow-once",
+    "resolved-allow-always",
+    "resolved-deny",
+    "running",
+    "finished",
+    "denied"
+  ]);
+  if (!allowedStatuses.has(status) || !summary) {
+    return null;
+  }
+  return stripUndefinedFields2({
+    status,
+    summary,
+    detail_text: normalizeText3(record.detail_text) || void 0,
+    approval_id: normalizeText3(record.approval_id) || void 0,
+    approval_command_id: normalizeText3(record.approval_command_id) || void 0,
+    host: normalizeText3(record.host) || void 0,
+    node_id: normalizeText3(record.node_id) || void 0,
+    session_id: normalizeText3(record.session_id) || void 0,
+    reason: normalizeText3(record.reason) || void 0,
+    decision: record.decision === "allow-once" || record.decision === "allow-always" || record.decision === "deny" ? record.decision : void 0,
+    resolved_by_id: normalizeText3(record.resolved_by_id) || void 0,
+    command: normalizeText3(record.command) || void 0,
+    exit_label: normalizeText3(record.exit_label) || void 0,
+    channel_label: normalizeText3(record.channel_label) || void 0,
+    warning_text: normalizeText3(record.warning_text) || void 0
+  });
+}
+function buildExecStatusCardEnvelope(payload) {
+  const parsed = parseStructuredExecStatus(payload);
+  if (!parsed) {
+    return void 0;
+  }
+  return {
+    extra: buildExecStatusExtra(parsed),
+    fallbackText: buildExecStatusFallbackText(parsed)
+  };
+}
+function buildExecApprovalResolutionReply(params) {
+  const decisionLabel2 = params.decision === "allow-once" ? "Allow once" : params.decision === "allow-always" ? "Allow always" : "Deny";
+  const actorId = params.actorId.trim() || "unknown";
+  const summary = `${decisionLabel2} selected by ${actorId}.`;
+  const detailText = params.reason?.trim() ? `Reason: ${params.reason.trim()}` : void 0;
+  const payload = stripUndefinedFields2({
+    status: params.decision === "allow-once" ? "resolved-allow-once" : params.decision === "allow-always" ? "resolved-allow-always" : "resolved-deny",
+    summary,
+    detail_text: detailText,
+    approval_id: params.approvalId.trim(),
+    approval_command_id: params.approvalCommandId.trim(),
+    decision: params.decision,
+    reason: params.reason?.trim() || void 0,
+    resolved_by_id: actorId
+  });
+  return {
+    extra: buildExecStatusExtra(payload),
+    fallbackText: buildExecStatusFallbackText(payload)
+  };
+}
+
+// src/outbound-envelope.ts
+function buildAibotOutboundEnvelope(payload) {
+  const execApprovalDiagnostic = diagnoseExecApprovalPayload(payload);
+  const execApprovalCard = buildExecApprovalCardEnvelope(payload);
+  const execStatusCard = execApprovalCard ? void 0 : buildExecStatusCardEnvelope(payload);
+  const envelope = execApprovalCard ?? execStatusCard;
+  return {
+    text: envelope?.fallbackText ?? String(payload.text ?? ""),
+    extra: envelope?.extra,
+    cardKind: execApprovalCard ? "exec_approval" : execStatusCard ? "exec_status" : void 0,
+    execApprovalDiagnostic
+  };
+}
+
+// src/exec-approval-command.ts
+var COMMAND_REGEX = /^\/approve(?:@[^\s]+)?(?:\s|$)/i;
+var DIRECTIVE_REGEX = /\[\[exec-approval-resolution\|(.+?)\]\]/i;
+var DECISION_ALIASES = {
+  allow: "allow-once",
+  once: "allow-once",
+  "allow-once": "allow-once",
+  allowonce: "allow-once",
+  always: "allow-always",
+  "allow-always": "allow-always",
+  allowalways: "allow-always",
+  deny: "deny",
+  reject: "deny",
+  block: "deny"
+};
+var EXEC_APPROVAL_USAGE = "Usage: /approve <id> allow-once|allow-always|deny";
+function decodeDirectiveValue(rawValue) {
+  const normalized = rawValue.trim();
+  if (!normalized) {
+    return void 0;
+  }
+  if (!normalized.includes("%")) {
+    return normalized;
+  }
+  try {
+    return decodeURIComponent(normalized);
+  } catch {
+    return normalized;
+  }
+}
+function parseExecApprovalResolutionDirective(raw) {
+  const match = DIRECTIVE_REGEX.exec(String(raw ?? ""));
+  if (!match) {
+    return { matched: false };
+  }
+  const body = String(match[1] ?? "").trim();
+  if (!body) {
+    return { matched: true, ok: false, error: EXEC_APPROVAL_USAGE };
+  }
+  const payload = /* @__PURE__ */ new Map();
+  for (const segment of body.split("|")) {
+    const normalizedSegment = segment.trim();
+    if (!normalizedSegment) {
+      return { matched: true, ok: false, error: EXEC_APPROVAL_USAGE };
+    }
+    const separatorIndex = normalizedSegment.indexOf("=");
+    if (separatorIndex <= 0 || separatorIndex >= normalizedSegment.length - 1) {
+      return { matched: true, ok: false, error: EXEC_APPROVAL_USAGE };
+    }
+    const key = normalizedSegment.slice(0, separatorIndex).trim();
+    const rawValue = normalizedSegment.slice(separatorIndex + 1);
+    const value = decodeDirectiveValue(rawValue);
+    if (!key || !value) {
+      return { matched: true, ok: false, error: EXEC_APPROVAL_USAGE };
+    }
+    payload.set(key, value);
+  }
+  const decision = DECISION_ALIASES[String(payload.get("decision") ?? "").toLowerCase()];
+  const approvalId = String(payload.get("approval_id") ?? "").trim() || void 0;
+  const approvalCommandId = String(
+    payload.get("approval_command_id") ?? payload.get("approval_id") ?? payload.get("approval_slug") ?? ""
+  ).trim();
+  if (!decision || !approvalCommandId) {
+    return { matched: true, ok: false, error: EXEC_APPROVAL_USAGE };
+  }
+  const reason = String(payload.get("reason") ?? "").trim() || void 0;
+  return {
+    matched: true,
+    ok: true,
+    id: approvalCommandId,
+    approvalId,
+    approvalCommandId,
+    decision,
+    reason
+  };
+}
+function parseExecApprovalCommand(raw) {
+  const directiveParsed = parseExecApprovalResolutionDirective(raw);
+  if (directiveParsed.matched) {
+    return directiveParsed;
+  }
+  const trimmed = String(raw ?? "").trim();
+  const commandMatch = trimmed.match(COMMAND_REGEX);
+  if (!commandMatch) {
+    return { matched: false };
+  }
+  const rest = trimmed.slice(commandMatch[0].length).trim();
+  if (!rest) {
+    return { matched: true, ok: false, error: EXEC_APPROVAL_USAGE };
+  }
+  const tokens = rest.split(/\s+/).filter(Boolean);
+  if (tokens.length < 2) {
+    return { matched: true, ok: false, error: EXEC_APPROVAL_USAGE };
+  }
+  const first = tokens[0].toLowerCase();
+  const second = tokens[1].toLowerCase();
+  const firstDecision = DECISION_ALIASES[first];
+  if (firstDecision) {
+    const id = tokens.slice(1).join(" ").trim();
+    if (!id) {
+      return { matched: true, ok: false, error: EXEC_APPROVAL_USAGE };
+    }
+    return {
+      matched: true,
+      ok: true,
+      decision: firstDecision,
+      id,
+      approvalCommandId: id
+    };
+  }
+  const secondDecision = DECISION_ALIASES[second];
+  if (!secondDecision) {
+    return { matched: true, ok: false, error: EXEC_APPROVAL_USAGE };
+  }
+  return {
+    matched: true,
+    ok: true,
+    decision: secondDecision,
+    id: tokens[0],
+    approvalCommandId: tokens[0]
+  };
+}
+
+// src/exec-approvals.ts
+function normalizeExecApprovalConfig(config) {
+  const approvers = (config?.approvers ?? []).map((value) => String(value ?? "").trim()).filter(Boolean);
+  return {
+    enabled: Boolean(config?.enabled && approvers.length > 0),
+    approvers
+  };
+}
+function formatCommandFailure(result) {
+  const parts = [String(result.stderr ?? "").trim(), String(result.stdout ?? "").trim()].filter(Boolean).flatMap((text) => text.split(/\r?\n/)).map((line) => line.trim()).filter(Boolean);
+  if (parts.length > 0) {
+    return parts.at(-1) ?? "unknown error";
+  }
+  if (result.signal) {
+    return `signal=${result.signal}`;
+  }
+  if (result.code !== null) {
+    return `exit code ${result.code}`;
+  }
+  return result.termination || "unknown failure";
+}
+function resolveOpenClawCliArgvPrefix() {
+  const execPath = String(process.execPath ?? "").trim();
+  const scriptPath = String(process.argv[1] ?? "").trim();
+  if (execPath && scriptPath) {
+    return [execPath, scriptPath];
+  }
+  return ["openclaw"];
+}
+function buildExecApprovalResolveArgv(params) {
+  const cliArgvPrefix = params.cliArgvPrefix && params.cliArgvPrefix.length > 0 ? params.cliArgvPrefix : resolveOpenClawCliArgvPrefix();
+  const timeoutMs = Math.max(1e3, Math.floor(params.timeoutMs ?? 15e3));
+  return [
+    ...cliArgvPrefix,
+    "gateway",
+    "call",
+    "exec.approval.resolve",
+    "--json",
+    "--timeout",
+    String(timeoutMs),
+    "--params",
+    JSON.stringify({
+      id: params.id,
+      decision: params.decision
+    })
+  ];
+}
+async function submitExecApprovalDecision(params) {
+  const runner = params.runner ?? params.runtime.system.runCommandWithTimeout;
+  const timeoutMs = Math.max(1e3, Math.floor(params.timeoutMs ?? 15e3));
+  const argv = buildExecApprovalResolveArgv({
+    cliArgvPrefix: params.cliArgvPrefix,
+    id: params.id,
+    decision: params.decision,
+    timeoutMs
+  });
+  const result = await runner(argv, { timeoutMs });
+  if (result.termination !== "exit" || result.code !== 0) {
+    throw new Error(formatCommandFailure(result));
+  }
+}
+function isExecApprovalApprover(params) {
+  const senderId = String(params.senderId ?? "").trim();
+  if (!senderId) {
+    return false;
+  }
+  const config = normalizeExecApprovalConfig(params.account.config.execApprovals);
+  if (!config.enabled) {
+    return false;
+  }
+  return config.approvers.includes(senderId);
+}
+function disabledReplyText(accountId) {
+  return `\u274C ClawPool exec approvals are not enabled for account ${accountId}.`;
+}
+function unauthorizedReplyText() {
+  return "\u274C You are not authorized to approve exec requests on ClawPool.";
+}
+function successReplyText(command) {
+  return `\u2705 Exec approval ${command.decision} submitted for ${command.id}.`;
+}
+function failureReplyText(message) {
+  return `\u274C Failed to submit approval: ${message}`;
+}
+async function handleExecApprovalCommand(params) {
+  const parsed = parseExecApprovalCommand(params.rawBody);
+  if (!parsed.matched) {
+    return { handled: false };
+  }
+  if (!parsed.ok) {
+    return {
+      handled: true,
+      replyText: parsed.error
+    };
+  }
+  const config = normalizeExecApprovalConfig(params.account.config.execApprovals);
+  if (!config.enabled) {
+    return {
+      handled: true,
+      replyText: disabledReplyText(params.account.accountId)
+    };
+  }
+  if (!isExecApprovalApprover({ account: params.account, senderId: params.senderId })) {
+    return {
+      handled: true,
+      replyText: unauthorizedReplyText()
+    };
+  }
+  try {
+    await submitExecApprovalDecision({
+      runtime: params.runtime,
+      id: parsed.id,
+      decision: parsed.decision,
+      timeoutMs: params.timeoutMs,
+      runner: params.runner,
+      cliArgvPrefix: params.cliArgvPrefix
+    });
+    const actorId = String(params.senderId ?? "").trim();
+    const approvalId = String(parsed.approvalId ?? "").trim();
+    return {
+      handled: true,
+      replyText: successReplyText(parsed),
+      ...approvalId ? {
+        replyExtra: buildExecApprovalResolutionReply({
+          approvalId,
+          approvalCommandId: parsed.approvalCommandId,
+          decision: parsed.decision,
+          actorId: actorId || "unknown",
+          reason: parsed.reason
+        }).extra
+      } : {}
+    };
+  } catch (err) {
+    return {
+      handled: true,
+      replyText: failureReplyText(err instanceof Error ? err.message : String(err))
+    };
+  }
+}
+
+// src/revoke-event.ts
+function toStringId(value) {
+  return String(value ?? "").trim();
+}
+function resolveChatType(sessionType) {
+  if (sessionType === 1) {
+    return "direct";
+  }
+  if (sessionType === 2) {
+    return "group";
+  }
+  throw new Error(`clawpool revoke event has unsupported session_type=${sessionType}`);
+}
+function enqueueRevokeSystemEvent(params) {
+  const sessionId = toStringId(params.event.session_id);
+  const messageId = toStringId(params.event.msg_id);
+  const senderId = toStringId(params.event.sender_id);
+  const sessionType = Number(params.event.session_type);
+  if (!sessionId || !messageId) {
+    throw new Error(
+      `invalid event_revoke payload: session_id=${sessionId || "<empty>"} msg_id=${messageId || "<empty>"}`
+    );
+  }
+  const chatType = resolveChatType(sessionType);
+  const route = params.core.channel.routing.resolveAgentRoute({
+    cfg: params.config,
+    channel: "clawpool",
+    accountId: params.account.accountId,
+    peer: {
+      kind: chatType,
+      id: sessionId
+    }
+  });
+  const metadataParts = [`session_id=${sessionId}`, `msg_id=${messageId}`];
+  if (senderId) {
+    metadataParts.push(`sender_id=${senderId}`);
+  }
+  const text = `Clawpool ${chatType} message deleted [${metadataParts.join(" ")}]`;
+  params.core.system.enqueueSystemEvent(text, {
+    sessionKey: route.sessionKey,
+    contextKey: `clawpool:revoke:${sessionId}:${messageId}`
+  });
+  return {
+    messageId,
+    sessionId,
+    sessionKey: route.sessionKey,
+    text
+  };
+}
+
+// src/reply-dispatch-outcome.ts
+function hasPositiveCount(value) {
+  if (typeof value === "number") {
+    return Number.isFinite(value) && value > 0;
+  }
+  if (Array.isArray(value)) {
+    return value.some(hasPositiveCount);
+  }
+  if (value && typeof value === "object") {
+    return Object.values(value).some(hasPositiveCount);
+  }
+  return false;
+}
+function shouldTreatDispatchAsRespondedWithoutVisibleOutput(result) {
+  if (!result || typeof result !== "object") {
+    return false;
+  }
+  const typedResult = result;
+  if (typedResult.queuedFinal === true) {
+    return true;
+  }
+  if (hasPositiveCount(typedResult.counts)) {
+    return true;
+  }
+  return false;
+}
+
+// src/aibot-payload-delivery.ts
+import {
+  resolveOutboundMediaUrls,
+  sendMediaWithLeadingCaption
+} from "openclaw/plugin-sdk/reply-payload";
+
+// src/outbound-text-delivery-plan.ts
+function buildAibotTextSendPlan(params) {
+  const plan = [];
+  let chunkIndex = 0;
+  for (const chunk of params.chunks) {
+    const normalized = String(chunk ?? "");
+    if (!normalized) {
+      continue;
+    }
+    chunkIndex += 1;
+    const clientMsgId = params.stableClientMsgId ? `${params.stableClientMsgId}_chunk${chunkIndex}` : void 0;
+    const extra = chunkIndex === 1 ? params.firstChunkExtra : void 0;
+    plan.push({
+      text: normalized,
+      ...clientMsgId ? { clientMsgId } : {},
+      ...extra ? { extra } : {}
+    });
+  }
+  return plan;
+}
+
+// src/aibot-payload-delivery.ts
+function resolveAckMessageId(ack, fallback) {
+  const raw = ack.msg_id ?? ack.client_msg_id ?? fallback;
+  const normalized = String(raw ?? "").trim();
+  return normalized || void 0;
+}
+async function deliverAibotPayload(params) {
+  const mediaUrls = resolveOutboundMediaUrls(params.payload);
+  const textChunks = splitTextForAibotProtocol(
+    params.text,
+    resolveOutboundTextChunkLimit(params.account.config.maxChunkChars)
+  );
+  const textSendPlan = buildAibotTextSendPlan({
+    chunks: textChunks,
+    stableClientMsgId: params.stableClientMsgId,
+    firstChunkExtra: params.extra
+  });
+  let firstMessageId;
+  let sent = false;
+  let notifiedFirstVisibleSend = false;
+  const markVisibleDelivery = () => {
+    if (notifiedFirstVisibleSend) {
+      return;
+    }
+    notifiedFirstVisibleSend = true;
+    params.onFirstVisibleSend?.();
+  };
+  const mediaSent = await sendMediaWithLeadingCaption({
+    mediaUrls,
+    caption: textSendPlan[0]?.text ?? "",
+    send: async ({ mediaUrl, caption }) => {
+      if (params.abortSignal?.aborted) {
+        return;
+      }
+      const ack = await params.client.sendMedia(params.sessionId, mediaUrl, caption ?? "", {
+        eventId: params.eventId,
+        quotedMessageId: params.quotedMessageId,
+        clientMsgId: params.stableClientMsgId ? `${params.stableClientMsgId}_media` : void 0,
+        extra: params.extra
+      });
+      firstMessageId ??= resolveAckMessageId(
+        ack,
+        params.stableClientMsgId ? `${params.stableClientMsgId}_media` : void 0
+      );
+      sent = true;
+      markVisibleDelivery();
+      params.statusSink?.({ lastOutboundAt: Date.now(), lastError: null });
+    },
+    onError: (error) => {
+      params.onMediaError?.(error);
+      params.statusSink?.({ lastError: String(error) });
+    }
+  });
+  if (mediaSent) {
+    for (const chunkPlan of textSendPlan.slice(1)) {
+      if (params.abortSignal?.aborted) {
+        return { sent, firstMessageId };
+      }
+      const ack = await params.client.sendText(params.sessionId, chunkPlan.text, {
+        eventId: params.eventId,
+        quotedMessageId: params.quotedMessageId,
+        clientMsgId: chunkPlan.clientMsgId
+      });
+      firstMessageId ??= resolveAckMessageId(ack, chunkPlan.clientMsgId);
+      sent = true;
+      params.statusSink?.({ lastOutboundAt: Date.now(), lastError: null });
+    }
+    return { sent: true, firstMessageId };
+  }
+  if (textSendPlan.length === 0) {
+    return { sent: false, firstMessageId };
+  }
+  for (const chunkPlan of textSendPlan) {
+    if (params.abortSignal?.aborted) {
+      return { sent, firstMessageId };
+    }
+    const ack = await params.client.sendText(params.sessionId, chunkPlan.text, {
+      eventId: params.eventId,
+      quotedMessageId: params.quotedMessageId,
+      clientMsgId: chunkPlan.clientMsgId,
+      extra: chunkPlan.extra
+    });
+    firstMessageId ??= resolveAckMessageId(ack, chunkPlan.clientMsgId);
+    sent = true;
+    markVisibleDelivery();
+    params.statusSink?.({ lastOutboundAt: Date.now(), lastError: null });
+  }
+  return { sent, firstMessageId };
+}
+
+// src/monitor.ts
+var activeMonitorClients = /* @__PURE__ */ new Map();
+function registerActiveMonitor(accountId, client) {
+  if (!accountId) {
+    return null;
+  }
+  const previous = activeMonitorClients.get(accountId) ?? null;
+  activeMonitorClients.set(accountId, client);
+  return previous === client ? null : previous;
+}
+function isActiveMonitor(accountId, client) {
+  if (!accountId) {
+    return false;
+  }
+  return activeMonitorClients.get(accountId) === client;
+}
+function clearActiveMonitor(accountId, client) {
+  if (!accountId) {
+    return;
+  }
+  if (activeMonitorClients.get(accountId) !== client) {
+    return;
+  }
+  activeMonitorClients.delete(accountId);
+}
+function toStringId2(value) {
+  const text = String(value ?? "").trim();
+  return text;
+}
+function toTimestampMs(value) {
+  const n = Number(value);
+  if (!Number.isFinite(n) || n <= 0) {
+    return void 0;
+  }
+  if (n < 1e12) {
+    return Math.floor(n * 1e3);
+  }
+  return Math.floor(n);
+}
+function normalizeNumericMessageId(value) {
+  const raw = toStringId2(value);
+  if (!raw) {
+    return void 0;
+  }
+  return /^\d+$/.test(raw) ? raw : void 0;
+}
+function resolveStreamChunkChars(account) {
+  return resolveStreamTextChunkLimit(account.config.streamChunkChars);
+}
+function resolveStreamChunkDelayMs(account) {
+  return Math.max(0, Math.floor(account.config.streamChunkDelayMs ?? 0));
+}
+function resolveStreamFinishDelayMs(account) {
+  return resolveStreamChunkDelayMs(account);
+}
+var composingRenewIntervalMs = 8e3;
+function sleep2(ms) {
+  if (ms <= 0) {
+    return Promise.resolve();
+  }
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function resolveAbortReason(signal) {
+  const reason = String(signal?.reason ?? "").trim();
+  return reason || "-";
+}
+function buildEventLogContext(params) {
+  const parts = [
+    `eventId=${params.eventId || "-"}`,
+    `sessionId=${params.sessionId}`,
+    `messageSid=${params.messageSid}`
+  ];
+  if (params.clientMsgId) {
+    parts.push(`clientMsgId=${params.clientMsgId}`);
+  }
+  if (params.outboundCounter !== void 0) {
+    parts.push(`outboundCounter=${params.outboundCounter}`);
+  }
+  return parts.join(" ");
+}
+async function deliverAibotStreamBlock(params) {
+  const chunks = splitTextForAibotProtocol(params.text, resolveStreamChunkChars(params.account));
+  const chunkDelayMs = resolveStreamChunkDelayMs(params.account);
+  let didSend = false;
+  const context = buildEventLogContext({
+    eventId: params.eventId,
+    sessionId: params.sessionId,
+    messageSid: params.messageSid,
+    clientMsgId: params.clientMsgId
+  });
+  params.runtime.log(
+    `[clawpool:${params.account.accountId}] stream block split into ${chunks.length} chunk(s) ${context} textLen=${params.text.length} chunkDelayMs=${chunkDelayMs}`
+  );
+  for (let index = 0; index < chunks.length; index++) {
+    if (params.abortSignal?.aborted) {
+      params.runtime.log(
+        `[clawpool:${params.account.accountId}] stream chunk abort before send ${context} chunkIndex=${index + 1}/${chunks.length} didSend=${didSend} abortReason=${resolveAbortReason(params.abortSignal)}`
+      );
+      return didSend;
+    }
+    const chunk = chunks[index];
+    const normalized = String(chunk ?? "");
+    if (!normalized) {
+      continue;
+    }
+    params.runtime.log(
+      `[clawpool:${params.account.accountId}] stream chunk send ${context} chunkIndex=${index + 1}/${chunks.length} deltaLen=${normalized.length}`
+    );
+    await params.client.sendStreamChunk(params.sessionId, normalized, {
+      eventId: params.eventId,
+      clientMsgId: params.clientMsgId,
+      quotedMessageId: params.quotedMessageId,
+      isFinish: false
+    });
+    didSend = true;
+    params.statusSink?.({ lastOutboundAt: Date.now(), lastError: null });
+    if (chunkDelayMs > 0 && index < chunks.length - 1) {
+      await sleep2(chunkDelayMs);
+    }
+  }
+  return didSend;
+}
+async function deliverAibotMessage(params) {
+  const { payload, client, account, sessionId, quotedMessageId, runtime: runtime2, statusSink, stableClientMsgId } = params;
+  const core = getAibotRuntime();
+  const tableMode = params.tableMode ?? "code";
+  const outboundEnvelope = buildAibotOutboundEnvelope(payload);
+  const execApprovalDiagnostic = outboundEnvelope.execApprovalDiagnostic;
+  if (execApprovalDiagnostic.isCandidate) {
+    runtime2.log(
+      `[clawpool:${account.accountId}] exec approval outbound diagnostic eventId=${params.eventId || "-"} sessionId=${sessionId} clientMsgId=${stableClientMsgId || "-"} matched=${execApprovalDiagnostic.matched ? "true" : "false"} reason=${execApprovalDiagnostic.reason} hasChannelData=${execApprovalDiagnostic.hasChannelData ? "true" : "false"} hasExecApprovalField=${execApprovalDiagnostic.hasExecApprovalField ? "true" : "false"} approvalId=${execApprovalDiagnostic.approvalId || "-"} approvalSlug=${execApprovalDiagnostic.approvalSlug || "-"} approvalCommandId=${execApprovalDiagnostic.approvalCommandId || "-"} commandDetected=${execApprovalDiagnostic.commandDetected ? "true" : "false"} host=${execApprovalDiagnostic.host || "-"} nodeId=${execApprovalDiagnostic.nodeId || "-"} cwd=${execApprovalDiagnostic.cwd || "-"} expiresInSeconds=${execApprovalDiagnostic.expiresInSeconds ?? "-"} allowedDecisionCount=${execApprovalDiagnostic.allowedDecisionCount} textPrefix=${JSON.stringify(execApprovalDiagnostic.textPrefix)} bizCard=${outboundEnvelope.cardKind ?? "none"}`
+    );
+  }
+  const rawText = outboundEnvelope.text;
+  const text = core.channel.text.convertMarkdownTables(rawText, tableMode);
+  const delivery = await deliverAibotPayload({
+    payload,
+    text,
+    extra: outboundEnvelope.extra,
+    client,
+    account,
+    sessionId,
+    abortSignal: params.abortSignal,
+    eventId: params.eventId,
+    quotedMessageId,
+    stableClientMsgId,
+    onMediaError: (error) => {
+      runtime2.error(`clawpool media send failed: ${String(error)}`);
+    },
+    statusSink
+  });
+  return delivery.sent;
+}
+async function bindSessionRouteMapping(params) {
+  const routeSessionKey = String(params.routeSessionKey ?? "").trim();
+  const sessionId = String(params.sessionId ?? "").trim();
+  if (!routeSessionKey || !sessionId) {
+    return;
+  }
+  try {
+    params.runtime.log(
+      `[clawpool:${params.account.accountId}] session route bind begin routeSessionKey=${routeSessionKey} sessionId=${sessionId}`
+    );
+    await params.client.bindSessionRoute(
+      "clawpool",
+      params.account.accountId,
+      routeSessionKey,
+      sessionId
+    );
+    params.runtime.log(
+      `[clawpool:${params.account.accountId}] session route bind success routeSessionKey=${routeSessionKey} sessionId=${sessionId}`
+    );
+  } catch (err) {
+    const reason = `clawpool session route bind failed routeSessionKey=${routeSessionKey} sessionId=${sessionId}: ${String(err)}`;
+    params.runtime.error(`[clawpool:${params.account.accountId}] ${reason}`);
+    params.statusSink?.({ lastError: reason });
+  }
+}
+function handleEventStop(params) {
+  const eventId = toStringId2(params.payload.event_id);
+  const sessionId = toStringId2(params.payload.session_id);
+  const stopId = toStringId2(params.payload.stop_id);
+  if (!eventId || !sessionId) {
+    const reason = `invalid event_stop payload: event_id=${eventId || "<empty>"} session_id=${sessionId || "<empty>"}`;
+    params.runtime.error(`[clawpool:${params.account.accountId}] ${reason}`);
+    params.statusSink?.({ lastError: reason });
+    return;
+  }
+  params.runtime.log(
+    `[clawpool:${params.account.accountId}] event_stop begin eventId=${eventId} sessionId=${sessionId} stopId=${stopId || "-"} acceptedPayload=${JSON.stringify(params.payload)}`
+  );
+  try {
+    params.client.sendEventStopAck({
+      stop_id: stopId,
+      event_id: eventId,
+      accepted: true,
+      updated_at: Date.now()
+    });
+    params.statusSink?.({ lastOutboundAt: Date.now(), lastError: null });
+    params.runtime.log(
+      `[clawpool:${params.account.accountId}] event_stop_ack sent eventId=${eventId} sessionId=${sessionId} stopId=${stopId || "-"}`
+    );
+  } catch (err) {
+    const reason = `event_stop_ack failed eventId=${eventId} sessionId=${sessionId}: ${String(err)}`;
+    params.runtime.error(`[clawpool:${params.account.accountId}] ${reason}`);
+    params.statusSink?.({ lastError: reason });
+    return;
+  }
+  const activeRun = resolveActiveReplyRun({
+    accountId: params.account.accountId,
+    eventId,
+    sessionId
+  });
+  params.runtime.log(
+    `[clawpool:${params.account.accountId}] event_stop resolve_active_run eventId=${eventId} sessionId=${sessionId} found=${activeRun ? "true" : "false"} stopRequested=${activeRun?.stopRequested === true} aborted=${activeRun?.controller.signal.aborted === true} abortReason=${activeRun ? resolveAbortReason(activeRun.controller.signal) : "-"}`
+  );
+  if (!activeRun) {
+    params.client.sendEventStopResult({
+      stop_id: stopId,
+      event_id: eventId,
+      status: "already_finished",
+      updated_at: Date.now()
+    });
+    params.statusSink?.({ lastOutboundAt: Date.now(), lastError: null });
+    params.runtime.log(
+      `[clawpool:${params.account.accountId}] event_stop already_finished eventId=${eventId} sessionId=${sessionId} stopId=${stopId || "-"}`
+    );
+    return;
+  }
+  activeRun.stopRequested = true;
+  activeRun.stopId = stopId;
+  activeRun.abortReason = "owner_requested_stop";
+  if (!activeRun.controller.signal.aborted) {
+    activeRun.controller.abort(activeRun.abortReason);
+  }
+  params.runtime.log(
+    `[clawpool:${params.account.accountId}] owner stop requested eventId=${eventId} sessionId=${sessionId} stopId=${stopId || "-"} aborted=${activeRun.controller.signal.aborted} abortReason=${resolveAbortReason(activeRun.controller.signal)}`
+  );
+}
+function reportHandledCommandResult(params) {
+  if (!params.eventId) {
+    return;
+  }
+  try {
+    params.client.sendEventResult({
+      event_id: params.eventId,
+      status: params.status,
+      code: params.code,
+      msg: params.msg,
+      updated_at: Date.now()
+    });
+    params.statusSink?.({ lastOutboundAt: Date.now(), lastError: null });
+  } catch (err) {
+    params.runtime.error(
+      `[clawpool:${params.account.accountId}] command event result send failed eventId=${params.eventId} status=${params.status}: ${String(err)}`
+    );
+    params.statusSink?.({ lastError: String(err) });
+  }
+}
+async function sendHandledCommandReply(params) {
+  await params.client.sendText(params.sessionId, params.replyText, {
+    eventId: params.eventId,
+    quotedMessageId: params.quotedMessageId,
+    extra: params.replyExtra
+  });
+  params.statusSink?.({ lastOutboundAt: Date.now(), lastError: null });
+  params.runtime.log(
+    `[clawpool:${params.account.accountId}] command reply sent eventId=${params.eventId || "-"} sessionId=${params.sessionId} quotedMessageId=${params.quotedMessageId || "-"} textLen=${params.replyText.length}`
+  );
+}
+async function processEvent(params) {
+  const { event, account, config, runtime: runtime2, client, statusSink } = params;
+  const core = getAibotRuntime();
+  const sessionId = toStringId2(event.session_id);
+  const messageSid = toStringId2(event.msg_id);
+  const rawBody = String(event.content ?? "").trim();
+  if (!sessionId || !messageSid || !rawBody) {
+    const reason = `invalid event_msg payload: session_id=${sessionId || "<empty>"} msg_id=${messageSid || "<empty>"}`;
+    runtime2.error(`[clawpool:${account.accountId}] ${reason}`);
+    statusSink?.({ lastError: reason });
+    return;
+  }
+  const eventId = toStringId2(event.event_id);
+  const quotedMessageId = normalizeNumericMessageId(event.quoted_message_id);
+  const bodyForAgent = buildBodyWithQuotedReplyId(rawBody, quotedMessageId);
+  const senderId = toStringId2(event.sender_id);
+  const isGroup = Number(event.session_type ?? 0) === 2 || String(event.event_type ?? "").startsWith("group_");
+  const chatType = isGroup ? "group" : "direct";
+  const createdAt = toTimestampMs(event.created_at);
+  const baseLogContext = buildEventLogContext({
+    eventId,
+    sessionId,
+    messageSid
+  });
+  let visibleOutputSent = false;
+  const inboundEvent = claimInboundEvent({
+    accountId: account.accountId,
+    eventId,
+    sessionId,
+    messageSid
+  });
+  if (inboundEvent.duplicate) {
+    runtime2.log(
+      `[clawpool:${account.accountId}] skip duplicate inbound event ${baseLogContext} confirmed=${inboundEvent.confirmed}`
+    );
+    if (inboundEvent.confirmed && eventId) {
+      try {
+        client.ackEvent(eventId, {
+          sessionId,
+          msgId: messageSid,
+          receivedAt: Date.now()
+        });
+        statusSink?.({ lastOutboundAt: Date.now(), lastError: null });
+      } catch (err) {
+        runtime2.error(
+          `[clawpool:${account.accountId}] duplicate event ack failed eventId=${eventId}: ${String(err)}`
+        );
+        statusSink?.({ lastError: String(err) });
+      }
+    }
+    return;
+  }
+  runtime2.log(
+    `[clawpool:${account.accountId}] inbound event ${baseLogContext} chatType=${chatType} bodyLen=${rawBody.length} quotedMessageId=${quotedMessageId || "-"}`
+  );
+  let inboundEventAccepted = false;
+  const commandOutcome = await handleExecApprovalCommand({
+    rawBody,
+    senderId,
+    account,
+    runtime: core
+  });
+  if (commandOutcome.handled) {
+    try {
+      if (eventId) {
+        client.ackEvent(eventId, {
+          sessionId,
+          msgId: messageSid,
+          receivedAt: Date.now()
+        });
+        statusSink?.({ lastOutboundAt: Date.now(), lastError: null });
+      }
+      confirmInboundEvent(inboundEvent.claim);
+      inboundEventAccepted = true;
+      await sendHandledCommandReply({
+        client,
+        sessionId,
+        replyText: commandOutcome.replyText,
+        replyExtra: commandOutcome.replyExtra,
+        eventId,
+        quotedMessageId: normalizeNumericMessageId(messageSid),
+        account,
+        runtime: runtime2,
+        statusSink
+      });
+      reportHandledCommandResult({
+        client,
+        eventId,
+        status: "responded",
+        code: "clawpool_exec_approval_command_handled",
+        msg: "exec approval command handled",
+        account,
+        runtime: runtime2,
+        statusSink
+      });
+      return;
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      runtime2.error(
+        `[clawpool:${account.accountId}] exec approval command failed ${baseLogContext}: ${message}`
+      );
+      statusSink?.({ lastError: message });
+      reportHandledCommandResult({
+        client,
+        eventId,
+        status: "failed",
+        code: "clawpool_exec_approval_command_failed",
+        msg: message,
+        account,
+        runtime: runtime2,
+        statusSink
+      });
+      throw err;
+    }
+  }
+  const runAbortController = new AbortController();
+  const activeRun = registerActiveReplyRun({
+    accountId: account.accountId,
+    eventId: eventId || `${sessionId}:${messageSid}`,
+    sessionId,
+    controller: runAbortController
+  });
+  runtime2.log(
+    `[clawpool:${account.accountId}] active reply run registered eventId=${eventId || `${sessionId}:${messageSid}`} sessionId=${sessionId} messageSid=${messageSid} activeRun=${activeRun ? "true" : "false"}`
+  );
+  try {
+    const route = core.channel.routing.resolveAgentRoute({
+      cfg: config,
+      channel: "clawpool",
+      accountId: account.accountId,
+      peer: {
+        kind: isGroup ? "group" : "direct",
+        id: sessionId
+      }
+    });
+    const storePath = core.channel.session.resolveStorePath(config.session?.store, {
+      agentId: route.agentId
+    });
+    const previousTimestamp = core.channel.session.readSessionUpdatedAt({
+      storePath,
+      sessionKey: route.sessionKey
+    });
+    const fromLabel = isGroup ? `group:${sessionId}/${senderId || "unknown"}` : `user:${senderId || "unknown"}`;
+    const envelopeOptions = core.channel.reply.resolveEnvelopeFormatOptions(config);
+    const body = core.channel.reply.formatAgentEnvelope({
+      channel: "Clawpool",
+      from: fromLabel,
+      timestamp: createdAt,
+      previousTimestamp,
+      envelope: envelopeOptions,
+      body: bodyForAgent
+    });
+    const from = isGroup ? `clawpool:group:${sessionId}:${senderId || "unknown"}` : `clawpool:${senderId || "unknown"}`;
+    const to = `clawpool:${sessionId}`;
+    const ctxPayload = core.channel.reply.finalizeInboundContext({
+      Body: body,
+      BodyForAgent: bodyForAgent,
+      RawBody: rawBody,
+      CommandBody: rawBody,
+      // Clawpool inbound text is end-user chat content; do not parse it as OpenClaw slash/bang commands.
+      BodyForCommands: "",
+      From: from,
+      To: to,
+      SessionKey: route.sessionKey,
+      AccountId: route.accountId,
+      ChatType: chatType,
+      ConversationLabel: fromLabel,
+      SenderName: senderId || void 0,
+      SenderId: senderId || void 0,
+      CommandAuthorized: false,
+      Provider: "clawpool",
+      Surface: "clawpool",
+      MessageSid: messageSid,
+      // This field carries the inbound quoted message id from end user (event.quoted_message_id).
+      // It is not the outbound reply anchor used when plugin sends replies back to Aibot.
+      ReplyToMessageSid: quotedMessageId,
+      OriginatingChannel: "clawpool",
+      OriginatingTo: to
+    });
+    const routeSessionKey = ctxPayload.SessionKey ?? route.sessionKey;
+    await core.channel.session.recordInboundSession({
+      storePath,
+      sessionKey: routeSessionKey,
+      ctx: ctxPayload,
+      onRecordError: (err) => runtime2.error(`clawpool session meta update failed: ${String(err)}`)
+    });
+    await bindSessionRouteMapping({
+      client,
+      account,
+      runtime: runtime2,
+      sessionId,
+      routeSessionKey,
+      statusSink: statusSink ? (patch) => statusSink({ lastError: patch.lastError }) : void 0
+    });
+    if (eventId) {
+      try {
+        client.ackEvent(eventId, {
+          sessionId,
+          msgId: messageSid,
+          receivedAt: Date.now()
+        });
+        statusSink?.({ lastOutboundAt: Date.now(), lastError: null });
+        confirmInboundEvent(inboundEvent.claim);
+        inboundEventAccepted = true;
+      } catch (err) {
+        runtime2.error(`[clawpool:${account.accountId}] event ack failed eventId=${eventId}: ${String(err)}`);
+        statusSink?.({ lastError: String(err) });
+      }
+    } else {
+      confirmInboundEvent(inboundEvent.claim);
+      inboundEventAccepted = true;
+    }
+    const outboundQuotedMessageId = normalizeNumericMessageId(event.msg_id);
+    const { onModelSelected, ...prefixOptions } = createReplyPrefixOptions({
+      cfg: config,
+      agentId: route.agentId,
+      channel: "clawpool",
+      accountId: account.accountId
+    });
+    const tableMode = core.channel.text.resolveMarkdownTableMode({
+      cfg: config,
+      channel: "clawpool",
+      accountId: account.accountId
+    });
+    const streamClientMsgId = `reply_${messageSid}_stream`;
+    const retryPolicy = resolveUpstreamRetryPolicy(account);
+    let composingSet = false;
+    let composingRenewTimer = null;
+    let eventResultReported = false;
+    let stopResultReported = false;
+    const setComposing = (active) => {
+      try {
+        client.setSessionComposing(sessionId, active, {
+          refEventId: eventId || void 0,
+          refMsgId: outboundQuotedMessageId
+        });
+        composingSet = active;
+        statusSink?.({ lastOutboundAt: Date.now(), lastError: null });
+      } catch (err) {
+        runtime2.error(
+          `[clawpool:${account.accountId}] session activity update failed eventId=${eventId || "-"} sessionId=${sessionId} active=${active}: ${String(err)}`
+        );
+        statusSink?.({ lastError: String(err) });
+      }
+    };
+    const stopComposingRenewal = () => {
+      if (composingRenewTimer) {
+        clearTimeout(composingRenewTimer);
+        composingRenewTimer = null;
+      }
+    };
+    const scheduleComposingRenewal = () => {
+      if (!composingSet || eventResultReported || visibleOutputSent || composingRenewTimer) {
+        return;
+      }
+      composingRenewTimer = setTimeout(() => {
+        composingRenewTimer = null;
+        if (!composingSet || eventResultReported || visibleOutputSent) {
+          return;
+        }
+        setComposing(true);
+        scheduleComposingRenewal();
+      }, composingRenewIntervalMs);
+    };
+    const reportEventResult = (status, code = "", msg = "") => {
+      if (eventResultReported) {
+        return;
+      }
+      eventResultReported = true;
+      stopComposingRenewal();
+      if (!eventId) {
+        return;
+      }
+      try {
+        client.sendEventResult({
+          event_id: eventId,
+          status,
+          code: code || void 0,
+          msg: msg || void 0,
+          updated_at: Date.now()
+        });
+        statusSink?.({ lastOutboundAt: Date.now(), lastError: null });
+      } catch (err) {
+        runtime2.error(
+          `[clawpool:${account.accountId}] event result send failed eventId=${eventId} status=${status}: ${String(err)}`
+        );
+        statusSink?.({ lastError: String(err) });
+      }
+    };
+    const reportStopResult = (status, code = "", msg = "") => {
+      if (stopResultReported || !eventId || !activeRun?.stopRequested) {
+        return;
+      }
+      stopResultReported = true;
+      try {
+        client.sendEventStopResult({
+          stop_id: activeRun.stopId,
+          event_id: eventId,
+          status,
+          code: code || void 0,
+          msg: msg || void 0,
+          updated_at: Date.now()
+        });
+        statusSink?.({ lastOutboundAt: Date.now(), lastError: null });
+        runtime2.log(
+          `[clawpool:${account.accountId}] event_stop_result sent eventId=${eventId} stopId=${activeRun.stopId || "-"} status=${status} code=${code || "-"} msg=${msg || "-"}`
+        );
+      } catch (err) {
+        runtime2.error(
+          `[clawpool:${account.accountId}] event_stop_result send failed eventId=${eventId} status=${status}: ${String(err)}`
+        );
+        statusSink?.({ lastError: String(err) });
+      }
+    };
+    const clearComposing = () => {
+      stopComposingRenewal();
+      if (composingSet) {
+        setComposing(false);
+      }
+    };
+    const markVisibleOutputSent = () => {
+      if (visibleOutputSent) {
+        return;
+      }
+      visibleOutputSent = true;
+      clearComposing();
+      reportEventResult("responded");
+    };
+    setComposing(true);
+    scheduleComposingRenewal();
+    try {
+      for (let attempt = 1; attempt <= retryPolicy.maxAttempts; attempt++) {
+        let hasSentBlock = false;
+        let outboundCounter = 0;
+        let attemptHasOutbound = false;
+        let retryGuardedText = null;
+        const attemptLabel = `${attempt}/${retryPolicy.maxAttempts}`;
+        const finishStreamIfNeeded = async () => {
+          if (!hasSentBlock) {
+            return;
+          }
+          if (runAbortController.signal.aborted) {
+            runtime2.log(
+              `[clawpool:${account.accountId}] skip stream finish due to abort ${buildEventLogContext({
+                eventId,
+                sessionId,
+                messageSid,
+                clientMsgId: streamClientMsgId
+              })} abortReason=${resolveAbortReason(runAbortController.signal)}`
+            );
+            hasSentBlock = false;
+            return;
+          }
+          hasSentBlock = false;
+          try {
+            const finishContext = buildEventLogContext({
+              eventId,
+              sessionId,
+              messageSid,
+              clientMsgId: streamClientMsgId
+            });
+            const finishDelayMs = resolveStreamFinishDelayMs(account);
+            if (finishDelayMs > 0) {
+              runtime2.log(
+                `[clawpool:${account.accountId}] stream finish delay ${finishContext} delayMs=${finishDelayMs}`
+              );
+              await sleep2(finishDelayMs);
+            }
+            runtime2.log(
+              `[clawpool:${account.accountId}] stream finish ${finishContext}`
+            );
+            await client.sendStreamChunk(sessionId, "", {
+              eventId,
+              clientMsgId: streamClientMsgId,
+              quotedMessageId: outboundQuotedMessageId,
+              isFinish: true
+            });
+            attemptHasOutbound = true;
+            statusSink?.({ lastOutboundAt: Date.now(), lastError: null });
+          } catch (err) {
+            runtime2.error(`[clawpool:${account.accountId}] stream finish failed: ${String(err)}`);
+            statusSink?.({ lastError: String(err) });
+          }
+        };
+        const dispatchResult = await core.channel.reply.dispatchReplyWithBufferedBlockDispatcher({
+          ctx: ctxPayload,
+          cfg: config,
+          dispatcherOptions: {
+            ...prefixOptions,
+            deliver: async (payload, info) => {
+              outboundCounter++;
+              const outPayload = payload;
+              const guardedText = guardInternalReplyText(String(outPayload.text ?? ""));
+              const normalizedPayload = guardedText ? { ...outPayload, text: guardedText.userText } : outPayload;
+              const hasMedia = Boolean(normalizedPayload.mediaUrl) || (normalizedPayload.mediaUrls?.length ?? 0) > 0;
+              const text = core.channel.text.convertMarkdownTables(normalizedPayload.text ?? "", tableMode);
+              const streamedTextAlreadyVisible = hasSentBlock;
+              const deliverContext = buildEventLogContext({
+                eventId,
+                sessionId,
+                messageSid,
+                clientMsgId: info.kind === "block" ? streamClientMsgId : `reply_${messageSid}_${outboundCounter}`,
+                outboundCounter
+              });
+              runtime2.log(
+                `[clawpool:${account.accountId}] deliver ${deliverContext} kind=${info.kind} textLen=${text.length} hasMedia=${hasMedia} streamedBefore=${streamedTextAlreadyVisible}`
+              );
+              if (guardedText) {
+                runtime2.error(
+                  `[clawpool:${account.accountId}] rewrite internal reply text ${deliverContext} code=${guardedText.code} raw=${JSON.stringify(guardedText.rawText)}`
+                );
+              }
+              if (guardedText && retryGuardedText == null && isRetryableGuardedReply(guardedText) && !attemptHasOutbound && !hasSentBlock) {
+                retryGuardedText = guardedText;
+                runtime2.log(
+                  `[clawpool:${account.accountId}] defer guarded upstream reply for retry ${deliverContext} attempt=${attemptLabel} code=${guardedText.code}`
+                );
+                return;
+              }
+              if (retryGuardedText && !attemptHasOutbound && !hasSentBlock) {
+                runtime2.log(
+                  `[clawpool:${account.accountId}] skip outbound while retry pending ${deliverContext} attempt=${attemptLabel} code=${retryGuardedText.code}`
+                );
+                return;
+              }
+              if (info.kind === "block" && !guardedText && !hasMedia && text) {
+                const didSendBlock = await deliverAibotStreamBlock({
+                  text,
+                  client,
+                  account,
+                  sessionId,
+                  abortSignal: runAbortController.signal,
+                  eventId,
+                  messageSid,
+                  quotedMessageId: outboundQuotedMessageId,
+                  clientMsgId: streamClientMsgId,
+                  runtime: runtime2,
+                  statusSink
+                });
+                hasSentBlock = hasSentBlock || didSendBlock;
+                attemptHasOutbound = attemptHasOutbound || didSendBlock;
+                if (didSendBlock) {
+                  markVisibleOutputSent();
+                }
+                return;
+              }
+              await finishStreamIfNeeded();
+              if (info.kind === "final" && streamedTextAlreadyVisible && !hasMedia && text) {
+                runtime2.log(
+                  `[clawpool:${account.accountId}] skip final text after streamed block ${deliverContext} textLen=${text.length}`
+                );
+                return;
+              }
+              const stableClientMsgId = `reply_${messageSid}_${outboundCounter}`;
+              runtime2.log(
+                `[clawpool:${account.accountId}] deliver message ${buildEventLogContext({
+                  eventId,
+                  sessionId,
+                  messageSid,
+                  clientMsgId: stableClientMsgId,
+                  outboundCounter
+                })} textLen=${text.length} hasMedia=${hasMedia}`
+              );
+              const didSendMessage = await deliverAibotMessage({
+                payload: normalizedPayload,
+                client,
+                account,
+                sessionId,
+                abortSignal: runAbortController.signal,
+                eventId,
+                quotedMessageId: outboundQuotedMessageId,
+                runtime: runtime2,
+                statusSink,
+                stableClientMsgId,
+                tableMode
+              });
+              attemptHasOutbound = attemptHasOutbound || didSendMessage;
+              if (didSendMessage) {
+                markVisibleOutputSent();
+              }
+            },
+            onError: (err, info) => {
+              runtime2.error(`[clawpool:${account.accountId}] ${info.kind} reply failed: ${String(err)}`);
+              statusSink?.({ lastError: String(err) });
+            }
+          },
+          replyOptions: {
+            abortSignal: runAbortController.signal,
+            onModelSelected
+          }
+        });
+        runtime2.log(
+          `[clawpool:${account.accountId}] dispatch complete ${baseLogContext} attempt=${attemptLabel} queuedFinal=${dispatchResult.queuedFinal} counts=${JSON.stringify(dispatchResult.counts)}`
+        );
+        await finishStreamIfNeeded();
+        if (!visibleOutputSent && consumeSilentUnsendCompleted(messageSid)) {
+          runtime2.log(
+            `[clawpool:${account.accountId}] silent unsend completed ${baseLogContext} attempt=${attemptLabel}`
+          );
+          reportEventResult("responded");
+        }
+        if (!visibleOutputSent && shouldTreatDispatchAsRespondedWithoutVisibleOutput(dispatchResult)) {
+          runtime2.log(
+            `[clawpool:${account.accountId}] dispatch completed without visible reply but produced actionable outcome ${baseLogContext} attempt=${attemptLabel}`
+          );
+          reportEventResult("responded");
+        }
+        if (retryGuardedText && !attemptHasOutbound) {
+          if (attempt < retryPolicy.maxAttempts) {
+            const delayMs = resolveUpstreamRetryDelayMs(retryPolicy, attempt);
+            runtime2.error(
+              `[clawpool:${account.accountId}] upstream guarded reply retry ${baseLogContext} code=${retryGuardedText.code} attempt=${attemptLabel} next=${attempt + 1}/${retryPolicy.maxAttempts} delayMs=${delayMs}`
+            );
+            if (delayMs > 0) {
+              await sleep2(delayMs);
+            }
+            continue;
+          }
+          outboundCounter++;
+          const stableClientMsgId = `reply_${messageSid}_${outboundCounter}`;
+          runtime2.error(
+            `[clawpool:${account.accountId}] upstream guarded reply retry exhausted ${baseLogContext} code=${retryGuardedText.code} attempts=${retryPolicy.maxAttempts}`
+          );
+          const didSendMessage = await deliverAibotMessage({
+            payload: {
+              text: retryGuardedText.userText
+            },
+            client,
+            account,
+            sessionId,
+            abortSignal: runAbortController.signal,
+            eventId,
+            quotedMessageId: outboundQuotedMessageId,
+            runtime: runtime2,
+            statusSink,
+            stableClientMsgId,
+            tableMode
+          });
+          attemptHasOutbound = attemptHasOutbound || didSendMessage;
+          if (didSendMessage) {
+            markVisibleOutputSent();
+          }
+        }
+        break;
+      }
+      if (!visibleOutputSent && !eventResultReported) {
+        reportEventResult("failed", "clawpool_no_outbound_reply", "no outbound reply emitted");
+      }
+    } catch (err) {
+      if (runAbortController.signal.aborted) {
+        runtime2.log(
+          `[clawpool:${account.accountId}] dispatch aborted ${baseLogContext} stopRequested=${activeRun?.stopRequested === true} abortReason=${resolveAbortReason(runAbortController.signal)}`
+        );
+        clearComposing();
+        if (activeRun?.stopRequested) {
+          if (!visibleOutputSent) {
+            reportEventResult("canceled", "owner_requested_stop", "owner requested stop");
+          }
+          reportStopResult("stopped", "owner_requested_stop", "owner requested stop");
+          return;
+        }
+      }
+      if (!visibleOutputSent) {
+        const message = err instanceof Error ? err.message : String(err);
+        reportEventResult("failed", "clawpool_dispatch_failed", message);
+      }
+      reportStopResult("failed", "clawpool_stop_failed", err instanceof Error ? err.message : String(err));
+      throw err;
+    } finally {
+      stopComposingRenewal();
+      if (composingSet) {
+        setComposing(false);
+      }
+    }
+  } finally {
+    runtime2.log(
+      `[clawpool:${account.accountId}] active reply run clearing eventId=${activeRun?.eventId || "-"} sessionId=${activeRun?.sessionId || sessionId} stopRequested=${activeRun?.stopRequested === true} abortReason=${activeRun ? resolveAbortReason(activeRun.controller.signal) : "-"} visibleOutputSent=${visibleOutputSent}`
+    );
+    clearActiveReplyRun(activeRun);
+    if (!inboundEventAccepted) {
+      releaseInboundEvent(inboundEvent.claim);
+    }
+  }
+}
+async function monitorAibotProvider(options) {
+  const { account, config, runtime: runtime2, abortSignal, statusSink } = options;
+  let client;
+  const guardedStatusSink = (patch) => {
+    if (!isActiveMonitor(account.accountId, client)) {
+      return;
+    }
+    statusSink?.(patch);
+  };
+  client = new AibotWsClient(account, {
+    logger: {
+      info: (message) => runtime2.log(message),
+      warn: (message) => runtime2.log(`[warn] ${message}`),
+      error: (message) => runtime2.error(message),
+      debug: (message) => runtime2.log(message)
+    },
+    onStatus: (status) => {
+      guardedStatusSink({
+        running: status.running,
+        connected: status.connected,
+        lastError: status.lastError,
+        lastConnectAt: status.lastConnectAt ?? void 0,
+        lastDisconnectAt: status.lastDisconnectAt ?? void 0
+      });
+    },
+    onEventMsg: (event) => {
+      if (!isActiveMonitor(account.accountId, client)) {
+        return;
+      }
+      guardedStatusSink({ lastInboundAt: Date.now() });
+      void processEvent({
+        event,
+        account,
+        config,
+        runtime: runtime2,
+        client,
+        statusSink: guardedStatusSink
+      }).catch((err) => {
+        if (!isActiveMonitor(account.accountId, client)) {
+          return;
+        }
+        const msg = err instanceof Error ? err.message : String(err);
+        runtime2.error(`[clawpool:${account.accountId}] process event failed: ${msg}`);
+        guardedStatusSink({ lastError: msg });
+      });
+    },
+    onEventRevoke: (event) => {
+      if (!isActiveMonitor(account.accountId, client)) {
+        return;
+      }
+      guardedStatusSink({ lastInboundAt: Date.now() });
+      try {
+        const eventId = String(event.event_id ?? "").trim();
+        if (eventId) {
+          client.ackEvent(eventId, {
+            sessionId: event.session_id,
+            msgId: event.msg_id
+          });
+        }
+        const revokeEvent = enqueueRevokeSystemEvent({
+          core: getAibotRuntime(),
+          event,
+          account,
+          config
+        });
+        runtime2.log(
+          `[clawpool:${account.accountId}] inbound revoke sessionId=${revokeEvent.sessionId} messageSid=${revokeEvent.messageId} routeSessionKey=${revokeEvent.sessionKey}`
+        );
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        runtime2.error(`[clawpool:${account.accountId}] process revoke event failed: ${msg}`);
+        guardedStatusSink({ lastError: msg });
+      }
+    },
+    onEventStop: (payload) => {
+      if (!isActiveMonitor(account.accountId, client)) {
+        return;
+      }
+      guardedStatusSink({ lastInboundAt: Date.now() });
+      handleEventStop({
+        payload,
+        account,
+        runtime: runtime2,
+        client,
+        statusSink: guardedStatusSink
+      });
+    }
+  });
+  const previousClient = registerActiveMonitor(account.accountId, client);
+  if (previousClient) {
+    runtime2.log(`[clawpool:${account.accountId}] stopping superseded clawpool monitor before restart`);
+    previousClient.stop();
+  }
+  setActiveAibotClient(account.accountId, client);
+  try {
+    await client.start(abortSignal);
+  } catch (err) {
+    clearActiveAibotClient(account.accountId, client);
+    clearActiveMonitor(account.accountId, client);
+    throw err;
+  }
+  void client.waitUntilStopped().catch((err) => {
+    if (!isActiveMonitor(account.accountId, client)) {
+      return;
+    }
+    const msg = err instanceof Error ? err.message : String(err);
+    runtime2.error(`[clawpool:${account.accountId}] background run loop failed: ${msg}`);
+    guardedStatusSink({ lastError: msg });
+  }).finally(() => {
+    clearActiveAibotClient(account.accountId, client);
+    clearActiveMonitor(account.accountId, client);
+  });
+  return {
+    stop: () => {
+      clearActiveAibotClient(account.accountId, client);
+      clearActiveMonitor(account.accountId, client);
+      client.stop();
+    }
+  };
+}
+
+// src/setup-config.ts
+import {
+  applyAccountNameToChannelSection,
+  migrateBaseNameToDefaultAccount
+} from "openclaw/plugin-sdk/core";
+function resolveSetupValues(input) {
+  const apiKey = String(input.token ?? input.appToken ?? "").trim();
+  const wsUrl = String(input.httpUrl ?? input.webhookUrl ?? input.url ?? "").trim();
+  const agentId = String(input.userId ?? "").trim();
+  return {
+    apiKey: apiKey || void 0,
+    wsUrl: wsUrl || void 0,
+    agentId: agentId || void 0
+  };
+}
+function applySetupAccountConfig(params) {
+  const { cfg, accountId, name, values } = params;
+  const namedConfig = applyAccountNameToChannelSection({
+    cfg,
+    channelKey: "clawpool",
+    accountId,
+    name
+  });
+  const next = accountId !== DEFAULT_ACCOUNT_ID ? migrateBaseNameToDefaultAccount({
+    cfg: namedConfig,
+    channelKey: "clawpool"
+  }) : namedConfig;
+  if (accountId === DEFAULT_ACCOUNT_ID) {
+    return {
+      ...next,
+      channels: {
+        ...next.channels,
+        clawpool: {
+          ...next.channels?.clawpool,
+          enabled: true,
+          ...values.apiKey ? { apiKey: values.apiKey } : {},
+          ...values.wsUrl ? { wsUrl: values.wsUrl } : {},
+          ...values.agentId ? { agentId: values.agentId } : {}
+        }
+      }
+    };
+  }
+  return {
+    ...next,
+    channels: {
+      ...next.channels,
+      clawpool: {
+        ...next.channels?.clawpool,
+        enabled: true,
+        accounts: {
+          ...next.channels?.clawpool?.accounts ?? {},
+          [accountId]: {
+            ...next.channels?.clawpool?.accounts?.[accountId],
+            enabled: true,
+            ...values.apiKey ? { apiKey: values.apiKey } : {},
+            ...values.wsUrl ? { wsUrl: values.wsUrl } : {},
+            ...values.agentId ? { agentId: values.agentId } : {}
+          }
+        }
+      }
+    }
+  };
+}
+
+// src/channel.ts
+var meta = {
+  id: "clawpool",
+  label: "Clawpool",
+  selectionLabel: "Clawpool",
+  docsPath: "/channels/clawpool",
+  blurb: "Bridge OpenClaw to Clawpool over the ClawPool Agent API WebSocket.",
+  aliases: ["cp", "clowpool"],
+  order: 90
+};
+function normalizeQuotedMessageId(rawInput) {
+  const raw = String(rawInput ?? "").trim();
+  if (!raw) {
+    return void 0;
+  }
+  if (/^\d+$/.test(raw)) {
+    return raw;
+  }
+  const parsed = raw.split(":").at(-1)?.trim() ?? "";
+  if (/^\d+$/.test(parsed)) {
+    return parsed;
+  }
+  return void 0;
+}
+function logAibotOutboundAdapter(message) {
+  console.info(`[clawpool:outbound] ${message}`);
+}
+function asAibotChannelConfig(cfg) {
+  return cfg.channels?.clawpool ?? {};
+}
+function buildAccountSnapshot(params) {
+  const { account, runtime: runtime2 } = params;
+  return {
+    accountId: account.accountId,
+    name: account.name,
+    enabled: account.enabled,
+    configured: account.configured,
+    running: runtime2?.running ?? false,
+    connected: runtime2?.connected ?? false,
+    lastError: runtime2?.lastError ?? null,
+    lastStartAt: runtime2?.lastStartAt ?? null,
+    lastStopAt: runtime2?.lastStopAt ?? null,
+    lastInboundAt: runtime2?.lastInboundAt ?? null,
+    lastOutboundAt: runtime2?.lastOutboundAt ?? null,
+    dmPolicy: account.config.dmPolicy ?? "open",
+    tokenSource: account.apiKey ? "config" : "none"
+  };
+}
+var AibotConfigSchema = {
+  type: "object",
+  additionalProperties: true,
+  properties: {}
+};
+function chunkTextForOutbound(text, limit) {
+  if (!text) return [];
+  if (limit <= 0 || text.length <= limit) return [text];
+  const chunks = [];
+  let remaining = text;
+  while (remaining.length > limit) {
+    const window = remaining.slice(0, limit);
+    const lastNewline = window.lastIndexOf("\n");
+    const lastSpace = window.lastIndexOf(" ");
+    const candidateBreak = lastNewline > 0 ? lastNewline : lastSpace;
+    const breakIdx = Number.isFinite(candidateBreak) && candidateBreak > 0 && candidateBreak <= limit ? candidateBreak : limit;
+    const chunk = remaining.slice(0, breakIdx).trimEnd();
+    if (chunk.length > 0) chunks.push(chunk);
+    const brokeOnSeparator = breakIdx < remaining.length && /\s/.test(remaining[breakIdx] ?? "");
+    const nextStart = Math.min(remaining.length, breakIdx + (brokeOnSeparator ? 1 : 0));
+    remaining = remaining.slice(nextStart).trimStart();
+  }
+  if (remaining.length) chunks.push(remaining);
+  return chunks;
+}
+var aibotPlugin = {
+  id: "clawpool",
+  meta,
+  capabilities: {
+    chatTypes: ["direct", "group"],
+    media: true,
+    reactions: true,
+    unsend: true,
+    threads: false,
+    polls: false,
+    nativeCommands: false,
+    blockStreaming: true
+  },
+  actions: aibotMessageActions,
+  reload: {
+    configPrefixes: ["channels.clawpool"]
+  },
+  configSchema: {
+    schema: AibotConfigSchema
+  },
+  config: {
+    listAccountIds: (cfg) => listAibotAccountIds(cfg),
+    resolveAccount: (cfg, accountId) => resolveAibotAccount({ cfg, accountId }),
+    defaultAccountId: (cfg) => resolveDefaultAibotAccountId(cfg),
+    setAccountEnabled: ({ cfg, accountId, enabled }) => setAccountEnabledInConfigSection({
+      cfg,
+      sectionKey: "clawpool",
+      accountId,
+      enabled,
+      allowTopLevel: true
+    }),
+    deleteAccount: ({ cfg, accountId }) => deleteAccountFromConfigSection({
+      cfg,
+      sectionKey: "clawpool",
+      accountId,
+      clearBaseFields: [
+        "name",
+        "wsUrl",
+        "agentId",
+        "apiKey",
+        "reconnectMs",
+        "reconnectMaxMs",
+        "reconnectStableMs",
+        "connectTimeoutMs",
+        "keepalivePingMs",
+        "keepaliveTimeoutMs",
+        "upstreamRetryMaxAttempts",
+        "upstreamRetryBaseDelayMs",
+        "upstreamRetryMaxDelayMs",
+        "maxChunkChars",
+        "execApprovals",
+        "dmPolicy",
+        "allowFrom",
+        "defaultTo"
+      ]
+    }),
+    isConfigured: (account) => account.configured,
+    describeAccount: (account, cfg) => {
+      const root = asAibotChannelConfig(cfg);
+      return {
+        accountId: account.accountId,
+        name: account.name,
+        enabled: account.enabled,
+        configured: account.configured,
+        running: false,
+        connected: false,
+        lastError: account.configured ? null : "missing wsUrl/agentId/apiKey (or CLAWPOOL_WS_URL/CLAWPOOL_AGENT_ID/CLAWPOOL_API_KEY)",
+        dmPolicy: account.config.dmPolicy ?? "open",
+        tokenSource: account.apiKey ? "config" : "none",
+        mode: "block_streaming",
+        baseUrl: redactAibotWsUrl(account.wsUrl),
+        allowFrom: account.config.allowFrom?.map((entry) => String(entry).trim()).filter(Boolean) ?? [],
+        nameSource: root.accounts?.[account.accountId]?.name ? "account" : "base"
+      };
+    },
+    resolveAllowFrom: ({ cfg, accountId }) => resolveAibotAccount({ cfg, accountId }).config.allowFrom?.map((entry) => String(entry)) ?? [],
+    formatAllowFrom: ({ allowFrom }) => allowFrom.map((entry) => String(entry).trim()).filter(Boolean),
+    resolveDefaultTo: ({ cfg, accountId }) => resolveAibotAccount({ cfg, accountId }).config.defaultTo?.trim() || void 0
+  },
+  setup: {
+    resolveAccountId: ({ accountId }) => normalizeAccountId(accountId),
+    applyAccountName: ({ cfg, accountId, name }) => applyAccountNameToChannelSection2({
+      cfg,
+      channelKey: "clawpool",
+      accountId,
+      name
+    }),
+    validateInput: ({ input }) => {
+      const values = resolveSetupValues(input);
+      const hasAny = Boolean(values.apiKey || values.wsUrl || values.agentId);
+      if (!hasAny) {
+        return "clawpool setup requires at least one of: --token(api key), --http-url(ws url), --user-id(agent id)";
+      }
+      return null;
+    },
+    applyAccountConfig: ({ cfg, accountId, input }) => {
+      const values = resolveSetupValues(input);
+      return applySetupAccountConfig({
+        cfg,
+        accountId,
+        name: input.name,
+        values
+      });
+    }
+  },
+  security: {
+    resolveDmPolicy: ({ cfg, accountId, account }) => {
+      const resolvedAccountId = accountId ?? account.accountId ?? DEFAULT_ACCOUNT_ID;
+      const isAccountScoped = Boolean(cfg.channels?.clawpool?.accounts?.[resolvedAccountId]);
+      const basePath = isAccountScoped ? `channels.clawpool.accounts.${resolvedAccountId}.` : "channels.clawpool.";
+      return {
+        policy: account.config.dmPolicy ?? "open",
+        allowFrom: account.config.allowFrom ?? [],
+        policyPath: `${basePath}dmPolicy`,
+        allowFromPath: basePath,
+        approveHint: formatPairingApproveHint("clawpool")
+      };
+    }
+  },
+  messaging: {
+    normalizeTarget: (raw) => normalizeAibotSessionTarget(raw),
+    targetResolver: {
+      looksLikeId: (raw) => Boolean(normalizeAibotSessionTarget(raw)),
+      hint: "<session_id|route.sessionKey>"
+    }
+  },
+  execApprovals: clawpoolExecApprovalAdapter,
+  threading: {
+    buildToolContext: ({ context, hasRepliedRef }) => ({
+      currentChannelId: context.To?.trim() || void 0,
+      currentMessageId: context.CurrentMessageId != null ? String(context.CurrentMessageId) : void 0,
+      hasRepliedRef
+    })
+  },
+  agentPrompt: {
+    messageToolHints: () => [
+      "- Clawpool `action=unsend` is a silent cleanup action: unsend the target `messageId`, unsend the recall command message when applicable, then end with `NO_REPLY` and do not send any confirmation text. Omit `sessionId`/`to` only when targeting the current Clawpool chat."
+    ]
+  },
+  outbound: {
+    deliveryMode: "direct",
+    chunker: chunkTextForOutbound,
+    chunkerMode: "markdown",
+    textChunkLimit: DEFAULT_OUTBOUND_TEXT_CHUNK_LIMIT,
+    sendText: async ({ cfg, to, text, accountId, replyToId }) => {
+      const account = resolveAibotAccount({ cfg, accountId });
+      const client = requireActiveAibotClient(account.accountId);
+      const rawTarget = String(to ?? "").trim() || "-";
+      logAibotOutboundAdapter(
+        `sendText target resolve begin accountId=${account.accountId} rawTarget=${rawTarget}`
+      );
+      let resolvedTarget;
+      try {
+        resolvedTarget = await resolveAibotOutboundTarget({
+          client,
+          accountId: account.accountId,
+          to
+        });
+      } catch (err) {
+        logAibotOutboundAdapter(
+          `sendText target resolve failed accountId=${account.accountId} rawTarget=${rawTarget} error=${String(err)}`
+        );
+        throw err;
+      }
+      const sessionId = resolvedTarget.sessionId;
+      const quotedMessageId = normalizeQuotedMessageId(replyToId);
+      logAibotOutboundAdapter(
+        `sendText accountId=${account.accountId} rawTarget=${rawTarget} normalizedTarget=${resolvedTarget.normalizedTarget} resolvedSessionId=${sessionId} resolveSource=${resolvedTarget.resolveSource} textLen=${text.length} quotedMessageId=${quotedMessageId ?? "-"}`
+      );
+      const ack = await client.sendText(sessionId, text, {
+        quotedMessageId
+      });
+      logAibotOutboundAdapter(
+        `sendText ack accountId=${account.accountId} resolvedSessionId=${sessionId} messageId=${String(ack.msg_id ?? ack.client_msg_id ?? "-")}`
+      );
+      return {
+        channel: "clawpool",
+        messageId: String(ack.msg_id ?? ack.client_msg_id ?? Date.now())
+      };
+    },
+    sendMedia: async ({ cfg, to, text, mediaUrl, accountId, replyToId }) => {
+      const account = resolveAibotAccount({ cfg, accountId });
+      const client = requireActiveAibotClient(account.accountId);
+      const rawTarget = String(to ?? "").trim() || "-";
+      logAibotOutboundAdapter(
+        `sendMedia target resolve begin accountId=${account.accountId} rawTarget=${rawTarget}`
+      );
+      let resolvedTarget;
+      try {
+        resolvedTarget = await resolveAibotOutboundTarget({
+          client,
+          accountId: account.accountId,
+          to
+        });
+      } catch (err) {
+        logAibotOutboundAdapter(
+          `sendMedia target resolve failed accountId=${account.accountId} rawTarget=${rawTarget} error=${String(err)}`
+        );
+        throw err;
+      }
+      const sessionId = resolvedTarget.sessionId;
+      if (!mediaUrl) {
+        throw new Error("clawpool sendMedia requires mediaUrl");
+      }
+      const quotedMessageId = normalizeQuotedMessageId(replyToId);
+      logAibotOutboundAdapter(
+        `sendMedia accountId=${account.accountId} rawTarget=${rawTarget} normalizedTarget=${resolvedTarget.normalizedTarget} resolvedSessionId=${sessionId} resolveSource=${resolvedTarget.resolveSource} textLen=${(text ?? "").length} quotedMessageId=${quotedMessageId ?? "-"} mediaUrl=${mediaUrl}`
+      );
+      const ack = await client.sendMedia(sessionId, mediaUrl, text ?? "", {
+        quotedMessageId
+      });
+      logAibotOutboundAdapter(
+        `sendMedia ack accountId=${account.accountId} resolvedSessionId=${sessionId} messageId=${String(ack.msg_id ?? ack.client_msg_id ?? "-")}`
+      );
+      return {
+        channel: "clawpool",
+        messageId: String(ack.msg_id ?? ack.client_msg_id ?? Date.now())
+      };
+    },
+    sendPayload: async ({ cfg, to, payload, accountId, replyToId }) => {
+      const account = resolveAibotAccount({ cfg, accountId });
+      const client = requireActiveAibotClient(account.accountId);
+      const rawTarget = String(to ?? "").trim() || "-";
+      logAibotOutboundAdapter(
+        `sendPayload target resolve begin accountId=${account.accountId} rawTarget=${rawTarget}`
+      );
+      let resolvedTarget;
+      try {
+        resolvedTarget = await resolveAibotOutboundTarget({
+          client,
+          accountId: account.accountId,
+          to
+        });
+      } catch (err) {
+        logAibotOutboundAdapter(
+          `sendPayload target resolve failed accountId=${account.accountId} rawTarget=${rawTarget} error=${String(err)}`
+        );
+        throw err;
+      }
+      const sessionId = resolvedTarget.sessionId;
+      const quotedMessageId = normalizeQuotedMessageId(replyToId);
+      const envelope = buildAibotOutboundEnvelope(payload);
+      logAibotOutboundAdapter(
+        `sendPayload accountId=${account.accountId} rawTarget=${rawTarget} normalizedTarget=${resolvedTarget.normalizedTarget} resolvedSessionId=${sessionId} resolveSource=${resolvedTarget.resolveSource} textLen=${envelope.text.length} quotedMessageId=${quotedMessageId ?? "-"} cardKind=${envelope.cardKind ?? "none"}`
+      );
+      const delivery = await deliverAibotPayload({
+        payload,
+        text: envelope.text,
+        extra: envelope.extra,
+        client,
+        account,
+        sessionId,
+        quotedMessageId
+      });
+      if (!delivery.sent) {
+        throw new Error("clawpool sendPayload produced no visible delivery");
+      }
+      const messageId = delivery.firstMessageId ?? `clawpool_payload_${Date.now()}`;
+      logAibotOutboundAdapter(
+        `sendPayload ack accountId=${account.accountId} resolvedSessionId=${sessionId} messageId=${messageId} cardKind=${envelope.cardKind ?? "none"}`
+      );
+      return {
+        channel: "clawpool",
+        messageId
+      };
+    }
+  },
+  status: {
+    defaultRuntime: {
+      accountId: DEFAULT_ACCOUNT_ID,
+      running: false,
+      connected: false,
+      lastError: null,
+      lastStartAt: null,
+      lastStopAt: null,
+      lastInboundAt: null,
+      lastOutboundAt: null
+    },
+    buildChannelSummary: ({ snapshot }) => ({
+      configured: snapshot.configured ?? false,
+      running: snapshot.running ?? false,
+      connected: snapshot.connected ?? false,
+      lastError: snapshot.lastError ?? null,
+      lastInboundAt: snapshot.lastInboundAt ?? null,
+      lastOutboundAt: snapshot.lastOutboundAt ?? null
+    }),
+    buildAccountSnapshot: ({ account, runtime: runtime2 }) => buildAccountSnapshot({ account, runtime: runtime2 }),
+    collectStatusIssues: (accounts) => accounts.flatMap((account) => {
+      if (!account.enabled) {
+        return [];
+      }
+      if (!account.configured) {
+        return [
+          {
+            channel: "clawpool",
+            accountId: account.accountId,
+            kind: "config",
+            message: "Clawpool account is not configured. Set wsUrl/agentId/apiKey (or CLAWPOOL_WS_URL/CLAWPOOL_AGENT_ID/CLAWPOOL_API_KEY)."
+          }
+        ];
+      }
+      if (account.running && !account.connected) {
+        return [
+          {
+            channel: "clawpool",
+            accountId: account.accountId,
+            kind: "runtime",
+            message: "Clawpool channel is running but not connected."
+          }
+        ];
+      }
+      if (typeof account.lastError === "string" && account.lastError.trim()) {
+        return [
+          {
+            channel: "clawpool",
+            accountId: account.accountId,
+            kind: "runtime",
+            message: account.lastError
+          }
+        ];
+      }
+      return [];
+    })
+  },
+  gateway: {
+    startAccount: async (ctx) => {
+      const account = ctx.account;
+      if (!account.configured) {
+        throw new Error(
+          `clawpool account "${account.accountId}" not configured: require wsUrl + agentId + apiKey`
+        );
+      }
+      ctx.log?.info?.(
+        `[${account.accountId}] starting clawpool monitor (${redactAibotWsUrl(account.wsUrl)})`
+      );
+      ctx.setStatus({
+        ...ctx.getStatus(),
+        running: true,
+        connected: false,
+        lastError: null,
+        lastStartAt: Date.now()
+      });
+      const monitor = await monitorAibotProvider({
+        account,
+        config: ctx.cfg,
+        runtime: ctx.runtime,
+        abortSignal: ctx.abortSignal,
+        statusSink: (patch) => {
+          ctx.setStatus({
+            ...ctx.getStatus(),
+            ...patch
+          });
+        }
+      });
+      try {
+        await waitUntilAbort(ctx.abortSignal);
+      } finally {
+        monitor.stop();
+        ctx.setStatus({
+          ...ctx.getStatus(),
+          running: false,
+          connected: false,
+          lastStopAt: Date.now()
+        });
+      }
+    },
+    stopAccount: async (ctx) => {
+      const client = getActiveAibotClient(ctx.accountId);
+      client?.stop();
+      ctx.setStatus({
+        ...ctx.getStatus(),
+        running: false,
+        connected: false,
+        lastStopAt: Date.now()
+      });
+    }
+  }
+};
+
+// index.ts
+var plugin = {
+  id: "clawpool",
+  name: "Clawpool OpenClaw",
+  description: "Clawpool channel plugin backed by Aibot Agent API",
+  configSchema: emptyPluginConfigSchema(),
+  register(api) {
+    setAibotRuntime(api.runtime);
+    api.registerChannel({ plugin: aibotPlugin });
+  }
+};
+var index_default = plugin;
+export {
+  index_default as default
+};