ai_co_discuss 0.2.32 → 0.2.34

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,124 @@ 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(event); }
+    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, restore a plan voided by a roster change, or decide the next round
+   * when named follow-ups are off. Anything left to the host says why; null (the opening, or nothing to do) records nothing.
+   */
+  async plan_schedule(event) {
+    if (String(event.cause || '').startsWith('start')) return null;
+    const room = await api(this.config, '');
+    if (!ACTIVE_PHASES.includes(room.phase)) return null;
+    if (room.current_turn && ['pending', 'notified'].includes(room.current_turn.status)) return null;
+    // Every record sits at the end of the latest expert answer, the card that just finished speaking.
+    const anchor = room.current_turn?.answer_id || room.latest_id;
+    const skip = (kind, reason) => ({ action: 'host', kind, confidence: null, label: `未判断：${reason}，交给主持人`, after_message_id: anchor });
+    if (room.limits?.reached) return skip('round', '已到讨论上限');
+    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, goal: room.goal, user_request: room.user_request, 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 skip('interjection', pending.length ? '同时有多条留言' : '话题设置有修改');
+      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: anchor };
+      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.queued_turns.length) return null;
+    const round_open = !room.rounds?.at(-1)?.completed;
+    if (round_open) {
+      const restored = await this.restore_voided_plan(room, experts, anchor);
+      return restored || skip('round', '本轮还有专家未发言但没有后续安排');
+    }
+    if (room.named_followup) return skip('round', '点名追问已开启，由主持人安排下一轮');
+    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: anchor };
+    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) })) };
+  }
+  /**
+   * A roster change voids queued turns, leaving them skipped after the last real arrangement. Put back the ones whose
+   * experts are still present, then ask each expert who has not spoken this round (such as a new member) to open.
+   * This needs no model: it only reinstates what the host had already planned.
+   */
+  async restore_voided_plan(room, experts, anchor) {
+    const turns = (await api(this.config, '/turns')).turns || [];
+    const last_real = Math.max(0, ...turns.filter(turn => turn.status !== 'skipped').map(turn => turn.id));
+    const voided = turns.filter(turn => turn.status === 'skipped' && turn.id > last_real && experts.includes(turn.expert));
+    if (!turns.some(turn => turn.status === 'skipped' && turn.id > last_real)) return null;
+    const spoken = new Set(room.rounds?.at(-1)?.speakers || []);
+    const planned = new Set(voided.map(turn => turn.expert));
+    const joining = experts.filter(name => !spoken.has(name) && !planned.has(name));
+    const opening = room.phase === 'initial' ? '欢迎加入：请先读取议题，独立给出你的开场观点。' : '欢迎加入：请先读取议题和已有回答，给出你的观点。';
+    const plan_turns = [...voided.map(({ expert, question }) => ({ expert, question })), ...joining.map(expert => ({ expert, question: opening }))].slice(0, MAX_PLAN_TURNS);
+    if (!plan_turns.length) return null;
+    const label = `成员有变化：${voided.length ? `补回原计划（${voided.map(turn => turn.expert).join('、')}）` : '原计划成员已离开'}${joining.length ? `，请 ${joining.join('、')} 开场` : ''}`;
+    return { action: 'restore', kind: 'round', confidence: null, label, after_message_id: anchor, turns: plan_turns };
+  }
+  /** 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) {
@@ -390,6 +501,7 @@ export class DiscussionRunner {
       if (room.runtime.generation !== generation) this.stop_children();
     }
     this.room_title = room.title;
+    this.members = room.members || [];
     const run = room.runtime;
     if (run.run_id) this.store.scope(this.config, run.run_id);
     if (run.mode !== 'automatic' || run.status !== 'running' || run.expired) {
@@ -431,7 +543,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/discussion_service.mjs

@@ -173,6 +173,7 @@ class RoomWorker {
     this.create_runner = create_runner;
     this.log = log;
     this.state = { config: path, status: 'starting', error: '' };
+    this.adopt_failed = new Set();
   }
   /** Open lazily so a busy lock or broken file is retried instead of stopping the service. */
   open() {
@@ -219,6 +220,23 @@ class RoomWorker {
     }
     this.state.config_version = snapshot.version;
   }
