@addozhang/dsh-discord 0.5.0-alpha.2 → 0.5.0-rc.2

package/README.md

@@ -108,7 +108,7 @@ The settings card exposes the three high-frequency fields (guild allowlist, auto
 | `/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 show` / `select` | session thread | show the live model directory; `select` without arguments walks the interactive provider → model → reasoning cascade (any authorized member by default) |
-| `/session resume` | project channel | pick one of this workspace's past sessions (autocomplete: title and age, newest first) and resume it into a new thread of this channel; blank, already-bound, subagent, and archived sessions are never offered |
+| `/session resume` | project channel | pick one of this workspace's past sessions (autocomplete: title and age, newest first) and resume it into a new thread of this channel; blank, already-bound, subagent, and archived sessions are never offered. The thread renders the session's history — answers and tool summaries plus the user's inputs as quoted echo lines (plugin/system injections are never echoed). After an adapter restart, threads catch up only what they missed: a persisted render watermark suppresses already-delivered history, and bound sessions re-subscribe on reconnect so turns prompted from the web UI still land in their thread |
 | `/guild forget` | any channel | operator-only removal of adapter records |
 
 ## Design notes
@@ -132,7 +132,7 @@ The settings card exposes the three high-frequency fields (guild allowlist, auto
 
 ```sh
 pnpm install --ignore-scripts
-pnpm test          # 683 tests incl. gateway/REST twin E2E
+pnpm test          # 729 tests incl. gateway/REST twin E2E
 pnpm typecheck
 pnpm lint
 pnpm build         # lib + client bundle

package/README.zh.md

@@ -108,7 +108,7 @@ dsh-discord:
 | `/queue list`, `/queue remove` | 会话线程 | 查看与移除待处理队列 |
 | `/steer`, `/stop` | 会话线程 | 插话或取消运行中的 Turn（仅属主） |
 | `/model show` / `select` | 会话线程 | 查看实时模型目录；`select` 不带参数时走交互式 provider → 模型 → 推理强度级联（默认对所有授权成员开放） |
-| `/session resume` | 项目频道 | 自动补全选择本工作区的历史会话（显示标题与时间，最新优先），恢复为当前频道的新线程；空白、已挂线程、subagent、已归档的会话不会出现 |
+| `/session resume` | 项目频道 | 自动补全选择本工作区的历史会话（显示标题与时间，最新优先），恢复为当前频道的新线程；空白、已挂线程、subagent、已归档的会话不会出现。线程会渲染会话历史——回答与工具摘要之外，用户输入以引用行回显（插件/系统注入永不回显）。适配器重启后线程只补齐错过部分：持久化的渲染水位抑制已投递过的历史，已绑定会话在重连时自动重订阅，因此从 web UI 发起的回合也会落进对应线程 |
 | `/guild forget` | 任意频道 | 仅操作员：移除适配器记录 |
 
 
@@ -133,7 +133,7 @@ dsh-discord:
 
 ```sh
 pnpm install --ignore-scripts
-pnpm test          # 683 tests incl. gateway/REST twin E2E
+pnpm test          # 729 tests incl. gateway/REST twin E2E
 pnpm typecheck
 pnpm lint
 pnpm build         # lib + client bundle

package/lib/dsh/host-events.d.ts

@@ -28,6 +28,18 @@ export interface HostSessionFollowFace {
     }, signal: AbortSignal): AsyncIterable<unknown>;
     control(signal: AbortSignal): AsyncIterable<unknown>;
 }
+/**
+ * Durable catch-up seeding for one tracked session (replay-fence D2):
+ * `floor` raises the in-memory watermark so snapshot records the thread
+ * already rendered are dropped before they reach the renderer;
+ * `suppressOpeningSnapshot` swallows the FIRST opening snapshot whole
+ * (watermark advances, nothing delivers) — the one-time migration for
+ * bindings that predate the persisted watermark.
+ */
+export interface TrackSeedOptions {
+    floor?: number;
+    suppressOpeningSnapshot?: boolean;
+}
 export interface HostEventRouterOptions {
     log?: (event: string, detail?: unknown) => void;
 }
