@shadowob/openclaw-shadowob 1.1.1 → 1.1.3

package/dist/chunk-PEV3R2R7.js

@@ -0,0 +1,2018 @@
+// src/monitor.ts
+import { ShadowClient as ShadowClient3, ShadowSocket as ShadowSocket2 } from "@shadowob/sdk";
+
+// src/monitor/channel-message.ts
+import { ShadowClient as ShadowClient2 } from "@shadowob/sdk";
+import { createChannelReplyPipeline } from "openclaw/plugin-sdk/channel-reply-pipeline";
+
+// src/mentions.ts
+function isMentionMetadata(value) {
+  return !!value && typeof value === "object";
+}
+function getShadowMessageMentions(message) {
+  const metadata = message.metadata;
+  if (!isMentionMetadata(metadata) || !Array.isArray(metadata.mentions)) return [];
+  return metadata.mentions.filter((mention) => mention && typeof mention.token === "string");
+}
+function mentionTargetsBot(params) {
+  const botUsername = params.botUsername.toLowerCase();
+  return params.mentions.some((mention) => {
+    if (mention.kind !== "user" && mention.kind !== "buddy") return false;
+    if (mention.userId === params.botUserId || mention.targetId === params.botUserId) return true;
+    return mention.username?.toLowerCase() === botUsername;
+  });
+}
+function formatShadowMentionsForAgent(mentions) {
+  if (mentions.length === 0) return "";
+  const lines = mentions.map((mention) => {
+    const label = mention.label || mention.sourceToken || mention.token;
+    if (mention.kind === "channel") {
+      return `- ${label} [channel] channelId=${mention.channelId ?? mention.targetId} serverId=${mention.serverId ?? ""} server=${mention.serverName ?? ""}`;
+    }
+    if (mention.kind === "server") {
+      return `- ${label} [server] serverId=${mention.serverId ?? mention.targetId} slug=${mention.serverSlug ?? ""}`;
+    }
+    if (mention.kind === "user" || mention.kind === "buddy") {
+      return `- ${label} [${mention.kind}] userId=${mention.userId ?? mention.targetId} username=${mention.username ?? ""}`;
+    }
+    return `- ${label} [${mention.kind}] serverId=${mention.serverId ?? mention.targetId}`;
+  });
+  return [
+    "Shadow mentions:",
+    ...lines,
+    "To mention a Shadow entity in a reply, write its visible handle (for example @username or #channel); Shadow will resolve it before delivery."
+  ].join("\n");
+}
+function mentionContextFields(mentions) {
+  if (mentions.length === 0) return {};
+  return {
+    Mentions: mentions,
+    MentionSummary: mentions.map(
+      (mention) => `${mention.label || mention.sourceToken || mention.token} (${mention.kind})`
+    ).join(", "),
+    MentionedUsers: mentions.filter((mention) => mention.kind === "user" || mention.kind === "buddy").map((mention) => ({
+      userId: mention.userId ?? mention.targetId,
+      username: mention.username,
+      displayName: mention.displayName,
+      isBot: mention.isBot
+    })),
+    MentionedChannels: mentions.filter((mention) => mention.kind === "channel").map((mention) => ({
+      channelId: mention.channelId ?? mention.targetId,
+      channelName: mention.channelName,
+      serverId: mention.serverId,
+      serverName: mention.serverName
+    })),
+    MentionedServers: mentions.filter((mention) => mention.kind === "server").map((mention) => ({
+      serverId: mention.serverId ?? mention.targetId,
+      serverSlug: mention.serverSlug,
+      serverName: mention.serverName
+    }))
+  };
+}
+async function resolveOutboundMentions(params) {
+  if (!params.channelId) return void 0;
+  if (!/[@#]|<[@#!][^>\s]+>/u.test(params.content)) return void 0;
+  try {
+    const resolved = await params.client.resolveMentions({
+      channelId: params.channelId,
+      content: params.content
+    });
+    return resolved.mentions.length > 0 ? resolved.mentions : void 0;
+  } catch (err) {
+    params.runtime?.error?.(`[mention] Failed to resolve outbound mentions: ${String(err)}`);
+    return void 0;
+  }
+}
+
+// src/monitor/commerce-context.ts
+function isResolvedId(value) {
+  return Boolean(value && value.trim() && !value.includes("${env:"));
+}
+function listResolvedCommerceOffers(account) {
+  return (account.commerceOffers ?? []).filter((offer) => isResolvedId(offer.offerId));
+}
+function buildCommerceContextForAgent(account) {
+  const offers = listResolvedCommerceOffers(account);
+  if (offers.length === 0) return "";
+  return [
+    "Shadow commerce offers available to this Buddy:",
+    ...offers.map((offer) => {
+      const label = offer.name ?? offer.seedId ?? offer.offerId;
+      const summary = offer.summary ? ` \u2014 ${offer.summary}` : "";
+      const fileHint = offer.fileId ? ` paid file ${offer.fileId}` : "";
+      return `- ${label}${summary}. CommerceOfferId: ${offer.offerId}.${fileHint}`;
+    }),
+    'To sell an offer, use the Shadow message tool with action "send", the current target, a natural sales message, and commerceOfferId set to the CommerceOfferId above.'
+  ].join("\n");
+}
+async function buildCommerceViewerContextForAgent(params) {
+  if (!params.viewerUserId) return "";
+  const offers = listResolvedCommerceOffers(params.account);
+  if (offers.length === 0) return "";
+  const lines = [];
+  const commerceClient = params.client;
+  if (!commerceClient.getCommerceOfferCheckoutPreview) return "";
+  for (const offer of offers) {
+    try {
+      const preview = await commerceClient.getCommerceOfferCheckoutPreview(offer.offerId, {
+        viewerUserId: params.viewerUserId
+      });
+      const label = offer.name ?? offer.seedId ?? offer.offerId;
+      lines.push(
+        `- ${label}: viewerState=${preview.viewerState}; nextAction=${preview.nextAction}.`
+      );
+    } catch {
+    }
+  }
+  if (lines.length === 0) return "";
+  return [
+    "Current viewer commerce state for the user you are speaking with:",
+    ...lines,
+    "If viewerState is active, do not ask them to buy again; help them open or use the unlocked content instead."
+  ].join("\n");
+}
+function commerceContextFields(account) {
+  const offers = listResolvedCommerceOffers(account);
+  if (offers.length === 0) return {};
+  return {
+    CommerceOffers: offers,
+    CommerceOfferIds: offers.map((offer) => offer.offerId).join(",")
+  };
+}
+
+// src/monitor/interactive-response.ts
+async function buildInteractiveResponseContext(params) {
+  const response = params.message.metadata?.interactiveResponse;
+  if (!response?.sourceMessageId) return { text: "", fields: {} };
+  let source = null;
+  try {
+    source = await params.client.getMessage(response.sourceMessageId);
+  } catch (err) {
+    params.runtime.error?.(
+      `[interactive] Failed to load source message ${response.sourceMessageId}: ${String(err)}`
+    );
+  }
+  const sourceInteractive = source?.metadata?.interactive;
+  const sourceSlashCommand = source?.metadata?.slashCommand;
+  const sourceCommandName = sourceSlashCommand && typeof sourceSlashCommand === "object" && !Array.isArray(sourceSlashCommand) ? sourceSlashCommand.name : void 0;
+  const sourceCommand = typeof sourceCommandName === "string" ? params.slashCommands?.find(
+    (command) => command.name.toLowerCase() === sourceCommandName.toLowerCase()
+  ) : void 0;
+  const sourcePrompt = sourceInteractive && typeof sourceInteractive === "object" && !Array.isArray(sourceInteractive) ? sourceInteractive.prompt : void 0;
+  const responsePrompt = sourceInteractive && typeof sourceInteractive === "object" && !Array.isArray(sourceInteractive) ? sourceInteractive.responsePrompt : void 0;
+  const lines = [
+    "Shadow interactive response received.",
+    `Source message: ${source?.content ?? "(unavailable)"}`,
+    typeof sourcePrompt === "string" && sourcePrompt.trim() ? `Source prompt: ${sourcePrompt.trim()}` : "",
+    typeof responsePrompt === "string" && responsePrompt.trim() ? `Follow-up instruction: ${responsePrompt.trim()}` : "",
+    sourceCommand?.body ? `Source slash command definition:
+${sourceCommand.body}` : "",
+    `Action: ${response.actionId ?? "(unknown)"}`,
+    response.values ? `Submitted values:
+${JSON.stringify(response.values, null, 2)}` : ""
+  ].filter(Boolean);
+  return {
+    text: lines.join("\n\n"),
+    fields: {
+      InteractiveResponse: response,
+      ...source ? { InteractiveSourceMessage: source.content } : {},
+      ...sourceInteractive ? { InteractiveSourceBlock: sourceInteractive } : {},
+      ...sourceCommand ? { InteractiveSourceSlashCommand: sourceCommand } : {}
+    }
+  };
+}
+
+// src/monitor/media.ts
+import nodeCrypto from "crypto";
+import fsPromises from "fs/promises";
+import nodePath2 from "path";
+import { ShadowClient } from "@shadowob/sdk";
+
+// src/monitor/paths.ts
+import nodeOs from "os";
+import nodePath from "path";
+async function getDataDir() {
+  const dataDir = process.env.OPENCLAW_DATA_DIR;
+  return dataDir || nodePath.join(nodeOs.homedir(), ".openclaw");
+}
+
+// src/monitor/media.ts
+function isShadowResolvableMediaUrl(url) {
+  if (url.startsWith("/")) {
+    return url.includes("/uploads/") || url.startsWith("/api/media/signed/");
+  }
+  return url.startsWith("http");
+}
+function inferMimeType(filename, headerType) {
+  const ext = filename.split(".").pop()?.toLowerCase() ?? "";
+  const map = {
+    jpg: "image/jpeg",
+    jpeg: "image/jpeg",
+    png: "image/png",
+    gif: "image/gif",
+    webp: "image/webp",
+    svg: "image/svg+xml",
+    mp4: "video/mp4",
+    webm: "video/webm",
+    mp3: "audio/mpeg",
+    wav: "audio/wav",
+    ogg: "audio/ogg",
+    pdf: "application/pdf"
+  };
+  return map[ext] ?? headerType ?? "application/octet-stream";
+}
+async function resolveShadowInboundMediaContext(params) {
+  const { account, message, rawBody, runtime } = params;
+  const attachmentUrls = (message.attachments ?? []).map((a) => a.url).filter(Boolean);
+  const markdownMediaRegex = /!?\[[^\]]*\]\(([^)]+)\)/g;
+  const markdownUrls = [];
+  for (const mdMatch of rawBody.matchAll(markdownMediaRegex)) {
+    const url = mdMatch[1];
+    if (isShadowResolvableMediaUrl(url)) {
+      markdownUrls.push(url);
+    }
+  }
+  const allRawUrls = [.../* @__PURE__ */ new Set([...attachmentUrls, ...markdownUrls])];
+  if (allRawUrls.length === 0) {
+    return { cleanBody: rawBody, fields: {} };
+  }
+  const mediaClient = new ShadowClient(account.serverUrl, account.token);
+  const dataDir = await getDataDir();
+  const mediaDir = nodePath2.join(dataDir, "media", "inbound");
+  await fsPromises.mkdir(mediaDir, { recursive: true });
+  const localMediaPaths = [];
+  const localMediaTypes = [];
+  const resolvedMediaUrls = [];
+  for (const rawUrl of allRawUrls) {
+    try {
+      const downloaded = await mediaClient.downloadFile(rawUrl);
+      const uuid = nodeCrypto.randomUUID();
+      const ext = nodePath2.extname(downloaded.filename) || ".bin";
+      const safeBase = downloaded.filename.replace(/[^a-zA-Z0-9._\u4e00-\u9fff-]/g, "_").slice(0, 100);
+      const localFilename = `${safeBase}---${uuid}${ext.startsWith(".") ? "" : "."}${ext}`;
+      const localPath = nodePath2.join(mediaDir, localFilename);
+      await fsPromises.writeFile(localPath, new Uint8Array(downloaded.buffer));
+      localMediaPaths.push(localPath);
+      localMediaTypes.push(inferMimeType(downloaded.filename, downloaded.contentType));
+      const baseUrl = account.serverUrl.replace(/\/$/, "");
+      resolvedMediaUrls.push(rawUrl.startsWith("/") ? `${baseUrl}${rawUrl}` : rawUrl);
+      runtime.log?.(
+        `[media] Downloaded ${rawUrl} \u2192 ${localPath} (${downloaded.buffer.byteLength} bytes)`
+      );
+    } catch (err) {
+      runtime.error?.(`[media] Failed to download ${rawUrl}: ${String(err)}`);
+    }
+  }
+  if (localMediaPaths.length === 0) {
+    return { cleanBody: rawBody, fields: {} };
+  }
+  const cleanBody = rawBody.replace(/!?\[[^\]]*\]\((?:[^)]*\/uploads\/[^)]+|[^)]*\/api\/media\/signed\/[^)]+)\)/g, "").replace(/\n{2,}/g, "\n").trim() || "[Media attached]";
+  return {
+    cleanBody,
+    fields: {
+      MediaPath: localMediaPaths[0],
+      MediaPaths: localMediaPaths,
+      MediaUrl: resolvedMediaUrls[0],
+      MediaUrls: resolvedMediaUrls,
+      MediaType: localMediaTypes[0],
+      MediaTypes: localMediaTypes
+    }
+  };
+}
+
+// src/monitor/preflight.ts
+function escapeRegex(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function evaluateShadowMessagePreflight(params) {
+  const { message, botUserId, botUsername, channelPolicies, runtime } = params;
+  const senderLabel = message.author?.username ?? message.authorId;
+  if (message.authorId === botUserId) {
+    return { ok: false, reason: `[msg] Skipping own message ${message.id}` };
+  }
+  const policy = channelPolicies.get(message.channelId);
+  const policyConfig = policy?.config;
+  const structuredMentions = getShadowMessageMentions(message);
+  let isProcessingBuddyMessage = false;
+  if (message.author?.isBot) {
+    if (!policyConfig?.replyToBuddy) {
+      return {
+        ok: false,
+        reason: `[msg] Skipping bot message from ${senderLabel} (replyToBuddy=false) (${message.id})`
+      };
+    }
+    const maxDepth = policyConfig.maxBuddyChainDepth ?? 3;
+    const chainMeta = message.metadata?.agentChain;
+    if (chainMeta) {
+      if (chainMeta.depth >= maxDepth) {
+        return {
+          ok: false,
+          reason: `[msg] Buddy chain depth ${chainMeta.depth} >= max ${maxDepth}, stopping loop (${message.id})`
+        };
+      }
+      if (chainMeta.participants?.includes(botUserId)) {
+        return {
+          ok: false,
+          reason: `[msg] Already in buddy chain [${chainMeta.participants.join(", ")}], skipping to prevent loop (${message.id})`
+        };
+      }
+      const senderAgentId = message.author?.id;
+      if (senderAgentId && policyConfig.buddyBlacklist?.includes(senderAgentId)) {
+        return {
+          ok: false,
+          reason: `[msg] Sender agent ${senderAgentId} is in blacklist, skipping (${message.id})`
+        };
+      }
+      if (senderAgentId && policyConfig.buddyWhitelist?.length && !policyConfig.buddyWhitelist.includes(senderAgentId)) {
+        return {
+          ok: false,
+          reason: `[msg] Sender agent ${senderAgentId} not in whitelist, skipping (${message.id})`
+        };
+      }
+    }
+    isProcessingBuddyMessage = true;
+    runtime.log?.(
+      `[msg] Processing bot message from ${senderLabel} (replyToBuddy=true) (${message.id})`
+    );
+  }
+  if (policy && !policy.listen) {
+    return {
+      ok: false,
+      reason: `[msg] Policy blocks listen for channel ${message.channelId}, skipping`
+    };
+  }
+  if (policy && !policy.reply) {
+    return {
+      ok: false,
+      reason: `[msg] Policy blocks reply for channel ${message.channelId}, skipping (${message.id})`
+    };
+  }
+  let wasMentionedExplicitly = false;
+  if (policy?.mentionOnly) {
+    const mentionRegex = new RegExp(`@${escapeRegex(botUsername)}(?:\\s|$)`, "i");
+    wasMentionedExplicitly = mentionTargetsBot({ mentions: structuredMentions, botUserId, botUsername }) || mentionRegex.test(message.content);
+    if (!wasMentionedExplicitly) {
+      return {
+        ok: false,
+        reason: `[msg] mentionOnly policy \u2014 no @${botUsername} mention found, skipping (${message.id})`
+      };
+    }
+    runtime.log?.(
+      `[msg] mentionOnly policy \u2014 @${botUsername} mentioned, processing (${message.id})`
+    );
+  }
+  if (policyConfig?.replyToUsers?.length) {
+    const allowedUsers = policyConfig.replyToUsers.map((u) => u.toLowerCase());
+    const senderUser = (message.author?.username ?? "").toLowerCase();
+    if (!allowedUsers.includes(senderUser)) {
+      return {
+        ok: false,
+        reason: `[msg] replyToUsers policy \u2014 sender "${senderUser}" not in allowed list, skipping (${message.id})`
+      };
+    }
+  }
+  if (policyConfig?.keywords?.length) {
+    const lowerContent = message.content.toLowerCase();
+    const matched = policyConfig.keywords.some((kw) => lowerContent.includes(kw.toLowerCase()));
+    if (!matched) {
+      return {
+        ok: false,
+        reason: `[msg] keywords policy \u2014 no matching keyword found, skipping (${message.id})`
+      };
+    }
+    runtime.log?.(`[msg] keywords policy \u2014 keyword matched, processing (${message.id})`);
+  }
+  const smartReplyEnabled = policyConfig?.smartReply !== false;
+  if (smartReplyEnabled && !isProcessingBuddyMessage && !wasMentionedExplicitly) {
+    const mentionPattern = /@([a-zA-Z0-9_\-\u4e00-\u9fa5]+)/g;
+    const userMentions = structuredMentions.filter(
+      (mention) => mention.kind === "user" || mention.kind === "buddy"
+    );
+    const allMentions = structuredMentions.length > 0 ? [] : message.content.match(mentionPattern) || [];
+    const structuredSelfMentioned = mentionTargetsBot({
+      mentions: userMentions,
+      botUserId,
+      botUsername
+    });
+    if (userMentions.length > 0 && !structuredSelfMentioned) {
+      return {
+        ok: false,
+        reason: `[msg] Smart reply: message mentions other users but not @${botUsername}, skipping (${message.id})`
+      };
+    }
+    const mentionsWithoutSelf = userMentions.length > 0 ? [] : allMentions.filter((m) => {
+      const mentionedUser = m.slice(1).toLowerCase();
+      return mentionedUser !== botUsername.toLowerCase();
+    });
+    if (userMentions.length === 0 && allMentions.length > 0 && mentionsWithoutSelf.length === allMentions.length) {
+      return {
+        ok: false,
+        reason: `[msg] Smart reply: message @mentions others (${allMentions.join(", ")}) but not @${botUsername}, skipping (${message.id})`
+      };
+    }
+    const replyToData = message.replyTo;
+    if (replyToData?.authorId && replyToData.authorId !== botUserId) {
+      const selfMentioned = allMentions.some((m) => {
+        const mentionedUser = m.slice(1).toLowerCase();
+        return mentionedUser === botUsername.toLowerCase();
+      }) || structuredSelfMentioned;
+      if (!selfMentioned) {
+        return {
+          ok: false,
+          reason: `[msg] Smart reply: message is a reply to another user (${replyToData.authorId}), not this Buddy, skipping (${message.id})`
+        };
+      }
+    }
+  }
+  return {
+    ok: true,
+    senderLabel,
+    policy,
+    policyConfig,
+    isProcessingBuddyMessage,
+    wasMentionedExplicitly
+  };
+}
+
+// src/monitor/reply-delivery.ts
+import { randomUUID } from "crypto";
+var DELIVERY_RETRY_DELAYS_MS = [500, 1e3, 2e3];
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function isRetryableDeliveryError(err) {
+  const message = String(err);
+  return message.includes("fetch failed") || message.includes("ECONNRESET") || message.includes("ETIMEDOUT") || message.includes("AbortError") || /failed \((408|429|5\d\d)\)/.test(message);
+}
+function replyMetadata(params) {
+  return {
+    ...params.agentChain ? { agentChain: params.agentChain } : {},
+    shadowDelivery: {
+      id: params.deliveryId,
+      source: "openclaw-shadowob",
+      replyToId: params.replyToId
+    }
+  };
+}
+function messageDeliveryId(message) {
+  const metadata = message.metadata;
+  if (!metadata || typeof metadata !== "object") return null;
+  const delivery = metadata.shadowDelivery;
+  if (!delivery || typeof delivery !== "object") return null;
+  const id = delivery.id;
+  return typeof id === "string" ? id : null;
+}
+async function findDeliveredChannelMessage(params) {
+  const messages = (await params.client.getMessages(params.channelId, 20)).messages;
+  return messages.find((message) => messageDeliveryId(message) === params.deliveryId) ?? null;
+}
+async function withDeliveryRetry(params) {
+  for (let attempt = 0; attempt <= DELIVERY_RETRY_DELAYS_MS.length; attempt++) {
+    try {
+      return await params.operation();
+    } catch (err) {
+      const recovered = await params.recover?.().catch((recoverErr) => {
+        params.runtime.error?.(
+          `[${params.label}] Delivery recovery check failed: ${String(recoverErr)}`
+        );
+        return null;
+      });
+      if (recovered) {
+        params.runtime.log?.(`[${params.label}] Recovered delivered message after retryable error`);
+        return recovered;
+      }
+      const delay3 = DELIVERY_RETRY_DELAYS_MS[attempt];
+      if (!delay3 || !isRetryableDeliveryError(err)) throw err;
+      params.runtime.error?.(
+        `[${params.label}] Delivery attempt ${attempt + 1} failed: ${String(err)}; retrying in ${delay3}ms`
+      );
+      await sleep(delay3);
+    }
+  }
+  throw new Error(`[${params.label}] Delivery retry exhausted`);
+}
+async function deliverShadowReply(params) {
+  const { payload, channelId, replyToId, client, runtime, agentChain, agentId, botUserId } = params;
+  try {
+    if (!payload.text && !(payload.mediaUrl || payload.mediaUrls?.length)) {
+      runtime.error?.("[reply] No text or media in reply payload");
+      return;
+    }
+    const text = payload.text ?? "";
+    runtime.log?.(`[reply] Sending reply to channel ${channelId}: "${text.slice(0, 80)}"`);
+    const mediaUrls = [payload.mediaUrl, ...payload.mediaUrls ?? []].filter(Boolean);
+    const newAgentChain = agentId ? {
+      agentId,
+      depth: (agentChain?.depth ?? 0) + 1,
+      participants: [...agentChain?.participants ?? [], botUserId].filter(
+        Boolean
+      ),
+      startedAt: agentChain?.startedAt ?? Date.now(),
+      rootMessageId: agentChain?.rootMessageId ?? replyToId
+    } : void 0;
+    let sentMessage = null;
+    if (text || mediaUrls.length > 0) {
+      const contentToSend = text || "\u200B";
+      const deliveryId = randomUUID();
+      const metadata = replyMetadata({
+        deliveryId,
+        agentChain: newAgentChain,
+        replyToId
+      });
+      const mentions = await resolveOutboundMentions({
+        client,
+        channelId,
+        content: contentToSend,
+        runtime
+      });
+      sentMessage = await withDeliveryRetry({
+        label: "reply",
+        runtime,
+        operation: () => client.sendMessage(channelId, contentToSend, {
+          replyToId,
+          metadata,
+          ...mentions ? { mentions } : {}
+        }),
+        recover: () => findDeliveredChannelMessage({ client, channelId, deliveryId })
+      });
+      runtime.log?.(
+        `[reply] Message created (${sentMessage.id})${text ? "" : " [media-only placeholder]"}${newAgentChain ? ` [chain depth: ${newAgentChain.depth}]` : ""}`
+      );
+    }
+    if (mediaUrls.length > 0) {
+      const messageId = sentMessage?.id;
+      let fallbackReplyToId = sentMessage?.id ?? replyToId;
+      for (const mediaUrl of mediaUrls) {
+        runtime.log?.(`[reply] Uploading media: ${mediaUrl}`);
+        try {
+          await withDeliveryRetry({
+            label: "reply-media",
+            runtime,
+            operation: () => client.uploadMediaFromUrl(mediaUrl, messageId)
+          });
+          runtime.log?.("[reply] Media uploaded successfully");
+        } catch (err) {
+          runtime.error?.(
+            `[reply] Media upload failed for ${mediaUrl}; sending URL fallback: ${String(err)}`
+          );
+          const deliveryId = randomUUID();
+          const metadata = replyMetadata({
+            deliveryId,
+            agentChain: newAgentChain,
+            replyToId: fallbackReplyToId
+          });
+          const mentions = await resolveOutboundMentions({
+            client,
+            channelId,
+            content: mediaUrl,
+            runtime
+          });
+          const fallbackMessage = await withDeliveryRetry({
+            label: "reply-media-fallback",
+            runtime,
+            operation: () => client.sendMessage(channelId, mediaUrl, {
+              replyToId: fallbackReplyToId,
+              metadata,
+              ...mentions ? { mentions } : {}
+            }),
+            recover: () => findDeliveredChannelMessage({ client, channelId, deliveryId })
+          });
+          fallbackReplyToId = fallbackMessage.id;
+        }
+      }
+    }
+    runtime.log?.("[reply] Reply delivered successfully");
+  } catch (err) {
+    runtime.error?.(`[reply] Failed to send reply: ${String(err)}`);
+    throw err;
+  }
+}
+
+// src/monitor/session.ts
+function resolveSessionStore(cfg) {
+  const raw = cfg.session?.store;
+  if (typeof raw === "string") return raw;
+  if (raw && typeof raw === "object") {
+    const pathValue = raw.path;
+    if (typeof pathValue === "string") return pathValue;
+  }
+  return void 0;
+}
+
+// src/monitor/slash-commands.ts
+import fsPromises2 from "fs/promises";
+var SLASH_COMMAND_RE = /^\/([a-zA-Z][a-zA-Z0-9._-]{0,63})(?:\s+([\s\S]*))?$/;
+function normalizeSlashCommandName(value) {
+  if (typeof value !== "string") return null;
+  const name = value.trim().replace(/^\/+/, "");
+  return /^[a-zA-Z][a-zA-Z0-9._-]{0,63}$/.test(name) ? name : null;
+}
+function isRecord(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function readString(value, max = 2e3) {
+  return typeof value === "string" && value.trim() ? value.trim().slice(0, max) : void 0;
+}
+function normalizeInteractionItems(value, max) {
+  if (!Array.isArray(value)) return void 0;
+  const items = value.filter(isRecord).map((item, index) => {
+    const label = readString(item.label, 120) ?? readString(item.value, 120) ?? `Option ${index + 1}`;
+    const id = readString(item.id, 80) ?? readString(item.value, 80) ?? label;
+    const itemValue = readString(item.value, 2048);
+    const rawStyle = readString(item.style, 40);
+    const style = rawStyle === "primary" || rawStyle === "secondary" || rawStyle === "destructive" ? rawStyle : void 0;
+    return {
+      id,
+      label,
+      ...itemValue ? { value: itemValue } : {},
+      ...style ? { style } : {}
+    };
+  }).filter((item) => item.id && item.label);
+  return items.length > 0 ? items.slice(0, max) : void 0;
+}
+function normalizeSlashInteraction(value) {
+  if (!isRecord(value)) return void 0;
+  const kind = readString(value.kind, 20);
+  if (kind !== "buttons" && kind !== "select" && kind !== "form" && kind !== "approval") {
+    return void 0;
+  }
+  const interaction = { kind };
+  const id = readString(value.id, 120);
+  const prompt = readString(value.prompt);
+  const submitLabel = readString(value.submitLabel, 40);
+  const responsePrompt = readString(value.responsePrompt);
+  const approvalCommentLabel = readString(value.approvalCommentLabel, 120);
+  if (id) interaction.id = id;
+  if (prompt) interaction.prompt = prompt;
+  if (submitLabel) interaction.submitLabel = submitLabel;
+  if (responsePrompt) interaction.responsePrompt = responsePrompt;
+  if (approvalCommentLabel) interaction.approvalCommentLabel = approvalCommentLabel;
+  if (typeof value.oneShot === "boolean") interaction.oneShot = value.oneShot;
+  const buttons = normalizeInteractionItems(value.buttons, 8);
+  const options = normalizeInteractionItems(value.options, 20)?.map((option) => ({
+    id: option.id,
+    label: option.label,
+    value: option.value ?? option.id
+  }));
+  if (buttons) interaction.buttons = buttons;
+  if (options) interaction.options = options;
+  if (Array.isArray(value.fields)) {
+    const fields = value.fields.filter(isRecord).flatMap((field, index) => {
+      const fieldKind = readString(field.kind, 20) ?? readString(field.type, 20) ?? "text";
+      if (!["text", "textarea", "number", "checkbox", "select"].includes(fieldKind)) return [];
+      const normalizedField = {
+        id: readString(field.id, 80) ?? readString(field.name, 80) ?? `field_${index + 1}`,
+        kind: fieldKind,
+        label: readString(field.label, 120) ?? readString(field.name, 120) ?? `Field ${index + 1}`,
+        ...readString(field.placeholder, 200) ? { placeholder: readString(field.placeholder, 200) } : {},
+        ...readString(field.defaultValue, 2048) ? { defaultValue: readString(field.defaultValue, 2048) } : {},
+        ...typeof field.required === "boolean" ? { required: field.required } : {},
+        ...typeof field.maxLength === "number" ? { maxLength: field.maxLength } : {},
+        ...typeof field.min === "number" ? { min: field.min } : {},
+        ...typeof field.max === "number" ? { max: field.max } : {}
+      };
+      const fieldOptions = normalizeInteractionItems(field.options, 20)?.map((option) => ({
+        id: option.id,
+        label: option.label,
+        value: option.value ?? option.id
+      }));
+      return [{ ...normalizedField, ...fieldOptions ? { options: fieldOptions } : {} }];
+    });
+    if (fields.length > 0) interaction.fields = fields.slice(0, 12);
+  }
+  return interaction;
+}
+function normalizeShadowSlashCommands(input) {
+  if (!Array.isArray(input)) return [];
+  const seen = /* @__PURE__ */ new Set();
+  const commands = [];
+  for (const item of input) {
+    if (!item || typeof item !== "object" || Array.isArray(item)) continue;
+    const record = item;
+    const name = normalizeSlashCommandName(record.name);
+    if (!name) continue;
+    const key = name.toLowerCase();
+    if (seen.has(key)) continue;
+    seen.add(key);
+    const aliases = Array.isArray(record.aliases) ? [
+      ...new Set(
+        record.aliases.map(normalizeSlashCommandName).filter((alias) => Boolean(alias))
+      )
+    ].filter((alias) => alias.toLowerCase() !== key) : void 0;
+    const interaction = normalizeSlashInteraction(record.interaction);
+    commands.push({
+      name,
+      ...typeof record.description === "string" && record.description.trim() ? { description: record.description.trim().slice(0, 240) } : {},
+      ...aliases && aliases.length > 0 ? { aliases } : {},
+      ...typeof record.packId === "string" && record.packId.trim() ? { packId: record.packId.trim().slice(0, 80) } : {},
+      ...typeof record.sourcePath === "string" && record.sourcePath.trim() ? { sourcePath: record.sourcePath.trim().slice(0, 500) } : {},
+      ...typeof record.body === "string" && record.body.trim() ? { body: record.body.trim().slice(0, 2e4) } : {},
+      ...interaction ? { interaction } : {}
+    });
+  }
+  return commands.slice(0, 200);
+}
+function toPublicSlashCommands(commands) {
+  return commands.map(({ body: _body, ...command }) => command);
+}
+async function loadLocalSlashCommands(runtime) {
+  const indexPath = process.env.SHADOW_SLASH_COMMANDS_PATH;
+  if (!indexPath) return [];
+  try {
+    const raw = await fsPromises2.readFile(indexPath, "utf-8");
+    const commands = normalizeShadowSlashCommands(JSON.parse(raw));
+    runtime.log?.(`[slash] Loaded ${commands.length} command(s) from ${indexPath}`);
+    return commands;
+  } catch (err) {
+    runtime.error?.(`[slash] Failed to load command index: ${String(err)}`);
+    return [];
+  }
+}
+async function registerAgentSlashCommands(params) {
+  const baseUrl = params.account.serverUrl.replace(/\/api\/?$/, "").replace(/\/$/, "");
+  const response = await fetch(`${baseUrl}/api/agents/${params.agentId}/slash-commands`, {
+    method: "PUT",
+    headers: {
+      Authorization: `Bearer ${params.account.token}`,
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({ commands: toPublicSlashCommands(params.commands) })
+  });
+  if (!response.ok) {
+    const errorText = await response.text().catch(() => "");
+    throw new Error(`Shadow slash command registry failed (${response.status}): ${errorText}`);
+  }
+}
+function matchShadowSlashCommand(content, commands) {
+  const match = content.trim().match(SLASH_COMMAND_RE);
+  if (!match) return null;
+  const invokedName = match[1];
+  const args = match[2]?.trim() ?? "";
+  const invokedKey = invokedName.toLowerCase();
+  const command = commands.find((candidate) => {
+    if (candidate.name.toLowerCase() === invokedKey) return true;
+    return (candidate.aliases ?? []).some((alias) => alias.toLowerCase() === invokedKey);
+  });
+  return command ? { command, invokedName, args } : null;
+}
+function formatSlashCommandPrompt(originalBody, match) {
+  const chunks = [
+    `Slash command /${match.command.name} was invoked.`,
+    match.command.description ? `Description: ${match.command.description}` : "",
+    match.command.packId ? `Pack: ${match.command.packId}` : "",
+    `Arguments:
+${match.args || "(none)"}`,
+    match.command.body ? `Command definition:
+${match.command.body}` : "",
+    `Original message:
+${originalBody}`
+  ].filter(Boolean);
+  return chunks.join("\n\n");
+}
+function buildAgentChainMetadata(params) {
+  if (!params.agentId) return void 0;
+  return {
+    agentId: params.agentId,
+    depth: (params.prior?.depth ?? 0) + 1,
+    participants: [...params.prior?.participants ?? [], params.botUserId].filter(Boolean),
+    startedAt: params.prior?.startedAt ?? Date.now(),
+    rootMessageId: params.prior?.rootMessageId ?? params.rootMessageId
+  };
+}
+function buildSlashCommandInteractiveBlock(match, messageId) {
+  const interaction = match.command.interaction;
+  if (!interaction) return void 0;
+  return {
+    ...interaction,
+    id: interaction.id && interaction.id.trim() ? `${interaction.id}:${messageId}` : `slash:${match.command.packId ?? "pack"}:${match.command.name}:${messageId}`
+  };
+}
+async function sendSlashCommandInteractivePrompt(params) {
+  const block = buildSlashCommandInteractiveBlock(params.match, params.messageId);
+  if (!block) return false;
+  const content = block.prompt ?? `/${params.match.command.name} needs input before the Buddy can continue.`;
+  const agentChain = buildAgentChainMetadata({
+    agentId: params.agentId,
+    botUserId: params.botUserId,
+    rootMessageId: params.messageId,
+    prior: params.agentChain
+  });
+  await params.client.sendMessage(params.channelId, content, {
+    replyToId: params.messageId,
+    threadId: params.threadId,
+    metadata: {
+      ...agentChain ? { agentChain } : {},
+      interactive: block,
+      slashCommand: {
+        name: params.match.command.name,
+        invokedName: params.match.invokedName,
+        args: params.match.args,
+        packId: params.match.command.packId
+      }
+    }
+  });
+  params.runtime.log?.(
+    `[slash] Sent interactive prompt for /${params.match.command.name} (${block.kind})`
+  );
+  return true;
+}
+
+// src/monitor/thread-bindings.ts
+import fsPromises4 from "fs/promises";
+import nodePath4 from "path";
+
+// src/monitor/state.ts
+import fsPromises3 from "fs/promises";
+import nodePath3 from "path";
+async function getSessionCachePath(accountId) {
+  const dataDir = await getDataDir();
+  return nodePath3.join(dataDir, "shadow", `session-cache-${accountId}.json`);
+}
+function safeCacheKey(value) {
+  return value.replace(/[^a-zA-Z0-9._-]/g, "_");
+}
+async function saveSessionCache(accountId, data) {
+  try {
+    const cachePath = await getSessionCachePath(accountId);
+    await fsPromises3.mkdir(nodePath3.dirname(cachePath), { recursive: true });
+    await fsPromises3.writeFile(cachePath, JSON.stringify(data), "utf-8");
+  } catch {
+  }
+}
+async function loadSessionCache(accountId) {
+  try {
+    const cachePath = await getSessionCachePath(accountId);
+    const raw = await fsPromises3.readFile(cachePath, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+async function getMessageWatermarksPath(accountId) {
+  const dataDir = await getDataDir();
+  return nodePath3.join(dataDir, "shadow", `message-watermarks-${safeCacheKey(accountId)}.json`);
+}
+async function loadMessageWatermarks(accountId) {
+  try {
+    const raw = await fsPromises3.readFile(await getMessageWatermarksPath(accountId), "utf-8");
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return {};
+    const watermarks = {};
+    for (const [channelId, value] of Object.entries(parsed)) {
+      if (!value || typeof value !== "object" || Array.isArray(value)) continue;
+      const record = value;
+      if (typeof record.createdAt !== "string" || !Number.isFinite(Date.parse(record.createdAt))) {
+        continue;
+      }
+      watermarks[channelId] = {
+        createdAt: record.createdAt,
+        ...typeof record.messageId === "string" ? { messageId: record.messageId } : {}
+      };
+    }
+    return watermarks;
+  } catch {
+    return {};
+  }
+}
+async function saveMessageWatermarks(accountId, watermarks) {
+  try {
+    const cachePath = await getMessageWatermarksPath(accountId);
+    await fsPromises3.mkdir(nodePath3.dirname(cachePath), { recursive: true });
+    await fsPromises3.writeFile(cachePath, JSON.stringify(watermarks), "utf-8");
+  } catch {
+  }
+}
+function getMessageCreatedMs(message) {
+  const createdMs = Date.parse(message.createdAt);
+  return Number.isFinite(createdMs) ? createdMs : null;
+}
+function updateMessageWatermark(watermarks, message) {
+  const createdMs = getMessageCreatedMs(message);
+  if (createdMs === null) return false;
+  const current = watermarks[message.channelId];
+  const currentMs = current ? Date.parse(current.createdAt) : Number.NaN;
+  if (Number.isFinite(currentMs) && createdMs < currentMs) return false;
+  if (current?.messageId === message.id && current.createdAt === message.createdAt) return false;
+  watermarks[message.channelId] = { createdAt: message.createdAt, messageId: message.id };
+  return true;
+}
+async function appendMonitorLog(accountId, level, message) {
+  try {
+    const dataDir = await getDataDir();
+    const logDir = nodePath3.join(dataDir, "shadow");
+    await fsPromises3.mkdir(logDir, { recursive: true });
+    const line = JSON.stringify({
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      level,
+      message
+    });
+    await fsPromises3.appendFile(
+      nodePath3.join(logDir, `monitor-${safeCacheKey(accountId)}.log`),
+      `${line}
+`,
+      "utf-8"
+    );
+  } catch {
+  }
+}
+
+// src/monitor/thread-bindings.ts
+async function getThreadBindingPath(accountId) {
+  const dataDir = await getDataDir();
+  return nodePath4.join(dataDir, "shadow", `thread-bindings-${safeCacheKey(accountId)}.json`);
+}
+async function loadShadowThreadBindings(accountId) {
+  try {
+    const raw = await fsPromises4.readFile(await getThreadBindingPath(accountId), "utf-8");
+    const parsed = JSON.parse(raw);
+    if (!Array.isArray(parsed.bindings)) return [];
+    return parsed.bindings.filter((binding) => {
+      return typeof binding.accountId === "string" && typeof binding.agentId === "string" && typeof binding.sessionKey === "string" && typeof binding.channelId === "string" && typeof binding.updatedAt === "string";
+    });
+  } catch {
+    return [];
+  }
+}
+async function saveShadowThreadBindings(accountId, bindings) {
+  const path = await getThreadBindingPath(accountId);
+  await fsPromises4.mkdir(nodePath4.dirname(path), { recursive: true });
+  await fsPromises4.writeFile(path, `${JSON.stringify({ bindings }, null, 2)}
+`, "utf-8");
+}
+async function upsertShadowThreadBinding(params) {
+  const bindings = await loadShadowThreadBindings(params.accountId);
+  const key = `${params.agentId}:${params.sessionKey}`;
+  const next = {
+    accountId: params.accountId,
+    agentId: params.agentId,
+    sessionKey: params.sessionKey,
+    channelId: params.channelId,
+    ...params.threadId ? { threadId: params.threadId } : {},
+    ...params.messageId ? { messageId: params.messageId } : {},
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  const filtered = bindings.filter((binding) => `${binding.agentId}:${binding.sessionKey}` !== key);
+  const recent = [next, ...filtered].slice(0, 500);
+  await saveShadowThreadBindings(params.accountId, recent);
+  return next;
+}
+
+// src/monitor/typing.ts
+import {
+  createTypingCallbacks
+} from "openclaw/plugin-sdk/channel-reply-pipeline";
+
+// src/monitor/usage-reporting.ts
+import { readdir, readFile, stat } from "fs/promises";
+import { homedir } from "os";
+import { join } from "path";
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function isSafeOpenClawAgentId(agentId) {
+  return !agentId.includes("/") && !agentId.includes("\\") && !agentId.includes("..");
+}
+function stateDir() {
+  return process.env.OPENCLAW_STATE_DIR ?? join(homedir(), ".openclaw");
+}
+function asRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function asString(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+function asNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function parseLine(line) {
+  try {
+    return asRecord(JSON.parse(line));
+  } catch {
+    return null;
+  }
+}
+function readUsageNumber(usage, keys) {
+  for (const key of keys) {
+    const value = asNumber(usage[key]);
+    if (value !== null) return Math.round(value);
+  }
+  return null;
+}
+function artifactFromLine(line, sessionKey) {
+  if (line.type !== "trace.artifacts" || line.sessionKey !== sessionKey) return null;
+  const data = asRecord(line.data);
+  const usage = asRecord(data?.usage);
+  if (!usage) return null;
+  const sessionId = asString(line.sessionId);
+  const generatedAt = asString(line.ts) ?? asString(data?.capturedAt);
+  const provider = asString(line.provider) ?? "openclaw";
+  if (!sessionId || !generatedAt) return null;
+  return {
+    sessionId,
+    sessionKey,
+    runId: asString(line.runId),
+    generatedAt,
+    provider,
+    model: asString(line.modelId),
+    modelApi: asString(line.modelApi),
+    inputTokens: readUsageNumber(usage, ["input", "inputTokens", "promptTokens"]),
+    outputTokens: readUsageNumber(usage, ["output", "outputTokens", "completionTokens"]),
+    cacheReadTokens: readUsageNumber(usage, ["cacheRead", "cacheReadTokens"]),
+    cacheWriteTokens: readUsageNumber(usage, ["cacheWrite", "cacheWriteTokens"]),
+    totalTokens: readUsageNumber(usage, ["total", "totalTokens", "total_tokens"])
+  };
+}
+async function listTrajectoryFiles(openClawAgentId) {
+  if (!isSafeOpenClawAgentId(openClawAgentId)) return [];
+  const sessionsDir = join(stateDir(), "agents", openClawAgentId, "sessions");
+  const entries = await readdir(sessionsDir, { withFileTypes: true }).catch(() => []);
+  const files = entries.filter((entry) => entry.isFile() && entry.name.endsWith(".trajectory.jsonl")).map((entry) => join(sessionsDir, entry.name));
+  const withStats = await Promise.all(
+    files.map(async (file) => ({
+      file,
+      mtimeMs: (await stat(file).catch(() => null))?.mtimeMs ?? 0
+    }))
+  );
+  return withStats.sort((left, right) => right.mtimeMs - left.mtimeMs).slice(0, 8).map((entry) => entry.file);
+}
+async function readLatestArtifact(params) {
+  const files = await listTrajectoryFiles(params.openClawAgentId);
+  for (const file of files) {
+    const text = await readFile(file, "utf8").catch(() => "");
+    if (!text) continue;
+    const lines = text.split("\n").filter(Boolean);
+    for (let index = lines.length - 1; index >= 0; index -= 1) {
+      const line = parseLine(lines[index]);
+      if (!line) continue;
+      const artifact = artifactFromLine(line, params.sessionKey);
+      if (!artifact) continue;
+      if (Date.parse(artifact.generatedAt) + 1e3 < params.sinceMs) continue;
+      return artifact;
+    }
+  }
+  return null;
+}
+function costFromAssistantMessage(message) {
+  const usage = asRecord(message.usage);
+  const cost = asRecord(usage?.cost);
+  return asNumber(cost?.total);
+}
+async function readAssistantCosts(openClawAgentId, sessionId) {
+  if (!isSafeOpenClawAgentId(openClawAgentId)) return { totalUsd: null };
+  const sessionFile = join(stateDir(), "agents", openClawAgentId, "sessions", `${sessionId}.jsonl`);
+  const text = await readFile(sessionFile, "utf8").catch(() => "");
+  if (!text) return { totalUsd: null };
+  let totalUsd = 0;
+  let foundCost = false;
+  let sawAssistant = false;
+  const lines = text.split("\n").filter(Boolean);
+  for (let index = lines.length - 1; index >= 0; index -= 1) {
+    const line = parseLine(lines[index]);
+    const message = asRecord(line?.message);
+    if (!message) continue;
+    const role = message?.role;
+    if (role === "user" && sawAssistant) break;
+    if (role !== "assistant") continue;
+    sawAssistant = true;
+    const cost = costFromAssistantMessage(message);
+    if (cost === null) continue;
+    foundCost = true;
+    totalUsd += cost;
+  }
+  return { totalUsd: foundCost ? totalUsd : null };
+}
+function buildSnapshot(artifact, costs) {
+  return {
+    source: "openclaw-trajectory",
+    model: artifact.model,
+    totalUsd: costs.totalUsd,
+    inputTokens: artifact.inputTokens,
+    outputTokens: artifact.outputTokens,
+    cacheReadTokens: artifact.cacheReadTokens,
+    cacheWriteTokens: artifact.cacheWriteTokens,
+    totalTokens: artifact.totalTokens,
+    providers: [
+      {
+        provider: artifact.provider,
+        amountUsd: costs.totalUsd,
+        usageLabel: artifact.model,
+        inputTokens: artifact.inputTokens,
+        outputTokens: artifact.outputTokens,
+        totalTokens: artifact.totalTokens,
+        raw: artifact.modelApi
+      }
+    ],
+    raw: {
+      sessionId: artifact.sessionId,
+      sessionKey: artifact.sessionKey,
+      runId: artifact.runId,
+      provider: artifact.provider,
+      model: artifact.model,
+      modelApi: artifact.modelApi,
+      cacheReadTokens: artifact.cacheReadTokens,
+      cacheWriteTokens: artifact.cacheWriteTokens
+    },
+    generatedAt: artifact.generatedAt
+  };
+}
+async function reportShadowUsageSnapshot(params) {
+  if (!params.shadowAgentId || !params.sessionKey) return;
+  let artifact = null;
+  for (let attempt = 0; attempt < 6; attempt += 1) {
+    artifact = await readLatestArtifact({
+      openClawAgentId: params.openClawAgentId,
+      sessionKey: params.sessionKey,
+      sinceMs: params.sinceMs
+    });
+    if (artifact) break;
+    await delay(250);
+  }
+  if (!artifact) {
+    params.runtime.log?.("[usage] No fresh OpenClaw usage artifact found for this dispatch");
+    return;
+  }
+  const costs = await readAssistantCosts(params.openClawAgentId, artifact.sessionId);
+  await params.client.reportAgentUsageSnapshot(params.shadowAgentId, buildSnapshot(artifact, costs));
+  params.runtime.log?.(
+    `[usage] Reported ${artifact.totalTokens ?? 0} token(s) for Shadow agent ${params.shadowAgentId}`
+  );
+}
+
+// src/monitor/channel-message.ts
+function buildChannelContextForAgent(info, channelId) {
+  if (!info) return `Shadow channel id: ${channelId}`;
+  return [
+    `Shadow server: ${info.serverName}`,
+    `Shadow server slug: ${info.serverSlug}`,
+    `Shadow channel: #${info.channelName}`,
+    `Shadow channel id: ${channelId}`
+  ].join("\n");
+}
+async function processShadowMessage(params) {
+  const {
+    message,
+    account,
+    accountId,
+    config,
+    runtime,
+    core,
+    botUserId,
+    botUsername,
+    agentId,
+    channelPolicies,
+    channelServerMap,
+    slashCommands,
+    socket
+  } = params;
+  const cfg = config;
+  const preflight = evaluateShadowMessagePreflight({
+    message,
+    botUserId,
+    botUsername,
+    channelPolicies,
+    runtime
+  });
+  if (!preflight.ok) {
+    runtime.log?.(preflight.reason);
+    return;
+  }
+  const { senderLabel } = preflight;
+  const channelId = message.channelId;
+  runtime.log?.(
+    `[msg] Processing message from ${senderLabel}: "${message.content.slice(0, 80)}" (${message.id})`
+  );
+  const senderName = message.author?.displayName ?? message.author?.username ?? "Unknown";
+  const senderUsername = message.author?.username ?? "";
+  const senderId = message.authorId;
+  const rawBody = message.content;
+  const chatType = message.threadId ? "thread" : "channel";
+  const peerId = message.threadId ? `${channelId}:thread:${message.threadId}` : channelId;
+  const route = core.channel.routing.resolveAgentRoute({
+    cfg,
+    channel: "shadowob",
+    accountId,
+    peer: { kind: "group", id: peerId }
+  });
+  runtime.log?.(`[routing] Resolved agent: ${route.agentId} (account ${accountId})`);
+  const mediaClient = new ShadowClient2(account.serverUrl, account.token);
+  const mediaContext = await resolveShadowInboundMediaContext({
+    account,
+    message,
+    rawBody,
+    runtime
+  });
+  const cleanBody = mediaContext.cleanBody;
+  const interactiveResponseContext = await buildInteractiveResponseContext({
+    message,
+    client: mediaClient,
+    runtime,
+    slashCommands
+  });
+  const slashCommandMatch = matchShadowSlashCommand(cleanBody, slashCommands);
+  if (slashCommandMatch) {
+    runtime.log?.(
+      `[slash] Matched /${slashCommandMatch.invokedName} -> /${slashCommandMatch.command.name}`
+    );
+  } else if (cleanBody.trim().startsWith("/")) {
+    runtime.log?.(`[slash] Unknown slash command in message ${message.id}; treating as text`);
+  }
+  const triggerChain = message.metadata?.agentChain;
+  if (slashCommandMatch?.command.interaction && !slashCommandMatch.args.trim() && !interactiveResponseContext.text) {
+    await sendSlashCommandInteractivePrompt({
+      match: slashCommandMatch,
+      messageId: message.id,
+      channelId,
+      threadId: message.threadId ?? void 0,
+      client: mediaClient,
+      runtime,
+      agentId,
+      botUserId,
+      agentChain: triggerChain
+    });
+    return;
+  }
+  const baseBodyForAgent = slashCommandMatch ? formatSlashCommandPrompt(cleanBody, slashCommandMatch) : cleanBody;
+  const structuredMentions = getShadowMessageMentions(message);
+  const mentionContext = formatShadowMentionsForAgent(structuredMentions);
+  const serverInfo = channelServerMap.get(channelId);
+  const channelLabel = serverInfo ? `#${serverInfo.channelName}` : `channel:${channelId}`;
+  const conversationLabel = serverInfo ? `${serverInfo.serverName} ${channelLabel}` : peerId;
+  const messageBodyForAgent = interactiveResponseContext.text ? `${interactiveResponseContext.text}
+
+User message:
+${baseBodyForAgent}` : baseBodyForAgent;
+  const client = new ShadowClient2(account.serverUrl, account.token);
+  const viewerCommerceContext = await buildCommerceViewerContextForAgent({
+    account,
+    client,
+    viewerUserId: senderId
+  });
+  const bodyForAgent = [
+    buildChannelContextForAgent(serverInfo, channelId),
+    buildCommerceContextForAgent(account),
+    viewerCommerceContext,
+    mentionContext,
+    messageBodyForAgent
+  ].filter(Boolean).join("\n\n");
+  const body = core.channel.reply.formatAgentEnvelope({
+    channel: serverInfo ? `Shadow ${channelLabel}` : "Shadow",
+    from: senderName,
+    timestamp: new Date(message.createdAt).getTime(),
+    envelope: core.channel.reply.resolveEnvelopeFormatOptions(cfg),
+    body: bodyForAgent
+  });
+  const escapedBotUsername = botUsername.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const mentionRegex = new RegExp(`@${escapedBotUsername}(?:\\s|$)`, "i");
+  const wasMentioned = mentionTargetsBot({ mentions: structuredMentions, botUserId, botUsername }) || mentionRegex.test(message.content);
+  const ctxPayload = core.channel.reply.finalizeInboundContext({
+    Body: body,
+    BodyForAgent: bodyForAgent,
+    RawBody: rawBody,
+    CommandBody: slashCommandMatch?.args ?? cleanBody,
+    From: `shadowob:user:${senderId}`,
+    To: `shadowob:channel:${channelId}`,
+    SessionKey: route.sessionKey,
+    AccountId: route.accountId,
+    ChatType: chatType,
+    ConversationLabel: conversationLabel,
+    SenderName: senderName,
+    SenderId: senderId,
+    SenderUsername: senderUsername,
+    Provider: "shadowob",
+    Surface: "shadowob",
+    MessageSid: message.id,
+    WasMentioned: wasMentioned,
+    ...mentionContextFields(structuredMentions),
+    OriginatingChannel: "shadowob",
+    OriginatingTo: `shadowob:channel:${channelId}`,
+    ...serverInfo ? {
+      ServerId: serverInfo.serverId,
+      ServerSlug: serverInfo.serverSlug,
+      ServerName: serverInfo.serverName,
+      ChannelName: serverInfo.channelName,
+      ChannelLabel: channelLabel
+    } : {},
+    BotUserId: botUserId,
+    BotUsername: botUsername,
+    AgentId: route.agentId,
+    ChannelId: channelId,
+    ...slashCommandMatch ? {
+      SlashCommand: `/${slashCommandMatch.command.name}`,
+      SlashCommandName: slashCommandMatch.command.name,
+      SlashCommandInvokedName: slashCommandMatch.invokedName,
+      SlashCommandArgs: slashCommandMatch.args,
+      ...slashCommandMatch.command.description ? { SlashCommandDescription: slashCommandMatch.command.description } : {},
+      ...slashCommandMatch.command.packId ? { SlashCommandPackId: slashCommandMatch.command.packId } : {},
+      ...slashCommandMatch.command.sourcePath ? { SlashCommandSourcePath: slashCommandMatch.command.sourcePath } : {},
+      ...slashCommandMatch.command.body ? { SlashCommandDefinition: slashCommandMatch.command.body } : {}
+    } : {},
+    ...account.buddyName ? { BuddyName: account.buddyName } : {},
+    ...account.buddyId ? { BuddyId: account.buddyId } : {},
+    ...account.buddyDescription ? { BuddyDescription: account.buddyDescription } : {},
+    ...commerceContextFields(account),
+    ...message.threadId ? { ThreadId: message.threadId } : {},
+    ...message.replyToId ? { ReplyToId: message.replyToId } : {},
+    ...interactiveResponseContext.fields,
+    ...mediaContext.fields
+  });
+  const storePath = core.channel.session.resolveStorePath(resolveSessionStore(cfg), {
+    agentId: route.agentId
+  });
+  await core.channel.session.recordInboundSession({
+    storePath,
+    sessionKey: ctxPayload.SessionKey ?? route.sessionKey,
+    ctx: ctxPayload,
+    onRecordError: (err) => {
+      runtime.error?.(`Failed updating session meta: ${String(err)}`);
+    }
+  });
+  const bindingSessionKey = typeof ctxPayload.SessionKey === "string" ? ctxPayload.SessionKey : route.sessionKey;
+  if (route.agentId && bindingSessionKey) {
+    await upsertShadowThreadBinding({
+      accountId,
+      agentId: route.agentId,
+      sessionKey: bindingSessionKey,
+      channelId,
+      ...message.threadId ? { threadId: message.threadId } : {},
+      messageId: message.id
+    }).catch((err) => {
+      runtime.error?.(`[session] Failed updating thread binding: ${String(err)}`);
+    });
+  }
+  runtime.log?.(`[msg] Dispatching to AI pipeline for message ${message.id}`);
+  const typingCbs = createTypingCallbacks({
+    start: async () => {
+      socket.sendTyping(channelId);
+    },
+    stop: async () => {
+      socket.sendTyping(channelId, false);
+    },
+    onStartError: (err) => {
+      runtime.error?.(`[typing] Failed to send typing indicator: ${String(err)}`);
+    },
+    onStopError: (err) => {
+      runtime.error?.(`[typing] Failed to clear typing indicator: ${String(err)}`);
+    },
+    maxDurationMs: 12e4
+  });
+  socket.updateActivity(channelId, "thinking");
+  const activityTimeout = setTimeout(() => {
+    runtime.log?.(`[activity] Clearing stale activity for message ${message.id}`);
+    socket.updateActivity(channelId, null);
+  }, 12e4);
+  try {
+    const dispatchAgentId = route.agentId || agentId;
+    if (!dispatchAgentId) {
+      runtime.error?.(`[msg] Cannot dispatch ${message.id}: no OpenClaw agent resolved`);
+      socket.updateActivity(channelId, null);
+      return;
+    }
+    const replyPipeline = createChannelReplyPipeline({
+      cfg,
+      agentId: dispatchAgentId,
+      channel: "shadowob",
+      accountId,
+      typingCallbacks: typingCbs
+    });
+    const dispatchStartedAt = Date.now();
+    await core.channel.reply.dispatchReplyWithBufferedBlockDispatcher({
+      ctx: ctxPayload,
+      cfg,
+      replyOptions: {
+        sourceReplyDeliveryMode: "automatic"
+      },
+      dispatcherOptions: {
+        ...replyPipeline,
+        deliver: async (payload) => {
+          socket.updateActivity(channelId, "working");
+          await deliverShadowReply({
+            payload,
+            channelId,
+            threadId: message.threadId ?? void 0,
+            replyToId: message.id,
+            client,
+            runtime,
+            agentChain: triggerChain,
+            agentId: dispatchAgentId,
+            botUserId
+          });
+        },
+        onError: (err, info) => {
+          runtime.error?.(
+            `[msg] Reply delivery failed for ${message.id} (${info.kind}): ${String(err)}`
+          );
+        }
+      }
+    });
+    await reportShadowUsageSnapshot({
+      client,
+      shadowAgentId: agentId,
+      openClawAgentId: dispatchAgentId,
+      sessionKey: bindingSessionKey,
+      runtime,
+      sinceMs: dispatchStartedAt
+    }).catch((err) => {
+      runtime.error?.(`[usage] Failed to report usage snapshot for ${message.id}: ${String(err)}`);
+    });
+    socket.updateActivity(channelId, "ready");
+  } catch (err) {
+    runtime.error?.(`[msg] AI dispatch failed for message ${message.id}: ${String(err)}`);
+    socket.updateActivity(channelId, null);
+    throw err;
+  } finally {
+    clearTimeout(activityTimeout);
+    typingCbs.onCleanup?.();
+    setTimeout(() => {
+      socket.updateActivity(channelId, null);
+    }, 3e3);
+  }
+}
+
+// src/runtime.ts
+import { createPluginRuntimeStore } from "openclaw/plugin-sdk/runtime-store";
+var store = createPluginRuntimeStore(
+  "Shadow runtime not initialized \u2014 plugin not registered yet"
+);
+var setShadowRuntime = store.setRuntime;
+var getShadowRuntime = store.getRuntime;
+var tryGetShadowRuntime = store.tryGetRuntime;
+
+// src/monitor.ts
+function resolveShadowAgentIdFromConfig(config, accountId) {
+  const cfg = config;
+  const routeBinding = cfg.bindings?.find((binding) => {
+    return binding.match?.channel === "shadowob" && binding.match.accountId === accountId;
+  });
+  if (typeof routeBinding?.agentId === "string" && routeBinding.agentId.trim()) {
+    return routeBinding.agentId;
+  }
+  const defaultAgent = cfg.agents?.list?.find((agent) => agent.default) ?? cfg.agents?.list?.[0];
+  return typeof defaultAgent?.id === "string" && defaultAgent.id.trim() ? defaultAgent.id : null;
+}
+var RECENT_MESSAGE_CATCHUP_WINDOW_MS = 30 * 60 * 1e3;
+var MAX_TRACKED_MESSAGE_IDS = 1e3;
+var SHADOW_API_RETRY_ATTEMPTS = 5;
+var SHADOW_API_RETRY_DELAY_MS = 750;
+function getMessageCreatedMs2(message) {
+  const createdMs = Date.parse(message.createdAt);
+  return Number.isFinite(createdMs) ? createdMs : null;
+}
+function delay2(ms, abortSignal) {
+  if (!abortSignal) return new Promise((resolve) => setTimeout(resolve, ms));
+  if (abortSignal.aborted) return Promise.resolve();
+  const signal = abortSignal;
+  return new Promise((resolve) => {
+    const timeout = setTimeout(done, ms);
+    function done() {
+      clearTimeout(timeout);
+      signal.removeEventListener("abort", done);
+      resolve();
+    }
+    signal.addEventListener("abort", done, { once: true });
+  });
+}
+async function runShadowApiOperation(label, operation, options) {
+  const attempts = options.attempts ?? SHADOW_API_RETRY_ATTEMPTS;
+  const delayMs = options.delayMs ?? SHADOW_API_RETRY_DELAY_MS;
+  let lastError;
+  for (let attempt = 1; attempt <= attempts; attempt += 1) {
+    if (options.abortSignal?.aborted) {
+      throw lastError ?? new Error(`${label} aborted`);
+    }
+    try {
+      return await operation();
+    } catch (err) {
+      lastError = err;
+      if (attempt >= attempts) break;
+      const waitMs = delayMs * attempt;
+      options.runtime.error?.(
+        `[shadow-api] ${label} failed (attempt ${attempt}/${attempts}): ${String(
+          err
+        )}; retrying in ${waitMs}ms`
+      );
+      await delay2(waitMs, options.abortSignal);
+    }
+  }
+  throw lastError;
+}
+function shouldCatchUpShadowMessage(message, options) {
+  if (message.authorId === options.botUserId) return false;
+  if (options.processedMessageIds?.has(message.id)) return false;
+  const createdMs = getMessageCreatedMs2(message);
+  if (createdMs === null) return false;
+  const watermark = options.watermarks?.[message.channelId];
+  const watermarkMs = watermark ? Date.parse(watermark.createdAt) : Number.NaN;
+  if (Number.isFinite(watermarkMs)) {
+    return createdMs > watermarkMs;
+  }
+  return createdMs >= options.startedAtMs - (options.catchupWindowMs ?? RECENT_MESSAGE_CATCHUP_WINDOW_MS);
+}
+async function monitorShadowProvider(options) {
+  const { account, accountId, config, abortSignal } = options;
+  const runtime = {
+    log: (msg) => {
+      options.runtime.log?.(msg);
+      void appendMonitorLog(accountId, "info", msg);
+    },
+    error: (msg) => {
+      options.runtime.error?.(msg);
+      void appendMonitorLog(accountId, "error", msg);
+    }
+  };
+  const core = options.channelRuntime ? { channel: options.channelRuntime } : getShadowRuntime();
+  let stopped = false;
+  const monitorStartedAtMs = Date.now();
+  const client = new ShadowClient3(account.serverUrl, account.token);
+  const me = await client.getMe();
+  const botUserId = me.id;
+  runtime.log?.(`Shadow bot connected as ${me.username} (${botUserId})`);
+  const agentId = account.agentId ?? me.agentId ?? resolveShadowAgentIdFromConfig(config, accountId);
+  if (!agentId) {
+    runtime.error?.(
+      "[config] Cannot resolve agentId \u2014 heartbeat and remote config will be unavailable"
+    );
+  } else {
+    runtime.log?.(`[config] Resolved agentId: ${agentId}`);
+  }
+  const slashCommands = await loadLocalSlashCommands(runtime);
+  if (agentId) {
+    try {
+      await runShadowApiOperation(
+        "register slash commands",
+        () => registerAgentSlashCommands({ account, agentId, commands: slashCommands }),
+        { runtime, abortSignal }
+      );
+      runtime.log?.(`[slash] Registered ${slashCommands.length} slash command(s) with Shadow`);
+    } catch (err) {
+      runtime.error?.(`[slash] Failed to register slash commands: ${String(err)}`);
+    }
+  }
+  let remoteConfig = null;
+  const channelPolicies = /* @__PURE__ */ new Map();
+  const channelServerMap = /* @__PURE__ */ new Map();
+  const allChannelIds = [];
+  const messageWatermarks = await loadMessageWatermarks(accountId);
+  const processedMessageIds = /* @__PURE__ */ new Set();
+  const catchupInFlight = /* @__PURE__ */ new Map();
+  const rememberProcessedMessage = (messageId) => {
+    processedMessageIds.add(messageId);
+    if (processedMessageIds.size > MAX_TRACKED_MESSAGE_IDS) {
+      const first = processedMessageIds.values().next().value;
+      if (first) processedMessageIds.delete(first);
+    }
+  };
+  const rememberChannelContext = (channel, server) => {
+    if (channel.kind === "dm" || !channel.serverId) return;
+    channelServerMap.set(channel.id, {
+      serverId: channel.serverId,
+      serverSlug: server?.slug ?? channel.serverId,
+      serverName: server?.name ?? channel.serverId,
+      channelName: channel.name
+    });
+  };
+  const resolveChannelContext = async (channelId, reason) => {
+    if (channelServerMap.has(channelId)) return true;
+    try {
+      const channel = await runShadowApiOperation(
+        `fetch channel context (${reason})`,
+        () => client.getChannel(channelId),
+        { runtime, abortSignal }
+      );
+      if (channel.kind === "dm" || !channel.serverId) {
+        runtime.log?.(`[config] Resolved direct channel context: ${channelId}`);
+        return true;
+      }
+      const serverId = channel.serverId;
+      let server = null;
+      try {
+        server = await runShadowApiOperation(
+          `fetch server context for channel ${channelId}`,
+          () => client.getServer(serverId),
+          { runtime, abortSignal }
+        );
+      } catch (err) {
+        runtime.error?.(`[config] Failed to fetch server context for ${channelId}: ${String(err)}`);
+      }
+      rememberChannelContext(channel, server);
+      const serverLabel = server?.name ?? channel.serverId;
+      runtime.log?.(`[config] Resolved channel context: ${serverLabel} #${channel.name}`);
+      return true;
+    } catch (err) {
+      runtime.error?.(`[config] Failed to resolve channel context for ${channelId}: ${String(err)}`);
+      return false;
+    }
+  };
+  if (agentId) {
+    try {
+      remoteConfig = await runShadowApiOperation(
+        "fetch remote config",
+        () => client.getAgentConfig(agentId),
+        { runtime, abortSignal }
+      );
+      runtime.log?.(`[config] Fetched remote config: ${remoteConfig.servers.length} server(s)`);
+      for (const server of remoteConfig.servers) {
+        runtime.log?.(
+          `[config] Server "${server.name}" (${server.id}) \u2014 ${server.channels.length} channel(s)`
+        );
+        for (const ch of server.channels) {
+          channelPolicies.set(ch.id, ch.policy);
+          channelServerMap.set(ch.id, {
+            serverId: server.id,
+            serverSlug: server.slug ?? server.id,
+            serverName: server.name,
+            channelName: ch.name
+          });
+          if (ch.policy.listen) {
+            allChannelIds.push(ch.id);
+            runtime.log?.(
+              `[config]   \u2713 #${ch.name} (${ch.id}) \u2014 listen=true reply=${ch.policy.reply} mentionOnly=${ch.policy.mentionOnly}`
+            );
+          } else {
+            runtime.log?.(`[config]   \u2717 #${ch.name} (${ch.id}) \u2014 listen=false, skipping`);
+          }
+        }
+      }
+      runtime.log?.(
+        `[config] Monitoring ${allChannelIds.length} channel(s) across ${remoteConfig.servers.length} server(s)`
+      );
+      void saveSessionCache(accountId, { remoteConfig, botUserId, botUsername: me.username });
+    } catch (err) {
+      runtime.error?.(`[config] Failed to fetch remote config: ${String(err)}`);
+      const cached = await loadSessionCache(accountId);
+      if (cached) {
+        runtime.log?.("[config] Loaded session from cache \u2014 using cached config");
+        remoteConfig = cached.remoteConfig;
+        for (const server of remoteConfig.servers) {
+          for (const ch of server.channels) {
+            channelPolicies.set(ch.id, ch.policy);
+            channelServerMap.set(ch.id, {
+              serverId: server.id,
+              serverSlug: server.slug ?? server.id,
+              serverName: server.name,
+              channelName: ch.name
+            });
+            if (ch.policy.listen) allChannelIds.push(ch.id);
+          }
+        }
+        runtime.log?.(`[config] Restored ${allChannelIds.length} channel(s) from cache`);
+      } else {
+        runtime.log?.("[config] No cached session \u2014 falling back to monitoring no channels");
+      }
+    }
+  }
+  try {
+    const directChannels = await runShadowApiOperation(
+      "fetch direct channels",
+      () => client.listDirectChannels(),
+      { runtime, abortSignal }
+    );
+    for (const ch of directChannels) {
+      if (!allChannelIds.includes(ch.id)) allChannelIds.push(ch.id);
+      if (!channelPolicies.has(ch.id)) {
+        channelPolicies.set(ch.id, {
+          listen: true,
+          reply: true,
+          mentionOnly: false,
+          config: {}
+        });
+      }
+    }
+    runtime.log?.(`[config] Monitoring ${directChannels.length} direct channel(s)`);
+  } catch (err) {
+    runtime.error?.(`[config] Failed to fetch direct channels: ${String(err)}`);
+  }
+  let heartbeatInterval = null;
+  if (agentId) {
+    const sendHeartbeat = async () => {
+      try {
+        await client.sendHeartbeat(agentId);
+        runtime.log?.("[heartbeat] Heartbeat sent");
+      } catch (err) {
+        runtime.error?.(`[heartbeat] Heartbeat failed: ${String(err)}`);
+      }
+    };
+    void sendHeartbeat();
+    heartbeatInterval = setInterval(sendHeartbeat, 3e4);
+  }
+  runtime.log?.(`[ws] Connecting to Shadow WebSocket at ${account.serverUrl}`);
+  const socket = new ShadowSocket2({
+    serverUrl: account.serverUrl,
+    token: account.token,
+    transports: ["websocket", "polling"]
+  });
+  const processChannelMessageWithRetry = async (message, source, attempt = 0) => {
+    try {
+      await resolveChannelContext(message.channelId, `${source} message`);
+      await processShadowMessage({
+        message,
+        account,
+        accountId,
+        config,
+        runtime,
+        core,
+        botUserId,
+        botUsername: me.username,
+        agentId,
+        channelPolicies,
+        channelServerMap,
+        slashCommands,
+        socket
+      });
+      if (updateMessageWatermark(messageWatermarks, message)) {
+        void saveMessageWatermarks(accountId, messageWatermarks);
+      }
+    } catch (err) {
+      const MAX_RETRIES = 2;
+      runtime.error?.(
+        `[${source}] Message processing failed (attempt ${attempt + 1}): ${String(err)}`
+      );
+      if (attempt < MAX_RETRIES) {
+        await new Promise((r) => setTimeout(r, 1e3 * (attempt + 1)));
+        return processChannelMessageWithRetry(message, source, attempt + 1);
+      }
+      runtime.error?.(
+        `[${source}] Message permanently failed after ${MAX_RETRIES + 1} attempts: ${message.id}`
+      );
+    }
+  };
+  const catchUpChannel = async (channelId, reason) => {
+    try {
+      const result = await client.getMessages(channelId, 50);
+      if (!messageWatermarks[channelId]) {
+        const latestBotMessage = [...result.messages].reverse().find((message) => message.authorId === botUserId);
+        if (latestBotMessage && updateMessageWatermark(messageWatermarks, latestBotMessage)) {
+          void saveMessageWatermarks(accountId, messageWatermarks);
+        }
+      }
+      const candidates = result.messages.filter(
+        (message) => shouldCatchUpShadowMessage(message, {
+          botUserId,
+          processedMessageIds,
+          startedAtMs: monitorStartedAtMs,
+          watermarks: messageWatermarks
+        })
+      );
+      if (candidates.length > 0) {
+        runtime.log?.(
+          `[catchup] Replaying ${candidates.length} missed message(s) in channel ${channelId} (${reason})`
+        );
+      }
+      for (const message of candidates) {
+        rememberProcessedMessage(message.id);
+        await processChannelMessageWithRetry(message, "catchup");
+      }
+    } catch (err) {
+      runtime.error?.(`[catchup] Failed for channel ${channelId}: ${String(err)}`);
+    }
+  };
+  const enqueueChannelCatchup = (channelId, reason) => {
+    if (catchupInFlight.has(channelId)) return;
+    const task = catchUpChannel(channelId, reason).finally(() => {
+      catchupInFlight.delete(channelId);
+    });
+    catchupInFlight.set(channelId, task);
+  };
+  socket.onConnect(() => {
+    runtime.log?.(`[ws] Connected (sid=${socket.raw.id})`);
+    if (allChannelIds.length === 0) {
+      runtime.log?.("[ws] No channels to join \u2014 allChannelIds is empty");
+      runtime.log?.("[ws] Shadow channel monitor ready (no channels configured)");
+    }
+    for (const chId of allChannelIds) {
+      runtime.log?.(`[ws] Emitting channel:join for ${chId}`);
+      socket.joinChannel(chId).then((ack) => {
+        if (ack?.ok) {
+          runtime.log?.(`[ws] \u2713 Joined channel room ${chId} (server confirmed)`);
+          runtime.log?.("[ws] Shadow channel monitor ready");
+        } else {
+          runtime.log?.(`[ws] channel:join for ${chId} \u2014 no ack received (older server?)`);
+          runtime.log?.("[ws] Shadow channel monitor ready");
+        }
+        enqueueChannelCatchup(chId, "connect");
+      });
+    }
+    runtime.log?.(
+      `[ws] Emitted channel:join for ${allChannelIds.length} channel(s), listening for messages`
+    );
+  });
+  socket.onConnectError((err) => {
+    runtime.error?.(`[ws] Connection error: ${err.message}`);
+  });
+  socket.onDisconnect((reason) => {
+    runtime.log?.(`[ws] Disconnected: ${reason}`);
+  });
+  socket.raw.io.on("reconnect", (attempt) => {
+    runtime.log?.(`[ws] Reconnected after ${attempt} attempt(s)`);
+  });
+  socket.raw.io.on("reconnect_attempt", (attempt) => {
+    runtime.log?.(`[ws] Reconnect attempt #${attempt}`);
+  });
+  socket.on("server:joined", async (data) => {
+    if (!agentId) return;
+    runtime.log?.(`[ws] Received server:joined for server ${data.serverId} \u2014 refreshing channels`);
+    try {
+      const updatedConfig = await runShadowApiOperation(
+        "refresh remote config",
+        () => client.getAgentConfig(agentId),
+        { runtime, abortSignal }
+      );
+      runtime.log?.(`[config] Refreshed config: ${updatedConfig.servers.length} server(s)`);
+      for (const server of updatedConfig.servers) {
+        for (const ch of server.channels) {
+          channelServerMap.set(ch.id, {
+            serverId: server.id,
+            serverSlug: server.slug ?? server.id,
+            serverName: server.name,
+            channelName: ch.name
+          });
+          if (!channelPolicies.has(ch.id)) {
+            channelPolicies.set(ch.id, ch.policy);
+            if (ch.policy.listen) {
+              allChannelIds.push(ch.id);
+              runtime.log?.(`[config] New channel: #${ch.name} (${ch.id}) \u2014 joining`);
+              socket.joinChannel(ch.id).then((ack) => {
+                if (ack?.ok) {
+                  runtime.log?.(`[ws] \u2713 Joined new channel room ${ch.id}`);
+                  runtime.log?.("[ws] Shadow channel monitor ready");
+                }
+              });
+            }
+          } else {
+            channelPolicies.set(ch.id, ch.policy);
+          }
+        }
+      }
+      remoteConfig = updatedConfig;
+    } catch (err) {
+      runtime.error?.(`[config] Failed to refresh config after server:joined: ${String(err)}`);
+    }
+  });
+  socket.on(
+    "channel:created",
+    async (data) => {
+      runtime.log?.(
+        `[ws] Received channel:created: #${data.name} (${data.id}) in server ${data.serverId} \u2014 ignoring (bot must be explicitly added)`
+      );
+      channelServerMap.set(data.id, {
+        serverId: data.serverId,
+        serverSlug: data.serverId,
+        serverName: data.serverId,
+        channelName: data.name
+      });
+    }
+  );
+  socket.on(
+    "agent:policy-changed",
+    (data) => {
+      if (data.agentId !== agentId) return;
+      if (!data.channelId) return;
+      const mentionOnly = data.mentionOnly ?? false;
+      runtime.log?.(
+        `[ws] Received agent:policy-changed for channel ${data.channelId}: mentionOnly=${mentionOnly}, reply=${data.reply}, config=${JSON.stringify(data.config ?? {})}`
+      );
+      const existing = channelPolicies.get(data.channelId);
+      if (existing) {
+        channelPolicies.set(data.channelId, {
+          ...existing,
+          mentionOnly,
+          reply: data.reply ?? existing.reply,
+          config: data.config ?? existing.config
+        });
+      } else {
+        channelPolicies.set(data.channelId, {
+          listen: true,
+          reply: data.reply ?? true,
+          mentionOnly,
+          config: data.config ?? {}
+        });
+      }
+    }
+  );
+  socket.on("channel:member-added", (data) => {
+    runtime.log?.(
+      `[ws] Received channel:member-added: channel ${data.channelId} in server ${data.serverId}`
+    );
+    const refreshChannelConfig = async () => {
+      if (!agentId) return false;
+      try {
+        const updatedConfig = await runShadowApiOperation(
+          "refresh remote config after channel member add",
+          () => client.getAgentConfig(agentId),
+          { runtime, abortSignal }
+        );
+        remoteConfig = updatedConfig;
+        for (const server2 of updatedConfig.servers) {
+          for (const ch of server2.channels) {
+            channelServerMap.set(ch.id, {
+              serverId: server2.id,
+              serverSlug: server2.slug ?? server2.id,
+              serverName: server2.name,
+              channelName: ch.name
+            });
+            channelPolicies.set(ch.id, ch.policy);
+          }
+        }
+        const server = updatedConfig.servers.find(
+          (candidate) => candidate.channels.some((ch) => ch.id === data.channelId)
+        );
+        const channel = server?.channels.find((ch) => ch.id === data.channelId);
+        if (channel) {
+          runtime.log?.(
+            `[config] Refreshed new channel context: #${channel.name} (${data.channelId})`
+          );
+        }
+        return true;
+      } catch (err) {
+        runtime.error?.(
+          `[config] Failed to refresh config after channel:member-added: ${String(err)}`
+        );
+        return false;
+      }
+    };
+    void (async () => {
+      const refreshed = await refreshChannelConfig();
+      if (!refreshed) {
+        await resolveChannelContext(data.channelId, "member-added");
+      }
+      if (!refreshed && !channelPolicies.has(data.channelId)) {
+        const defaultPolicy = {
+          listen: true,
+          reply: true,
+          mentionOnly: false,
+          config: {}
+        };
+        channelPolicies.set(data.channelId, defaultPolicy);
+      }
+      if (!allChannelIds.includes(data.channelId)) {
+        allChannelIds.push(data.channelId);
+      }
+      socket.joinChannel(data.channelId).then((ack) => {
+        if (ack?.ok) {
+          runtime.log?.(`[ws] \u2713 Joined channel room ${data.channelId} after member-added`);
+          runtime.log?.("[ws] Shadow channel monitor ready");
+        }
+        enqueueChannelCatchup(data.channelId, "member-added");
+      });
+    })();
+  });
+  socket.on("channel:member-removed", (data) => {
+    runtime.log?.(
+      `[ws] Received channel:member-removed: channel ${data.channelId} in server ${data.serverId}`
+    );
+    channelPolicies.delete(data.channelId);
+    const idx = allChannelIds.indexOf(data.channelId);
+    if (idx !== -1) allChannelIds.splice(idx, 1);
+    socket.leaveChannel(data.channelId);
+    runtime.log?.(`[ws] Left channel room ${data.channelId} after member-removed`);
+  });
+  socket.on("message:new", (message) => {
+    const senderLabel = message.author?.username ?? message.authorId;
+    runtime.log?.(
+      `[ws] \u2190 message:new from ${senderLabel} in channel ${message.channelId}: "${message.content?.slice(0, 60)}" (${message.id})`
+    );
+    if (processedMessageIds.has(message.id)) {
+      runtime.log?.(`[ws] Skipping duplicate message:new ${message.id}`);
+      return;
+    }
+    rememberProcessedMessage(message.id);
+    if (stopped) {
+      runtime.log?.("[ws] Monitor stopped, ignoring message");
+      return;
+    }
+    if (allChannelIds.length > 0 && !allChannelIds.includes(message.channelId)) {
+      runtime.log?.(`[ws] Message from unmonitored channel ${message.channelId}, ignoring`);
+      return;
+    }
+    void processChannelMessageWithRetry(message, "ws");
+  });
+  socket.connect();
+  const stop = () => {
+    runtime.log?.("[lifecycle] Stopping Shadow monitor...");
+    stopped = true;
+    if (heartbeatInterval) clearInterval(heartbeatInterval);
+    socket.disconnect();
+    runtime.log?.("[lifecycle] Shadow monitor stopped");
+  };
+  abortSignal.addEventListener("abort", stop, { once: true });
+  await new Promise((resolve) => {
+    if (abortSignal.aborted) {
+      resolve();
+      return;
+    }
+    abortSignal.addEventListener("abort", () => resolve(), { once: true });
+  });
+  return { stop };
+}
+
+export {
+  resolveOutboundMentions,
+  normalizeShadowSlashCommands,
+  matchShadowSlashCommand,
+  formatSlashCommandPrompt,
+  setShadowRuntime,
+  getShadowRuntime,
+  tryGetShadowRuntime,
+  resolveShadowAgentIdFromConfig,
+  shouldCatchUpShadowMessage,
+  monitorShadowProvider
+};