ai_co_discuss 0.2.70 → 0.2.72

package/runner/discussion_adapters.mjs

@@ -262,11 +262,74 @@ function tree_killable(child) {
   return child;
 }
 
+const EDIT_TOOLS = /^(Edit|MultiEdit|Write|NotebookEdit|write_file|write_to_file|replace_file_content|multi_replace_file_content)$/;
+
+/**
+ * What a streamed CLI event says the agent is doing: thinking, command, tool, editing or writing.
+ * Returns '' when the event says nothing about it; the page only shows the latest phase.
+ */
+export function activity_phase(adapter, event) {
+  if (adapter === 'claude') {
+    if (event.type === 'system' || event.type === 'user') return 'thinking';
+    const block = event.type === 'assistant' ? event.message?.content?.at(-1) : null;
+    if (block?.type === 'tool_use') return /^(Bash|PowerShell)$/.test(block.name) ? 'command' : EDIT_TOOLS.test(block.name) ? 'editing' : 'tool';
+    return block?.type === 'text' ? 'writing' : block?.type === 'thinking' ? 'thinking' : '';
+  }
+  if (adapter === 'codex_cli') {
+    if (event.type === 'turn.started') return 'thinking';
+    const kind = event.item?.type;
+    if (event.type === 'item.started') {
+      return { command_execution: 'command', file_change: 'editing', mcp_tool_call: 'tool', web_search: 'tool', reasoning: 'thinking' }[kind] || '';
+    }
+    if (event.type === 'item.completed') return kind === 'agent_message' ? 'writing' : 'thinking';
+    return '';
+  }
+  if (event.event === 'init') return 'thinking';
+  const step = event.step_update;
+  if (!step) return '';
+  if (step.step_type === 'agent_response' && step.state === 'ACTIVE') return 'writing';
+  if (step.step_type !== 'tool' || ['DONE', 'ERROR'].includes(step.state)) return 'thinking';
+  return step.tool_name === 'run_command' ? 'command' : EDIT_TOOLS.test(step.tool_name || '') ? 'editing' : 'tool';
+}
+
+/**
+ * Text the agent wrote to the user in one streamed event, such as a progress remark between tool calls.
+ * agy streams a response in deltas, so its text is collected per step in `responses` and returned when the step ends.
+ */
+export function progress_note(adapter, event, responses = new Map()) {
+  if (adapter === 'claude') {
+    if (event.type !== 'assistant') return '';
+    return (event.message?.content || []).filter(block => block.type === 'text').map(block => block.text).join('\n').trim();
+  }
+  if (adapter === 'codex_cli') return event.type === 'item.completed' && event.item?.type === 'agent_message' ? String(event.item.text || '').trim() : '';
+  const step = event.step_update;
+  if (step?.step_type !== 'agent_response') return '';
+  responses.set(step.step_index, (responses.get(step.step_index) || '') + (step.text_delta || ''));
+  if (step.state === 'ACTIVE') return '';
+  const text = responses.get(step.step_index).trim();
+  responses.delete(step.step_index);
+  return text;
+}
+
+/** Report the phase and any progress note of each complete JSON line; malformed lines are left to the caller's own parsing. */
+function watch_activity(adapter, stream, task) {
+  if (!task.on_activity && !task.on_note) return;
+  createInterface({ input: stream, crlfDelay: Infinity }).on('line', line => {
+    let event;
+    try { event = JSON.parse(line); } catch { return; }
+    const phase = activity_phase(adapter, event);
+    if (phase) task.on_activity?.(phase);
+    const note = progress_note(adapter, event);
+    if (note) task.on_note?.(note);
+  });
+}
+
 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); }
   catch (error) { throw not_sent(error); }
