ai_co_discuss 0.3.12 → 0.3.14

package/backend/free_room.py

@@ -1727,6 +1727,8 @@ def route_wide(connection, room_id, message_id, payload):
         return route_group(connection, room_id, group, payload)
     if action in ("sequential", "host"):
         raise ValueError("只有请全体成员回应的消息可以依次回答或交回主持人")
+    if action not in ("all", "none", "some"):
+        raise ValueError("未点名消息只能选 action=all、some 或 none")
     route = host_route_request(connection, message_id)
     if not route or route["room_id"] != room_id:
         raise LookupError("只能处理交给主持人的未点名消息")
@@ -1735,6 +1737,8 @@ def route_wide(connection, room_id, message_id, payload):
     if action == "none":
         record_cancel_reasons(connection, "id=?", (route["id"],), "no_reply")
         connection.execute("UPDATE member_requests SET status='cancelled' WHERE id=?", (route["id"],))
+    elif action == "some":
+        route_some(connection, room_id, route, payload.get("members"))
     else:
         # The host keeps its row (one request per message and member) and now answers its own share, without dispatching.
         connection.execute("UPDATE member_requests SET purpose='all' WHERE id=?", (route["id"],))
@@ -1745,6 +1749,28 @@ def route_wide(connection, room_id, message_id, payload):
     return {"action": action, "requests": [dict(row) for row in requests]}
 
 
+def route_some(connection, room_id, route, names):
+    """Smart scheduling answers an unnamed message with the few members it names, each once, as if the user named them."""
+    if not isinstance(names, list) or not all(isinstance(name, str) for name in names) or len(set(names)) < 2:
+        raise ValueError("action=some 须带 members：至少两位不同的成员名")
+    found = {row["name"]: row["id"] for row in connection.execute(
+        f"SELECT id,name FROM room_members WHERE room_id=? AND status='active' AND {REGISTERED_MEMBER}", (room_id,))}
+    missing = [name for name in dict.fromkeys(names) if name not in found]
+    if missing:
+        raise FileExistsError(f"这些成员不在场或未注册：{'、'.join(missing)}")
+    ids = [found[name] for name in dict.fromkeys(names)]
+    if route["member_id"] in ids:
+        # The host is one of them: it keeps its row and answers its own share, without dispatching.
+        connection.execute("UPDATE member_requests SET purpose='all' WHERE id=?", (route["id"],))
+    else:
+        record_cancel_reasons(connection, "id=?", (route["id"],), "rerouted")
+        connection.execute("UPDATE member_requests SET status='cancelled' WHERE id=?", (route["id"],))
+    for member_id in ids:
+        if member_id != route["member_id"]:
+            connection.execute("""INSERT OR IGNORE INTO member_requests (room_id,member_id,message_id,chain_id,purpose,created_by,created_at)
+                VALUES (?,?,?,?,'all','user',?)""", (room_id, member_id, route["message_id"], route["message_id"], int(time.time())))
+
+
 def adopt_recommendation(connection, room_id, token, message_id, payload):
     """The user adopts a recommendation before it expires: interrupt the host now, or ask the member after the host.
 
@@ -1752,10 +1778,10 @@ def adopt_recommendation(connection, room_id, token, message_id, payload):
     """
     require_owner(connection, room_id, token)
     begin_write(connection)
-    if payload.get("action") in ("all", "none", "sequential", "host"):
+    if payload.get("action") in ("all", "none", "sequential", "host", "some"):
         return route_wide(connection, room_id, message_id, payload)
     if payload.get("action") != "adopt" or payload.get("mode") not in ("interrupt", "after"):
-        raise ValueError("采纳须为 action=adopt，mode 为 interrupt 或 after；全体、依次或无需回应为 action=all、sequential 或 none")
+        raise ValueError("采纳须为 action=adopt，mode 为 interrupt 或 after；全体、依次、指定几位或无需回应为 action=all、sequential、some 或 none")
     row = connection.execute("SELECT * FROM member_recommendations WHERE room_id=? AND message_id=?", (room_id, message_id)).fetchone()
     if not row:
         raise LookupError("这条消息没有智能调度推荐")

package/docs/runner.md

