remerge

Author: Yuan

RELEASE_NOTE.md

@@ -109,3 +109,22 @@
   - `file://` URLs
   - Windows drive paths (`C:\...`)
   - Windows UNC paths (`\\server\share\...`)
+
+---
+
+# Release Note (2026-02-09)
+
+## 🐞 Bugfix: Plan-Mode Question Flow
+
+- Fixed `tool=question` error flow getting stuck in bridge conversations.
+- Added question-proxy handling in bridge runtime:
+  - captures question tool input when tool status is `error`
+  - sends actionable question prompt back to IM chat (Feishu/Telegram)
+  - accepts user reply by index or option text
+  - resumes session with structured answer payload
+- Updated timeout behavior:
+  - no longer auto-continues with defaults
+  - after 15 minutes without reply, pending question is canceled with status notice
+- Added debug logs for real `question` tool payload inspection:
+  - logs `status`, `input`, and `error` (with safe truncation)
+  - logs explicit `payload-parse-failed` when normalization fails

src/handler/command.ts

@@ -126,6 +126,8 @@ export type CommandContext = {
   chatAwaitingSaveFile: Map<string, boolean>;
   chatMaxFileSizeMb: Map<string, number>;
   chatMaxFileRetry: Map<string, number>;
+  clearPendingQuestionForChat: (cacheKey: string) => void;
+  clearAllPendingQuestions: () => void;
   ensureSession: () => Promise<string>;
   createNewSession: () => Promise<string | undefined>;
   sendCommandMessage: (content: string) => Promise<void>;
@@ -155,6 +157,8 @@ export async function handleSlashCommand(ctx: CommandContext): Promise<boolean>
     chatAwaitingSaveFile,
     chatMaxFileSizeMb,
     chatMaxFileRetry,
+    clearPendingQuestionForChat,
+    clearAllPendingQuestions,
     ensureSession,
     createNewSession,
     sendCommandMessage,
@@ -502,6 +506,7 @@ export async function handleSlashCommand(ctx: CommandContext): Promise<boolean>
     sessionToCtx.set(targetId, { chatId: ctx.chatId, senderId: ctx.senderId });
     chatAgent.delete(cacheKey);
     chatModel.delete(cacheKey);
+    clearPendingQuestionForChat(cacheKey);
     await sendCommandMessage(`✅ 已切换到会话: ${targetId}`);
     return true;
   }
