@xmanrui/dsh-im 4.9.1 → 4.10.0

package/plugin-src/host/inbound-ttl-service.mjs

@@ -0,0 +1,179 @@
+import { realpathSync } from 'node:fs';
+import { resolve } from 'node:path';
+
+import { sweepInboundAttachments } from '../../src/channels/shared/inbound-file.mjs';
+
+const DEFAULT_SWEEP_INTERVAL_MS = 30 * 60_000;
+
+// A tracked directory is shielded from sweeps while its turn may still be
+// running. Aborted or stalled turns never call cleanup(), so protection has
+// an upper bound — far above the default reply timeout — after which the
+// directory falls back under TTL control instead of leaking forever.
+const TRACKED_PROTECTION_MS = 24 * 60 * 60_000;
+
+/**
+ * Host-process coordinator for the global inbound attachment TTL. The staged
+ * registry marks directories owned by in-flight turns so a slow turn can
+ * outlive any TTL window without the sweeper deleting its files.
+ */
+export function createInboundTtlService({
+  store,
+  logger = console,
+  intervalMs = DEFAULT_SWEEP_INTERVAL_MS,
+} = {}) {
+  if (!store || typeof store.getTtlHours !== 'function') {
+    throw new TypeError('createInboundTtlService requires a store exposing getTtlHours()');
+  }
+  const tracked = new Map();
+  const providers = new Set();
+  let timer = null;
+
+  const runSweep = () => {
+    sweepNow().catch((error) => {
+      logger.error?.('[dsh-im] inbound attachment sweep failed', error);
+    });
+  };
+
+  function registerWorkspaceProvider(provider) {
+    if (typeof provider !== 'function') {
+      throw new TypeError('inbound TTL workspace provider must be a function');
+    }
+    const wasEmpty = providers.size === 0;
+    providers.add(provider);
+    // The startup sweep races channel activation and usually runs before any
+    // provider exists; re-sweep on the first registration so crash leftovers
+    // do not wait a full interval.
+    if (wasEmpty && timer) runSweep();
+    return () => {
+      providers.delete(provider);
+    };
+  }
+
+  function stagingRetention() {
+    // TTL 0 deletes at turn end; every other mode keeps files for the sweeper.
+    return store.getTtlHours() === 0 ? 'turn' : 'persistent';
+  }
+
+  function canonicalPath(directory) {
+    try {
+      return realpathSync(directory);
+    } catch {
+      return null;
+    }
+  }
+
+  function trackDirectory(directory, { now = () => Date.now() } = {}) {
+    if (typeof directory !== 'string' || !directory) return;
+    const trackedAt = now();
+    tracked.set(directory, trackedAt);
+    // The harness-reported cwd and workspaceFor() may normalize symlinks
+    // differently; track both spellings so either side finds the entry.
+    const canonical = canonicalPath(directory);
+    if (canonical && canonical !== directory) tracked.set(canonical, trackedAt);
+  }
+
+  function releaseDirectory(directory) {
+    tracked.delete(directory);
+    const canonical = canonicalPath(directory);
+    if (canonical && canonical !== directory) tracked.delete(canonical);
+  }
+
+  function isTrackedNow(directory) {
+    const trackedAt = tracked.get(directory);
+    if (trackedAt === undefined) return false;
+    if (Date.now() - trackedAt >= TRACKED_PROTECTION_MS) {
+      tracked.delete(directory);
+      return false;
+    }
+    return true;
+  }
+
+  function trackStaged(staged) {
+    if (!staged || typeof staged !== 'object') return staged;
+    const { directory } = staged;
+    if (typeof directory !== 'string' || !directory) return staged;
+    trackDirectory(directory);
+    const cleanup = typeof staged.cleanup === 'function' ? staged.cleanup : null;
+    return Object.freeze({
+      ...staged,
+      async cleanup() {
+        try {
+          await cleanup?.call(staged);
+        } finally {
+          releaseDirectory(directory);
+        }
+      },
+    });
+  }
+
+  async function sweepNow() {
+    const ttlHours = store.getTtlHours();
+    // Keep-forever never deletes, so no workspace is even inspected.
+    if (ttlHours === -1) return { deletedDirectories: 0, sweptWorkspaces: 0 };
+    const workspaces = new Set();
+    for (const provider of providers) {
+      try {
+        const provided = await provider();
+        for (const workspace of Array.isArray(provided) ? provided : []) {
+          if (typeof workspace === 'string' && workspace) workspaces.add(resolve(workspace));
+        }
+      } catch (error) {
+        logger.warn?.('[dsh-im] inbound TTL workspace provider failed', error);
+      }
+    }
+    const isTracked = (directory) => isTrackedNow(directory)
+      || (canonicalPath(directory) !== null && isTrackedNow(canonicalPath(directory)));
+    let deletedDirectories = 0;
+    let sweptWorkspaces = 0;
+    for (const workspace of workspaces) {
+      try {
+        const result = await sweepInboundAttachments(workspace, ttlHours, { isTracked });
+        deletedDirectories += result.deleted;
+        sweptWorkspaces += 1;
+      } catch (error) {
+        logger.warn?.(`[dsh-im] inbound attachment sweep failed under ${workspace}`, error);
+      }
+    }
+    if (deletedDirectories > 0) {
+      logger.info?.(
+        `[dsh-im] inbound attachment sweep deleted ${deletedDirectories} directories`
+        + ` across ${sweptWorkspaces} workspaces (ttl ${ttlHours}h)`,
+      );
+    }
+    return { deletedDirectories, sweptWorkspaces };
+  }
+
+  function start() {
+    if (timer) return;
+    runSweep();
+    timer = setInterval(runSweep, intervalMs);
+    timer.unref?.();
+  }
+
+  // A freshly saved TTL postpones the next scheduled sweep by a full
+  // interval so the new value is never enforced by a sweep firing moments
+  // after the change, and is not starved of one either.
+  function resetSweepSchedule() {
+    if (!timer) return;
+    clearInterval(timer);
+    timer = setInterval(runSweep, intervalMs);
+    timer.unref?.();
+  }
+
+  function stop() {
+    if (!timer) return;
+    clearInterval(timer);
+    timer = null;
+  }
+
+  return Object.freeze({
+    registerWorkspaceProvider,
+    stagingRetention,
+    trackDirectory,
+    trackStaged,
+    sweepNow,
+    start,
+    resetSweepSchedule,
+    stop,
+  });
+}