@@ -65,7 +65,7 @@ API 成员可以担任专家或主持人，只有房间读写工具，不访问
 
 ## 智能调度（可选）
 
-建房时在“智能调度”下选择供应商并填写密钥，需要连接本机服务。作用见 [使用指南](workflow.md#智能调度)。
+建房时在“智能调度”下选择供应商并填写密钥，需要连接本机服务。卡片下方的“判断方式”可选“引导（试验）”（默认，正在打磨）或“稳定”（已通过回归评测），影响未点名消息的分派和讨论中的插话、下一位发言、下一轮判断。作用见 [使用指南](workflow.md#智能调度)。
 
 翻开成员卡片，“提示”一行可以给这位专家单独写几句要求，例如“回答先给结论”。它只发给这位专家，不改变权限；部分软件带有预设，可随时恢复。卡片背面的书签图标把这张卡片的描述、提示词、项目权限、模型与强度存为专家预设，之后在“添加”行一键加入，见 [使用指南](workflow.md#成员管理)。
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai_co_discuss",
-  "version": "0.3.12",
+  "version": "0.3.14",
   "bin": {
     "codiscuss": "runner/codiscuss.mjs"
   },

package/runner/discussion_launch.mjs

@@ -14,7 +14,7 @@ import { setup_sidecar } from './adapters/antigravity_app.mjs';
 import { adapter_of, adoption_adapter, BRANCHABLE_ADAPTERS, branch_session, session_settings, software_defaults, software_effort, software_models } from './adapters/index.mjs';
 import { ADAPTER_IDS, ADAPTER_PROFILES, adapter_profile, platform_adapters, same_session_family } from './adapters/profiles.mjs';
 import { API_PROVIDERS, api_check, api_models, save_api_key, saved_api_keys, validate_api_profile } from './discussion_api.mjs';
-import { SCHEDULER_PROVIDERS, scheduler_check } from './scheduler.mjs';
+import { DEFAULT_SCHEDULER_MODE, SCHEDULER_MODES, SCHEDULER_PROVIDERS, scheduler_check } from './scheduler.mjs';
 import { access_levels, BUILTIN_EXPERT_PRESETS, MAX_EXPERT_PROMPT, PROJECT_ACCESS } from './expert_prompts.mjs';
 import { acquire_lock, api, DiscussionStore, service_drafts, validate_config } from './discussion_runner.mjs';
 import { FreeRoomRunner, free_task_files } from './free_runner.mjs';
@@ -285,7 +285,7 @@ export async function room_models(home, raw, { read_defaults = software_defaults
       own_project: Boolean(facts?.own_project_when_bound && profile.session_id) }];
   })));
   // Smart scheduling is a local choice; only which model decides is shown, never its key.
-  const scheduler = config.scheduler ? { provider: config.scheduler.provider, model: config.scheduler.model } : null;
+  const scheduler = config.scheduler ? { provider: config.scheduler.provider, model: config.scheduler.model, mode: config.scheduler.mode || DEFAULT_SCHEDULER_MODE } : null;
   return { room_id: input.room_id, registered: paths.length > 0, participants, scheduler };
 }
 
@@ -1232,7 +1232,7 @@ export async function launch_main(args = process.argv.slice(2), input_text) {
   assert_shared_home(home);
   let result;
   if (positionals[0] === 'settings') result = { ...(input ? save_launch_settings(home, input) : launch_settings(home)), api_providers: API_PROVIDERS,
-    scheduler_providers: SCHEDULER_PROVIDERS, api_keys: saved_api_keys(home), projects: launch_projects(home).projects, ...expert_presets(home) };
+    scheduler_providers: SCHEDULER_PROVIDERS, scheduler_modes: SCHEDULER_MODES, scheduler_default_mode: DEFAULT_SCHEDULER_MODE, api_keys: saved_api_keys(home), projects: launch_projects(home).projects, ...expert_presets(home) };
   else if (positionals[0] === 'projects') result = input ? save_launch_projects(home, input) : launch_projects(home);
   else if (positionals[0] === 'presets') result = input ? save_expert_presets(home, input) : expert_presets(home);
   else if (positionals[0] === 'api-key' && input) result = save_api_key(home, input);