@@ -37,6 +49,6 @@ export interface HostEventRouterOptions {
  * tracked session owns one follow loop whose frames join the shared queue.
  */
 export declare function createHostEventRouter(services: HostSessionFollowFace, options?: HostEventRouterOptions): {
-    track(sessionId: string): void;
+    track(sessionId: string, seed?: TrackSeedOptions): void;
     stream(signal: AbortSignal): AsyncIterable<unknown>;
 };

package/lib/dsh/host-events.js

@@ -75,6 +75,17 @@ function createFrameQueue() {
 function isRecord(value) {
     return typeof value === 'object' && value !== null;
 }
+/**
+ * Extract one journal record's seq through both envelope shapes (double
+ * `{type:'event', event:{seq}}` and flat `{seq}`); undefined when absent.
+ */
+function journalSeq(record) {
+    if (!isRecord(record))
+        return undefined;
+    const inner = isRecord(record['event']) ? record['event'] : record;
+    const seq = inner['seq'];
+    return typeof seq === 'number' ? seq : undefined;
+}
 /** Defensive text extraction from a queued message's JSON content parts. */
 function queueItemSummary(content) {
     if (!Array.isArray(content))
@@ -99,6 +110,8 @@ export function createHostEventRouter(services, options = {}) {
     const tracked = new Map();
     /** Last delivered durable seq per session: the replay-dedupe watermark. */
     const watermark = new Map();
+    /** Sessions whose NEXT opening snapshot is swallowed whole (legacy bindings). */
+    const suppressOnce = new Set();
     let consumer;
     let rootSignal;
     const startLoop = (sessionId, attempt = 0) => {
@@ -139,6 +152,25 @@ export function createHostEventRouter(services, options = {}) {
                                 : undefined;
                         if (batch === undefined)
                             continue;
+                        // Legacy-binding migration (D2): swallow the first opening
+                        // snapshot whole — the thread already rendered that history in
+                        // a pre-feature process; re-delivering it would replay the very
+                        // duplication this fence exists to stop. The watermark still
+                        // advances, so later live frames deliver untouched.
+                        if (frame['type'] === 'snapshot' && suppressOnce.delete(sessionId)) {
+                            let maxSeq = watermark.get(sessionId) ?? 0;
+                            for (const record of batch) {
+                                const seq = journalSeq(record);
+                                if (seq !== undefined && seq > maxSeq)
+                                    maxSeq = seq;
+                            }
+                            if (maxSeq > 0)
+                                watermark.set(sessionId, maxSeq);
+                            if (process.env['DSH_DISCORD_TRACE'] === '1') {
+                                console.error(`[dsh-discord:trace] snapshot-suppressed session=${sessionId.slice(0, 8)} watermark=${String(maxSeq)}`);
+                            }
+                            continue;
+                        }
                         const through = watermark.get(sessionId) ?? 0;
                         let delivered = through;
                         for (const record of batch) {
@@ -169,6 +201,11 @@ export function createHostEventRouter(services, options = {}) {
                                 type: 'session/event',
                                 sessionId,
                                 event: { type: inner.type, data: (typeof inner.data === 'object' && inner.data !== null ? inner.data : {}) },
+                                // Carrier + seq (replay-fence D4): the renderer's watermark
+                                // tracking and catch-up/live distinction ride these; pure
+                                // additions every existing consumer can ignore.
+                                carrier: frame['type'] === 'snapshot' ? 'snapshot' : 'live',
+                                ...(typeof inner.seq === 'number' ? { seq: inner.seq } : {}),
                             });
                         }
                         if (delivered > through)
@@ -253,11 +290,20 @@ export function createHostEventRouter(services, options = {}) {
         })();
     };
     return {
-        track(sessionId) {
+        track(sessionId, seed) {
             if (sessionId === '' || tracked.has(sessionId))
                 return;
             if (rootSignal?.aborted)
                 return;
+            if (seed !== undefined) {
+                // Seed BEFORE the loop opens: the opening snapshot races the very
+                // first watermark read.
+                if (seed.floor !== undefined && seed.floor > (watermark.get(sessionId) ?? 0)) {
+                    watermark.set(sessionId, seed.floor);
+                }
+                if (seed.suppressOpeningSnapshot === true)
+                    suppressOnce.add(sessionId);
+            }
             startLoop(sessionId);
         },
         stream(signal) {

package/lib/i18n.d.ts

@@ -90,6 +90,9 @@ declare const zh: {
     progressWriting: string;
     progressApprovalWait: string;
     progressTurnSummary: (total: number, failed: number, breakdown: string) => string;
+    userInputLabel: string;
+    userInputNonText: string;
+    userInputTruncated: string;
     modelNeedsThread: string;
     modelShowUnavailable: string;
     modelShowHeader: (sel: string, groups: number) => string;

package/lib/i18n.js

@@ -100,6 +100,9 @@ const zh = {
     progressTurnSummary: (total, failed, breakdown) => failed > 0
         ? `⚙️ 本轮 ${String(total)} 次工具调用 · ${String(failed)} 失败 ✗（${breakdown}）`
         : `⚙️ 本轮 ${String(total)} 次工具调用 ✓（${breakdown}）`,
+    userInputLabel: '💬 用户输入',
+    userInputNonText: '（非文本消息）',
+    userInputTruncated: '（已截断）',
     // ── /model show / select ─────────────────────────────────────────────
     modelNeedsThread: '⚠️ /model 需要在已绑定 Session 的任务线程中使用（先在项目频道 @ 机器人）。',
     modelShowUnavailable: '⚠️ 模型目录暂时不可用，请稍后重试。',
@@ -229,6 +232,9 @@ const en = {
     progressTurnSummary: (total, failed, breakdown) => failed > 0
         ? `⚙️ ${String(total)} tool calls this turn · ${String(failed)} failed ✗ (${breakdown})`
         : `⚙️ ${String(total)} tool calls this turn ✓ (${breakdown})`,
+    userInputLabel: '💬 User input',
+    userInputNonText: '(non-text message)',
+    userInputTruncated: '(truncated)',
     // ── /model show / select ─────────────────────────────────────────────
     modelNeedsThread: '⚠️ /model needs a thread bound to a Session (mention the bot in a project channel first).',
     modelShowUnavailable: '⚠️ The model catalog is temporarily unavailable; try again later.',

package/lib/index.js

@@ -24,7 +24,7 @@ import { guildKeysToForget, sweepExpired } from './state/retention.js';
 import { createHostEventRouter } from './dsh/host-events.js';
 import { listSessionIds, listSessionSummaries } from './dsh/host-face.js';
 import { installAskServicePatches } from './dsh/host-asks.js';
-import { createBindingStore } from './state/bindings.js';
+import { createBindingStore, renderWatermarkSeed } from './state/bindings.js';
 import { createIntentStore } from './state/intents.js';
 import { createTurnTracker } from './features/turn-ownership.js';
 import { createThreadCreationFlow } from './features/thread-creation.js';
@@ -173,6 +173,61 @@ export function apply(ctx, config = DEFAULT_DISCORD_SETTINGS) {
         const threadBindingStore = createBindingStore(threadTable);
         const intents = createIntentStore(intentTable);
         const turnTracker = createTurnTracker();
+        // Replay-fence (replay-fence-and-user-input D1/D2): the process start
+        // mark separates "binding created in-process" (fresh thread, render full
+        // history) from "binding from an earlier process" (its thread already
+        // shows that history; catch-up must not re-deliver it).
+        const processStartMs = Date.now();
+        /**
+         * The full reverse lookup the watermark paths need: binding key, parsed
+         * scope, and record for one session's owning thread (bindings are 1:1).
+         */
+        const threadBindingForSession = (sessionId) => {
+            for (const [key, record] of threadTable.entries()) {
+                if (record.sessionId !== sessionId)
+                    continue;
+                const scope = parseThreadBindingKey(key);
+                if (scope !== undefined)
+                    return { key, scope, record };
+            }
+            return undefined;
+        };
+        /**
+         * Durable catch-up seeding (D2), derived per record by
+         * `renderWatermarkSeed` — see state/bindings.ts.
+         */
+        const trackSeedForRecord = (record) => renderWatermarkSeed(record, processStartMs);
+        const trackSeedFor = (sessionId) => {
+            const found = threadBindingForSession(sessionId);
+            return found === undefined ? undefined : trackSeedForRecord(found.record);
+        };
+        /**
+         * Advance the owning thread's durable render watermark (D5): one
+         * revision-fenced write per turn boundary. A lost fence race is
+         * abandoned and retried at the next boundary — the watermark is a
+         * monotonic upper bound, so one lost write only widens the crash
+         * window's bounded re-render suffix.
+         */
+        const persistRenderedSeq = (sessionId, renderedSeq) => {
+            const found = threadBindingForSession(sessionId);
+            if (found === undefined)
+                return Promise.resolve();
+            const { key, record } = found;
+            if (renderedSeq <= (record.renderedSeq ?? 0))
+                return Promise.resolve();
+            return threadBindingStore.bind(key, {
+                sessionId: record.sessionId,
+                workspaceId: record.workspaceId,
+                createdBy: record.createdBy,
+                createdAtMs: record.createdAtMs,
+                renderedSeq,
+            }, { expectedRevision: record.revision }).then(outcome => {
+                if (!outcome.ok)
+                    rpcLog('discord_render_watermark_skipped', { sessionId, error: outcome.error });
+            }).catch((cause) => {
+                rpcLog('discord_render_watermark_threw', { sessionId, cause: String(cause) });
+            });
+        };
         // Approvals: process-local backing (minutes-lived; DSH replays pending
         // asks on mux reopen). turnActors maps submitted request ids to their
         // Discord authors — the ownership fact for approval/question clicks.
@@ -308,7 +363,7 @@ export function apply(ctx, config = DEFAULT_DISCORD_SETTINGS) {
                     ...(request.images === undefined ? {} : { images: request.images }),
                 }, { log: rpcLog, rpcId: request.requestId });
                 if (submitted.outcome === 'accepted')
-                    hostEvents.track(request.sessionId);
+                    hostEvents.track(request.sessionId, trackSeedFor(request.sessionId));
                 return submitted;
             },
         };
@@ -655,6 +710,16 @@ export function apply(ctx, config = DEFAULT_DISCORD_SETTINGS) {
                         rpcLog('discord_reconcile_thread_retired', { threadId: action.threadId, reason: action.reason });
                     }
                 }
+                // Replay fence (16.70): re-arm follow subscriptions for every
+                // binding that survived reconciliation. Without a Discord-side
+                // acquisition event this process (create/prompt/steer/resume), a
+                // web-origin turn on a bound session would render into nothing —
+                // the seeded floor keeps the opening snapshot from re-delivering
+                // history the thread already shows, so only the missed suffix
+                // (bounded by the last persisted turn boundary) catches up.
+                for (const [, record] of threadTable.entries()) {
+                    hostEvents.track(record.sessionId, trackSeedForRecord(record));
+                }
                 rpcLog('discord_reconcile_done', {});
             }
             finally {
@@ -689,16 +754,7 @@ export function apply(ctx, config = DEFAULT_DISCORD_SETTINGS) {
             }).catch((cause) => { rpcLog('discord_question_expiry_threw', String(cause)); });
         }, 30_000);
         ctx.effect(() => () => { clearInterval(expiryTimer); }, 'discord interaction expiry sweep');
-        const threadForSession = (sessionId) => {
-            for (const [key, record] of threadTable.entries()) {
-                if (record.sessionId !== sessionId)
-                    continue;
-                const scope = parseThreadBindingKey(key);
-                if (scope !== undefined)
-                    return scope.threadId;
-            }
-            return undefined;
-        };
+        const threadForSession = (sessionId) => threadBindingForSession(sessionId)?.scope.threadId;
         // DSH ask answerers (0.1.6 composed-approval model): the waterfalls
         // dispatch on the BASE TREE's event bus (the profile composes one event
         // tree per bundle and a waterfall only enumerates its own registry), so
@@ -781,7 +837,7 @@ export function apply(ctx, config = DEFAULT_DISCORD_SETTINGS) {
                 steer: async (sessionId, prompt) => {
                     const steered = await steerSession(dsh, { sessionId, prompt }, { log: rpcLog });
                     if (steered.outcome === 'accepted')
-                        hostEvents.track(sessionId);
+                        hostEvents.track(sessionId, trackSeedFor(sessionId));
                     return steered;
                 },
                 removeQueueItem: (sessionId, itemId) => removeQueueItemViaProxy(dsh, { sessionId, itemId }, { log: rpcLog }),
@@ -1093,12 +1149,19 @@ export function apply(ctx, config = DEFAULT_DISCORD_SETTINGS) {
                 approvalWait: copy.progressApprovalWait,
                 turnSummary: copy.progressTurnSummary,
             }),
+            userEchoCopy: () => ({
+                label: copy.userInputLabel,
+                nonText: copy.userInputNonText,
+                truncated: copy.userInputTruncated,
+            }),
             onQueueSnapshot: (sessionId, items) => { queueSnapshots.set(sessionId, items); },
-            onTurnEnded: (sessionId) => {
+            onTurnEnded: (sessionId, info) => {
                 const turn = turnTracker.active(sessionId);
                 if (turn !== undefined)
                     turnTracker.complete(turn.requestId);
                 rpcLog('discord_turn_ended', { sessionId, hadActiveTurn: turn !== undefined });
+                if (info !== undefined)
+                    void persistRenderedSeq(sessionId, info.renderedSeq);
             },
         });
         // The ask patches steer the same renderer's progress line (3.2 wiring).

package/lib/state/bindings.d.ts

@@ -44,3 +44,16 @@ export declare function createBindingStore<V extends {
 export type ChannelBindingStore = BindingStore<ChannelBinding>;
 /** Convenience alias for the thread-binding table's store. */
 export type ThreadBindingStore = BindingStore<ThreadBinding>;
+/** Catch-up seeding options for the event router's `track()` (replay-fence D2). */
+export interface RenderWatermarkSeed {
+    floor?: number;
+    suppressOpeningSnapshot?: boolean;
+}
+/**
+ * The durable catch-up seed for one thread binding (replay-fence-and-user-input
+ * D2): a persisted `renderedSeq` floors the watermark; a binding created
+ * before this process that never persisted one (pre-feature) suppresses its
+ * first opening snapshot whole; a binding born in-process seeds nothing so a
+ * fresh thread (resume adopt) renders the session's full history.
+ */
+export declare function renderWatermarkSeed(record: ThreadBinding, processStartMs: number): RenderWatermarkSeed | undefined;

package/lib/state/bindings.js

@@ -53,3 +53,17 @@ export function createBindingStore(table) {
         withKey: (key, op) => enqueue(key, op),
     };
 }
+/**
+ * The durable catch-up seed for one thread binding (replay-fence-and-user-input
+ * D2): a persisted `renderedSeq` floors the watermark; a binding created
+ * before this process that never persisted one (pre-feature) suppresses its
+ * first opening snapshot whole; a binding born in-process seeds nothing so a
+ * fresh thread (resume adopt) renders the session's full history.
+ */
+export function renderWatermarkSeed(record, processStartMs) {
+    if (record.renderedSeq !== undefined)
+        return { floor: record.renderedSeq };
+    if (record.createdAtMs < processStartMs)
+        return { suppressOpeningSnapshot: true };
+    return undefined;
+}

package/lib/state/domain.d.ts

@@ -54,6 +54,7 @@ export declare const discordDomainSpec: {
             revision: number;
             createdBy: string;
             createdAtMs: number;
+            renderedSeq?: number | undefined;
         }>;
         inbound_intents: import("@deepseek-ai/dsh-storage-domain").DomainTableSpec<"intent", {
             contentHash: string;

package/lib/state/records.d.ts

@@ -33,5 +33,6 @@ export declare const ThreadBindingRecord: z.ZodObject<{
     revision: z.ZodNumber;
     createdBy: z.ZodString;
     createdAtMs: z.ZodNumber;
+    renderedSeq: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strict>;
 export type ThreadBinding = z.infer<typeof ThreadBindingRecord>;

package/lib/state/records.js

@@ -27,4 +27,11 @@ export const ThreadBindingRecord = z.strictObject({
     revision: z.number().int().min(1),
     createdBy: z.string().min(1),
     createdAtMs: z.number().int().min(0),
+    /**
+     * Highest journal seq this thread has consumed (the durable render
+     * watermark, replay-fence-and-user-input D1). Absent on records written
+     * before the feature or before the thread rendered anything; advanced at
+     * turn boundaries through the revision fence.
+     */
+    renderedSeq: z.number().int().min(0).optional(),
 });

package/lib/stream/live.d.ts

@@ -17,6 +17,10 @@ export type LiveFrame = {
         type: string;
         data: Record<string, unknown>;
     };
+    /** Journal seq of the carried record (absent on seq-less records). */
+    seq?: number;
+    /** Which follow carrier delivered the record (replay-fence D4). */
+    carrier?: 'snapshot' | 'live';
     view?: unknown;
 } | {
     type: 'session/subscribed';
@@ -107,8 +111,20 @@ export interface LiveRenderDeps {
         approvalWait: string;
         turnSummary: (total: number, failed: number, breakdown: string) => string;
     };
-    /** Turn ownership release on turn/end. */
-    onTurnEnded?: (sessionId: string) => void;
+    /**
+     * Localized user-echo copy, resolved live (language can change).
+     * Unset: user/message records never echo (the pre-feature behavior).
+     */
+    userEchoCopy?: () => {
+        label: string;
+        nonText: string;
+        truncated: string;
+    };
+    /** Turn ownership release on turn/end; `info` carries the consumed watermark. */
+    onTurnEnded?: (sessionId: string, info?: {
+        threadId: string;
+        renderedSeq: number;
+    }) => void;
 }
 export declare function startLiveRender(deps: LiveRenderDeps): {
     dispose(): void;

package/lib/stream/live.js

@@ -21,6 +21,12 @@ 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;
+/**
+ * Echo budget for one user/message (replay-fence D6): history catch-up
+ * mirrors, it does not replay wholesale — beyond this the text truncates
+ * with a marker and the Session log remains the source of truth.
+ */
+const USER_ECHO_MAX = 500;
 /**
  * Wire-level live-path tracing (`DSH_DISCORD_TRACE=1` → stderr). Default
  * silent like the rest of the adapter; the live path's drops (unrecognized
@@ -53,6 +59,15 @@ function assistantText(message) {
         .map(block => block.text)
         .join('');
 }
+/** Extract one user message's text (text parts only, newline-joined). */
+function userTextParts(content) {
+    if (!Array.isArray(content))
+        return '';
+    return content
+        .filter((block) => typeof block === 'object' && block !== null && block.type === 'text')
+        .map(block => block.text)
+        .join('\n');
+}
 /** The callId of a tool/result event (block-carried, defensive). */
 function resultCallId(data) {
     if (typeof data['callId'] === 'string')
@@ -119,6 +134,8 @@ export function startLiveRender(deps) {
             toolNames: new Map(),
             toolTitles: new Map(),
             lastTitle: undefined,
+            lastSeq: 0,
+            caughtUp: false,
         };
         runtimes.set(threadId, runtime);
         return runtime;
@@ -270,13 +287,63 @@ export function startLiveRender(deps) {
             await flush;
         };
     }
+    /**
+     * User-input echo (replay-fence D6): mirror one human `user/message` into
+     * the thread as one quoted bot message. Filter matrix:
+     * - `source.kind !== 'user'` (plugin/system injections): never renders,
+     *   and none of its content is disclosed.
+     * - Discord-originated input (`source.rpcId` = `discord:<messageId>`):
+     *   already the user's own message in the thread — echoes only during a
+     *   fresh runtime's initial catch-up (resume into a new thread); live
+     *   frames and post-catch-up snapshots skip it.
+     */
+    function echoUserInput(threadId, runtime, data, event) {
+        const copy = deps.userEchoCopy?.();
+        if (copy === undefined)
+            return;
+        const source = data['source'];
+        if (typeof source !== 'object' || source === null)
+            return;
+        const { kind, rpcId } = source;
+        if (kind !== 'user')
+            return;
+        const fromDiscord = typeof rpcId === 'string' && rpcId.startsWith('discord:');
+        if (fromDiscord && (event.carrier === 'live' || runtime.caughtUp))
+            return;
+        const text = userTextParts(data['content']);
+        const body = text === ''
+            ? copy.nonText
+            : text.length <= USER_ECHO_MAX
+                ? text
+                : `${truncateText(text, USER_ECHO_MAX)} ${copy.truncated}`;
+        const quoted = body.split('\n').map(line => `> ${line}`).join('\n');
+        const payload = buildOutboundMessage({ kind: 'user', content: `${copy.label}\n${quoted}` });
+        void deps.delivery.send({ channelId: threadId, content: payload.content }).then(sent => {
+            if (sent.outcome !== 'completed') {
+                deps.log?.('discord_live_user_echo_failed', { threadId, outcome: sent.outcome });
+            }
+        }).catch((cause) => {
+            deps.log?.('discord_live_user_echo_threw', { threadId, cause: String(cause) });
+        });
+    }
     function handleSessionEvent(sessionId, threadId, runtime, event, frameView) {
         const data = event.data;
         if (TRACE)
             trace('handleSessionEvent', event.type, 'keys:', Object.keys(data).join(','));
+        // Watermark bookkeeping BEFORE any branch (replay-fence D5): a record
+        // that falls through the switch is still consumed — the persisted
+        // watermark must never claim less than what was delivered.
+        if (typeof event.seq === 'number' && event.seq > runtime.lastSeq)
+            runtime.lastSeq = event.seq;
+        if (event.carrier === 'live')
+            runtime.caughtUp = true;
         const turnId = typeof data['turn'] === 'number' ? String(data['turn']) : undefined;
         const stepId = typeof data['step'] === 'number' ? String(data['step']) : undefined;
         switch (event.type) {
+            case 'user/message': {
+                echoUserInput(threadId, runtime, data, event);
+                return;
+            }
             case 'turn/start': {
                 if (typeof turnId !== 'string')
                     return;
@@ -453,7 +520,10 @@ export function startLiveRender(deps) {
                         deps.log?.('discord_live_activity_delete_threw', { threadId, cause: String(cause) });
                     });
                 });
-                deps.onTurnEnded?.(sessionId);
+                // Watermark persist rides the same boundary (replay-fence D5): the
+                // consumed high-water seq at turn end becomes the durable floor the
+                // next process's catch-up seeds from.
+                deps.onTurnEnded?.(sessionId, { threadId, renderedSeq: runtime.lastSeq });
                 return;
             }
             default:
@@ -546,7 +616,14 @@ export function startLiveRender(deps) {
             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']);
+        const frameSeq = frame['seq'];
+        const frameCarrier = frame['carrier'];
+        handleSessionEvent(sessionId, threadId, runtimeFor(threadId), {
+            type: eventWrapper.type,
+            data: eventWrapper.data ?? {},
+            ...(typeof frameSeq === 'number' ? { seq: frameSeq } : {}),
+            ...(frameCarrier === 'snapshot' || frameCarrier === 'live' ? { carrier: frameCarrier } : {}),
+        }, frame['view']);
     }
     async function runLoop() {
         // Bounded reopen loop: the mux stream is the live accelerator; a dropped

package/lib/stream/outbound.d.ts

@@ -8,7 +8,7 @@
  */
 /** Discord message flags the adapter always sets (silent delivery). */
 export declare const OUTBOUND_MESSAGE_FLAGS: number;
-export type OutboundContentKind = 'assistant' | 'tool' | 'title' | 'error';
+export type OutboundContentKind = 'assistant' | 'tool' | 'title' | 'error' | 'user';
 export interface OutboundMessage {
     content: string;
     flags: number;
@@ -20,6 +20,8 @@ export interface OutboundMessage {
 /**
  * Build one outbound payload. Titles are additionally length-capped (they
  * render into headers and badges); all content is mention-neutralized.
+ * `user` rides the tool path: suppression only, no table wrapping — echoed
+ * input is quoted verbatim, never reflowed.
  */
 export declare function buildOutboundMessage(input: {
     kind: OutboundContentKind;

package/lib/stream/outbound.js

@@ -14,6 +14,8 @@ export const OUTBOUND_MESSAGE_FLAGS = DISCORD_SUPPRESS_NOTIFICATIONS_FLAG;
 /**
  * Build one outbound payload. Titles are additionally length-capped (they
  * render into headers and badges); all content is mention-neutralized.
+ * `user` rides the tool path: suppression only, no table wrapping — echoed
+ * input is quoted verbatim, never reflowed.
  */
 export function buildOutboundMessage(input) {
     const content = input.kind === 'title'

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@addozhang/dsh-discord",
-  "version": "0.5.0-alpha.2",
-  "description": "Discord-first adapter for DeepSeek Harness",
+  "version": "0.5.0-rc.2",
+  "description": "Discord adapter for DeepSeek Harness · DeepSeek Harness 的 Discord 适配器",
   "license": "MIT",
   "type": "module",
   "packageManager": "pnpm@11.0.8",