ai_co_discuss 0.2.32 → 0.2.33

package/runner/discussion_runner.mjs

@@ -9,7 +9,7 @@ import { parseArgs } from 'node:util';
 import { setTimeout as sleep } from 'node:timers/promises';
 import { atomic_json, deliver_task, remove_agy_projects, setup_sidecar, sidecar_receipt, TASK_SUBCOMMANDS } from './discussion_adapters.mjs';
 import { read_api_key } from './discussion_api.mjs';
-import { suggest_interjection, validate_scheduler } from './scheduler.mjs';
+import { decide_interjection, decide_round, validate_scheduler } from './scheduler.mjs';
 
 const POLL_MS = 2000;
 /** Headless CLIs know their session at start, so the runner enters the execution instead of spending model turns on it. */
@@ -29,6 +29,23 @@ export const CODEX_ADAPTERS = ['codex', 'codex_cli'];
 const REPO_ROOT = dirname(dirname(fileURLToPath(import.meta.url)));
 /** Project files in cwd are read-only unless the launch or participant explicitly grants write. */
 const PROJECT_ACCESS = ['read', 'write'];
+const ACTIVE_PHASES = ['initial', 'discussing', 'reviewing'];
+const MAX_PLAN_TURNS = 10;
+const CONTEXT_MESSAGES = 12;
+/** Session recorded when smart scheduling performs the host's writes without waking its software. */
+const SCHEDULER_SESSION = 'smart-scheduler';
+const MAX_QUOTE_CHARS = 300;
+
+/** The shared prompt for rounds bridged without named follow-ups: experts answer and question each other. */
+export function peer_round_question(round) {
+  return `第 ${round} 轮：先读取上一轮其他专家的最新回答，回应你不同意或需要补充的观点；被其他专家 @ 提问时优先回答，也可以 @ 某位专家提出问题。`;
+}
+
+/** Ask one expert to answer a user's interjection before the rest of the plan continues. */
+function interjection_question(message) {
+  const text = String(message.text || '').replace(/\s+/g, ' ').trim();
+  return `用户在 #${message.id} 留言：「${text.length > MAX_QUOTE_CHARS ? `${text.slice(0, MAX_QUOTE_CHARS)}…` : text}」请先读取原文并回应这条留言，再继续你的观点。`;
+}
 
 /** Explicit per-room configuration is the only source of software paths and capabilities. */
 export function load_config(path) {
@@ -180,7 +197,7 @@ export function acquire_lock(directory) {
 }
 
 /** Write a non-secret task separately from its CLI-only credential file; suggestions are smart-scheduling hints for the host. */
-export function task_files(config, event, token, binding, suggestions = []) {
+export function task_files(config, event, token, binding, suggestions = [], entered = false) {
   const id = `event-${event.id}`;
   const draft_directory = config.draft_directory || `${config.directory}-drafts`;
   mkdirSync(draft_directory, { recursive: true });
@@ -190,7 +207,7 @@ export function task_files(config, event, token, binding, suggestions = []) {
   const skills = [join(config.project, '.agents/skills/discuss-participant/SKILL.md')];
   if (event.role === 'host') skills.push(join(config.project, '.agents/skills/discuss-host/SKILL.md'));
   const adapter = config.participants[event.participant];
-  const auto_enter = AUTO_ENTER_ADAPTERS.has(adapter.adapter);
+  const auto_enter = entered || AUTO_ENTER_ADAPTERS.has(adapter.adapter);
   const skills_directory = join(config.project, '.agents', 'skills');
   // Codex and agy run commands through PowerShell on Windows, whose execution policy blocks npm's codiscuss.ps1 shim.
   const cli = process.platform === 'win32' && adapter.adapter !== 'claude' ? 'codiscuss.cmd' : 'codiscuss';
@@ -216,7 +233,7 @@ ${readFileSync(task_path, 'utf8')}
 
 /** A running dispatcher retains only the processes it created itself. */
 export class DiscussionRunner {
-  constructor(config, store, deliver = deliver_task, log = () => {}) {
+  constructor(config, store, deliver = deliver_task, log = () => {}, fetch_impl = fetch) {
     this.config = config;
     this.store = store;
     this.deliver = deliver;
@@ -226,7 +243,7 @@ export class DiscussionRunner {
     this.running = new Map();
     this.seen = new Set();
     this.blocked = new Set();
-    this.suggestions = new Map();
+    this.fetch = fetch_impl;
   }
   /** Append one timestamped stage to the event's trace file when CODISCUSS_TRACE=1; tracing must never affect delivery. */
   trace(id, stage, detail = {}) {
@@ -235,33 +252,34 @@ export class DiscussionRunner {
     catch { /* Diagnostics only. */ }
   }
   /** Reserve with a durable token so a lost HTTP response can be reconciled. */
-  async dispatch(row, event) {
+  async dispatch(row, event, options = {}) {
     const token = row.token || randomUUID();
     this.store.record(row.id, { token, status: 'reserving' });
     this.log(`派发 #${row.id} → ${event.participant}（${event.role}，turn ${event.turn_id ?? '-'}）`);
     this.trace(row.id, 'reserve_start');
     await api(this.config, `/events/${row.id}`, { action: 'reserve', execution_token: token });
     this.trace(row.id, 'reserve_done');
-    await this.deliver_reserved({ ...row, token }, event);
+    await this.deliver_reserved({ ...row, token }, event, options);
   }
-  /** Retry only proven non-delivery, keeping the event, token and task unchanged. */
-  async deliver_reserved(row, event) {
+  /**
+   * Retry only proven non-delivery, keeping the event, token and task unchanged. `entered` marks an execution
+   * smart scheduling already entered before handing it back, so the software must not enter it again.
+   */
+  async deliver_reserved(row, event, { suggestions = [], entered: pre_entered = false } = {}) {
     const adapter = this.config.participants[event.participant];
     if (!adapter) throw new Error(`未配置 ${event.participant} 的本机接入`);
     const binding = this.store.binding(event.participant);
     if (!binding.session_id && adapter.session_id) binding.session_id = adapter.session_id;
     const attempts = row.attempts + 1;
-    // Ask before recording the dispatch, so a slow or failed suggestion never leaves an uncertain delivery behind.
-    const suggestions = event.role === 'host' ? await this.interjection_suggestions() : [];
     this.store.record(row.id, { status: 'dispatching', sent_at: Date.now(), attempts, error: '', retry_at: 0 });
     let invoked = false;
-    let entered = false;
+    let entered = pre_entered;
     try {
-      const task = task_files(this.config, event, row.token, binding, suggestions);
+      const task = task_files(this.config, event, row.token, binding, suggestions, pre_entered);
       invoked = true;
       const result = await this.deliver(adapter, binding, { ...task, room_title: this.room_title,
         api_context: { site: this.config.site, room: this.config.room, token: row.token, home: this.config.api_home,
-          event_id: row.id, role: event.role, turn_id: event.turn_id, scheduler_suggestions: suggestions },
+          event_id: row.id, role: event.role, turn_id: event.turn_id, scheduler_suggestions: suggestions, entered: pre_entered },
         on_trace: (stage, detail) => this.trace(row.id, stage, detail),
         on_binding: session => {
           this.store.bind(event.participant, session);
@@ -283,31 +301,91 @@ export class DiscussionRunner {
     }
   }
   /**
-   * With smart scheduling on, suggest how to handle each user message the host has not processed yet.
-   * Suggestions never act on the room; any failure only leaves the host without them.
+   * Smart scheduling before waking the host: decide read-only first; only a confident decision reserves the host's
+   * execution, enters it and performs the host's own writes with that credential. Returns {done} when the host
+   * need not be woken, otherwise the suggestions to hand over. Every decision is recorded for the transcript.
    */
-  async interjection_suggestions() {
-    if (!this.config.scheduler) return [];
+  async smart_schedule(row, event) {
+    if (!this.config.scheduler) return {};
+    let plan;
+    try { plan = await this.plan_schedule(); }
+    catch (error) { this.log(`智能调度判断失败，交给主持人：${error.message}`); return {}; }
+    if (!plan) return {};
+    const suggestions = plan.message_id ? [{ message_id: plan.message_id, suggestion: plan.label, confidence: plan.confidence }] : [];
+    if (plan.action === 'host') {
+      await this.record_decision(plan, false);
+      return { suggestions };
+    }
+    const token = randomUUID();
+    this.store.record(row.id, { token, status: 'reserving' });
+    await api(this.config, `/events/${row.id}`, { action: 'reserve', execution_token: token });
+    try { await api(this.config, `/events/${row.id}`, { action: 'enter', session_id: SCHEDULER_SESSION }, token); }
+    catch (error) {
+      this.log(`智能调度进入执行失败，交给主持人：${error.message}`);
+      await this.deliver_reserved({ ...row, token }, event, { suggestions });
+      return { done: true };
+    }
+    this.store.record(row.id, { status: 'started', last_renew: Date.now() });
     try {
-      const room = await api(this.config, '');
-      if (!room.held_since) return [];
-      const page = await api(this.config, `/messages?after=${Math.max(0, room.held_since - 11)}`);
-      const experts = Object.keys(room.experts || {}).filter(name => name !== room.host);
-      const suggestions = [];
-      for (const message of page.messages.filter(item => item.id >= room.held_since && item.author === '用户')) {
-        if (!this.suggestions.has(message.id)) {
-          const suggestion = await suggest_interjection(this.config.api_home, this.config.scheduler,
-            { title: room.title, context: page.messages, message, host: room.host, experts });
-          this.suggestions.set(message.id, suggestion);
-          this.log(`智能调度建议 #${message.id}：${suggestion ? `${suggestion.suggestion}（置信度 ${suggestion.confidence}）` : '无可用建议'}`);
-        }
-        if (this.suggestions.get(message.id)) suggestions.push(this.suggestions.get(message.id));
-      }
-      return suggestions;
+      await this.apply_schedule(plan, token);
+      await this.record_decision(plan, true);
+      this.log(`智能调度 #${row.id}：${plan.label}（置信度 ${plan.confidence}）`);
     } catch (error) {
-      this.log(`智能调度建议失败，主持人照常处理：${error.message}`);
-      return [];
+      this.log(`智能调度执行失败，交给主持人：${error.message}`);
+      await this.record_decision({ ...plan, label: `${plan.label}；执行未成功，已交给主持人` }, false);
+      await this.deliver_reserved({ ...row, token }, event, { suggestions, entered: true });
     }
+    return { done: true };
+  }
+  /** Read the room and decide one interjection, or the next round when named follow-ups are off. Null leaves the host alone. */
+  async plan_schedule() {
+    const room = await api(this.config, '');
+    if (room.limits?.reached || !ACTIVE_PHASES.includes(room.phase)) return null;
+    if (room.current_turn && ['pending', 'notified'].includes(room.current_turn.status)) return null;
+    const page = await api(this.config, `/messages?after=${Math.max(0, room.latest_id - CONTEXT_MESSAGES)}`);
+    const experts = Object.keys(room.experts || {});
+    const context = { title: room.title, context: page.messages, host: room.host };
+    if (room.held_since) {
+      const pending = page.messages.filter(item => item.id >= room.held_since && item.author === '用户');
+      // Topic edits and several messages at once need the host's judgement.
+      if (pending.length !== 1) return null;
+      const message = pending[0];
+      const decision = await decide_interjection(this.config.api_home, this.config.scheduler,
+        { ...context, message, experts: experts.filter(name => name !== room.host) }, this.fetch);
+      const plan = { ...decision, kind: 'interjection', message_id: message.id, after_message_id: message.id };
+      if (decision.action === 'ask') {
+        return { ...plan, turns: [{ expert: decision.expert, question: interjection_question(message) },
+          ...room.queued_turns.map(({ expert, question }) => ({ expert, question }))].slice(0, MAX_PLAN_TURNS) };
+      }
+      if (decision.action === 'note' && room.queued_turns.length) return { ...plan, continue_plan: true };
+      // A note after the plan ran out falls through to deciding the next round.
+      if (decision.action !== 'note') return plan;
+    }
+    if (room.named_followup || room.queued_turns.length || !room.rounds?.at(-1)?.completed) return null;
+    const decision = await decide_round(this.config.api_home, this.config.scheduler,
+      { ...context, experts, last_speaker: room.current_turn?.expert }, this.fetch);
+    const plan = { ...decision, kind: 'round', after_message_id: room.latest_id };
+    if (decision.action !== 'continue') return plan;
+    const round = room.completed_rounds + 1;
+    const order = [decision.first, ...experts.filter(name => name !== decision.first)].slice(0, MAX_PLAN_TURNS);
+    return { ...plan, phase: room.phase === 'initial' ? 'discussing' : undefined,
+      turns: order.map(expert => ({ expert, question: peer_round_question(round) })) };
+  }
+  /** Perform the host's writes for a decided plan under its own execution credential. */
+  async apply_schedule(plan, token) {
+    const room = await api(this.config, '');
+    const actor = room.host;
+    if (room.floor.holder !== actor) await api(this.config, '/floor', { actor, speaker: actor, action: 'take', revision: room.floor.revision }, token);
+    if (plan.phase) await api(this.config, '/topic', { actor, phase: plan.phase }, token);
+    if (plan.continue_plan) await api(this.config, '/turns/continue', { actor }, token);
+    else await api(this.config, '/turns', { actor, turns: plan.turns, submission_id: randomUUID() }, token);
+  }
+  /** Show the decision in the transcript; a failed record never affects the discussion. */
+  async record_decision(plan, applied) {
+    try {
+      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: plan.after_message_id || 0 });
+    } catch (error) { this.log(`智能调度决策记录未保存：${error.message}`); }
   }
   /** Enter once per delivery; a failure is recorded so reconcile revokes the execution. */
   async enter(row, session_id) {
@@ -431,7 +509,8 @@ export class DiscussionRunner {
     if (next && !this.running.get(next.event.participant)) {
       const fresh = await api(this.config, `/events/${next.row.id}`, { action: 'view' });
       if (fresh.status === 'pending') {
-        await this.dispatch(next.row, fresh);
+        const scheduled = fresh.role === 'host' ? await this.smart_schedule(next.row, fresh) : {};
+        if (!scheduled.done) await this.dispatch(next.row, fresh, scheduled);
       }
       else this.store.record(next.row.id, { status: fresh.status });
     }

package/runner/free_runner.mjs

@@ -69,15 +69,13 @@ export function free_task_files(config, member, execution, binding) {
   const host_rule = member.role === 'host'
     ? `你是本房间的主持人：purpose 为 route 的请求是用户未点名的消息，handoff 表示你派出的成员都已结束。先用 ${cli} room view ${config.room} 查看成员与状态，再决定由谁处理；需要派活时在回答中加 --to 成员名（可重复，不能点名自己），被点名的成员都结束后你会再被唤醒一次。不需要他人时不加 --to，本次即结束。只派分给各成员的文件或模块，避免多人改同一文件。`
     : '';
-  const scheduled_rule = execution.requests.some(item => item.purpose === 'scheduled')
-    ? 'purpose 为 scheduled 的消息用户没有点名，是智能调度判断交给你的；若它其实需要主持人拆分或协调，简短说明后结束即可。' : '';
   atomic_json(task_path, { site: config.site, room: config.room, mode: 'free', member: member.name,
     execution_id: execution.id, request_messages: execution.requests.map(item => item.message_id),
     request_purposes: execution.requests.map(item => item.purpose || 'ask'), role: member.role || 'member',
     read_after: execution.read_until, cwd: profile.cwd || null, project_access: profile.project_access, draft_directory,
     skills: [join(config.project, '.agents/skills/discuss-participant/SKILL.md')], cli, subcommands: TASK_SUBCOMMANDS,
     access_file: access_path,
-    instructions: `自由协作房间：用户点名了你（${messages}）。先用 ${cli} message list ${config.room} --after ${execution.read_until} --access-file 凭据路径 读取新消息，按时间顺序处理，后面的消息可能修正前面的，以最新指令为准。${host_rule}${scheduled_rule}完成后用 ${cli} message post ${config.room} --as ${member.name} --kind chat --execution ${execution.id} --body-file 草稿 --submission-id 新UUID --access-file 凭据路径 提交一次回答。提交被拒绝说明本次执行已被打断或过期：保留草稿并结束，不要去掉 --execution 改作普通发言。草稿只写入 draft_directory；${project_rule}不读取或打印凭据内容，不建定时任务。` });
+    instructions: `自由协作房间：用户点名了你（${messages}）。先用 ${cli} message list ${config.room} --after ${execution.read_until} --access-file 凭据路径 读取新消息，按时间顺序处理，后面的消息可能修正前面的，以最新指令为准。${host_rule}完成后用 ${cli} message post ${config.room} --as ${member.name} --kind chat --execution ${execution.id} --body-file 草稿 --submission-id 新UUID --access-file 凭据路径 提交一次回答。提交被拒绝说明本次执行已被打断或过期：保留草稿并结束，不要去掉 --execution 改作普通发言。草稿只写入 draft_directory；${project_rule}不读取或打印凭据内容，不建定时任务。` });
   const prompt = `用户在自由协作房间点名了你（${member.name}），对应消息 ${messages}。请先读取任务文件：${task_path}，按其中说明读取新消息、完成请求，并用 ${cli} message post 带 --execution ${execution.id} 提交一次回答后结束。命令只用任务内 subcommands 列出的 ${cli} 子命令；${project_rule}不读取凭据内容。`;
   return { id, participant: member.name, directory: config.directory, draft_directory,
     skills_directory: join(config.project, '.agents', 'skills'), access_path, prompt };
@@ -101,6 +99,7 @@ export class FreeRoomRunner {
     this.log = log;
     this.fetch = fetch_impl;
     this.routed = new Set();
+    this.decisions = new Set();
     this.children = new Set();
     this.members = new Map();
     this.exited = new Set();
@@ -139,10 +138,10 @@ export class FreeRoomRunner {
   }
   /** One bounded iteration: reconcile live executions, then deliver idle members with open requests. */
   async tick() {
-    let inbox = await api(this.config, '/inbox');
+    const inbox = await api(this.config, '/inbox');
     const room = await api(this.config, '');
-    // Re-read after smart scheduling moved a request, so the host is not woken for it in this same pass.
-    if (this.config.scheduler && !inbox.archived && await this.route_unnamed(inbox, room)) inbox = await api(this.config, '/inbox');
+    // Smart scheduling runs beside delivery: the host gets the message now, a recommendation may follow.
+    if (this.config.scheduler && !inbox.archived) this.recommend_unnamed(inbox, room);
     this.room_title = room.title;
     const active = new Map(inbox.executions.map(item => [item.id, item]));
     const present = new Set(inbox.members.map(member => member.name));
@@ -158,36 +157,33 @@ export class FreeRoomRunner {
     }
   }
   /**
-   * Smart scheduling: give each unnamed message waiting for the host directly to one woken member when the
-   * provider is confident. Each message is decided once; a failure or low confidence leaves it with the host.
+   * Smart scheduling: for each new unnamed message routed to the host, ask the provider in the background whether
+   * another woken member suits it better, and post a recommendation the user may adopt. Nothing waits on it.
    */
-  async route_unnamed(inbox, room) {
+  recommend_unnamed(inbox, room) {
     const host = inbox.members.find(member => member.role === 'host');
     const waiting = host?.pending.filter(request => request.purpose === 'route' && !this.routed.has(request.id)) || [];
-    const members = inbox.members.filter(member => member !== host && this.config.participants[member.name]).map(member => ({ name: member.name,
+    const members = inbox.members.filter(member => member !== host && this.config.participants[member.name]).map(member => ({ id: member.id, name: member.name,
       description: member_description(member.name, this.config.participants[member.name]) }));
-    let moved = false;
     for (const request of waiting) {
       this.routed.add(request.id);
       if (!members.length) continue;
-      try {
-        const page = await api(this.config, `/messages?after=${Math.max(0, request.message_id - 11)}`);
-        const message = page.messages.find(item => item.id === request.message_id);
-        if (!message) continue;
-        const decision = await route_free_message(this.config.api_home, this.config.scheduler,
-          { title: room.title, context: page.messages, message, host: host.name, members }, this.fetch);
-        this.log(`智能调度 #${message.id}：${decision.member ? `派给 ${decision.member}` : '交回主持人'}（选择 ${decision.choice ?? '-'}，置信度 ${decision.confidence ?? '-'}）`);
-        if (!decision.member) continue;
-        const target = inbox.members.find(member => member.name === decision.member);
-        await api(this.config, `/requests/${request.id}`, { action: 'schedule', member_id: target.id,
-          provider: this.config.scheduler.provider, confidence: decision.confidence });
-        moved = true;
-      } catch (error) {
-        // A request the host already took, or any provider failure, simply stays with the host.
-        this.log(`智能调度 #${request.message_id} 未改派，交回主持人：${error.message}`);
-      }
+      const decision = this.recommend(request, room, host, members).catch(error => this.log(`智能调度 #${request.message_id} 未给出推荐：${error.message}`));
+      this.decisions.add(decision);
+      decision.finally(() => this.decisions.delete(decision));
     }
-    return moved;
+  }
+  /** Decide one message and record a confident recommendation; the host's handling is unaffected either way. */
+  async recommend(request, room, host, members) {
+    const page = await api(this.config, `/messages?after=${Math.max(0, request.message_id - 11)}`);
+    const message = page.messages.find(item => item.id === request.message_id);
+    if (!message) return;
+    const decision = await route_free_message(this.config.api_home, this.config.scheduler,
+      { title: room.title, context: page.messages, message, host: host.name, members }, this.fetch);
+    this.log(`智能调度 #${message.id}：${decision.member ? `推荐 ${decision.member}` : '不推荐，交主持人'}（选择 ${decision.choice ?? '-'}，置信度 ${decision.confidence ?? '-'}）`);
+    if (!decision.member) return;
+    await api(this.config, '/recommendations', { message_id: message.id, member_id: members.find(member => member.name === decision.member).id,
+      provider: this.config.scheduler.provider, confidence: decision.confidence });
   }
   /** Reserve with a persisted client id before invoking any software. */
   async start(member, row) {

package/runner/scheduler.mjs

@@ -85,15 +85,41 @@ export async function route_free_message(home, scheduler, { title, context, mess
   return { member, choice: answer.choice ?? null, confidence: answer.confidence ?? null };
 }
 
-/** Suggest how the host might handle one interjection in a discussion; the host decides and may ignore it. */
-export async function suggest_interjection(home, scheduler, { title, context, message, host, experts }, fetch_impl) {
+/**
+ * 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, context, message, host, experts }, fetch_impl) {
   const choices = [...experts.map(name => ({ value: name, description: `请 ${name} 回应这条留言` })),
     { value: HOST_CHOICE, description: `由主持人 ${host} 处理：调整目标、方向、安排，或需要主持人决定` },
     { value: NOTE_CHOICE, description: '仅补充信息：不需要专人回应，按原计划继续' }];
   const answers = await decide(home, scheduler, scheduler_state(title, context, message), [{ type: 'choice', name: 'handling',
     instructions: '讨论进行中用户发来这条留言。判断它最适合怎样处理。', choices }], fetch_impl);
-  const answer = answers.handling || {};
-  const label = answer.choice === HOST_CHOICE ? '主持人处理' : answer.choice === NOTE_CHOICE ? '仅补充信息，按原计划继续'
-    : experts.includes(answer.choice) ? `请 ${answer.choice} 回应` : '';
-  return label ? { message_id: message.id, suggestion: label, confidence: answer.confidence ?? null } : null;
+  const { choice, confidence = null } = answers.handling || {};
+  const sure = confidence !== null && confidence >= ROUTE_CONFIDENCE;
+  if (sure && choice === NOTE_CHOICE) return { action: 'note', confidence, label: '仅补充信息，按原计划继续' };
+  if (sure && experts.includes(choice)) return { action: 'ask', expert: choice, confidence, label: `先请 ${choice} 回应这条留言` };
+  return { action: 'host', confidence, label: '交给主持人处理这条留言' };
+}
+
+/**
+ * At the end of a round without named follow-ups: continue with another peer round, or wake the host
+ * (to conclude, or because the discussion drifted, repeats itself or is stuck). The first speaker is never the last one.
+ */
+export async function decide_round(home, scheduler, { title, context, host, experts, last_speaker }, fetch_impl) {
+  const candidates = experts.filter(name => name !== last_speaker);
+  const recent = context.slice(-CONTEXT_MESSAGES).map(excerpt);
+  const state = [`讨论：${title || ''}`, 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}：已可收束，或讨论跑偏、重复立场、卡住，需要主持人引导` }] }];
+  if (candidates.length > 1) questions.push({ type: 'choice', name: 'first', instructions: '下一轮应先请谁发言？优先选被其他专家点名追问、最需要回应的人。',
+    choices: candidates.map(name => ({ value: name, description: `先请 ${name}` })) });
+  const answers = await decide(home, scheduler, state, questions, fetch_impl);
+  const { choice, confidence = null } = answers.next || {};
+  if (choice !== 'continue' || confidence === null || confidence < ROUTE_CONFIDENCE || !candidates.length) {
+    return { action: 'host', confidence, label: '交给主持人：判断是否收束或调整方向' };
+  }
+  const first = candidates.includes(answers.first?.choice) ? answers.first.choice : candidates[0];
+  return { action: 'continue', first, confidence, label: `继续下一轮，先请 ${first} 发言` };
 }

package/web/app.js

@@ -38,7 +38,7 @@ const PLATFORM_IDENTITIES = {
 };
 const IDENTITIES = by_platform(PLATFORM_IDENTITIES, (identity, name) => ({ ...identity, label: name, description: "AI 实例" }));
 const state = { rooms: [], folders: [], room: null, page: 1, pages: 1, query: "", mention_only: false, free_notice: "", free_error: "",
-  free_proxy: "", create_parent: null,
+  free_proxy: "", create_parent: null, named_followup: false,
   archive_view: false, directory_sort: "manual", management: null, dragged_room: null, folder_moves: new Map(), folder_version: 0,
   reply_to: null, turn_reply_to: null, tab: "topic", refresh_version: 0, context_dirty: false, topic_dirty: false,
   snapshot_id: 0, pending_submission: null, pending_turn: null, pending_room: null, toast_timer: null,
@@ -841,6 +841,7 @@ function reset_create_form() {
   state.launch.create = true;
   state.launch.workspace = {};
   state.launch.scheduler = {};
+  state.named_followup = false;
   state.launch.profiles = JSON.parse(JSON.stringify(state.launch.saved_profiles || {}));
   Object.values(state.launch.profiles).forEach(fill_api_key);
   state.launch.notice = "";
@@ -1342,7 +1343,7 @@ function room_creation_payload(folder_id) {
   // Free rooms carry their task in the conversation, so no opening brief is sent even if one was typed for a discussion.
   if (element("new-room-kind").value === "free") return { ...common, user_request: "", mode: "free", host: common.host || "用户" };
   return { ...common, mode: "brainstorm", background: element("new-room-background").value,
-    boundaries: element("new-room-boundaries").value, runtime_mode: "automatic", limits: read_limits("new-room"),
+    boundaries: element("new-room-boundaries").value, runtime_mode: "automatic", limits: read_limits("new-room"), named_followup: state.named_followup,
     ...(state.create_parent ? { parent_room_id: state.create_parent } : {}) };
 }
 
@@ -1758,6 +1759,12 @@ function creation_launch_options() {
   return { ...launch_options(), ...(enabled && provider && model && api_key_ref ? { scheduler: { provider, model, api_key_ref } } : {}) };
 }
 
+/** Choose whether the new discussion's host writes named follow-ups for each expert between rounds. */
+function write_named_followup(value) {
+  state.named_followup = Boolean(value);
+  publish_view();
+}
+
 /** Change the smart scheduling draft; a new provider starts from its preset model and any key saved for its root. */
 function write_scheduler(field, value) {
   const scheduler = state.launch.scheduler;
@@ -2260,6 +2267,13 @@ async function convert_suggestion({ message_id, member_id }) {
   await refresh_room();
 }
 
+/** Adopt smart scheduling's recommendation: interrupt the host now, or ask the member once the host is done. */
+async function adopt_recommendation({ message_id, mode }) {
+  const room_id = state.room.id;
+  await request_json(`/api/rooms/${room_id}/recommendations/${message_id}`, { action: "adopt", mode });
+  if (state.room?.id === room_id) await refresh_room();
+}
+
 /** A completed creation starts the next form with fresh mode defaults. */
 function reset_creation_mode() {
   state.creation_mode = "brainstorm";
@@ -2869,7 +2883,7 @@ function view_snapshot() {
     free_notice: state.free_notice, free_error: state.free_error, free_proxy: state.free_proxy,
     create_parent: state.create_parent, access: access_snapshot(),
     tab: state.tab, snapshot_id: state.snapshot_id, context_dirty: state.context_dirty,
-    theme: document.documentElement.dataset.theme, fields, experts, launch: structuredClone(state.launch) };
+    theme: document.documentElement.dataset.theme, fields, experts, launch: structuredClone(state.launch), named_followup: state.named_followup };
 }
 
 /** Update a shared draft using the same input events as the original controls. */
@@ -3041,7 +3055,7 @@ async function execute_view_action(name, value) {
     choose_runtime, 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, force_close, conclude_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, change_member, invite_member, interrupt_free, set_proxy, copy_online_notice,
-    prepare_brainstorm, return_conclusion, convert_suggestion,
+    prepare_brainstorm, return_conclusion, convert_suggestion, adopt_recommendation,
     busy: () => { throw new Error("上一个操作仍在处理中，请稍候；长时间无响应请刷新页面"); },
     copy_reading: () => copy_text(`${location.origin}/r/${state.room.id}`), copy: copy_text };
   if (!["refresh", "busy"].includes(name)) state.free_error = "";
@@ -3064,7 +3078,7 @@ function change_view_theme(theme) {
 
 window.discuss_view = { snapshot: view_snapshot, write_field: write_view_field,
   write_launch: write_launch_field, 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_launch_api, launch_summary, launch_can_set_access, launch_can_bind_session, pick_launch_directory, restore_launch_profile, reset_create_form, empty_discussion_message,
+  launch_model_state, load_launch_models, write_launch_model, save_launch_api_key, write_scheduler, save_scheduler_api_key, write_named_followup, check_launch_api, launch_summary, launch_can_set_access, launch_can_bind_session, pick_launch_directory, restore_launch_profile, reset_create_form, empty_discussion_message,
   start_drag: start_directory_drag,
   attachment_markup, attachment_size, attachment_file_icon, drop_attachments, paste_attachments,
   write_expert: write_view_expert, add_instance: add_view_instance, platform_of, execute: execute_view_action, theme: change_view_theme,