package/runner/free_runner.mjs

@@ -9,7 +9,7 @@ import { SegmentLog } from './execution_progress.mjs';
 import { free_task_text, TASK_SUBCOMMANDS, with_expert_prompt } from './expert_prompts.mjs';
 import { atomic_json } from './files.mjs';
 import { SessionDriver } from './session_driver.mjs';
-import { REVIEW_CONFIDENCE, REVIEW_PROMPT_VERSION, ROUTE_CONFIDENCE, ROUTE_CONTEXT_MESSAGES, ROUTE_PROMPT_VERSION, ROUTE_WIDE_CONFIDENCE, decide_group_order, decide_review_completion, route_free_message } from './scheduler.mjs';
+import { DEFAULT_SCHEDULER_MODE, REVIEW_CONFIDENCE, REVIEW_PROMPT_VERSION, ROUTE_CONFIDENCE, ROUTE_CONTEXT_MESSAGES, ROUTE_PROMPT_VERSION, ROUTE_WIDE_CONFIDENCE, decide_group_order, decide_review_completion, route_free_message, route_prompt_version, scheduler_thresholds, some_members } from './scheduler.mjs';
 
 const PACKAGE_VERSION = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8')).version;
 const RENEW_MS = 30_000;
@@ -142,7 +142,8 @@ function member_work(requests, name, message_id) {
 /** Why a message stayed with the host: the scheduler chose the host, or leaned elsewhere without enough certainty. */
 function route_host_label(decision, host, members) {
   if (decision.choice === '__host__' || decision.confidence === null) return `交给主持人 ${host}`;
-  const lean = decision.choice === '__all__' ? '全体各自回应' : decision.choice === '__none__' ? '无需回应'
+  const group = some_members(decision.choice);
+  const lean = decision.choice === '__all__' ? '全体各自回应' : decision.choice === '__none__' ? '无需回应' : group ? `请 ${group.join('、')} 各自回应`
     : members.some(member => member.name === decision.choice) ? `请 ${decision.choice} 回答` : '';
   return lean ? `倾向${lean}，把握不足，交给主持人 ${host}` : `交给主持人 ${host}`;
 }
@@ -451,7 +452,8 @@ export class FreeRoomRunner {
     let record;
     if (decision.detail) {
       if (result.status === 'failed') label += '（未生效，网站写入失败）';
-      record = await this.record_decision(request.message_id, decision, label, result.applied && decision.action !== 'host');
+      // The @全体成员 question has one wording in every mode.
+      record = await this.record_decision(request.message_id, decision, label, result.applied && decision.action !== 'host', { prompt: ROUTE_PROMPT_VERSION, threshold: ROUTE_CONFIDENCE, wide_threshold: ROUTE_WIDE_CONFIDENCE });
     }
     this.save_suggestion(request, { action: decision.action, actual_action,
       applied: result.applied && decision.action !== 'host', model_judgment: Boolean(decision.detail),
@@ -481,7 +483,10 @@ export class FreeRoomRunner {
       const work = member_work(requests, member.name, message_id);
       const profile = this.config.participants[member.name];
       const described = room.descriptions?.[member.name] ? `；用户描述：${room.descriptions[member.name]}` : '';
-      return { id: member.id, name: member.name, role: member.role, description: profile ? member_description(member.name, profile, `${work}${described}`)
+      // The model and the last finished message are only read by the guided wording.
+      const finished = (room.free?.requests || []).filter(item => item.member === member.name && item.status === 'completed' && item.message_id !== message_id).at(-1);
+      return { id: member.id, name: member.name, role: member.role, model: profile?.model || '', finished: finished ? `#${finished.message_id}` : '',
+        description: profile ? member_description(member.name, profile, `${work}${described}`)
         : `${member.name}（${member.access === 'online' ? '网页 AI' : '手动接入'}，由用户代为触发${work}${described}）` };
     });
   }
@@ -517,11 +522,11 @@ export class FreeRoomRunner {
     this.log(`智能调度 #${message.id}：${decision.action}${decision.member ? ` ${decision.member}` : ''}（选择 ${decision.choice ?? '-'}，置信度 ${decision.confidence ?? '-'}）`);
     if (decision.action === 'host') return this.record_route(request, decision, route_host_label(decision, host.name, members), false);
     if (decision.action !== 'member') {
-      // Everyone or no one replaces the host's request in one step; a host that already started keeps the message.
-      const applied = await api(this.config, `/recommendations/${message.id}`, { action: decision.action })
+      // Everyone, the named few or no one replaces the host's request in one step; a host that already started keeps the message.
+      const applied = await api(this.config, `/recommendations/${message.id}`, { action: decision.action, ...(decision.members ? { members: decision.members } : {}) })
         .then(() => true, error => { this.log(`智能调度 #${message.id} 未能改派：${error.message}`); return false; });
       const names = described.map(member => member.name).join('、');
-      const label = decision.action === 'all' ? `请全体各自回应（${names}）` : '无需回应，未唤醒任何成员';
+      const label = decision.action === 'all' ? `请全体各自回应（${names}）` : decision.action === 'some' ? `请 ${decision.members.join('、')} 各自回应` : '无需回应，未唤醒任何成员';
       return this.record_route(request, decision, applied ? label : `${label}（未生效，仍由主持人处理）`, applied);
     }
     try {
@@ -538,11 +543,12 @@ export class FreeRoomRunner {
   }
   /** Show each judgment under its message so the user can rate it; a failed record never affects delivery. */
   async record_decision(message_id, decision, label, applied, context = {}) {
+    const limits = scheduler_thresholds(this.config.scheduler.mode || DEFAULT_SCHEDULER_MODE);
     try {
       return await api(this.config, '/scheduler-decisions', { kind: 'interjection', label, confidence: decision.confidence ?? null,
         applied, provider: this.config.scheduler.provider, after_message_id: message_id, detail: decision.detail, input: decision.input,
-        context: { model: this.config.scheduler.model, threshold: ROUTE_CONFIDENCE, wide_threshold: ROUTE_WIDE_CONFIDENCE,
-          prompt: ROUTE_PROMPT_VERSION, package: PACKAGE_VERSION, ...context } });
+        context: { model: this.config.scheduler.model, threshold: limits.member, wide_threshold: limits.wide,
+          mode: this.config.scheduler.mode || DEFAULT_SCHEDULER_MODE, prompt: route_prompt_version(this.config.scheduler.mode || DEFAULT_SCHEDULER_MODE), package: PACKAGE_VERSION, ...context } });
     } catch (error) { this.log(`智能调度 #${message_id} 决策记录未保存：${error.message}`); }
   }
   /** Reserve with a persisted client id before invoking any software. */

package/runner/scheduler.mjs

@@ -11,10 +11,38 @@ const REQUEST_TIMEOUT_MS = 30_000;
 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;
+/**
+ * The guided wording gives lower probabilities for the same correct pick, so it has its own thresholds, set where the
+ * regression set gains correct picks without any new wrong one (2026-10-31). @全体成员 and review keep their own.
+ */
+export const GUIDED_CONFIDENCE = 0.6;
+export const GUIDED_WIDE_CONFIDENCE = 0.8;
+/** The single-member and the everyone-or-no-one thresholds of one wording. */
+export function scheduler_thresholds(mode) {
+  return mode === 'stable' ? { member: ROUTE_CONFIDENCE, wide: ROUTE_WIDE_CONFIDENCE } : { member: GUIDED_CONFIDENCE, wide: GUIDED_WIDE_CONFIDENCE };
+}
 /** 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 = 13;
+/**
+ * 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 = 7;
+/** 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 = 2;
+/** 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;
@@ -23,19 +51,34 @@ const HOST_CHOICE = '__host__';
 const NOTE_CHOICE = '__note__';
 const ALL_CHOICE = '__all__';
 const NONE_CHOICE = '__none__';
+/** Prefix of the "only these few" options; the value lists the names after it, joined by SOME_JOINER. */
+export const SOME_PREFIX = '__some__:';
+const SOME_JOINER = '、';
+/** At most this many named members are combined, so the options stay few (4 names give 11 groups). */
+const MAX_SOME_NAMES = 4;
 const CONTEXT_MESSAGES = 10;
 /** A free-room route sees a longer stretch, enough to tell who has not spoken for a while. */
 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 +168,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,28 +208,76 @@ 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 = '用户发来上面这条消息，没有 @ 任何人。请你像熟悉这个房间的成员一样读懂它：用户想让谁来回应？'
+  + '用户心里已经有明确的对象时，直接交给对方，省掉主持人转一手的时间；需要有人先理解、拆分或协调时交给主持人。'
+  + '用户想听每个人各自说一句时，交给全体能让大家同时开始，比主持人逐个点名快得多；但大家看不到彼此的回答，需要互相接话、讨论的事仍要主持人安排。用户只是表示收到或感谢时，不必唤醒任何人。'
+  + '两种容易看错的情况：向在场的各位问好，是在等每个人回一声，和只对房间说一句“hi”不同；用户问“谁是……”“谁能……”时是在找符合条件的人，只需要符合的人出来回应（哪怕说“自己说一下”），成员信息里（含主持人）只有一位符合就交给他。';
+
+/** The routing question in one mode: option texts, the stem, and what the state adds about the members. */
+/** Every group of two or more among the members the text names, so "these few each answer" is one choice. */
+function named_groups(text, host, members) {
+  const lower = String(text || '').toLowerCase();
+  const named = [host, ...members].map(member => member.name).filter(name => lower.includes(name.toLowerCase()));
+  if (named.length < 2 || named.length > MAX_SOME_NAMES) return [];
+  const groups = [];
+  for (let mask = 1; mask < 1 << named.length; mask += 1) {
+    const group = named.filter((_, index) => mask & (1 << index));
+    if (group.length >= 2) groups.push(group);
+  }
+  return groups;
+}
+/** The members of a "these few" choice, or null for any other value. */
+export function some_members(choice) {
+  return typeof choice === 'string' && choice.startsWith(SOME_PREFIX) ? choice.slice(SOME_PREFIX.length).split(SOME_JOINER) : null;
+}
+
+function route_question(mode, host, members, text) {
+  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}：由他回应，或由他安排别人` },
+      ...named_groups(text, host, members).map(group => ({ value: `${SOME_PREFIX}${group.join(SOME_JOINER)}`,
+        description: `只请 ${group.join('、')} 各自回应一次：同时开始，每人都收到这句原话，彼此看不到对方的回答，其他成员不被唤醒` })),
+      { 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, message.text);
+  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;
   const confidence = certainty(answers.handler);
-  const wide = choice === ALL_CHOICE || choice === NONE_CHOICE;
-  const sure = confidence !== null && confidence >= (wide ? ROUTE_WIDE_CONFIDENCE : ROUTE_CONFIDENCE);
+  // Waking several members, everyone or no one costs more when wrong than moving the message to one member.
+  const group = some_members(choice);
+  const wide = choice === ALL_CHOICE || choice === NONE_CHOICE || Boolean(group);
+  const limits = scheduler_thresholds(scheduler.mode || DEFAULT_SCHEDULER_MODE);
+  const sure = confidence !== null && confidence >= (wide ? limits.wide : limits.member);
   if (sure && choice === ALL_CHOICE) return { action: 'all', choice, confidence, ...judged };
   if (sure && choice === NONE_CHOICE) return { action: 'none', choice, confidence, ...judged };
+  if (sure && group) return { action: 'some', members: group, choice, confidence, ...judged };
   if (sure && members.some(item => item.name === choice)) return { action: 'member', member: choice, choice, confidence, ...judged };
   return { action: 'host', choice, confidence, ...judged };
 }
@@ -201,18 +305,29 @@ 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;
   const confidence = certainty(answers.handling);
-  const sure = confidence !== null && confidence >= ROUTE_CONFIDENCE;
+  const sure = confidence !== null && confidence >= scheduler_thresholds(scheduler.mode || DEFAULT_SCHEDULER_MODE).member;
   if (sure && choice === NOTE_CHOICE) return { action: 'note', confidence, ...judged, label: '仅补充信息，按原计划继续' };
   if (sure && experts.includes(choice)) return { action: 'ask', expert: choice, confidence, ...judged, label: `先请 ${choice} 回应这条留言` };
   const lean = choice === NOTE_CHOICE ? '按原计划继续' : experts.includes(choice) ? `请 ${choice} 回应` : choice === HOST_CHOICE ? '由主持人处理' : '';
@@ -244,18 +359,25 @@ 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;
   const confidence = certainty(answers.speaker);
-  const sure = confidence !== null && confidence >= ROUTE_CONFIDENCE;
+  const sure = confidence !== null && confidence >= scheduler_thresholds(scheduler.mode || DEFAULT_SCHEDULER_MODE).member;
   if (sure && candidates.includes(choice)) return { action: 'next', expert: choice, confidence, ...judged, label: `本轮继续，请 ${choice} 接着发言` };
   return { action: 'host', confidence, ...judged, label: choice === HOST_CHOICE && sure ? '没有明确该谁发言，交给主持人安排' : unsure_label(candidates.includes(choice) ? `请 ${choice} 发言` : choice === HOST_CHOICE ? '交给主持人' : '') };
 }
@@ -268,26 +390,36 @@ 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;
   const confidence = certainty(answers.next);
   // A wrong "continue" costs a whole round of runs, so it needs the same certainty as waking everyone.
-  if (choice !== 'continue' || confidence === null || confidence < ROUTE_WIDE_CONFIDENCE) {
-    const sure = confidence !== null && confidence >= (choice === 'continue' ? ROUTE_WIDE_CONFIDENCE : ROUTE_CONFIDENCE);
+  const limits = scheduler_thresholds(scheduler.mode || DEFAULT_SCHEDULER_MODE);
+  if (choice !== 'continue' || confidence === null || confidence < limits.wide) {
+    const sure = confidence !== null && confidence >= (choice === 'continue' ? limits.wide : limits.member);
     return { action: 'host', confidence, ...judged, label: choice === HOST_CHOICE && sure ? '建议收束或调整方向，交给主持人' : unsure_label(choice === 'continue' ? '继续下一轮' : choice === HOST_CHOICE ? '收束或调整方向' : '') };
   }
   const first = answers.first?.choice;
   const first_confidence = certainty(answers.first);
-  if (!candidates.includes(first) || first_confidence === null || first_confidence < ROUTE_CONFIDENCE) {
+  if (!candidates.includes(first) || first_confidence === null || first_confidence < limits.member) {
     return { action: 'host', confidence: first_confidence, ...judged, label: '下一轮首位没有明确依据或把握不足，交给主持人安排' };
   }
   return { action: 'continue', first, confidence, ...judged, label: `继续下一轮，先请 ${first} 发言` };

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_CONTEXT_MESSAGES, scheduler_thresholds, 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 };
@@ -198,8 +200,9 @@ export class SessionDriver {
       return await api(this.config, '/scheduler-decisions', { kind: plan.kind, label: plan.label,
         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 } });
+        context: { model: this.config.scheduler.model, threshold: scheduler_thresholds(this.config.scheduler.mode || DEFAULT_SCHEDULER_MODE).member,
+          wide_threshold: scheduler_thresholds(this.config.scheduler.mode || DEFAULT_SCHEDULER_MODE).wide,
+          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

@@ -2115,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();
@@ -2420,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. */
@@ -2452,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. */
@@ -3264,6 +3264,11 @@ async function rate_decision({ decision_id, rating, should_be = "", note = "" })
   if (state.room?.id === room_id) await refresh_room();
 }
 
+/** Read what the decision model was given for one decision (state and questions), for the card's input view. */
+async function load_decision_input(decision_id) {
+  return request_json(`/api/rooms/${state.room.id}/scheduler-decisions/${decision_id}`);
+}
+
 /** A completed creation starts the next form with fresh mode defaults. */
 function reset_creation_mode() {
   state.creation_mode = "free";
@@ -4107,7 +4112,7 @@ async function execute_view_action(name, value) {
     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, 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,
+    prepare_brainstorm, return_conclusion, adopt_recommendation, rate_decision, load_decision_input,
     busy: () => { throw new Error("上一个操作仍在处理中，请稍候；长时间无响应请刷新页面"); },
     copy_reading: () => copy_text(`${location.origin}/r/${state.room.id}`), copy: copy_text };
   try {