tavern-harness 0.1.0

package/src/store/store.ts

@@ -0,0 +1,2419 @@
+import { create } from 'zustand';
+import { db } from '../db/database';
+import {
+  type ApiProvider,
+  type AppSettings,
+  type ProviderModelOption,
+  enabledModelIds,
+  modelAliases,
+  ChatMessage,
+  ChatParticipant,
+  ChatSession,
+  ContextCompression,
+  ToolConfirmationRequest,
+  WorldBook,
+  NpcCharacter,
+  McpTool,
+} from '../types/models';
+import { streamChatCompletions, buildChatRequest, summarizeContext } from '../core/openai';
+import {
+  buildGroupSystemPrompt,
+  buildNetworkMessagesForSession,
+  buildNpcSystemPrompt,
+  STANDARD_SYSTEM_PROMPT,
+} from '../core/prompts';
+import {
+  completeTurn,
+  initializeTurnQueue,
+  mentionedParticipantIds,
+  parseMagicCommand,
+  passPlayer,
+  queueHistoryJson,
+  queueJson,
+  refreshQueue,
+  requeueSpeaker,
+  safeParseQueue,
+  safeParseQueueHistory,
+} from '../core/turnLoop';
+import type { ChatCompletionRequest, SessionMode, TurnOrderMode } from '../types/models';
+import {
+  MAX_CONSECUTIVE_TOOL_FAILURES,
+  MAX_IDENTICAL_TOOL_CALLS,
+  MAX_TOOL_CALL_DEPTH,
+  MAX_TOOL_CALLS_PER_TURN,
+  NEW_TOPIC_MARKER,
+} from '../core/toolDefinitions';
+import { getEnabledToolsForSession, executeToolCall, parseDisplayRef, applySessionWorkspace } from '../core/tools/toolExecutor';
+import { createSessionWorkspaceDir, ensureSessionWorkspaceDir, deleteSessionWorkspace, isCurrentInstanceWorkspaceDir } from '../core/tools/generatedSkillExecutor';
+import { applyTheme as applyThemeManual, cacheThemeMode, watchSystemTheme } from '../theme/theme';
+import { setLanguage, translate } from '../core/i18n';
+import { trimEdgeNewlines } from '../core/strings';
+import {
+  isBuiltinTavernHandbook,
+  isTavernKeeper,
+  localizeBuiltinNpc,
+  localizeBuiltinTavernHandbook,
+} from '../db/database';
+import { estimateTokensFromChars, accumulateStats, sessionPreviewText } from '../core/stats';
+import { seedOpeningGreeting } from '../core/openingGreeting';
+import { ACHIEVEMENTS, type AchievementDef } from '../core/achievements';
+
+// ============================================================
+// Store（对应 MainViewModel）
+// ============================================================
+
+export type ActiveView = 'chat' | 'characters' | 'settings' | 'stats' | 'achievements';
+
+interface StreamingState {
+  sessionId: number | null;
+  abort: AbortController | null;
+}
+
+interface Toast {
+  id: number;
+  message: string;
+  kind: 'info' | 'error';
+}
+
+export interface AchievementState {
+  def: AchievementDef;
+  unlockedAt: number | null;
+}
+
+/** 展示类工具（file_display）当前打开的弹窗载荷 */
+export interface ActiveDisplay {
+  path: string;
+  kind: 'text' | 'image' | 'html';
+  title?: string;
+  /** 产生该展示的会话 id（读取文件时按其专属工作目录解析，null = 共享工作区） */
+  sessionId: number | null;
+  /** 初始展示方式；文件管理器使用大弹窗，file_display 默认使用小窗 */
+  presentation?: 'pip' | 'modal';
+}
+
+interface AppState {
+  initialized: boolean;
+  settings: AppSettings | null;
+  providers: ApiProvider[];
+  npcs: NpcCharacter[];
+  sessions: ChatSession[];
+  worldBooks: WorldBook[];
+  tools: McpTool[];
+  messages: Record<number, ChatMessage[]>;
+  contextCompressions: Record<number, ContextCompression[]>;
+  participants: Record<number, ChatParticipant[]>;
+  achievements: AchievementState[];
+  /** 生涯总 token（输入 + 输出），实时刷新用于成就进度展示 */
+  careerTotalTokens: number | null;
+
+  activeSessionId: number | null;
+  activeView: ActiveView;
+
+  streaming: StreamingState;
+  /** 正在生成或生成结束后尚未进入查看的会话 */
+  activitySessionIds: Record<number, true>;
+  pendingConfirmation: ToolConfirmationRequest | null;
+
+  /** 当前打开的展示弹窗（file_display），null = 无 */
+  activeDisplay: ActiveDisplay | null;
+  /** 打开 / 关闭展示弹窗 */
+  setActiveDisplay: (d: ActiveDisplay | null) => void;
+
+  /** 群聊实时队列快照（与 DB 同步更新，面板订阅此值实现实时指示） */
+  liveQueueBySession: Record<number, {
+    /** 当前循环剩余队列（队首 = 正在发言/下一发言者） */
+    queue: string[];
+    /** 各循环完整初始顺序历史（含当前循环） */
+    history: string[][];
+    loopIndex: number;
+    turnOrderMode: TurnOrderMode;
+  }>;
+
+  toasts: Toast[];
+
+  init: () => Promise<void>;
+  setSettings: (partial: Partial<AppSettings>) => Promise<void>;
+  /** 删除当前浏览器源上的酒馆数据并重新载入初始状态。 */
+  resetTavern: () => Promise<void>;
+  setActiveSession: (id: number | null) => void;
+  setActiveView: (v: ActiveView) => void;
+
+  sendMessage: (text: string, attachments?: string[], attachmentNames?: string[]) => Promise<void>;
+  /** 重新生成指定消息（右键菜单：右键哪条就重生成哪条）。删除该消息及之后的 tool 消息后重跑 */
+  regenerateMessage: (messageId: number) => Promise<void>;
+  editMessage: (messageId: number, newContent: string, sessionId: number, newAttachments?: string[], newAttachmentNames?: string[]) => Promise<void>;
+  saveMessageOnly: (messageId: number, newContent: string, sessionId: number, newAttachments?: string[], newAttachmentNames?: string[]) => Promise<void>;
+  stopStreaming: () => void;
+  deleteSession: (id: number) => Promise<void>;
+  /** 切换会话置顶状态（置顶会话排列表最前，可跨会话固定） */
+  togglePin: (id: number) => Promise<void>;
+  /** 从指定消息分叉（Fork）：复制该消息及之前的内容到新会话并跳转过去。返回新会话 id */
+  forkSession: (messageId: number) => Promise<number | null>;
+  updateSessionSettings: (sessionId: number, opts: {
+    title?: string;
+    npcIds: number[];
+    worldBookId?: number | null;
+    userPersonaNpcId?: number | null;
+    turnOrderMode?: TurnOrderMode;
+    participantOrder?: number[];
+    enableGreeting?: boolean;
+    mentionOnlyMode?: boolean;
+  }) => Promise<void>;
+  resetSessionConversation: (sessionId: number) => Promise<void>;
+  resolveConfirmation: (approved: boolean) => void;
+  /** 用 DB 最新数据刷新某会话的队列快照（面板实时源） */
+  refreshLiveQueue: (sessionId: number) => Promise<void>;
+  /** 清除某会话的队列快照（会话删除时） */
+  clearLiveQueue: (sessionId: number) => void;
+
+  refreshSessions: () => Promise<void>;
+  refreshNpcs: () => Promise<void>;
+  refreshWorldBooks: () => Promise<void>;
+  refreshTools: () => Promise<void>;
+  refreshProviders: () => Promise<void>;
+  refreshAchievements: () => Promise<void>;
+  loadMessages: (sessionId: number) => Promise<void>;
+  /** 重新加载当前活动会话的参与者（语言切换后刷新内置角色显示名） */
+  refreshParticipants: () => Promise<void>;
+
+  /** 聚合所有启用 Provider 的模型列表，每个 Provider 的条目独立保留。 */
+  modelsList: ProviderModelOption[];
+  refreshModelsList: () => Promise<void>;
+  selectModel: (option: ProviderModelOption) => Promise<void>;
+
+  addToast: (message: string, kind?: 'info' | 'error') => void;
+  removeToast: (id: number) => void;
+}
+
+let toastSeq = 0;
+let initLock: Promise<void> | null = null;
+/** 用户主动停止生成时置位，用于中断群聊循环 */
+let groupLoopStopped = false;
+const contextCompressionJobs = new Map<number, Promise<void>>();
+const contextCompressionControllers = new Map<number, AbortController>();
+const contextCompressionRevisions = new Map<number, number>();
+const queuedContextCompressionSessions = new Set<number>();
+
+function invalidateContextCompressionJob(sessionId: number): void {
+  contextCompressionRevisions.set(sessionId, (contextCompressionRevisions.get(sessionId) ?? 0) + 1);
+  contextCompressionControllers.get(sessionId)?.abort();
+  queuedContextCompressionSessions.delete(sessionId);
+}
+
+async function waitForContextCompressionIdle(sessionId: number): Promise<void> {
+  while (true) {
+    const job = contextCompressionJobs.get(sessionId);
+    if (!job) return;
+    await job;
+  }
+}
+
+async function deleteContextCompressionsFrom(sessionId: number, timestamp: number): Promise<void> {
+  invalidateContextCompressionJob(sessionId);
+  const affected = await db.contextCompressions
+    .where('sessionId').equals(sessionId)
+    .filter((compression) => compression.endTimestamp >= timestamp)
+    .toArray();
+  if (affected.length > 0) {
+    await db.contextCompressions.bulkDelete(affected.map((compression) => compression.id!));
+  }
+}
+
+/** 会话排序：置顶在前、其余在后，组内按 updatedAt 倒序（最新在前） */
+function sortSessionsPinnedFirst(sessions: ChatSession[]): ChatSession[] {
+  const sorted = [...sessions].sort((a, b) => b.updatedAt - a.updatedAt);
+  const pinned = sorted.filter((s) => (s as { pinned?: unknown }).pinned);
+  const rest = sorted.filter((s) => !(s as { pinned?: unknown }).pinned);
+  return [...pinned, ...rest];
+}
+
+function sortWorldBooks(worldBooks: WorldBook[]): WorldBook[] {
+  return [...worldBooks].sort((a, b) => Number(Boolean(b.isBuiltIn)) - Number(Boolean(a.isBuiltIn)) || a.createdAt - b.createdAt);
+}
+
+function sortNpcs(npcs: NpcCharacter[]): NpcCharacter[] {
+  return [...npcs].sort((a, b) => Number(b.isBuiltIn) - Number(a.isBuiltIn) || a.createdAt - b.createdAt);
+}
+
+/** 单回合生成结果：ok 成功 / failed 失败（应回退） / stopped 用户主动停止（不回退） */
+type TurnResult = 'ok' | 'failed' | 'stopped';
+
+export const useStore = create<AppState>((set, get) => ({
+  initialized: false,
+  settings: null,
+  providers: [],
+  npcs: [],
+  sessions: [],
+  worldBooks: [],
+  tools: [],
+  messages: {},
+  contextCompressions: {},
+  participants: {},
+  achievements: [],
+  careerTotalTokens: null,
+
+  activeSessionId: null,
+  activeView: 'chat',
+  modelsList: [],
+
+  streaming: { sessionId: null, abort: null },
+  activitySessionIds: {},
+  pendingConfirmation: null,
+  activeDisplay: null,
+
+  liveQueueBySession: {},
+
+  toasts: [],
+
+  init: async () => {
+    // StrictMode 双调用保护
+    if (initLock) return initLock;
+    initLock = (async () => {
+      const settings = (await db.settings.get(1))!;
+      setLanguage(settings.language ?? null);
+      // 内置角色与世界书按当前语言本地化。
+      await localizeBuiltinNpc();
+      await localizeBuiltinTavernHandbook();
+      const npcs = sortNpcs(await db.npcs.toArray());
+      const sessions = sortSessionsPinnedFirst(await db.sessions.toArray());
+      const worldBooks = sortWorldBooks(await db.worldBooks.toArray());
+      const tools = [...(await db.tools.toArray())].sort((a, b) => (a.displayOrder ?? 0) - (b.displayOrder ?? 0));
+      set({ initialized: true, settings, npcs, sessions, worldBooks, tools });
+      await get().refreshProviders();
+      cacheThemeMode(settings.themeMode);
+      applyThemeManual(settings.themeMode);
+      // 跟随系统模式下，系统切换深浅色时自动重新应用主题
+      watchSystemTheme(() => {
+        const s = useStore.getState().settings;
+        if (s) applyThemeManual(s.themeMode);
+      });
+      await get().refreshAchievements();
+      // 每次刷新固定回到开始页，会话仅在用户主动选择后加载。
+      set({ activeSessionId: null, activeView: 'chat' });
+    })();
+    return initLock;
+  },
+
+  setSettings: async (partial) => {
+    const current = get().settings;
+    if (!current) return;
+    const next = { ...current, ...partial };
+    await db.settings.put(next);
+    set({ settings: next });
+    if (partial.language !== undefined) {
+      setLanguage(next.language ?? null);
+      // 切换语言后：内置角色与世界书文本一并本地化并刷新。
+      await localizeBuiltinNpc();
+      await localizeBuiltinTavernHandbook();
+      await get().refreshNpcs();
+      await get().refreshWorldBooks();
+      await get().refreshSessions();
+      await get().refreshParticipants();
+    }
+    cacheThemeMode(next.themeMode);
+    applyThemeManual(next.themeMode);
+  },
+
+  resetTavern: async () => {
+    const streaming = get().streaming;
+    if (streaming.abort) {
+      groupLoopStopped = true;
+      streaming.abort.abort();
+    }
+    for (const session of await db.sessions.toArray()) {
+      invalidateContextCompressionJob(session.id!);
+      if (isCurrentInstanceWorkspaceDir(session.workspaceDir)) await deleteSessionWorkspace(session.workspaceDir);
+    }
+    confirmationDeferreds.forEach(({ resolve }) => resolve(false));
+    confirmationDeferreds.clear();
+    await db.delete();
+    localStorage.removeItem('tav-theme-mode');
+    localStorage.removeItem('th-builtin-npc-lang');
+    localStorage.removeItem('th-workspace-scope');
+    window.location.reload();
+  },
+
+  setActiveSession: (id) => {
+    set((state) => {
+      if (id == null || !state.activitySessionIds[id]) {
+        return { activeSessionId: id, activeView: 'chat' };
+      }
+      const activitySessionIds = { ...state.activitySessionIds };
+      delete activitySessionIds[id];
+      return { activeSessionId: id, activeView: 'chat', activitySessionIds };
+    });
+    if (id != null) {
+      get().loadMessages(id);
+      get().refreshLiveQueue(id);
+    }
+  },
+
+  setActiveView: (v) => set((state) => {
+    const sessionId = state.activeSessionId;
+    if (v !== 'chat' || sessionId == null || !state.activitySessionIds[sessionId]) {
+      return { activeView: v };
+    }
+    const activitySessionIds = { ...state.activitySessionIds };
+    delete activitySessionIds[sessionId];
+    return { activeView: v, activitySessionIds };
+  }),
+
+  refreshSessions: async () => {
+    // 置顶会话排最前（各自按 updatedAt 倒序），其次为普通会话（同样按 updatedAt 倒序）
+    set({ sessions: sortSessionsPinnedFirst(await db.sessions.toArray()) });
+  },
+
+  refreshNpcs: async () => {
+    set({ npcs: sortNpcs(await db.npcs.toArray()) });
+  },
+
+  refreshWorldBooks: async () => {
+    set({ worldBooks: sortWorldBooks(await db.worldBooks.toArray()) });
+  },
+
+  refreshTools: async () => {
+    // 按 displayOrder 排序：技能表拖拽调整的顺序跨刷新保持
+    const tools = [...(await db.tools.toArray())].sort((a, b) => (a.displayOrder ?? 0) - (b.displayOrder ?? 0));
+    set({ tools });
+  },
+
+  refreshAchievements: async () => {
+    const unlocked = await db.achievementUnlocks.toArray();
+    const byId = new Map(unlocked.map((u) => [u.achievementId, u.unlockedAt]));
+    set({
+      achievements: ACHIEVEMENTS.map((def) => ({
+        def,
+        unlockedAt: byId.get(def.id) ?? null,
+      })),
+    });
+    const stats = (await db.careerStats.get(1)) ?? { id: 1, inputTokens: 0, outputTokens: 0, totalRounds: 0 };
+    set({ careerTotalTokens: stats.inputTokens + stats.outputTokens });
+  },
+
+  refreshProviders: async () => {
+    const providers = await db.providers.toArray();
+    set({ providers });
+    // 同步聚合模型列表
+    const models = aggregateEnabledProviderModels(providers);
+    set({ modelsList: models });
+    // 若当前默认模型不在列表、但列表非空，自动取第一个
+    const current = get().settings;
+    if (current) {
+      const enabledProviders = providers.filter((p) => p.isEnabled && p.baseUrl.trim());
+      const next: Partial<AppSettings> = {};
+      // 唯一启用 Provider 时自动设为默认
+      if (enabledProviders.length === 1 && current.defaultProviderId !== enabledProviders[0].id) {
+        next.defaultProviderId = enabledProviders[0].id ?? null;
+      }
+      const selected = current.defaultModel.trim();
+      const selectedProviderId = current.defaultProviderId;
+      if (!models.some((option) => option.providerId === selectedProviderId && option.modelId === selected) && models.length > 0) {
+        next.defaultModel = models[0].modelId;
+        next.defaultProviderId = models[0].providerId;
+      }
+      if (Object.keys(next).length > 0) {
+        const updated = { ...current, ...next };
+        await db.settings.put(updated);
+        set({ settings: updated });
+      }
+    }
+  },
+
+  refreshModelsList: async () => {
+    const providers = await db.providers.toArray();
+    set({ modelsList: aggregateEnabledProviderModels(providers) });
+  },
+
+  selectModel: async (option) => {
+    const current = get().settings;
+    if (!current) return;
+    const provider = await db.providers.get(option.providerId);
+    if (!provider || !isEnabledProviderModel(provider, option.modelId)) return;
+    const next = { ...current, defaultModel: option.modelId, defaultProviderId: option.providerId };
+    await db.settings.put(next);
+    set({ settings: next });
+  },
+
+  loadMessages: async (sessionId) => {
+    const messages = await db.messages.where('sessionId').equals(sessionId).sortBy('timestamp');
+    const compressions = await db.contextCompressions.where('sessionId').equals(sessionId).sortBy('createdAt');
+    const participants = await db.participants.where('sessionId').equals(sessionId).toArray();
+    set((s) => {
+      // 流式过程中 publishDraft 已把最新内容写入内存与 DB；重新加载时以 DB 记录为基准、
+      // 叠加内存中的流式字段（content / thinkingContent / toolCallsJson），避免文本回跳。
+      // 这样 DB 里已落库的 raw 字段（生成完成后才写入）不会被内存中的旧草稿对象覆盖，
+      // —— 否则右键「查看原始日志」要等刷新页面（streaming 清空后从 DB 重载）才会出现。
+      const loadedMessages = s.streaming.sessionId === sessionId
+        ? messages.map((message) => {
+            const current = s.messages[sessionId]?.find((c) => c.id === message.id);
+            if (!current) return message;
+            return {
+              ...message,
+              content: current.content,
+              thinkingContent: current.thinkingContent,
+              toolCallsJson: current.toolCallsJson,
+            };
+          })
+        : messages;
+      return {
+        messages: { ...s.messages, [sessionId]: loadedMessages },
+        contextCompressions: { ...s.contextCompressions, [sessionId]: compressions },
+        participants: { ...s.participants, [sessionId]: participants },
+      };
+    });
+  },
+
+  /** 重新加载当前活动会话的参与者列表（语言切换本地化内置角色后调用） */
+  refreshParticipants: async () => {
+    const sessionId = get().activeSessionId;
+    if (sessionId == null) return;
+    await get().loadMessages(sessionId);
+  },
+
+  sendMessage: async (text, attachments = [], attachmentNames = []) => {
+    const sessionId = get().activeSessionId;
+    if (sessionId == null) return;
+    const session = await db.sessions.get(sessionId);
+    if (!session) return;
+    if (get().streaming.sessionId != null) {
+      get().addToast(translate('toast.busy'), 'error');
+      return;
+    }
+    if (session.mode === 'GROUP' && session.mentionOnlyMode) {
+      const participants = await db.participants.where('sessionId').equals(sessionId).toArray();
+      if (mentionedParticipantIds(text, participants, -1).length === 0) {
+        get().addToast(translate('toast.mentionRequired'), 'error');
+        return;
+      }
+    }
+
+    // 魔法命令（有附件时不生效）
+    const cmd = parseMagicCommand(text, attachments.length > 0);
+    if (cmd) {
+      await handleMagicCommand(session, cmd.text);
+      await get().refreshSessions();
+      return;
+    }
+
+    // 保存用户消息（若在群聊中轮到玩家，同时将其移出队列）
+    const attachInfos = attachments.map((_, i) => ({
+      displayName: attachmentNames[i]?.trim() || translate('common.attachment'),
+    }));
+    const userMsg: ChatMessage = {
+      sessionId,
+      role: 'user',
+      speakerParticipantId: null,
+      speakerName: null,
+      content: text,
+      toolCallsJson: '[]',
+      toolCallId: null,
+      thinkingContent: null,
+      // 群聊：用户发言归属于当前循环（用于对话↔队列联动滚动定位）
+      loopIndex: session.mode === 'GROUP' ? currentLoopIndexOf(session) : null,
+      timestamp: Date.now(),
+      latencyMs: null,
+      promptTokens: 0,
+      completionTokens: 0,
+      totalTokens: 0,
+      tokensPerSec: null,
+      modelUsed: null,
+      attachments,
+      attachmentInfos: attachInfos,
+      displayRef: null,
+      rawRequestBody: null,
+      rawResponseBody: null,
+    };
+    await db.messages.add(userMsg);
+    await db.sessions.update(sessionId, { updatedAt: Date.now(), lastMessage: sessionPreviewText(text) });
+    await get().loadMessages(sessionId);
+    await get().refreshSessions();
+
+    if (session.mode === 'GROUP') {
+      // 群聊：玩家始终是队列正式成员（默认队首）。轮到玩家时输入 → 将玩家移出队列，
+      // 其余成员继续发言；@点名也能让目标优先/立即发言。
+      const participants = await db.participants.where('sessionId').equals(sessionId).toArray();
+      const fresh = (await db.sessions.get(sessionId)) ?? session;
+      const { queue, loopIndex, loopStarted } = refreshQueue(fresh, participants);
+      const player = participants.find((p) => p.kind === 'PLAYER') ?? { participantId: -1 } as ChatParticipant;
+      const playerId = player.participantId.toString();
+      const isPlayerQueued = queue.includes(playerId);
+      const next = isPlayerQueued
+        ? completeTurn(queue, player.participantId, mentionedParticipantIds(text, participants, player.participantId))
+        : queue;
+      // 边界时 queue 为全新完整顺序 → persistQueue 会把它追加进循环历史
+      await persistQueue(sessionId, next, loopIndex, loopStarted);
+      await get().refreshLiveQueue(sessionId);
+      await continueGroupConversation(sessionId);
+      return;
+    }
+
+    await runConversationLoop(session);
+  },
+
+  regenerateMessage: async (messageId) => {
+    const message = await db.messages.get(messageId);
+    if (!message) return;
+    const sessionId = message.sessionId;
+    const session = await db.sessions.get(sessionId);
+    if (!session) return;
+    if (get().streaming.sessionId != null) return;
+
+    // ---- 生成前快照：完整保留删除前的消息与队列状态，生成失败时整体回退 ----
+    const snapshotMessages = await db.messages.where('sessionId').equals(sessionId).sortBy('timestamp');
+    const snapshotCompressions = await db.contextCompressions.where('sessionId').equals(sessionId).toArray();
+    const snapshotSessionFields = {
+      turnQueueJson: session.turnQueueJson,
+      turnQueueHistoryJson: session.turnQueueHistoryJson,
+      loopIndex: session.loopIndex,
+      lastMessage: session.lastMessage,
+      updatedAt: session.updatedAt,
+    };
+
+    // 以目标消息的时间戳为切断点：删除它及之后的所有消息（通常为其附属 tool 结果），
+    // 随后重新生成该条回复（重新生成 = 旧回复连同后续内容一起被新回复替换）
+    const messages = snapshotMessages;
+    const toDelete = messages.filter((m) => m.timestamp >= message.timestamp);
+    await deleteContextCompressionsFrom(sessionId, message.timestamp);
+    await db.messages.bulkDelete(toDelete.map((m) => m.id!));
+    await get().loadMessages(sessionId);
+
+    // 会话预览回退到删除后最后一条可见消息；空则置空
+    const remaining = await db.messages.where('sessionId').equals(sessionId).sortBy('timestamp');
+    const lastVisible = [...remaining].reverse().find((m) => m.role !== 'tool');
+    await db.sessions.update(sessionId, {
+      updatedAt: Date.now(),
+      lastMessage: lastVisible ? sessionPreviewText(lastVisible.content) || '…' : '',
+    });
+
+    let result: TurnResult;
+    if (session.mode === 'GROUP') {
+      // 群聊：把被重生成 assistant 的发言人重新置顶（联动发言队列）。
+      // 若该条发言是当前循环某位成员（未知 speakerParticipantId，如收尾回复），
+      // 无法映射到具体成员，则直接按当前队列继续。
+      const participant = message.speakerParticipantId != null
+        ? (await db.participants
+            .where('sessionId').equals(sessionId)
+            .filter((p) => p.participantId === message.speakerParticipantId)
+            .first()) ?? null
+        : null;
+      result = await continueRegeneratedGroupLoop(session, message, participant);
+    } else {
+      result = await runConversationLoop(session);
+    }
+
+    if (result === 'failed') {
+      // 生成失败（网络 / 超时 / 空回复等）→ 回退到原先的状态：
+      // 恢复全部消息（含被删除的旧回复及其工具结果）与会话队列 / 预览。
+      await db.transaction('rw', db.messages, db.contextCompressions, async () => {
+        await db.messages.where('sessionId').equals(sessionId).delete();
+        await db.messages.bulkPut(snapshotMessages);
+        await db.contextCompressions.where('sessionId').equals(sessionId).delete();
+        if (snapshotCompressions.length > 0) await db.contextCompressions.bulkPut(snapshotCompressions);
+      });
+      await db.sessions.update(sessionId, snapshotSessionFields);
+      await get().loadMessages(sessionId);
+    }
+    await get().refreshSessions();
+    await get().refreshLiveQueue(sessionId);
+  },
+
+  editMessage: async (messageId, newContent, sessionId, newAttachments?: string[], newAttachmentNames?: string[]) => {
+    if (get().streaming.sessionId != null) return;
+    const message = await db.messages.get(messageId);
+    if (!message) return;
+    // 编辑该消息，删除它之后的所有消息（不含自身）
+    const messages = await db.messages.where('sessionId').equals(sessionId).sortBy('timestamp');
+    const toDelete = messages.filter(
+      (m) => m.timestamp > message.timestamp || (m.timestamp === message.timestamp && m.id !== messageId)
+    );
+    await deleteContextCompressionsFrom(sessionId, message.timestamp);
+    await db.messages.bulkDelete(toDelete.map((m) => m.id!));
+    const attachments = newAttachments ?? message.attachments;
+    const attachmentInfos = (newAttachments != null ? newAttachments : message.attachments).map((_, i) => ({
+      displayName: (newAttachmentNames?.[i]?.trim()) || message.attachmentInfos?.[i]?.displayName || translate('common.attachment'),
+    }));
+    await db.messages.update(messageId, { content: newContent, attachments, attachmentInfos });
+    await get().loadMessages(sessionId);
+
+    const session = await db.sessions.get(sessionId);
+    if (!session) return;
+    if (session.mode === 'GROUP' && message.role === 'assistant') {
+      // 群聊中编辑的是 NPC 的发言 → 重新生成该发言者的回复，
+      // 并把该发言人重新置顶队列（联动发言队列：它还没轮完一轮时优先补发）。
+      const participant =
+        message.speakerParticipantId != null
+          ? (await db.participants
+              .where('sessionId')
+              .equals(sessionId)
+              .filter((p) => p.participantId === message.speakerParticipantId)
+              .first()) ?? null
+          : null;
+      await continueRegeneratedGroupLoop(session, message, participant);
+      await get().refreshSessions();
+      return;
+    }
+    if (session.mode === 'GROUP' && message.role === 'user') {
+      // 群聊中编辑的是玩家消息 → 发言队列回退到该消息所属「循环与轮次」：
+      // 1) 用循环历史里该轮的完整初始顺序重建队列（移除玩家 + 该轮玩家之前已发言者，
+      //    后者仅在 RANDOM 模式玩家非队首时可能出现）
+      // 2) 循环历史与 loopIndex 截断回退到该轮
+      // 3) 应用编辑文本中的 @点名 → 进入群聊主循环重新生成
+      const participants = await db.participants.where('sessionId').equals(sessionId).toArray();
+      const fresh = (await db.sessions.get(sessionId)) ?? session;
+      const player = participants.find((p) => p.kind === 'PLAYER') ?? null;
+      const playerId = player?.participantId ?? -1;
+      const targetLoop = message.loopIndex ?? 0;
+      const history = safeParseQueueHistory(fresh.turnQueueHistoryJson || '[]');
+      const curQueue = safeParseQueue(fresh.turnQueueJson);
+      const loopOrder =
+        history[targetLoop] ??
+        (curQueue.length > 0 ? curQueue : initializeTurnQueue(participants, fresh.turnOrderMode));
+      // 该轮中玩家发言之前已发言的 NPC（其消息未被删除 → 不重讲）
+      const spokenBeforePlayer = new Set(
+        messages
+          .filter(
+            (m) => m.role === 'assistant' && m.loopIndex === targetLoop && m.timestamp < message.timestamp && m.speakerParticipantId != null
+          )
+          .map((m) => m.speakerParticipantId as number)
+      );
+      // 重建该轮：移除玩家、被 @ 点名者置顶 → 再剔除玩家之前已发言的 NPC
+      let rolledQueue = completeTurn(loopOrder, playerId, mentionedParticipantIds(newContent, participants, playerId));
+      rolledQueue = rolledQueue.filter((id) => !spokenBeforePlayer.has(parseInt(id, 10)));
+      await db.sessions.update(sessionId, {
+        turnQueueJson: queueJson(rolledQueue),
+        loopIndex: targetLoop,
+        turnQueueHistoryJson: queueHistoryJson(history.slice(0, targetLoop + 1)),
+      });
+      await get().refreshLiveQueue(sessionId);
+      await continueGroupConversation(sessionId);
+      await get().refreshSessions();
+      return;
+    }
+
+    await runConversationLoop(session);
+    await get().refreshSessions();
+  },
+
+  saveMessageOnly: async (messageId, newContent, sessionId, newAttachments?: string[], newAttachmentNames?: string[]) => {
+    if (get().streaming.sessionId != null) return;
+    const message = await db.messages.get(messageId);
+    if (!message) return;
+    const attachments = newAttachments ?? message.attachments;
+    const attachmentInfos = (newAttachments != null ? newAttachments : message.attachments).map((_, i) => ({
+      displayName: (newAttachmentNames?.[i]?.trim()) || message.attachmentInfos?.[i]?.displayName || translate('common.attachment'),
+    }));
+    // 仅修改本条消息内容，不删除任何后续消息、不触发重新生成
+    await deleteContextCompressionsFrom(sessionId, message.timestamp);
+    await db.messages.update(messageId, { content: newContent, attachments, attachmentInfos });
+    await get().loadMessages(sessionId);
+    await get().refreshSessions();
+  },
+
+  stopStreaming: () => {
+    const abort = get().streaming.abort;
+    if (abort) {
+      groupLoopStopped = true;
+      abort.abort();
+    }
+  },
+
+  deleteSession: async (id) => {
+    // 先取会话记录（工作目录在删除后不可查），再清理目录与数据
+    const session = await db.sessions.get(id);
+    invalidateContextCompressionJob(id);
+    await db.messages.where('sessionId').equals(id).delete();
+    await db.contextCompressions.where('sessionId').equals(id).delete();
+    await db.participants.where('sessionId').equals(id).delete();
+    await db.sessions.delete(id);
+    // 删除会话的专属磁盘工作目录；沙箱不可用时静默跳过
+    if (session?.workspaceDir) {
+      await deleteSessionWorkspace(session.workspaceDir);
+    }
+    set((state) => {
+      const activitySessionIds = { ...state.activitySessionIds };
+      delete activitySessionIds[id];
+      return state.activeSessionId === id
+        ? { activeSessionId: null, activitySessionIds }
+        : { activitySessionIds };
+    });
+    get().clearLiveQueue(id);
+    await get().refreshSessions();
+  },
+
+  togglePin: async (id) => {
+    const session = await db.sessions.get(id);
+    if (!session) return;
+    const pinned = (session as { pinned?: unknown }).pinned ? 0 : 1;
+    await db.sessions.update(id, { pinned });
+    await get().refreshSessions();
+  },
+
+  /** 从指定消息分叉：复制会话与该消息之前（含）的消息到新会话，并跳转过去 */
+  forkSession: async (messageId: number) => {
+    const message = await db.messages.get(messageId);
+    if (!message) return null;
+    const sessionId = message.sessionId;
+    await waitForContextCompressionIdle(sessionId);
+    const session = await db.sessions.get(sessionId);
+    if (!session) return null;
+    const [allMessages, sourceCompressions] = await db.transaction(
+      'r',
+      db.messages,
+      db.contextCompressions,
+      async () => Promise.all([
+        db.messages.where('sessionId').equals(sessionId).sortBy('timestamp'),
+        db.contextCompressions.where('sessionId').equals(sessionId).sortBy('createdAt'),
+      ]),
+    );
+    const snapshotMessage = allMessages.find((candidate) => candidate.id === messageId);
+    if (!snapshotMessage) return null;
+
+    // 复制会话（保留模式 / 角色 / 世界书 / 人设 / 队列设置；置顶与顺序“未置顶”）
+    // 新 Fork 会话分配当前酒馆实例专属的独立工作目录，与原会话互不影响
+    const now = Date.now();
+    const newSession: ChatSession = {
+      ...session,
+      id: undefined,
+      title: `${session.title} #fork`,
+      turnQueueJson: '[]',
+      turnQueueHistoryJson: '[]',
+      loopIndex: 0,
+      pinned: 0,
+      lastMessage: '',
+      updatedAt: now,
+      createdAt: now,
+    };
+    const newId = await db.sessions.add(newSession);
+    const workspaceDir = createSessionWorkspaceDir(newId);
+    await db.sessions.update(newId, { workspaceDir });
+    // 创建对话的同时预建其专属工作目录（会话间隔离，Fork 后互不影响）
+    await ensureSessionWorkspaceDir(workspaceDir);
+
+    // 复制参与者（PLAYER 保留 -1 编号，NPC 按 npcId 映射；重建 seatOrder 保持一致）
+    const participants = await db.participants.where('sessionId').equals(sessionId).sortBy('seatOrder');
+    const mappedParticipants = participants.map((p, i) => ({
+      sessionId: newId,
+      participantId: p.participantId,
+      kind: p.kind,
+      npcId: p.npcId,
+      displayName: p.displayName,
+      seatOrder: i,
+    }));
+    await db.participants.bulkAdd(mappedParticipants);
+
+    // 复制消息：取该消息及之前的全部消息（按时间戳顺序）
+    // 消息 id 不可复用（自增），重新按时间顺序写库，保持展示顺序一致。
+    // 若分叉点在带工具调用的 assistant 消息上，其 tool 结果消息的时间戳晚于分叉点，
+    // 但属于该回合（缺失会导致模型侧 tool_calls 悬空）→ 一并复制。
+    const toCopy = allMessages.filter((m) => m.timestamp <= snapshotMessage.timestamp);
+    // 分叉点消息及其之前 assistant 声明的工具调用 id
+    const declaredCallIds = new Set<string>();
+    for (const m of toCopy) {
+      if (m.role !== 'assistant') continue;
+      try {
+        for (const tc of JSON.parse(m.toolCallsJson || '[]') as { id?: string }[]) {
+          if (tc.id) declaredCallIds.add(tc.id);
+        }
+      } catch {
+        /* ignore */
+      }
+    }
+    // 追加这些工具调用对应的结果消息（若尚未被时间戳条件覆盖）
+    const toolResultsToInclude = allMessages.filter(
+      (m) => m.role === 'tool' && m.toolCallId != null && declaredCallIds.has(m.toolCallId) && !toCopy.includes(m)
+    );
+    const finalCopy = [...toCopy, ...toolResultsToInclude].sort((a, b) => a.timestamp - b.timestamp);
+    const copiedMessageIds = new Map<number, number>();
+    for (const m of finalCopy) {
+      const { id: oldId, ...rest } = m;
+      const copiedId = await db.messages.add({ ...rest, sessionId: newId });
+      if (oldId != null) copiedMessageIds.set(oldId, copiedId);
+    }
+
+    // 复制分叉范围内的完整压缩记录，并将压缩边界映射到新消息 id。
+    const copiedCompressions = sourceCompressions.flatMap((compression) => {
+      const endMessageId = copiedMessageIds.get(compression.endMessageId);
+      if (endMessageId == null) return [];
+      const { id: _oldId, ...rest } = compression;
+      return [{ ...rest, sessionId: newId, endMessageId }];
+    });
+    if (copiedCompressions.length > 0) {
+      await db.contextCompressions.bulkAdd(copiedCompressions);
+    }
+
+    // 新会话预览取最后一条可见消息（工具消息不计入）
+    const lastVisible = [...finalCopy].reverse().find((m) => m.role !== 'tool');
+    const lastMessage = lastVisible ? sessionPreviewText(lastVisible.content) || '…' : '';
+    await db.sessions.update(newId, { lastMessage });
+
+    await get().refreshSessions();
+    await get().loadMessages(newId);
+    await get().setActiveSession(newId);
+    return newId;
+  },
+
+  updateSessionSettings: async (sessionId, opts) => {
+    const session = await db.sessions.get(sessionId);
+    if (!session) return;
+    const npcIds = [...new Set((opts.npcIds ?? []).filter((id) => Number.isFinite(id)).map(Number))].slice(0, 5);
+    if (npcIds.length === 0) return;
+    const participantOrder = opts.participantOrder ?? [-1, ...npcIds];
+    const participants = await buildSessionParticipants(sessionId, npcIds, participantOrder);
+    const finalNpcIds = participants.filter((p) => p.kind === 'NPC' && p.npcId != null).map((p) => p.npcId!);
+    if (finalNpcIds.length === 0) return;
+    const finalTitle = opts.title?.trim() || participants
+      .filter((p) => p.kind === 'NPC' && p.npcId != null)
+      .map((p) => p.displayName)
+      .join('、');
+    const turnOrderMode = opts.turnOrderMode === 'RANDOM' ? 'RANDOM' : 'PRESET';
+    const existingParticipants = (await db.participants.where('sessionId').equals(sessionId).toArray())
+      .sort((left, right) => left.seatOrder - right.seatOrder);
+    const queueSettingsChanged = turnOrderMode !== session.turnOrderMode
+      || existingParticipants.length !== participants.length
+      || existingParticipants.some((existing, index) => {
+        const next = participants[index];
+        return existing.participantId !== next.participantId
+          || existing.kind !== next.kind
+          || existing.npcId !== next.npcId
+          || existing.displayName !== next.displayName
+          || existing.seatOrder !== next.seatOrder;
+      });
+    const queue = queueSettingsChanged ? initializeTurnQueue(participants, turnOrderMode) : safeParseQueue(session.turnQueueJson);
+    if (queueSettingsChanged) {
+      await db.participants.where('sessionId').equals(sessionId).delete();
+      await db.participants.bulkAdd(participants);
+    }
+    await db.sessions.update(sessionId, {
+      title: finalTitle,
+      mode: finalNpcIds.length === 1 ? 'NPC' : 'GROUP',
+      associatedId: finalNpcIds.length === 1 ? finalNpcIds[0] : null,
+      worldBookId: opts.worldBookId ?? null,
+      userPersonaNpcId: opts.userPersonaNpcId ?? null,
+      enableGreeting: opts.enableGreeting !== false,
+      mentionOnlyMode: opts.mentionOnlyMode === true && finalNpcIds.length > 1,
+      turnOrderMode,
+      ...(queueSettingsChanged ? {
+        turnQueueJson: queueJson(queue),
+        turnQueueHistoryJson: queueHistoryJson([queue]),
+        loopIndex: 0,
+      } : {}),
+      updatedAt: Date.now(),
+    });
+    await get().loadMessages(sessionId);
+    await get().refreshSessions();
+    await get().refreshLiveQueue(sessionId);
+  },
+
+  resetSessionConversation: async (sessionId) => {
+    const session = await db.sessions.get(sessionId);
+    if (!session) return;
+    invalidateContextCompressionJob(sessionId);
+    const participants = (await db.participants.where('sessionId').equals(sessionId).toArray()).sort((a, b) => a.seatOrder - b.seatOrder);
+    const queue = initializeTurnQueue(participants, session.turnOrderMode);
+    await db.messages.where('sessionId').equals(sessionId).delete();
+    await db.contextCompressions.where('sessionId').equals(sessionId).delete();
+    const greetingSpeakerId = pickGreetingSpeakerId(session.mode, session.associatedId, queue, session.enableGreeting !== false);
+    const lastMessage = await seedOpeningGreetingForSpeaker(sessionId, greetingSpeakerId);
+    const greeting = greetingSpeakerId != null
+      ? (await db.messages.where('sessionId').equals(sessionId).sortBy('timestamp')).at(-1)
+      : null;
+    const greetingMentions = greeting && greetingSpeakerId != null
+      ? mentionedParticipantIds(greeting.content, participants, greetingSpeakerId)
+      : [];
+    await db.sessions.update(sessionId, {
+      turnQueueJson: queueJson(session.mode === 'GROUP' && greetingSpeakerId != null
+        ? completeTurn(queue, greetingSpeakerId, greetingMentions.length > 0 ? greetingMentions : (session.mentionOnlyMode ? [-1] : []))
+        : queue),
+      turnQueueHistoryJson: queueHistoryJson([queue]),
+      loopIndex: 0,
+      lastMessage,
+      updatedAt: Date.now(),
+    });
+    await get().loadMessages(sessionId);
+    await get().refreshSessions();
+    await get().refreshLiveQueue(sessionId);
+    if (session.mode === 'GROUP' && greetingSpeakerId != null) {
+      void continueGroupConversation(sessionId);
+    }
+  },
+
+  resolveConfirmation: (approved) => {
+    const req = get().pendingConfirmation;
+    if (!req) return;
+    const d = confirmationDeferreds.get(req);
+    if (d) {
+      confirmationDeferreds.delete(req);
+      d.resolve(approved);
+    }
+    set({ pendingConfirmation: null });
+  },
+
+  setActiveDisplay: (d) => set({ activeDisplay: d }),
+
+  /** 用 DB 最新队列刷新快照（群聊面板的实时数据源） */
+  refreshLiveQueue: async (sessionId) => {
+    const session = await db.sessions.get(sessionId);
+    if (!session) {
+      get().clearLiveQueue(sessionId);
+      return;
+    }
+    const history = await ensureLoopHistory(sessionId);
+    const parts = await db.participants.where('sessionId').equals(sessionId).toArray();
+    // 展示用：队首仅用于「正在发言」指示；队列本身以循环历史为准
+    const queue = safeParseQueue(session.turnQueueJson).filter((id) =>
+      parts.some((p) => String(p.participantId) === id)
+    );
+    set((s) => ({
+      liveQueueBySession: {
+        ...s.liveQueueBySession,
+        [sessionId]: {
+          queue,
+          history,
+          loopIndex: session.loopIndex,
+          turnOrderMode: session.turnOrderMode,
+        },
+      },
+    }));
+  },
+
+  /** 清除某会话的队列快照 */
+  clearLiveQueue: (sessionId) => {
+    set((s) => {
+      if (!(sessionId in s.liveQueueBySession)) return {};
+      const next = { ...s.liveQueueBySession };
+      delete next[sessionId];
+      return { liveQueueBySession: next };
+    });
+  },
+
+  addToast: (message, kind = 'info') => {
+    const id = ++toastSeq;
+    set({ toasts: [...get().toasts, { id, message, kind }] });
+    setTimeout(() => set({ toasts: get().toasts.filter((t) => t.id !== id) }), 3500);
+  },
+
+  removeToast: (id) => set({ toasts: get().toasts.filter((t) => t.id !== id) }),
+}));
+
+// ============================================================
+// 内部实现
+// ============================================================
+
+const confirmationDeferreds = new Map<ToolConfirmationRequest, { resolve: (v: boolean) => void }>();
+
+function isEnabledProviderModel(provider: ApiProvider, modelId: string): boolean {
+  return provider.isEnabled &&
+    Boolean(provider.baseUrl.trim()) &&
+    enabledModelIds(provider).has(modelId) &&
+    provider.cachedModelsCsv.split(',').some((candidateModel) => candidateModel.trim() === modelId);
+}
+
+/** 聚合启用 Provider 的模型列表，每个 Provider 保留独立的选择项。 */
+function aggregateEnabledProviderModels(providers: ApiProvider[]): ProviderModelOption[] {
+  return providers
+    .flatMap((provider) => {
+      if (provider.id == null || !provider.isEnabled || !provider.baseUrl.trim()) return [];
+      const aliases = modelAliases(provider);
+      const enabledModels = enabledModelIds(provider);
+      return provider.cachedModelsCsv
+        .split(',')
+        .map((modelId) => modelId.trim())
+        .filter((modelId) => modelId && enabledModels.has(modelId))
+        .map((modelId) => ({ providerId: provider.id!, modelId, label: aliases[modelId]?.trim() || modelId }));
+    })
+    .sort((left, right) => left.label.localeCompare(right.label) || left.providerId - right.providerId);
+}
+
+/** 创建会话（公开给 UI 用） */
+export async function createSession(
+  mode: 'STANDARD' | 'NPC' | 'GROUP',
+  opts?: {
+    associatedId?: number;
+    npcIds?: number[];
+    title?: string;
+    worldBookId?: number | null;
+    userPersonaNpcId?: number | null;
+    turnOrderMode?: TurnOrderMode;
+    participantOrder?: number[];
+    enableGreeting?: boolean;
+    mentionOnlyMode?: boolean;
+  }
+): Promise<number> {
+ let title = opts?.title;
+ if (!title) {
+   title = mode === 'STANDARD' ? translate('nav.newStandardTitle') : mode === 'NPC' ? translate('nav.newNpcTitle') : translate('nav.newGroupTitle');
+ }
+ const turnOrderMode = opts?.turnOrderMode === 'RANDOM' ? 'RANDOM' : 'PRESET';
+ const requestedNpcIds = mode === 'NPC'
+   ? (opts?.associatedId != null ? [opts.associatedId] : [])
+   : [...new Set((opts?.npcIds ?? []).filter((id) => Number.isFinite(id)).map(Number))].slice(0, 5);
+ const now = Date.now();
+ const npcId = mode === 'NPC' ? (requestedNpcIds[0] ?? null) : null;
+ const npc = npcId != null ? await db.npcs.get(npcId) : null;
+ let worldBookId = opts?.worldBookId ?? null;
+ // 默认将内置经营手册附加到酒馆老板的单聊；保留显式指定的世界书。
+ if (worldBookId == null && npc && isTavernKeeper(npc)) {
+   const handbook = await db.worldBooks.filter(isBuiltinTavernHandbook).first();
+   if (handbook?.id != null) worldBookId = handbook.id;
+ }
+ // 会话专属工作目录：先写入会话拿自增 id，再用 id 生成当前酒馆实例专属目录并回填。
+ // 该会话的所有工具调用（shell / 文件读写 / 脚本执行等）都在此目录下进行，会话间及酒馆实例间互相隔离。
+ const id = await db.sessions.add({
+   title,
+   mode,
+   associatedId: npcId,
+   worldBookId,
+   userPersonaNpcId: opts?.userPersonaNpcId ?? null,
+   enableGreeting: opts?.enableGreeting !== false,
+   mentionOnlyMode: opts?.mentionOnlyMode === true && mode === 'GROUP',
+   turnOrderMode,
+   workspaceDir: null,
+   turnQueueJson: '[]',
+   turnQueueHistoryJson: '[]',
+   loopIndex: 0,
+   pinned: 0,
+   lastMessage: '',
+   updatedAt: now,
+   createdAt: now,
+  });
+ // 用当前酒馆实例标识和会话 id 生成单层工作目录，确保不同酒馆实例间互不影响。
+ const workspaceDir = createSessionWorkspaceDir(id);
+ await db.sessions.update(id, { workspaceDir });
+ // 创建对话的同时预建其专属工作目录（磁盘沙箱启动时会真实创建；
+ // 未启动/失败时静默跳过，首次工具调用时仍会自动补建）
+ await ensureSessionWorkspaceDir(workspaceDir);
+
+  // 参与者
+  const participantsById = new Map<number, ChatParticipant>();
+  participantsById.set(-1, {
+    sessionId: id,
+    participantId: -1,
+    kind: 'PLAYER',
+    npcId: null,
+    displayName: translate('common.user'),
+    seatOrder: 0,
+  });
+
+  if (mode === 'NPC' && requestedNpcIds[0] != null) {
+    const npc = await db.npcs.get(requestedNpcIds[0]);
+    if (npc) {
+      participantsById.set(requestedNpcIds[0], {
+        sessionId: id,
+        participantId: requestedNpcIds[0],
+        kind: 'NPC',
+        npcId: requestedNpcIds[0],
+        displayName: npc.name,
+        seatOrder: 1,
+      });
+    }
+  } else if (mode === 'GROUP') {
+    for (const npcId of requestedNpcIds) {
+      const npc = await db.npcs.get(npcId);
+      if (!npc) continue;
+      participantsById.set(npcId, {
+        sessionId: id,
+        participantId: npcId,
+        kind: 'NPC',
+        npcId,
+        displayName: npc.name,
+        seatOrder: participantsById.size,
+      });
+    }
+  }
+  const defaultParticipantOrder = [...participantsById.keys()];
+  const validParticipantIds = new Set(defaultParticipantOrder);
+  const normalizedParticipantOrder: number[] = [];
+  for (const rawId of opts?.participantOrder ?? []) {
+    const participantId = Number(rawId);
+    if (!validParticipantIds.has(participantId) || normalizedParticipantOrder.includes(participantId)) continue;
+    normalizedParticipantOrder.push(participantId);
+  }
+  for (const participantId of defaultParticipantOrder) {
+    if (!normalizedParticipantOrder.includes(participantId)) normalizedParticipantOrder.push(participantId);
+  }
+  const participants = normalizedParticipantOrder
+    .map((participantId, seatOrder) => {
+      const participant = participantsById.get(participantId);
+      return participant ? { ...participant, seatOrder } : null;
+    })
+    .filter(Boolean) as ChatParticipant[];
+  await db.participants.bulkAdd(participants);
+
+  // 初始化队列（含玩家；玩家默认队首）— 群聊的循环由全体成员组成
+  const queue = initializeTurnQueue(participants, turnOrderMode);
+  await db.sessions.update(id, {
+    turnQueueJson: queueJson(queue),
+    turnQueueHistoryJson: queueHistoryJson([queue]),
+  });
+
+  const enableGreeting = opts?.enableGreeting !== false;
+  const greetingSpeakerId = pickGreetingSpeakerId(mode, mode === 'NPC' ? (requestedNpcIds[0] ?? null) : null, queue, enableGreeting);
+  const greetingPreview = await seedOpeningGreetingForSpeaker(id, greetingSpeakerId);
+  if (greetingPreview) {
+    const patch: Partial<ChatSession> = { lastMessage: greetingPreview };
+    if (mode === 'GROUP' && greetingSpeakerId != null) {
+      const greeting = (await db.messages.where('sessionId').equals(id).sortBy('timestamp')).at(-1);
+      const mentions = greeting
+        ? mentionedParticipantIds(greeting.content, participants, greetingSpeakerId)
+        : [];
+      patch.turnQueueJson = queueJson(completeTurn(
+        queue,
+        greetingSpeakerId,
+        mentions.length > 0 ? mentions : (opts?.mentionOnlyMode ? [-1] : []),
+      ));
+    }
+    await db.sessions.update(id, patch);
+  }
+
+  // 同步 store
+  await useStore.getState().refreshSessions();
+  await useStore.getState().refreshLiveQueue(id);
+  if (mode === 'GROUP' && greetingSpeakerId != null) {
+    void continueGroupConversation(id);
+  }
+
+  return id;
+}
+
+async function buildSessionParticipants(sessionId: number, npcIds: number[], participantOrder?: number[]): Promise<ChatParticipant[]> {
+  const participantsById = new Map<number, ChatParticipant>();
+  participantsById.set(-1, {
+    sessionId,
+    participantId: -1,
+    kind: 'PLAYER',
+    npcId: null,
+    displayName: translate('common.user'),
+    seatOrder: 0,
+  });
+  for (const npcId of npcIds) {
+    const npc = await db.npcs.get(npcId);
+    if (!npc) continue;
+    participantsById.set(npcId, {
+      sessionId,
+      participantId: npcId,
+      kind: 'NPC',
+      npcId,
+      displayName: npc.name,
+      seatOrder: participantsById.size,
+    });
+  }
+  const defaultParticipantOrder = [...participantsById.keys()];
+  const validParticipantIds = new Set(defaultParticipantOrder);
+  const normalizedParticipantOrder: number[] = [];
+  for (const rawId of participantOrder ?? []) {
+    const participantId = Number(rawId);
+    if (!validParticipantIds.has(participantId) || normalizedParticipantOrder.includes(participantId)) continue;
+    normalizedParticipantOrder.push(participantId);
+  }
+  for (const participantId of defaultParticipantOrder) {
+    if (!normalizedParticipantOrder.includes(participantId)) normalizedParticipantOrder.push(participantId);
+  }
+  return normalizedParticipantOrder
+    .map((participantId, seatOrder) => {
+      const participant = participantsById.get(participantId);
+      return participant ? { ...participant, seatOrder } : null;
+    })
+    .filter(Boolean) as ChatParticipant[];
+}
+
+async function seedOpeningGreetingForSpeaker(
+  sessionId: number,
+  greetingSpeakerId: number | null,
+): Promise<string> {
+  if (greetingSpeakerId == null) return '';
+  const [session, npc, participants] = await Promise.all([
+    db.sessions.get(sessionId),
+    db.npcs.get(greetingSpeakerId),
+    db.participants.where('sessionId').equals(sessionId).toArray(),
+  ]);
+  if (!npc) return '';
+  const preview = await seedOpeningGreeting(sessionId, npc);
+  const player = participants.find((participant) => participant.kind === 'PLAYER');
+  if (session?.mentionOnlyMode && player) {
+    const greeting = (await db.messages.where('sessionId').equals(sessionId).sortBy('timestamp'))
+      .filter((message) => message.role === 'assistant' && message.speakerParticipantId === greetingSpeakerId)
+      .at(-1);
+    if (greeting?.id != null && mentionedParticipantIds(greeting.content, participants, greetingSpeakerId).length === 0) {
+      await db.messages.update(greeting.id, { displayHandoffMention: `@${player.displayName}` });
+    }
+  }
+  return preview;
+}
+
+function pickGreetingSpeakerId(
+  mode: SessionMode,
+  associatedId: number | null,
+  queue: string[],
+  enableGreeting: boolean
+): number | null {
+  if (!enableGreeting) return null;
+  if (mode === 'NPC' && associatedId != null) return associatedId;
+  if (mode === 'GROUP') {
+    const firstSpeakerId = Number(queue[0] ?? NaN);
+    if (Number.isFinite(firstSpeakerId) && firstSpeakerId !== -1) return firstSpeakerId;
+  }
+  return null;
+}
+
+async function handleMagicCommand(session: ChatSession, cmd: string): Promise<void> {
+  if (cmd === '/new') {
+    const marker: ChatMessage = {
+      sessionId: session.id!,
+      role: 'system',
+      speakerParticipantId: null,
+      speakerName: null,
+      content: NEW_TOPIC_MARKER,
+      toolCallsJson: '[]',
+      toolCallId: null,
+      thinkingContent: null,
+      loopIndex: session.mode === 'GROUP' ? currentLoopIndexOf(session) : null,
+      timestamp: Date.now(),
+      latencyMs: null,
+      promptTokens: 0,
+      completionTokens: 0,
+      totalTokens: 0,
+      tokensPerSec: null,
+      modelUsed: null,
+      attachments: [],
+      attachmentInfos: [],
+      displayRef: null,
+      rawRequestBody: null,
+      rawResponseBody: null,
+    };
+    await db.messages.add(marker);
+    await db.sessions.update(session.id!, { updatedAt: Date.now(), lastMessage: NEW_TOPIC_MARKER });
+    await useStore.getState().loadMessages(session.id!);
+  } else if (cmd === '/pass') {
+    // 魔法指令 /pass：将玩家移出队列，不修改任何对话历史
+    if (session.mode === 'GROUP') {
+      const participants = await db.participants.where('sessionId').equals(session.id!).toArray();
+      const session1 = await db.sessions.get(session.id!);
+      if (session1) {
+        const player = participants.find((p) => p.kind === 'PLAYER');
+        const playerId = player ? player.participantId : -1;
+        const { queue, loopIndex, loopStarted } = refreshQueue(session1, participants);
+        // 将玩家移出队列；边界时把新循环完整顺序写入历史
+        await persistQueue(session1.id!, passPlayer(queue, playerId), loopIndex, loopStarted);
+        // 实时刷新队列面板（玩家已移出）
+        await useStore.getState().refreshLiveQueue(session1.id!);
+        // 继续群聊（其余成员依次发言）
+        await continueGroupConversation(session.id!);
+      }
+    } else {
+      useStore.getState().addToast(translate('toast.passOnlyGroup'), 'error');
+    }
+  }
+}
+
+/** 对话主循环：NPC / STANDARD 直接回复；GROUP 依队列轮转。
+ * 返回该轮生成结果（供「重新生成」失败回退判断）。 */
+async function runConversationLoop(session: ChatSession): Promise<TurnResult> {
+  if (session.mode === 'STANDARD') {
+    return streamAssistantTurn(session, null, null);
+  } else if (session.mode === 'NPC') {
+    const npc = session.associatedId ? await db.npcs.get(session.associatedId) : null;
+    if (npc) {
+      return streamAssistantTurn(session, npc, session.associatedId);
+    }
+    return 'failed';
+  } else if (session.mode === 'GROUP') {
+    return continueGroupConversation(session.id!);
+  }
+  return 'ok';
+}
+
+/**
+ * 统一持久化队列与循环历史：
+ * - 保存剩余队列（队首 = 下一发言者）
+ * - loopStarted（刚进入新循环）→ 把新循环完整顺序追加到历史末尾
+ * 所有队列变更点（玩家发言 / /pass / 回合推进 / 循环结束重初始化）都经由它落库，
+ * 保证面板的「循环历史」完整可观测。
+ */
+async function persistQueue(
+  sessionId: number,
+  queue: string[],
+  loopIndex: number,
+  loopStarted: boolean
+): Promise<void> {
+  const session = await db.sessions.get(sessionId);
+  if (!session) return;
+  const history = safeParseQueueHistory(session.turnQueueHistoryJson || '[]');
+  const nextHistory = loopStarted ? [...history, queue] : history;
+  await db.sessions.update(sessionId, {
+    turnQueueJson: queueJson(queue),
+    loopIndex,
+    turnQueueHistoryJson: queueHistoryJson(nextHistory),
+  });
+}
+
+async function refreshQueueAndSave(sessionId: number): Promise<void> {
+  const session = await db.sessions.get(sessionId);
+  if (!session) return;
+  const parts = await db.participants.where('sessionId').equals(sessionId).toArray();
+  const { queue, loopIndex, loopStarted } = refreshQueue(session, parts);
+  await persistQueue(sessionId, queue, loopIndex, loopStarted);
+  await useStore.getState().refreshLiveQueue(sessionId);
+}
+
+/**
+ * 读取循环历史（带兼容兜底：无历史记录时用当前队列作为第 1 轮）。
+ * 历史的新循环追加由各队列变更点（persistQueue）完成。
+ */
+async function ensureLoopHistory(sessionId: number): Promise<string[][]> {
+  const session = await db.sessions.get(sessionId);
+  if (!session) return [];
+  const history = safeParseQueueHistory(session.turnQueueHistoryJson || '[]');
+  if (history.length > 0) return history;
+  // 兼容旧数据 / 极早阶段：用当前队列作为唯一一轮
+  const parts = await db.participants.where('sessionId').equals(sessionId).toArray();
+  const { queue } = refreshQueue(session, parts);
+  if (queue.length > 0) {
+    await db.sessions.update(sessionId, { turnQueueHistoryJson: queueHistoryJson([queue]) });
+    return [queue];
+  }
+  return [];
+}
+
+/** 最近一次某 NPC 的发言文本（用于解析该 NPC 发言中的 @ 点名） */
+function lastAssistantTextBySpeaker(sessionId: number, speakerParticipantId: number): string {
+  const list = useStore.getState().messages[sessionId] ?? [];
+  const last = [...list]
+    .reverse()
+    .find((m) => m.role === 'assistant' && m.speakerParticipantId === speakerParticipantId);
+  return last?.content ?? '';
+}
+
+/**
+ * 群聊当前循环号（0 起）：以会话最新持久化的 loopIndex 为准。
+ * 玩家在某循环发言时，消息归属该循环；会话刚进入新循环（loopIndex 未变）时，
+ * 新循环的“领首”消息仍归属当前 loopIndex，保证对话与队列循环历史逐轮对齐。
+ */
+function currentLoopIndexOf(session: ChatSession): number {
+  return session.loopIndex ?? 0;
+}
+
+/**
+ * 解析当前生效的 API 端点：
+ * 1. 若 settings.defaultProviderId 指向已启用 Provider → 用其 baseUrl/apiKey
+ * 2. 否则回退 settings 中的 baseUrl/apiKey
+ */
+async function resolveActiveEndpoint(): Promise<{
+  baseUrl: string;
+  apiKey: string;
+  model: string;
+} | null> {
+  const settings = useStore.getState().settings;
+  if (!settings) return null;
+  const providers = await db.providers.toArray();
+  const model = settings.defaultModel?.trim() || '';
+  if (!model) return null;
+
+  const activeProvider = settings.defaultProviderId != null
+    ? providers.find((provider) => provider.id === settings.defaultProviderId && isEnabledProviderModel(provider, model))
+    : null;
+
+  if (!activeProvider) return null;
+  return { baseUrl: activeProvider.baseUrl, apiKey: activeProvider.apiKey, model };
+}
+
+/**
+ * 执行一次 assistant 流式回合（含 ReAct 工具调用链，最多 4 层）。
+ * 返回该回合结果：'ok' 已产出回复 / 'failed' 生成失败（调用方据此回退）
+ * / 'stopped' 用户主动停止（视为成功保留部分内容，不回退）。
+ */
+function toPromptMessage(message: ChatMessage) {
+  return {
+    role: message.role,
+    content: message.content,
+    speakerParticipantId: message.speakerParticipantId,
+    speakerName: message.speakerName,
+    thinkingContent: message.thinkingContent,
+    toolCallsJson: message.toolCallsJson,
+    toolCallId: message.toolCallId,
+    attachments: message.attachments,
+  };
+}
+
+type ConversationTurn = { start: number; end: number };
+
+function completedConversationTurns(messages: ChatMessage[]): ConversationTurn[] {
+  const turns: ConversationTurn[] = [];
+  let pendingTurn: { start: number; end: number; phase: 'user' | 'assistant' } | null = null;
+
+  for (let index = 0; index < messages.length; index++) {
+    const role = messages[index].role;
+    if (role === 'user') {
+      if (pendingTurn?.phase === 'assistant') turns.push({ start: pendingTurn.start, end: index - 1 });
+      if (pendingTurn?.phase !== 'user') pendingTurn = { start: index, end: index, phase: 'user' };
+      else pendingTurn.end = index;
+    } else if (role === 'assistant' && pendingTurn) {
+      pendingTurn.phase = 'assistant';
+      pendingTurn.end = index;
+    } else if (pendingTurn?.phase === 'assistant') {
+      pendingTurn.end = index;
+    }
+  }
+  if (pendingTurn?.phase === 'assistant') turns.push({ start: pendingTurn.start, end: pendingTurn.end });
+  return turns;
+}
+
+function messagesAfterLastNewTopic(messages: ChatMessage[]): ChatMessage[] {
+  for (let index = messages.length - 1; index >= 0; index--) {
+    if (messages[index].role === 'system' && messages[index].content === NEW_TOPIC_MARKER) {
+      return messages.slice(index + 1);
+    }
+  }
+  return messages;
+}
+
+function groupCurrentTurnHasAssistantReply(messages: ChatMessage[]): boolean {
+  for (let index = messages.length - 1; index >= 0; index--) {
+    if (messages[index].role === 'assistant') return true;
+    if (messages[index].role === 'user') return false;
+  }
+  return false;
+}
+
+function selectActiveContextCompression(
+  messages: ChatMessage[],
+  turns: ConversationTurn[],
+  compressions: ContextCompression[],
+  currentThreshold: AppSettings['contextCompressionThreshold'],
+  excludeCurrentGroupTurn: boolean,
+): ContextCompression | undefined {
+  if (typeof currentThreshold !== 'number') return undefined;
+
+  const turnIndexByMessageId = new Map<number, number>();
+  turns.forEach(({ start, end }, turnIndex) => {
+    for (let messageIndex = start; messageIndex <= end; messageIndex++) {
+      const messageId = messages[messageIndex].id;
+      if (messageId != null) turnIndexByMessageId.set(messageId, turnIndex);
+    }
+  });
+
+  for (let index = compressions.length - 1; index >= 0; index--) {
+    const candidate = compressions[index];
+    const compressedTurnIndex = turnIndexByMessageId.get(candidate.endMessageId);
+    const completedTurnCount = turns.length - (excludeCurrentGroupTurn && groupCurrentTurnHasAssistantReply(messages) ? 1 : 0);
+    if (compressedTurnIndex != null && completedTurnCount >= compressedTurnIndex + 1 + currentThreshold) {
+      return candidate;
+    }
+  }
+  return undefined;
+}
+
+function scheduleContextCompression(
+  sessionId: number,
+  settings: AppSettings,
+  baseUrl: string,
+  apiKey: string,
+  model: string,
+): void {
+  if (contextCompressionJobs.has(sessionId)) {
+    queuedContextCompressionSessions.add(sessionId);
+    return;
+  }
+  const controller = new AbortController();
+  const revision = contextCompressionRevisions.get(sessionId) ?? 0;
+  contextCompressionControllers.set(sessionId, controller);
+  const job = compressCompletedConversationIfNeeded(sessionId, settings, baseUrl, apiKey, model, revision, controller.signal)
+    .finally(async () => {
+      contextCompressionJobs.delete(sessionId);
+      if (contextCompressionControllers.get(sessionId) === controller) {
+        contextCompressionControllers.delete(sessionId);
+      }
+      if (queuedContextCompressionSessions.delete(sessionId)) {
+        const [currentSettings, endpoint] = [useStore.getState().settings, await resolveActiveEndpoint()];
+        if (currentSettings && endpoint) {
+          scheduleContextCompression(sessionId, currentSettings, endpoint.baseUrl, endpoint.apiKey, endpoint.model);
+        }
+      }
+    });
+  contextCompressionJobs.set(sessionId, job);
+}
+
+async function compressCompletedConversationIfNeeded(
+  sessionId: number,
+  settings: AppSettings,
+  baseUrl: string,
+  apiKey: string,
+  model: string,
+  revision: number,
+  signal: AbortSignal,
+): Promise<void> {
+  const threshold = settings.contextCompressionThreshold;
+  if (typeof threshold !== 'number' || threshold < 1) return;
+
+  const [messages, existingCompressions, session] = await Promise.all([
+    db.messages.where('sessionId').equals(sessionId).sortBy('timestamp'),
+    db.contextCompressions.where('sessionId').equals(sessionId).sortBy('createdAt'),
+    db.sessions.get(sessionId),
+  ]);
+  if (!session) return;
+  const topicMessages = messagesAfterLastNewTopic(messages);
+  const topicMessageIds = new Set(topicMessages.flatMap((message) => message.id == null ? [] : [message.id]));
+  const existingCompression = [...existingCompressions]
+    .reverse()
+    .find((compression) => topicMessageIds.has(compression.endMessageId));
+  const turns = completedConversationTurns(topicMessages);
+  const compressedTurnCount = existingCompression
+    ? turns.findIndex(({ start, end }) =>
+        topicMessages.slice(start, end + 1).some((message) => message.id === existingCompression.endMessageId)
+      ) + 1
+    : 0;
+  const nextCompressionTurnCount = compressedTurnCount + threshold;
+  if (turns.length < nextCompressionTurnCount) return;
+
+  const firstTurnIndex = compressedTurnCount;
+  const lastTurnIndex = nextCompressionTurnCount - 1;
+  const newMessages = topicMessages.slice(turns[firstTurnIndex].start, turns[lastTurnIndex].end + 1);
+
+  try {
+    const compressionResult = await summarizeContext(baseUrl, apiKey, model, [{
+      role: 'user',
+      content: [
+        'BEGIN_MEMORY_INPUT',
+        existingCompression ? `<prior_memory>\n${existingCompression.summary}\n</prior_memory>` : '',
+        `<conversation_history>\n${formatMessagesForContextSummary(newMessages, session.mode === 'GROUP')}\n</conversation_history>`,
+        'END_MEMORY_INPUT',
+      ].filter(Boolean).join('\n\n'),
+    }], signal);
+    if (signal.aborted || (contextCompressionRevisions.get(sessionId) ?? 0) !== revision) return;
+    const endMessage = await db.messages.get(newMessages[newMessages.length - 1].id!);
+    if (!endMessage || endMessage.sessionId !== sessionId) return;
+    const compression: ContextCompression = {
+      sessionId,
+      summary: compressionResult.summary,
+      endMessageId: newMessages[newMessages.length - 1].id!,
+      endTimestamp: newMessages[newMessages.length - 1].timestamp,
+      createdAt: Date.now(),
+      threshold,
+      rawRequestBody: compressionResult.rawRequestBody,
+      rawResponseBody: compressionResult.rawResponseBody,
+    };
+    const compressionId = await db.contextCompressions.add(compression);
+    compression.id = compressionId;
+    if (signal.aborted || (contextCompressionRevisions.get(sessionId) ?? 0) !== revision) {
+      await db.contextCompressions.delete(compressionId);
+      return;
+    }
+    useStore.setState((state) => ({
+      contextCompressions: {
+        ...state.contextCompressions,
+        [sessionId]: [...(state.contextCompressions[sessionId] ?? []), compression],
+      },
+    }));
+  } catch (error) {
+    if (signal.aborted) return;
+    useStore.getState().addToast(translate('toast.contextCompressionFailed', { msg: (error as Error).message || String(error) }), 'error');
+  }
+}
+
+function formatMessagesForContextSummary(messages: ChatMessage[], isGroup: boolean): string {
+  return messages.map((message) => {
+    const toolCalls = message.toolCallsJson && message.toolCallsJson !== '[]'
+      ? `\nTool calls: ${message.toolCallsJson}`
+      : '';
+    if (isGroup && message.speakerName) {
+      return `${message.speakerName}: ${message.content}${toolCalls}`;
+    }
+    return `${message.role}: ${message.content}${toolCalls}`;
+  }).join('\n\n');
+}
+
+async function streamAssistantTurn(
+  session: ChatSession,
+  npc: NpcCharacter | null,
+  participantId: number | null = null,
+  participant?: ChatParticipant,
+  turnLoopIndex: number | null = null,
+): Promise<TurnResult> {
+  const settings = useStore.getState().settings;
+  if (!settings) return 'failed';
+
+  const endpoint = await resolveActiveEndpoint();
+  if (!endpoint) {
+    useStore.getState().addToast(translate('toast.noEndpoint'), 'error');
+    return 'failed';
+  }
+  const { baseUrl, apiKey, model } = endpoint;
+
+  const sessionId = session.id!;
+  const abortController = new AbortController();
+  useStore.setState((state) => ({
+    streaming: { sessionId, abort: abortController },
+    activitySessionIds: { ...state.activitySessionIds, [sessionId]: true },
+  }));
+  // 面板实时指示：该角色开始发言（队列首位高亮）
+  await useStore.getState().refreshLiveQueue(sessionId);
+
+  const participants = await db.participants.where('sessionId').equals(sessionId).toArray();
+  const activeParticipantId = participantId;
+  // 用户点击「停止生成」（stopStreaming → abort.abort()）后置位，用于中断正在进行的流式拉取
+  let stopped = false;
+  // 是否已成功持久化一条回复（含工具调用消息）；false 且非停止 → 视为生成失败
+  let produced = false;
+  // 本回合是否已计入 1 轮对话（ReAct 多层循环只计一次，避免一轮生成被重复统计）
+  let roundCounted = false;
+  let toolCallCount = 0;
+  let consecutiveToolFailures = 0;
+  let lastToolCallSignature = '';
+  let identicalToolCallCount = 0;
+  let limitDeclined = false;
+  let toolCancelled = false;
+  const resetToolBudgets = () => {
+    depth = 0;
+    toolCallCount = 0;
+    consecutiveToolFailures = 0;
+    lastToolCallSignature = '';
+    identicalToolCallCount = 0;
+  };
+  const confirmLimitContinuation = async (reason: string): Promise<boolean> => {
+    const approved = await requestLimitConfirmation(sessionId, reason, {
+      depth,
+      toolCallCount,
+      identicalToolCallCount,
+      consecutiveToolFailures,
+    });
+    if (approved) resetToolBudgets();
+    else limitDeclined = true;
+    return approved;
+  };
+
+  // ---- ReAct 深度循环 ----
+  let depth = 0;
+  while (true) {
+    if (depth >= MAX_TOOL_CALL_DEPTH) {
+      const continued = await confirmLimitContinuation(
+        translate('confirm.depthLimit', { limit: MAX_TOOL_CALL_DEPTH })
+      );
+      if (!continued) break;
+    }
+    const allMessages = await db.messages.where('sessionId').equals(sessionId).sortBy('timestamp');
+    const currentCompressionThreshold = useStore.getState().settings?.contextCompressionThreshold ?? 'off';
+    const compressions = typeof currentCompressionThreshold === 'number'
+      ? await db.contextCompressions.where('sessionId').equals(sessionId).sortBy('createdAt')
+      : [];
+    const topicMessages = messagesAfterLastNewTopic(allMessages);
+    const activeCompression = selectActiveContextCompression(
+      topicMessages,
+      completedConversationTurns(topicMessages),
+      compressions,
+      currentCompressionThreshold,
+      session.mode === 'GROUP',
+    );
+    const requestMessages = activeCompression
+      ? [
+          {
+            role: 'user',
+            content: `[Context summary / long-term memory]\n${activeCompression.summary}`,
+            speakerParticipantId: null,
+            speakerName: null,
+            thinkingContent: null,
+            toolCallsJson: '[]',
+            toolCallId: null,
+            attachments: [],
+          },
+          ...allMessages.filter((message) => message.id! > activeCompression.endMessageId).map(toPromptMessage),
+        ]
+      : allMessages.map(toPromptMessage);
+    const nmessages = buildNetworkMessagesForSession({
+      session,
+      participants,
+      activeSpeakerParticipantId: activeParticipantId,
+      messages: requestMessages,
+    });
+
+    // system prompt
+    const worldBook = session.worldBookId ? await db.worldBooks.get(session.worldBookId) : null;
+    const userPersona = session.userPersonaNpcId ? await db.npcs.get(session.userPersonaNpcId) : null;
+    let systemPrompt: string;
+    if (session.mode === 'STANDARD') systemPrompt = STANDARD_SYSTEM_PROMPT;
+    else if (session.mode === 'NPC') {
+      systemPrompt = buildNpcSystemPrompt(npc?.prompt ?? '', worldBook?.content, userPersona?.prompt);
+    } else {
+      const name = participant?.displayName ?? npc?.name ?? '';
+      // 传入全体成员、玩家称谓与当前回合队列顺序，让模型感知轮次与 @ 呼叫
+      const allSpeakerNames = participants
+        .filter((p) => p.kind === 'NPC')
+        .map((p) => p.displayName);
+      systemPrompt = buildGroupSystemPrompt(name, npc?.prompt ?? '', worldBook?.content, userPersona?.prompt, {
+        allSpeakerNames,
+        mentionOnlyMode: session.mentionOnlyMode === true,
+      });
+    }
+    nmessages.unshift({ role: 'system', content: systemPrompt });
+
+    // 工具
+    const tools = await getEnabledToolsForSession(sessionId, activeParticipantId ?? null);
+
+    const request = buildChatRequest({
+      model,
+      messages: nmessages,
+      tools: tools.length > 0 ? tools : undefined,
+      temperature: settings.temperature,
+      topP: settings.topP,
+      maxTokens: settings.maxTokens,
+      topK: settings.topK,
+      frequencyPenalty: settings.frequencyPenalty,
+      presencePenalty: settings.presencePenalty,
+      repetitionPenalty: settings.repetitionPenalty,
+      reasoningEffort: settings.reasoningEffort,
+      // 流式输出与工具调用默认开启（无 UI 开关）；思考强度由 Reasoning Effort 控制
+      isThinkingModeEnabled: true,
+      streaming: true,
+      baseUrl,
+    });
+
+    // 本次循环已因用户停止而中断 → 不再发起新一轮请求
+    if (abortController.signal.aborted) break;
+
+    // 草稿消息（流式更新）
+    const startTime = Date.now();
+    const draftId = await db.messages.add({
+      sessionId,
+      role: 'assistant',
+      speakerParticipantId: participantId,
+      speakerName: participant?.displayName ?? npc?.name ?? null,
+      content: '',
+      toolCallsJson: '[]',
+      toolCallId: null,
+      thinkingContent: null,
+      loopIndex: turnLoopIndex,
+      timestamp: Date.now(),
+      latencyMs: null,
+      promptTokens: 0,
+      completionTokens: 0,
+      totalTokens: 0,
+      tokensPerSec: null,
+      modelUsed: model,
+      attachments: [],
+      attachmentInfos: [],
+      displayRef: null,
+      rawRequestBody: null,
+      rawResponseBody: null,
+    });
+    await useStore.getState().loadMessages(sessionId);
+
+    let content = '';
+    let thinking = '';
+    let promptTokens = 0;
+    let completionTokens = 0;
+    const rawLines: string[] = [];
+    const toolCalls: Array<{ id: string; name: string; argumentsJson: string; contentOffset: number }> = [];
+    let errorMsg = '';
+
+    // Large file_write arguments arrive as a growing JSON string. Publishing every token
+    // repeatedly parses/reconciles the whole value and can monopolize the browser main thread.
+    // Persist the same snapshots so a reload can recover an in-progress draft.
+    const DRAFT_PUBLISH_INTERVAL_MS = 100;
+    let publishTimer: ReturnType<typeof setTimeout> | null = null;
+    let lastPublishedAt = 0;
+    let draftWrite = Promise.resolve();
+    const publishDraft = () => {
+      publishTimer = null;
+      lastPublishedAt = Date.now();
+      const contentSnapshot = content;
+      const thinkingContent = thinking || null;
+      const toolCallsJson = JSON.stringify(
+        toolCalls.map((tc) => ({ id: tc.id, name: tc.name, argumentsJson: tc.argumentsJson, contentOffset: tc.contentOffset }))
+      );
+      useStore.setState((s) => {
+        const list = [...(s.messages[sessionId] ?? [])];
+        const idx = list.findIndex((m) => m.id === draftId);
+        if (idx < 0) return {};
+        list[idx] = { ...list[idx], content: contentSnapshot, thinkingContent, toolCallsJson };
+        return { messages: { ...s.messages, [sessionId]: list } };
+      });
+      draftWrite = draftWrite
+        .then(() => db.messages.update(draftId, { content: contentSnapshot, thinkingContent, toolCallsJson }))
+        .then(() => undefined);
+    };
+    const scheduleDraftPublish = () => {
+      if (publishTimer) return;
+      const delay = Math.max(0, DRAFT_PUBLISH_INTERVAL_MS - (Date.now() - lastPublishedAt));
+      publishTimer = setTimeout(publishDraft, delay);
+    };
+
+    await streamChatCompletions(baseUrl, apiKey, request, (chunk) => {
+      switch (chunk.type) {
+        case 'raw':
+          rawLines.push(chunk.line);
+          break;
+        case 'content':
+          content += chunk.text;
+          break;
+        case 'thinking':
+          thinking += chunk.text;
+          break;
+        case 'tool_call':
+          {
+            const idx = toolCalls.findIndex((tc) => tc.id === chunk.id);
+            if (idx >= 0) {
+              toolCalls[idx] = {
+                ...toolCalls[idx],
+                name: chunk.name || toolCalls[idx].name,
+                argumentsJson: chunk.argJson || toolCalls[idx].argumentsJson,
+              };
+            } else {
+              toolCalls.push({
+                id: chunk.id,
+                name: chunk.name,
+                argumentsJson: chunk.argJson,
+                contentOffset: content.length,
+              });
+            }
+          }
+          break;
+        case 'usage':
+          promptTokens = chunk.prompt;
+          completionTokens = chunk.completion;
+          break;
+        case 'error':
+          errorMsg = chunk.message;
+          break;
+        case 'done':
+          // 用户点击「停止」（stopStreaming → abort.abort()）导致读取被中断时,
+          // attemptStream 会以 done 结束;不再继续累积内容/工具调用
+          if (abortController.signal.aborted) stopped = true;
+          break;
+      }
+      scheduleDraftPublish();
+    }, abortController.signal);
+
+    if (publishTimer) clearTimeout(publishTimer);
+    publishDraft();
+    await draftWrite;
+
+    // 出错时：撤销草稿消息并提示
+    if (errorMsg) {
+      await db.messages.delete(draftId);
+      await useStore.getState().loadMessages(sessionId);
+      finishSessionActivity(sessionId);
+      useStore.getState().addToast(translate('toast.genFailed', { msg: errorMsg }), 'error');
+      return 'failed';
+    }
+
+    // 用户点击「停止」时：中断后续处理（工具调用、ReAct 下一层）
+    if (stopped || abortController.signal.aborted) {
+      await persistPartialDraft(draftId, sessionId, content, thinking, toolCalls, request, rawLines, promptTokens, completionTokens, startTime, model, !roundCounted, npc);
+      break;
+    }
+
+    // 最终持久化草稿
+    const latencyMs = Date.now() - startTime;
+    const finalTokens = completionTokens > 0 ? completionTokens : estimateTokensFromChars(content.length);
+    const tokensPerSec = latencyMs > 0 ? finalTokens / (latencyMs / 1000) : null;
+    const finalToolCalls = toolCalls.map((tc, i) => ({
+      ...tc,
+      id: tc.id || `call-${Date.now()}-${i}`,
+    }));
+    const normalizedContent = trimEdgeNewlines(content);
+    const isEmptyAssistantReply =
+      !normalizedContent &&
+      !thinking.trim() &&
+      finalToolCalls.length === 0;
+    if (isEmptyAssistantReply) {
+      await db.messages.delete(draftId);
+      await useStore.getState().loadMessages(sessionId);
+      continue;
+    }
+    produced = true;
+
+    await db.messages.update(draftId, {
+      content: normalizedContent,
+      thinkingContent: thinking || null,
+      toolCallsJson: JSON.stringify(
+        finalToolCalls.map((tc) => ({ id: tc.id, name: tc.name, argumentsJson: tc.argumentsJson, contentOffset: tc.contentOffset }))
+      ),
+      latencyMs: errorMsg ? null : latencyMs,
+      promptTokens,
+      completionTokens: finalTokens,
+      totalTokens: promptTokens + finalTokens,
+      tokensPerSec,
+      rawRequestBody: JSON.stringify(request),
+      rawResponseBody: rawLines.join('\n'),
+    });
+    await useStore.getState().loadMessages(sessionId);
+
+    // 生涯统计：1 个回复回合 = 1 轮对话（ReAct 多层只计一次）；
+    // 群聊中 NPC 发言会把该轮计入对应角色的 careerNpcStats（最活跃角色统计）
+    const { rounds: assistantRounds, npcRounds } = assistantRoundDelta(!roundCounted, npc);
+    roundCounted = roundCounted || assistantRounds > 0;
+    await accumulateStats(
+      {
+        inputTokens: promptTokens,
+        outputTokens: finalTokens,
+        rounds: assistantRounds,
+        npcRounds,
+      },
+      sessionId,
+      null
+    );
+
+    // 更新会话预览
+    const preview = sessionPreviewText(normalizedContent);
+    await db.sessions.update(sessionId, {
+      updatedAt: Date.now(),
+      lastMessage: preview || '…',
+    });
+
+    if (finalToolCalls.length === 0 && session.mode !== 'GROUP') {
+      scheduleContextCompression(sessionId, settings, baseUrl, apiKey, model);
+    }
+
+    if (errorMsg) {
+      useStore.getState().addToast(translate('toast.genFailed', { msg: errorMsg }), 'error');
+    }
+
+    // ---- 工具调用处理（默认开启） ----
+    if (finalToolCalls.length > 0) {
+      for (const tc of finalToolCalls) {
+        let result: string;
+        const signature = toolCallSignature(tc.name, tc.argumentsJson);
+        const nextIdenticalCount = signature === lastToolCallSignature ? identicalToolCallCount + 1 : 1;
+
+        let allowed = !limitDeclined;
+        let limitReason = '';
+        if (allowed && toolCallCount >= MAX_TOOL_CALLS_PER_TURN) {
+          limitReason = translate('confirm.callLimit', { limit: MAX_TOOL_CALLS_PER_TURN });
+        } else if (allowed && nextIdenticalCount >= MAX_IDENTICAL_TOOL_CALLS) {
+          limitReason = translate('confirm.identicalLimit', {
+            name: tc.name,
+            limit: MAX_IDENTICAL_TOOL_CALLS,
+          });
+        } else if (allowed && consecutiveToolFailures >= MAX_CONSECUTIVE_TOOL_FAILURES) {
+          limitReason = translate('confirm.failureLimit', { limit: MAX_CONSECUTIVE_TOOL_FAILURES });
+        }
+        if (limitReason) allowed = await confirmLimitContinuation(limitReason);
+
+        if (!allowed) {
+          result = translate('confirm.limitCanceled');
+        } else try {
+          identicalToolCallCount = signature === lastToolCallSignature ? identicalToolCallCount + 1 : 1;
+          lastToolCallSignature = signature;
+          toolCallCount++;
+          // 普通角色限制在会话目录；内置酒馆老板的单人会话固定使用 public
+          await applySessionWorkspace(sessionId, npc?.id ?? null);
+          // 确认收口：修改/删除组在外层白名单确认（执行前），shell 组在执行中按需确认，
+          // 两条路径共用同一个 requestConfirmation 回调（requestGeneratedToolConfirmation）
+          const needsConfirm = ['update_skill', 'delete_skill', 'update_character', 'delete_character', 'update_lorebook', 'delete_lorebook'].includes(tc.name);
+          let approved = true;
+          if (needsConfirm) {
+            approved = await requestToolConfirmation(sessionId, tc);
+          }
+          if (!approved) {
+            result = translate('toast.canceled', { name: tc.name });
+          } else {
+            result = await executeToolCall(tc.name, tc.argumentsJson, {
+              sessionId,
+              npcId: npc?.id ?? null,
+              requestConfirmation: (req) => requestGeneratedToolConfirmation(sessionId, req),
+            });
+          }
+        } catch (e) {
+          // 工具执行本身抛异常（网络 / 沙箱 / 安全拦截等）→ 立即落库为失败结果，
+          // 避免整个回合中断、失败不可见（只有用户下一条消息后才显示）
+          result = `ERROR: ${(e as Error).message || String(e)}`;
+        }
+        // 工具没有返回任何内容（空模板 / 空文件 / 空输出等）→ 补占位结果，
+        // 保证调用卡片立即显示「无结果」而不是空白
+        if (!result || !result.trim()) result = translate('tool.noResult');
+        // 数据变更类工具执行后即时刷新 store，保证界面（角色工坊等）无需刷新即可看到最新数据
+        if (result.startsWith('OK:')) {
+          if (tc.name.includes('character')) await useStore.getState().refreshNpcs();
+          if (tc.name.includes('world_book')) await useStore.getState().refreshWorldBooks();
+          if (tc.name.includes('skill')) {
+            await useStore.getState().refreshTools();
+            await useStore.getState().refreshNpcs();
+          }
+        }
+        await db.messages.add({
+          sessionId,
+          role: 'tool',
+          speakerParticipantId: null,
+          speakerName: null,
+          content: result,
+          toolCallsJson: '[]',
+          toolCallId: tc.id,
+          thinkingContent: null,
+          loopIndex: turnLoopIndex,
+          timestamp: Date.now(),
+          latencyMs: null,
+          promptTokens: 0,
+          completionTokens: 0,
+          totalTokens: 0,
+          tokensPerSec: null,
+          modelUsed: null,
+          attachments: [],
+          attachmentInfos: [],
+          displayRef: displayRefForToolName(tc.name, result),
+          rawRequestBody: null,
+          rawResponseBody: null,
+        });
+
+        // 展示类工具（file_display）：执行成功后自动打开展示弹窗
+        const displayPayload = tc.name === 'file_display' ? parseDisplayRef(result) : null;
+        if (displayPayload) {
+          useStore.getState().setActiveDisplay({
+            path: displayPayload.path,
+            kind: displayPayload.kind,
+            title: displayPayload.title,
+            sessionId,
+          });
+        }
+
+        // 结果前缀语义约定：ERROR: = 执行失败（计入连续失败）；
+        // CANCELLED: = 用户主动停止（外层白名单取消 toast.canceled / shell 拒绝 tool.shellDenied /
+        // Agent 限额停止 confirm.limitCanceled，全部产生点仅此三类），一律不计失败，
+        // 清零失败计数并终止当前 ReAct 回合，把控制权交还用户；其余为成功结果（部分工具成功时返回非 OK: 文本，
+        // 如掷骰结果、JSON 快照、模板输出，不能简单用「非 OK:」判定失败）。
+        // 历史版本曾按「与 toast.canceled 字符串全等」判定用户取消，导致 shell 拒绝（tool.shellDenied，
+        // 名字硬编码为 shell）被误判为失败，现统一按前缀豁免。
+        const isToolError = result.startsWith('ERROR:');
+        const isToolCancelled = result.startsWith('CANCELLED:');
+        if (isToolError) {
+          consecutiveToolFailures++;
+        } else {
+          consecutiveToolFailures = 0;
+        }
+
+        if (isToolCancelled) {
+          toolCancelled = true;
+          break;
+        }
+
+        if (
+          !limitDeclined &&
+          consecutiveToolFailures >= MAX_CONSECUTIVE_TOOL_FAILURES &&
+          !(await confirmLimitContinuation(
+            translate('confirm.failureLimit', { limit: MAX_CONSECUTIVE_TOOL_FAILURES })
+          ))
+        ) {
+          limitDeclined = true;
+        }
+      }
+
+      // 工具结果在 DB 落库后立刻刷新 UI（无论是否继续下一层 ReAct），
+      // 保证「失败 / 无结果」在工具执行完成时立即可见，而不是等用户下一条消息
+      await useStore.getState().loadMessages(sessionId);
+
+      if (limitDeclined || toolCancelled) break;
+
+      // 有工具结果 → 下一层 ReAct
+      depth++;
+      continue;
+    }
+
+    break; // 无工具调用则结束
+  }
+
+  finishSessionActivity(sessionId);
+  await refreshQueueAndSave(sessionId);
+
+  // 用户主动停止 → 保留部分内容（不回退）；未产出任何回复 → 视为失败
+  if (stopped || abortController.signal.aborted) return 'stopped';
+  return produced ? 'ok' : 'failed';
+}
+
+function finishSessionActivity(sessionId: number) {
+  useStore.setState((state) => {
+    if (state.activeView !== 'chat' || state.activeSessionId !== sessionId) {
+      return {
+        streaming: { sessionId: null, abort: null },
+        activitySessionIds: { ...state.activitySessionIds, [sessionId]: true },
+      };
+    }
+    const activitySessionIds = { ...state.activitySessionIds };
+    delete activitySessionIds[sessionId];
+    return {
+      streaming: { sessionId: null, abort: null },
+      activitySessionIds,
+    };
+  });
+}
+
+function toolCallSignature(name: string, argumentsJson: string): string {
+  try {
+    return `${name}:${JSON.stringify(sortJsonValue(JSON.parse(argumentsJson || '{}')))}`;
+  } catch {
+    return `${name}:${argumentsJson.trim()}`;
+  }
+}
+
+function sortJsonValue(value: unknown): unknown {
+  if (Array.isArray(value)) return value.map(sortJsonValue);
+  if (value && typeof value === 'object') {
+    return Object.fromEntries(
+      Object.entries(value as Record<string, unknown>)
+        .sort(([left], [right]) => left.localeCompare(right))
+        .map(([key, child]) => [key, sortJsonValue(child)])
+    );
+  }
+  return value;
+}
+
+/**
+ * 用户停止生成时，把已流式收到的部分内容持久化为最终消息，
+ * 避免中断后内容丢失（停止而非报错：不加 latency/raw 等数据）。
+ * 返回是否真的持久化了一条非空回复（用于轮数统计）。
+ */
+async function persistPartialDraft(
+  draftId: number,
+  sessionId: number,
+  content: string,
+  thinking: string,
+  toolCalls: Array<{ id: string; name: string; argumentsJson: string; contentOffset: number }>,
+  request: ChatCompletionRequest,
+  rawLines: string[],
+  promptTokens: number,
+  completionTokens: number,
+  startTime: number,
+  model: string,
+  countRound: boolean,
+  npc: NpcCharacter | null
+): Promise<void> {
+  const latencyMs = Date.now() - startTime;
+  const normalizedContent = trimEdgeNewlines(content);
+  const isEmptyAssistantReply =
+    !normalizedContent &&
+    !thinking.trim() &&
+    toolCalls.length === 0;
+  if (isEmptyAssistantReply) {
+    await db.messages.delete(draftId);
+    await useStore.getState().loadMessages(sessionId);
+    return;
+  }
+  const finalTokens = completionTokens > 0 ? completionTokens : estimateTokensFromChars(normalizedContent.length);
+  await db.messages.update(draftId, {
+    content: normalizedContent,
+    thinkingContent: thinking || null,
+    toolCallsJson: JSON.stringify(toolCalls.map((tc) => ({ id: tc.id, name: tc.name, argumentsJson: tc.argumentsJson, contentOffset: tc.contentOffset }))),
+    latencyMs,
+    promptTokens,
+    completionTokens: finalTokens,
+    totalTokens: promptTokens + finalTokens,
+    tokensPerSec: latencyMs > 0 ? finalTokens / (latencyMs / 1000) : null,
+    modelUsed: model,
+    rawRequestBody: JSON.stringify(request),
+    rawResponseBody: rawLines.join('\n'),
+  });
+  await useStore.getState().loadMessages(sessionId);
+
+  // 生涯统计与会话预览仍同步（与正常回合一致）；
+  // 用户停止但保留了部分内容 → 仍算 1 轮对话（未停止前产生的内容也计）
+  const { rounds: partialRounds, npcRounds } = assistantRoundDelta(countRound, npc);
+  await accumulateStats(
+    { inputTokens: promptTokens, outputTokens: finalTokens, rounds: partialRounds, npcRounds },
+    sessionId,
+    null
+  );
+  const preview = sessionPreviewText(normalizedContent);
+  await db.sessions.update(sessionId, {
+    updatedAt: Date.now(),
+    lastMessage: preview || '…',
+  });
+}
+
+/** 当前 assistant 回合产生的「一轮对话」对应到生涯统计的增量 */
+function assistantRoundDelta(
+  round: boolean,
+  npc: NpcCharacter | null
+): { rounds: number; npcRounds?: { npcId: number; npcName: string; rounds: number } } {
+  if (!round) return { rounds: 0 };
+  if (npc) {
+    return {
+      rounds: 1,
+      npcRounds: { npcId: npc.id!, npcName: npc.name, rounds: 1 },
+    };
+  }
+  return { rounds: 1 };
+}
+
+/** 群聊主循环：持续从队列取发言者。
+ * 返回整段循环的结果：任一回合成败决定整体结果（供「重新生成」失败回退判断）。 */
+async function continueGroupConversation(sessionId: number): Promise<TurnResult> {
+  groupLoopStopped = false;
+  let guard = 0;
+  let failed = false;
+  let stopped = false;
+
+  while (guard < 20) {
+    if (groupLoopStopped) break;
+    const session = await db.sessions.get(sessionId);
+    if (!session) break;
+    const players = await db.participants.where('sessionId').equals(sessionId).toArray();
+    const { queue, loopIndex, loopStarted } = refreshQueue(session, players);
+    if (loopStarted) {
+      // 循环边界：把新循环的完整顺序写入历史（队首可能直接是 NPC，需先落库），
+      // 并立刻刷新面板 → 新循环立即加入显示
+      await persistQueue(sessionId, queue, loopIndex, true);
+      await useStore.getState().refreshLiveQueue(sessionId);
+    }
+    if (queue.length === 0) {
+      // 队列空 = 循环结束：刷新面板
+      await refreshQueueAndSave(sessionId);
+      break;
+    }
+    const nextId = parseInt(queue[0], 10);
+    const next = players.find((p) => p.participantId === nextId);
+    if (!next || next.kind !== 'NPC') {
+      // 轮到玩家 → 等待输入，结束本轮
+      await refreshQueueAndSave(sessionId);
+      break;
+    }
+    // 面板实时指示：正在发言者 = 队列首位
+    await useStore.getState().refreshLiveQueue(sessionId);
+    const npc = next.npcId ? await db.npcs.get(next.npcId) : null;
+    if (!npc) {
+      await persistQueue(sessionId, completeTurn(queue, nextId, []), loopIndex, false);
+      guard++;
+      continue;
+    }
+    // 先不推进队列：让流式发言期间队列首位 = 正在发言的角色（面板实时高亮）
+    const turnResult = await streamAssistantTurn(session, npc, nextId, next, loopIndex);
+    if (turnResult === 'failed') {
+      failed = true;
+      break;
+    }
+    const responseText = lastAssistantTextBySpeaker(sessionId, nextId);
+    const mentioned = mentionedParticipantIds(responseText, players, nextId);
+    if (session.mentionOnlyMode && mentioned.length === 0) {
+      const player = players.find((participant) => participant.kind === 'PLAYER');
+      const playerName = player?.displayName ?? translate('common.user');
+      const message = [...(useStore.getState().messages[sessionId] ?? [])]
+        .reverse()
+        .find((candidate) => candidate.role === 'assistant' && candidate.speakerParticipantId === nextId);
+      if (message?.id != null) {
+        await db.messages.update(message.id, { displayHandoffMention: `@${playerName}` });
+        await useStore.getState().loadMessages(sessionId);
+      }
+      // 未点名时自动将对话权交还给玩家。
+      await persistQueue(sessionId, completeTurn(queue, nextId, [player?.participantId ?? -1]), loopIndex, false);
+    } else {
+      // 回合结束：移出该发言者 + 被 @ 点名者插入/移到队首（历史轮次不受影响）
+      await persistQueue(sessionId, completeTurn(queue, nextId, mentioned), loopIndex, false);
+    }
+    if (turnResult === 'stopped') {
+      stopped = true;
+      break;
+    }
+    guard++;
+    // 用户主动 stop 时中断
+    if (groupLoopStopped) break;
+  }
+  if (!failed && !stopped && !groupLoopStopped) {
+    const [settings, endpoint] = [useStore.getState().settings, await resolveActiveEndpoint()];
+    if (settings && endpoint) {
+      scheduleContextCompression(sessionId, settings, endpoint.baseUrl, endpoint.apiKey, endpoint.model);
+    }
+  }
+  if (groupLoopStopped || stopped) return 'stopped';
+  return failed ? 'failed' : 'ok';
+}
+
+/**
+ * 群聊中「编辑消息 / 重新生成」后的续跑：
+ * 把被编辑的 assistant 发言人重新置顶当前队列（联动发言队列），
+ * 再进入群聊主循环 —— 因此新回复会由「刚才被编辑的角色」生成，
+ * 其余轮次按队列自然推进，队列面板历史也会同步更新。
+ *
+ * 参数 editedSpeaker 可为 null（如发言者已被删除 / 未知 speakerParticipantId），
+ * 此时退化为普通 continueGroupConversation。
+ */
+async function continueRegeneratedGroupLoop(
+  session: ChatSession,
+  editedMessage: ChatMessage,
+  editedSpeaker: ChatParticipant | null
+): Promise<TurnResult> {
+  const sessionId = session.id!;
+  const participants = await db.participants.where('sessionId').equals(sessionId).toArray();
+  const speakerParticipantId = editedSpeaker?.participantId ?? editedMessage.speakerParticipantId;
+  if (speakerParticipantId == null) {
+    // 发言者不可映射 → 仅刷新队列并照常续跑
+    await refreshQueueAndSave(sessionId);
+    return continueGroupConversation(sessionId);
+  }
+  const { queue, loopIndex, loopStarted } = refreshQueue(session, participants);
+  // 编辑后：该角色“重讲一遍” → 置顶队列，联动发言队列面板与下一轮顺序
+  const nextQueue = requeueSpeaker(queue, speakerParticipantId);
+  await persistQueue(sessionId, nextQueue, loopIndex, loopStarted);
+  await useStore.getState().refreshLiveQueue(sessionId);
+  return continueGroupConversation(sessionId);
+}
+
+/** 挂起一个确认请求，直到用户在弹窗上应答（resolveConfirmation）。所有确认共用此唯一挂起点。 */
+function suspendConfirmation(req: ToolConfirmationRequest): Promise<boolean> {
+  return new Promise((resolve) => {
+    confirmationDeferreds.set(req, { resolve });
+    useStore.setState({ pendingConfirmation: req });
+  });
+}
+
+/** 外层白名单确认（修改/删除组，executeToolCall 之前按工具名拦截）。 */
+function requestToolConfirmation(
+  sessionId: number,
+  tc: { id: string; name: string; argumentsJson: string }
+): Promise<boolean> {
+  // message 留空 → 弹窗回退到已本地化的 confirm.modify 文案（工具名由弹窗单独一行展示）
+  return suspendConfirmation({
+    sessionId,
+    toolName: tc.name,
+    title: translate('confirm.modifyTitle', { name: tc.name }),
+    message: '',
+    argsJson: tc.argumentsJson,
+  });
+}
+
+/** shell 执行中确认（沙箱服务判定后透传 ToolConfirmationRequest）。 */
+function requestGeneratedToolConfirmation(
+  sessionId: number,
+  request: ToolConfirmationRequest
+): Promise<boolean> {
+  return suspendConfirmation({ ...request, sessionId });
+}
+
+function requestLimitConfirmation(
+  sessionId: number,
+  reason: string,
+  counters: {
+    depth: number;
+    toolCallCount: number;
+    identicalToolCallCount: number;
+    consecutiveToolFailures: number;
+  }
+): Promise<boolean> {
+  return suspendConfirmation({
+    sessionId,
+    toolName: 'agent_limit',
+    title: translate('confirm.limitTitle'),
+    message: translate('confirm.limitMessage', { reason }),
+    argsJson: JSON.stringify({
+      depth: counters.depth,
+      tool_calls: counters.toolCallCount,
+      identical_calls: counters.identicalToolCallCount,
+      consecutive_failures: counters.consecutiveToolFailures,
+    }),
+    kind: 'limit',
+  });
+}
+
+/**
+ * 展示类工具（file_display）的结果会携带展示引用（DISPLAY_REF 前缀）。
+ * 解析成功 → 返回序列化后的 DisplayFileRef（写入工具结果消息的 displayRef 字段，
+ * 供对话流中的「查看」按钮回看）；其他工具一律返回 null。
+ */
+function displayRefForToolName(toolName: string, result: string): string | null {
+  if (toolName !== 'file_display') return null;
+  const payload = parseDisplayRef(result);
+  if (!payload) return null;
+  // path 前面去展示前缀的剩余文本是给模型看的（留在 content 中）。
+  // displayRef 只保存展示所需的最小信息；sessionId 用于回看时定位会话工作目录。
+  const sessionId = useStore.getState().activeSessionId;
+  return JSON.stringify({
+    path: payload.path,
+    kind: payload.kind,
+    title: payload.title,
+    sessionId,
+  });
+}