ai_co_discuss 0.2.69 → 0.2.71

package/runner/discussion_adapters.mjs

@@ -253,6 +253,15 @@ export function kill_process_tree(child, plain_kill, platform = process.platform
   return plain_kill();
 }
 
+/** Make a delivered process's kill end its whole tree on Windows, so a stopped turn leaves no tool commands running. */
+function tree_killable(child) {
+  if (typeof child.kill === 'function') {
+    const plain_kill = child.kill.bind(child);
+    child.kill = () => kill_process_tree(child, plain_kill);
+  }
+  return child;
+}
+
 async function claude_delivery(config, binding, task, spawn_process = spawn) {
   const session_id = binding.session_id || randomUUID();
   try { bind_access(task.access_path, session_id); }
@@ -266,10 +275,7 @@ async function claude_delivery(config, binding, task, spawn_process = spawn) {
       env: { ...standalone_claude_env(), DISCUSS_ACCESS_FILE: task.access_path },
     });
   } catch (error) { throw not_sent(error); }
-  if (typeof child.kill === 'function') {
-    const plain_kill = child.kill.bind(child);
-    child.kill = () => kill_process_tree(child, plain_kill);
-  }
+  tree_killable(child);
   let spawned = false;
   const log_path = resolve(task.directory, `claude-${task.id}.log`);
   let output = '';
@@ -497,6 +503,7 @@ async function cli_delivery(config, binding, task, spawn_process, user_home) {
       env: { ...process.env, DISCUSS_ACCESS_FILE: task.access_path },
     });
   } catch (error) { throw not_sent(error); }
+  tree_killable(child);
   const state = monitor_cli(child, config, binding, task);
   task.on_process(child);
   await new Promise((resolve_spawn, reject) => {

package/runner/discussion_runner.mjs

@@ -462,7 +462,7 @@ export class DiscussionRunner {
   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, detail: plan.detail });
+        applied, provider: this.config.scheduler.provider, after_message_id: plan.after_message_id || 0, detail: plan.detail, input: plan.input });
     } catch (error) { this.log(`智能调度决策记录未保存：${error.message}`); }
   }
   /** Enter once per delivery; a failure is recorded so reconcile revokes the execution. */

package/runner/free_runner.mjs

@@ -5,7 +5,7 @@ import { appendFileSync, mkdirSync, readFileSync, statSync } from 'node:fs';
 import { basename, join, resolve } from 'node:path';
 import { atomic_json, deliver_task, sidecar_receipt, TASK_SUBCOMMANDS } from './discussion_adapters.mjs';
 import { api } from './discussion_runner.mjs';
-import { ROUTE_CONFIDENCE, ROUTE_CONTEXT_MESSAGES, ROUTE_PROMPT_VERSION, ROUTE_WIDE_CONFIDENCE, route_free_message } from './scheduler.mjs';
+import { ROUTE_CONFIDENCE, ROUTE_CONTEXT_MESSAGES, ROUTE_PROMPT_VERSION, ROUTE_WIDE_CONFIDENCE, decide_group_order, route_free_message } from './scheduler.mjs';
 
 const PACKAGE_VERSION = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8')).version;
 const RENEW_MS = 30_000;