package/plugin-src/host/index.mjs

@@ -13,6 +13,7 @@ import { setImHostLanguage } from '../../src/channels/shared/i18n.mjs';
 import { installDeliveryRpc } from './delivery-rpc.mjs';
 import { installDeliveryHttp } from './delivery-http.mjs';
 import { createDeliveryService } from './delivery-service.mjs';
+import { installInboundTtlRpc } from './inbound-ttl-rpc.mjs';
 import { installUpdateRpc } from './update-rpc.mjs';
 
 export const name = 'dsh-im-host';
@@ -32,6 +33,7 @@ function channelConfig(config, name, deliveryService) {
 
 export function createImHostPlugin(internals = {}) {
   const startUpdate = internals.installUpdateRpc ?? installUpdateRpc;
+  const startInboundTtl = internals.installInboundTtlRpc ?? installInboundTtlRpc;
   const startDelivery = internals.installDeliveryRpc ?? installDeliveryRpc;
   const startDeliveryHttp = internals.installDeliveryHttp ?? installDeliveryHttp;
   const makeDeliveryService = internals.createDeliveryService ?? createDeliveryService;
@@ -68,6 +70,7 @@ export function createImHostPlugin(internals = {}) {
             deliveryService.send(botId, targetId, text, options)
           ),
           listTargets: async (botId) => (await deliveryService.listTargets(botId)).targets,
+          listBots: () => deliveryService.listBots(),
         }));
       }
       const activate = async (readyCtx) => {
@@ -109,6 +112,11 @@ export function createImHostPlugin(internals = {}) {
       } catch (error) {
         logger.error?.('[dsh-im] failed to activate update management; continuing with channels', error);
       }
+      try {
+        startInboundTtl(ctx, { config });
+      } catch (error) {
+        logger.error?.('[dsh-im] failed to activate inbound TTL settings; continuing with channels', error);
+      }
       try {
         startDelivery(ctx, deliveryService, { authority: config.rpcAuthority });
       } catch (error) {

package/plugin-src/host/modern-harness-api.mjs

@@ -200,6 +200,7 @@ class ModernHarnessApi {
   #pendingQuestions = new Map();
   #pendingApprovals = new Map();
   #sessionCursors = new Map();
+  #assistantStreams = new Map();
   #disposers = [];
   #disposed = false;
 
@@ -261,6 +262,13 @@ class ModernHarnessApi {
         if (Number.isSafeInteger(event.seq)) this.#rememberCursor(sessionId, event.seq);
         this.#broadcast({ type: 'session/event', sessionId, event });
       }, { global: true }));
+      this.#disposers.push(ctx.on('agent/assistant-stream', ({ agent, frame }) => {
+        this.#acceptAssistantStream(agent, frame);
+      }, { global: true }));
+      this.#disposers.push(ctx.on('agent/disposed', ({ agent }) => {
+        const sessionId = agent?.session?.id;
+        if (typeof sessionId === 'string') this.#assistantStreams.delete(sessionId);
+      }, { global: true }));
       this.#disposers.push(ctx.on(
         'approval/request',
         (request, next) => this.#requestApproval(request, next),
