fix: handle Telegram General topic thread params (#848) (thanks @azade-c)

Telegram General topic (id=1) has inconsistent API behavior:
- sendMessage: rejects explicit message_thread_id=1
- sendChatAction: requires message_thread_id=1 for typing to show

Split into two helper functions:
- buildTelegramThreadParams: excludes General topic for messages
- buildTypingThreadParams: includes General topic for typing

CHANGELOG.md

@@ -2,7 +2,6 @@
 
 ## 2026.1.15 (unreleased)
 
-- Slack: add optional user token routing for read access with safe write fallback. (#981) — thanks @jalehman.
 - Fix: list model picker entries as provider/model pairs for explicit selection. (#970) — thanks @mcinteerj.
 - Daemon: fix profile-aware service label resolution (env-driven) and add coverage for launchd/systemd/schtasks. (#969) — thanks @bjesuiter.
 - Daemon: share profile/state-dir resolution across service helpers and honor `CLAWDBOT_STATE_DIR` for Windows task scripts.
@@ -19,6 +18,7 @@
 - Browser: extension mode recovers when only one tab is attached (stale targetId fallback).
 - Browser: fix `tab not found` for extension relay snapshots/actions when Playwright blocks `newCDPSession` (use the single available Page).
 - Telegram: add bidirectional reaction support with configurable notifications and agent guidance. (#964) — thanks @bohdanpodvirnyi.
+- Telegram: skip `message_thread_id=1` for General topic sends while keeping typing indicators. (#848) — thanks @azade-c.
 - Discord: allow allowlisted guilds without channel lists to receive messages when `groupPolicy="allowlist"`. — thanks @thewilloftheshadow.
 
 ## 2026.1.14-1

docs/channels/slack.md

@@ -27,8 +27,7 @@ Minimal config:
 1) Create a Slack app (From scratch) in https://api.channels.slack.com/apps.
 2) **Socket Mode** → toggle on. Then go to **Basic Information** → **App-Level Tokens** → **Generate Token and Scopes** with scope `connections:write`. Copy the **App Token** (`xapp-...`).
 3) **OAuth & Permissions** → add bot token scopes (use the manifest below). Click **Install to Workspace**. Copy the **Bot User OAuth Token** (`xoxb-...`).
-4) Optional: **OAuth & Permissions** → add **User Token Scopes** (see the read-only list below). Reinstall the app and copy the **User OAuth Token** (`xoxp-...`).
-5) **Event Subscriptions** → enable events and subscribe to:
+4) **Event Subscriptions** → enable events and subscribe to:
    - `message.*` (includes edits/deletes/thread broadcasts)
    - `app_mention`
    - `reaction_added`, `reaction_removed`
@@ -36,9 +35,9 @@ Minimal config:
    - `channel_id_changed`
    - `channel_rename`
    - `pin_added`, `pin_removed`
-6) Invite the bot to channels you want it to read.
-7) Slash Commands → create `/clawd` if you use `channels.slack.slashCommand`. If you enable native commands, add one slash command per built-in command (same names as `/help`). Native defaults to off for Slack unless you set `channels.slack.commands.native: true` (global `commands.native` is `"auto"` which leaves Slack off).
-8) App Home → enable the **Messages Tab** so users can DM the bot.
+5) Invite the bot to channels you want it to read.
+6) Slash Commands → create `/clawd` if you use `channels.slack.slashCommand`. If you enable native commands, add one slash command per built-in command (same names as `/help`). Native defaults to off for Slack unless you set `channels.slack.commands.native: true` (global `commands.native` is `"auto"` which leaves Slack off).
+7) App Home → enable the **Messages Tab** so users can DM the bot.
 
 Use the manifest below so scopes and events stay in sync.
 
@@ -64,52 +63,6 @@ Or via config:
 }
 ```
 
-## User token (optional)
-Clawdbot can use a Slack user token (`xoxp-...`) for read operations (history,
-pins, reactions, emoji, member info). By default this stays read-only: reads
-prefer the user token when present, and writes still use the bot token unless
-you explicitly opt in. Even with `userTokenReadOnly: false`, the bot token stays
-preferred for writes when it is available.
-
-User tokens are configured in the config file (no env var support). For
-multi-account, set `channels.slack.accounts.<id>.userToken`.
-
-Example with bot + app + user tokens:
-```json5
-{
-  channels: {
-    slack: {
-      enabled: true,
-      appToken: "xapp-...",
-      botToken: "xoxb-...",
-      userToken: "xoxp-..."
-    }
-  }
-}
-```
-
-Example with userTokenReadOnly explicitly set (allow user token writes):
-```json5
-{
-  channels: {
-    slack: {
-      enabled: true,
-      appToken: "xapp-...",
-      botToken: "xoxb-...",
-      userToken: "xoxp-...",
-      userTokenReadOnly: false
-    }
-  }
-}
-```
-
-### Token usage
-- Read operations (history, reactions list, pins list, emoji list, member info,
-  search) prefer the user token when configured, otherwise the bot token.
-- Write operations (send/edit/delete messages, add/remove reactions, pin/unpin,
-  file uploads) use the bot token by default. If `userTokenReadOnly: false` and
-  no bot token is available, Clawdbot falls back to the user token.
-
 ## History context
 - `channels.slack.historyLimit` (or `channels.slack.accounts.*.historyLimit`) controls how many recent channel/group messages are wrapped into the prompt.
 - Falls back to `messages.groupChat.historyLimit`. Set `0` to disable (default 50).
@@ -130,8 +83,7 @@ Disable with:
 ```
 
 ## Manifest (optional)
