ai_co_discuss 0.3.6 → 0.3.7

package/package.json

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

package/runner/discussion_setup.mjs

@@ -9,7 +9,7 @@ import { parseArgs } from 'node:util';
 import { atomic_json } from './discussion_adapters.mjs';
 import { launch_settings, save_launch_settings } from './discussion_launch.mjs';
 import { assert_shared_home, service_home } from './discussion_service.mjs';
-import { install_skills } from './discussion_skills.mjs';
+import { SKILLS, install_skills, remove_legacy_skills } from './discussion_skills.mjs';
 import { ask, checkbox_prompt, intro, outro, pad, short_path, spinner, step, styled, text_width, tone } from './discussion_tui.mjs';
 export { checkbox_prompt } from './discussion_tui.mjs';
 
@@ -22,10 +22,13 @@ const ATTENTION_EXIT_CODE = 2;
 const AGY_SETTINGS = ['.gemini', 'antigravity-cli', 'settings.json'];
 const AGY_RULE_RECORD = 'agy-permission.json';
 const AGY_SETTINGS_BACKUP = 'agy-settings.backup.json';
+const SKILL_RECORD = 'skills-manifest.json';
+const AGY_SKILL_CONFIG = ['.gemini', 'config', 'skills.json'];
 const CLIENTS = {
   codex: { name: 'Codex', commands: ['codex'], adapter: 'codex_cli', skills: ['.agents', 'skills'] },
   claude: { name: 'Claude', commands: ['claude'], adapter: 'claude', skills: ['.claude', 'skills'] },
-  antigravity: { name: 'Gemini', commands: ['agy'], adapter: 'antigravity_cli', skills: ['.gemini', 'antigravity-cli', 'skills'] },
+  antigravity: { name: 'Gemini', commands: ['agy'], adapter: 'antigravity_cli', skills: ['.gemini', 'config', 'skills'],
+    legacy_skills: ['.gemini', 'antigravity-cli', 'skills'] },
   cursor: { name: 'Grok（Cursor CLI）', commands: ['agent', 'cursor-agent'], skills: ['.cursor', 'skills'] },
 };
 const OPTIONS = { yes: { type: 'boolean' }, clients: { type: 'string' }, python: { type: 'string' },
@@ -222,16 +225,58 @@ export function remove_legacy_agy_rules(home, user_home) {
   return { client: 'Gemini', status: next.length !== allow.length ? 'removed' : 'unchanged', path };
 }
 
+/** Follow a linked skill directory so clients sharing one folder install a single copy. */
+function real_directory(path) {
+  try { return realpathSync.native(path); } catch { return resolve(path); }
+}
+
+/** True when an entry's include_only/exclude patterns let agy load every discussion skill; invalid patterns count as filtering. */
+function entry_loads_skills(entry) {
+  const matches = (patterns, name) => patterns.some(pattern => {
+    try { return new RegExp(`^(?:${pattern})$`).test(name); } catch { return true; }
+  });
+  const include = Array.isArray(entry.include_only) ? entry.include_only : null;
+  const exclude = Array.isArray(entry.exclude) ? entry.exclude : [];
+  return SKILLS.every(name => (!include || matches(include, name)) && !matches(exclude, name));
+}
+
+/** Absolute directories agy loads the discussion skills from through its global skills.json; agy leaves ~/ unexpanded on Windows. */
+function agy_skill_entries(user_home) {
+  const path = join(user_home, ...AGY_SKILL_CONFIG);
+  let config;
+  try { config = JSON.parse(readFileSync(path, 'utf8')); } catch { return []; }
+  return (Array.isArray(config?.entries) ? config.entries : [])
+    .filter(entry => typeof entry?.path === 'string' && entry_loads_skills(entry)).map(entry => entry.path)
+    .map(value => process.platform !== 'win32' && value.startsWith('~/') ? join(user_home, value.slice(2)) : value)
+    .filter(value => isAbsolute(value)).map(real_directory);
+}
+
+/** Pick the directory each client really reads; agy reuses a skills.json entry instead of its own folder. */
+function skill_targets(selected, user_home) {
+  const own = new Map(selected.map(client => [client.key, real_directory(join(user_home, ...client.skills))]));
+  const entries = agy_skill_entries(user_home);
+  return selected.map(client => {
+    const directory = own.get(client.key);
+    if (client.key !== 'antigravity' || !entries.length) return { client, directory, own: directory };
+    const others = selected.filter(item => item.key !== client.key).map(item => own.get(item.key));
+    return { client, directory: entries.find(entry => others.includes(entry)) || entries[0], own: directory };
+  });
+}
+
 /** Save the selected effective profiles and copy complete skills without overwriting edits. */
 async function configure_clients(home, selected, options, existing) {
   const participants = { ...existing };
   const skills = [], profiles = [];
   const user_home = resolve(options['skills-home'] || homedir());
-  for (const client of selected) {
+  const record = join(home, SKILL_RECORD), installed = new Map();
+  for (const { client, directory, own } of skill_targets(selected, user_home)) {
     const profile = await choose_profile(client, participants[client.name], options);
     profiles.push(profile);
     if (profile.status === 'configured') participants[client.name] = { ...participants[client.name], ...profile.effective };
-    skills.push({ client: client.name, results: install_skills(join(user_home, ...client.skills)) });
+    if (!installed.has(directory)) installed.set(directory, install_skills(directory, record));
+    const retired = [client.legacy_skills && real_directory(join(user_home, ...client.legacy_skills)), own]
+      .filter(path => path && path !== directory);
+    skills.push({ client: client.name, results: installed.get(directory), legacy: retired.flatMap(path => remove_legacy_skills(path, record)) });
   }
   save_launch_settings(home, { participants });
   const legacy = remove_legacy_agy_rules(home, user_home);
@@ -273,6 +318,9 @@ function setup_issues(result) {
   for (const group of result.skills) for (const skill of group.results) {
     if (skill.status === 'conflict') issues.push(`${group.client} 技能冲突，已保留 ${skill.path}；请核对并移走需替换的旧副本，再运行 setup。`);
   }
+  for (const group of result.skills) for (const skill of group.legacy) {
+    if (skill.status === 'kept') issues.push(`${group.client} 旧技能目录中的副本有改动，已保留 ${skill.path}；软件会同时加载新旧两份，请核对后删除。`);
+  }
   for (const permission of result.permissions) {
     if (permission.status === 'invalid') issues.push(`${permission.client} 设置文件无法解析，未能移除旧版全局放行规则：${permission.path}；修复后重新运行 setup，否则全自动讨论会拒绝交付给 agy。`);
   }

package/runner/discussion_skills.mjs

@@ -1,14 +1,14 @@
-/** Install complete skills without replacing an unmanaged or locally edited copy. */
+/** Install complete skills without replacing an unmanaged or locally edited copy; hashes live in the service home. */
 import { createHash } from 'node:crypto';
 import { cpSync, existsSync, lstatSync, mkdirSync, readFileSync, readdirSync, rmSync } from 'node:fs';
-import { join, resolve } from 'node:path';
+import { dirname, join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 
 import { atomic_json } from './discussion_adapters.mjs';
 
 const SOURCE = fileURLToPath(new URL('../.agents/skills/', import.meta.url));
-const SKILLS = ['discuss-host', 'discuss-participant', 'discuss-report'];
-const MANIFEST = '.codiscuss-skills.json';
+export const SKILLS = ['discuss-host', 'discuss-participant', 'discuss-report'];
+const LEGACY_MANIFEST = '.codiscuss-skills.json';
 
 /** Hash names and contents, rejecting links instead of following them outside a skill. */
 function tree_hash(directory) {
@@ -41,15 +41,49 @@ function install_skill(root, name, previous) {
   return { name, status: previous ? 'updated' : 'installed', path: destination, hash };
 }
 
+/** Read hashes recorded for one directory, folding in the copy older versions kept inside it. */
+function recorded_hashes(record, root) {
+  const data = existsSync(record) ? JSON.parse(readFileSync(record, 'utf8')) : {};
+  const legacy = join(root, LEGACY_MANIFEST);
+  return { data, previous: { ...(existsSync(legacy) ? JSON.parse(readFileSync(legacy, 'utf8')) : {}), ...data[root] } };
+}
+
+/** Save the record outside skill directories and drop the in-directory file older versions wrote. */
+function save_record(record, root, data) {
+  mkdirSync(dirname(record), { recursive: true });
+  atomic_json(record, data);
+  rmSync(join(root, LEGACY_MANIFEST), { force: true });
+}
+
 /** Install all three skills together and remember only copies this installer manages. */
-export function install_skills(directory) {
+export function install_skills(directory, record) {
   const root = resolve(directory);
   mkdirSync(root, { recursive: true });
-  const manifest = join(root, MANIFEST);
-  const previous = existsSync(manifest) ? JSON.parse(readFileSync(manifest, 'utf8')) : {};
+  const { data, previous } = recorded_hashes(record, root);
   const results = SKILLS.map(name => install_skill(root, name, previous[name]));
   const managed = { ...previous };
   for (const result of results) if (result.hash) managed[result.name] = result.hash;
-  atomic_json(manifest, managed);
+  save_record(record, root, { ...data, [root]: managed });
   return results.map(({ hash, ...result }) => result);
 }
+
+/** Remove unmodified copies a previous install left in a retired directory; edited copies stay. */
+export function remove_legacy_skills(directory, record) {
+  const root = resolve(directory);
+  if (!existsSync(root)) return [];
+  const { data, previous } = recorded_hashes(record, root);
+  if (!Object.keys(previous).length) return [];
+  const results = SKILLS.filter(name => previous[name] && existsSync(join(root, name))).map(name => {
+    const path = join(root, name);
+    let current;
+    try { current = tree_hash(path); } catch { return { name, status: 'kept', path }; }
+    if (current !== previous[name]) return { name, status: 'kept', path };
+    rmSync(path, { recursive: true });
+    return { name, status: 'removed', path };
+  });
+  const kept = Object.fromEntries(results.filter(result => result.status === 'kept').map(result => [result.name, previous[result.name]]));
+  const { [root]: _, ...rest } = data;
+  save_record(record, root, Object.keys(kept).length ? { ...rest, [root]: kept } : rest);
+  if (!readdirSync(root).length) rmSync(root, { recursive: true });
+  return results;
+}

package/runner/scheduler.mjs

@@ -12,7 +12,9 @@ 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 = 6;
+export const ROUTE_PROMPT_VERSION = 7;
+/** The same for the three discussion questions (interjection, next speaker, next round). */
+export const DISCUSSION_PROMPT_VERSION = 2;
 const HOST_CHOICE = '__host__';
 const NOTE_CHOICE = '__note__';
 const ALL_CHOICE = '__all__';
@@ -101,6 +103,11 @@ function judged_of(state, questions, answers) {
   return { detail: detail_of(questions, answers), input: { state, questions } };
 }
 
+/** Who has and has not spoken this round, so a decision knows who the plan still owes a turn. */
+function round_progress(spoken, waiting) {
+  return `本轮已发言：${spoken.join('、') || '无'}；本轮尚未发言：${waiting.join('、') || '无'}。`;
+}
+
 /** 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}，把握不足，交给主持人` : '拿不准，交给主持人';
@@ -152,7 +159,7 @@ export async function route_free_message(home, scheduler, { title, goal, context
     { value: ALL_CHOICE, description: '全体成员（含主持人）各自回应一次，彼此不需要看到别人的回答；只在要求简单明确、每人独立回应一次就算完成时选，如“大家打个招呼”“各自报一下在用的模型”' },
     { value: NONE_CHOICE, description: '无需回应：只是确认、致谢或旁注，不需要任何人回答' }];
   const questions = [{ type: 'choice', name: 'handler', choices,
-    instructions: '这条用户消息没有用 @ 点名成员。判断它的回应对象，按下面的顺序：1）正文叫了某位成员的名字，或在向其提问（包括“X在吗”“X还在吗”“X你怎么看”），选该成员，即使上一条是别人的回答；2）正文没有指向任何人时，看它是否在延续某位成员的回答（追问、要求修改、引用，或“回复”指向其消息），或在补充、纠正一条正由某位成员处理的消息，是则选该成员，是主持人就选主持人；3）符合“全体”选项的条件时选全体；只出现“大家”“都”“各自”“一起”等字眼不够；4）单独的问候或闲聊（如“hi”）既没有指向某位成员，也没有要求大家一起回应，选主持人；5）只是确认、致谢或旁注选无需回应；6）对象不明确，或要讨论、互相回应、分工、排先后时选主持人，由主持人安排。' }];
+    instructions: '这条用户消息没有用 @ 点名成员。判断它的回应对象，按下面的顺序：1）正文叫了某位成员的名字，或在向其提问（包括“X在吗”“X还在吗”“X你怎么看”），选该成员，即使上一条是别人的回答；同时提到几位成员时，选被直接称呼、要求其回应或做事的那位（如“A 你让 B 去改”是在对 A 说）；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);
@@ -187,12 +194,13 @@ export async function decide_group_order(home, scheduler, { title, goal, context
  * Decide one interjection in a discussion: continue the plan (note), ask one expert (ask) or wake the host (host).
  * Anything but a confident note or ask is returned as host.
  */
-export async function decide_interjection(home, scheduler, { title, goal, user_request, context, message, host, experts, ...extra }, fetch_impl) {
+export async function decide_interjection(home, scheduler, { title, goal, user_request, context, message, host, experts, spoken = [], ...extra }, fetch_impl) {
+  // Only experts still owed a turn this round can be asked: asking one who has spoken would open a new round.
   const choices = [...experts.map(name => ({ value: name, description: `请 ${name} 回应这条留言：留言是向该专家（或其负责的内容）提问、质疑或补充要求` })),
-    { value: HOST_CHOICE, description: `由主持人 ${host} 处理：留言要改变讨论目标、规则、分工、安排或结束讨论，或同时涉及多位专家` },
-    { value: NOTE_CHOICE, description: '仅补充信息：留言只是旁注、信息或鼓励，不要求任何人回应，按当前安排继续' }];
+    { value: HOST_CHOICE, description: `由主持人 ${host} 处理：留言要改变讨论目标、规则、分工、安排或结束讨论，同时涉及多位专家，或针对的是不在选项里的人（如本轮已发言的专家、主持人自己）` },
+    { value: NOTE_CHOICE, description: '仅补充信息：留言补充背景、约束或偏好，或只是旁注、鼓励，没有要求某人立即回应；后续发言的专家都能看到它，按当前安排继续' }];
   const questions = [{ type: 'choice', name: 'handling', instructions: '讨论进行中用户发来这条留言。对照当前焦点、主持简报和安排，判断它最适合怎样处理。', choices }];
-  const state = scheduler_state(title, context, message, goal, user_request, extra);
+  const state = scheduler_state(title, context, message, goal, user_request, { ...extra, progress: round_progress(spoken, experts) });
   const answers = await decide(home, scheduler, state, questions, fetch_impl);
   const judged = judged_of(state, questions, answers);
   const choice = answers.handling?.choice;
@@ -210,27 +218,19 @@ export async function decide_interjection(home, scheduler, { title, goal, user_r
  */
 export async function decide_next_speaker(home, scheduler, { title, goal, user_request, context, host, candidates, spoken = [], ...extra }, fetch_impl) {
   const recent = context.slice(-CONTEXT_MESSAGES).map(excerpt);
-  const progress = `本轮已发言：${spoken.join('、') || '无'}；本轮尚未发言：${candidates.join('、')}。`;
-  const state = [topic_lines(title, goal, user_request, { ...extra, progress }), recent.length ? `本轮及最近发言（旧→新）：\n${recent.join('\n')}` : '还没有发言。'].join('\n\n');
-  const choices = [...candidates.map(name => ({ value: name, description: `请 ${name} 接着发言：简报的分工或接龙顺序轮到 ${name}，或刚才的发言点名追问了 ${name}` })),
-    { value: HOST_CHOICE, description: `交给主持人 ${host}：没有明确该谁发言，或需要主持人重新安排` }];
-  // Having not spoken yet is no reason to speak: the host's plan may have ended on purpose, so the scheduler acts only on an explicit obligation.
+  const state = [topic_lines(title, goal, user_request, { ...extra, progress: round_progress(spoken, candidates) }), recent.length ? `本轮及最近发言（旧→新）：\n${recent.join('\n')}` : '还没有发言。'].join('\n\n');
+  // Having not spoken yet is no reason to speak: the host's plan may have ended on purpose, so a candidate needs an explicit basis.
+  const choices = [...candidates.map(name => ({ value: name, description: `请 ${name} 接着发言：简报的分工或流程规定轮到 ${name}，或最近的发言点名追问了 ${name}` })),
+    { value: HOST_CHOICE, description: `交给主持人 ${host}：简报和最近发言都没有明确规定下一位（仅仅是本轮还没发言不算依据），或需要主持人重新安排` }];
   const questions = [{ type: 'choice', name: 'speaker',
-    instructions: '主持人预排的安排已用完或被取消。对照主持简报的分工、当前焦点和主持人最近的安排，判断下一位应请谁发言。', choices },
-    { type: 'predicate', name: 'obligation',
-      instructions: `是否存在明确依据要求 ${candidates.join('、')} 之一接着发言：简报分工或流程规定轮到其人，或最近发言点名追问了其人？仅仅是“本轮还没发言”不算依据。` }];
+    instructions: '主持人预排的安排已用完或被取消，主持人可能有意只安排到这里。对照主持简报、当前焦点和主持人最近的安排，判断下一位应请谁发言。', choices }];
   const answers = await decide(home, scheduler, state, questions, fetch_impl);
   const judged = judged_of(state, questions, answers);
   const choice = answers.speaker?.choice;
   const confidence = certainty(answers.speaker);
-  const obligation = answers.obligation?.probability;
-  if (candidates.includes(choice) && confidence !== null && confidence >= ROUTE_CONFIDENCE && obligation >= ROUTE_CONFIDENCE) {
-    return { action: 'next', expert: choice, confidence, ...judged, label: `本轮继续，请 ${choice} 接着发言` };
-  }
-  if (typeof obligation === 'number' && obligation < ROUTE_CONFIDENCE) {
-    return { action: 'host', confidence, ...judged, label: `有明确依据的概率 ${obligation.toFixed(2)}，未达 ${ROUTE_CONFIDENCE.toFixed(2)}，交给主持人安排` };
-  }
-  return { action: 'host', confidence, ...judged, label: choice === HOST_CHOICE && confidence >= ROUTE_CONFIDENCE ? '建议由主持人调整安排，交给主持人' : unsure_label(candidates.includes(choice) ? `请 ${choice} 发言` : choice === HOST_CHOICE ? '交给主持人' : '') };
+  const sure = confidence !== null && confidence >= ROUTE_CONFIDENCE;
+  if (sure && candidates.includes(choice)) return { action: 'next', expert: choice, confidence, ...judged, label: `本轮继续，请 ${choice} 接着发言` };
+  return { action: 'host', confidence, ...judged, label: choice === HOST_CHOICE && sure ? '没有明确该谁发言，交给主持人安排' : unsure_label(candidates.includes(choice) ? `请 ${choice} 发言` : choice === HOST_CHOICE ? '交给主持人' : '') };
 }
 
 /**
@@ -239,7 +239,8 @@ export async function decide_next_speaker(home, scheduler, { title, goal, user_r
  */
 export async function decide_round(home, scheduler, { title, goal, user_request, context, host, experts, last_speaker, ...extra }, fetch_impl) {
   const candidates = experts.filter(name => name !== last_speaker);
-  const recent = context.slice(-CONTEXT_MESSAGES).map(excerpt);
+  // Telling repetition or drift needs at least the last two rounds side by side.
+  const recent = context.slice(-ROUTE_CONTEXT_MESSAGES).map(excerpt);
   const state = [topic_lines(title, goal, user_request, extra), recent.length ? `本轮及最近发言（旧→新）：\n${recent.join('\n')}` : '还没有发言。'].join('\n\n');
   const questions = [{ type: 'choice', name: 'next', instructions: '一轮发言刚结束。对照讨论目标、主持简报与当前焦点判断：下一轮是否还有明确的内容可以让大家互相回应、追问或补充？', choices: [
     { value: 'continue', description: '继续下一轮：最近发言里有未回应的分歧、追问或可展开的点，或简报规定的流程还没走完' },
@@ -250,8 +251,9 @@ export async function decide_round(home, scheduler, { title, goal, user_request,
   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;
+  // A wrong "continue" costs a whole round of runs, so it needs the same certainty as waking everyone.
+  if (choice !== 'continue' || confidence === null || confidence < ROUTE_WIDE_CONFIDENCE || !candidates.length) {
+    const sure = confidence !== null && confidence >= (choice === 'continue' ? ROUTE_WIDE_CONFIDENCE : ROUTE_CONFIDENCE);
     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];

package/runner/session_driver.mjs

@@ -1,9 +1,14 @@
 /** Smart scheduling and limit checks for a discussion hosted inside a free room. */
+import { readFileSync } from 'node:fs';
 import { api, peer_round_question } from './discussion_runner.mjs';
-import { decide_interjection, decide_next_speaker, decide_round } from './scheduler.mjs';
+import { DISCUSSION_PROMPT_VERSION, ROUTE_CONFIDENCE, ROUTE_CONTEXT_MESSAGES, ROUTE_WIDE_CONFIDENCE, decide_interjection, decide_next_speaker, decide_round } from './scheduler.mjs';
 
-const CONTEXT_MESSAGES = 12;
+const PACKAGE_VERSION = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8')).version;
 const MAX_QUOTE_CHARS = 300;
+/** How many of the latest plans describe "the host's recent arrangement" to the scheduler. */
+const ARRANGEMENT_TURNS = 3;
+const MAX_ARRANGEMENT_CHARS = 200;
+const TURN_STATUS_LABELS = { answered: '已发言', open: '发言中', queued: '排队中', cancelled: '已取消', skipped: '已跳过' };
 
 /** Read every page of current-session discussion plans; the list endpoint is capped at 20 rows per page. */
 async function read_all_turns(config) {
@@ -49,8 +54,9 @@ export class SessionDriver {
     try {
       const [roster, turns] = await Promise.all([api(this.config, '/turns/roster'), read_all_turns(this.config)]);
       const open_turn = turns.some(turn => ['open', 'queued'].includes(turn.status));
+      // An interjection is judged when someone can still be asked or a plan is running that a side note can leave alone.
       const should_decide = request.cause_kind === 'user_message'
-        ? roster.waiting.length > 0
+        ? roster.waiting.length > 0 || open_turn
         : !open_turn && (roster.waiting.length > 0 || !session.named_followup);
       if (!should_decide) return false;
       this.handled_requests.add(request.id);
@@ -60,7 +66,7 @@ export class SessionDriver {
       const suggestion = { message_id: request.source_message_id || latest_id, suggestion: plan.label,
         confidence: plan.confidence ?? null };
 
-      if (plan.action !== 'schedule') {
+      if (plan.action !== 'schedule' && plan.action !== 'continue') {
         await this.record_decision(plan, false, suggestion.message_id);
         this.suggestions.set(request.id, [suggestion]);
         return false;
@@ -76,7 +82,9 @@ export class SessionDriver {
         if (latest_roster.revision !== roster.revision) throw new Error('讨论名单或安排已变化，交回主持人');
         const host_token = this.config.members?.[room.host]?.token;
         if (!host_token) throw new Error('缺少主持人成员凭据，交回主持人');
-        await api(this.config, '/turns', { actor: room.host, turns: [plan.turn], roster: latest_roster.revision,
+        // A side note keeps the running plan: closing the host request is all that is needed.
+        if (plan.action === 'continue') await api(this.config, '/turns/continue', { actor: room.host, revision: latest_roster.revision }, host_token);
+        else await api(this.config, '/turns', { actor: room.host, turns: [plan.turn], roster: latest_roster.revision,
           submission_id: `session-driver-${session.id}-${request.id}` }, host_token);
         await this.record_decision(plan, true, suggestion.message_id);
         this.log(`智能调度 #${request.id}：${plan.label}`);
@@ -108,14 +116,15 @@ export class SessionDriver {
   /** Choose an eligible next task; manual and web members remain valid candidates from the roster. */
   async plan(session, roster, turns, request, room) {
     const latest_id = room.latest_id || 0;
-    const page = await api(this.config, `/messages?after=${Math.max(0, latest_id - CONTEXT_MESSAGES)}`);
+    const page = await api(this.config, `/messages?after=${Math.max(0, latest_id - ROUTE_CONTEXT_MESSAGES)}`);
     const base = { title: room.title, goal: session.goal || room.goal, user_request: room.user_request,
-      context: page.messages, host: room.host, brief: room.host_brief?.text, focus: room.focus, profiles: room.descriptions };
+      context: page.messages, host: room.host, brief: room.host_brief?.text, focus: room.focus, profiles: room.descriptions,
+      arrangement: arrangement_of(turns) };
     const last_answer = [...turns].filter(turn => turn.status === 'answered')
       .sort((left, right) => Number(left.answer_id || 0) - Number(right.answer_id || 0)).at(-1);
     const anchor = last_answer?.answer_id || request.source_message_id || latest_id;
 
-    if (request.cause_kind === 'user_message') return this.plan_interjection(base, page.messages, session, roster, request);
+    if (request.cause_kind === 'user_message') return this.plan_interjection(base, page.messages, session, roster, request, turns);
     const open = turns.some(turn => ['open', 'queued'].includes(turn.status));
     if (open) return null;
     if (roster.waiting.length) return this.plan_speaker(base, session, roster, turns, anchor);
@@ -130,12 +139,18 @@ export class SessionDriver {
   }
 
   /** Decide whether an unnamed user message should be answered by an expert or returned to the host. */
-  async plan_interjection(base, messages, session, roster, request) {
+  async plan_interjection(base, messages, session, roster, request, turns) {
     const message = messages.find(item => item.id === request.source_message_id)
       || messages.find(item => item.author === '用户' && item.id >= (session.held_since || 0));
-    if (!message || !roster.waiting.length) return null;
+    if (!message) return null;
+    const spoken = turns.filter(turn => turn.round === roster.round && turn.status === 'answered').map(turn => turn.expert);
     const result = await decide_interjection(this.config.api_home, this.config.scheduler,
-      { ...base, message, experts: roster.waiting }, this.fetch);
+      { ...base, message, experts: roster.waiting, spoken }, this.fetch);
+    if (result.action === 'note') {
+      // Continuing needs a plan to continue; with nothing open or queued the discussion would stall without the host.
+      if (turns.some(turn => ['open', 'queued'].includes(turn.status))) return { ...result, action: 'continue', kind: 'interjection', after_message_id: message.id };
+      return { ...result, action: 'host', kind: 'interjection', after_message_id: message.id, label: '仅补充信息，但当前没有进行中的安排，交给主持人' };
+    }
     if (result.action !== 'ask' || !roster.waiting.includes(result.expert)) {
       return { ...result, action: 'host', kind: 'interjection', after_message_id: message.id };
     }
@@ -165,11 +180,21 @@ export class SessionDriver {
     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, detail: plan.detail, input: plan.input });
+        after_message_id, detail: plan.detail, input: plan.input,
+        context: { model: this.config.scheduler.model, threshold: ROUTE_CONFIDENCE, wide_threshold: ROUTE_WIDE_CONFIDENCE,
+          prompt: DISCUSSION_PROMPT_VERSION, package: PACKAGE_VERSION } });
     } catch (error) { this.log(`智能调度决策记录未保存：${error.message}`); }
   }
 }
 
+/** The latest plans with their state, as the host's recent arrangement the questions refer to. */
+function arrangement_of(turns) {
+  return [...turns].sort((left, right) => Number(left.id || 0) - Number(right.id || 0)).slice(-ARRANGEMENT_TURNS).map(turn => {
+    const question = String(turn.question || '').replace(/\s+/g, ' ').trim();
+    return `${turn.expert}（第 ${turn.round} 轮，${TURN_STATUS_LABELS[turn.status] || turn.status}）：${question.length > MAX_ARRANGEMENT_CHARS ? `${question.slice(0, MAX_ARRANGEMENT_CHARS)}…` : question}`;
+  }).join('；');
+}
+
 function opening_question(phase) {
   return phase === 'initial' ? '请先独立阅读议题，给出你的开场观点。' : '请先阅读议题和已有回答，给出你的观点。';
 }