+  /** A manual Claude expert whose CLI reported its session is handed to the service, which resumes that session from the next turn on. */
+  async adopt_manual_members() {
+    if (this.config.mode === 'free') return;
+    for (const member of this.runner.members || []) {
+      const key = `${member.name}:${member.reported_session}`;
+      if (member.access !== 'manual' || member.status !== 'active' || !member.reported_session || this.adopt_failed.has(key)) continue;
+      try {
+        const { adopt_member_profile } = await import('./discussion_launch.mjs');
+        adopt_member_profile(this.home, this.path, member.name, member.reported_session);
+        await api(this.config, `/members/${member.id}`, { action: 'adopt', adapter: 'claude', session_id: member.reported_session });
+        this.log(`${this.config.room}: ${member.name} 已转为本机托管`);
+      } catch (error) {
+        this.adopt_failed.add(key);
+        this.log(`${this.config.room}: ${member.name} 未能转为托管，保持手动：${error.message}`);
+      }
+    }
+  }
   /** Run one bounded dispatcher iteration and keep the last result for status. */
   async tick() {
     const previous_status = this.state.status;
@@ -226,6 +244,7 @@ class RoomWorker {
       if (!this.runner) this.open();
       await this.refresh_control();
       const result = await this.runner.tick();
+      await this.adopt_manual_members();
       Object.assign(this.state, { status: TICK_STATES[result], error: '' });
     } catch (error) {
       if (await this.deleted(error)) { this.removed = true; return; }

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, goal: room.goal, 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

@@ -6,7 +6,7 @@ export const SCHEDULER_PROVIDERS = {
   jev: { label: 'TypeSafe Jev', base_url: 'https://api.typesafe.ai/v1', path: '/systemone', models: ['jev-latest'] },
   decisions: { label: 'OpenAI Decisions', base_url: 'https://api.openai.com/v1', path: '/decisions', models: ['gpt-6-luna'] },
 };
-const REQUEST_TIMEOUT_MS = 15_000;
+const REQUEST_TIMEOUT_MS = 30_000;
 /** Below this confidence a free-room message stays with the host, exactly as without scheduling. */
 export const ROUTE_CONFIDENCE = 0.8;
 const HOST_CHOICE = '__host__';
@@ -59,41 +59,93 @@ export async function decide(home, scheduler, state, questions, fetch_impl = fet
   return scheduler_answers(scheduler, await response.json());
 }
 
+/** Send one tiny yes/no question so provider, model and key are checked together before a room relies on them. */
+export async function scheduler_check(home, input, fetch_impl = fetch) {
+  const scheduler = validate_scheduler(home, input);
+  const answers = await decide(home, scheduler, '这是一条连通性检查消息。', [{ type: 'predicate', name: 'check', instructions: '这条内容是否是连通性检查？' }], fetch_impl);
+  if (typeof answers.check?.probability !== 'number') throw new Error('决策模型未返回可用答案，请核对供应商与模型');
+  return { ok: true };
+}
+
 /** Shorten a message so recent context stays small; the decision never needs whole answers. */
 function excerpt(message) {
   const text = String(message.text || '').replace(/\s+/g, ' ').trim();
   return `#${message.id} ${message.author}：${text.length > MAX_MESSAGE_CHARS ? `${text.slice(0, MAX_MESSAGE_CHARS)}…` : text}`;
 }
 
+/** The room's purpose in the user's words, so a decision can tell drifting from progress. */
+function topic_lines(title, goal, user_request) {
+  return [`房间：${title || ''}`, goal && `目标：${goal}`, user_request && `用户原文：${String(user_request).slice(0, MAX_MESSAGE_CHARS)}`].filter(Boolean).join('\n');
+}
+
 /** State shared by both uses: the room, a few earlier messages, and the message to place. */
-export function scheduler_state(title, context, message) {
+export function scheduler_state(title, context, message, goal = '', user_request = '') {
   const earlier = context.filter(item => item.id < message.id).slice(-CONTEXT_MESSAGES).map(excerpt);
-  return [`房间：${title || ''}`, earlier.length ? `近期消息（旧→新）：\n${earlier.join('\n')}` : '近期没有其他消息。', `待处理的用户消息：\n${excerpt(message)}`].join('\n\n');
+  return [topic_lines(title, goal, user_request), earlier.length ? `近期消息（旧→新）：\n${earlier.join('\n')}` : '近期没有其他消息。', `待处理的用户消息：\n${excerpt(message)}`].join('\n\n');
+}
+
+/**
+ * How sure the provider is of its pick: the chosen option's probability when given. Jev's separate `confidence`
+ * runs lower than that probability on two-way choices, so it is only the fallback.
+ */
+export function certainty(answer) {
+  const probability = answer?.probabilities?.[answer.choice];
+  return typeof probability === 'number' ? probability : typeof answer?.confidence === 'number' ? answer.confidence : null;
 }
 
 /**
  * Pick the member for one unnamed free-room message, or null to leave it with the host.
  * Members are [{name, description}] without the host; only a confident member choice is returned.
  */
-export async function route_free_message(home, scheduler, { title, context, message, host, members }, fetch_impl) {
+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}：需要拆分任务、补充说明、多人协作，或无法确定由谁处理` }];
-  const answers = await decide(home, scheduler, scheduler_state(title, context, message), [{ type: 'choice', name: 'handler',
+  const answers = await decide(home, scheduler, scheduler_state(title, context, message, goal), [{ type: 'choice', name: 'handler',
     instructions: '这条用户消息没有点名成员。判断它能否直接交给一位成员独立处理；需要主持人先理解、拆分或协调时选交回主持人。', choices }], fetch_impl);
   const answer = answers.handler || {};
-  const member = members.some(item => item.name === answer.choice) && answer.confidence >= ROUTE_CONFIDENCE ? answer.choice : null;
-  return { member, choice: answer.choice ?? null, confidence: answer.confidence ?? null };
+  const confidence = certainty(answer);
+  const member = members.some(item => item.name === answer.choice) && confidence >= ROUTE_CONFIDENCE ? answer.choice : null;
+  return { member, choice: answer.choice ?? null, confidence };
 }
 
-/** 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, goal, user_request, 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 answers = await decide(home, scheduler, scheduler_state(title, context, message, goal, user_request), [{ type: 'choice', name: 'handling',
+    instructions: '讨论进行中用户发来这条留言。结合讨论目标判断它最适合怎样处理。', choices }], fetch_impl);
+  const choice = answers.handling?.choice;
+  const confidence = certainty(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: choice === HOST_CHOICE && sure ? '这条留言需要主持人处理' : '拿不准这条留言如何处理，交给主持人' };
+}
+
+/**
+ * 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, goal, user_request, 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 = [topic_lines(title, goal, user_request), 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 = answers.next?.choice;
+  const confidence = certainty(answers.next);
+  if (choice !== 'continue' || confidence === null || confidence < ROUTE_CONFIDENCE || !candidates.length) {
+    const sure = confidence !== null && confidence >= ROUTE_CONFIDENCE;
+    return { action: 'host', confidence, label: choice === HOST_CHOICE && sure ? '建议收束或调整方向，交给主持人' : '拿不准是否继续下一轮，交给主持人' };
+  }
+  const first = candidates.includes(answers.first?.choice) ? answers.first.choice : candidates[0];
+  return { action: 'continue', first, confidence, label: `继续下一轮，先请 ${first} 发言` };
 }