@@ -542,6 +547,7 @@ export async function handleSlashCommand(ctx: CommandContext): Promise<boolean>
   }
 
   if (normalizedCommand === 'new') {
+    clearPendingQuestionForChat(cacheKey);
     const sessionId = await createNewSession();
     if (sessionId) {
       await sendCommandMessage(`✅ 已切换到新会话: ${sessionId}`);
@@ -562,6 +568,7 @@ export async function handleSlashCommand(ctx: CommandContext): Promise<boolean>
     chatAwaitingSaveFile.clear();
     chatMaxFileSizeMb.clear();
     chatMaxFileRetry.clear();
+    clearAllPendingQuestions();
 
     if (globalState.__bridge_progress_msg_ids) {
       globalState.__bridge_progress_msg_ids.clear();

src/handler/event.flow.ts

@@ -6,6 +6,7 @@ import type {
   EventSessionIdle,
   OpencodeClient,
 } from '@opencode-ai/sdk';
+import type { ToolPart } from '@opencode-ai/sdk';
 import type { BridgeAdapter } from '../types';
 import type { AdapterMux } from './mux';
 import { bridgeLogger } from '../logger';
@@ -31,12 +32,20 @@ import {
   shouldSplitOutFinalAnswer,
   splitFinalAnswerFromExecution,
 } from './execution.flow';
+import {
+  extractQuestionPayload,
+  isQuestionToolPart,
+  QUESTION_TIMEOUT_MS,
+  renderQuestionPrompt,
+} from './question.proxy';
+import type { PendingQuestionState, NormalizedQuestionPayload } from './question.proxy';
 
 type SessionContext = { chatId: string; senderId: string };
 type SelectedModel = { providerID: string; modelID: string; name?: string };
 type ListenerState = { isListenerStarted: boolean; shouldStopListener: boolean };
 type EventWithType = { type: string; properties?: unknown };
 type EventMessageBuffer = MessageBuffer & { __executionCarried?: boolean };
+const QUESTION_DEBUG_MAX_LEN = 4000;
 
 export type EventFlowDeps = {
   listenerState: ListenerState;
@@ -53,8 +62,110 @@ export type EventFlowDeps = {
   chatAwaitingSaveFile: Map<string, boolean>;
   chatMaxFileSizeMb: Map<string, number>;
   chatMaxFileRetry: Map<string, number>;
+  chatPendingQuestion: Map<string, PendingQuestionState>;
+  pendingQuestionTimers: Map<string, NodeJS.Timeout>;
 };
 
+function clearPendingQuestionForChat(deps: EventFlowDeps, cacheKey: string) {
+  const timer = deps.pendingQuestionTimers.get(cacheKey);
+  if (timer) {
+    clearTimeout(timer);
+    deps.pendingQuestionTimers.delete(cacheKey);
+  }
+  deps.chatPendingQuestion.delete(cacheKey);
+}
+
+function clearAllPendingQuestions(deps: EventFlowDeps) {
+  for (const timer of deps.pendingQuestionTimers.values()) {
+    clearTimeout(timer);
+  }
+  deps.pendingQuestionTimers.clear();
+  deps.chatPendingQuestion.clear();
+}
+
+function getCacheKeyBySession(
+  sessionId: string,
+  deps: EventFlowDeps,
+): { cacheKey: string; adapterKey: string; chatId: string } | null {
+  const ctx = deps.sessionToCtx.get(sessionId);
+  const adapterKey = deps.sessionToAdapterKey.get(sessionId);
+  if (!ctx || !adapterKey) return null;
+  return {
+    cacheKey: `${adapterKey}:${ctx.chatId}`,
+    adapterKey,
+    chatId: ctx.chatId,
+  };
+}
+
+function clipDebugText(value: string, max = QUESTION_DEBUG_MAX_LEN): string {
+  if (value.length <= max) return value;
+  return `${value.slice(0, max)}...<truncated>`;
+}
+
+async function captureQuestionProxyIfNeeded(params: {
+  part: ToolPart;
+  sessionId: string;
+  messageId: string;
+  api: OpencodeClient;
+  mux: AdapterMux;
+  deps: EventFlowDeps;
+}): Promise<boolean> {
+  const { part, sessionId, messageId, api, mux, deps } = params;
+  if (!isQuestionToolPart(part)) return false;
+
+  const payloadMaybe = extractQuestionPayload(part?.state?.input);
+  if (payloadMaybe === null) return false;
+  const payload: NormalizedQuestionPayload = payloadMaybe;
+
+  const sessionCtx = getCacheKeyBySession(sessionId, deps);
+
+  if (!sessionCtx) return false;
+
+  const { cacheKey, adapterKey, chatId } = sessionCtx;
+  const callID = part.callID || `question-${messageId}`;
+  const existing = deps.chatPendingQuestion.get(cacheKey);
+  if (existing && existing.callID === callID && existing.messageId === messageId) {
+    return true;
+  }
+
+  clearPendingQuestionForChat(deps, cacheKey);
+
+  const pending: PendingQuestionState = {
+    key: cacheKey,
+    adapterKey,
+    chatId,
+    sessionId,
+    messageId,
+    callID,
+    payload,
+    createdAt: Date.now(),
+    dueAt: Date.now() + QUESTION_TIMEOUT_MS,
+  };
+
+  deps.chatPendingQuestion.set(cacheKey, pending);
+
+  const adapter = mux.get(adapterKey);
+  if (adapter) {
+    await adapter.sendMessage(chatId, renderQuestionPrompt(pending)).catch(() => {});
+  }
+
+  const timer = setTimeout(async () => {
+    const current = deps.chatPendingQuestion.get(cacheKey);
+    if (!current || current.callID !== callID || current.messageId !== messageId) return;
+
+    clearPendingQuestionForChat(deps, cacheKey);
+    const currentAdapter = mux.get(current.adapterKey);
+    if (currentAdapter) {
+      await currentAdapter
+        .sendMessage(current.chatId, '## Status\n⏰ 超时，本轮提问已取消。请重新发起问题。')
+        .catch(() => {});
+    }
+  }, QUESTION_TIMEOUT_MS);
+
+  deps.pendingQuestionTimers.set(cacheKey, timer);
+  return true;
+}
+
 function isAbortedError(err: unknown): boolean {
   return (
     typeof err === 'object' &&
@@ -145,6 +256,15 @@ async function handleMessageUpdatedEvent(
   }
 
   if (info.error) {
+    const cache = getCacheKeyBySession(sid, deps);
+    const pending = cache ? deps.chatPendingQuestion.get(cache.cacheKey) : undefined;
+
+    if (pending && pending.messageId === mid) {
+      markStatus(deps.msgBuffers, mid, 'done', 'awaiting-user-reply');
+      await flushMessage(adapter, ctx.chatId, mid, deps.msgBuffers, true);
+      return;
+    }
+
     if (isAbortedError(info.error)) {
       markStatus(
         deps.msgBuffers,
@@ -181,6 +301,7 @@ async function handleMessageUpdatedEvent(
 
 async function handleMessagePartUpdatedEvent(
   event: EventMessagePartUpdated,
+  api: OpencodeClient,
   mux: AdapterMux,
   deps: EventFlowDeps,
 ) {
@@ -225,6 +346,21 @@ async function handleMessagePartUpdatedEvent(
     buffer.selectedModel = selectedModel;
   }
   applyPartToBuffer(buffer, part, delta);
+
+  if (
+    part.type === 'tool' &&
+    (await captureQuestionProxyIfNeeded({
+      part: part as ToolPart,
+      sessionId,
+      messageId,
+      api,
+      mux,
+      deps,
+    }))
+  ) {
+    markStatus(deps.msgBuffers, messageId, 'done', 'awaiting-user-reply');
+  }
+
   bridgeLogger.debug(
     `[BridgeFlowDebug] part-applied sid=${sessionId} mid=${messageId} part=${part.type} textLen=${buffer.text.length} reasoningLen=${buffer.reasoning.length} tools=${buffer.tools.size} status=${buffer.status} note="${buffer.statusNote || ''}" hasPlatform=${!!buffer.platformMsgId}`,
   );
@@ -394,7 +530,7 @@ export async function startGlobalEventListenerWithDeps(
           bridgeLogger.debug(
             `[BridgeFlowDebug] part.updated sid=${p.sessionID} mid=${p.messageID} type=${p.type} deltaLen=${(pe.properties.delta || '').length}`,
           );
-          await handleMessagePartUpdatedEvent(event as EventMessagePartUpdated, mux, deps);
+          await handleMessagePartUpdatedEvent(event as EventMessagePartUpdated, api, mux, deps);
           continue;
         }
 
@@ -447,4 +583,6 @@ export function stopGlobalEventListenerWithDeps(deps: EventFlowDeps) {
   deps.chatAwaitingSaveFile.clear();
   deps.chatMaxFileSizeMb.clear();
   deps.chatMaxFileRetry.clear();
+  
+  clearAllPendingQuestions(deps);
 }

src/handler/incoming.flow.ts

@@ -6,6 +6,13 @@ import { ERROR_HEADER, parseSlashCommand, globalState } from '../utils';
 import { bridgeLogger } from '../logger';
 import { handleSlashCommand } from './command';
 import type { AdapterMux } from './mux';
+import {
+  buildResumePrompt,
+  parseUserReply,
+  renderAnswerSummary,
+  renderReplyHint,
+} from './question.proxy';
+import type { PendingQuestionState } from './question.proxy';
 
 type SessionContext = { chatId: string; senderId: string };
 type SelectedModel = { providerID: string; modelID: string; name?: string };
@@ -68,6 +75,9 @@ export type IncomingFlowDeps = {
   chatAwaitingSaveFile: Map<string, boolean>;
   chatMaxFileSizeMb: Map<string, number>;
   chatMaxFileRetry: Map<string, number>;
+  chatPendingQuestion: Map<string, PendingQuestionState>;
+  clearPendingQuestionForChat: (cacheKey: string) => void;
+  clearAllPendingQuestions: () => void;
   formatUserError: (err: unknown) => string;
 };
 
@@ -92,6 +102,7 @@ export const createIncomingHandlerWithDeps = (
     );
 
     const slash = parseSlashCommand(text);
+    const hasText = Boolean(text && text.trim());
     const cacheKey = `${adapterKey}:${chatId}`;
     const rawCommand = slash?.command?.toLowerCase();
     const normalizedCommand = normalizeSlashCommand(rawCommand);
@@ -203,6 +214,8 @@ export const createIncomingHandlerWithDeps = (
           chatAwaitingSaveFile: deps.chatAwaitingSaveFile,
           chatMaxFileSizeMb: deps.chatMaxFileSizeMb,
           chatMaxFileRetry: deps.chatMaxFileRetry,
+          clearPendingQuestionForChat: deps.clearPendingQuestionForChat,
+          clearAllPendingQuestions: deps.clearAllPendingQuestions,
           ensureSession,
           createNewSession,
           sendCommandMessage,
@@ -214,8 +227,40 @@ export const createIncomingHandlerWithDeps = (
         if (handled) return;
       }
 
+      const pendingQuestion = deps.chatPendingQuestion.get(cacheKey);
+      if (pendingQuestion && !slash) {
+        if (!hasText) {
+          await adapter.sendMessage(chatId, renderReplyHint(pendingQuestion));
+          return;
+        }
+
+        const resolved = parseUserReply(text, pendingQuestion);
+        if (!resolved.ok) {
+          await adapter.sendMessage(chatId, renderReplyHint(pendingQuestion));
+          return;
+        }
+
+        deps.clearPendingQuestionForChat(cacheKey);
+        await adapter.sendMessage(chatId, renderAnswerSummary(pendingQuestion, resolved.answers, 'user'));
+
+        const sessionId = await ensureSession();
+        deps.sessionToAdapterKey.set(sessionId, adapterKey);
+        deps.sessionToCtx.set(sessionId, { chatId, senderId });
+
+        const agent = deps.chatAgent.get(cacheKey);
+        const model = deps.chatModel.get(cacheKey);
+        await api.session.prompt({
+          path: { id: sessionId },
+          body: {
+            parts: [{ type: 'text', text: buildResumePrompt(pendingQuestion, resolved.answers, 'user') }],
+            ...(agent ? { agent } : {}),
+            ...(model ? { model: { providerID: model.providerID, modelID: model.modelID } } : {}),
+          },
+        });
+        return;
+      }
+
       const fileParts = (parts || []).filter(isFilePartInput);
-      const hasText = Boolean(text && text.trim());
 
       if (fileParts.length > 0) {
         const isSaveFileMode = deps.chatAwaitingSaveFile.get(cacheKey) === true;