@@ -121,6 +121,8 @@ export class FreeRoomRunner {
     this.log = log;
     this.fetch = fetch_impl;
     this.routed = new Set();
+    // Group requests (@全体成员) being arranged; a failed arrangement leaves the set so the next tick retries.
+    this.grouped = new Set();
     this.decisions = new Set();
     // Routed requests whose decision is still pending: their host waits, so one pick replaces the host's start.
     this.routing = new Set();
@@ -164,8 +166,9 @@ export class FreeRoomRunner {
   async tick() {
     const inbox = await api(this.config, '/inbox');
     const room = await api(this.config, '');
-    // Smart scheduling runs beside delivery: the host gets the message now, a recommendation may follow.
+    // Smart scheduling runs beside delivery: the host waits for its answer (or failure) before starting, see `routing`.
     if (this.config.scheduler && !inbox.archived) this.recommend_unnamed(inbox, room);
+    if (!inbox.archived) this.arrange_groups(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));
@@ -177,7 +180,7 @@ export class FreeRoomRunner {
     for (const member of inbox.members) {
       const row = this.row(member.name);
       if (row && LIVE.includes(row.status)) await this.reconcile(member, row, active, inbox.execution_minutes);
-      else if (!inbox.archived && member.pending.length && !this.members.get(member.name)?.size
+      else if (!inbox.archived && member.pending.some(request => request.purpose !== 'group') && !this.members.get(member.name)?.size
         && !member.pending.some(request => this.routing.has(request.id))) await this.start(member, row);
     }
   }
@@ -202,6 +205,39 @@ export class FreeRoomRunner {
       decision.finally(() => this.decisions.delete(decision));
     }
   }
+  /** For each message naming everyone, have them answer at once, or one after another when smart scheduling says so. */
+  arrange_groups(inbox, room) {
+    const everyone = [...inbox.members, ...(inbox.observers || [])];
+    for (const request of everyone.flatMap(member => member.pending).filter(item => item.purpose === 'group' && !this.grouped.has(item.id))) {
+      this.grouped.add(request.id);
+      const arranged = (this.config.scheduler ? this.mark_routing(request.message_id, true).then(() => this.order_group(request, room, everyone))
+        .finally(() => this.mark_routing(request.message_id, false)) : this.apply_group(request.message_id, { action: 'all' }))
+        .catch(error => { this.grouped.delete(request.id); this.log(`全体成员 #${request.message_id} 未能安排：${error.message}`); });
+      this.decisions.add(arranged);
+      arranged.finally(() => this.decisions.delete(arranged));
+    }
+  }
+  /** Ask the scheduler how everyone answers; a failed call still has them answer at once. */
+  async order_group(request, room, everyone) {
+    const page = await api(this.config, `/messages?after=${Math.max(0, request.message_id - ROUTE_CONTEXT_MESSAGES - 1)}`);
+    const message = page.messages.find(item => item.id === request.message_id);
+    const members = (room.speaking_order?.items || []).map(item => item.name).filter(name => everyone.some(member => member.name === name));
+    const decision = await decide_group_order(this.config.api_home, this.config.scheduler,
+      { title: room.title, goal: room.goal, context: page.messages, message, members: members.length ? members : everyone.map(member => member.name) }, this.fetch)
+      .catch(error => { this.log(`智能调度 #${request.message_id} 未判断全体回答方式：${error.message}`); return { action: 'all' }; });
+    await this.apply_group(request.message_id, decision);
+    if (decision.detail) {
+      const label = decision.action === 'sequential' ? '请全体按发言顺序依次回答' : '请全体同时回答';
+      await this.record_decision(request.message_id, decision, label, true);
+    }
+  }
+  /** Replace the host's group request with everyone's requests; a message already arranged elsewhere is left as is. */
+  async apply_group(message_id, decision) {
+    this.log(`全体成员 #${message_id}：${decision.action === 'sequential' ? '依次回答' : '同时回答'}`);
+    await api(this.config, `/recommendations/${message_id}`, { action: decision.action }).catch(error => {
+      if (!/HTTP (404|409)/.test(error.message)) throw error;
+    });
+  }
   /** Tell the website a message is being analysed so it can show the card; a failed mark never blocks routing. */
   async mark_routing(message_id, active) {
     try { await api(this.config, '/scheduler-routing', { message_id, active }); }
@@ -248,7 +284,7 @@ export class FreeRoomRunner {
   async record_decision(message_id, decision, label, applied) {
     try {
       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,
+        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 } });
     } catch (error) { this.log(`智能调度 #${message_id} 决策记录未保存：${error.message}`); }

package/runner/scheduler.mjs

@@ -12,7 +12,7 @@ export const ROUTE_CONFIDENCE = 0.7;
 /** Waking everyone or no one costs more when wrong (N runs, or an ignored message), so it needs more certainty. */
 export const ROUTE_WIDE_CONFIDENCE = 0.85;
 /** Bump when the routing question or its option descriptions change, so ratings can be compared across wordings. */
-export const ROUTE_PROMPT_VERSION = 3;
+export const ROUTE_PROMPT_VERSION = 4;
 const HOST_CHOICE = '__host__';
 const NOTE_CHOICE = '__note__';
 const ALL_CHOICE = '__all__';
@@ -95,6 +95,11 @@ function detail_of(questions, answers) {
   });
 }
 
