@addozhang/dsh-discord 0.1.1 → 0.2.0

package/README.md

@@ -1,6 +1,15 @@
 # @addozhang/dsh-discord
 
-Discord-first adapter for [DeepSeek Harness](https://github.com/deepseek-ai) — run DSH sessions from a Discord guild: mention the bot to open a task thread, steer and stop turns, answer approvals and questions inline, and watch the answer stream in.
+[English](README.md) | [中文](README.zh.md)
+
+[![npm](https://img.shields.io/npm/v/@addozhang/dsh-discord)](https://www.npmjs.com/package/@addozhang/dsh-discord)
+[![CI](https://img.shields.io/github/actions/workflow/status/addozhang/dsh-discord/ci.yml?branch=main&label=CI)](https://github.com/addozhang/dsh-discord/actions/workflows/ci.yml)
+[![license](https://img.shields.io/npm/l/@addozhang/dsh-discord)](./LICENSE)
+[![node](https://img.shields.io/node/v/@addozhang/dsh-discord)](./package.json)
+
+A Discord-first adapter for [DeepSeek Harness](https://github.com/deepseek-ai): run DSH sessions from a Discord guild — mention the bot to open a task thread, steer and stop turns, answer approvals and questions inline, and watch the answer stream in.
+
+This is a function/namespace plugin (`inject: ['apiProxy', 'credentials', 'settings', 'storageDomain', 'connection']`). It mounts the Discord Gateway, command surface, stream renderer, and the settings card onto a DSH web profile; session state lives in DSH and durable adapter bindings live in the profile's storage domain.
 
 ## Features
 
@@ -8,21 +17,34 @@ Discord-first adapter for [DeepSeek Harness](https://github.com/deepseek-ai) —
 - **Stream rendering** — typing indicators, a single edited head message, per-tool activity rows, fenced long-answer splitting, one-time finalize; the activity message is deleted when the turn ends.
 - **Approvals & questions** — DSH ask frames become Discord buttons, select menus, and a free-text modal; ownership is enforced (the asker — or the thread owner on later turns — clicks), expiry sweeps fail closed, and remote resolution retires the controls.
 - **Session control** — `/steer`, `/stop`, `/queue list|remove` with turn-ownership checks; `/project bind|list|info` for guild↔workspace binding; `/guild forget` for operator cleanup.
-- **Settings card** — token onboarding (paste + Connect; stored in the Host credential service, never in settings or logs), connect/disconnect, guild allowlist, thread auto-archive, and bot language (follow the DSH language, or pin 中文/English).
-- **Bilingual copy** — every Discord-visible string ships in Chinese and English, selected live from the card.
-- **Hardened by design** — deny-first authorization inside an explicit guild allowlist, byte-level mention neutralization plus `allowed_mentions` on every wire body, at-most-once DSH submission with unknown-preserving reconciliation, and durable bindings that survive restarts.
+- **Settings card** — token onboarding (paste + Connect; stored in the Host credential service, never in settings or logs), connect/disconnect, guild allowlist, thread auto-archive, and bot language.
+- **Bilingual copy** — every Discord-visible string ships in Chinese and English; the bot language defaults to following the DSH language preference and can be pinned from the card.
+- **Hardened by design** — deny-first authorization inside an explicit guild allowlist, mention suppression via `allowed_mentions` plus byte-level neutralization on every wire body, at-most-once DSH submission with unknown-preserving reconciliation, durable bindings that survive restarts, and a READY sweep that rebuilds the deleted category/control channel while treating a deleted workspace channel as user intent (the mapping retires; the workspace stays bindable).
+
+## Requirements
+
+- The [dsh CLI](https://www.npmjs.com/package/@deepseek-ai/dsh) `0.1.1-rc.2` or newer, running a web profile
+- Node.js `^22.19.0 || >=24`
+- A Discord application with a bot user and the **MESSAGE CONTENT** privileged intent enabled (Developer Portal → your application → Bot → Privileged Gateway Intents)
 
 ## Install
 
-The adapter runs as a DSH plugin bundle inside a web profile:
+Install with the dsh CLI — it installs the package into the profile and registers the bundle for you:
 
 ```sh
-pnpm build && pnpm pack --pack-destination /tmp
-cd "$DSH_HOME/profiles/<your-profile>"
-pnpm add file:/tmp/addozhang-dsh-discord-0.1.0.tgz
+dsh plugin --profile web add @addozhang/dsh-discord
 ```
 
-and register it in the profile's `package.json`:
+Then restart `dsh web` and refresh the browser. Under the hood `dsh plugin` is a thin pnpm forwarder into the profile directory; after installing, it reconciles the profile's `dsh.profile.bundles` layer list and appends every dependency that declares a `dsh.bundle` patch — nothing to edit by hand.
+
+Upgrade and removal use the same command:
+
+```sh
+dsh plugin --profile web up @addozhang/dsh-discord   # upgrade; the bundle list reconciles again
+dsh plugin --profile web rm @addozhang/dsh-discord   # remove; run /guild forget first to clean adapter records
+```
+
+If you manage a profile without the CLI, the manual equivalent is to add the package with pnpm inside the profile directory and list it in `dsh.profile.bundles` yourself:
 
 ```json
 {
@@ -30,14 +52,41 @@ and register it in the profile's `package.json`:
 }
 ```
 
-> Publishing to npm is pending (account unavailable). Until then, install from the packed tarball.
+## Configuration
+
+All keys live in the `dsh-discord` settings namespace and can be set either from the settings card or by editing the profile's user settings (`settings.yaml`):
+
+| Key | Default | Meaning |
+|---|---|---|
+| `enabled` | `false` | Adapter master switch; the card's Connect starts it once a token is stored. |
+| `allowedGuildIds` | `[]` | Guild allowlist. Anything outside is ignored with zero adapter or DSH calls. |
+| `memberUserIds` / `memberRoleIds` | `[]` | Member-level authorization inside an allowed guild. |
+| `administratorUserIds` / `administratorRoleIds` | `[]` | Workspace-administrator level (`/project bind`, preset changes). |
+| `deniedUserIds` / `deniedRoleIds` | `[]` | Deny entries; they win over every grant above. |
+| `hostOperatorUserIds` | `[]` | Host operators (`/guild forget`). |
+| `defaultVerbosity` | `essential-tools` | Tool-activity row granularity: `text-only`, `essential-tools`, or `full-tools`. |
+| `language` | `auto` | Bot-visible copy language: `auto` follows the DSH language preference (non-Chinese renders English), or pin `zh`/`en`. |
+| `streamUpdateIntervalMs` | `800` | Coalescing budget for stream edits (250–10000). |
+| `typingIntervalMs` | `7000` | Typing-indicator heartbeat (1000–30000). |
+| `approvalTimeoutMs` | `600000` | Approval ask deadline (30000–86400000); overdue asks auto-reject. |
+| `questionTimeoutMs` | `1800000` | Question ask deadline (30000–86400000); expiry cancels the owning turn. |
+| `threadAutoArchiveMinutes` | `1440` | Task-thread auto-archive: 60, 1440, 4320, or 10080. |
+
+```yaml
+dsh-discord:
+  allowedGuildIds: ["1517134847850709032"]
+  language: auto
+```
+
+The settings card exposes the three high-frequency fields (guild allowlist, auto-archive, language) plus the connection and token surface; every other key is fully supported through `settings.yaml`. An invalid stored section preserves the last known-good configuration.
 
 ## Setup
 
-1. Boot the profile and open the web UI.
-2. In **Settings → Discord**, paste the bot token (Discord Developer Portal → your application → Bot → Reset Token) and press **Connect**. The token is stored by the Host credential service — never in settings, logs, or the client.
-3. Fill in the allowed servers (server IDs via Discord's Developer Mode → right-click → Copy Server ID) and invite the bot to those guilds.
-4. Mention the bot in a bound channel to start a session.
+1. Invite the bot to your guild with at least: View Channels, **Manage Channels** (the adapter provisions its category and workspace home channels), Send Messages, Create Public Threads, Send Messages in Threads, Attach Files, Read Message History.
+2. Boot the profile and open the web UI.
+3. In **Settings → Discord**, paste the bot token (Developer Portal → your application → Bot → Reset Token) and press **Connect**. The token is stored by the Host credential service — never in settings, logs, or the client.
+4. Fill in **Allowed servers** (server IDs via Discord's Developer Mode → right-click a server → Copy Server ID). Everything outside this allowlist is ignored.
+5. Pick the bot language and mention the bot in a bound channel to start a session.
 
 ## Commands
 
@@ -47,10 +96,27 @@ and register it in the profile's `package.json`:
 | `/project list` / `info` | any channel | list workspaces / inspect this channel's binding |
 | `/queue list`, `/queue remove` | session thread | inspect and trim the pending queue |
 | `/steer`, `/stop` | session thread | steer or cancel the running turn (owner only) |
-| `/model`, `/preset`, `/skill` | per context | model/preset defaults and skill runs |
-| `/host status` | any channel | connection and version |
 | `/guild forget` | any channel | operator-only removal of adapter records |
 
+`/model` remains registered ahead of its interactive provider → model → thinking/reasoning cascade (next milestone); `/preset`, `/skill`, and `/host` are deregistered until the router wires them — see Known limitations.
+
+## Design notes
+
+- The settings card is the first-run onboarding surface: the token entry writes the credential service's `DSH_DISCORD_BOT_TOKEN` ref over the plugin management channel, then triggers the start chain. Disconnect keeps the credential; an empty reconnect uses it.
+- The publish workflow authenticates to npm via trusted publishing (OIDC) — no publish token is stored anywhere.
+- The adapter start chain is generation-counted, so Connect/Disconnect races with the initial boot yield exactly one gateway.
+- A credential probe falls back to `resolve()` because the Host's `describe()` misses env-sourced values — a connected adapter never reads as unconfigured.
+- Adapter logging is default-quiet: flow records ride the Host's debug level and failure-shaped events escalate to warn — nothing prints into the DSH process at the default level.
+- Wire-level live-path tracing: set `DSH_DISCORD_TRACE=1` before booting to emit mux frames, drop points, and delivery outcomes to stderr (default silent). It exists because the rc.2 Host wires no plugin log exporter and exposes no log-level switch — `logger.debug` output is unobservable — and should be dropped once the Host grows one.
+
+## Known Limitations and Deferred Work
+
+- **`/session new|resume` is not registered** — the selector and cold-adoption modules are implemented and unit-tested, but the Host RPC face cannot back them yet (`sessions.list` v1 returns bare ids; no `session.inspect`). They return with the next milestone.
+- **`/model` is registered but not routed yet** — its control module (model catalog with guarded selection) is implemented and unit-tested; the interactive provider → model → thinking/reasoning cascade lands with the router-wiring milestone. `/preset`, `/skill`, and `/host` stay deregistered until the same pass wires them (the `/preset` thread-context guard rides along).
+- **Verbosity is a single global setting** (the DSH ecosystem has per-channel precedent).
+- **Deferred after a Kimaki parity pass**: reconcile-interactions wiring, typing pause during ask waits, fail-closed binding/session-owner store wiring, and credential-rotation watching.
+- **Known tension**: the 250ms minimum stream-edit interval against Discord's edit budget under heavy load (429s self-heal), and typing has no duration-capped watchdog.
+
 ## Development
 
 ```sh
@@ -61,7 +127,16 @@ pnpm lint
 pnpm build         # lib + client bundle
 ```
 
-The implementation follows the OpenSpec change at `openspec/changes/build-discord-native-adapter/` (design, capability specs, verification checklist, review reports).
+To try a local build in a profile:
+
+```sh
+pnpm pack --pack-destination /tmp
+dsh plugin --profile <your-profile> add file:/tmp/addozhang-dsh-discord-<version>.tgz
+```
+
+`dsh plugin` anchors relative path specs to the invoking directory, so from a checkout that has run `pnpm build`, `dsh plugin --profile <your-profile> add ../fiber` works too. Re-run pack + add to refresh the installed copy, then restart `dsh web`.
+
+Releases are tagged (`npm version <level> && git push --follow-tags`) and published by [GitHub Actions](./.github/workflows/publish.yml) via npm trusted publishing (OIDC) — no publish token is stored anywhere. The implementation follows the OpenSpec change at `openspec/changes/build-discord-native-adapter/` (design, capability specs, verification checklist, review reports).
 
 ## License
 

package/README.zh.md

@@ -0,0 +1,143 @@
+# @addozhang/dsh-discord
+
+[English](README.md) | 中文
+
+[![npm](https://img.shields.io/npm/v/@addozhang/dsh-discord)](https://www.npmjs.com/package/@addozhang/dsh-discord)
+[![CI](https://img.shields.io/github/actions/workflow/status/addozhang/dsh-discord/ci.yml?branch=main&label=CI)](https://github.com/addozhang/dsh-discord/actions/workflows/ci.yml)
+[![license](https://img.shields.io/npm/l/@addozhang/dsh-discord)](./LICENSE)
+[![node](https://img.shields.io/node/v/@addozhang/dsh-discord)](./package.json)
+
+[DeepSeek Harness](https://github.com/deepseek-ai) 的 Discord 优先适配器：在 Discord 服务器中运行 DSH 会话——@机器人即可开启任务线程、插话与停止运行、在线审批与回答问题，并实时观看回答流式输出。
+
+本插件为 function/namespace 插件（`inject: ['apiProxy', 'credentials', 'settings', 'storageDomain', 'connection']`）：将 Discord Gateway、命令面、流式渲染器与设置卡片挂载到 DSH web profile；会话状态保存在 DSH，适配器的持久绑定保存在 profile 的存储域中。
+
+## 功能
+
+- **@提及驱动会话** — 在已绑定的频道中，被授权的 `@机器人 <任务>` 会锚定一个线程（你的消息成为首帖）、创建 DSH 会话，并且至多提交一次。线程内的后续消息无需 @ 即可排队。
+- **流式渲染** — typing 指示、单条头消息编辑、逐工具活动行、代码围栏感知的长文分段、一次性收尾；Turn 结束时活动消息会被删除。
+- **审批与提问** — DSH ask 帧渲染为 Discord 按钮、下拉菜单与自由文本弹窗；所有权强制校验（提问者——或后续 Turn 的线程属主——才能点击），超时清扫 fail-closed，远端决议自动退役控件。
+- **会话控制** — `/steer`、`/stop`、`/queue list|remove` 带运行所有权校验；`/project bind|list|info` 管理 Guild↔工作区绑定；`/guild forget` 供操作员清理。
+- **设置卡片** — Token 引导（粘贴 + 连接；存入 Host 凭据服务，绝不写入设置或日志）、连接/断开、服务器白名单、线程自动归档、Bot 语言。
+- **双语文案** — 所有 Discord 可见文案提供中英双语；Bot 语言默认跟随 DSH 语言偏好，也可从卡片固定。
+- **安全设计** — 显式服务器白名单内的 deny-first 授权、每条 wire 请求携带 `allowed_mentions` 并做字节级提及中和、至多一次的 DSH 提交与保留 unknown 的对账、重启后持久的绑定，以及 READY 扫描：被删的 category/控制频道会重建，被删的工作区频道视为用户意图（解除映射，workspace 保持可重新绑定）。
+
+## 环境要求
+
+- [dsh CLI](https://www.npmjs.com/package/@deepseek-ai/dsh) `0.1.1-rc.2` 或更新（web profile）
+- Node.js `^22.19.0 || >=24`
+- 一个 Discord 应用（含 Bot 用户），并在开发者门户启用 **MESSAGE CONTENT** 特权 intent（Developer Portal → 你的应用 → Bot → Privileged Gateway Intents）
+
+## 安装
+
+使用 dsh CLI 安装——它会自动把包装进 profile 并注册 bundle：
+
+```sh
+dsh plugin --profile web add @addozhang/dsh-discord
+```
+
+然后重启 `dsh web` 并刷新浏览器。`dsh plugin` 底层是指向 profile 目录的 pnpm 薄转发；安装完成后它会自动对账 profile 的 `dsh.profile.bundles` 层列表，把所有声明了 `dsh.bundle` patch 的依赖追加进去——无需手动编辑。
+
+升级与卸载使用同一条命令：
+
+```sh
+dsh plugin --profile web up @addozhang/dsh-discord   # 升级；bundle 列表会重新对账
+dsh plugin --profile web rm @addozhang/dsh-discord   # 卸载；先执行 /guild forget 清理适配器记录
+```
+
+如果不用 CLI、手工管理 profile，等价做法是在 profile 目录里用 pnpm 安装本包，并在 `dsh.profile.bundles` 中自行登记：
+
+```json
+{
+  "dsh": { "profile": { "bundles": ["@deepseek-ai/dsh-base", "@deepseek-ai/dsh-web-app", "@addozhang/dsh-discord"] } }
+}
+```
+
+## 配置
+
+全部配置项位于 `dsh-discord` 设置命名空间，既可以在设置卡片中修改，也可以直接编辑 profile 的用户设置（`settings.yaml`）：
+
+| 配置项 | 默认值 | 说明 |
+|---|---|---|
+| `enabled` | `false` | 适配器总开关；卡片 Connect 在 Token 存入后启动。 |
+| `allowedGuildIds` | `[]` | 服务器白名单。白名单之外零响应、零 DSH 调用。 |
+| `memberUserIds` / `memberRoleIds` | `[]` | 白名单 Guild 内的成员级授权。 |
+| `administratorUserIds` / `administratorRoleIds` | `[]` | 工作区管理员级（`/project bind`、预设修改）。 |
+| `deniedUserIds` / `deniedRoleIds` | `[]` | 拒绝名单；优先级高于上述一切授权。 |
+| `hostOperatorUserIds` | `[]` | Host 操作员（`/guild forget`）。 |
+| `defaultVerbosity` | `essential-tools` | 工具活动行粒度：`text-only`、`essential-tools`、`full-tools`。 |
+| `language` | `auto` | Bot 可见文案语言：`auto` 跟随 DSH 语言偏好（非中文渲染英文），或固定 `zh`/`en`。 |
+| `streamUpdateIntervalMs` | `800` | 流式编辑合并间隔（250–10000）。 |
+| `typingIntervalMs` | `7000` | typing 心跳（1000–30000）。 |
+| `approvalTimeoutMs` | `600000` | 审批超时（30000–86400000）；超时自动拒绝。 |
+| `questionTimeoutMs` | `1800000` | 问题超时（30000–86400000）；超时取消所属 Turn。 |
+| `threadAutoArchiveMinutes` | `1440` | 任务线程自动归档：60、1440、4320 或 10080。 |
+
+```yaml
+dsh-discord:
+  allowedGuildIds: ["1517134847850709032"]
+  language: auto
+```
+
+设置卡片暴露三个高频项（服务器白名单、自动归档、语言）以及连接与 Token 面；其余键完全支持通过 `settings.yaml` 配置。非法的已存配置会保留最近一次有效配置。
+
+## 初始设置
+
+1. 以至少以下权限把 Bot 邀请到你的服务器：查看频道、**管理频道**（适配器要创建自己的分类和工作区频道）、发送消息、创建公共线程、在线程中发送消息、上传文件、读取消息历史。
+2. 启动 profile 并打开 Web 界面。
+3. 在 **Settings → Discord** 中粘贴 Bot Token（开发者门户 → 你的应用 → Bot → Reset Token）并点击 **Connect**。Token 由 Host 凭据服务保存——绝不写入设置、日志或客户端。
+4. 填写 **允许的服务器**（服务器 ID 获取方式：Discord 开发者模式 → 右键服务器 → 复制服务器 ID）。白名单之外的一切都会被忽略。
+5. 选择 Bot 语言，然后在已绑定的频道 @机器人 开始会话。
+
+## 命令
+
+| 命令 | 位置 | 说明 |
+|---|---|---|
+| `/project bind` | 任意频道 | 将 Guild 绑定到工作区（管理员；会创建主频道） |
+| `/project list` / `info` | 任意频道 | 列出工作区 / 查看当前频道绑定 |
+| `/queue list`, `/queue remove` | 会话线程 | 查看与移除待处理队列 |
+| `/steer`, `/stop` | 会话线程 | 插话或取消运行中的 Turn（仅属主） |
+| `/guild forget` | 任意频道 | 仅操作员：移除适配器记录 |
+
+`/model` 保持注册，等待其交互式 provider → 模型 → thinking/reasoning 级联（下个里程碑）；`/preset`、`/skill`、`/host` 已取消注册，待路由接线后回归——见已知限制。
+
+## 设计说明
+
+- 设置卡片是首次使用的引导面：Token 输入通过插件管理通道写入凭据服务的 `DSH_DISCORD_BOT_TOKEN` 引用，然后触发启动链。断开连接保留凭据；留空重连直接使用已存 Token。
+- 发布工作流通过 npm trusted publishing (OIDC) 认证——任何地方都不保存发布凭证。
+- 适配器启动链带代际计数，Connect/Disconnect 与初始启动竞争时只会产生一个 Gateway。
+- 凭据探测会回退到 `resolve()`：Host 的 `describe()` 不识别环境变量来源的值——已连接的适配器不会被误报为未配置。
+- 适配器日志默认静默：流程记录走 Host 的 debug 级别，失败形态的事件升到 warn——默认级别下不会向 DSH 进程打印任何内容。
+- 链路级 trace：启动前设置 `DSH_DISCORD_TRACE=1` 可将 mux 帧、丢弃点与投递结果输出到 stderr（默认静默）。存在原因：rc.2 Host 未为插件日志接线任何 exporter，也没有日志级别开关——`logger.debug` 输出不可见；Host 提供等价机制后应移除。
+
+## 已知限制与推迟项
+
+- **`/session new|resume` 未注册** — 选择器与冷收养模块已实现并通过单元测试，但 Host RPC 面尚不支持（`sessions.list` v1 只返回裸 id；缺少 `session.inspect`）。将在下个里程碑回归。
+- **`/model` 已注册但尚未接线** — 其控制模块（模型目录与受控选择）已实现并通过单元测试；交互式 provider → 模型 → thinking/reasoning 级联将随路由接线里程碑落地。`/preset`、`/skill`、`/host` 保持注销状态，同一次接线时回归（`/preset` 的会话线程守卫一并处理）。
+- **verbosity 为全局设置**（DSH 生态有按频道设置的先例）。
+- **经 Kimaki 对齐后有意推迟**：reconcile-interactions 接线、ask 等待期暂停 typing、fail-closed 绑定/会话属主 store 接线、凭据轮换监听。
+- **已知张力**：流式编辑 250ms 下限与高负载下 Discord 编辑预算的冲突（429 自愈），以及 typing 缺少时长上限看门狗。
+
+## 开发
+
+```sh
+pnpm install --ignore-scripts
+pnpm test          # 642 tests incl. gateway/REST twin E2E
+pnpm typecheck
+pnpm lint
+pnpm build         # lib + client bundle
+```
+
+在 profile 中试用本地构建：
+
+```sh
+pnpm pack --pack-destination /tmp
+dsh plugin --profile <your-profile> add file:/tmp/addozhang-dsh-discord-<version>.tgz
+```
+
+`dsh plugin` 会把相对路径锚定到调用目录，因此在已执行 `pnpm build` 的仓库里也可以直接 `dsh plugin --profile <your-profile> add ../fiber`。重复 pack + add 即可刷新已安装副本，然后重启 `dsh web`。
+
+发布由 [GitHub Actions](./.github/workflows/publish.yml) 经 npm trusted publishing (OIDC) 完成（`npm version <level> && git push --follow-tags`）——任何地方都不保存发布凭证。实现遵循 `openspec/changes/build-discord-native-adapter/` 中的 OpenSpec 变更（设计、能力 spec、验证清单、评审报告）。
+
+## 许可证
+
+MIT

package/lib/compose.d.ts

@@ -110,16 +110,13 @@ export interface CompositionDeps {
         actorId: string;
         audience: 'administrator' | 'member';
     }) => void | Promise<void>;
-    /** Idempotently ensure the category + control channel exist in a guild. */
-    ensureGuildChannels?: (guildId: string) => Promise<void>;
     /**
-     * Runs once per READY after channel provisioning: the reconciliation
-     * sweep's trigger (startup mapping verification precedes accepting
-     * writes for those mappings — reconciliation spec).
+     * Runs once per READY: the reconciliation sweep — which also self-heals
+     * the adapter's guild surface (category, control channel, bound home
+     * channels) — and the trigger for startup mapping verification preceding
+     * accepted writes for those mappings (reconciliation spec).
      */
     onReady?: () => void | Promise<void>;
-    /** Allowlist snapshot used to provision channels on READY. */
-    allowedGuildIds?: readonly string[] | undefined;
     /**
      * Registry override so the composition root shares ONE registry instance
      * across the runtime and every feature handler (question controls,

package/lib/compose.js

@@ -98,9 +98,6 @@ export function startDiscordAdapter(deps) {
     let started = false;
     let startError;
     let ingress;
-    // provisioning style: one category + one control channel per
-    // allowed guild, created idempotently on the first READY.
-    const provisioned = new Set();
     function handleDispatch(dispatch) {
         if (dispatch.t === 'READY')
             status.setGateway('connected');
@@ -118,16 +115,6 @@ export function startDiscordAdapter(deps) {
                 console.error('[dsh-discord] interaction handler failed:', cause);
             });
         }
-        if (dispatch.t === 'READY' && deps.ensureGuildChannels !== undefined) {
-            for (const guildId of deps.allowedGuildIds ?? []) {
-                if (provisioned.has(guildId))
-                    continue;
-                provisioned.add(guildId);
-                deps.ensureGuildChannels(guildId).catch((cause) => {
-                    deps.logger?.warn('discord_channel_provision_failed', { guildId, cause: String(cause) });
-                });
-            }
-        }
         if (dispatch.t === 'READY' && deps.onReady !== undefined) {
             void Promise.resolve(deps.onReady()).catch((cause) => {
                 deps.logger?.warn('discord_ready_reconcile_failed', String(cause));

package/lib/discord/commands.d.ts

@@ -2,8 +2,13 @@
  * The Milestone 1 Discord command contract (design.md §13). One declarative
  * table feeds both the adapter's own routing metadata and the Discord
  * registration payload, so the wire shape cannot drift from the contract:
- * nine fixed commands, guild-only, ephemeral responses, no Discord-level
- * permission gates (adapter RBAC decides at interaction time, deny-first).
+ * only commands the interaction router actually routes are registered —
+ * guild-only, ephemeral responses, no Discord-level permission gates
+ * (adapter RBAC decides at interaction time, deny-first).
+ *
+ * Deregistered: `/preset`, `/skill`, `/host` (their control modules stay
+ * implemented and unit-tested; they return when the router wires them,
+ * alongside `/session new|resume` — see design.md §13 and tasks 16.26/16.32).
  */
 /** A command argument as the contract table declares it. */
 export interface CommandArgument {
@@ -32,7 +37,7 @@ export interface AdapterCommand {
     /** Milestone 1: every response is ephemeral. */
     responseVisibility: 'ephemeral';
 }
-/** The complete Milestone 1 command set, in registration order. */
+/** The live command set, in registration order. */
 export declare const MILESTONE_ONE_COMMANDS: readonly AdapterCommand[];
 /**
  * Build the bulk-overwrite registration payload for

package/lib/discord/commands.js

@@ -2,8 +2,13 @@
  * The Milestone 1 Discord command contract (design.md §13). One declarative
  * table feeds both the adapter's own routing metadata and the Discord
  * registration payload, so the wire shape cannot drift from the contract:
- * nine fixed commands, guild-only, ephemeral responses, no Discord-level
- * permission gates (adapter RBAC decides at interaction time, deny-first).
+ * only commands the interaction router actually routes are registered —
+ * guild-only, ephemeral responses, no Discord-level permission gates
+ * (adapter RBAC decides at interaction time, deny-first).
+ *
+ * Deregistered: `/preset`, `/skill`, `/host` (their control modules stay
+ * implemented and unit-tested; they return when the router wires them,
+ * alongside `/session new|resume` — see design.md §13 and tasks 16.26/16.32).
  */
 function leaf(name, description, options) {
     return { name, description, ...(options === undefined ? {} : { options }), guildOnly: true, responseVisibility: 'ephemeral' };
@@ -11,7 +16,7 @@ function leaf(name, description, options) {
 function grouped(name, description, subcommands) {
     return { name, description, subcommands, guildOnly: true, responseVisibility: 'ephemeral' };
 }
-/** The complete Milestone 1 command set, in registration order. */
+/** The live command set, in registration order. */
 export const MILESTONE_ONE_COMMANDS = [
     grouped('project', 'Bind this channel to a DSH workspace', [
         { name: 'list', options: [{ name: 'query', required: false, autocomplete: true }] },
@@ -28,17 +33,6 @@ export const MILESTONE_ONE_COMMANDS = [
         { name: 'show' },
         { name: 'select', options: [{ name: 'model', required: true }, { name: 'reasoning', required: false }] },
     ]),
-    grouped('preset', 'Show, select, or reset this channel\'s agent preset', [
-        { name: 'show' },
-        { name: 'select', options: [{ name: 'preset', required: true }] },
-        { name: 'reset' },
-    ]),
-    grouped('skill', 'Run a DSH skill through the session queue', [
-        { name: 'run', options: [{ name: 'skill', required: true }, { name: 'input', required: false }] },
-    ]),
-    grouped('host', 'Show the connected DSH host status', [
-        { name: 'status' },
-    ]),
     grouped('guild', 'Guild-scoped adapter operations', [
         { name: 'forget' },
     ]),

package/lib/discord/rest.d.ts

@@ -58,6 +58,13 @@ export declare function createRestClient(config: RestClientConfig, options?: Res
  * major parameters — `channels/:id`, `guilds/:id`, `webhooks/:id` — so every
  * write into one channel shares one bucket and serializes behind it.
  */
+/**
+ * A fresh Discord message nonce: reconciliation identity for an
+ * unobservable send (rest.ts contract). Discord validates the wire field at
+ * **25 characters max** — a 36-char UUID is a 50035 Invalid Form Body on
+ * every send (task 16.38) — so the id is the UUID's 25 hex digits.
+ */
+export declare function newNonce(): string;
 export declare function routeBucketOf(path: string): string;
 export interface SharedRestClient {
     request<T>(method: RestMethod, path: string, body?: unknown, init?: {

package/lib/discord/rest.js

@@ -6,6 +6,7 @@
  * exhausted 5xx) may or may not have been applied and must be reconciled,
  * never blindly retried by callers.
  */
+import { randomUUID } from 'node:crypto';
 const DEFAULT_API_BASE = 'https://discord.com/api/v10';
 const DEFAULT_MAX_RETRIES = 3;
 const DEFAULT_BACKOFF_BASE_MS = 1_000;
@@ -121,6 +122,15 @@ export function createRestClient(config, options = {}, fetchLike) {
  * major parameters — `channels/:id`, `guilds/:id`, `webhooks/:id` — so every
  * write into one channel shares one bucket and serializes behind it.
  */
+/**
+ * A fresh Discord message nonce: reconciliation identity for an
+ * unobservable send (rest.ts contract). Discord validates the wire field at
+ * **25 characters max** — a 36-char UUID is a 50035 Invalid Form Body on
+ * every send (task 16.38) — so the id is the UUID's 25 hex digits.
+ */
+export function newNonce() {
+    return randomUUID().replaceAll('-', '').slice(0, 25);
+}
 export function routeBucketOf(path) {
     const segments = path.split('/').filter(segment => segment.length > 0);
     return segments.slice(0, 2).join('/');

package/lib/features/interaction-router.d.ts

@@ -76,6 +76,12 @@ export interface InteractionRouterDeps {
         text: string;
     }) => QuestionInteractionOutcome;
     rest: () => Promise<SharedRestClient | undefined>;
+    /**
+     * Delete one channel→Workspace binding row (bind precheck: a bound
+     * channel that Discord no longer has is user intent — purge, then bind
+     * fresh; task 16.37).
+     */
+    purgeChannelBinding: (guildId: string, channelId: string) => Promise<void>;
     log: (event: string, detail?: unknown) => void;
     warn: (event: string, detail?: unknown) => void;
 }

package/lib/features/interaction-router.js

@@ -137,9 +137,25 @@ export function createInteractionRouter(deps) {
                     const { id: workspaceId, title } = resolvedWorkspace.workspace;
                     const existing = deps.findBoundChannelFor(event.guildId, workspaceId);
                     if (existing !== undefined) {
-                        // Idempotent: one workspace, one channel.
-                        await followUp(deps.copy.bindChannelExists(title, existing));
-                        return;
+                        // Idempotent: one workspace, one channel — but only while the
+                        // bound channel still exists. A Discord-side deletion is user
+                        // intent: purge the stale mapping and bind fresh (16.37). An
+                        // unverified surface keeps the idempotent reply, never a purge.
+                        const stillLive = await (async () => {
+                            const client = await deps.rest();
+                            if (client === undefined)
+                                return undefined;
+                            const listed = await client.request('GET', `/guilds/${event.guildId}/channels`);
+                            if (listed.outcome !== 'completed' || !Array.isArray(listed.body))
+                                return undefined;
+                            return listed.body.some(channel => channel.id === existing);
+                        })();
+                        if (stillLive === true) {
+                            await followUp(deps.copy.bindChannelExists(title, existing));
+                            return;
+                        }
+                        if (stillLive === false)
+                            await deps.purgeChannelBinding(event.guildId, existing);
                     }
                     const expiresAtMs = Date.now() + 15 * 60 * 1000;
                     const confirmId = deps.registry.register({ kind: 'project-bind', action: 'confirm', workspaceId, workspaceTitle: title, guildId: event.guildId, actorId: event.actorId, expiresAtMs });

package/lib/index.js

@@ -5,7 +5,7 @@ import { ALLOWED_MENTIONS_NONE, DISCORD_SUPPRESS_NOTIFICATIONS_FLAG, OUTBOUND_EP
 import { validateHostCapabilities } from './startup.js';
 import { createAdapterStatusTracker, installAdapterStatusRpc, } from './features/adapter-status.js';
 import { DISCORD_BOT_TOKEN_REF, describeDiscordCredential, resolveDiscordBotToken } from './credential.js';
-import { createSharedRestClient } from './discord/rest.js';
+import { createSharedRestClient, newNonce } from './discord/rest.js';
 import { createRestThreadPort } from './discord/thread-port.js';
 import { createComponentRegistry } from './discord/components.js';
 import { buildCommandRegistrations } from './discord/commands.js';
@@ -120,11 +120,16 @@ export function apply(ctx, config = DEFAULT_DISCORD_SETTINGS) {
     // RpcResponse and never throw business errors; boundedness and outcome
     // logging live in src/dsh/api-proxy-face.ts.
     const apiProxy = ctx.get('apiProxy');
-    // Every apiProxy outcome is visible on stderr: the live profile pass reads
-    // this channel, and a silent call can never again be misread as a hang.
+    // Default-quiet logging (16.33): flow records ride the Host's debug level
+    // only — the adapter prints nothing into the DSH process at the default
+    // level. Failure-shaped events (…failed/…threw/…blocked/…unknown) escalate
+    // to warn so a default-level Host still surfaces them.
     const rpcLog = (event, detail) => {
-        console.error(`[dsh-discord] ${event}:`, typeof detail === 'string' ? detail : JSON.stringify(detail ?? null));
-        emitLog(ctx, 'debug', { event, detail: typeof detail === 'string' ? detail : JSON.stringify(detail ?? null) });
+        const serialized = typeof detail === 'string' ? detail : JSON.stringify(detail ?? null);
+        if (process.env['DSH_DISCORD_TRACE'] === '1') {
+            console.error(`[dsh-discord:trace] ${event}:`, serialized);
+        }
+        emitLog(ctx, /(?:failed|threw|blocked|unknown)/.test(event) ? 'warn' : 'debug', { event, detail: serialized });
     };
     void (async () => {
         // The durable domain gates the whole composition: no adapter starts
@@ -486,8 +491,11 @@ export function apply(ctx, config = DEFAULT_DISCORD_SETTINGS) {
                 }
                 for (const guildId of current.allowedGuildIds) {
                     const facts = {};
+                    const channelRows = [];
                     const channels = await rest.request('GET', `/guilds/${guildId}/channels`);
-                    if (channels.outcome === 'completed') {
+                    const listed = channels.outcome === 'completed';
+                    if (listed) {
+                        channelRows.push(...channels.body);
                         for (const channel of channels.body)
                             facts[channel.id] = 'ok';
                         const threads = await rest.request('GET', `/guilds/${guildId}/threads/active`);
@@ -496,15 +504,60 @@ export function apply(ctx, config = DEFAULT_DISCORD_SETTINGS) {
                                 facts[thread.id] = 'ok';
                         }
                     }
+                    // This guild's bindings only: another guild's pass must never
+                    // judge (or retire) this guild's mappings against its own facts.
+                    const channelKeyById = new Map();
+                    const threadKeyById = new Map();
+                    for (const key of channelTable.keys()) {
+                        const scope = parseChannelBindingKey(key);
+                        if (scope?.guildId !== guildId || scope.channelId === '')
+                            continue;
+                        channelKeyById.set(scope.channelId, key);
+                    }
+                    for (const key of threadTable.keys()) {
+                        const scope = parseThreadBindingKey(key);
+                        if (scope?.guildId !== guildId || scope.threadId === '')
+                            continue;
+                        threadKeyById.set(scope.threadId, key);
+                    }
+                    // Verified absence: the listing succeeded and the channel is gone.
+                    if (listed) {
+                        for (const channelId of channelKeyById.keys()) {
+                            if (facts[channelId] === undefined)
+                                facts[channelId] = 'missing';
+                        }
+                    }
+                    // Default surface (16.34/16.37): the adapter's category and the
+                    // general control channel are ensured on every READY. Bound home
+                    // channels are NOT recreated — a Discord-side deletion is user
+                    // intent, so the verified absence marked above retires the
+                    // mapping in the plan below instead.
+                    const category = channelRows.find(channel => channel.type === 4 && channel.name.toLowerCase() === CATEGORY_NAME.toLowerCase())
+                        ?? await (async () => {
+                            const made = await rest.request('POST', `/guilds/${guildId}/channels`, { name: CATEGORY_NAME, type: 4 });
+                            if (made.outcome !== 'completed') {
+                                // Usually HTTP 403: the bot's roles lack Manage Channels.
+                                rpcLog('discord_category_ensure_failed', { guildId, cause: made.outcome === 'rejected' ? `HTTP ${String(made.status)}` : made.reason });
+                                return undefined;
+                            }
+                            return made.body;
+                        })();
+                    if (category !== undefined && channelRows.find(channel => channel.type === 0 && channel.name.toLowerCase() === 'general' && channel.parent_id === category.id) === undefined) {
+                        const made = await rest.request('POST', `/guilds/${guildId}/channels`, { name: 'general', type: 0, parent_id: category.id });
+                        if (made.outcome === 'completed')
+                            rpcLog('discord_control_channel_created', { guildId });
+                        else
+                            rpcLog('discord_control_channel_create_failed', { guildId, cause: made.outcome === 'rejected' ? `HTTP ${String(made.status)}` : made.reason });
+                    }
                     const plan = planBindingReconciliation({
                         channelBindings: [...channelTable.entries()].map(([key, record]) => {
                             const scope = parseChannelBindingKey(key);
                             return { channelId: scope?.channelId ?? '', ...record };
-                        }).filter(binding => binding.channelId !== ''),
+                        }).filter(binding => binding.channelId !== '' && channelKeyById.has(binding.channelId)),
                         threadBindings: [...threadTable.entries()].map(([key, record]) => {
                             const scope = parseThreadBindingKey(key);
                             return { threadId: scope?.threadId ?? '', ...record };
-                        }).filter(binding => binding.threadId !== ''),
+                        }).filter(binding => binding.threadId !== '' && threadKeyById.has(binding.threadId)),
                         baseline: {
                             workspaces: catalog.workspaces.map(workspace => ({ workspaceId: workspace.id, title: workspace.title, path: '' })),
                             sessionIds: sessionIds.ids,
@@ -514,19 +567,19 @@ export function apply(ctx, config = DEFAULT_DISCORD_SETTINGS) {
                     for (const action of plan.channelActions) {
                         if (action.action !== 'retire')
                             continue;
-                        const scope = parseChannelBindingKey(channelBindingKey({ applicationId: applicationIdRef.current, guildId, channelId: action.channelId }));
-                        if (scope === undefined)
+                        const key = channelKeyById.get(action.channelId);
+                        if (key === undefined)
                             continue;
-                        await channelTable.delete(channelBindingKey(scope));
+                        await channelTable.delete(key);
                         rpcLog('discord_reconcile_channel_retired', { channelId: action.channelId, reason: action.reason });
                     }
                     for (const action of plan.threadActions) {
                         if (action.action !== 'retire')
                             continue;
-                        const scope = parseThreadBindingKey(threadBindingKey({ applicationId: applicationIdRef.current, guildId, threadId: action.threadId }));
-                        if (scope === undefined)
+                        const key = threadKeyById.get(action.threadId);
+                        if (key === undefined)
                             continue;
-                        await threadTable.delete(threadBindingKey(scope));
+                        await threadTable.delete(key);
                         rpcLog('discord_reconcile_thread_retired', { threadId: action.threadId, reason: action.reason });
                     }
                 }
@@ -628,6 +681,10 @@ export function apply(ctx, config = DEFAULT_DISCORD_SETTINGS) {
             sessionForThread: (guildId, threadId) => bindings.sessionForThread(guildId, threadId),
             ensureWorkspaceChannel,
             rest: sharedRest,
+            purgeChannelBinding: async (guildId, channelId) => {
+                await channelTable.delete(bindChannelKey(guildId, channelId));
+                rpcLog('discord_reconcile_channel_retired', { channelId, reason: 'discord-deleted' });
+            },
             log: rpcLog,
             warn: (event, detail) => {
                 emitLog(ctx, 'warn', { event, detail: typeof detail === 'string' ? detail : JSON.stringify(detail ?? null) });
@@ -672,7 +729,6 @@ export function apply(ctx, config = DEFAULT_DISCORD_SETTINGS) {
             ...(process.env['DSH_DISCORD_GATEWAY_URL'] === undefined
                 ? {}
                 : { gatewayUrl: process.env['DSH_DISCORD_GATEWAY_URL'] }),
-            allowedGuildIds: [...current.allowedGuildIds],
             applicationId: () => applicationIdRef.current,
             mainline,
             bindings,
@@ -689,18 +745,6 @@ export function apply(ctx, config = DEFAULT_DISCORD_SETTINGS) {
                     rpcLog('discord_unbound_notice_threw', String(cause));
                 });
             },
-            ensureGuildChannels: async (guildId) => {
-                await withRest(async (rest) => {
-                    const ensured = await ensureCategory(rest, guildId);
-                    if (ensured === undefined)
-                        return;
-                    // Never touch channels outside our category: create our own only.
-                    const hasControl = ensured.channels.some((c) => c.type === 0 && c.name.toLowerCase() === 'general' && c.parent_id === ensured.categoryId);
-                    if (hasControl)
-                        return;
-                    await rest.request('POST', `/guilds/${guildId}/channels`, { name: 'general', type: 0, parent_id: ensured.categoryId });
-                });
-            },
             approvals: approvalsStore,
             questions: questionsStore,
             status: statusTracker,
@@ -782,7 +826,7 @@ export function apply(ctx, config = DEFAULT_DISCORD_SETTINGS) {
                     // The nonce lets an unobservable send be reconciled instead of
                     // blindly retried (rest.ts contract): a message that actually
                     // landed is found by its nonce and reported completed.
-                    const nonce = crypto.randomUUID();
+                    const nonce = newNonce();
                     const sent = await rest.request('POST', `/channels/${request.channelId}/messages`, {
                         content: request.content,
                         flags: DISCORD_SUPPRESS_NOTIFICATIONS_FLAG,
@@ -799,7 +843,12 @@ export function apply(ctx, config = DEFAULT_DISCORD_SETTINGS) {
                         rpcLog('discord_live_send_unknown', { channelId: request.channelId });
                         return { outcome: 'unknown' };
                     }
-                    rpcLog('discord_live_send_failed', { channelId: request.channelId, outcome: sent.outcome });
+                    if (sent.outcome === 'rejected') {
+                        rpcLog('discord_live_send_failed', { channelId: request.channelId, status: sent.status, error: sent.error });
+                    }
+                    else {
+                        rpcLog('discord_live_send_failed', { channelId: request.channelId, outcome: sent.outcome });
+                    }
                     return { outcome: 'failed' };
                 },
                 edit: async (request) => {
@@ -811,6 +860,9 @@ export function apply(ctx, config = DEFAULT_DISCORD_SETTINGS) {
                         flags: DISCORD_SUPPRESS_NOTIFICATIONS_FLAG,
                         allowed_mentions: ALLOWED_MENTIONS_NONE,
                     });
+                    if (edited.outcome === 'rejected') {
+                        rpcLog('discord_live_edit_failed', { channelId: request.channelId, status: edited.status, error: edited.error });
+                    }
                     return edited.outcome === 'completed' ? { outcome: 'completed' } : { outcome: 'failed' };
                 },
                 typing: async (channelId) => {

package/lib/stream/live.js

@@ -20,6 +20,17 @@ import { discordChannelNameKey, safeTitle } from '../policy/disclosure.js';
 const DEFAULT_ACTIVITY_COALESCE_MS = 1_000;
 /** Row budget: a presentation title is truncated before it reaches Discord. */
 const ACTIVITY_TITLE_MAX = 80;
+/**
+ * Wire-level live-path tracing (`DSH_DISCORD_TRACE=1` → stderr). Default
+ * silent like the rest of the adapter; the live path's drops (unrecognized
+ * frame shapes, unmatched sessions) are otherwise unobservable, which once
+ * hid a real-Host shape mismatch from every gate (16.38).
+ */
+const TRACE = process.env['DSH_DISCORD_TRACE'] === '1';
+function trace(...parts) {
+    if (TRACE)
+        console.error('[dsh-discord:trace]', ...parts);
+}
 const ANSWER_MARKER = (interrupted, marker) => interrupted ? `\n\n${marker}` : '';
 /** Pair-safe truncation: never split a surrogate pair at the boundary. */
 function truncateText(text, max) {
@@ -85,6 +96,7 @@ export function startLiveRender(deps) {
             finalizer: undefined,
             headMessageId: undefined,
             activityMessageId: undefined,
+            headFlush: undefined,
             stepSeq: 0,
             headAttempted: false,
             activityAttempted: false,
@@ -99,26 +111,33 @@ export function startLiveRender(deps) {
     /** Flush the current answer text: create the head once, then edit it. */
     function flushAnswer(threadId, runtime) {
         const stepSeq = runtime.stepSeq;
-        return async (content) => {
+        return (content) => {
             if (runtime.stepSeq !== stepSeq)
-                return;
+                return Promise.resolve();
             const payload = buildOutboundMessage({ kind: 'assistant', content });
-            if (runtime.headMessageId === undefined) {
-                // An earlier send whose application was unobservable must never be
-                // blind-resent (rest.ts contract): the stream pauses here and the
-                // finalizer's single fresh send carries the answer instead.
-                if (runtime.headAttempted)
-                    return;
-                const sent = await deps.delivery.send({ channelId: threadId, content: payload.content });
-                if (sent.outcome === 'completed')
-                    runtime.headMessageId = sent.messageId;
-                else if (sent.outcome === 'unknown') {
-                    runtime.headAttempted = true;
-                    deps.log?.('discord_live_head_send_unknown', { threadId });
+            const flush = (async () => {
+                if (runtime.headMessageId === undefined) {
+                    // An earlier send whose application was unobservable must never be
+                    // blind-resent (rest.ts contract): the stream pauses here and the
+                    // finalizer's single fresh send carries the answer instead.
+                    if (runtime.headAttempted)
+                        return undefined;
+                    const sent = await deps.delivery.send({ channelId: threadId, content: payload.content });
+                    if (sent.outcome === 'completed') {
+                        runtime.headMessageId = sent.messageId;
+                        return sent.messageId;
+                    }
+                    if (sent.outcome === 'unknown') {
+                        runtime.headAttempted = true;
+                        deps.log?.('discord_live_head_send_unknown', { threadId });
+                    }
+                    return undefined;
                 }
-                return;
-            }
-            await deps.delivery.edit({ channelId: threadId, messageId: runtime.headMessageId, content: payload.content });
+                await deps.delivery.edit({ channelId: threadId, messageId: runtime.headMessageId, content: payload.content });
+                return runtime.headMessageId;
+            })();
+            runtime.headFlush = flush;
+            return flush.then(() => undefined);
         };
     }
     function beginTurn(threadId, runtime, turnId) {
@@ -126,6 +145,7 @@ export function startLiveRender(deps) {
         runtime.turnId = turnId;
         runtime.headMessageId = undefined;
         runtime.activityMessageId = undefined;
+        runtime.headFlush = undefined;
         runtime.headAttempted = false;
         runtime.activityAttempted = false;
         runtime.stepSeq += 1;
@@ -205,6 +225,7 @@ export function startLiveRender(deps) {
                 // A new step opens a NEW logical answer message: the previous
                 // step's completed head is never overwritten (stream-renderer spec).
                 runtime.headMessageId = undefined;
+                runtime.headFlush = undefined;
                 runtime.headAttempted = false;
                 runtime.stepSeq += 1;
                 // The previous step's finalize disposed the scheduler; a fresh one
@@ -218,11 +239,15 @@ export function startLiveRender(deps) {
                 return;
             }
             case 'assistant/chunk': {
-                if (runtime.scheduler === undefined || turnId === undefined || stepId === undefined)
+                if (runtime.scheduler === undefined || turnId === undefined || stepId === undefined) {
+                    trace('chunk dropped (no turn/step/scheduler)', event.type, turnId, stepId);
                     return;
+                }
                 const chunk = data['chunk'];
-                if (chunk?.type !== 'text-delta' || typeof chunk.text !== 'string')
+                if (chunk?.type !== 'text-delta' || typeof chunk.text !== 'string') {
+                    trace('chunk not text-delta:', String(chunk?.type));
                     return;
+                }
                 runtime.render.appendDelta({ turnId, stepId, text: chunk.text });
                 const snapshot = runtime.render.snapshot();
                 const current = snapshot.answers.find(answer => answer.stepId === stepId);
@@ -235,6 +260,7 @@ export function startLiveRender(deps) {
                     return;
                 const interrupted = data['interrupted'] === true;
                 const text = assistantText(data['message']);
+                trace('assistant/message: extracted text length', text.length, 'interrupted:', interrupted);
                 runtime.render.setAuthoritative({ turnId, stepId, text });
                 if (interrupted)
                     runtime.render.interrupt({ turnId, stepId });
@@ -243,39 +269,43 @@ export function startLiveRender(deps) {
                 if (text === '')
                     return;
                 // The authoritative finalize sends exactly once per turn answer. It
-                // runs detached, so it captures the step generation here: a finalize
-                // whose REST is still in flight when the next step starts must not
-                // re-point the live head at its own (older) message.
-                const finalizedStepSeq = runtime.stepSeq;
-                runtime.finalizer = createAnswerFinalizer({
-                    delivery: {
-                        editHead: async ({ messageId, content }) => {
-                            const payload = buildOutboundMessage({ kind: 'assistant', content });
-                            // No head exists (text arrived without flushed chunks): the
-                            // first finalize send IS the head, recorded for continuations.
-                            if (messageId === '') {
-                                const sent = await deps.delivery.send({ channelId: threadId, content: payload.content });
-                                if (sent.outcome === 'completed') {
-                                    if (runtime.stepSeq === finalizedStepSeq && runtime.headMessageId === undefined) {
-                                        runtime.headMessageId = sent.messageId;
+                // runs detached AFTER the in-flight head flush settles: racing the
+                // flush would read `headMessageId` before the flushed send landed
+                // and post the answer as a duplicate second message (16.39). The
+                // step fence is read post-settle for the same reason.
+                const pendingFlush = Promise.resolve(runtime.headFlush).catch(() => undefined);
+                void pendingFlush.then((inFlightHead) => {
+                    const finalizedStepSeq = runtime.stepSeq;
+                    const finalizer = createAnswerFinalizer({
+                        delivery: {
+                            editHead: async ({ messageId, content }) => {
+                                const payload = buildOutboundMessage({ kind: 'assistant', content });
+                                // No head exists (text arrived without flushed chunks): the
+                                // first finalize send IS the head, recorded for continuations.
+                                if (messageId === '') {
+                                    const sent = await deps.delivery.send({ channelId: threadId, content: payload.content });
+                                    if (sent.outcome === 'completed') {
+                                        if (runtime.stepSeq === finalizedStepSeq && runtime.headMessageId === undefined) {
+                                            runtime.headMessageId = sent.messageId;
+                                        }
+                                        return { outcome: 'completed' };
                                     }
-                                    return { outcome: 'completed' };
+                                    return { outcome: 'failed' };
                                 }
-                                return { outcome: 'failed' };
-                            }
-                            const edited = await deps.delivery.edit({ channelId: threadId, messageId, content: payload.content });
-                            return edited.outcome === 'completed' ? { outcome: 'completed' } : { outcome: 'failed' };
-                        },
-                        sendContinuation: async ({ content }) => {
-                            const payload = buildOutboundMessage({ kind: 'assistant', content });
-                            const sent = await deps.delivery.send({ channelId: threadId, content: payload.content });
-                            return sent.outcome === 'completed' ? { outcome: 'completed' } : { outcome: 'failed' };
+                                const edited = await deps.delivery.edit({ channelId: threadId, messageId, content: payload.content });
+                                return edited.outcome === 'completed' ? { outcome: 'completed' } : { outcome: 'failed' };
+                            },
+                            sendContinuation: async ({ content }) => {
+                                const payload = buildOutboundMessage({ kind: 'assistant', content });
+                                const sent = await deps.delivery.send({ channelId: threadId, content: payload.content });
+                                return sent.outcome === 'completed' ? { outcome: 'completed' } : { outcome: 'failed' };
+                            },
                         },
-                    },
-                    headMessageId: runtime.headMessageId ?? '',
-                });
-                const finalText = text + ANSWER_MARKER(interrupted, deps.interruptedMarker?.() ?? '*（已被中断）*');
-                void runtime.finalizer.finalize(finalText).catch((cause) => {
+                        headMessageId: inFlightHead ?? runtime.headMessageId ?? '',
+                    });
+                    const finalText = text + ANSWER_MARKER(interrupted, deps.interruptedMarker?.() ?? '*（已被中断）*');
+                    return finalizer.finalize(finalText);
+                }).catch((cause) => {
                     deps.log?.('discord_live_finalize_threw', { threadId, cause: String(cause) });
                 });
                 return;
@@ -455,11 +485,15 @@ export function startLiveRender(deps) {
         if (type !== 'session/event')
             return;
         const threadId = deps.threadForSession(sessionId);
-        if (threadId === undefined)
+        if (threadId === undefined) {
+            trace('drop: no thread for session', sessionId);
             return;
+        }
         const eventWrapper = frame['event'];
-        if (eventWrapper === undefined || typeof eventWrapper.type !== 'string')
+        if (eventWrapper === undefined || typeof eventWrapper.type !== 'string') {
+            trace('drop: session/event without event wrapper', JSON.stringify(frame).slice(0, 200));
             return;
+        }
         handleSessionEvent(sessionId, threadId, runtimeFor(threadId), { type: eventWrapper.type, data: eventWrapper.data ?? {} }, frame['view']);
     }
     async function runLoop() {
@@ -480,6 +514,11 @@ export function startLiveRender(deps) {
                         const payload = (typeof frame === 'object' && frame !== null && 'payload' in frame)
                             ? frame.payload
                             : frame;
+                        if (TRACE) {
+                            const t = (typeof payload === 'object' && payload !== null ? payload.type : undefined);
+                            const sid = (typeof payload === 'object' && payload !== null ? payload.sessionId : undefined);
+                            trace('frame', String(t), String(sid));
+                        }
                         handleFrame(payload, typeof envelopeRpcId === 'string' ? envelopeRpcId : undefined);
                     }
                     catch (cause) {
@@ -492,6 +531,7 @@ export function startLiveRender(deps) {
                 if (isDisposed())
                     return;
                 deps.log?.('discord_live_stream_error', { cause: String(cause) });
+                trace('stream closed:', String(cause));
             }
             if (isDisposed())
                 return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@addozhang/dsh-discord",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "description": "Discord-first adapter for DeepSeek Harness",
   "license": "MIT",
   "type": "module",
@@ -24,9 +24,10 @@
   },
   "files": [
     "lib",
-    "cordis.patch.yml",
     "README.md",
-    "LICENSE"
+    "README.zh.md",
+    "LICENSE",
+    "cordis.patch.yml"
   ],
   "publishConfig": {
     "access": "public"
@@ -82,5 +83,13 @@
     "@deepseek-ai/schemastery": "3.18.1",
     "zod": "^4.4.3"
   },
-  "pnpm": {}
+  "pnpm": {},
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/addozhang/dsh-discord.git"
+  },
+  "bugs": {
+    "url": "https://github.com/addozhang/dsh-discord/issues"
+  },
+  "homepage": "https://github.com/addozhang/dsh-discord#readme"
 }