@@ -328,7 +336,7 @@ class ModernHarnessApi {
       cursor = this.#sessionCursors.get(sessionId) ?? snapshot.cursor;
       if (beforeSeq === undefined && cursor === snapshot.cursor) {
         return {
-          events: historyEntries(snapshot.records),
+          events: this.#withAssistantStream(sessionId, historyEntries(snapshot.records)),
           hasMore: snapshot.hasMore === true,
           ...(snapshot.projections === undefined ? {} : { projections: snapshot.projections }),
         };
@@ -342,7 +350,54 @@ class ModernHarnessApi {
         ...(beforeSeq === undefined ? {} : { beforeSeq }),
       },
     }, signal);
-    return { events: historyEntries(page.records), hasMore: page.hasMore === true };
+    return {
+      events: beforeSeq === undefined
+        ? this.#withAssistantStream(sessionId, historyEntries(page.records))
+        : historyEntries(page.records),
+      hasMore: page.hasMore === true,
+    };
+  }
+
+  #acceptAssistantStream(agent, frame) {
+    const sessionId = agent?.session?.id;
+    if (typeof sessionId !== 'string' || !frame || typeof frame !== 'object') return;
+    if (frame.type === 'start') {
+      const nextSeq = agent?.session?.seq;
+      const startedAfterSeq = Number.isSafeInteger(nextSeq) && nextSeq >= 0
+        ? nextSeq - 1
+        : this.#sessionCursors.get(sessionId) ?? -1;
+      this.#assistantStreams.set(sessionId, {
+        attemptId: frame.attemptId,
+        turn: frame.turn,
+        step: frame.step,
+        startedAfterSeq,
+        entries: [],
+      });
+      return;
+    }
+    const stream = this.#assistantStreams.get(sessionId);
+    if (!stream || stream.attemptId !== frame.attemptId) return;
+    if (frame.type === 'end') {
+      this.#assistantStreams.delete(sessionId);
+      return;
+    }
+    if (frame.type !== 'chunk' || frame.index !== stream.entries.length) return;
+    stream.entries.push({
+      type: 'transient',
+      event: {
+        type: 'assistant/chunk',
+        // Match DSH's Web client ordering: live chunks sit in the numeric gap
+        // before the durable assistant/message that replaces them.
+        seq: stream.startedAfterSeq + 1 - 1 / (frame.index + 2),
+        time: frame.time,
+        data: { turn: stream.turn, step: stream.step, chunk: frame.chunk },
+      },
+    });
+  }
+
+  #withAssistantStream(sessionId, entries) {
+    const transient = this.#assistantStreams.get(sessionId)?.entries ?? [];
+    return transient.length === 0 ? entries : [...entries, ...transient];
   }
 
   #rememberCursor(sessionId, cursor) {
