@chrysb/alphaclaw 0.6.2-beta.4 → 0.6.2-beta.6

package/lib/server/agents/channels.js

@@ -15,6 +15,7 @@ const {
   isValidChannelAccountId,
   normalizeChannelProvider,
   deriveChannelEnvKey,
+  deriveChannelExtraEnvKeys,
   getConfiguredChannelEnvKeys,
   assertActiveChannelTokenEnvVars,
   normalizeChannelConfig,
@@ -63,15 +64,28 @@ const createChannelsDomain = ({
       throw new Error(`Channel account "${provider}/${accountId}" not found`);
     }
     const envKey = deriveChannelEnvKey({ provider, accountId });
+    const extraEnvKeys = deriveChannelExtraEnvKeys({ provider, accountId });
     const envVars = readEnvFile();
     const envEntry = (Array.isArray(envVars) ? envVars : []).find(
       (entry) => String(entry?.key || "").trim() === envKey,
     );
+    const appEnvKey = extraEnvKeys[0] || "";
+    const appEnvEntry = appEnvKey
+      ? (Array.isArray(envVars) ? envVars : []).find(
+          (entry) => String(entry?.key || "").trim() === appEnvKey,
+        )
+      : null;
     return {
       provider,
       accountId,
       envKey,
       token: String(envEntry?.value || ""),
+      ...(provider === "slack"
+        ? {
+            appEnvKey,
+            appToken: String(appEnvEntry?.value || ""),
+          }
+        : {}),
     };
   };
 
@@ -129,11 +143,21 @@ const createChannelsDomain = ({
           `Channel account "${provider}/${accountId}" already exists`,
         );
       }
-      if (provider === "discord" && Object.keys(existingAccounts).length > 0) {
-        throw new Error("Discord supports a single channel account");
+      if (
+        (provider === "discord" || provider === "slack") &&
+        Object.keys(existingAccounts).length > 0
+      ) {
+        throw new Error(
+          `${kChannelLabels[provider] || "This provider"} supports a single channel account`,
+        );
       }
 
       const envKey = deriveChannelEnvKey({ provider, accountId });
+      const extraEnvKeys = deriveChannelExtraEnvKeys({ provider, accountId });
+      const appToken = String(input.appToken || "").trim();
+      if (provider === "slack" && !appToken) {
+        throw new Error("Slack App Token is required");
+      }
       const tokenField = kChannelTokenFields[provider];
       const currentEnvVars = readEnvFile();
       const previousEnvVars = Array.isArray(currentEnvVars) ? currentEnvVars : [];
@@ -156,11 +180,41 @@ const createChannelsDomain = ({
           `[alphaclaw] Overwriting orphaned channel env var ${dupKey} (no matching config entry)`,
         );
       }
+      let orphanedExtraEnvKey = null;
+      if (provider === "slack") {
+        const appEnvKey = extraEnvKeys[0];
+        const duplicateAppTokenEntry = previousEnvVars.find((entry) => {
+          const existingKey = String(entry?.key || "").trim();
+          const existingValue = String(entry?.value || "").trim();
+          if (!existingKey || !existingValue) return false;
+          if (existingKey === envKey || existingKey === appEnvKey) return false;
+          return existingValue === appToken;
+        });
+        if (duplicateAppTokenEntry) {
+          const dupKey = String(duplicateAppTokenEntry.key || "").trim();
+          const configuredKeys = getConfiguredChannelEnvKeys(cfg);
+          if (configuredKeys.has(dupKey)) {
+            throw new Error(`Channel token already exists in ${dupKey}`);
+          }
+          orphanedExtraEnvKey = dupKey;
+          console.log(
+            `[alphaclaw] Overwriting orphaned channel env var ${dupKey} (no matching config entry)`,
+          );
+        }
+      }
       const nextEnvVars = previousEnvVars.filter((entry) => {
         const key = String(entry?.key || "").trim();
-        return key !== envKey && key !== orphanedEnvKey;
+        return (
+          key !== envKey &&
+          key !== orphanedEnvKey &&
+          !extraEnvKeys.includes(key) &&
+          key !== orphanedExtraEnvKey
+        );
       });
       nextEnvVars.push({ key: envKey, value: token });
+      if (provider === "slack" && extraEnvKeys[0]) {
+        nextEnvVars.push({ key: extraEnvKeys[0], value: appToken });
+      }
 
       const previousConfig = cloneJson(cfg);
       try {
@@ -188,7 +242,12 @@ const createChannelsDomain = ({
             ? `--account ${shellEscapeArg(accountId)}`
             : "",
           name ? `--name ${shellEscapeArg(name)}` : "",
-          `--token ${shellEscapeArg(token)}`,
+          provider === "slack"
+            ? `--bot-token ${shellEscapeArg(token)}`
+            : `--token ${shellEscapeArg(token)}`,
+          provider === "slack" && appToken
+            ? `--app-token ${shellEscapeArg(appToken)}`
+            : "",
         ].filter(Boolean);
         const addResult = await clawCmd(addArgs.join(" "), {
           quiet: true,
@@ -225,6 +284,9 @@ const createChannelsDomain = ({
             : {}),
           ...(name ? { name } : {}),
           [tokenField]: `\${${envKey}}`,
+          ...(provider === "slack" && extraEnvKeys[0]
+            ? { appToken: `\${${extraEnvKeys[0]}}` }
+            : {}),
           dmPolicy: "pairing",
         };
         nextProviderConfig.accounts = nextAccounts;
@@ -308,6 +370,7 @@ const createChannelsDomain = ({
     const nextName = String(input.name || "").trim();
     const nextAgentId = String(input.agentId || "").trim();
     const nextToken = String(input.token || "").trim();
+    const nextAppToken = String(input.appToken || "").trim();
     if (!nextName) throw new Error("Channel name is required");
     if (!nextAgentId) throw new Error("Agent is required");
 
@@ -337,6 +400,41 @@ const createChannelsDomain = ({
     }
 
     let tokenUpdated = false;
+    if (provider === "slack" && nextAppToken) {
+      const appEnvKey = deriveChannelExtraEnvKeys({ provider, accountId })[0];
+      const currentEnvVars = readEnvFile();
+      const previousEnvVars = Array.isArray(currentEnvVars)
+        ? currentEnvVars
+        : [];
+      const existingAppToken = String(
+        previousEnvVars.find(
+          (entry) => String(entry?.key || "").trim() === appEnvKey,
+        )?.value || "",
+      );
+      const duplicateEnvEntry = previousEnvVars.find((entry) => {
+        const existingKey = String(entry?.key || "").trim();
+        const existingValue = String(entry?.value || "").trim();
+        if (!existingKey || !existingValue) return false;
+        if (existingKey === appEnvKey) return false;
+        return existingValue === nextAppToken;
+      });
+      if (duplicateEnvEntry) {
+        const dupKey = String(duplicateEnvEntry.key || "").trim();
+        const configuredKeys = getConfiguredChannelEnvKeys(cfg);
+        if (configuredKeys.has(dupKey)) {
+          throw new Error(`Channel token already exists in ${dupKey}`);
+        }
+      }
+      if (existingAppToken !== nextAppToken) {
+        const nextEnvVars = previousEnvVars.filter(
+          (entry) => String(entry?.key || "").trim() !== appEnvKey,
+        );
+        nextEnvVars.push({ key: appEnvKey, value: nextAppToken });
+        writeEnvFile(nextEnvVars);
+        reloadEnv();
+        tokenUpdated = true;
+      }
+    }
     if (nextToken) {
       const envKey = deriveChannelEnvKey({ provider, accountId });
       const currentEnvVars = readEnvFile();
@@ -542,12 +640,15 @@ const createChannelsDomain = ({
       saveConfig({ fsImpl, OPENCLAW_DIR, config: nextCfg });
 
       const envKey = deriveChannelEnvKey({ provider, accountId });
+      const extraEnvKeys = deriveChannelExtraEnvKeys({ provider, accountId });
       const currentEnvVars = readEnvFile();
       const previousEnvVars = Array.isArray(currentEnvVars)
         ? currentEnvVars
         : [];
       const nextEnvVars = previousEnvVars.filter(
-        (entry) => String(entry?.key || "").trim() !== envKey,
+        (entry) =>
+          String(entry?.key || "").trim() !== envKey &&
+          !extraEnvKeys.includes(String(entry?.key || "").trim()),
       );
       if (nextEnvVars.length !== previousEnvVars.length) {
         writeEnvFile(nextEnvVars);
@@ -577,10 +678,13 @@ const createChannelsDomain = ({
     }
 
     const envKey = deriveChannelEnvKey({ provider, accountId });
+    const extraEnvKeys = deriveChannelExtraEnvKeys({ provider, accountId });
     const currentEnvVars = readEnvFile();
     const previousEnvVars = Array.isArray(currentEnvVars) ? currentEnvVars : [];
     const nextEnvVars = previousEnvVars.filter(
-      (entry) => String(entry?.key || "").trim() !== envKey,
+      (entry) =>
+        String(entry?.key || "").trim() !== envKey &&
+        !extraEnvKeys.includes(String(entry?.key || "").trim()),
     );
     if (nextEnvVars.length !== previousEnvVars.length) {
       writeEnvFile(nextEnvVars);

package/lib/server/agents/shared.js

@@ -13,14 +13,23 @@ const kDefaultAgentFiles = ["SOUL.md", "AGENTS.md", "USER.md", "IDENTITY.md"];
 const kChannelEnvKeys = {
   telegram: "TELEGRAM_BOT_TOKEN",
   discord: "DISCORD_BOT_TOKEN",
+  slack: "SLACK_BOT_TOKEN",
+};
+const kChannelExtraEnvKeys = {
+  slack: ["SLACK_APP_TOKEN"],
 };
 const kChannelTokenFields = {
   telegram: "botToken",
   discord: "token",
+  slack: "botToken",
+};
+const kChannelExtraTokenFields = {
+  slack: ["appToken"],
 };
 const kChannelLabels = {
   telegram: "Telegram",
   discord: "Discord",
+  slack: "Slack",
 };
 const kMaskedChannelToken = "********";
 
@@ -152,6 +161,19 @@ const deriveChannelEnvKey = ({ provider, accountId }) => {
   return `${envKey}_${normalizedAccountId.replace(/-/g, "_").toUpperCase()}`;
 };
 
+const deriveChannelExtraEnvKeys = ({ provider, accountId }) => {
+  const normalizedProvider = normalizeChannelProvider(provider);
+  const baseEnvKeys = Array.isArray(kChannelExtraEnvKeys[normalizedProvider])
+    ? kChannelExtraEnvKeys[normalizedProvider]
+    : [];
+  const normalizedAccountId = String(accountId || "").trim();
+  if (!normalizedAccountId || normalizedAccountId === "default") {
+    return [...baseEnvKeys];
+  }
+  const suffix = normalizedAccountId.replace(/-/g, "_").toUpperCase();
+  return baseEnvKeys.map((baseKey) => `${baseKey}_${suffix}`);
+};
+
 const getConfiguredChannelEnvKeys = (cfg) => {
   const keys = new Set();
   const channels =
@@ -164,9 +186,19 @@ const getConfiguredChannelEnvKeys = (cfg) => {
         : {};
     for (const accountId of Object.keys(accounts)) {
       keys.add(deriveChannelEnvKey({ provider, accountId }));
+      const extraEnvKeys = deriveChannelExtraEnvKeys({ provider, accountId });
+      for (const extraEnvKey of extraEnvKeys) {
+        keys.add(extraEnvKey);
+      }
     }
     if (Object.keys(accounts).length === 0 && providerConfig?.enabled) {
       keys.add(kChannelEnvKeys[provider]);
+      for (const extraEnvKey of deriveChannelExtraEnvKeys({
+        provider,
+        accountId: "default",
+      })) {
+        keys.add(extraEnvKey);
+      }
     }
   }
   return keys;
@@ -208,6 +240,15 @@ const assertActiveChannelTokenEnvVars = ({ cfg, envVars }) => {
           `Missing required channel token env var ${envKey} for active channel ${provider}/${accountId}`,
         );
       }
+      const extraEnvKeys = deriveChannelExtraEnvKeys({ provider, accountId });
+      for (const extraEnvKey of extraEnvKeys) {
+        const extraEnvValue = String(envMap.get(extraEnvKey) || "").trim();
+        if (!extraEnvValue) {
+          throw new Error(
+            `Missing required channel token env var ${extraEnvKey} for active channel ${provider}/${accountId}`,
+          );
+        }
+      }
     }
   }
 };
@@ -223,8 +264,13 @@ const normalizeChannelConfig = ({ provider, channelConfig }) => {
       ? { ...nextConfig.accounts }
       : {};
   const tokenField = kChannelTokenFields[normalizedProvider];
+  const extraTokenFields = Array.isArray(
+    kChannelExtraTokenFields[normalizedProvider],
+  )
+    ? kChannelExtraTokenFields[normalizedProvider]
+    : [];
   if (Object.keys(existingAccounts).length > 0) {
-    if (tokenField) {
+    if (tokenField || extraTokenFields.length > 0) {
       for (const [accountId, accountConfig] of Object.entries(
         existingAccounts,
       )) {
@@ -239,6 +285,17 @@ const normalizeChannelConfig = ({ provider, channelConfig }) => {
             accountId,
           })}}`;
         }
+        const extraEnvKeys = deriveChannelExtraEnvKeys({
+          provider: normalizedProvider,
+          accountId,
+        });
+        extraTokenFields.forEach((fieldName, index) => {
+          const rawValue = String(nextAccountConfig[fieldName] || "").trim();
+          if (!rawValue) return;
+          if (isEnvRef(rawValue)) return;
+          if (!extraEnvKeys[index]) return;
+          nextAccountConfig[fieldName] = `\${${extraEnvKeys[index]}}`;
+        });
         existingAccounts[accountId] = nextAccountConfig;
       }
     }
@@ -266,6 +323,17 @@ const normalizeChannelConfig = ({ provider, channelConfig }) => {
       defaultAccountConfig[tokenField] = defaultTokenEnvRef;
     }
   }
+  const defaultExtraEnvKeys = deriveChannelExtraEnvKeys({
+    provider: normalizedProvider,
+    accountId: "default",
+  });
+  extraTokenFields.forEach((fieldName, index) => {
+    const rawValue = String(defaultAccountConfig[fieldName] || "").trim();
+    if (!rawValue) return;
+    if (isEnvRef(rawValue)) return;
+    if (!defaultExtraEnvKeys[index]) return;
+    defaultAccountConfig[fieldName] = `\${${defaultExtraEnvKeys[index]}}`;
+  });
   if (
     Object.keys(defaultAccountConfig).length > 0 ||
     defaultAccountConfig[tokenField]
@@ -615,6 +683,7 @@ module.exports = {
   isValidChannelAccountId,
   normalizeChannelProvider,
   deriveChannelEnvKey,
+  deriveChannelExtraEnvKeys,
   getConfiguredChannelEnvKeys,
   assertActiveChannelTokenEnvVars,
   normalizeChannelConfig,

package/lib/server/constants.js

@@ -235,6 +235,18 @@ const kKnownVars = [
     group: "channels",
     hint: "From Discord Developer Portal",
   },
+  {
+    key: "SLACK_BOT_TOKEN",
+    label: "Slack Bot Token",
+    group: "channels",
+    hint: "From your Slack app's OAuth & Permissions page (xoxb-...)",
+  },
+  {
+    key: "SLACK_APP_TOKEN",
+    label: "Slack App Token",
+    group: "channels",
+    hint: "From Basic Information → App-Level Tokens (xapp-...)",
+  },
   {
     key: "MISTRAL_API_KEY",
     label: "Mistral API Key",
@@ -336,6 +348,7 @@ const API_TEST_COMMANDS = {
 const kChannelDefs = {
   telegram: { envKey: "TELEGRAM_BOT_TOKEN" },
   discord: { envKey: "DISCORD_BOT_TOKEN" },
+  slack: { envKey: "SLACK_BOT_TOKEN", extraEnvKeys: ["SLACK_APP_TOKEN"] },
 };
 const kProtectedBrowsePaths = new Set(
   Array.isArray(kBrowseFilePolicies?.protectedPaths)

package/lib/server/gateway.js

@@ -302,17 +302,34 @@ const syncChannelConfig = (savedVars, mode = "all") => {
       if (token && !isConfigured && (mode === "add" || mode === "all")) {
         console.log(`[alphaclaw] Adding channel: ${ch}`);
         try {
-          execSync(`openclaw channels add --channel ${ch} --token "${token}"`, {
-            env,
-            timeout: 15000,
-            encoding: "utf8",
-          });
-          const raw = fs.readFileSync(configPath, "utf8");
-          if (raw.includes(token)) {
-            fs.writeFileSync(
-              configPath,
-              raw.split(token).join("${" + def.envKey + "}"),
+          if (ch === "slack") {
+            const appToken = savedMap[def.extraEnvKeys?.[0]];
+            if (!appToken) continue;
+            execSync(
+              `openclaw channels add --channel slack --bot-token "${token}" --app-token "${appToken}"`,
+              { env, timeout: 15000, encoding: "utf8" },
             );
+            let raw = fs.readFileSync(configPath, "utf8");
+            if (raw.includes(token)) {
+              raw = raw.split(token).join("${" + def.envKey + "}");
+            }
+            if (raw.includes(appToken)) {
+              raw = raw.split(appToken).join("${" + def.extraEnvKeys[0] + "}");
+            }
+            fs.writeFileSync(configPath, raw);
+          } else {
+            execSync(`openclaw channels add --channel ${ch} --token "${token}"`, {
+              env,
+              timeout: 15000,
+              encoding: "utf8",
+            });
+            const raw = fs.readFileSync(configPath, "utf8");
+            if (raw.includes(token)) {
+              fs.writeFileSync(
+                configPath,
+                raw.split(token).join("${" + def.envKey + "}"),
+              );
+            }
           }
           console.log(`[alphaclaw] Channel ${ch} added`);
         } catch (e) {
@@ -353,7 +370,7 @@ const getChannelStatus = () => {
     const credDir = `${OPENCLAW_DIR}/credentials`;
     const channels = {};
 
-    for (const ch of ["telegram", "discord"]) {
+    for (const ch of Object.keys(kChannelDefs)) {
       const channelConfig =
         config.channels?.[ch] && typeof config.channels[ch] === "object"
           ? config.channels[ch]

package/lib/server/onboarding/openclaw.js

@@ -198,6 +198,19 @@ const applyFreshOnboardingChannels = ({ cfg, varMap }) => {
     ensurePluginAllowed(cfg, "discord");
     console.log("[onboard] Discord configured");
   }
+  if (varMap.SLACK_BOT_TOKEN && varMap.SLACK_APP_TOKEN) {
+    cfg.channels.slack = {
+      enabled: true,
+      botToken: varMap.SLACK_BOT_TOKEN,
+      appToken: varMap.SLACK_APP_TOKEN,
+      mode: "socket",
+      dmPolicy: "pairing",
+      groupPolicy: "open",
+    };
+    cfg.plugins.entries.slack = { enabled: true };
+    ensurePluginAllowed(cfg, "slack");
+    console.log("[onboard] Slack configured");
+  }
   if (!cfg.plugins.load.paths.includes(kUsageTrackerPluginPath)) {
     cfg.plugins.load.paths.push(kUsageTrackerPluginPath);
   }
@@ -274,6 +287,23 @@ const writeManagedImportOpenclawConfig = ({ fs, openclawDir, varMap }) => {
     ensurePluginAllowed(cfg, "discord");
   }
 
+  if (varMap.SLACK_BOT_TOKEN && varMap.SLACK_APP_TOKEN) {
+    cfg.channels.slack = {
+      ...(cfg.channels.slack || {}),
+      enabled: true,
+      botToken: "${SLACK_BOT_TOKEN}",
+      appToken: "${SLACK_APP_TOKEN}",
+      mode: cfg.channels.slack?.mode || "socket",
+      dmPolicy: getSafeImportedDmPolicy(cfg.channels.slack),
+      groupPolicy: cfg.channels.slack?.groupPolicy || "open",
+    };
+    cfg.plugins.entries.slack = {
+      ...(cfg.plugins.entries.slack || {}),
+      enabled: true,
+    };
+    ensurePluginAllowed(cfg, "slack");
+  }
+
   fs.writeFileSync(configPath, JSON.stringify(cfg, null, 2));
 };
 

package/lib/server/onboarding/validation.js

@@ -89,7 +89,7 @@ const validateOnboardingInput = ({ vars, modelKey, resolveModelProvider, hasCode
       ? hasAiByProvider[selectedProvider]
       : hasAnyAi;
   const hasGithub = !!(githubToken && githubRepoInput);
-  const hasChannel = !!(varMap.TELEGRAM_BOT_TOKEN || varMap.DISCORD_BOT_TOKEN);
+  const hasChannel = !!(varMap.TELEGRAM_BOT_TOKEN || varMap.DISCORD_BOT_TOKEN || (varMap.SLACK_BOT_TOKEN && varMap.SLACK_APP_TOKEN));
 
   if (!hasAi) {
     if (selectedProvider === "openai-codex") {

package/lib/server/routes/pairings.js

@@ -5,7 +5,7 @@ const { buildManagedPaths } = require("../internal-files-migration");
 const { parseJsonObjectFromNoisyOutput } = require("../utils/json");
 const { quoteShellArg } = require("../utils/shell");
 
-const kAllowedPairingChannels = new Set(["telegram", "discord"]);
+const kAllowedPairingChannels = new Set(["telegram", "discord", "slack"]);
 const kSafePairingArgPattern = /^[\w\-:.]+$/;
 const quoteCliArg = (value) => quoteShellArg(value, { strategy: "single" });
 
@@ -111,7 +111,7 @@ const registerPairingRoutes = ({ app, clawCmd, isOnboarded, fsModule = fs, openc
     }
 
     const pending = [];
-    const channels = ["telegram", "discord"];
+    const channels = ["telegram", "discord", "slack"];
 
     for (const ch of channels) {
       try {

package/lib/server/routes/system.js

@@ -25,7 +25,8 @@ const registerSystemRoutes = ({
   authProfiles,
 }) => {
   let envRestartPending = false;
-  const kManagedChannelTokenPattern = /^(TELEGRAM|DISCORD)_BOT_TOKEN(?:_[A-Z0-9_]+)?$/;
+  const kManagedChannelTokenPattern =
+    /^(?:TELEGRAM_BOT_TOKEN|DISCORD_BOT_TOKEN|SLACK_BOT_TOKEN|SLACK_APP_TOKEN)(?:_[A-Z0-9_]+)?$/;
   const kEnvVarsReservedForUserInput = new Set([
     "GITHUB_WORKSPACE_REPO",
     "GOG_KEYRING_PASSWORD",
@@ -311,7 +312,13 @@ const registerSystemRoutes = ({
     }
 
     for (const v of fileVars) {
-      if (kKnownKeys.has(v.key) || isReservedUserEnvVar(v.key)) continue;
+      if (
+        kKnownKeys.has(v.key) ||
+        isReservedUserEnvVar(v.key) ||
+        isManagedChannelTokenKey(v.key)
+      ) {
+        continue;
+      }
       merged.push({
         key: v.key,
         value: v.value,

package/lib/server/slack-api.js

@@ -0,0 +1,38 @@
+const kSlackApiBase = "https://slack.com/api";
+
+const createSlackApi = (getToken) => {
+  const call = async (method, body = {}) => {
+    const token = typeof getToken === "function" ? getToken() : getToken;
+    if (!token) throw new Error("SLACK_BOT_TOKEN is not set");
+    const res = await fetch(`${kSlackApiBase}/${method}`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${token}`,
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify(body),
+    });
+    if (!res.ok) {
+      throw new Error(`Slack API ${method}: HTTP ${res.status}`);
+    }
+    const data = await res.json();
+    if (!data.ok) {
+      const err = new Error(data.error || `Slack API error: ${method}`);
+      err.slackError = data.error;
+      throw err;
+    }
+    return data;
+  };
+
+  const authTest = () => call("auth.test");
+
+  const postMessage = (channel, text) =>
+    call("chat.postMessage", { channel, text: String(text || "") });
+
+  return {
+    authTest,
+    postMessage,
+  };
+};
+
+module.exports = { createSlackApi };

package/lib/server/watchdog-notify.js

@@ -36,11 +36,12 @@ const getPairedIds = (channel) => {
 const formatDiscordMessage = (message) =>
   String(message || "").replace(/(?<!\*)\*(?!\*)(.+?)(?<!\*)\*(?!\*)/g, "**$1**");
 
-const createWatchdogNotifier = ({ telegramApi, discordApi }) => {
+const createWatchdogNotifier = ({ telegramApi, discordApi, slackApi }) => {
   const notify = async (message) => {
     const summary = {
       telegram: { sent: 0, failed: 0, skipped: false, targets: 0 },
       discord: { sent: 0, failed: 0, skipped: false, targets: 0 },
+      slack: { sent: 0, failed: 0, skipped: false, targets: 0 },
     };
     const telegramTargets = getPairedIds("telegram");
     summary.telegram.targets = telegramTargets.length;
@@ -77,8 +78,24 @@ const createWatchdogNotifier = ({ telegramApi, discordApi }) => {
       }
     }
 
-    const sent = summary.telegram.sent + summary.discord.sent;
-    const failed = summary.telegram.failed + summary.discord.failed;
+    const slackTargets = getPairedIds("slack");
+    summary.slack.targets = slackTargets.length;
+    if (!slackApi?.postMessage || !process.env.SLACK_BOT_TOKEN || slackTargets.length === 0) {
+      summary.slack.skipped = true;
+    } else {
+      for (const userId of slackTargets) {
+        try {
+          await slackApi.postMessage(userId, String(message || ""));
+          summary.slack.sent += 1;
+        } catch (err) {
+          summary.slack.failed += 1;
+          console.error(`[watchdog] slack notification failed for ${userId}: ${err.message}`);
+        }
+      }
+    }
+
+    const sent = summary.telegram.sent + summary.discord.sent + summary.slack.sent;
+    const failed = summary.telegram.failed + summary.discord.failed + summary.slack.failed;
     return {
       ok: sent > 0,
       sent,

package/lib/server.js

@@ -104,6 +104,7 @@ const {
 const { installGogCliSkill } = require("./server/gog-skill");
 const { createTelegramApi } = require("./server/telegram-api");
 const { createDiscordApi } = require("./server/discord-api");
+const { createSlackApi } = require("./server/slack-api");
 const { createWatchdogNotifier } = require("./server/watchdog-notify");
 const { createWatchdog } = require("./server/watchdog");
 const { createDoctorService } = require("./server/doctor/service");
@@ -307,7 +308,8 @@ const gmailWatchService = registerGmailRoutes({
 });
 const telegramApi = createTelegramApi(() => process.env.TELEGRAM_BOT_TOKEN);
 const discordApi = createDiscordApi(() => process.env.DISCORD_BOT_TOKEN);
-const watchdogNotifier = createWatchdogNotifier({ telegramApi, discordApi });
+const slackApi = createSlackApi(() => process.env.SLACK_BOT_TOKEN);
+const watchdogNotifier = createWatchdogNotifier({ telegramApi, discordApi, slackApi });
 const watchdog = createWatchdog({
   clawCmd,
   launchGatewayProcess,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chrysb/alphaclaw",
-  "version": "0.6.2-beta.4",
+  "version": "0.6.2-beta.6",
   "publishConfig": {
     "access": "public"
   },