@rezti/dsh-rez-wechat 0.1.22 → 0.1.24

package/lib/index.d.ts

@@ -1,4 +1,6 @@
 import type { Context } from '@deepseek-ai/cordis';
+import type { WebRoute } from '@deepseek-ai/dsh-host-webserver';
 export declare const name = "rez-wechat";
 export declare const inject: string[];
+export declare function channelHistoryRoute(ctx: Context): WebRoute;
 export declare function apply(ctx: Context): Promise<void>;

package/lib/index.js

@@ -3,6 +3,7 @@ import { WeixinChannel } from './channel.js';
 import { WecomChannel, shouldStartWecomWebhook } from './wecom-channel.js';
 import { revealSessionInRegistry } from './unarchive.js';
 import { WECOM_BINDABLE_ROOMS } from './wecom-store.js';
+import { channelHistorySnapshot } from './session-history.js';
 export const name = 'rez-wechat';
 export const inject = ['systemPrompt', 'webServer', 'rezSso'];
 const GUIDANCE = [
@@ -165,6 +166,42 @@ function getWorkspaceRegistry(ctx) {
         return undefined;
     }
 }
+export function channelHistoryRoute(ctx) {
+    return {
+        kind: 'exact',
+        path: '/api/dsh-rez-suite/channel/history',
+        handler: async (req, res) => {
+            if (!isLoopbackRequest(req))
+                return writeJson(res, 403, { error: 'forbidden: loopback-only' });
+            if (req.method !== 'POST')
+                return writeJson(res, 405, { error: 'method not allowed' });
+            if (req.headers.origin && req.headers.origin !== `http://${req.headers.host}`) {
+                return writeJson(res, 403, { error: 'forbidden: cross-origin' });
+            }
+            const body = await readJsonBody(req);
+            const sessionId = typeof body?.sessionId === 'string' ? body.sessionId.trim() : '';
+            const maxMessages = body?.maxMessages ?? 40;
+            if (!sessionId || typeof maxMessages !== 'number' || !Number.isInteger(maxMessages) || maxMessages < 1 || maxMessages > 100) {
+                return writeJson(res, 400, { error: 'invalid sessionId or maxMessages' });
+            }
+            const abort = new AbortController();
+            const close = () => { abort.abort(); };
+            res.on('close', close);
+            try {
+                const controller = ctx.get('sessionController');
+                const snapshot = await channelHistorySnapshot(controller, sessionId, maxMessages, abort.signal);
+                writeJson(res, 200, snapshot);
+            }
+            catch (error) {
+                if (!res.destroyed)
+                    writeJson(res, 502, { error: error instanceof Error ? error.message : String(error) });
+            }
+            finally {
+                res.off('close', close);
+            }
+        },
+    };
+}
 export async function apply(ctx) {
     const channel = new WeixinChannel();
     channel.startIfLoggedIn();
@@ -175,7 +212,7 @@ export async function apply(ctx) {
         order: 162,
         text: GUIDANCE,
     }), 'dsh-rez-wechat: prompt');
