ai_co_discuss 0.3.11 → 0.3.13

package/runner/remote_launch.mjs

@@ -9,7 +9,8 @@ import { hostname } from 'node:os';
 import { join } from 'node:path';
 import { fileURLToPath } from 'node:url';
 
-import { atomic_json } from './discussion_adapters.mjs';
+import { adapter_profile } from './adapters/profiles.mjs';
+import { atomic_json } from './files.mjs';
 import { saved_api_keys } from './discussion_api.mjs';
 import { launch_discussion, launch_projects, launch_settings, platform_of } from './discussion_launch.mjs';
 
@@ -82,9 +83,13 @@ function api_key_ref(profile, keys) {
 /** Platforms this computer can wake without further setup, and the client each uses. */
 export function ready_clients(home) {
   const keys = saved_api_keys(home);
-  return Object.fromEntries(Object.entries(launch_settings(home).participants).filter(([, profile]) => profile.adapter === 'api'
-    ? Boolean(profile.base_url && profile.api_protocol && profile.model && api_key_ref(profile, keys))
-    : Boolean(profile.adapter && (profile.adapter === 'antigravity' ? profile.ipc_directory : profile.executable))).map(([name, profile]) => [name, profile.adapter]));
+  return Object.fromEntries(Object.entries(launch_settings(home).participants).filter(([, profile]) => {
+    const facts = adapter_profile(profile.adapter);
+    if (!facts) return false;
+    // A model API needs its endpoint and key; other software needs its installed location.
+    return facts.kind === 'api' ? Boolean(profile.base_url && profile.api_protocol && profile.model && api_key_ref(profile, keys))
+      : Boolean(profile[facts.location]);
+  }).map(([name, profile]) => [name, profile.adapter]));
 }
 
 /** Turn a relayed request into the request the connected browser would send, using this computer's directory and keys. */
@@ -97,7 +102,7 @@ export function local_request(home, site, request) {
   const participants = { ...(input.participants || {}) };
   for (const member of input.room?.members || []) {
     const profile = defaults[platform_of(member.name)];
-    const ref = profile?.adapter === 'api' && !participants[member.name]?.api_key_ref ? api_key_ref(profile, keys) : undefined;
+    const ref = adapter_profile(profile?.adapter)?.kind === 'api' && !participants[member.name]?.api_key_ref ? api_key_ref(profile, keys) : undefined;
     if (ref) participants[member.name] = { ...participants[member.name], api_key_ref: ref };
   }
   return { ...input, participants, site, entry: 'web', ...(project ? { cwd: project.path } : {}) };

package/runner/scheduler.mjs

@@ -12,9 +12,27 @@ export const ROUTE_CONFIDENCE = 0.7;
 /** Waking everyone or no one costs more when wrong (N runs, or an ignored message), so it needs more certainty. */
 export const ROUTE_WIDE_CONFIDENCE = 0.85;
 /** Bump when the routing question or its option descriptions change, so ratings can be compared across wordings. */
-export const ROUTE_PROMPT_VERSION = 10;
+export const ROUTE_PROMPT_VERSION = 12;
+/**
+ * How the free-room routing question is worded. guided (experimental, the default while it is being refined) states the
+ * purpose and the evidence in prose; stable keeps the ordered checklist that passed the regression set.
+ */
+export const SCHEDULER_MODES = { guided: '引导（试验）', stable: '稳定' };
+export const DEFAULT_SCHEDULER_MODE = 'guided';
+/** The guided wording has its own version, so its ratings are never mixed with the stable checklist's. */
+export const ROUTE_GUIDED_PROMPT_VERSION = 4;
+/** The routing prompt version that a decision in this mode was made with. */
+export function route_prompt_version(mode) {
+  return mode === 'stable' ? ROUTE_PROMPT_VERSION : ROUTE_GUIDED_PROMPT_VERSION;
+}
 /** The same for the three discussion questions (interjection, next speaker, next round). */
-export const DISCUSSION_PROMPT_VERSION = 4;
+export const DISCUSSION_PROMPT_VERSION = 5;
+/** The guided wording of the discussion questions, versioned apart from the stable one. */
+export const DISCUSSION_GUIDED_PROMPT_VERSION = 1;
+/** The discussion prompt version that a decision in this mode was made with. */
+export function discussion_prompt_version(mode) {
+  return mode === 'stable' ? DISCUSSION_PROMPT_VERSION : DISCUSSION_GUIDED_PROMPT_VERSION;
+}
 /** Completion of a preauthorized implementation batch is separate from routing and discussion. */
 export const REVIEW_PROMPT_VERSION = 1;
 export const REVIEW_CONFIDENCE = 0.85;
@@ -29,13 +47,23 @@ export const ROUTE_CONTEXT_MESSAGES = 20;
 const MAX_MESSAGE_CHARS = 600;
 const MAX_BRIEF_CHARS = 1200;
 const MAX_PROFILE_CHARS = 500;
+/**
+ * What the room is and how its people talk, so a decision reads the user's words the way a member would.
+ * Shared by every scene built from topic_lines; bump both prompt versions when it changes.
+ */
+const ROOM_GUIDE = ['这是 AI CoDiscuss 的协作房间。用户是房主和需求方；其余成员都是 AI，各自运行在 Claude Code、Codex 等软件或模型 API 上，用户也称它们为专家或 AI。',
+  '其中一位是主持人，负责接收没有点名的消息并分派、协调，也可以自己回答；其他成员是专家，在各自的会话里工作并回复。',
+  '用户用 @名字 点名成员，用 @全体成员 请所有人回应。每唤醒一位成员就要花一次执行（数十秒）；几位成员同时回答时彼此看不到对方的回答。',
+  '房间可以临时开启讨论：主持人按目标安排专家轮流发言，到达轮次或时长上限后回到自由协作。'].join('\n');
 
 /** Normalize a launch's scheduler choice and prove its key exists for that provider's root. */
 export function validate_scheduler(home, scheduler) {
   const provider = SCHEDULER_PROVIDERS[scheduler?.provider];
   if (!provider) throw new Error(`智能调度供应商只能为 ${Object.keys(SCHEDULER_PROVIDERS).join(' / ')}`);
   if (!scheduler.model || typeof scheduler.model !== 'string') throw new Error('请填写智能调度模型');
-  const normalized = { provider: scheduler.provider, model: scheduler.model.trim(), base_url: provider.base_url, api_key_ref: scheduler.api_key_ref };
+  if (scheduler.mode !== undefined && !SCHEDULER_MODES[scheduler.mode]) throw new Error(`智能调度模式只能为 ${Object.keys(SCHEDULER_MODES).join(' / ')}`);
+  const normalized = { provider: scheduler.provider, model: scheduler.model.trim(), base_url: provider.base_url, api_key_ref: scheduler.api_key_ref,
+    mode: scheduler.mode || DEFAULT_SCHEDULER_MODE };
   read_saved_api_key(home, normalized.base_url, normalized.api_key_ref);
   return normalized;
 }
@@ -125,10 +153,23 @@ function excerpt(message) {
 }
 
 /** The room's purpose in the user's words, so a decision can tell drifting from progress. */
-function topic_lines(title, goal, user_request, { roster, profiles, brief, focus, arrangement, progress } = {}) {
-  return [`房间：${title || ''}`, roster && `房间成员（名字不区分大小写）：${roster}`, profile_lines(profiles), goal && `目标：${goal}`, user_request && `用户原文：${String(user_request).slice(0, MAX_MESSAGE_CHARS)}`,
+function topic_lines(title, goal, user_request, { guide = ROOM_GUIDE, roster, people, profiles, brief, focus, arrangement, progress, upcoming } = {}) {
+  return [guide, `房间：${title || ''}`, roster && `房间成员（名字不区分大小写）：${roster}`, people, profile_lines(profiles), goal && `目标：${goal}`, user_request && `用户原文：${String(user_request).slice(0, MAX_MESSAGE_CHARS)}`,
     focus && `当前焦点：${focus}`, brief && `主持简报（含分工与规则）：${String(brief).slice(0, MAX_BRIEF_CHARS)}`,
-    arrangement && `主持人最近的安排：${arrangement}`, progress].filter(Boolean).join('\n');
+    arrangement && `主持人最近的安排：${arrangement}`, progress, upcoming && `接下来按安排发言：${upcoming.length ? upcoming.join(' → ') : '暂无，没有已安排的发言'}`].filter(Boolean).join('\n');
+}
+
+/**
+ * Guided discussion background: how a discussion runs and what each step costs, so the model weighs the situation
+ * instead of matching rules. Used by the three discussion questions in the guided mode.
+ */
+const DISCUSSION_GUIDED_GUIDE = ['这是 AI CoDiscuss 协作房间里临时开启的一场讨论。用户是房主，给出讨论目标；其余成员都是 AI，用户常称它们为专家。',
+  '主持人按目标安排专家轮流发言：每轮每位专家发言一次，后发言的人能看到前面所有发言；主持简报里记着分工、顺序和规则。到达轮次或时长上限、目标达成或用户结束时，回到自由协作。',
+  '每请一位专家发言或回答，都要花一次执行（通常几十秒）。用户在讨论中随时可能留言：补充约束、追问某人、调整方向，或者只是鼓励。'].join('\n');
+/** The member line of the guided routing state: the shared facts plus the model and the last finished message. */
+function guided_member_line(role, member) {
+  const extra = [member.model && `模型 ${member.model}`, member.finished && `最近完成 ${member.finished}`].filter(Boolean).join('；');
+  return `- ${role} ${extra ? String(member.description).replace(/）$/, `；${extra}）`) : member.description}`;
 }
 
 /** The owner's descriptions of members, so a decision can weigh who is good at what. */
@@ -152,20 +193,44 @@ export function certainty(answer) {
   return typeof probability === 'number' ? probability : typeof answer?.confidence === 'number' ? answer.confidence : null;
 }
 
+/** Stable routing wording: an ordered checklist of evidence, each item settling the addressee before the next is read. */
+const ROUTE_STABLE_STEM = '这条用户消息没有用 @ 点名成员。判断它的回应对象，按下面的顺序：1）正文叫了某位成员的名字或用其他说法指代他（对照房间成员名单和前文只可能是他），或在向其提问（包括“X在吗”“X还在吗”“X你怎么看”），选该成员，即使上一条是别人的回答；同时提到几位成员时，选被直接称呼、要求其回应或做事的那位（如“A 你让 B 去改”是在对 A 说）；2）正文没有指向任何人时，看它是否在延续某位成员的回答（追问、要求修改、引用，或“回复”指向其消息），或在补充、纠正一条正由某位成员处理的消息，是则选该成员，是主持人就选主持人；3）查看各成员的用户描述：已经明确由唯一一位成员负责这类任务时，直接选该成员，不需要再次点名；仅有擅长、多人分工重叠或任务还需要拆分时交主持人；4）符合“全体”选项的条件时选全体；要求成员之间讨论或互相回应的不算，按第 7 条处理；5）单独的问候或闲聊（如“hi”）既没有指向某位成员，也没有要求大家一起回应，选主持人；6）只是确认、致谢或旁注选无需回应；7）对象不明确，或要讨论、互相回应、分工、排先后时选主持人，由主持人安排。';
+/**
+ * Guided routing: instead of rules, the model gets what a member of the room would know (who is who, what each is busy
+ * with, what each choice leads to) and the purpose of this step, and weighs the message itself.
+ */
+const ROUTE_GUIDED_GUIDE = ['这是 AI CoDiscuss 的协作房间。用户是房主，也是提出需求的人；其余成员都是 AI，各自运行在 Claude Code、Codex 等软件或模型 API 上，用户常称它们为专家。',
+  '主持人是其中一位：平时接收没人点名的消息，自己回答或分派给别人，也负责协调需要几个人配合的事。专家们在各自的会话里工作，回复都发在房间里，所有人都看得到。',
+  '用户找某人时通常会 @ 他，但聊顺了也常直接说话：叫名字、换个说法指代，或者接着刚才的话往下说。用户也可能事先在成员描述里交代过谁负责什么。',
+  '唤醒一位成员要花一次执行，通常几十秒；交给了不对的人，就得打断后重来。'].join('\n');
+const ROUTE_GUIDED_STEM = '用户发来上面这条消息，没有 @ 任何人。请你像熟悉这个房间的成员一样读懂它：用户想让谁来回应？'
+  + '用户心里已经有明确的对象时，直接交给对方，省掉主持人转一手的时间；需要有人先理解、拆分或协调时交给主持人。'
+  + '用户想听每个人各自说一句时，交给全体能让大家同时开始，比主持人逐个点名快得多；但大家看不到彼此的回答，需要互相接话、讨论的事仍要主持人安排。用户只是表示收到或感谢时，不必唤醒任何人。';
+
+/** The routing question in one mode: option texts, the stem, and what the state adds about the members. */
+function route_question(mode, host, members) {
+  if (mode === 'stable') return { extra: { roster: [`${host.name}（主持人）`, ...members.map(member => `${member.name}（专家）`)].join('、') },
+    instructions: ROUTE_STABLE_STEM, choices: [...members.map(member => ({ value: member.name, description: member.description })),
+      { value: HOST_CHOICE, description: `主持人 ${host.description}：没有指向任何人且用户没有确定负责人（如单独一句“hi”“你好”这类问候、闲聊，由主持人代表房间回应），或诉求模糊、复杂，需要主持人判断怎么安排` },
+      { value: ALL_CHOICE, description: '全体成员（含主持人）各自回应一次，彼此不需要看到别人的回答；只在要求简单明确、每人独立回应一次就算完成时选，如“大家打个招呼”“各自报一下在用的模型”' },
+      { value: NONE_CHOICE, description: '无需回应：只是确认、致谢或旁注，不需要任何人回答' }] };
+  const people = ['成员（名字不区分大小写）：', guided_member_line('主持人', host), ...members.map(member => guided_member_line('专家', member))].join('\n');
+  return { extra: { guide: ROUTE_GUIDED_GUIDE, people }, instructions: ROUTE_GUIDED_STEM,
+    choices: [...members.map(member => ({ value: member.name, description: `交给 ${member.name} 回应` })),
+      { value: HOST_CHOICE, description: `交给主持人 ${host.name}：由他回应，或由他安排别人` },
+      { value: ALL_CHOICE, description: '全体成员（含主持人）同时收到这句原话，各自回应一次，彼此看不到对方的回答，也不会被分到不同的任务' },
+      { value: NONE_CHOICE, description: '不唤醒任何人' }] };
+}
+
 /**
  * Decide who answers one unnamed free-room message: whether its addressee is already settled by the text or the thread.
  * Members are [{name, description}] without the host; host is {name, description}. Returns action member (with member),
  * all, none, or host for anything unsettled or not confident enough.
  */
 export async function route_free_message(home, scheduler, { title, goal, context, message, host, members }, fetch_impl) {
-  const choices = [...members.map(member => ({ value: member.name, description: member.description })),
-    { value: HOST_CHOICE, description: `主持人 ${host.description}：没有指向任何人且用户没有确定负责人（如单独一句“hi”“你好”这类问候、闲聊，由主持人代表房间回应），或诉求模糊、复杂，需要主持人判断怎么安排` },
-    { value: ALL_CHOICE, description: '全体成员（含主持人）各自回应一次，彼此不需要看到别人的回答；只在要求简单明确、每人独立回应一次就算完成时选，如“大家打个招呼”“各自报一下在用的模型”' },
-    { value: NONE_CHOICE, description: '无需回应：只是确认、致谢或旁注，不需要任何人回答' }];
-  const questions = [{ type: 'choice', name: 'handler', choices,
-    instructions: '这条用户消息没有用 @ 点名成员。判断它的回应对象，按下面的顺序：1）正文叫了某位成员的名字，或在向其提问（包括“X在吗”“X还在吗”“X你怎么看”），选该成员，即使上一条是别人的回答；同时提到几位成员时，选被直接称呼、要求其回应或做事的那位（如“A 你让 B 去改”是在对 A 说）；2）正文没有指向任何人时，看它是否在延续某位成员的回答（追问、要求修改、引用，或“回复”指向其消息），或在补充、纠正一条正由某位成员处理的消息，是则选该成员，是主持人就选主持人；3）查看各成员的用户描述：已经明确由唯一一位成员负责这类任务时，直接选该成员，不需要再次点名；仅有擅长、多人分工重叠或任务还需要拆分时交主持人；4）符合“全体”选项的条件时选全体；要求成员之间讨论或互相回应的不算，按第 7 条处理；5）单独的问候或闲聊（如“hi”）既没有指向某位成员，也没有要求大家一起回应，选主持人；6）只是确认、致谢或旁注选无需回应；7）对象不明确，或要讨论、互相回应、分工、排先后时选主持人，由主持人安排。' }];
-  const roster = [`${host.name}（主持人）`, ...members.map(member => member.name)].join('、');
-  const state = scheduler_state(title, context, message, goal, '', { roster }, ROUTE_CONTEXT_MESSAGES);
+  const { choices, instructions, extra } = route_question(scheduler.mode || DEFAULT_SCHEDULER_MODE, host, members);
+  const questions = [{ type: 'choice', name: 'handler', choices, instructions }];
+  const state = scheduler_state(title, context, message, goal, '', extra, ROUTE_CONTEXT_MESSAGES);
   const answers = await decide(home, scheduler, state, questions, fetch_impl);
   const judged = judged_of(state, questions, answers);
   const choice = answers.handler?.choice ?? null;
@@ -201,13 +266,24 @@ export async function decide_group_order(home, scheduler, { title, goal, context
  * Decide one interjection in a discussion: continue the plan (note), ask one expert (ask) or wake the host (host).
  * Anything but a confident note or ask is returned as host.
  */
-export async function decide_interjection(home, scheduler, { title, goal, user_request, context, message, host, experts, spoken = [], ...extra }, fetch_impl) {
+export async function decide_interjection(home, scheduler, { title, goal, user_request, context, message, host, experts, spoken = [], upcoming = [], ...extra }, fetch_impl) {
+  const guided = (scheduler.mode || DEFAULT_SCHEDULER_MODE) !== 'stable';
   // Ordinary asks do not consume a discussion turn; all present members are eligible.
-  const choices = [...experts.map(name => ({ value: name, description: `请 ${name} 回应这条留言：留言是向该专家（或其负责的内容）提问、质疑或补充要求` })),
-    { value: HOST_CHOICE, description: `由主持人 ${host} 处理：留言要改变讨论目标、规则、分工、安排或结束讨论，同时涉及多位专家，或针对的是不在选项里的人` },
-    { value: NOTE_CHOICE, description: '仅补充信息：留言补充背景、约束或偏好，或只是旁注、鼓励，没有要求某人立即回应；后续发言的专家都能看到它，按当前安排继续' }];
-  const questions = [{ type: 'choice', name: 'handling', instructions: '讨论进行中用户发来这条留言。对照当前焦点、主持简报和安排，判断它最适合怎样处理。', choices }];
-  const state = scheduler_state(title, context, message, goal, user_request, { ...extra, progress: round_progress(spoken, experts.filter(name => !spoken.includes(name))) });
+  const choices = guided
+    ? [...experts.map(name => ({ value: name, description: `现在单独请 ${name} 回应这条留言：不占讨论轮次，多花一次执行` })),
+      { value: HOST_CHOICE, description: `交给主持人 ${host} 处理` },
+      { value: NOTE_CHOICE, description: '按原安排继续：留言留在房间里，后面发言的专家都会看到并可在发言中回应' }]
+    : [...experts.map(name => ({ value: name, description: `请 ${name} 回应这条留言：留言是向该专家（或其负责的内容）提问、质疑或补充要求` })),
+      { value: HOST_CHOICE, description: `由主持人 ${host} 处理：留言要改变讨论目标、规则、分工、安排或结束讨论，同时涉及多位专家，或针对的是不在选项里的人` },
+      { value: NOTE_CHOICE, description: '仅补充信息：留言补充背景、约束或偏好，或只是旁注、鼓励，没有要求某人立即回应；后续发言的专家都能看到它，按当前安排继续' }];
+  const instructions = guided
+    ? '讨论进行中，用户发来上面这条留言。请你像熟悉这场讨论的人一样读懂它，选出最合适的处理方式。'
+      + '用户向某位专家要回应时，现在单独请他回答能马上得到答复，但要多花一次执行；如果他就在接下来要发言的人里，留到他发言时一并回应更省，也不打乱讨论。'
+      + '补充的约束、偏好和鼓励，后面发言的人都看得到。要改目标、规则、分工或安排，或需要几位专家协调的，由主持人处理。'
+    : '讨论进行中用户发来这条留言。对照当前焦点、主持简报和安排，判断它最适合怎样处理。';
+  const questions = [{ type: 'choice', name: 'handling', instructions, choices }];
+  const state = scheduler_state(title, context, message, goal, user_request, { ...extra, progress: round_progress(spoken, experts.filter(name => !spoken.includes(name))),
+    ...(guided ? { guide: DISCUSSION_GUIDED_GUIDE, upcoming } : {}) });
   const answers = await decide(home, scheduler, state, questions, fetch_impl);
   const judged = judged_of(state, questions, answers);
   const choice = answers.handling?.choice;
@@ -244,13 +320,20 @@ export async function decide_review_completion(home, scheduler, ready, fetch_imp
  * this round, or hand back to the host when unsure or when the discussion needs steering.
  */
 export async function decide_next_speaker(home, scheduler, { title, goal, user_request, context, host, candidates, spoken = [], ...extra }, fetch_impl) {
+  const guided = (scheduler.mode || DEFAULT_SCHEDULER_MODE) !== 'stable';
   const recent = context.slice(-CONTEXT_MESSAGES).map(excerpt);
-  const state = [topic_lines(title, goal, user_request, { ...extra, progress: round_progress(spoken, candidates) }), recent.length ? `本轮及最近发言（旧→新）：\n${recent.join('\n')}` : '还没有发言。'].join('\n\n');
+  const state = [topic_lines(title, goal, user_request, { ...extra, progress: round_progress(spoken, candidates), ...(guided ? { guide: DISCUSSION_GUIDED_GUIDE } : {}) }),
+    recent.length ? `本轮及最近发言（旧→新）：\n${recent.join('\n')}` : '还没有发言。'].join('\n\n');
   // Having not spoken yet is no reason to speak: the host's plan may have ended on purpose, so a candidate needs an explicit basis.
-  const choices = [...candidates.map(name => ({ value: name, description: `请 ${name} 接着发言：简报的分工或流程规定轮到 ${name}，或最近的发言点名追问了 ${name}` })),
-    { value: HOST_CHOICE, description: `交给主持人 ${host}：简报和最近发言都没有明确规定下一位（仅仅是本轮还没发言不算依据），或需要主持人重新安排` }];
-  const questions = [{ type: 'choice', name: 'speaker',
-    instructions: '主持人预排的安排已用完或被取消，主持人可能有意只安排到这里。对照主持简报、当前焦点和主持人最近的安排，判断下一位应请谁发言。', choices }];
+  const choices = guided
+    ? [...candidates.map(name => ({ value: name, description: `请 ${name} 接着发言` })), { value: HOST_CHOICE, description: `交给主持人 ${host} 重新安排` }]
+    : [...candidates.map(name => ({ value: name, description: `请 ${name} 接着发言：简报的分工或流程规定轮到 ${name}，或最近的发言点名追问了 ${name}` })),
+      { value: HOST_CHOICE, description: `交给主持人 ${host}：简报和最近发言都没有明确规定下一位（仅仅是本轮还没发言不算依据），或需要主持人重新安排` }];
+  const instructions = guided
+    ? '主持人预排的发言安排已经用完或被取消。主持人有时有意只安排到这里，有时只是还没排下一位。请判断下一位该请谁发言：'
+      + '简报的分工、顺序，或最近有人被点名追问，都说明下一位已经明确；看不出来就交给主持人重新安排，请错人会白花一次执行，还可能违背主持人的安排。'
+    : '主持人预排的安排已用完或被取消，主持人可能有意只安排到这里。对照主持简报、当前焦点和主持人最近的安排，判断下一位应请谁发言。';
+  const questions = [{ type: 'choice', name: 'speaker', instructions, choices }];
   const answers = await decide(home, scheduler, state, questions, fetch_impl);
   const judged = judged_of(state, questions, answers);
   const choice = answers.speaker?.choice;
@@ -268,14 +351,23 @@ export async function decide_round(home, scheduler, { title, goal, user_request,
   const candidates = experts.filter(name => name !== last_speaker);
   if (!candidates.length) return { action: 'host', confidence: null, label: '没有可选的下一轮首位，交给主持人' };
   // Telling repetition or drift needs at least the last two rounds side by side.
+  const guided = (scheduler.mode || DEFAULT_SCHEDULER_MODE) !== 'stable';
   const recent = context.slice(-ROUTE_CONTEXT_MESSAGES).map(excerpt);
-  const state = [topic_lines(title, goal, user_request, extra), recent.length ? `本轮及最近发言（旧→新）：\n${recent.join('\n')}` : '还没有发言。'].join('\n\n');
-  const questions = [{ type: 'choice', name: 'next', instructions: '一轮发言刚结束。对照讨论目标、主持简报与当前焦点判断：下一轮是否还有明确的内容可以让大家互相回应、追问或补充？', choices: [
-    { value: 'continue', description: '继续下一轮：最近发言里有未回应的分歧、追问或可展开的点，或简报规定的流程还没走完' },
-    { value: HOST_CHOICE, description: `交给主持人 ${host}：目标已经达成可以收束，或最近发言在重复、偏离目标、卡住，需要主持人引导` }] }];
-  questions.push({ type: 'choice', name: 'first', instructions: '下一轮应先请谁发言？按简报分工或接龙顺序判断；没有规定时选被其他专家点名追问、需要回应的人；没有明确依据时交主持人安排。',
-    choices: [...candidates.map(name => ({ value: name, description: `先请 ${name}：简报规定下一轮由其开头，或最近发言点名追问了该成员` })),
-      { value: HOST_CHOICE, description: `交给主持人 ${host}：没有明确规定首位，也没有点名追问；仅仅有未决分歧不足以确定先请谁` }] });
+  const state = [topic_lines(title, goal, user_request, guided ? { ...extra, guide: DISCUSSION_GUIDED_GUIDE } : extra),
+    recent.length ? `本轮及最近发言（旧→新）：\n${recent.join('\n')}` : '还没有发言。'].join('\n\n');
+  const questions = guided ? [
+    { type: 'choice', name: 'next', instructions: '一轮发言刚结束。请判断讨论值不值得马上再进行一轮：还有没回应的分歧、追问，或简报规定的流程没走完时，再来一轮能推进讨论；'
+      + '已经达成一致、在重复、偏离目标或卡住时，多一轮只是让每位专家白花一次执行，应交给主持人收束或引导。', choices: [
+      { value: 'continue', description: '直接开始下一轮，每位专家再发言一次' },
+      { value: HOST_CHOICE, description: `交给主持人 ${host} 收束或引导` }] },
+    { type: 'choice', name: 'first', instructions: '如果开始下一轮，先请谁发言？简报规定了顺序，或有人被点名追问、需要先回应时，先请他；看不出依据就交给主持人决定。',
+      choices: [...candidates.map(name => ({ value: name, description: `先请 ${name}` })), { value: HOST_CHOICE, description: `交给主持人 ${host} 决定首位` }] }] : [
+    { type: 'choice', name: 'next', instructions: '一轮发言刚结束。对照讨论目标、主持简报与当前焦点判断：下一轮是否还有明确的内容可以让大家互相回应、追问或补充？', choices: [
+      { value: 'continue', description: '继续下一轮：最近发言里有未回应的分歧、追问或可展开的点，或简报规定的流程还没走完' },
+      { value: HOST_CHOICE, description: `交给主持人 ${host}：目标已经达成可以收束，或最近发言在重复、偏离目标、卡住，需要主持人引导` }] },
+    { type: 'choice', name: 'first', instructions: '下一轮应先请谁发言？按简报分工或接龙顺序判断；没有规定时选被其他专家点名追问、需要回应的人；没有明确依据时交主持人安排。',
+      choices: [...candidates.map(name => ({ value: name, description: `先请 ${name}：简报规定下一轮由其开头，或最近发言点名追问了该成员` })),
+        { value: HOST_CHOICE, description: `交给主持人 ${host}：没有明确规定首位，也没有点名追问；仅仅有未决分歧不足以确定先请谁` }] }];
   const answers = await decide(home, scheduler, state, questions, fetch_impl);
   const judged = judged_of(state, questions, answers);
   const choice = answers.next?.choice;

package/runner/session_driver.mjs

@@ -1,7 +1,7 @@
 /** Smart scheduling and limit checks for a discussion hosted inside a free room. */
 import { readFileSync } from 'node:fs';
 import { api, peer_round_question } from './discussion_runner.mjs';
-import { DISCUSSION_PROMPT_VERSION, ROUTE_CONFIDENCE, ROUTE_CONTEXT_MESSAGES, ROUTE_WIDE_CONFIDENCE, decide_interjection, decide_next_speaker, decide_round } from './scheduler.mjs';
+import { DEFAULT_SCHEDULER_MODE, ROUTE_CONFIDENCE, ROUTE_CONTEXT_MESSAGES, ROUTE_WIDE_CONFIDENCE, decide_interjection, decide_next_speaker, decide_round, discussion_prompt_version } from './scheduler.mjs';
 
 const PACKAGE_VERSION = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8')).version;
 /** How many of the latest plans describe "the host's recent arrangement" to the scheduler. */
@@ -164,8 +164,10 @@ export class SessionDriver {
     if (!message) return null;
     const spoken = turns.filter(turn => turn.round === roster.round && turn.status === 'answered').map(turn => turn.expert);
     const experts = roster.experts.filter(item => item.registered).map(item => item.name);
+    // Who the plan will ask next, in order, so a question to one of them can wait for that turn.
+    const upcoming = turns.filter(turn => ['open', 'queued'].includes(turn.status)).sort((left, right) => Number(left.id || 0) - Number(right.id || 0)).map(turn => turn.expert);
     const result = await decide_interjection(this.config.api_home, this.config.scheduler,
-      { ...base, message, experts, spoken }, this.fetch);
+      { ...base, message, experts, spoken, upcoming }, this.fetch);
     if (result.action === 'note') {
       // Continuing needs a plan to continue; with nothing open or queued the discussion would stall without the host.
       if (turns.some(turn => ['open', 'queued'].includes(turn.status))) return { ...result, action: 'continue', kind: 'interjection', after_message_id: message.id };
@@ -199,7 +201,7 @@ export class SessionDriver {
         confidence: plan.confidence ?? null, applied, provider: this.config.scheduler.provider,
         after_message_id, detail: plan.detail, input: plan.input,
         context: { model: this.config.scheduler.model, threshold: ROUTE_CONFIDENCE, wide_threshold: ROUTE_WIDE_CONFIDENCE,
-          prompt: DISCUSSION_PROMPT_VERSION, package: PACKAGE_VERSION } });
+          mode: this.config.scheduler.mode || DEFAULT_SCHEDULER_MODE, prompt: discussion_prompt_version(this.config.scheduler.mode || DEFAULT_SCHEDULER_MODE), package: PACKAGE_VERSION } });
     } catch (error) { this.log(`智能调度决策记录未保存：${error.message}`); }
   }
 }

package/web/app.js

@@ -2,6 +2,8 @@
 
 const REFRESH_INTERVAL_MS = 60000;
 const FALLBACK_REFRESH_INTERVAL_MS = 12000;
+// The site caps one message batch at 200.
+const MESSAGE_HISTORY_BATCH = 200;
 // A poll reads the room in full only when it changed or an AI is working in it; this full read still comes at least this often.
 const SAFETY_REFRESH_MS = 5 * 60 * 1000;
 const WORKING_STATUSES = ["dispatched", "started"];
@@ -75,6 +77,9 @@ state.reconnecting = false;
 state.attachment_drafts = [];
 state.upload_status = "";
 state.sending_message = false;
+// The message being sent, shown in the transcript as soon as Send is pressed until the site answers;
+// a failed send keeps it in place, marked with its reason, until it is retried or discarded.
+state.sending_preview = null;
 state.attachment_preview = null;
 state.archive_changes = new Map();
 state.archive_version = 0;
@@ -828,7 +833,8 @@ function render_messages(result) {
   state.messages = result.messages.map((message) => {
     const saved = previous.get(message.id);
     const kind = withdrawn.get(message.id) || message.withdrawn || "";
-    if (saved) return (saved.withdrawn || "") === kind ? saved : { ...saved, withdrawn: kind };
+    // A message shown straight from its send response is replaced by the copy the transcript reads.
+    if (saved && !saved.just_sent) return (saved.withdrawn || "") === kind ? saved : { ...saved, withdrawn: kind };
     return { ...message, withdrawn: kind, rendered_text: window.discuss_markdown.render_markdown(message.text),
       rendered_summary: window.discuss_markdown.render_markdown(message.summary || "") };
   });
@@ -852,6 +858,8 @@ async function load_message_history(room_id, version) {
   const params = new URLSearchParams({ q: state.query, withdrawn: "include" });
   if (state.mention_only) params.set("mention", element("author-select").value);
   const key = `${room_id}?${params}`;
+  // Large batches: a long transcript loads in one round-trip, and the site counts the room's messages once, not per batch.
+  params.set("limit", MESSAGE_HISTORY_BATCH);
   const saved = state.message_history?.key === key ? state.message_history.messages : [];
   const messages = [...saved];
   let has_more = true;
@@ -906,6 +914,7 @@ async function select_room(room_id) {
   state.navigation_version++;
   state.refresh_version++;
   state.room = state.rooms.find((room) => room.id === room_id);
+  state.sending_preview = null;
   state.page = 1;
   state.query = "";
   state.mention_only = false;
@@ -927,7 +936,7 @@ async function select_room(room_id) {
   cancel_turn_reply();
   element("turn-form").reset();
   element("message-kind").value = "opinion";
-  select_tab("discussion");
+  select_tab("discussion", { refresh: false });
   history.replaceState(null, "", state.room ? `/?room=${encodeURIComponent(room_id)}` : "/");
   if (state.room) state.archive_view = Boolean(state.room.archived);
   else {
@@ -942,8 +951,8 @@ async function select_room(room_id) {
   await refresh_room();
 }
 
-/** Switch between history, manually maintained state, and participation guidance. */
-function select_tab(tab_name) {
+/** Switch between history, manually maintained state, and participation guidance; `refresh: false` when the caller reads the room itself. */
+function select_tab(tab_name, { refresh = true } = {}) {
   state.navigation_version++;
   state.tab = tab_name;
   document.querySelectorAll("[data-tab]").forEach((tab) => {
@@ -951,7 +960,7 @@ function select_tab(tab_name) {
     tab.setAttribute("aria-selected", String(tab.dataset.tab === tab_name));
   });
   document.querySelectorAll("[data-panel]").forEach((panel) => { panel.hidden = panel.dataset.panel !== tab_name; });
-  if (tab_name === "discussion") run_action(refresh_room);
+  if (tab_name === "discussion" && refresh) run_action(refresh_room);
   publish_view();
 }
 
@@ -1411,8 +1420,14 @@ async function finish_message(result, room_id, drafts) {
   element("search-input").value = "";
   element("mention-filter").setAttribute("aria-pressed", "false");
   state.page = 1;
-  await refresh_room();
+  state.sending_preview = null;
+  // Show the saved message at once; the room, its requests and other new messages follow from a background refresh,
+  // so the composer does not wait for further round-trips on a slow connection.
+  if (!state.messages.some(message => message.id === result.message.id)) {
+    render_messages({ messages: [...state.messages, { ...result.message, just_sent: true }], total: state.message_total + 1, page: 1, pages: 1 });
+  }
   element("messages").scrollTop = element("messages").scrollHeight;
+  run_action(refresh_room);
 }
 
 /** Submit one message; reuse its identifier if a network failure requires a retry. */
@@ -1429,6 +1444,9 @@ async function send_message(event) {
   element("send-message").disabled = true;
   state.sending_message = true;
   element("message-input").disabled = true;
+  state.sending_preview = { author: payload.author, text: payload.text, files: drafts.map(file => file.file.name) };
+  let sent;
+  state.sending_done = new Promise(resolve => { sent = resolve; });
   publish_view();
   try {
     payload.attachment_ids = await upload_message_attachments(room_id, payload.submitted_by, drafts);
@@ -1436,12 +1454,18 @@ async function send_message(event) {
     saved = true;
     await finish_message(result, room_id, drafts);
   } catch (error) {
-    if (state.room?.id === room_id) notify_failure(error, saved
-      ? `留言已保存，但页面刷新失败：${error.message}`
-      : `${error.message}；草稿已保留，可重试发送`);
+    if (state.room?.id !== room_id) throw error;
+    // An unsaved message stays as a failed card in place, the one signal of this failure; the draft is kept for the retry.
+    if (saved) notify_failure(error, `留言已保存，但页面刷新失败：${error.message}`);
+    else {
+      state.sending_preview = { ...state.sending_preview, failed: error.message };
+      error.notified = true;
+    }
     throw error;
   } finally {
     state.sending_message = false;
+    sent();
+    if (!state.sending_preview?.failed) state.sending_preview = null;
     state.upload_status = "";
     element("send-message").disabled = false;
     element("message-input").disabled = false;
@@ -2091,7 +2115,7 @@ async function load_launch_settings() {
     state.launch.saved_profiles = JSON.parse(JSON.stringify(settings.participants || {}));
     Object.assign(state.launch, { available: true, profiles: settings.participants, projects: settings.projects || [], api_providers: settings.api_providers || {}, api_keys: settings.api_keys || {},
       presets: settings.presets || [], builtin_presets: settings.builtin_presets || [], description_templates: settings.description_templates || {},
-      scheduler_providers: settings.scheduler_providers || {}, error: "",
+      scheduler_providers: settings.scheduler_providers || {}, scheduler_modes: settings.scheduler_modes || {}, scheduler_default_mode: settings.scheduler_default_mode || "", error: "",
       notice: relay_machine ? `经电脑「${relay_machine.name}」执行本机操作` : local_connection ? "已连接本机服务，讨论保存在当前网站" : "" });
     Object.values(state.launch.profiles).forEach(fill_api_key);
     if (local_connection) pair_local_machine();
@@ -2396,8 +2420,8 @@ function launch_options() {
 
 /** A new room also carries the optional smart scheduling choice; only a complete, enabled choice is sent. */
 function creation_launch_options() {
-  const { enabled, provider, model, api_key_ref } = state.launch.scheduler;
-  return { ...launch_options(), ...(enabled && provider && model && api_key_ref ? { scheduler: { provider, model, api_key_ref } } : {}) };
+  const { enabled, provider, model, api_key_ref, mode } = state.launch.scheduler;
+  return { ...launch_options(), ...(enabled && provider && model && api_key_ref ? { scheduler: { provider, model, api_key_ref, ...(mode ? { mode } : {}) } } : {}) };
 }
 
 /** Choose whether the new discussion's host writes named follow-ups for each expert between rounds. */
@@ -2428,7 +2452,7 @@ function default_scheduler() {
   const provider = Object.keys(providers).find((name) => state.launch.api_keys?.[providers[name].base_url]);
   if (!provider) return {};
   const { base_url, models } = providers[provider];
-  return { enabled: true, provider, model: models[0] || "", api_key_ref: state.launch.api_keys[base_url] };
+  return { enabled: true, provider, model: models[0] || "", api_key_ref: state.launch.api_keys[base_url], mode: state.launch.scheduler_default_mode || "" };
 }
 
 /** Change the smart scheduling draft; a new provider starts from its preset model and any key saved for its root. */
@@ -2966,6 +2990,40 @@ async function interrupt_member(member_id) {
   if (state.room?.id === room_id) await refresh_room();
 }
 
+/**
+ * How a voided execution's stop really went, from what the runner's adapter reported for it (`capabilities`): stopped
+ * once the runner ended its software, stopping until it says so, and only voided where it cannot stop the software (a
+ * window or App) or never reported (an older runner). See `.dev/docs/Design_适配能力.md`.
+ */
+function stop_label(execution) {
+  if (execution.stop_result === "stopped") return "已停止";
+  if (execution.stop_result === "unconfirmed") return "停止未确认";
+  if (execution.stop_result === "unstoppable") return "已作废";
+  if (!execution.capabilities?.stoppable) return "已作废";
+  return "正在停止";
+}
+
+/** What stopping some executions really did: who is stopping, who may keep generating, and whose software never said. */
+function stop_summary(executions) {
+  const names = items => [...new Set(items.map(item => display_name(item.member)))].join("、");
+  const stopping = executions.filter(item => item.capabilities?.stoppable === true);
+  const unstoppable = executions.filter(item => item.capabilities?.stoppable === false);
+  const unknown = executions.filter(item => !item.capabilities);
+  return [stopping.length ? `正在停止 ${names(stopping)}` : "",
+    unstoppable.length ? `${names(unstoppable)} 在自己的窗口或 App 里本机无法停止，可能仍在生成，之后的回答会被拒收` : "",
+    unknown.length ? `${names(unknown)} 的本次工作已作废` : ""].filter(Boolean).join("；");
+}
+
+/** Stop the whole free room: running work and everything still owed end; a new message starts again. */
+async function stop_room() {
+  const room_id = state.room.id;
+  const live = (state.room.free?.executions || []).filter(item => ["dispatched", "started"].includes(item.status));
+  await request_json(`/api/rooms/${room_id}/stop`, {});
+  // Quiet when everything is stopping; a window or App that keeps generating is said at once.
+  if (live.some(item => !item.capabilities?.stoppable)) notify("warning", stop_summary(live));
+  if (state.room?.id === room_id) await refresh_room();
+}
+
 /** Answer a manual member's waiting retry: deliver now, or stop so the runner fails the execution. */
 async function retry_delivery({ execution_id, action }) {
   const room_id = state.room.id;
@@ -2973,15 +3031,50 @@ async function retry_delivery({ execution_id, action }) {
   if (state.room?.id === room_id) await refresh_room();
 }
 
-/** Take back the user's message before any member handled it; its text returns to an empty input for editing. */
+/** Take back the user's message, its text returning to an empty input for editing; once members started on it, see `stop_and_rewind`. */
 async function retract_message(message_id) {
   const room_id = state.room.id;
-  const result = await request_json(`/api/rooms/${room_id}/messages/${message_id}/retract`, {});
+  let result;
+  try { result = await request_json(`/api/rooms/${room_id}/messages/${message_id}/retract`, {}); }
+  catch (error) {
+    if (error.status !== 409) throw error;
+    result = await stop_and_rewind(room_id, message_id, error);
+  }
   if (state.room?.id !== room_id) return;
   if (!element("message-input").value.trim()) element("message-input").value = result.text;
   await refresh_room();
 }
 
+/**
+ * Take back the latest message members already started on, like interrupting a turn: stop that work and rewind to just
+ * before the message, cutting their sessions. Reads the rewind plan itself and sends its revision; anything wider (a later
+ * message, or running work on other messages) is refused with the site's reason, which points to editing.
+ */
+async function stop_and_rewind(room_id, message_id, refusal) {
+  const [plan, room] = await Promise.all([rewind_plan(message_id), request_json(`/api/rooms/${room_id}`)]);
+  const own = new Set(room.free.requests.filter(item => item.message_id === message_id && item.execution_id).map(item => item.execution_id));
+  const touched = plan.members.filter(member => member.executions.length);
+  if (plan.messages !== 1 || touched.some(member => member.executions.some(id => !own.has(id)))) throw refusal;
+  const taken = new Set(touched.flatMap(member => member.executions));
+  const live = room.free.executions.filter(item => taken.has(item.id) && ["dispatched", "started"].includes(item.status));
+  const text = state.messages.find(message => message.id === message_id)?.text ?? "";
+  await request_json(`/api/rooms/${room_id}/rewind`, { message_id, revision: plan.revision });
+  const kept = touched.filter(member => member.session === "kept").map(member => display_name(member.name));
+  if (live.length) notify("info", `已撤回；${stop_summary(live)}`
+    + `${kept.length ? `；${kept.join("、")} 的会话未回退，仍记得这条消息` : ""}；文件改动不会恢复`);
+  return { text };
+}
+
+/** Take back the owner's latest message, after a send still in flight is saved; the site refuses once a member started on it. */
+async function retract_latest() {
+  if (state.sending_message) {
+    await state.sending_done;
+    if (state.sending_preview?.failed) return;
+  }
+  const message = state.messages.findLast(item => item.author === "用户" && !item.withdrawn);
+  if (message) await retract_message(message.id);
+}
+
 /** What editing a message would take back, with the revision the rewind must carry. */
 function rewind_plan(message_id) {
   return request_json(`/api/rooms/${state.room.id}/rewind?message_id=${message_id}`);
@@ -3796,7 +3889,7 @@ function view_snapshot() {
     directory_pending: [...state.directory_pending.keys()], folder_pending: [...state.folder_moves.keys()], creating_room: state.creating_room,
     connected: state.connected, reconnecting: state.reconnecting, backup_pending: Boolean(state.backup_pending), page: state.page, pages: state.pages, query: state.query,
     attachment_drafts: state.attachment_drafts.map(item => ({ id: item.id, file_name: item.file.name, size: item.file.size, preview_url: item.preview_url })),
-    upload_status: state.upload_status, sending_message: state.sending_message,
+    upload_status: state.upload_status, sending_message: state.sending_message, sending_preview: state.sending_preview,
     mention_only: state.mention_only, reply_to: state.reply_to, turn_reply_to: state.turn_reply_to,
     free_proxy: state.free_proxy,
     create_parent: state.create_parent, access: access_snapshot(), admin: admin_snapshot(),
@@ -3922,12 +4015,12 @@ async function attach_local_members(snapshot, room_id) {
   } catch (error) { throw new Error(`读取本机成员会话失败，未生成备份：${error.message}`); }
 }
 
-/** The website copy of a backup: local paths and sessions stay in the browser, and Claude Code members return as manual. */
+/** The website copy of a backup: keep local data private and apply each adapter's restore policy. */
 function import_body(snapshot) {
   const { local_members, ...body } = snapshot;
   if (local_members?.mode !== "free") return body;
-  const claude = new Set(Object.entries(local_members.participants || {}).filter(([, profile]) => profile.adapter === "claude").map(([name]) => name));
-  const room_members = (body.tables?.room_members || []).map(row => claude.has(row.name) && row.status !== "removed"
+  const manual = new Set(Object.entries(local_members.participants || {}).filter(([, profile]) => window.discuss_backup.adapter_profile(profile.adapter)?.restore_manual).map(([name]) => name));
+  const room_members = (body.tables?.room_members || []).map(row => manual.has(row.name) && row.status !== "removed"
     ? { ...row, access: "manual", adapter: "", session_mode: "new" } : row);
   return { ...body, tables: { ...body.tables, room_members } };
 }
@@ -3939,7 +4032,7 @@ async function restore_local_members(room, token, local_members) {
     const result = await local_launch_request("room-restore", { room_id: room.id, token, local_members });
     return { members: result.members.map(member => ({ name: member.name, failed: member.status === "failed",
       text: member.status === "failed" ? `未恢复：${member.error}` : member.status === "resumed" ? "请回后接续原会话" : "已改为手动接入，请回后在原窗口重新注册",
-      resume: member.status === "manual" && member.session_id ? { command: `claude --resume ${member.session_id}`, cwd: member.cwd } : null })) };
+      resume: member.resume || null })) };
   } catch (error) { return { members: [], problem: `成员会话未恢复：${error.message}` }; }
 }
 
@@ -4004,7 +4097,7 @@ async function execute_view_action(name, value) {
   const event = { preventDefault() {} };
   const actions = { refresh: refresh_room, room: select_room, tab: select_tab,
     archives: toggle_archives, backup: backup_room, backup_rooms, import_rooms, manage_channel, move_channel, create_folder, move_folder, rename_folder, delete_folder, sort_directory,
-    send: () => send_message(event), choose_attachments: () => element("attachment-input").click(), remove_attachment, preview_attachment,
+    send: () => send_message(event), discard_sending: () => { state.sending_preview = null; }, choose_attachments: () => element("attachment-input").click(), remove_attachment, preview_attachment,
     create: (folder_id) => submit_room(event, folder_id),
     save_context: () => save_context(event), save_topic: () => save_topic(event),
     schedule: () => schedule_turn(event), filter: filter_view, reply: set_view_reply,
@@ -4013,7 +4106,7 @@ async function execute_view_action(name, value) {
     copy_online: () => copy_context(), copy_cli: () => copy_context("cli"), copy_background,
     export_runtime, download_member_access, copy_member_access_text, copy_member_join, copy_member_launch: name => copy_member_join(name, true), pause_runtime, check_limits, pause_discussion, restart_discussion, conclude_discussion, start_room_discussion, end_room_discussion, reopen_discussion,
     save_launch_defaults, launch_current_room, resume_launch, discard_launch, retry_launch_connection, check_launch_connection: load_launch_settings,
-    load_room_configuration, save_room_configuration, interrupt_member, retry_delivery, retract_message, rewind_and_send, fork_room, change_member, reorder_speakers, invite_member, set_proxy, copy_online_notice,
+    load_room_configuration, save_room_configuration, interrupt_member, retry_delivery, retract_message, retract_latest, stop_room, rewind_and_send, fork_room, change_member, reorder_speakers, invite_member, set_proxy, copy_online_notice,
     prepare_brainstorm, return_conclusion, adopt_recommendation, rate_decision,
     busy: () => { throw new Error("上一个操作仍在处理中，请稍候；长时间无响应请刷新页面"); },
     copy_reading: () => copy_text(`${location.origin}/r/${state.room.id}`), copy: copy_text };
@@ -4035,7 +4128,7 @@ function change_view_theme(theme) {
 window.discuss_view = { snapshot: view_snapshot, write_field: write_view_field, notify,
   write_launch: write_launch_field, default_launch_entry, description_template, save_description_template, description_draft, write_description_draft, describe_member, set_chain_rounds, continue_chain, expert_presets, apply_expert_preset, unique_instance, member_label, preset_identity, save_expert_preset, delete_expert_preset, write_room_connection, write_room_adapter, launch_clients: LAUNCH_CLIENTS,
   launch_model_state, load_launch_models, write_launch_model, save_launch_api_key, write_scheduler, save_scheduler_api_key, check_scheduler, write_named_followup, write_create_discussion, write_create_chain_rounds, check_launch_api, launch_summary, launch_can_set_access, pick_launch_directory, browse_local_directory, save_launch_projects, restore_launch_profile, reset_create_form, empty_discussion_message,
-  start_drag: start_directory_drag, reconnect: reconnect_live_updates,
+  start_drag: start_directory_drag, reconnect: reconnect_live_updates, stop_label,
   attachment_markup, attachment_size, attachment_file_icon, drop_attachments, paste_attachments,
   write_expert: write_view_expert, add_instance: add_view_instance, add_preset: add_preset_instance, platform_of, execute: execute_view_action, theme: change_view_theme,
   admin: { register: register_admin, login: login_admin, logout: logout_admin,