-Use this Slack app manifest to create the app quickly (adjust the name/command if you want). Include the
-user scopes if you plan to configure a user token.
+Use this Slack app manifest to create the app quickly (adjust the name/command if you want).
 
 ```json
 {
@@ -181,21 +133,6 @@ user scopes if you plan to configure a user token.
         "commands",
         "files:read",
         "files:write"
-      ],
-      "user": [
-        "channels:history",
-        "channels:read",
-        "groups:history",
-        "groups:read",
-        "im:history",
-        "im:read",
-        "mpim:history",
-        "mpim:read",
-        "users:read",
-        "reactions:read",
-        "pins:read",
-        "emoji:read",
-        "search:read"
       ]
     }
   },
@@ -229,7 +166,7 @@ Slack's Conversations API is type-scoped: you only need the scopes for the
 conversation types you actually touch (channels, groups, im, mpim). See
 https://api.channels.slack.com/docs/conversations-api for the overview.
 
-### Bot token scopes (required)
+### Required scopes
 - `chat:write` (send/update/delete messages via `chat.postMessage`)
   https://api.channels.slack.com/methods/chat.postMessage
 - `im:write` (open DMs via `conversations.open` for user DMs)
@@ -251,17 +188,6 @@ https://api.channels.slack.com/docs/conversations-api for the overview.
 - `files:write` (uploads via `files.uploadV2`)
   https://api.channels.slack.com/messaging/files/uploading
 
-### User token scopes (optional, read-only by default)
-Add these under **User Token Scopes** if you configure `channels.slack.userToken`.
-
-- `channels:history`, `groups:history`, `im:history`, `mpim:history`
-- `channels:read`, `groups:read`, `im:read`, `mpim:read`
-- `users:read`
-- `reactions:read`
-- `pins:read`
-- `emoji:read`
-- `search:read`
-
 ### Not needed today (but likely future)
 - `mpim:write` (only if we add group-DM open/DM start via `conversations.open`)
 - `groups:write` (only if we add private-channel management: create/rename/invite/archive)
@@ -394,17 +320,6 @@ Slack tool actions can be gated with `channels.slack.actions.*`:
 | memberInfo | enabled | Member info |
 | emojiList | enabled | Custom emoji list |
 
-## Security notes
-- Writes default to the bot token so state-changing actions stay scoped to the
-  app's bot permissions and identity.
-- Setting `userTokenReadOnly: false` allows the user token to be used for write
-  operations when a bot token is unavailable, which means actions run with the
-  installing user's access. Treat the user token as highly privileged and keep
-  action gates and allowlists tight.
-- If you enable user-token writes, make sure the user token includes the write
-  scopes you expect (`chat:write`, `reactions:write`, `pins:write`,
-  `files:write`) or those operations will fail.
-
 ## Notes
 - Mention gating is controlled via `channels.slack.channels` (set `requireMention` to `true`); `agents.list[].groupChat.mentionPatterns` (or `messages.groupChat.mentionPatterns`) also count as mentions.
 - Multi-agent override: set per-agent patterns on `agents.list[].groupChat.mentionPatterns`.

docs/channels/telegram.md

@@ -188,6 +188,7 @@ Disable with:
 Telegram forum topics include a `message_thread_id` per message. Clawdbot:
 - Appends `:topic:<threadId>` to the Telegram group session key so each topic is isolated.
 - Sends typing indicators and replies with `message_thread_id` so responses stay in the topic.
+- General topic (thread id `1`) is special: message sends omit `message_thread_id` (Telegram rejects it), but typing indicators still include it.
 - Exposes `MessageThreadId` + `IsForum` in template context for routing/templating.
 - Topic-specific configuration is available under `channels.telegram.groups.<chatId>.topics.<threadId>` (skills, allowlists, auto-reply, system prompts, disable).
 

docs/gateway/configuration.md

@@ -1052,8 +1052,6 @@ Slack runs in Socket Mode and requires both a bot token and app token:
       enabled: true,
       botToken: "xoxb-...",
       appToken: "xapp-...",
-      userToken: "xoxp-...",     // optional (read-only by default)
-      userTokenReadOnly: true,   // default: true
       dm: {
         enabled: true,
         policy: "pairing", // pairing | allowlist | open | disabled
@@ -1104,7 +1102,6 @@ Slack runs in Socket Mode and requires both a bot token and app token:
 Multi-account support lives under `channels.slack.accounts` (see the multi-account section above). Env tokens only apply to the default account.
 
 Clawdbot starts Slack when the provider is enabled and both tokens are set (via config or `SLACK_BOT_TOKEN` + `SLACK_APP_TOKEN`). Use `user:<id>` (DM) or `channel:<id>` when specifying delivery targets for cron/CLI commands.
-Optional user tokens (`xoxp-...`) are configured in the config file (no env var support). Reads prefer the user token when present; writes use the bot token unless you set `channels.slack.userTokenReadOnly: false` and no bot token is available.
 Set `channels.slack.configWrites: false` to block Slack-initiated config writes (including channel ID migrations and `/config set|unset`).
 
 Bot-authored messages are ignored by default. Enable with `channels.slack.allowBots` or `channels.slack.channels.<id>.allowBots`.

src/agents/tools/slack-actions.test.ts

@@ -361,82 +361,4 @@ describe("handleSlackAction", () => {
     expect(payload.pins[0].message?.timestampMs).toBe(expectedMs);
     expect(payload.pins[0].message?.timestampUtc).toBe(new Date(expectedMs).toISOString());
   });
-
-  it("uses user token for reads when available", async () => {
-    const cfg = {
-      channels: { slack: { botToken: "xoxb-1", userToken: "xoxp-1" } },
-    } as ClawdbotConfig;
-    readSlackMessages.mockClear();
-    readSlackMessages.mockResolvedValueOnce({ messages: [], hasMore: false });
-    await handleSlackAction({ action: "readMessages", channelId: "C1" }, cfg);
-    const [, opts] = readSlackMessages.mock.calls[0] ?? [];
-    expect(opts?.token).toBe("xoxp-1");
-  });
-
-  it("uses user token for pin reads when available", async () => {
-    const cfg = {
-      channels: { slack: { botToken: "xoxb-1", userToken: "xoxp-1" } },
-    } as ClawdbotConfig;
-    listSlackPins.mockClear();
-    listSlackPins.mockResolvedValueOnce([]);
-    await handleSlackAction({ action: "listPins", channelId: "C1" }, cfg);
-    const [, opts] = listSlackPins.mock.calls[0] ?? [];
-    expect(opts?.token).toBe("xoxp-1");
-  });
-
-  it("uses user token for member info reads when available", async () => {
-    const cfg = {
-      channels: { slack: { botToken: "xoxb-1", userToken: "xoxp-1" } },
-    } as ClawdbotConfig;
-    getSlackMemberInfo.mockClear();
-    getSlackMemberInfo.mockResolvedValueOnce({});
-    await handleSlackAction({ action: "memberInfo", userId: "U1" }, cfg);
-    const [, opts] = getSlackMemberInfo.mock.calls[0] ?? [];
-    expect(opts?.token).toBe("xoxp-1");
-  });
-
-  it("falls back to bot token for reads when user token missing", async () => {
-    const cfg = {
-      channels: { slack: { botToken: "xoxb-1" } },
-    } as ClawdbotConfig;
-    readSlackMessages.mockClear();
-    readSlackMessages.mockResolvedValueOnce({ messages: [], hasMore: false });
-    await handleSlackAction({ action: "readMessages", channelId: "C1" }, cfg);
-    const [, opts] = readSlackMessages.mock.calls[0] ?? [];
-    expect(opts?.token).toBeUndefined();
-  });
-
-  it("uses bot token for writes when userTokenReadOnly is true", async () => {
-    const cfg = {
-      channels: { slack: { botToken: "xoxb-1", userToken: "xoxp-1" } },
-    } as ClawdbotConfig;
-    sendSlackMessage.mockClear();
-    await handleSlackAction({ action: "sendMessage", to: "channel:C1", content: "Hello" }, cfg);
-    const [, , opts] = sendSlackMessage.mock.calls[0] ?? [];
-    expect(opts?.token).toBeUndefined();
-  });
-
-  it("allows user token writes when bot token is missing", async () => {
-    const cfg = {
-      channels: {
-        slack: { userToken: "xoxp-1", userTokenReadOnly: false },
-      },
-    } as ClawdbotConfig;
-    sendSlackMessage.mockClear();
-    await handleSlackAction({ action: "sendMessage", to: "channel:C1", content: "Hello" }, cfg);
-    const [, , opts] = sendSlackMessage.mock.calls[0] ?? [];
-    expect(opts?.token).toBe("xoxp-1");
-  });
-
-  it("prefers bot token for writes when both tokens are available", async () => {
-    const cfg = {
-      channels: {
-        slack: { botToken: "xoxb-1", userToken: "xoxp-1", userTokenReadOnly: false },
-      },
-    } as ClawdbotConfig;
-    sendSlackMessage.mockClear();
-    await handleSlackAction({ action: "sendMessage", to: "channel:C1", content: "Hello" }, cfg);
-    const [, , opts] = sendSlackMessage.mock.calls[0] ?? [];
-    expect(opts?.token).toBeUndefined();
-  });
 });

src/agents/tools/slack-actions.ts

@@ -2,7 +2,6 @@ import type { AgentToolResult } from "@mariozechner/pi-agent-core";
 
 import type { ClawdbotConfig } from "../../config/config.js";
 import { resolveSlackAccount } from "../../slack/accounts.js";
-import { resolveSlackTokenOverride } from "../../slack/token.js";
 import {
   deleteSlackMessage,
   editSlackMessage,
@@ -79,27 +78,11 @@ export async function handleSlackAction(
 ): Promise<AgentToolResult<unknown>> {
   const action = readStringParam(params, "action", { required: true });
   const accountId = readStringParam(params, "accountId");
+  const accountOpts = accountId ? { accountId } : undefined;
   const account = resolveSlackAccount({ cfg, accountId });
   const actionConfig = account.actions ?? cfg.channels?.slack?.actions;
   const isActionEnabled = createActionGate(actionConfig);
 
-  const buildActionOpts = (operation: "read" | "write") => {
-    const tokenOverride = resolveSlackTokenOverride({
-      botToken: account.botToken,
-      userToken: account.userToken,
-      userTokenReadOnly: account.config.userTokenReadOnly,
-      operation,
-    });
-    if (!accountId && !tokenOverride) return undefined;
-    return {
-      ...(accountId ? { accountId } : {}),
-      ...(tokenOverride ? { token: tokenOverride } : {}),
-    };
-  };
-
-  const readOpts = buildActionOpts("read");
-  const writeOpts = buildActionOpts("write");
-
   if (reactionsActions.has(action)) {
     if (!isActionEnabled("reactions")) {
       throw new Error("Slack reactions are disabled.");
@@ -111,28 +94,28 @@ export async function handleSlackAction(
         removeErrorMessage: "Emoji is required to remove a Slack reaction.",
       });
       if (remove) {
-        if (writeOpts) {
-          await removeSlackReaction(channelId, messageId, emoji, writeOpts);
+        if (accountOpts) {
+          await removeSlackReaction(channelId, messageId, emoji, accountOpts);
         } else {
           await removeSlackReaction(channelId, messageId, emoji);
         }
         return jsonResult({ ok: true, removed: emoji });
       }
       if (isEmpty) {
-        const removed = writeOpts
-          ? await removeOwnSlackReactions(channelId, messageId, writeOpts)
+        const removed = accountOpts
+          ? await removeOwnSlackReactions(channelId, messageId, accountOpts)
           : await removeOwnSlackReactions(channelId, messageId);
         return jsonResult({ ok: true, removed });
       }
-      if (writeOpts) {
-        await reactSlackMessage(channelId, messageId, emoji, writeOpts);
+      if (accountOpts) {
+        await reactSlackMessage(channelId, messageId, emoji, accountOpts);
       } else {
         await reactSlackMessage(channelId, messageId, emoji);
       }
       return jsonResult({ ok: true, added: emoji });
     }
-    const reactions = readOpts
-      ? await listSlackReactions(channelId, messageId, readOpts)
+    const reactions = accountOpts
+      ? await listSlackReactions(channelId, messageId, accountOpts)
       : await listSlackReactions(channelId, messageId);
     return jsonResult({ ok: true, reactions });
   }
@@ -152,7 +135,7 @@ export async function handleSlackAction(
           context,
         );
         const result = await sendSlackMessage(to, content, {
-          ...writeOpts,
+          accountId: accountId ?? undefined,
           mediaUrl: mediaUrl ?? undefined,
           threadTs: threadTs ?? undefined,
         });
@@ -179,8 +162,8 @@ export async function handleSlackAction(
         const content = readStringParam(params, "content", {
           required: true,
         });
-        if (writeOpts) {
-          await editSlackMessage(channelId, messageId, content, writeOpts);
+        if (accountOpts) {
+          await editSlackMessage(channelId, messageId, content, accountOpts);
         } else {
           await editSlackMessage(channelId, messageId, content);
         }
@@ -193,8 +176,8 @@ export async function handleSlackAction(
         const messageId = readStringParam(params, "messageId", {
           required: true,
         });
-        if (writeOpts) {
-          await deleteSlackMessage(channelId, messageId, writeOpts);
+        if (accountOpts) {
+          await deleteSlackMessage(channelId, messageId, accountOpts);
         } else {
           await deleteSlackMessage(channelId, messageId);
         }
@@ -210,7 +193,7 @@ export async function handleSlackAction(
         const before = readStringParam(params, "before");
         const after = readStringParam(params, "after");
         const result = await readSlackMessages(channelId, {
-          ...readOpts,
+          accountId: accountId ?? undefined,
           limit,
           before: before ?? undefined,
           after: after ?? undefined,
@@ -237,8 +220,8 @@ export async function handleSlackAction(
       const messageId = readStringParam(params, "messageId", {
         required: true,
       });
-      if (writeOpts) {
-        await pinSlackMessage(channelId, messageId, writeOpts);
+      if (accountOpts) {
+        await pinSlackMessage(channelId, messageId, accountOpts);
       } else {
         await pinSlackMessage(channelId, messageId);
       }
@@ -248,15 +231,15 @@ export async function handleSlackAction(
       const messageId = readStringParam(params, "messageId", {
         required: true,
       });
-      if (writeOpts) {
-        await unpinSlackMessage(channelId, messageId, writeOpts);
+      if (accountOpts) {
+        await unpinSlackMessage(channelId, messageId, accountOpts);
       } else {
         await unpinSlackMessage(channelId, messageId);
       }
       return jsonResult({ ok: true });
     }
-    const pins = readOpts
-      ? await listSlackPins(channelId, readOpts)
+    const pins = accountOpts
+      ? await listSlackPins(channelId, accountOpts)
       : await listSlackPins(channelId);
     const normalizedPins = pins.map((pin) => {
       const message = pin.message
@@ -275,8 +258,8 @@ export async function handleSlackAction(
       throw new Error("Slack member info is disabled.");
     }
     const userId = readStringParam(params, "userId", { required: true });
-    const info = readOpts
-      ? await getSlackMemberInfo(userId, readOpts)
+    const info = accountOpts
+      ? await getSlackMemberInfo(userId, accountOpts)
       : await getSlackMemberInfo(userId);
     return jsonResult({ ok: true, info });
   }
@@ -285,7 +268,7 @@ export async function handleSlackAction(
     if (!isActionEnabled("emojiList")) {
       throw new Error("Slack emoji list is disabled.");
     }
-    const emojis = readOpts ? await listSlackEmojis(readOpts) : await listSlackEmojis();
+    const emojis = accountOpts ? await listSlackEmojis(accountOpts) : await listSlackEmojis();
     return jsonResult({ ok: true, emojis });
   }
 

src/channels/plugins/outbound/slack.ts

@@ -1,6 +1,4 @@
-import { resolveSlackAccount } from "../../../slack/accounts.js";
 import { sendMessageSlack } from "../../../slack/send.js";
-import { resolveSlackTokenOverride } from "../../../slack/token.js";
 import type { ChannelOutboundAdapter } from "../types.js";
 
 export const slackOutbound: ChannelOutboundAdapter = {
@@ -17,36 +15,20 @@ export const slackOutbound: ChannelOutboundAdapter = {
     }
     return { ok: true, to: trimmed };
   },
-  sendText: async ({ cfg, to, text, accountId, deps, replyToId }) => {
+  sendText: async ({ to, text, accountId, deps, replyToId }) => {
     const send = deps?.sendSlack ?? sendMessageSlack;
-    const account = resolveSlackAccount({ cfg, accountId });
-    const tokenOverride = resolveSlackTokenOverride({
-      botToken: account.botToken,
-      userToken: account.userToken,
-      userTokenReadOnly: account.config.userTokenReadOnly,
-      operation: "write",
-    });
     const result = await send(to, text, {
       threadTs: replyToId ?? undefined,
       accountId: accountId ?? undefined,
-      ...(tokenOverride ? { token: tokenOverride } : {}),
     });
     return { channel: "slack", ...result };
   },
-  sendMedia: async ({ cfg, to, text, mediaUrl, accountId, deps, replyToId }) => {
+  sendMedia: async ({ to, text, mediaUrl, accountId, deps, replyToId }) => {
     const send = deps?.sendSlack ?? sendMessageSlack;
-    const account = resolveSlackAccount({ cfg, accountId });
-    const tokenOverride = resolveSlackTokenOverride({
-      botToken: account.botToken,
-      userToken: account.userToken,
-      userTokenReadOnly: account.config.userTokenReadOnly,
-      operation: "write",
-    });
     const result = await send(to, text, {
       mediaUrl,
       threadTs: replyToId ?? undefined,
       accountId: accountId ?? undefined,
-      ...(tokenOverride ? { token: tokenOverride } : {}),
     });
     return { channel: "slack", ...result };
   },

src/channels/plugins/slack.ts

@@ -7,7 +7,6 @@ import {
 } from "../../slack/accounts.js";
 import { probeSlack } from "../../slack/probe.js";
 import { sendMessageSlack } from "../../slack/send.js";
-import { resolveSlackTokenOverride } from "../../slack/token.js";
 import { getChatChannelMeta } from "../registry.js";
 import {
   deleteAccountFromConfigSection,
@@ -36,19 +35,8 @@ export const slackPlugin: ChannelPlugin<ResolvedSlackAccount> = {
   pairing: {
     idLabel: "slackUserId",
     normalizeAllowEntry: (entry) => entry.replace(/^(slack|user):/i, ""),
-    notifyApproval: async ({ cfg, id }) => {
-      const account = resolveSlackAccount({ cfg, accountId: DEFAULT_ACCOUNT_ID });
-      const tokenOverride = resolveSlackTokenOverride({
-        botToken: account.botToken,
-        userToken: account.userToken,
-        userTokenReadOnly: account.config.userTokenReadOnly,
-        operation: "write",
-      });
-      await sendMessageSlack(
-        `user:${id}`,
-        PAIRING_APPROVED_MESSAGE,
-        tokenOverride ? { token: tokenOverride } : undefined,
-      );
+    notifyApproval: async ({ id }) => {
+      await sendMessageSlack(`user:${id}`, PAIRING_APPROVED_MESSAGE);
     },
   },
   capabilities: {
@@ -237,36 +225,20 @@ export const slackPlugin: ChannelPlugin<ResolvedSlackAccount> = {
       }
       return { ok: true, to: trimmed };
     },
-    sendText: async ({ to, text, accountId, deps, replyToId, cfg }) => {
+    sendText: async ({ to, text, accountId, deps, replyToId }) => {
       const send = deps?.sendSlack ?? sendMessageSlack;
-      const account = resolveSlackAccount({ cfg, accountId });
-      const tokenOverride = resolveSlackTokenOverride({
-        botToken: account.botToken,
-        userToken: account.userToken,
-        userTokenReadOnly: account.config.userTokenReadOnly,
-        operation: "write",
-      });
       const result = await send(to, text, {
         threadTs: replyToId ?? undefined,
         accountId: accountId ?? undefined,
-        ...(tokenOverride ? { token: tokenOverride } : {}),
       });
       return { channel: "slack", ...result };
     },
-    sendMedia: async ({ to, text, mediaUrl, accountId, deps, replyToId, cfg }) => {
+    sendMedia: async ({ to, text, mediaUrl, accountId, deps, replyToId }) => {
       const send = deps?.sendSlack ?? sendMessageSlack;
-      const account = resolveSlackAccount({ cfg, accountId });
-      const tokenOverride = resolveSlackTokenOverride({
-        botToken: account.botToken,
-        userToken: account.userToken,
-        userTokenReadOnly: account.config.userTokenReadOnly,
-        operation: "write",
-      });
       const result = await send(to, text, {
         mediaUrl,
         threadTs: replyToId ?? undefined,
         accountId: accountId ?? undefined,
-        ...(tokenOverride ? { token: tokenOverride } : {}),
       });
       return { channel: "slack", ...result };
     },

src/config/schema.ts

@@ -204,8 +204,6 @@ const FIELD_LABELS: Record<string, string> = {
   "channels.discord.token": "Discord Bot Token",
   "channels.slack.botToken": "Slack Bot Token",
   "channels.slack.appToken": "Slack App Token",
-  "channels.slack.userToken": "Slack User Token",
-  "channels.slack.userTokenReadOnly": "Slack User Token Read Only",
   "channels.slack.thread.historyScope": "Slack Thread History Scope",
   "channels.slack.thread.inheritParent": "Slack Thread Parent Inheritance",
   "channels.signal.account": "Signal Account",

src/config/slack-token-validation.test.ts

@@ -1,37 +0,0 @@
-import { describe, expect, it } from "vitest";
-
-import { validateConfigObject } from "./config.js";
-
-describe("Slack token config fields", () => {
-  it("accepts user token config fields", () => {
-    const res = validateConfigObject({
-      channels: {
-        slack: {
-          botToken: "xoxb-any",
-          appToken: "xapp-any",
-          userToken: "xoxp-any",
-          userTokenReadOnly: false,
-        },
-      },
-    });
-    expect(res.ok).toBe(true);
-  });
-
-  it("accepts account-level user token config", () => {
-    const res = validateConfigObject({
-      channels: {
-        slack: {
-          accounts: {
-            work: {
-              botToken: "xoxb-any",
-              appToken: "xapp-any",
-              userToken: "xoxp-any",
-              userTokenReadOnly: true,
-            },
-          },
-        },
-      },
-    });
-    expect(res.ok).toBe(true);
-  });
-});

src/config/types.slack.ts

@@ -80,9 +80,6 @@ export type SlackAccountConfig = {
   enabled?: boolean;
   botToken?: string;
   appToken?: string;
-  userToken?: string;
-  /** If true, restrict user token to read operations only. Default: true. */
-  userTokenReadOnly?: boolean;
   /** Allow bot-authored messages to trigger replies (default: false). */
   allowBots?: boolean;
   /** Default mention requirement for channel messages (default: true). */

src/config/zod-schema.providers-core.ts

@@ -220,8 +220,6 @@ export const SlackAccountSchema = z.object({
   configWrites: z.boolean().optional(),
   botToken: z.string().optional(),
   appToken: z.string().optional(),
-  userToken: z.string().optional(),
-  userTokenReadOnly: z.boolean().optional().default(true),
   allowBots: z.boolean().optional(),
   requireMention: z.boolean().optional(),
   groupPolicy: GroupPolicySchema.optional().default("allowlist"),

src/slack/accounts.ts

@@ -1,7 +1,7 @@
 import type { ClawdbotConfig } from "../config/config.js";
 import type { SlackAccountConfig } from "../config/types.js";
 import { DEFAULT_ACCOUNT_ID, normalizeAccountId } from "../routing/session-key.js";
-import { resolveSlackAppToken, resolveSlackBotToken, resolveSlackUserToken } from "./token.js";
+import { resolveSlackAppToken, resolveSlackBotToken } from "./token.js";
 
 export type SlackTokenSource = "env" | "config" | "none";
 
@@ -11,7 +11,6 @@ export type ResolvedSlackAccount = {
   name?: string;
   botToken?: string;
   appToken?: string;
-  userToken?: string;
   botTokenSource: SlackTokenSource;
   appTokenSource: SlackTokenSource;
   config: SlackAccountConfig;
@@ -76,7 +75,6 @@ export function resolveSlackAccount(params: {
   const envApp = allowEnv ? resolveSlackAppToken(process.env.SLACK_APP_TOKEN) : undefined;
   const configBot = resolveSlackBotToken(merged.botToken);
   const configApp = resolveSlackAppToken(merged.appToken);
-  const configUser = resolveSlackUserToken(merged.userToken);
   const botToken = configBot ?? envBot;
   const appToken = configApp ?? envApp;
   const botTokenSource: SlackTokenSource = configBot ? "config" : envBot ? "env" : "none";
@@ -88,7 +86,6 @@ export function resolveSlackAccount(params: {
     name: merged.name?.trim() || undefined,
     botToken,
     appToken,
-    userToken: configUser,
     botTokenSource,
     appTokenSource,
     config: merged,

src/slack/token.ts

@@ -10,44 +10,3 @@ export function resolveSlackBotToken(raw?: string): string | undefined {
 export function resolveSlackAppToken(raw?: string): string | undefined {
   return normalizeSlackToken(raw);
 }
-
-export function resolveSlackUserToken(raw?: string): string | undefined {
-  return normalizeSlackToken(raw);
-}
-
-export type SlackTokenOperation = "read" | "write";
-
-export type SlackTokenSelection = {
-  botToken?: string;
-  userToken?: string;
-  userTokenReadOnly?: boolean;
-  operation: SlackTokenOperation;
-};
-
-function selectSlackTokenNormalized(params: SlackTokenSelection): string | undefined {
-  const allowUserWrites = params.userTokenReadOnly === false;
-  if (params.operation === "read") return params.userToken ?? params.botToken;
-  if (!allowUserWrites) return params.botToken;
-  return params.botToken ?? params.userToken;
-}
-
-export function selectSlackToken(params: SlackTokenSelection): string | undefined {
-  const botToken = resolveSlackBotToken(params.botToken);
-  const userToken = resolveSlackUserToken(params.userToken);
-  return selectSlackTokenNormalized({
-    ...params,
-    botToken,
-    userToken,
-  });
-}
-
-export function resolveSlackTokenOverride(params: SlackTokenSelection): string | undefined {
-  const botToken = resolveSlackBotToken(params.botToken);
-  const userToken = resolveSlackUserToken(params.userToken);
-  const token = selectSlackTokenNormalized({
-    ...params,
-    botToken,
-    userToken,
-  });
-  return token && token !== botToken ? token : undefined;
-}

src/telegram/bot-message-context.ts

@@ -17,7 +17,7 @@ import {
   buildSenderName,
   buildTelegramGroupFrom,
   buildTelegramGroupPeerId,
-  buildTelegramThreadParams,
+  buildTypingThreadParams,
   describeReplyTarget,
   extractTelegramLocation,
   hasBotMention,
@@ -92,7 +92,7 @@ export const buildTelegramMessageContext = async ({
 
   const sendTyping = async () => {
     try {
-      await bot.api.sendChatAction(chatId, "typing", buildTelegramThreadParams(resolvedThreadId));
+      await bot.api.sendChatAction(chatId, "typing", buildTypingThreadParams(resolvedThreadId));
     } catch (err) {
       logVerbose(`telegram typing cue failed for chat ${chatId}: ${String(err)}`);
     }

src/telegram/bot.create-telegram-bot.matches-tg-prefixed-allowfrom-entries-case-insensitively.test.ts

@@ -352,10 +352,8 @@ describe("createTelegramBot", () => {
       getFile: async () => ({ download: async () => new Uint8Array() }),
     });
 
-    expect(sendMessageSpy).toHaveBeenCalledWith(
-      "-1001234567890",
-      expect.any(String),
-      expect.objectContaining({ message_thread_id: 1 }),
-    );
+    expect(sendMessageSpy).toHaveBeenCalledTimes(1);
+    const sendParams = sendMessageSpy.mock.calls[0]?.[2] as { message_thread_id?: number };
+    expect(sendParams?.message_thread_id).toBeUndefined();
   });
 });

src/telegram/bot.test.ts

@@ -1710,11 +1710,9 @@ describe("createTelegramBot", () => {
       getFile: async () => ({ download: async () => new Uint8Array() }),
     });
 
-    expect(sendMessageSpy).toHaveBeenCalledWith(
-      "-1001234567890",
-      expect.any(String),
-      expect.objectContaining({ message_thread_id: 1 }),
-    );
+    expect(sendMessageSpy).toHaveBeenCalledTimes(1);
+    const sendParams = sendMessageSpy.mock.calls[0]?.[2] as { message_thread_id?: number };
+    expect(sendParams?.message_thread_id).toBeUndefined();
   });
 
   it("applies topic skill filters and system prompts", async () => {

src/telegram/bot/helpers.test.ts

@@ -0,0 +1,30 @@
+import { describe, expect, it } from "vitest";
+import { buildTelegramThreadParams, buildTypingThreadParams } from "./helpers.js";
+
+describe("buildTelegramThreadParams", () => {
+  it("omits General topic thread id for message sends", () => {
+    expect(buildTelegramThreadParams(1)).toBeUndefined();
+  });
+
+  it("includes non-General topic thread ids", () => {
+    expect(buildTelegramThreadParams(99)).toEqual({ message_thread_id: 99 });
+  });
+
+  it("normalizes thread ids to integers", () => {
+    expect(buildTelegramThreadParams(42.9)).toEqual({ message_thread_id: 42 });
+  });
+});
+
+describe("buildTypingThreadParams", () => {
+  it("returns undefined when no thread id is provided", () => {
+    expect(buildTypingThreadParams(undefined)).toBeUndefined();
+  });
+
+  it("includes General topic thread id for typing indicators", () => {
+    expect(buildTypingThreadParams(1)).toEqual({ message_thread_id: 1 });
+  });
+
+  it("normalizes thread ids to integers", () => {
+    expect(buildTypingThreadParams(42.9)).toEqual({ message_thread_id: 42 });
+  });
+});

src/telegram/bot/helpers.ts

@@ -19,8 +19,31 @@ export function resolveTelegramForumThreadId(params: {
   return params.messageThreadId ?? undefined;
 }
 
+/**
+ * Build thread params for Telegram API calls (messages, media).
+ * General forum topic (id=1) must be treated like a regular supergroup send:
+ * Telegram rejects sendMessage/sendMedia with message_thread_id=1 ("thread not found").
+ */
 export function buildTelegramThreadParams(messageThreadId?: number) {
-  return messageThreadId != null ? { message_thread_id: messageThreadId } : undefined;
+  if (messageThreadId == null) {
+    return undefined;
+  }
+  const normalized = Math.trunc(messageThreadId);
+  if (normalized === TELEGRAM_GENERAL_TOPIC_ID) {
+    return undefined;
+  }
+  return { message_thread_id: normalized };
+}
+
+/**
+ * Build thread params for typing indicators (sendChatAction).
+ * Empirically, General topic (id=1) needs message_thread_id for typing to appear.
+ */
+export function buildTypingThreadParams(messageThreadId?: number) {
+  if (messageThreadId == null) {
+    return undefined;
+  }
+  return { message_thread_id: Math.trunc(messageThreadId) };
 }
 
 export function resolveTelegramStreamMode(

src/telegram/send.ts

@@ -20,6 +20,7 @@ import { markdownToTelegramHtml } from "./format.js";
 import { recordSentMessage } from "./sent-message-cache.js";
 import { parseTelegramTarget, stripTelegramInternalPrefixes } from "./targets.js";
 import { resolveTelegramVoiceSend } from "./voice.js";
+import { buildTelegramThreadParams } from "./bot/helpers.js";
 
 type TelegramSendOpts = {
   token?: string;
@@ -166,12 +167,10 @@ export async function sendMessageTelegram(
 
   // Build optional params for forum topics and reply threading.
   // Only include these if actually provided to keep API calls clean.
-  const threadParams: Record<string, number> = {};
   const messageThreadId =
     opts.messageThreadId != null ? opts.messageThreadId : target.messageThreadId;
-  if (messageThreadId != null) {
-    threadParams.message_thread_id = Math.trunc(messageThreadId);
-  }
+  const threadIdParams = buildTelegramThreadParams(messageThreadId);
+  const threadParams: Record<string, number> = threadIdParams ? { ...threadIdParams } : {};
   if (opts.replyToMessageId != null) {
     threadParams.reply_to_message_id = Math.trunc(opts.replyToMessageId);
   }