-  const args = ['-p', '--output-format', 'json', binding.session_id ? '--resume' : '--session-id', session_id,
+  // Streamed events show the turn's progress; the final line is still the result that decides success.
+  const args = ['-p', '--output-format', 'stream-json', '--verbose', binding.session_id ? '--resume' : '--session-id', session_id,
     ...(config.model ? ['--model', config.model] : []), ...(config.effort ? ['--effort', config.effort] : []), ...claude_permissions(config, task)];
   let child;
   try {
@@ -281,6 +344,7 @@ async function claude_delivery(config, binding, task, spawn_process = spawn) {
   let output = '';
   child.stdout.on('data', chunk => { output += chunk; task.on_output(log_path, chunk); });
   child.stderr.on('data', chunk => task.on_output(log_path, chunk));
+  watch_activity('claude', child.stdout, task);
   child.once('close', code => {
     if (!spawned) return;
     const error = claude_exit_error(code, output);
@@ -445,7 +509,7 @@ function cli_exit_error(state, code, signal) {
 
 /** Parse complete UTF-8 JSON lines while keeping raw output in the private task log. */
 function monitor_cli(child, config, binding, task) {
-  const state = { child, session_id: binding.session_id || '', initialized: false, completed: false, error: '', diagnostic: '' };
+  const state = { child, session_id: binding.session_id || '', initialized: false, completed: false, error: '', diagnostic: '', responses: new Map() };
   const log_path = resolve(task.directory, `${config.adapter}-${task.id}.log`);
   const lines = createInterface({ input: child.stdout, crlfDelay: Infinity });
   const max_run_ms = Number(process.env.CODISCUSS_CLI_MAX_MS) || CLI_MAX_RUN_MS;
@@ -463,6 +527,10 @@ function monitor_cli(child, config, binding, task) {
     try { event = JSON.parse(line); }
     catch { state.diagnostic = 'CLI 输出中存在无效 JSON，详情见本机日志'; return; }
     trace_cli_event(event, task);
+    const phase = activity_phase(config.adapter, event);
+    if (phase) task.on_activity?.(phase);
+    const note = progress_note(config.adapter, event, state.responses);
+    if (note) task.on_note?.(note);
     try { cli_event(config.adapter, state, event, task); }
     catch (error) { state.error = error.message; child.kill(); }
   });

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,10 +5,16 @@ 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;
+/** A changed phase is reported early, but no more often than this, since each report refreshes open pages. */
+const ACTIVITY_REPORT_MS = 10_000;
+/** Progress notes kept per execution, each cut to this length, and how many one renewal carries; the website enforces the same. */
+const MAX_EXECUTION_NOTES = 50;
+const MAX_NOTE_LENGTH = 500;
+const MAX_NOTES_PER_RENEW = 10;
 const MAX_DELIVERY_ATTEMPTS = 3;
 const LIVE = ['reserving', 'delivering', 'sidecar_pending', 'running'];
 const MAX_HASHED_BYTES = 5 * 1024 * 1024;
@@ -121,6 +127,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();
@@ -128,6 +136,9 @@ export class FreeRoomRunner {
     this.members = new Map();
     this.exited = new Set();
     this.snapshots = new Map();
+    // Execution id -> { phase, at, sent_phase, sent_at, notes, next_seq }: what the member's software last showed it doing,
+    // and the progress notes not yet on the website.
+    this.activity = new Map();
     this.context_errors = new Map();
     this.adopt(config);
     this.store.db.exec(`CREATE TABLE IF NOT EXISTS free_deliveries(member TEXT PRIMARY KEY, client_id TEXT NOT NULL,
@@ -166,6 +177,7 @@ export class FreeRoomRunner {
     const room = await api(this.config, '');
     // 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 +189,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 +214,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 +293,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}`); }
@@ -293,7 +338,9 @@ export class FreeRoomRunner {
           requests: execution.requests, read_after: execution.read_until },
         on_binding: session => this.store.bind(member.name, session),
         on_process: child => this.track(member.name, child),
-        on_output: (path, chunk) => appendFileSync(path, chunk, { mode: 0o600 }),
+        on_output: (path, chunk) => { appendFileSync(path, chunk, { mode: 0o600 }); this.touch(execution.id); },
+        on_activity: phase => this.touch(execution.id, phase),
+        on_note: text => this.note(execution.id, text),
         // A stopped process may report after the next execution started; only its own execution takes the result.
         on_failure: error => { try { if (this.row(member.name)?.execution_id === execution.id) this.save(member.name, { error }); } catch { /* Store may already be closed at shutdown. */ } },
         on_exit: () => this.exited.add(execution.id),
@@ -321,6 +368,7 @@ export class FreeRoomRunner {
     }
     const execution = active.get(row.execution_id);
     if (!execution) {
+      this.activity.delete(row.execution_id);
       this.stop_member(member.name);
       return this.save(member.name, { status: 'idle', error: '' });
     }
@@ -333,11 +381,34 @@ export class FreeRoomRunner {
       return this.save(member.name, { status: 'idle' });
     }
     if (Date.now() >= execution.created_at * 1000 + minutes * 60_000) return this.fail(member.name, execution.id, `超过单次执行时限 ${minutes} 分钟；请核对原会话确认是否已有内容`);
-    if (Date.now() - row.last_renew >= RENEW_MS) {
-      await api(this.config, `/executions/${execution.id}`, { action: 'renew' });
+    const activity = this.activity.get(execution.id);
+    const changed = activity && (activity.phase !== activity.sent_phase || activity.at !== activity.sent_at || activity.notes.length);
+    const elapsed = Date.now() - row.last_renew;
+    if (elapsed >= RENEW_MS || (changed && elapsed >= ACTIVITY_REPORT_MS)) {
+      const notes = activity?.notes.slice(0, MAX_NOTES_PER_RENEW) || [];
+      await api(this.config, `/executions/${execution.id}`, { action: 'renew',
+        ...(activity ? { activity: activity.phase, activity_at: Math.floor(activity.at / 1000) } : {}), ...(notes.length ? { notes } : {}) });
+      if (activity) Object.assign(activity, { sent_phase: activity.phase, sent_at: activity.at, notes: activity.notes.slice(notes.length) });
       this.save(member.name, { last_renew: Date.now() });
     }
   }
+  /** Note that the software produced output now, and its phase when the output names one. */
+  touch(execution_id, phase) {
+    // Updated in place: a renewal in flight marks what it sent on this same record.
+    if (!this.activity.has(execution_id)) this.activity.set(execution_id, { phase: '', notes: [], next_seq: 0 });
+    const current = this.activity.get(execution_id);
+    if (phase) current.phase = phase;
+    current.at = Date.now();
+  }
+  /** Queue one progress note for the next renewal; numbering makes a retried renewal harmless, and notes past the cap are dropped. */
+  note(execution_id, text) {
+    this.touch(execution_id);
+    const current = this.activity.get(execution_id);
+    if (current.next_seq >= MAX_EXECUTION_NOTES) return;
+    current.next_seq += 1;
+    // Cut by UTF-16 units like the website's check, without leaving half of a surrogate pair.
+    current.notes.push({ seq: current.next_seq, text: text.slice(0, MAX_NOTE_LENGTH).replace(/[\uD800-\uDBFF]$/, '') });
+  }
   /** Report observed file changes once an execution has ended and its member's processes have exited. */
   async report_finished(active) {
     for (const [execution_id, snapshot] of this.snapshots) {
@@ -352,6 +423,7 @@ export class FreeRoomRunner {
   }
   /** Record the cause on the website, then stop this member's own processes. */
   async fail(name, execution_id, reason) {
+    this.activity.delete(execution_id);
     try { await api(this.config, `/executions/${execution_id}`, { action: 'fail', reason }); }
     catch (error) { if (!/HTTP 409/.test(error.message)) throw error; }
     this.save(name, { status: 'idle', error: reason });

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

@@ -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;
@@ -960,7 +962,6 @@ function message_payload() {
   if (payload.kind === "opinion" && payload.author !== "用户") {
     payload.summary = element("message-summary").value.trim();
     payload.summary_by = element("message-summary-source").value === "submitter" ? payload.submitted_by : payload.author;
-    if (!payload.summary) throw new Error("请补充本次回答的摘要，保留关键结论、条件与不确定性");
     if ([...payload.summary].length > MAX_SUMMARY_LENGTH) throw new Error(`回答摘要最多 ${MAX_SUMMARY_LENGTH} 字，草稿已保留`);
   }
   if ([...payload.text].length > MAX_MESSAGE_LENGTH) throw new Error(`留言最多 ${MAX_MESSAGE_LENGTH} 字，原文已保留，请调整后提交`);
@@ -2753,7 +2754,6 @@ function update_composer_role() {
   if (mode === "moderation") element("author-select").value = "用户";
   const needs_summary = ["opinion", "forward"].includes(mode) && element("author-select").value !== "用户";
   element("message-summary-fields").hidden = !needs_summary;
-  element("message-summary").required = needs_summary;
   element("author-note").textContent = mode === "moderation" ? "主持发言" :
     (mode === "forward" ? "由用户代发" : (element("author-select").value === "用户" ? "发言" : "的观点代发"));
 }