+/** The shown detail plus the exact input (state and full questions), kept so a rated-bad decision can be reviewed later. */
+function judged_of(state, questions, answers) {
+  return { detail: detail_of(questions, answers), input: { state, questions } };
+}
+
 /** Say which option the provider leaned to when it was not sure enough, so the transcript shows how close it was. */
 function unsure_label(lean) {
   return lean ? `倾向${lean}，把握不足，交给主持人` : '拿不准，交给主持人';
@@ -108,8 +113,8 @@ 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, { brief, focus, arrangement, progress } = {}) {
-  return [`房间：${title || ''}`, goal && `目标：${goal}`, user_request && `用户原文：${String(user_request).slice(0, MAX_MESSAGE_CHARS)}`,
+function topic_lines(title, goal, user_request, { roster, brief, focus, arrangement, progress } = {}) {
+  return [`房间：${title || ''}`, roster && `房间成员（名字不区分大小写）：${roster}`, 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');
 }
@@ -136,21 +141,39 @@ export function certainty(answer) {
  */
 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}：消息在延续主持人自己的回答，或对象不明确，或需要分工、排先后、互相回应` },
-    { value: ALL_CHOICE, description: '全体成员（含主持人）各自回应一次，彼此不需要配合，如打招呼、自我介绍、各说一句看法' },
+    { value: HOST_CHOICE, description: `主持人 ${host.description}：没有指向任何人（如单独一句“hi”“你好”这类问候、闲聊，由主持人代表房间回应），或需要分工、排先后、互相回应` },
+    { value: ALL_CHOICE, description: '全体成员（含主持人）各自回应一次，彼此不需要配合；须是用户明确要求大家各自回应，如“大家/都出来打个招呼”“各自介绍一下”“各说一句看法”' },
     { value: NONE_CHOICE, description: '无需回应：只是确认、致谢或旁注，不需要任何人回答' }];
   const questions = [{ type: 'choice', name: 'handler', choices,
-    instructions: '这条用户消息没有用 @ 点名成员。判断它的回应对象是否已经确定：正文叫了某位成员的名字或在向其提问；在延续某位成员的回答（追问、要求修改、引用，或“回复”指向其消息）；在补充或纠正一条正由某位成员处理的消息。以上情况选该成员，是主持人就选主持人。要求所有成员各自回应一次选全体；只是确认、致谢或旁注选无需回应；对象不明确，或需要分工、排先后、互相回应时选主持人。' }];
-  const answers = await decide(home, scheduler, scheduler_state(title, context, message, goal, '', {}, ROUTE_CONTEXT_MESSAGES), questions, fetch_impl);
-  const detail = detail_of(questions, answers);
+    instructions: '这条用户消息没有用 @ 点名成员。判断它的回应对象，按下面的顺序：1）正文叫了某位成员的名字，或在向其提问（包括“X在吗”“X还在吗”“X你怎么看”），选该成员，即使上一条是别人的回答；2）正文没有指向任何人时，看它是否在延续某位成员的回答（追问、要求修改、引用，或“回复”指向其消息），或在补充、纠正一条正由某位成员处理的消息，是则选该成员，是主持人就选主持人；3）明确要求所有成员各自回应一次（用了“大家”“都”“各自”等）选全体；4）单独的问候或闲聊（如“hi”）既没有指向某位成员，也没有要求大家一起回应，选主持人；5）只是确认、致谢或旁注选无需回应；6）对象不明确，或需要分工、排先后、互相回应时选主持人。' }];
+  const roster = [`${host.name}（主持人）`, ...members.map(member => member.name)].join('、');
+  const state = scheduler_state(title, context, message, goal, '', { roster }, 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);
-  if (sure && choice === ALL_CHOICE) return { action: 'all', choice, confidence, detail };
-  if (sure && choice === NONE_CHOICE) return { action: 'none', choice, confidence, detail };
-  if (sure && members.some(item => item.name === choice)) return { action: 'member', member: choice, choice, confidence, detail };
-  return { action: 'host', choice, confidence, detail };
+  if (sure && choice === ALL_CHOICE) return { action: 'all', choice, confidence, ...judged };
+  if (sure && choice === NONE_CHOICE) return { action: 'none', 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 };
+}
+
+/**
+ * The user named everyone (@全体成员): decide whether they answer at once (parallel) or one after another (sequential).
+ * Anything but a confident sequential stays parallel, the cheaper and earlier behaviour of naming everyone.
+ */
+export async function decide_group_order(home, scheduler, { title, goal, context, message, members }, fetch_impl) {
+  const questions = [{ type: 'choice', name: 'order', choices: [
+    { value: 'parallel', description: '同时回答：各自独立回应即可，不需要看到别人的回答，如打招呼、各自介绍、各说一句看法、各自投票' },
+    { value: 'sequential', description: `依次回答：后发言的需要看到前面的回答，如接龙、轮流补充或反驳、逐个评审上一位的结果、按顺序分工接力；按房间发言顺序（${members.join('、')}）逐个回答` }],
+    instructions: '用户用 @全体成员 请房间里所有成员回应这条消息。判断大家应同时各自回答，还是需要按顺序依次回答（后一位看到前一位的回答再接着说）。' }];
+  const state = scheduler_state(title, context, message, goal, '', {}, ROUTE_CONTEXT_MESSAGES);
+  const answers = await decide(home, scheduler, state, questions, fetch_impl);
+  const confidence = certainty(answers.order);
+  const sequential = answers.order?.choice === 'sequential' && confidence !== null && confidence >= ROUTE_CONFIDENCE;
+  return { action: sequential ? 'sequential' : 'all', choice: answers.order?.choice ?? null, confidence, ...judged_of(state, questions, answers) };
 }
 
 /**
@@ -162,15 +185,16 @@ export async function decide_interjection(home, scheduler, { title, goal, user_r
     { value: HOST_CHOICE, description: `由主持人 ${host} 处理：留言要改变讨论目标、规则、分工、安排或结束讨论，或同时涉及多位专家` },
     { value: NOTE_CHOICE, description: '仅补充信息：留言只是旁注、信息或鼓励，不要求任何人回应，按当前安排继续' }];
   const questions = [{ type: 'choice', name: 'handling', instructions: '讨论进行中用户发来这条留言。对照当前焦点、主持简报和安排，判断它最适合怎样处理。', choices }];
-  const answers = await decide(home, scheduler, scheduler_state(title, context, message, goal, user_request, extra), questions, fetch_impl);
-  const detail = detail_of(questions, answers);
+  const state = scheduler_state(title, context, message, goal, user_request, extra);
+  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;
-  if (sure && choice === NOTE_CHOICE) return { action: 'note', confidence, detail, label: '仅补充信息，按原计划继续' };
-  if (sure && experts.includes(choice)) return { action: 'ask', expert: choice, confidence, detail, label: `先请 ${choice} 回应这条留言` };
+  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 ? '由主持人处理' : '';
-  return { action: 'host', confidence, detail, label: choice === HOST_CHOICE && sure ? '这条留言需要主持人处理' : unsure_label(lean) };
+  return { action: 'host', confidence, ...judged, label: choice === HOST_CHOICE && sure ? '这条留言需要主持人处理' : unsure_label(lean) };
 }
 
 /**
@@ -189,17 +213,17 @@ export async function decide_next_speaker(home, scheduler, { title, goal, user_r
     { type: 'predicate', name: 'obligation',
       instructions: `是否存在明确依据要求 ${candidates.join('、')} 之一接着发言：简报分工或流程规定轮到其人，或最近发言点名追问了其人？仅仅是“本轮还没发言”不算依据。` }];
   const answers = await decide(home, scheduler, state, questions, fetch_impl);
-  const detail = detail_of(questions, answers);
+  const judged = judged_of(state, questions, answers);
   const choice = answers.speaker?.choice;
   const confidence = certainty(answers.speaker);
   const obligation = answers.obligation?.probability;
   if (candidates.includes(choice) && confidence !== null && confidence >= ROUTE_CONFIDENCE && obligation >= ROUTE_CONFIDENCE) {
-    return { action: 'next', expert: choice, confidence, detail, label: `本轮继续，请 ${choice} 接着发言` };
+    return { action: 'next', expert: choice, confidence, ...judged, label: `本轮继续，请 ${choice} 接着发言` };
   }
   if (typeof obligation === 'number' && obligation < ROUTE_CONFIDENCE) {
-    return { action: 'host', confidence, detail, label: `有明确依据的概率 ${obligation.toFixed(2)}，未达 ${ROUTE_CONFIDENCE.toFixed(2)}，交给主持人安排` };
+    return { action: 'host', confidence, ...judged, label: `有明确依据的概率 ${obligation.toFixed(2)}，未达 ${ROUTE_CONFIDENCE.toFixed(2)}，交给主持人安排` };
   }
-  return { action: 'host', confidence, detail, label: choice === HOST_CHOICE && confidence >= ROUTE_CONFIDENCE ? '建议由主持人调整安排，交给主持人' : unsure_label(candidates.includes(choice) ? `请 ${choice} 发言` : choice === HOST_CHOICE ? '交给主持人' : '') };
+  return { action: 'host', confidence, ...judged, label: choice === HOST_CHOICE && confidence >= ROUTE_CONFIDENCE ? '建议由主持人调整安排，交给主持人' : unsure_label(candidates.includes(choice) ? `请 ${choice} 发言` : choice === HOST_CHOICE ? '交给主持人' : '') };
 }
 
 /**
@@ -216,13 +240,13 @@ export async function decide_round(home, scheduler, { title, goal, user_request,
   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 detail = detail_of(questions, answers);
+  const judged = judged_of(state, questions, answers);
   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, detail, label: choice === HOST_CHOICE && sure ? '建议收束或调整方向，交给主持人' : unsure_label(choice === 'continue' ? '继续下一轮' : choice === HOST_CHOICE ? '收束或调整方向' : '') };
+    return { action: 'host', confidence, ...judged, label: choice === HOST_CHOICE && sure ? '建议收束或调整方向，交给主持人' : unsure_label(choice === 'continue' ? '继续下一轮' : choice === HOST_CHOICE ? '收束或调整方向' : '') };
   }
   const first = candidates.includes(answers.first?.choice) ? answers.first.choice : candidates[0];
-  return { action: 'continue', first, confidence, detail, label: `继续下一轮，先请 ${first} 发言` };
+  return { action: 'continue', first, confidence, ...judged, label: `继续下一轮，先请 ${first} 发言` };
 }

package/web/app.js

@@ -47,7 +47,7 @@ const PLATFORM_IDENTITIES = {
   Grok: { initials: "GK", style: "grok", description: "AI 身份" },
 };
 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: "",
+const state = { rooms: [], folders: [], room: null, page: 1, pages: 1, query: "", mention_only: false, free_notice: "", free_error: "", order_error: null,
   free_proxy: "", create_parent: null, named_followup: false, create_discussion: 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,
@@ -939,12 +939,14 @@ function message_payload() {
       request_ids: state.room.free.requests.filter(item => item.member === online.name && item.status === "pending").map(item => item.id) };
     const payload = { author: "用户", text, reply_to: state.reply_to, kind: "chat", submitted_by: "用户" };
     const active = (state.room.free?.members || []).filter(member => member.status === "active" && (member.access !== "manual" || member.registered_at)).map(member => member.name);
-    // @mentions outside code name members (@全体成员 or @all names them all; @全体依次 or @all-seq has them answer one after another, the host first);
-    // without any, the server gives the message to the only member or the host.
+    // @mentions outside code name members (@全体成员 or @all names them all, answering at once or in turn as smart scheduling decides;
+    // @全体依次 or @all-seq has them answer one after another, the host first); without any, the server gives the message to the only member or the host.
     const sequential = mentioned(text, "全体依次") || mentioned(text, "all-seq");
-    const named = sequential || mentioned(text, "全体成员") || mentioned(text, "all") ? active : active.filter(name => mentioned(text, name));
+    const everyone = !sequential && (mentioned(text, "全体成员") || mentioned(text, "all"));
+    const named = sequential || everyone ? active : active.filter(name => mentioned(text, name));
     if (named.length) payload.to = named;
     if (sequential && named.length) payload.sequential = true;
+    if (everyone && named.length) payload.order = "auto";
     return payload;
   }
   const mode = element("message-kind").value;
@@ -1067,6 +1069,18 @@ async function change_member({ member_id, name, action, role, latest_id }) {
   } catch (error) { if (state.room?.id === room_id) state.free_error = error.message; }
 }
 
+/** Reorder who has not spoken yet against the revision the board showed; a changed order is refused and the board reloads. */
+async function reorder_speakers({ revision, order }) {
+  const room_id = state.room.id;
+  state.order_error = null;
+  try { await request_json(`/api/rooms/${room_id}/speaking-order`, { revision, order }); }
+  catch (error) {
+    // A conflict means someone else's change landed first; the board reloads below, so ask for the move again (same text as the board's own notice).
+    state.order_error = { room_id, message: error.status === 409 ? "发言顺序刚有变化，已更新为最新顺序，请重新调整" : error.message };
+  }
+  if (state.room?.id === room_id) await refresh_room();
+}
+
 /** Invite an independent member, retaining its credential before either delivery path runs. */
 async function invite_member({ name, access, project_access = "read", session_id = "" }) {
   const room_id = state.room.id;
@@ -3158,7 +3172,7 @@ function view_snapshot() {
     attachment_drafts: state.attachment_drafts.map(item => ({ id: item.id, file_name: item.file.name, size: item.file.size, preview_url: item.preview_url })),
     composer_error: state.composer_error, upload_status: state.upload_status, sending_message: state.sending_message,
     mention_only: state.mention_only, reply_to: state.reply_to, turn_reply_to: state.turn_reply_to,
-    free_notice: state.free_notice, free_error: state.free_error, free_proxy: state.free_proxy,
+    free_notice: state.free_notice, free_error: state.free_error, free_proxy: state.free_proxy, order_error: state.order_error,
     create_parent: state.create_parent, access: access_snapshot(), admin: admin_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), named_followup: state.named_followup, create_discussion: state.create_discussion };
@@ -3331,7 +3345,7 @@ async function execute_view_action(name, value) {
     copy_online: () => copy_context(), copy_cli: () => copy_context("cli"), copy_background,
     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, retry_execution, 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, change_member, invite_member, set_proxy, copy_online_notice,
+    load_room_configuration, save_room_configuration, interrupt_member, change_member, reorder_speakers, invite_member, set_proxy, copy_online_notice,
     prepare_brainstorm, return_conclusion, convert_suggestion, adopt_recommendation, rate_decision,
     busy: () => { throw new Error("上一个操作仍在处理中，请稍候；长时间无响应请刷新页面"); },
     copy_reading: () => copy_text(`${location.origin}/r/${state.room.id}`), copy: copy_text };