-    const routes = [...weixinRoutes(channel, ctx), ...wecomRoutes(wecom)];
+    const routes = [channelHistoryRoute(ctx), ...weixinRoutes(channel, ctx), ...wecomRoutes(wecom)];
     ctx.effect(() => {
         const disposers = routes.map(route => ctx.webServer.register(route));
         return () => { for (const dispose of disposers)

package/lib/session-history.d.ts

@@ -0,0 +1,14 @@
+/** Reuse the host's official SessionController; never implement a second stream carrier. */
+export interface ChannelSessionController {
+    follow(request: {
+        address: {
+            kind: 'session';
+            sessionId: string;
+        };
+        maxMessages: number;
+    }, signal: AbortSignal): AsyncIterable<unknown>;
+}
+export declare function channelHistorySnapshot(controller: ChannelSessionController | undefined, sessionId: string, maxMessages?: number, signal?: AbortSignal): Promise<{
+    records: unknown[];
+    cursor: number;
+}>;

package/lib/session-history.js

@@ -0,0 +1,21 @@
+export async function channelHistorySnapshot(controller, sessionId, maxMessages = 40, signal) {
+    if (!controller)
+        throw new Error('未找到官方 sessionController，请使用 Harness 0.1.5-rc.2 启动本测试版。');
+    const abort = new AbortController();
+    const combined = AbortSignal.any([abort.signal, AbortSignal.timeout(10_000), ...(signal ? [signal] : [])]);
+    const stream = controller.follow({ address: { kind: 'session', sessionId }, maxMessages }, combined);
+    try {
+        for await (const value of stream) {
+            combined.throwIfAborted();
+            const frame = value;
+            if (frame?.type !== 'snapshot' || !Array.isArray(frame.records) || !Number.isSafeInteger(frame.cursor)) {
+                throw new Error('官方会话快照格式不兼容，无法读取回复。');
+            }
+            return { records: frame.records, cursor: frame.cursor };
+        }
+        throw new Error('官方会话订阅未返回快照。');
+    }
+    finally {
+        abort.abort();
+    }
+}

package/lib/web-shim.d.ts

@@ -106,6 +106,19 @@ export declare function parseChoice(userText: string, questions: PendingQuestion
     label: string;
 } | undefined;
 export declare function historyEvents(body: unknown): unknown[];
+/** Durable seq, or seq0 for batched frames like text-chunks. Missing → -1. */
+export declare function eventSeq(event: unknown): number;
+export declare function historyCursor(events: unknown[]): number;
+/**
+ * True when a turn that started *after* beforeSeq has ended.
+ * Events without seq are always included (unit fixtures / legacy history).
+ */
+export declare function turnSettledAfter(events: unknown[], beforeSeq: number): boolean;
+/**
+ * Visible assistant text for WeChat.
+ * Web UI streams via text-chunks; final assistant/message is often tool-only.
+ * Prefer longer streamed chunks when they supersede a short mid-turn message.
+ */
 export declare function lastAssistantText(events: unknown[]): string;
 export declare function turnIsIdle(events: unknown[]): boolean;
 export declare function pickWechatModel(models: unknown, env?: NodeJS.ProcessEnv): ModelRef | undefined;
@@ -122,7 +135,7 @@ export declare function weixinBridgeEnv(opts: {
     launcherPath: string;
     shimScript: string;
 }): NodeJS.ProcessEnv;
-export declare function postRpc(baseUrl: string, method: string, params: Record<string, unknown>, timeoutMs?: number, env?: NodeJS.ProcessEnv): Promise<unknown>;
+export declare function postRpc(baseUrl: string, method: string, params: Record<string, unknown>, timeoutMs?: number, env?: NodeJS.ProcessEnv, signal?: AbortSignal): Promise<unknown>;
 export declare function extractArchivedSessionIds(body: unknown): string[];
 /** Stock dsh archives one-way and hides blank sessions. Restore + attach + title. */
 export declare function ensureSessionVisible(rpc: RpcFn, sessionId: string, env?: NodeJS.ProcessEnv, workspaceId?: string, loopback?: boolean): Promise<void>;

package/lib/web-shim.js

@@ -733,24 +733,105 @@ export function historyEvents(body) {
                         : []);
     return raw.map(unwrapHistoryItem);
 }
+/** Durable seq, or seq0 for batched frames like text-chunks. Missing → -1. */
+export function eventSeq(event) {
+    if (typeof event !== 'object' || event === null)
+        return -1;
+    const rec = event;
+    if (typeof rec.seq === 'number' && Number.isFinite(rec.seq))
+        return rec.seq;
+    if (typeof rec.seq0 === 'number' && Number.isFinite(rec.seq0))
+        return rec.seq0;
+    return -1;
+}
+export function historyCursor(events) {
+    let max = -1;
+    for (const event of events) {
+        const seq = eventSeq(event);
+        if (seq > max)
+            max = seq;
+    }
+    return max;
+}
+/**
+ * True when a turn that started *after* beforeSeq has ended.
+ * Events without seq are always included (unit fixtures / legacy history).
+ */
+export function turnSettledAfter(events, beforeSeq) {
+    let open = 0;
+    let sawStart = false;
+    for (const event of events) {
+        if (typeof event !== 'object' || event === null)
+            continue;
+        const seq = eventSeq(event);
+        if (seq >= 0 && seq <= beforeSeq)
+            continue;
+        const type = event.type;
+        if (type === 'turn/start') {
+            open += 1;
+            sawStart = true;
+        }
+        if (type === 'turn/end')
+            open = Math.max(0, open - 1);
+    }
+    return sawStart && open === 0;
+}
+function textsFromChunkEvent(rec) {
+    const data = typeof rec.data === 'object' && rec.data !== null ? rec.data : rec;
+    const texts = data.texts;
+    if (!Array.isArray(texts))
+        return '';
+    return texts.map(part => typeof part === 'string' ? part : '').join('');
+}
+/**
+ * Visible assistant text for WeChat.
+ * Web UI streams via text-chunks; final assistant/message is often tool-only.
+ * Prefer longer streamed chunks when they supersede a short mid-turn message.
+ */
 export function lastAssistantText(events) {
-    let text = '';
+    let lastUserSeq = -1;
     for (const event of events) {
         if (typeof event !== 'object' || event === null)
             continue;
         const rec = event;
         const type = typeof rec.type === 'string' ? rec.type : '';
         const role = typeof rec.role === 'string' ? rec.role : '';
+        if (type === 'user/message' || role === 'user') {
+            lastUserSeq = Math.max(lastUserSeq, eventSeq(rec));
+        }
+    }
+    let fromMessage = '';
+    const chunkParts = [];
+    for (const event of events) {
+        if (typeof event !== 'object' || event === null)
+            continue;
+        const rec = event;
+        const type = typeof rec.type === 'string' ? rec.type : '';
+        const seq = eventSeq(rec);
+        const afterUser = lastUserSeq < 0 || seq < 0 || seq > lastUserSeq;
+        if (afterUser && type === 'text-chunks') {
+            const piece = textsFromChunkEvent(rec);
+            if (piece !== '')
+                chunkParts.push(piece);
+            continue;
+        }
+        const role = typeof rec.role === 'string' ? rec.role : '';
         const isAssistant = type === 'assistant/message' || role === 'assistant';
-        if (!isAssistant)
+        if (!isAssistant || !afterUser)
             continue;
         const data = typeof rec.data === 'object' && rec.data !== null ? rec.data : rec;
         const message = typeof data.message === 'object' && data.message !== null ? data.message : data;
-        const chunk = flattenVisibleText(message.content ?? data.content ?? rec.content) || (typeof rec.text === 'string' ? stripThinkTags(rec.text) : '');
+        const chunk = flattenVisibleText(message.content ?? data.content ?? rec.content)
+            || (typeof rec.text === 'string' ? stripThinkTags(rec.text) : '');
         if (chunk.trim() !== '')
-            text = chunk;
+            fromMessage = chunk;
     }
-    return text.trim();
+    const fromChunks = chunkParts.join('');
+    const msg = fromMessage.trim();
+    const chunks = fromChunks.trim();
+    if (chunks.length > msg.length)
+        return chunks;
+    return msg || chunks;
 }
 export function turnIsIdle(events) {
     let open = 0;
@@ -875,7 +956,7 @@ export function weixinBridgeEnv(opts) {
 async function sleep(ms) {
     await new Promise(resolve => setTimeout(resolve, ms));
 }
-export async function postRpc(baseUrl, method, params, timeoutMs = RPC_TIMEOUT_MS, env = process.env) {
+export async function postRpc(baseUrl, method, params, timeoutMs = RPC_TIMEOUT_MS, env = process.env, signal) {
     const origin = (() => {
         try {
             const withScheme = /:\/\//.test(baseUrl) ? baseUrl : `http://${baseUrl}`;
@@ -888,7 +969,9 @@ export async function postRpc(baseUrl, method, params, timeoutMs = RPC_TIMEOUT_M
     })();
     const endpoint = normalizeRpcEndpoint(method);
     const url = `${origin}/api/${endpoint}`;
-    const envelope = encodeClientRequest(endpoint, params);
+    const envelope = endpoint === 'dsh-rez-suite/channel/history'
+        ? params
+        : encodeClientRequest(endpoint, params);
     const send = async (cookie) => {
         const headers = { 'content-type': 'application/json' };
         if (cookie !== undefined && cookie.length > 0)
@@ -897,7 +980,7 @@ export async function postRpc(baseUrl, method, params, timeoutMs = RPC_TIMEOUT_M
             method: 'POST',
             headers,
             body: JSON.stringify(envelope),
-            signal: AbortSignal.timeout(timeoutMs),
+            signal: signal ? AbortSignal.any([signal, AbortSignal.timeout(timeoutMs)]) : AbortSignal.timeout(timeoutMs),
         });
     };
     let cookie = await authCookieFor(origin, env);
@@ -976,38 +1059,21 @@ async function maybeSelectModel(rpc, sessionId, env) {
         }
     }
 }
-/** Prefer session/page (0.1.5 surface); fall back to session/history (apiproxy). */
+/** Read the official follow opening snapshot via our authenticated loopback route.
+ * session/page requires a real cursor; -1 means an empty log, not its tip.
+ */
 async function fetchSessionHistory(rpc, sessionId, maxMessages = 40) {
-    const attempts = [
-        {
-            method: 'session/page',
-            params: {
-                address: { kind: 'session', sessionId },
-                // Official tip-of-log sentinel. MAX_SAFE_INTEGER is "past cursor" and always 400s.
-                throughSeq: -1,
-                maxMessages,
-            },
-        },
-        { method: 'session/history', params: { sessionId, maxMessages } },
-    ];
-    let lastError;
-    for (const attempt of attempts) {
-        try {
-            return historyEvents(await rpc(attempt.method, attempt.params));
-        }
-        catch (error) {
-            lastError = error;
-        }
-    }
-    throw lastError instanceof Error ? lastError : new Error(String(lastError));
+    return historyEvents(await rpc('dsh-rez-suite/channel/history', { sessionId, maxMessages }));
 }
 async function sessionAlive(rpc, sessionId) {
     try {
         await fetchSessionHistory(rpc, sessionId, 1);
         return true;
     }
-    catch {
-        return false;
+    catch (error) {
+        if (/not.found|不存在/i.test(error instanceof Error ? error.message : String(error)))
+            return false;
+        throw error;
     }
 }
 function promptPayload(sessionId, text) {
@@ -1124,21 +1190,17 @@ function composeWechatReply(events, ignorePending) {
     }
     return { text: visible, pendingQuestions };
 }
-async function waitForAssistant(rpc, sessionId, beforeText, timeoutMs, ignorePending, stuckText = STUCK_ACK, signal) {
+async function waitForAssistant(rpc, sessionId, beforeText, beforeSeq, timeoutMs, ignorePending, stuckText = STUCK_ACK, signal) {
     const deadline = Date.now() + timeoutMs;
     let last = { text: '', pendingQuestions: [] };
-    let idleOnce = false;
+    const emptyDone = '（本轮无文字回复，请到网页查看）';
     while (Date.now() < deadline) {
         if (signal?.aborted === true) {
             throw new Error('本轮已被新消息打断（可发「重启对话」或再问一句）');
         }
-        let events = [];
-        try {
-            events = await fetchSessionHistory(rpc, sessionId, 40);
-        }
-        catch {
-            events = [];
-        }
+        const history = await fetchSessionHistory(rpc, sessionId, 40);
+        const cursorAware = beforeSeq >= 0 || history.some(event => eventSeq(event) >= 0);
+        const events = cursorAware ? history.filter(event => eventSeq(event) > beforeSeq) : history;
         const composed = composeWechatReply(events, ignorePending);
         // 旧题（本轮 prompt 前就在的 Selection）不能立刻发回微信；只发新 turn 里新出现的题。
         if (composed.pendingQuestions.length > 0 && composed.text !== '') {
@@ -1148,12 +1210,17 @@ async function waitForAssistant(rpc, sessionId, beforeText, timeoutMs, ignorePen
             return { text: stuckText, pendingQuestions: [] };
         if (composed.text !== '')
             last = composed;
+        if (cursorAware && turnSettledAfter(events, beforeSeq)) {
+            if (composed.text !== '')
+                return composed;
+            // Turn finished but no new usable text (tool-only / filtered monologue).
+            return {
+                text: emptyDone,
+                pendingQuestions: composed.pendingQuestions,
+            };
+        }
         const idle = turnIsIdle(events);
-        if (idle)
-            idleOnce = true;
-        if (idle && composed.text !== '' && composed.text !== beforeText)
-            return composed;
-        if (idleOnce && composed.text !== '' && composed.text !== beforeText)
+        if (!cursorAware && idle && composed.text !== '' && composed.text !== beforeText)
             return composed;
         await sleep(400);
     }
@@ -1170,7 +1237,7 @@ export async function runHeadlessViaWeb(opts) {
     const storeFile = sessionStorePath(env);
     const key = basename(opts.cwd ?? process.cwd()) || 'default';
     const customRpc = opts.rpc !== undefined;
-    const rpc = opts.rpc ?? ((method, params) => postRpc(webBaseUrl(env), method, params));
+    const rpc = opts.rpc ?? ((method, params) => postRpc(webBaseUrl(env), method, params, RPC_TIMEOUT_MS, env, opts.signal));
     const timeoutMs = opts.timeoutMs ?? Number(env.DSH_BRIDGE_TIMEOUT_MS ?? 10 * 60 * 1000);
     const signal = opts.signal;
     const sidebarUnarchive = opts.sidebarUnarchive !== false && !customRpc;
@@ -1207,15 +1274,9 @@ export async function runHeadlessViaWeb(opts) {
     if (signal?.aborted === true)
         throw new Error('本轮已被新消息打断');
     const promptText = restart ? RESTART_SEED : text;
-    let before = '';
-    let events = [];
-    try {
-        events = await fetchSessionHistory(rpc, sessionId, 40);
-        before = usableAssistantText(lastAssistantText(events));
-    }
-    catch {
-        before = '';
-    }
+    const events = await fetchSessionHistory(rpc, sessionId, 40);
+    const before = usableAssistantText(lastAssistantText(events));
+    const beforeSeq = historyCursor(events);
     const pending = extractPendingQuestions(events);
     const questions = pending.length > 0
         ? pending
@@ -1240,7 +1301,8 @@ export async function runHeadlessViaWeb(opts) {
         }
         await rpc('session/prompt', promptPayload(sessionId, promptText));
     }
-    const reply = await waitForAssistant(rpc, sessionId, before, timeoutMs, questions, stuckAck(folder), signal);
+    const reply = await waitForAssistant(rpc, sessionId, before, beforeSeq, timeoutMs, questions, stuckAck(folder), signal);
+    signal?.throwIfAborted();
     // Stuck / approval-blocked sessions poison the sticky pointer — drop it so
     // the next WeCom/WeChat turn opens a fresh web session instead of hanging.
     if (reply.text === stuckAck(folder)) {

package/lib/wecom-channel.d.ts

@@ -4,6 +4,11 @@
  */
 import { type WecomBotPublic, type WecomBotRecord } from './wecom-store.js';
 export declare const WECOM_NON_TEXT_HINT = "\u8BF7\u53D1\u6587\u5B57\u3002\u56FE\u7247\u548C\u6587\u4EF6\u8BF7\u8D70\u7F51\u9875\u7AEF\u6216 Nextcloud\u3002";
+/** Official replyStream content limit, measured in UTF-8 bytes. */
+export declare const WECOM_REPLY_MAX_BYTES = 20480;
+export declare function clipWecomReply(text: string): string;
+/** Bound even a turn implementation that fails to observe cancellation. */
+export declare function abortableTurn<T>(work: Promise<T>, signal: AbortSignal): Promise<T>;
 export type WecomBindingPhase = 'idle' | 'connecting' | 'authenticated' | 'error';
 export interface WecomBindingStatus {
     room: string;

package/lib/wecom-channel.js

@@ -7,6 +7,42 @@ import { dshHome } from '@rezti/dsh-rez-sso';
 import { clearSessionStoreKey, isRestartCommand, runHeadlessViaWeb, } from './web-shim.js';
 import { loadWecomChannels, publicWecomBots, saveWecomChannels, applyWecomBotPatch, WECOM_BINDABLE_ROOMS, } from './wecom-store.js';
 export const WECOM_NON_TEXT_HINT = '请发文字。图片和文件请走网页端或 Nextcloud。';
+/** Official replyStream content limit, measured in UTF-8 bytes. */
+export const WECOM_REPLY_MAX_BYTES = 20_480;
+export function clipWecomReply(text) {
+    if (Buffer.byteLength(text, 'utf8') <= WECOM_REPLY_MAX_BYTES)
+        return text;
+    const suffix = '\n…(已截断，请到网页查看完整回复)';
+    const budget = WECOM_REPLY_MAX_BYTES - Buffer.byteLength(suffix, 'utf8');
+    let bytes = 0;
+    let end = 0;
+    for (const character of text) {
+        bytes += Buffer.byteLength(character, 'utf8');
+        if (bytes > budget)
+            break;
+        end += character.length;
+    }
+    return text.slice(0, end) + suffix;
+}
+/** Bound even a turn implementation that fails to observe cancellation. */
+export async function abortableTurn(work, signal) {
+    let abort;
+    try {
+        return await Promise.race([
+            work,
+            new Promise((_, reject) => {
+                abort = () => reject(signal.reason ?? new Error('本轮已被新消息打断'));
+                signal.addEventListener('abort', abort, { once: true });
+                if (signal.aborted)
+                    abort();
+            }),
+        ]);
+    }
+    finally {
+        if (abort)
+            signal.removeEventListener('abort', abort);
+    }
+}
 /** Cap how long one WeCom turn can block the per-room queue (stuck Kimi / approval). */
 export const WECOM_TURN_TIMEOUT_MS = 90_000;
 const MAX_SEEN_MSGIDS = 200;
@@ -163,6 +199,7 @@ export class WecomChannel {
     }
     dropBindings() {
         for (const row of this.bindings.values()) {
+            row.turnAbort?.abort();
             try {
                 row.client.disconnect();
             }
@@ -229,6 +266,8 @@ export class WecomChannel {
      * queue reaches it). Otherwise「重启对话」waits behind a hung「正在处理…」.
      */
     enqueueText(row, frame) {
+        if (this.rememberMsgid(row, frame))
+            return;
         const text = extractWecomText(frame);
         if (text.length > 0) {
             row.turnAbort?.abort();
@@ -236,7 +275,7 @@ export class WecomChannel {
                 clearSessionStoreKey(join(this.home, 'dsh-rez-wecom', row.bot.room, 'web-sessions.json'), row.bot.room);
             }
         }
-        this.enqueue(row, () => this.handleText(row, frame));
+        this.enqueue(row, () => this.handleText(row, frame, true));
     }
     rememberMsgid(row, frame) {
         const id = wecomMsgid(frame);
@@ -249,8 +288,8 @@ export class WecomChannel {
             row.seen.splice(0, row.seen.length - MAX_SEEN_MSGIDS);
         return false;
     }
-    async handleText(row, frame) {
-        if (this.rememberMsgid(row, frame))
+    async handleText(row, frame, remembered = false) {
+        if (!remembered && this.rememberMsgid(row, frame))
             return;
         const text = extractWecomText(frame);
         const streamId = newStreamId();
@@ -262,21 +301,29 @@ export class WecomChannel {
         row.turnAbort = turnAbort;
         const timeout = AbortSignal.timeout(WECOM_TURN_TIMEOUT_MS);
         const signal = AbortSignal.any([turnAbort.signal, timeout]);
+        let finished = false;
+        const finish = async (content) => {
+            if (finished)
+                return;
+            await row.client.replyStream(frame, streamId, clipWecomReply(content), true);
+            finished = true;
+        };
         try {
             await row.client.replyStream(frame, streamId, '正在处理…', false);
-            const reply = await this.runTurn(row.bot.room, text, signal);
+            const reply = await abortableTurn(this.runTurn(row.bot.room, text, signal), signal);
             if (turnAbort.signal.aborted) {
-                await row.client.replyStream(frame, streamId, '已取消（收到新消息）', true);
+                await finish('已取消（收到新消息）');
                 return;
             }
-            await row.client.replyStream(frame, streamId, reply.length > 0 ? reply : '（空回复）', true);
+            await finish(reply.length > 0 ? reply : '（空回复）');
         }
         catch (error) {
             const why = error instanceof Error ? error.message : String(error);
+            row.hint = `「${row.bot.room}」回复未完成：${why}`;
             const superseded = turnAbort.signal.aborted && !timeout.aborted;
             if (superseded) {
                 try {
-                    await row.client.replyStream(frame, streamId, '已取消（收到新消息）', true);
+                    await finish('已取消（收到新消息）');
                 }
                 catch { /* WS may already be closed */ }
                 return;
@@ -286,7 +333,7 @@ export class WecomChannel {
                 ? '处理超时。请发「重启对话」再试，或到网页左侧该房间看是否在等批准。'
                 : `处理失败：${why}`;
             try {
-                await row.client.replyStream(frame, streamId, message, true);
+                await finish(message);
             }
             catch {
                 /* WS may already be closed */
@@ -295,6 +342,12 @@ export class WecomChannel {
             clearSessionStoreKey(join(this.home, 'dsh-rez-wecom', row.bot.room, 'web-sessions.json'), row.bot.room);
         }
         finally {
+            if (!finished) {
+                try {
+                    await finish('（回复中断，请再发一句或「重启对话」）');
+                }
+                catch { /* WS may already be closed */ }
+            }
             if (row.turnAbort === turnAbort)
                 delete row.turnAbort;
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rezti/dsh-rez-wechat",
-  "version": "0.1.22",
+  "version": "0.1.24",
   "description": "ReZ-TI WeChat/WeCom bridges. Personal WeChat is QClaw/ClawBot scan-and-chat via dsh-wechat-bridge; WeCom AI bots use the official @wecom/aibot-node-sdk (BotID + Secret) bound per Harness room.",
   "type": "module",
   "engines": {