dsh-slack 0.1.0 → 0.2.1

package/README.en.md

@@ -0,0 +1,174 @@
+# dsh-slack
+
+DSH (DeepSeek Harness) community plugin: lets the agent communicate with Slack bidirectionally.
+
+> **v0.2 scope (two-way)**: v0.1 only did one-way "agent → Slack" notifications; v0.2 adds Socket Mode,
+> enabling "Slack message → agent": `slack_inbox` receives messages, `slack_reply` replies in threads.
+> RTM and interactive components (buttons/modals/slash command replies) are out of scope for v0.2 — see
+> [Known limitations and roadmap](#known-limitations-and-roadmap) below.
+
+## Features
+
+- `slack_notify`: send a Markdown text message to a channel (or thread), returning the message `ts`.
+- `slack_channels`: list the channels currently visible to the bot (`conversations.list`).
+- `slack_inbox`: read messages received via Socket Mode (in-memory queue, keeps up to 200).
+- `slack_reply`: reply to an inbox message as a thread (`chat.postMessage` with `thread_ts`).
+- Configuration via `cordis.patch.yml`; tokens support environment-variable fallback (`DSH_SLACK_TOKEN` / `DSH_SLACK_APP_TOKEN`).
+
+## Installation
+
+The plugin runs inside the host process, is installed into the profile via `dsh plugin`, and takes effect after a restart:
+
+```sh
+dsh plugin --profile web add dsh-slack
+```
+
+After installing, restart your dsh Web service; the four tools `slack_notify` / `slack_channels` / `slack_inbox` / `slack_reply` become visible to the model.
+
+## Configuration
+
+Configuration lives in the profile's `cordis.patch.yml`; override this plugin's line by `id: slack` (overriding replaces that line's `config` wholesale — it does not merge). Available options:
+
+| Key | Type | Required | Description |
+| --- | --- | --- | --- |
+| `token` | string | yes* | Slack token: bot token (`xoxb-`) or user token (`xoxp-`). When empty, falls back to the `DSH_SLACK_TOKEN` env var. |
+| `appToken` | string | no* | App-Level Token (starts with `xapp-`); used to receive messages after enabling Socket Mode. When empty, falls back to the `DSH_SLACK_APP_TOKEN` env var. |
+| `defaultChannel` | string | no | Default channel (e.g. `#general`). The default target when the model doesn't specify a channel; written into the `channel` parameter description. |
+
+`*` `token` may be left empty at the "config layer", in which case it falls back to the env var; when both are empty the plugin still loads, but calling the send/list/reply tools returns a Chinese error. An empty `appToken` only warns — no crash — and `slack_inbox` returns an empty queue (one-way mode).
+
+**Method 1: environment variables (recommended, no hard-coded tokens)**
+
+```sh
+# 在启动 dsh 的进程里设置
+export DSH_SLACK_TOKEN=xoxb-你的机器人令牌
+export DSH_SLACK_APP_TOKEN=xapp-你的App级令牌
+```
+
+**Method 2: override in the profile's cordis.patch.yml**
+
+In your profile directory (`$DSH_HOME/profiles/web/cordis.patch.yml`) append:
+
+```yaml
+# 覆盖 dsh-slack 的 slack 行配置（整体替换）
+- id: slack
+  config:
+    token: 'xoxb-你的机器人令牌'
+    appToken: 'xapp-你的App级令牌'
+    defaultChannel: '#general'
+```
+
+> Priority: `config.token` > env var `DSH_SLACK_TOKEN`; `config.appToken` > env var
+> `DSH_SLACK_APP_TOKEN`.
+
+### Create a Slack App and get a token
+
+1. Open <https://api.slack.com/apps>, click **Create New App** (choose `From scratch`, name the app, select the workspace).
+2. On the **OAuth & Permissions** page, under **Scopes → Bot Token Scopes** check:
+   - `chat:write` (required to send messages)
+   - `channels:read` (required to list channels)
+3. Back at the top, click **Install to Workspace** (authorize).
+4. Grab the **Bot User OAuth Token** (starts with `xoxb-`).
+5. Add the bot (App) to the channels it should post in: `/invite @your-bot` in the channel (required for private channels).
+
+### Enable Socket Mode (two-way message receiving)
+
+To receive Slack messages (`slack_inbox` / `slack_reply`), enable Socket Mode and generate an App-Level Token:
+
+1. Open <https://api.slack.com/apps> and open your App.
+2. Open the **Socket Mode** page → turn on the toggle (**Enable Socket Mode**).
+3. Click **Generate Token and Scopes** to create an App-Level Token: name the token, check the `connections:write` scope.
+   Copy the `xapp-` App-Level Token (shown only once — save it immediately).
+4. Open the **Event Subscriptions** page, enable events, and under **Subscribe to bot events → Add Bot User Event** add:
+   - `message.channels` (public channel messages)
+   - `message.im` (bot DMs)
+5. Put the App-Level Token into `appToken` (or the `DSH_SLACK_APP_TOKEN` env var).
+6. Restart the dsh Web service; the plugin connects automatically via Socket Mode and starts receiving messages.
+
+> Without `appToken` the plugin **won't crash**: it only prints a warning and `slack_inbox` returns an empty queue (with a Chinese hint).
+> Socket Mode network errors are auto-reconnected by the SDK; the plugin only logs a warning and never throws.
+
+## Tool reference
+
+### `slack_notify`
+
+Send Markdown text to a channel/thread (underlying `chat.postMessage`).
+
+| Param | Type | Required | Description |
+| --- | --- | --- | --- |
+| `channel` | string | yes | Channel name (e.g. `#general`) or channel ID. |
+| `text` | string | yes | The Markdown text to send. |
+| `thread_ts` | string | no | The `ts` of the thread to reply to. |
+
+Returns: `{ "ts": "...", "channel": "#general" }` (`ts` for later `thread_ts` reference).
+
+### `slack_channels`
+
+List channels visible to the bot (underlying `conversations.list`).
+
+No parameters. Returns: `{ "channels": [{ "id": "...", "name": "..." }, ...] }`.
+
+### `slack_inbox`
+
+Read messages received via Socket Mode (in-memory queue, keeps up to 200, newest first).
+
+| Param | Type | Required | Description |
+| --- | --- | --- | --- |
+| `limit` | integer | no | Maximum number of messages to return (default 10, range 1-50). |
+| `markRead` | boolean | no | When `true`, clears the inbox queue after returning (mark as read). |
+
+Returns: `{ "messages": [{ "ts": "...", "channel": "...", "user": "...", "text": "..." }, ...] }`.
+
+### `slack_reply`
+
+Reply to an inbox message as a thread (underlying `chat.postMessage` with `thread_ts`).
+
+| Param | Type | Required | Description |
+| --- | --- | --- | --- |
+| `channel` | string | yes | Channel name (e.g. `#general`) or channel ID. |
+| `text` | string | yes | Reply content (Markdown text). |
+| `thread_ts` | string | yes | The `ts` of the message to reply to (from `slack_inbox`). |
+
+Returns: `{ "ts": "...", "channel": "#general" }`.
+
+## Error handling
+
+All error messages are in Chinese, readable by both the model and the user:
+
+- Unconfigured token: `token 未配置：缺少 Slack 机器人令牌（xoxb-）…请在 profile 的 cordis.patch.yml 覆盖 slack 行的 config.token 并重启，或设置环境变量 DSH_SLACK_TOKEN。`
+- Unconfigured App-Level Token: only a warning; `slack_inbox` returns an empty queue (with a Chinese hint) and other tools are unaffected.
+- `invalid_auth`: hints to check/regenerate the token.
+- `channel_not_found`: hints the channel name or ID is wrong.
+- `not_in_channel`: hints to invite the bot App into the channel first.
+- `token_revoked` / `account_inactive` / `missing_scope`: hints permission or token expiry, reinstall the App.
+
+## Development and testing
+
+```sh
+pnpm install   # 安装依赖并触发 prepare（tsc 构建）
+pnpm build     # tsc 编译 src → lib
+pnpm test      # 先 build，再用 node:test 跑 test/*.test.mjs
+```
+
+Tests need no real token: parameter compilation, config parsing (incl. env fallback), tool registration (4 tools + Chinese error on missing config),
+injecting a fake client to assert `postMessage` arguments (incl. `thread_ts`), output schema pure-JSON validation,
+inbox queue capacity/clear, Socket Mode event parsing (fake event objects), and no-crash on missing appToken.
+
+## Known limitations and roadmap
+
+- **v0.1 is one-way notification (agent→Slack)**; **v0.2 is two-way via Socket Mode** (`slack_inbox` / `slack_reply`).
+- **No** RTM or interactive components (buttons/modals/slash command replies).
+- `slack_inbox` is an in-process memory queue: cleared on restart, not persisted; keeps up to 200, dropping the oldest when full.
+- `channel` is a required parameter; `defaultChannel` is currently only written into the `channel` parameter description as a hint — it does not replace the required `channel`.
+- With a missing token the plugin still loads (lazy loading); the error is only thrown when the tool is called; a missing appToken only warns.
+
+Roadmap: v0.3 plans to introduce interactive components (buttons/modals) and a persisted inbox.
+
+## Dependencies
+
+- Runtime: `@slack/web-api` (official WebClient), `@slack/socket-mode` (Socket Mode client)
+- peer (provided by the host; not imported directly by the plugin at runtime): `@deepseek-ai/cordis`, `@deepseek-ai/dsh-tools`
+
+## License
+
+MIT

package/README.md

@@ -1,16 +1,21 @@
+[English](README.en.md)
+
 # dsh-slack
 
-DSH（DeepSeek Harness）社区插件：让 agent 向 Slack 发通知/桥接消息。
+DSH（DeepSeek Harness）社区插件：让 agent 与 Slack 双向通信。
 
-> **v0.1 范围（单向）**：本版本只做「agent → Slack」的单向通知（发消息、列频道）。
-> 双向对话（Slack 消息实时流入 agent）、Socket Mode、RTM、交互组件都不在 v0.1，见下方
+> **v0.2 范围（双向）**：v0.1 只做「agent → Slack」单向通知；v0.2 新增 Socket Mode，
+> 支持「Slack 消息 → agent」：`slack_inbox` 收取消息、`slack_reply` 线程回复。
+> RTM、交互组件（按钮/弹窗/slash command 回复）不在 v0.2，见下方
 > [已知限制与路线图](#已知限制与路线图)。
 
 ## 功能
 
-- `slack_notify`：向指定频道（或线程）发送一条 Markdown 文本消息，返回消息 `ts` 供后续引用。
+- `slack_notify`：向指定频道（或线程）发送一条 Markdown 文本消息，返回消息 `ts`。
 - `slack_channels`：列出机器人当前可见的频道（`conversations.list`）。
-- 配置走 `cordis.patch.yml`，令牌支持环境变量回退 `DSH_SLACK_TOKEN`。
+- `slack_inbox`：读取通过 Socket Mode 收到的消息（内存队列，最多保留 200 条）。
+- `slack_reply`：以线程回复形式回复某条收件箱消息（`chat.postMessage` 带 `thread_ts`）。
+- 配置走 `cordis.patch.yml`，令牌支持环境变量回退（`DSH_SLACK_TOKEN` / `DSH_SLACK_APP_TOKEN`）。
 
 ## 安装
 
@@ -20,7 +25,8 @@ DSH（DeepSeek Harness）社区插件：让 agent 向 Slack 发通知/桥接消
 dsh plugin --profile web add dsh-slack
 ```
 
-安装后重启你的 dsh Web 服务，`slack_notify` / `slack_channels` 两个工具即对模型可见。
+安装后重启你的 dsh Web 服务，`slack_notify` / `slack_channels` / `slack_inbox` / `slack_reply`
+四个工具即对模型可见。
 
 ## 配置
 
@@ -30,16 +36,18 @@ dsh plugin --profile web add dsh-slack
 | 键 | 类型 | 必填 | 说明 |
 | --- | --- | --- | --- |
 | `token` | string | 是* | Slack 令牌：机器人令牌（`xoxb-`）或用户令牌（`xoxp-`）。留空时回退到环境变量 `DSH_SLACK_TOKEN`。 |
+| `appToken` | string | 否* | App-Level Token（`xapp-` 开头），开启 Socket Mode 后用于接收消息。留空时回退到环境变量 `DSH_SLACK_APP_TOKEN`。 |
 | `defaultChannel` | string | 否 | 默认频道（如 `#general`）。模型未特别指定频道时的默认目标，写进 `channel` 参数说明里。 |
 
-`*` `token` 在「配置层」可留空，此时回退环境变量；两者都为空时插件照常加载，但调用工具时会
-返回中文报错（懒加载，见[错误处理](#错误处理)）。
+`*` `token` 在「配置层」可留空，此时回退环境变量；两者都为空时插件照常加载，但调用发消息/列频道/
+回复工具时会返回中文报错。`appToken` 留空则只告警、不崩溃，`slack_inbox` 返回空队列（单向模式）。
 
 **方式一：环境变量（推荐，不写死令牌）**
 
 ```sh
 # 在启动 dsh 的进程里设置
 export DSH_SLACK_TOKEN=xoxb-你的机器人令牌
+export DSH_SLACK_APP_TOKEN=xapp-你的App级令牌
 ```
 
 **方式二：profile 的 cordis.patch.yml 直接覆盖**
@@ -51,10 +59,12 @@ export DSH_SLACK_TOKEN=xoxb-你的机器人令牌
 - id: slack
   config:
     token: 'xoxb-你的机器人令牌'
+    appToken: 'xapp-你的App级令牌'
     defaultChannel: '#general'
 ```
 
-> 优先级：`config.token` > 环境变量 `DSH_SLACK_TOKEN`。
+> 优先级：`config.token` > 环境变量 `DSH_SLACK_TOKEN`；`config.appToken` > 环境变量
+> `DSH_SLACK_APP_TOKEN`。
 
 ### 创建 Slack App 并拿令牌
 
@@ -66,6 +76,23 @@ export DSH_SLACK_TOKEN=xoxb-你的机器人令牌
 4. 拿到 **Bot User OAuth Token**（以 `xoxb-` 开头）。
 5. 把机器人（App）加进它要发消息的频道：在频道里 `/invite @你的机器人`（私有频道必需）。
 
+### 开启 Socket Mode（双向收消息）
+
+要接收 Slack 消息（`slack_inbox` / `slack_reply`），需要开启 Socket Mode 并生成 App-Level Token：
+
+1. 打开 <https://api.slack.com/apps>，进入你的 App。
+2. 左侧 **Socket Mode** 页 → 打开开关（**Enable Socket Mode**）。
+3. 点 **Generate Token and Scopes** 生成 App-Level Token：给 Token 起名，勾选 `connections:write` scope。
+   生成后拿到以 `xapp-` 开头的 App-Level Token（只显示一次，请立即保存）。
+4. 进入 **Event Subscriptions** 页，开启事件订阅，在 **Subscribe to bot events → Add Bot User Event** 添加：
+   - `message.channels`（公开频道消息）
+   - `message.im`（机器人私信）
+5. 把 App-Level Token 配进 `appToken`（或环境变量 `DSH_SLACK_APP_TOKEN`）。
+6. 重启 dsh Web 服务，插件自动通过 Socket Mode 建立连接并开始收消息。
+
+> 未配置 `appToken` 时插件**不会崩溃**：只打印告警，`slack_inbox` 返回空队列（中文提示）。
+> Socket Mode 网络错误由 SDK 自动重连，插件只记录告警、不抛崩。
+
 ## 工具清单
 
 ### `slack_notify`
@@ -76,7 +103,7 @@ export DSH_SLACK_TOKEN=xoxb-你的机器人令牌
 | --- | --- | --- | --- |
 | `channel` | string | 是 | 频道名（如 `#general`）或频道 ID。 |
 | `text` | string | 是 | 要发送的 Markdown 文本。 |
-| `thread_ts` | string | 否 | 回复某条消息所在线程的 `ts`（即 `slack_notify` 返回的 `ts`）。 |
+| `thread_ts` | string | 否 | 回复某条消息所在线程的 `ts`。 |
 
 返回：`{ "ts": "...", "channel": "#general" }`（`ts` 供后续 `thread_ts` 引用）。
 
@@ -86,11 +113,35 @@ export DSH_SLACK_TOKEN=xoxb-你的机器人令牌
 
 无参数。返回：`{ "channels": [{ "id": "...", "name": "..." }, ...] }`。
 
+### `slack_inbox`
+
+读取通过 Socket Mode 收到的消息（内存队列，最多保留 200 条，新的在前）。
+
+| 参数 | 类型 | 必填 | 说明 |
+| --- | --- | --- | --- |
+| `limit` | integer | 否 | 最多返回的消息数（默认 10，范围 1-50）。 |
+| `markRead` | boolean | 否 | 为 `true` 时，返回后清空收件箱队列（标记已读）。 |
+
+返回：`{ "messages": [{ "ts": "...", "channel": "...", "user": "...", "text": "..." }, ...] }`。
+
+### `slack_reply`
+
+以线程回复形式回复某条收件箱消息（底层 `chat.postMessage` 带 `thread_ts`）。
+
+| 参数 | 类型 | 必填 | 说明 |
+| --- | --- | --- | --- |
+| `channel` | string | 是 | 频道名（如 `#general`）或频道 ID。 |
+| `text` | string | 是 | 回复内容（Markdown 文本）。 |
+| `thread_ts` | string | 是 | 要回复消息的 `ts`（来自 `slack_inbox` 返回的 `ts`）。 |
+
+返回：`{ "ts": "...", "channel": "#general" }`。
+
 ## 错误处理
 
 所有错误信息均为中文，模型与用户都能直接读懂：
 
 - 未配置令牌：`token 未配置：缺少 Slack 机器人令牌（xoxb-）…请在 profile 的 cordis.patch.yml 覆盖 slack 行的 config.token 并重启，或设置环境变量 DSH_SLACK_TOKEN。`
+- 未配置 App-Level Token：只告警，`slack_inbox` 返回空队列（含中文提示），不影响其它工具。
 - `invalid_auth`：提示检查/重新生成 token。
 - `channel_not_found`：提示频道名或频道 ID 错误。
 - `not_in_channel`：提示先把机器人 App 邀请进频道。
@@ -104,23 +155,24 @@ pnpm build     # tsc 编译 src → lib
 pnpm test      # 先 build，再用 node:test 跑 test/*.test.mjs
 ```
 
-测试无需真实 token：参数编译、配置解析（含 env 回退）、工具注册（2 个工具 + 缺配置中文报错）、
-注入 fake client 断言 `postMessage` 参数、输出 schema 纯 JSON 校验。
+测试无需真实 token：参数编译、配置解析（含 env 回退）、工具注册（4 个工具 + 缺配置中文报错）、
+注入 fake client 断言 `postMessage` 参数（含 `thread_ts`）、输出 schema 纯 JSON 校验、
+收件箱队列容量/清空、Socket Mode 事件解析（fake event 对象）、appToken 缺失不崩。
 
 ## 已知限制与路线图
 
-- **v0.1 是单向通知（agent→Slack）**：不能从 Slack 收消息反向驱动 agent。
-- **不支持** Socket Mode 实时接收、RTM、交互组件（按钮/弹窗/slash command 回复）。
+- **v0.1 是单向通知（agent→Slack）**；**v0.2 通过 Socket Mode 实现双向**（`slack_inbox` / `slack_reply`）。
+- **不支持** RTM、交互组件（按钮/弹窗/slash command 回复）。
+- `slack_inbox` 为进程内存队列：重启即清空，且不持久化；最多保留 200 条，满则丢最旧。
 - `channel` 为必填参数，`defaultChannel` 目前只作为说明提示写入 `channel` 参数描述，不替代
   必填的 `channel`。
-- 令牌缺失时插件仍会加载（懒加载），错误在工具被调用时才抛出。
+- 令牌缺失时插件仍会加载（懒加载），错误在工具被调用时才抛出；appToken 缺失则仅告警。
 
-路线图：v0.2 计划引入 Socket Mode（`@slack/socket-mode`）实现「Slack 消息 → agent」双向桥接与
-交互组件。
+路线图：v0.3 计划引入交互组件（按钮/弹窗）与持久化收件箱。
 
 ## 依赖
 
-- 运行时：`@slack/web-api`（官方 WebClient）
+- 运行时：`@slack/web-api`（官方 WebClient）、`@slack/socket-mode`（Socket Mode 客户端）
 - peer（由宿主提供，插件运行时不直接 import）：`@deepseek-ai/cordis`、`@deepseek-ai/dsh-tools`
 
 ## License

package/cordis.patch.yml

@@ -9,3 +9,6 @@
         token: ''
         # 默认频道（可选）：模型未特别指定频道时的默认目标（如 #general）。
         defaultChannel: ''
+        # App-Level Token（xapp- 开头）：开启 Socket Mode 后用于接收消息。
+        # 留空时回退到环境变量 DSH_SLACK_APP_TOKEN；两者都为空则仅单向（不收消息）。
+        appToken: ''

package/lib/config.d.ts

@@ -8,9 +8,15 @@
 export interface SlackConfig {
     token: string;
     defaultChannel: string;
+    /** App-Level Token（xapp- 开头），用于 Socket Mode 接收消息。 */
+    appToken: string;
+    /** Slack Web API 基地址；默认官方 https://slack.com/api/。企业网格（Enterprise Grid）与本地协议级测试可覆盖。 */
+    slackApiUrl?: string;
 }
 /** token 的环境变量名。 */
 export declare const ENV_TOKEN = "DSH_SLACK_TOKEN";
+/** appToken 的环境变量名。 */
+export declare const ENV_APP_TOKEN = "DSH_SLACK_APP_TOKEN";
 /**
  * 解析原始配置。永不抛错：非法形状返回 undefined，让插件懒加载不失败。
  */
@@ -19,6 +25,10 @@ export declare function parseConfig(raw: unknown): SlackConfig | undefined;
  * 解析 token：config.token 优先，其次环境变量 DSH_SLACK_TOKEN。
  */
 export declare function resolveToken(config: SlackConfig | undefined): string;
+/**
+ * 解析 appToken：config.appToken 优先，其次环境变量 DSH_SLACK_APP_TOKEN。
+ */
+export declare function resolveAppToken(config: SlackConfig | undefined): string;
 /**
  * 解析默认频道。
  */

package/lib/config.js

@@ -6,18 +6,22 @@
  */
 /** token 的环境变量名。 */
 export const ENV_TOKEN = 'DSH_SLACK_TOKEN';
+/** appToken 的环境变量名。 */
+export const ENV_APP_TOKEN = 'DSH_SLACK_APP_TOKEN';
 /**
  * 解析原始配置。永不抛错：非法形状返回 undefined，让插件懒加载不失败。
  */
 export function parseConfig(raw) {
     if (raw === undefined || raw === null)
-        return { token: '', defaultChannel: '' };
+        return { token: '', defaultChannel: '', appToken: '' };
     if (typeof raw !== 'object' || Array.isArray(raw))
         return undefined;
     const obj = raw;
     const token = typeof obj.token === 'string' ? obj.token.trim() : '';
     const defaultChannel = typeof obj.defaultChannel === 'string' ? obj.defaultChannel.trim() : '';
-    return { token, defaultChannel };
+    const appToken = typeof obj.appToken === 'string' ? obj.appToken.trim() : '';
+    const slackApiUrl = typeof obj.slackApiUrl === 'string' && obj.slackApiUrl.trim() !== '' ? obj.slackApiUrl.trim() : undefined;
+    return { token, defaultChannel, appToken, ...(slackApiUrl !== undefined ? { slackApiUrl } : {}) };
 }
 /**
  * 解析 token：config.token 优先，其次环境变量 DSH_SLACK_TOKEN。
@@ -28,6 +32,15 @@ export function resolveToken(config) {
         return fromConfig;
     return process.env[ENV_TOKEN]?.trim() ?? '';
 }
+/**
+ * 解析 appToken：config.appToken 优先，其次环境变量 DSH_SLACK_APP_TOKEN。
+ */
+export function resolveAppToken(config) {
+    const fromConfig = config?.appToken?.trim() ?? '';
+    if (fromConfig)
+        return fromConfig;
+    return process.env[ENV_APP_TOKEN]?.trim() ?? '';
+}
 /**
  * 解析默认频道。
  */

package/lib/inbox.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Socket Mode 收件箱：把收到的 Slack message 事件解析进内存队列。
+ * 队列容量 200，满则丢最旧；解析为纯函数，便于注入 fake 事件测试。
+ */
+/** 收件箱中的一条消息。 */
+export interface InboxMessage {
+    ts: string;
+    channel: string;
+    user: string;
+    text: string;
+}
+/** 队列容量上限。 */
+export declare const INBOX_CAPACITY = 200;
+/** 创建收件箱队列。 */
+export declare function createInboxQueue(capacity?: number): InboxQueue;
+/**
+ * 内存消息队列：先进先出，容量满时丢弃最旧消息。
+ */
+export declare class InboxQueue {
+    private items;
+    readonly capacity: number;
+    constructor(capacity?: number);
+    /** 追加一条消息；超过容量时丢弃最旧。 */
+    push(message: InboxMessage): void;
+    /** 返回最近 limit 条消息（新的在前）。 */
+    list(limit: number): InboxMessage[];
+    /** 清空队列。 */
+    clear(): void;
+    /** 当前队列长度。 */
+    get size(): number;
+}
+/**
+ * 从 Socket Mode 事件里解析出一条消息；不满足条件返回 null。
+ * - 兼容直接 message 事件、slack_event 包（{ type: 'events_api', body: { event } }）与
+ *   按类型监听包（{ event }）。
+ * - 排除 subtype 非空的消息、bot 自己发的消息（bot_id 非空，或 user 等于 botUserId）。
+ */
+export declare function parseMessageEvent(raw: unknown, botUserId?: string): InboxMessage | null;

package/lib/inbox.js

@@ -0,0 +1,99 @@
+/**
+ * Socket Mode 收件箱：把收到的 Slack message 事件解析进内存队列。
+ * 队列容量 200，满则丢最旧；解析为纯函数，便于注入 fake 事件测试。
+ */
+/** 队列容量上限。 */
+export const INBOX_CAPACITY = 200;
+/** 创建收件箱队列。 */
+export function createInboxQueue(capacity = INBOX_CAPACITY) {
+    return new InboxQueue(capacity);
+}
+/**
+ * 内存消息队列：先进先出，容量满时丢弃最旧消息。
+ */
+export class InboxQueue {
+    items = [];
+    capacity;
+    constructor(capacity = INBOX_CAPACITY) {
+        this.capacity = capacity;
+    }
+    /** 追加一条消息；超过容量时丢弃最旧。 */
+    push(message) {
+        this.items.push(message);
+        if (this.items.length > this.capacity) {
+            this.items.splice(0, this.items.length - this.capacity);
+        }
+    }
+    /** 返回最近 limit 条消息（新的在前）。 */
+    list(limit) {
+        const n = Math.max(0, Math.trunc(limit));
+        if (n === 0)
+            return [];
+        return this.items.slice(-n).reverse();
+    }
+    /** 清空队列。 */
+    clear() {
+        this.items = [];
+    }
+    /** 当前队列长度。 */
+    get size() {
+        return this.items.length;
+    }
+}
+function isObject(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+/**
+ * 从 Socket Mode 事件里解析出一条消息；不满足条件返回 null。
+ * - 兼容直接 message 事件、slack_event 包（{ type: 'events_api', body: { event } }）与
+ *   按类型监听包（{ event }）。
+ * - 排除 subtype 非空的消息、bot 自己发的消息（bot_id 非空，或 user 等于 botUserId）。
+ */
+export function parseMessageEvent(raw, botUserId) {
+    const event = unwrapMessageEvent(raw);
+    if (event === null)
+        return null;
+    if (event.type !== 'message')
+        return null;
+    const subtype = event.subtype;
+    if (typeof subtype === 'string' && subtype !== '')
+        return null;
+    const botId = event.bot_id;
+    if (typeof botId === 'string' && botId !== '')
+        return null;
+    if (botUserId !== undefined && event.user === botUserId)
+        return null;
+    const ts = event.ts;
+    const channel = event.channel;
+    const user = event.user;
+    const text = event.text;
+    if (typeof ts !== 'string' || ts === '')
+        return null;
+    if (typeof channel !== 'string' || channel === '')
+        return null;
+    if (typeof user !== 'string' || user === '')
+        return null;
+    if (typeof text !== 'string' || text === '')
+        return null;
+    return { ts, channel, user, text };
+}
+function unwrapMessageEvent(raw) {
+    if (!isObject(raw))
+        return null;
+    const type = raw.type;
+    if (type === 'message')
+        return raw;
+    if (type === 'events_api') {
+        const body = raw.body;
+        if (isObject(body) && isObject(body.event))
+            return body.event;
+        if (isObject(raw.event))
+            return raw.event;
+        return null;
+    }
+    // 按类型监听的包：{ event: { type: 'message', ... } }
+    const inner = raw.event;
+    if (isObject(inner) && inner.type === 'message')
+        return inner;
+    return null;
+}

package/lib/index.d.ts

@@ -1,18 +1,21 @@
 /**
  * dsh-slack：DSH 社区 Slack 通知/桥接插件。
- * v0.1 只做单向通知（agent→Slack），无 Socket Mode / RTM / 交互组件。
+ * v0.2 新增 Socket Mode 双向：slack_inbox 收消息、slack_reply 线程回复。
  * @module dsh-slack
  */
 import type { SlackContext } from './types.js';
 export declare const name = "dsh-slack";
 export declare const inject: string[];
 export { compileParameters, type ParameterDsl, type ParameterDslMap, type JsonSchemaNode } from './compile.js';
-export { parseConfig, resolveToken, resolveDefaultChannel, requireToken, ENV_TOKEN, type SlackConfig, } from './config.js';
-export { createWebSlackClient, mapSlackError, assertChannel, assertText, type SlackClient, type PostMessageParams, type ChannelInfo, } from './slack-client.js';
-export { buildNotifyTool, buildChannelsTool, type ToolDeps } from './tools.js';
+export { parseConfig, resolveToken, resolveDefaultChannel, requireToken, resolveAppToken, ENV_TOKEN, ENV_APP_TOKEN, type SlackConfig, } from './config.js';
+export { createWebSlackClient, mapSlackError, assertChannel, assertText, assertThreadTs, type SlackClient, type PostMessageParams, type ChannelInfo, } from './slack-client.js';
+export { buildNotifyTool, buildChannelsTool, buildInboxTool, buildReplyTool, type ToolDeps } from './tools.js';
+export { parseMessageEvent, InboxQueue, createInboxQueue, INBOX_CAPACITY, type InboxMessage } from './inbox.js';
+export { startSocketModeClient, type SocketMessageHandler } from './socket.js';
 export type { SlackContext, ToolDefinition, ToolOutputDefinition, ContentBlock } from './types.js';
 /**
  * 插件入口。配置缺失【不失败】（懒加载）：只 console.warn；
- * token 缺失在每个工具的 execute 时抛出带中文指引的错误。
+ * token 缺失在每个工具的 execute 时抛出带中文指引的错误；
+ * appToken 存在时启动 Socket Mode（ctx.effect 管理生命周期，dispose 时断开）。
  */
 export declare function apply(ctx: SlackContext, rawConfig: unknown): void;

package/lib/index.js

@@ -1,47 +1,85 @@
 /**
  * dsh-slack：DSH 社区 Slack 通知/桥接插件。
- * v0.1 只做单向通知（agent→Slack），无 Socket Mode / RTM / 交互组件。
+ * v0.2 新增 Socket Mode 双向：slack_inbox 收消息、slack_reply 线程回复。
  * @module dsh-slack
  */
-import { parseConfig, requireToken } from './config.js';
+import { parseConfig, requireToken, resolveAppToken, resolveToken } from './config.js';
 import { createWebSlackClient } from './slack-client.js';
-import { buildChannelsTool, buildNotifyTool } from './tools.js';
+import { buildChannelsTool, buildInboxTool, buildNotifyTool, buildReplyTool } from './tools.js';
+import { createInboxQueue } from './inbox.js';
+import { startSocketModeClient } from './socket.js';
 export const name = 'dsh-slack';
 export const inject = ['tools'];
 export { compileParameters } from './compile.js';
-export { parseConfig, resolveToken, resolveDefaultChannel, requireToken, ENV_TOKEN, } from './config.js';
-export { createWebSlackClient, mapSlackError, assertChannel, assertText, } from './slack-client.js';
-export { buildNotifyTool, buildChannelsTool } from './tools.js';
+export { parseConfig, resolveToken, resolveDefaultChannel, requireToken, resolveAppToken, ENV_TOKEN, ENV_APP_TOKEN, } from './config.js';
+export { createWebSlackClient, mapSlackError, assertChannel, assertText, assertThreadTs, } from './slack-client.js';
+export { buildNotifyTool, buildChannelsTool, buildInboxTool, buildReplyTool } from './tools.js';
+export { parseMessageEvent, InboxQueue, createInboxQueue, INBOX_CAPACITY } from './inbox.js';
+export { startSocketModeClient } from './socket.js';
 /**
  * 插件入口。配置缺失【不失败】（懒加载）：只 console.warn；
- * token 缺失在每个工具的 execute 时抛出带中文指引的错误。
+ * token 缺失在每个工具的 execute 时抛出带中文指引的错误；
+ * appToken 存在时启动 Socket Mode（ctx.effect 管理生命周期，dispose 时断开）。
  */
 export function apply(ctx, rawConfig) {
+    const warn = (message, ...args) => {
+        const logger = ctx.logger;
+        if (logger !== undefined && typeof logger.warn === 'function') {
+            logger.warn(message, ...args);
+        }
+        else {
+            console.warn(message, ...args);
+        }
+    };
     let config;
     try {
         config = parseConfig(rawConfig);
     }
     catch (error) {
-        console.warn('[dsh-slack] 配置解析失败，工具将在调用时报错：', error);
+        warn('[dsh-slack] 配置解析失败，工具将在调用时报错：', error);
         config = undefined;
     }
     if (config === undefined) {
-        console.warn('[dsh-slack] 配置缺失或格式错误：slack_notify / slack_channels 已注册，但调用时会报错。请在 profile 的 cordis.patch.yml 配置 slack 行并重启。');
+        warn('[dsh-slack] 配置缺失或格式错误：slack_notify / slack_channels / slack_inbox / slack_reply 已注册，但调用时会报错。请在 profile 的 cordis.patch.yml 配置 slack 行并重启。');
     }
     else {
-        const token = config.token.trim() || process.env.DSH_SLACK_TOKEN?.trim();
-        if (!token) {
-            console.warn('[dsh-slack] 未检测到 Slack 令牌（config.token 与 DSH_SLACK_TOKEN 均为空）：slack_notify / slack_channels 调用时会报错。');
+        if (!resolveToken(config)) {
+            warn('[dsh-slack] 未检测到 Slack 令牌（config.token 与 DSH_SLACK_TOKEN 均为空）：slack_notify / slack_channels / slack_reply 调用时会报错。');
+        }
+        const appToken = resolveAppToken(config);
+        if (!appToken) {
+            warn('[dsh-slack] 未检测到 App-Level Token（config.appToken 与 DSH_SLACK_APP_TOKEN 均为空）：未开启 Socket Mode，slack_inbox 将返回空队列。');
+        }
+        else if (!appToken.startsWith('xapp-')) {
+            warn('[dsh-slack] appToken 格式错误（应以 xapp- 开头）：已跳过 Socket Mode 启动。');
         }
     }
+    const inboxQueue = createInboxQueue();
     const configProvider = () => config;
     const clientProvider = () => {
         // 每次调用时重新解析配置（config.token 优先，环境变量回退），并懒创建客户端。
         const current = parseConfig(rawConfig);
         const token = requireToken(current);
-        return createWebSlackClient(token);
+        return createWebSlackClient(token, current?.slackApiUrl);
     };
-    const deps = { clientProvider, configProvider };
+    const inboxProvider = () => inboxQueue;
+    const deps = { clientProvider, configProvider, inboxProvider };
+    const appToken = resolveAppToken(config);
+    if (appToken !== '' && appToken.startsWith('xapp-')) {
+        const startSocket = () => startSocketModeClient(appToken, {
+            onMessage(message) {
+                inboxQueue.push(message);
+            },
+        }, warn);
+        if (typeof ctx.effect === 'function') {
+            ctx.effect(startSocket);
+        }
+        else {
+            startSocket();
+        }
+    }
     ctx.tools.register(buildNotifyTool(deps));
     ctx.tools.register(buildChannelsTool(deps));
+    ctx.tools.register(buildInboxTool(deps));
+    ctx.tools.register(buildReplyTool(deps));
 }

package/lib/slack-client.d.ts

@@ -23,7 +23,7 @@ export interface SlackClient {
     listChannels(): Promise<ChannelInfo[]>;
 }
 /** 用官方 WebClient 实现。 */
-export declare function createWebSlackClient(token: string): SlackClient;
+export declare function createWebSlackClient(token: string, slackApiUrl?: string): SlackClient;
 /**
  * 把 Slack API 错误映射为全中文提示。
  */
@@ -32,3 +32,5 @@ export declare function mapSlackError(error: unknown): string;
 export declare function assertChannel(channel: unknown): string;
 /** 校验 text 参数：必须是非空字符串。 */
 export declare function assertText(text: unknown): string;
+/** 校验 thread_ts 参数：必须是待回复消息 ts 的非空字符串。 */
+export declare function assertThreadTs(thread_ts: unknown): string;

package/lib/slack-client.js

@@ -4,8 +4,8 @@
  */
 import { WebClient } from '@slack/web-api';
 /** 用官方 WebClient 实现。 */
-export function createWebSlackClient(token) {
-    const client = new WebClient(token);
+export function createWebSlackClient(token, slackApiUrl) {
+    const client = new WebClient(token, { ...(slackApiUrl !== undefined && slackApiUrl !== '' ? { slackApiUrl } : {}) });
     return {
         async postMessage(params) {
             const result = await client.chat.postMessage({
@@ -63,3 +63,10 @@ export function assertText(text) {
     }
     return text;
 }
+/** 校验 thread_ts 参数：必须是待回复消息 ts 的非空字符串。 */
+export function assertThreadTs(thread_ts) {
+    if (typeof thread_ts !== 'string' || thread_ts.trim() === '') {
+        throw new Error('thread_ts 参数错误：必须是待回复消息的 ts（来自 slack_inbox 返回的 ts）的非空字符串。');
+    }
+    return thread_ts.trim();
+}

package/lib/socket.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Socket Mode 启动/生命周期：用 @slack/socket-mode 建立 WebSocket，
+ * 收到 message 事件写入收件箱；网络错误只 warn 不抛崩（SDK 自带自动重连）。
+ */
+import { type InboxMessage } from './inbox.js';
+/** Socket 消息回调。 */
+export interface SocketMessageHandler {
+    onMessage(message: InboxMessage): void;
+}
+type Warn = (message: string, ...args: unknown[]) => void;
+/**
+ * 启动 Socket Mode 客户端，返回 dispose 函数（断开连接）。
+ * 网络错误 / 解析错误均 try/catch + warn，绝不抛出。
+ */
+export declare function startSocketModeClient(appToken: string, handler: SocketMessageHandler, warn: Warn): () => void;
+export {};

package/lib/socket.js

@@ -0,0 +1,44 @@
+/**
+ * Socket Mode 启动/生命周期：用 @slack/socket-mode 建立 WebSocket，
+ * 收到 message 事件写入收件箱；网络错误只 warn 不抛崩（SDK 自带自动重连）。
+ */
+import { SocketModeClient } from '@slack/socket-mode';
+import { parseMessageEvent } from './inbox.js';
+/**
+ * 启动 Socket Mode 客户端，返回 dispose 函数（断开连接）。
+ * 网络错误 / 解析错误均 try/catch + warn，绝不抛出。
+ */
+export function startSocketModeClient(appToken, handler, warn) {
+    const client = new SocketModeClient({ appToken });
+    client.on('slack_event', (...args) => {
+        try {
+            const message = parseMessageEvent(args[0]);
+            if (message !== null)
+                handler.onMessage(message);
+        }
+        catch (error) {
+            warn('[dsh-slack] 解析 Socket Mode 事件失败：', error);
+        }
+    });
+    client.on('error', (...args) => {
+        warn('[dsh-slack] Socket Mode 连接错误（SDK 会自动重连）：', args[0]);
+    });
+    try {
+        client.start().catch((error) => {
+            warn('[dsh-slack] Socket Mode 启动失败：', error);
+        });
+    }
+    catch (error) {
+        warn('[dsh-slack] Socket Mode 启动异常：', error);
+    }
+    return () => {
+        try {
+            client.disconnect().catch((error) => {
+                warn('[dsh-slack] Socket Mode 断开失败：', error);
+            });
+        }
+        catch (error) {
+            warn('[dsh-slack] Socket Mode 断开异常：', error);
+        }
+    };
+}

package/lib/tools.d.ts

@@ -1,18 +1,14 @@
-/**
- * 构建两个面向模型的工具：slack_notify、slack_channels。
- * 依赖通过 ToolDeps 注入（clientProvider / configProvider），测试可注入 fake client。
- */
 import type { SlackConfig } from './config.js';
 import type { ToolDefinition } from './types.js';
 import type { SlackClient } from './slack-client.js';
+import type { InboxQueue } from './inbox.js';
 /** 工具构建的依赖注入点。 */
 export interface ToolDeps {
-    /** 返回一个 SlackClient；token 缺失时抛中文错误。 */
     clientProvider: () => SlackClient;
-    /** 返回当前配置（供默认频道等解析）。 */
     configProvider: () => SlackConfig | undefined;
+    inboxProvider: () => InboxQueue;
 }
-/** 构建 slack_notify：向指定频道/线程发送 Markdown 文本，返回 ts。 */
 export declare function buildNotifyTool(deps: ToolDeps): ToolDefinition;
-/** 构建 slack_channels：列出机器人可见频道（conversations.list）。 */
 export declare function buildChannelsTool(deps: ToolDeps): ToolDefinition;
+export declare function buildInboxTool(deps: ToolDeps): ToolDefinition;
+export declare function buildReplyTool(deps: ToolDeps): ToolDefinition;

package/lib/tools.js

@@ -1,11 +1,6 @@
-/**
- * 构建两个面向模型的工具：slack_notify、slack_channels。
- * 依赖通过 ToolDeps 注入（clientProvider / configProvider），测试可注入 fake client。
- */
 import { compileParameters } from './compile.js';
 import { resolveDefaultChannel } from './config.js';
-import { assertChannel, assertText, mapSlackError } from './slack-client.js';
-/** slack_notify 的输出 schema（原始 JSON Schema，纯 JSON 无 undefined）。 */
+import { assertChannel, assertText, assertThreadTs, mapSlackError } from './slack-client.js';
 const NOTIFY_OUTPUT_SCHEMA = {
     type: 'object',
     properties: {
@@ -15,7 +10,6 @@ const NOTIFY_OUTPUT_SCHEMA = {
     required: ['ts', 'channel'],
     additionalProperties: true,
 };
-/** slack_channels 的输出 schema。 */
 const CHANNELS_OUTPUT_SCHEMA = {
     type: 'object',
     properties: {
@@ -35,14 +29,39 @@ const CHANNELS_OUTPUT_SCHEMA = {
     required: ['channels'],
     additionalProperties: true,
 };
+const INBOX_OUTPUT_SCHEMA = {
+    type: 'object',
+    properties: {
+        messages: {
+            type: 'array',
+            items: {
+                type: 'object',
+                properties: {
+                    ts: { type: 'string' },
+                    channel: { type: 'string' },
+                    user: { type: 'string' },
+                    text: { type: 'string' },
+                },
+                required: ['ts', 'channel', 'user', 'text'],
+                additionalProperties: true,
+            },
+        },
+    },
+    required: ['messages'],
+    additionalProperties: true,
+};
 function textBlock(text) {
     return { type: 'text', text };
 }
-/** 构建 slack_notify：向指定频道/线程发送 Markdown 文本，返回 ts。 */
+function clampLimit(value) {
+    if (typeof value !== 'number' || !Number.isFinite(value))
+        return 10;
+    return Math.min(50, Math.max(1, Math.trunc(value)));
+}
 export function buildNotifyTool(deps) {
     const defaultChannel = resolveDefaultChannel(deps.configProvider());
     const channelDescription = defaultChannel
-        ? `目标频道：频道名（如 #general）或频道 ID。未特别指定时可使用默认频道 ${defaultChannel}。`
+        ? '目标频道：频道名（如 #general）或频道 ID。未特别指定时可使用默认频道 ' + defaultChannel + '。'
         : '目标频道：频道名（如 #general）或频道 ID。';
     const parameters = compileParameters({
         channel: { type: 'string', required: true, description: channelDescription },
@@ -53,7 +72,7 @@ export function buildNotifyTool(deps) {
         schema: NOTIFY_OUTPUT_SCHEMA,
         render: (_args, value) => {
             const v = value;
-            return [textBlock(`已发送到 ${v.channel}（消息 ts：${v.ts}）。`)];
+            return [textBlock('已发送到 ' + v.channel + '（消息 ts：' + v.ts + '）。')];
         },
     };
     return {
@@ -84,7 +103,6 @@ export function buildNotifyTool(deps) {
         },
     };
 }
-/** 构建 slack_channels：列出机器人可见频道（conversations.list）。 */
 export function buildChannelsTool(deps) {
     const parameters = compileParameters({});
     const output = {
@@ -94,8 +112,8 @@ export function buildChannelsTool(deps) {
             if (v.channels.length === 0) {
                 return [textBlock('机器人当前看不到任何频道（可能需要先把 App 加入频道）。')];
             }
-            const names = v.channels.map((c) => `#${c.name}`).join('、');
-            return [textBlock(`机器人可见频道（${v.channels.length} 个）：${names}。`)];
+            const names = v.channels.map((c) => '#' + c.name).join('、');
+            return [textBlock('机器人可见频道（' + v.channels.length + ' 个）：' + names + '。')];
         },
     };
     return {
@@ -116,3 +134,71 @@ export function buildChannelsTool(deps) {
         },
     };
 }
+export function buildInboxTool(deps) {
+    const parameters = compileParameters({
+        limit: { type: 'integer', description: '最多返回的消息数（默认 10，范围 1-50）。' },
+        markRead: { type: 'boolean', description: '为 true 时，返回后清空收件箱队列（标记已读）。' },
+    });
+    const output = {
+        schema: INBOX_OUTPUT_SCHEMA,
+        render: (_args, value) => {
+            const v = value;
+            if (v.messages.length === 0) {
+                return [textBlock('收件箱为空：尚未开启 Socket Mode（缺少 appToken），或暂未收到新的 Slack 消息。请确认已配置 appToken 并订阅 message.channels / message.im 事件。')];
+            }
+            const lines = v.messages.map((m) => '[' + m.channel + '] ' + m.user + '（ts: ' + m.ts + '）：' + m.text);
+            return [textBlock('收件箱（' + v.messages.length + ' 条，新的在前）：\n' + lines.join('\n'))];
+        },
+    };
+    return {
+        name: 'slack_inbox',
+        description: '读取通过 Socket Mode 收到的 Slack 消息（内存队列，最多保留 200 条，新的在前）。',
+        parameters,
+        output,
+        async execute(args) {
+            const raw = args;
+            const limit = clampLimit(raw.limit);
+            const markRead = raw.markRead === true;
+            const queue = deps.inboxProvider();
+            const messages = queue.list(limit);
+            if (markRead)
+                queue.clear();
+            return { messages: messages.map((m) => ({ ts: m.ts, channel: m.channel, user: m.user, text: m.text })) };
+        },
+    };
+}
+export function buildReplyTool(deps) {
+    const parameters = compileParameters({
+        channel: { type: 'string', required: true, description: '目标频道：频道名（如 #general）或频道 ID。' },
+        text: { type: 'string', required: true, description: '回复内容（Markdown 文本）。' },
+        thread_ts: { type: 'string', required: true, description: '要回复消息的 ts（来自 slack_inbox 返回的 ts）。' },
+    });
+    const output = {
+        schema: NOTIFY_OUTPUT_SCHEMA,
+        render: (_args, value) => {
+            const v = value;
+            return [textBlock('已线程回复 ' + v.channel + '（消息 ts：' + v.ts + '）。')];
+        },
+    };
+    return {
+        name: 'slack_reply',
+        description: '以线程回复的形式回复某条 Slack 消息（chat.postMessage 带 thread_ts）。',
+        parameters,
+        output,
+        timeoutMs: 30000,
+        async execute(args) {
+            const raw = args;
+            const channel = assertChannel(raw.channel);
+            const text = assertText(raw.text);
+            const thread_ts = assertThreadTs(raw.thread_ts);
+            const client = deps.clientProvider();
+            try {
+                const result = await client.postMessage({ channel, text, thread_ts });
+                return { ts: result.ts, channel };
+            }
+            catch (error) {
+                throw new Error(mapSlackError(error));
+            }
+        },
+    };
+}

package/lib/types.d.ts

@@ -26,4 +26,10 @@ export interface SlackContext {
     tools: {
         register(definition: ToolDefinition): () => void;
     };
+    /** Cordis 生命周期：传入启动函数，其返回的清理函数在 dispose 时执行。 */
+    effect?: (start: () => void | (() => void)) => void;
+    /** 可选日志器；缺省回退 console.warn。 */
+    logger?: {
+        warn(message: string, ...args: unknown[]): void;
+    };
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "dsh-slack",
-  "version": "0.1.0",
-  "description": "DSH 社区插件：Slack 通知/桥接（v0.1 单向 agent→Slack，配置走 cordis.patch.yml）",
+  "version": "0.2.1",
+  "description": "DSH 社区插件：Slack 通知/桥接（v0.2 支持 Socket Mode 双向：收件箱 + 线程回复）",
   "type": "module",
   "main": "./lib/index.js",
   "types": "./lib/index.d.ts",
@@ -28,9 +28,11 @@
     "build": "tsc -p tsconfig.json",
     "prepare": "tsc -p tsconfig.json",
     "test": "pnpm run build && node --test \"test/*.test.mjs\"",
-    "prepublishOnly": "pnpm run build"
+    "prepublishOnly": "pnpm run build",
+    "test:protocol": "node test/protocol-acceptance.mjs"
   },
   "dependencies": {
+    "@slack/socket-mode": "^3.0.0",
     "@slack/web-api": "^8.0.0"
   },
   "devDependencies": {
@@ -50,5 +52,6 @@
     "dsh-plugin",
     "deepseek-harness",
     "dsh"
-  ]
+  ],
+  "packageManager": "pnpm@11.7.0"
 }