@@ -556,6 +611,7 @@ class ModernHarnessApi {
     if (this.#disposed) return;
     this.#disposed = true;
     for (const subscription of [...this.#mux]) subscription.close();
+    this.#assistantStreams.clear();
     for (const pending of [...this.#pendingApprovals.values()]) pending.settle('cancelled');
     for (const pending of [...this.#pendingQuestions.values()]) pending.settle(
       'cancelled',

package/src/channels/feishu/bridge.mjs

@@ -5,6 +5,8 @@ import {
   extractText,
   isAllowedSender,
   isBotSender,
+  isTopicGroupKey,
+  managedGroupKey,
   splitText,
 } from './message-utils.mjs';
 import {
@@ -101,6 +103,10 @@ import {
 // Lazily evaluated: t() must run after setImHostLanguage, not at import time.
 const INTERACTION_RESOLVED_TEXT = () => t('这个问题已在其他客户端处理，无需再次回答。');
 const RESOLVED_REPLY_TTL_MS = 30 * 60_000;
+/** Managed-topic root candidates expire without a returned thread_id. */
+const ROOT_CANDIDATE_TTL_MS = 30 * 60_000;
+/** Bound main-feed roots awaiting a topic so silent drops cannot grow them. */
+const MAX_ROOT_CANDIDATES = 512;
 
 const MENU_COMMAND = /^\/m(?:enu)?$/i;
 const REPAIR_COMMAND_PREFIX = /^\/repair(?:\s|$)/i;
@@ -480,6 +486,14 @@ export class FeishuHarnessBridge {
   #appId;
   #botOpenId;
   #groupResponseMode;
+  /** When true, group replies that belong to a Feishu topic ask reply_in_thread. */
+  #groupTopicReply = false;
+  /** Group chats this bot has seen; only these may use topic replies. */
+  #groupChatIds = new Set();
+  /** Anchor message id → whether its replies should stay in a Feishu topic. */
+  #anchorTopicReply = new Map();
+  /** Main-feed roots this bot intends to auto-open as topics, awaiting thread_id. */
+  #rootCandidates = new Map();
   #repair;
   #repairAttempt = null;
   #repairMonitorVersion = 0;
@@ -516,6 +530,7 @@ export class FeishuHarnessBridge {
     appId,
     botOpenId,
     groupResponseMode = FEISHU_GROUP_RESPONSE_MODES.ALL,
+    groupTopicReply = false,
     repair,
     repairPollIntervalMs = REPAIR_POLL_INTERVAL_MS,
     repairLinkWaitMs = REPAIR_LINK_WAIT_MS,
@@ -555,6 +570,7 @@ export class FeishuHarnessBridge {
     this.#appId = nonEmptyString(appId);
     this.#botOpenId = nonEmptyString(botOpenId);
     this.#groupResponseMode = normalizeFeishuGroupResponseMode(groupResponseMode);
+    this.#groupTopicReply = groupTopicReply === true;
     this.#repair = repair ?? null;
     this.#repairPollIntervalMs = repairPollIntervalMs;
     this.#repairLinkWaitMs = repairLinkWaitMs;
@@ -576,6 +592,10 @@ export class FeishuHarnessBridge {
     this.#groupResponseMode = normalizeFeishuGroupResponseMode(value);
   }
 
+  setGroupTopicReply(value) {
+    this.#groupTopicReply = value === true;
+  }
+
   #isAddressed(event) {
     if (event?.message?.chat_type === 'p2p') return true;
     const mentions = Array.isArray(event?.message?.mentions) ? event.message.mentions : [];
@@ -584,6 +604,106 @@ export class FeishuHarnessBridge {
       || mention?.open_id === this.#botOpenId);
   }
 
+  /**
+   * Conversation key for one inbound event. When group-topic replies are on,
+   * a main-feed question addressed to the bot opens a fresh managed topic
+   * session instead of joining the shared group session, and messages inside
+   * a topic we already opened resolve back to that same managed session.
+   */
+  #resolveKey(event) {
+    const chatType = event?.message?.chat_type;
+    const chatId = nonEmptyString(event?.message?.chat_id);
+    if (chatType !== 'group') return conversationKey(event);
+    const messageId = nonEmptyString(event?.message?.message_id);
+    const threadId = nonEmptyString(event?.message?.thread_id);
+    if (threadId) {
+      const root = this.#state?.topicRootFor?.(threadId) ?? null;
+      return root && chatId
+        ? managedGroupKey(chatId, root.rootMessageId)
+        : `group:${chatId}:thread:${threadId}`;
+    }
+    if (this.#groupTopicReply && chatId && messageId && this.#isAddressed(event)) {
+      return managedGroupKey(chatId, messageId);
+    }
+    return `group:${chatId}`;
+  }
+
+  /**
+   * Record whether replies anchored on `messageId` should stay in a topic.
+   * `asRoot` marks a main-feed question this bot will auto-open as a topic.
+   */
+  #rememberTopicReply(messageId, key) {
+    if (!nonEmptyString(messageId)) return;
+    this.#anchorTopicReply.set(messageId, this.#groupTopicReply && isTopicGroupKey(key));
+    if (this.#anchorTopicReply.size > 2048) {
+      const oldest = this.#anchorTopicReply.keys().next().value;
+      if (oldest !== undefined) this.#anchorTopicReply.delete(oldest);
+    }
+    if (typeof key === 'string' && key.startsWith('group:')) {
+      const chatId = key.split(':')[1];
+      if (chatId) this.#groupChatIds.add(chatId);
+    }
+  }
+
+  /** Whether a reply anchored on `replyTo` must ask Feishu to keep it in a topic. */
+  #replyInThreadFor(replyTo) {
+    return this.#groupTopicReply
+      && nonEmptyString(replyTo)
+      && this.#anchorTopicReply.get(replyTo) === true;
+  }
+
+  /** Drop expired root candidates so a silently dropped reply cannot leak memory. */
+  #pruneRootCandidates(now = Date.now()) {
+    for (const [messageId, expiresAt] of this.#rootCandidates) {
+      if (expiresAt <= now) this.#rootCandidates.delete(messageId);
+    }
+  }
+
+  /** Track a main-feed root this bot will auto-open as a topic, bounded + TTL'd. */
+  #rememberTopicRoot(messageId) {
+    if (!nonEmptyString(messageId)) return;
+    const now = Date.now();
+    this.#pruneRootCandidates(now);
+    this.#rootCandidates.delete(messageId);
+    this.#rootCandidates.set(messageId, now + ROOT_CANDIDATE_TTL_MS);
+    while (this.#rootCandidates.size > MAX_ROOT_CANDIDATES) {
+      const oldest = this.#rootCandidates.keys().next().value;
+      if (oldest === undefined) break;
+      this.#rootCandidates.delete(oldest);
+    }
+  }
+
+  /** Forget a root candidate once its topic opened or the reply degraded. */
+  #forgetTopicRoot(messageId) {
+    if (!nonEmptyString(messageId)) return;
+    this.#rootCandidates.delete(messageId);
+  }
+
+  /** Persist thread_id once Feishu auto-opened a topic from a managed root. */
+  async #registerTopicFromReply(replyTo, chatId, response) {
+    const threadId = nonEmptyString(response?.data?.thread_id);
+    if (threadId) {
+      await this.#registerTopicThreadId(threadId, replyTo, chatId);
+    } else {
+      // No thread_id means the topic did not open; drop the candidate so a
+      // later addressed question opens a fresh session, not a stale slot.
+      this.#forgetTopicRoot(replyTo);
+    }
+  }
+
+  /** Persist thread_id when the reply anchor is a root this bot auto-opened. */
+  async #registerTopicThreadId(threadId, rootMessageId, chatId) {
+    this.#pruneRootCandidates();
+    if (!threadId || !this.#rootCandidates.has(rootMessageId)) return;
+    this.#rootCandidates.delete(rootMessageId);
+    if (!chatId || typeof this.#state?.setTopic !== 'function') return;
+    try {
+      await this.#state.setTopic(threadId, { rootMessageId, chatId });
+    } catch (error) {
+      this.#logger.warn?.('[dsh-feishu] failed to record managed topic:', error?.message ?? String(error));
+    }
+  }
+
   accept(event) {
     if (this.#signal?.aborted) return Promise.resolve();
     const messageId = nonEmptyString(event?.message?.message_id);
@@ -606,12 +726,13 @@ export class FeishuHarnessBridge {
 
     let key;
     try {
-      key = conversationKey(event);
+      key = this.#resolveKey(event);
     } catch {
       this.#status.messagesRejected += 1;
       this.#status.lastRejectedAt = new Date().toISOString();
       return Promise.resolve();
     }
+    this.#rememberTopicReply(messageId, key);
 
     const commandMessage = extractInboundMessage(event, this.#client);
     const commandText = nonEmptyString(commandMessage.content) ?? '';
@@ -635,6 +756,15 @@ export class FeishuHarnessBridge {
       this.#acceptedMessageIds.set(messageId, null);
       return this.#finishAccessDecision(event, messageId, access);
     }
+    // Register a managed-topic root only after access is allowed, so a
+    // rejected or ignored question never reserves a candidate slot.
+    if (this.#groupTopicReply
+      && event?.message?.chat_type === 'group'
+      && !nonEmptyString(event?.message?.thread_id)
+      && isTopicGroupKey(key)
+      && key.includes(':managed:')) {
+      this.#rememberTopicRoot(messageId);
+    }
     if (event.message.chat_type === 'p2p') {
       const chatId = nonEmptyString(event.message.chat_id);
       if (chatId) rememberConnectionTestTarget(this.#state, { chatId });
@@ -1910,6 +2040,7 @@ export class FeishuHarnessBridge {
   }) {
     // Confirmations triggered by a card interaction stay anchored to the
     // card's message so they land inside the same Feishu topic.
+    this.#rememberTopicReply(messageId, key);
     const reply = (text) => this.#send(chatId, text, { replyTo: messageId });
     // Approval card buttons: approve:<approvalId> / reject:<approvalId>
     if (action.startsWith('approve:') || action.startsWith('reject:')) {
@@ -2383,18 +2514,25 @@ export class FeishuHarnessBridge {
       try {
         const response = await this.#client.im.v1.message.reply({
           path: { message_id: replyTo },
-          data: { msg_type: 'interactive', content },
+          data: {
+            msg_type: 'interactive',
+            content,
+            ...(this.#replyInThreadFor(replyTo) ? { reply_in_thread: true } : {}),
+          },
         });
         if (response?.code && response.code !== 0) {
           throw new Error(`Feishu card reply failed: ${response.msg || response.code}`);
         }
         const repliedMessageId = nonEmptyString(response?.data?.message_id);
+        await this.#registerTopicFromReply(replyTo, chatId, response);
         if (repliedMessageId) {
           this.#rememberCardRoute(repliedMessageId, chatId, options);
           return repliedMessageId;
         }
       } catch (error) {
         this.#logger.warn?.('[dsh-feishu] threaded card reply failed; sending a plain card:', error?.message ?? String(error));
+        // The topic never opened; a managed root candidate must not linger.
+        this.#forgetTopicRoot(replyTo);
       }
     }
     const response = await this.#client.im.v1.message.create({
@@ -3206,6 +3344,10 @@ export class FeishuHarnessBridge {
         || (validLastSeq(entry.lastSeq) && entry.lastSeq >= event.seq)
         || (validEventSeq(failedSeq) && event.seq > failedSeq)) continue;
       try {
+        // Re-derive topic intent at delivery time: the push may outlive the
+        // bounded in-memory anchor cache, but the conversation key still tells
+        // us whether the completion belongs to a Feishu topic.
+        this.#rememberTopicReply(entry.replyToMessageId ?? null, key);
         await this.#sendCard(
           entry.chatId,
           completionCard(sessionId, entry.title, reason),
@@ -3346,12 +3488,18 @@ export class FeishuHarnessBridge {
         ? (file) => this.#channel.sendImage(chatId, file, {
             replyTo,
             signal: this.#signal,
+            ...(this.#replyInThreadFor(replyTo)
+              ? { replyInThread: true, onReplyThreadId: async (threadId) => this.#registerTopicThreadId(threadId, replyTo, chatId) }
+              : {}),
           })
         : undefined,
       sendFile: typeof this.#channel?.sendFile === 'function'
         ? (file) => this.#channel.sendFile(chatId, file, {
             replyTo,
             signal: this.#signal,
+            ...(this.#replyInThreadFor(replyTo)
+              ? { replyInThread: true, onReplyThreadId: async (threadId) => this.#registerTopicThreadId(threadId, replyTo, chatId) }
+              : {}),
           })
         : undefined,
       onFailure: (artifact, error) => setLastMessageFailure(this.#status, error, {
@@ -3499,7 +3647,12 @@ export class FeishuHarnessBridge {
           completedArtifacts = completed.artifacts ?? [];
           await controller.setContent(answerTextForDelivery(completedAnswer, completedArtifacts));
         },
-      }, { replyTo: messageId });
+      }, {
+        replyTo: messageId,
+        ...(this.#replyInThreadFor(messageId)
+          ? { replyInThread: true, onReplyThreadId: async (threadId) => this.#registerTopicThreadId(threadId, messageId, chatId) }
+          : {}),
+      });
     } catch (error) {
       this.#status.streamErrors = (this.#status.streamErrors ?? 0) + 1;
       if (completedAnswer || completedArtifacts.length > 0) {
@@ -4007,11 +4160,16 @@ export class FeishuHarnessBridge {
       try {
         const response = await this.#client.im.v1.message.reply({
           path: { message_id: replyTo },
-          data: { msg_type: 'text', content },
+          data: {
+            msg_type: 'text',
+            content,
+            ...(this.#replyInThreadFor(replyTo) ? { reply_in_thread: true } : {}),
+          },
         });
         if (response?.code && response.code !== 0) {
           throw new Error(`Feishu reply failed: ${response.msg || response.code}`);
         }
+        await this.#registerTopicFromReply(replyTo, chatId, response);
         return nonEmptyString(response?.data?.message_id);
       } catch (error) {
         // The referenced message may be gone (recalled/deleted); keep the
@@ -4020,6 +4178,8 @@ export class FeishuHarnessBridge {
           '[dsh-feishu] threaded reply failed; falling back to a plain message:',
           error?.message ?? String(error),
         );
+        // The topic never opened; a managed root candidate must not linger.
+        this.#forgetTopicRoot(replyTo);
       }
     }
     const response = await this.#client.im.v1.message.create({