ai_co_discuss 0.2.33 → 0.2.34

package/runner/discussion_launch.mjs

@@ -11,7 +11,7 @@ import { parseArgs } from 'node:util';
 import { atomic_json } from './discussion_adapters.mjs';
 import { software_models } from './discussion_models.mjs';
 import { API_PROVIDERS, api_check, api_models, save_api_key, saved_api_keys, validate_api_profile } from './discussion_api.mjs';
-import { SCHEDULER_PROVIDERS } from './scheduler.mjs';
+import { SCHEDULER_PROVIDERS, scheduler_check } from './scheduler.mjs';
 import { acquire_lock, api, CODEX_ADAPTERS, DiscussionStore, service_drafts, task_files, validate_config } from './discussion_runner.mjs';
 import { assert_shared_home, CONNECTION_FIELDS, configuration_snapshot, read_registry, registered_identity, register_room, service_home, service_pid, start_service } from './discussion_service.mjs';
 
@@ -46,6 +46,7 @@ const HELP = `用法：codiscuss launch settings [--file FILE]
       codiscuss launch models --file FILE
       codiscuss launch api-key --file FILE
       codiscuss launch api-check --file FILE
+      codiscuss launch scheduler-check --file FILE
       codiscuss launch room-member --file FILE
       codiscuss launch pick-directory
 
@@ -56,6 +57,7 @@ room-models 只读指定 site、room_id 的本机登记模型与思考强度，
 models 按 adapter、executable 或 API profile 读取模型目录，不启动讨论或生成回答。
 api-key 将 base_url、api_key 保存于本机私有目录，只返回 api_key_ref。
 api-check 用 API profile 向模型发送一次极短请求，核对地址、密钥、协议与模型是否可用。
+scheduler-check 用智能调度配置（provider、model、api_key_ref）向决策模型发送一道是非题，核对供应商、模型与密钥是否可用。
 pick-directory 在本机弹出系统目录选择窗口，返回所选路径；取消时不返回路径。
 room-member 为运行中的自由房间或讨论邀请、请回一位成员（讨论只接受本机唤醒的成员）；须提供 site、room_id、token、action（add/rejoin）、name。
 JSON 指定 site、entry（conversation/web）、room（建房内容，含 submission_id）
@@ -409,6 +411,22 @@ export async function room_member(home, raw, locked = false) {
   } finally { release(); }
 }
 
+/**
+ * Register a manual Claude expert's own session as a hosted participant, so the service resumes it for later turns.
+ * Throws when the local Claude software is not configured or the session is not found on this machine; the member then stays manual.
+ */
+export function adopt_member_profile(home, path, name, session_id) {
+  const release = acquire_lock(join(dirname(path), 'configuration-edit'));
+  try {
+    const config = configuration_snapshot(path).config;
+    const input = { cwd: config.cwd, participants: { [name]: { adapter: 'claude', session_id } } };
+    const profile = borrowed_session(name, participant_profile(name, launch_settings(home).participants, input, false), config.cwd);
+    const next = { ...config, participants: { ...config.participants, [name]: profile } };
+    validate_config(next, dirname(path));
+    atomic_json(path, next);
+  } finally { release(); }
+}
+
 /** Stable signatures make changed retry requests explicit without putting credentials in receipts. */
 function signature(value) {
   if (Array.isArray(value)) return `[${value.map(signature).join(',')}]`;
@@ -718,6 +736,7 @@ export async function launch_main(args = process.argv.slice(2), input_text) {
     scheduler_providers: SCHEDULER_PROVIDERS, api_keys: saved_api_keys(home) };
   else if (positionals[0] === 'api-key' && input) result = save_api_key(home, input);
   else if (positionals[0] === 'api-check' && input) result = await api_check(home, input);
+  else if (positionals[0] === 'scheduler-check' && input) result = await scheduler_check(home, input);
   else if (positionals[0] === 'room-models' && input) result = room_models(home, input);
   else if (positionals[0] === 'models' && input?.adapter === 'api') result = await api_models(home, input);
   else if (positionals[0] === 'models' && input) {

package/runner/discussion_runner.mjs

@@ -308,7 +308,7 @@ export class DiscussionRunner {
   async smart_schedule(row, event) {
     if (!this.config.scheduler) return {};
     let plan;
-    try { plan = await this.plan_schedule(); }
+    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 }] : [];
@@ -337,22 +337,30 @@ export class DiscussionRunner {
     }
     return { done: true };
   }
-  /** Read the room and decide one interjection, or the next round when named follow-ups are off. Null leaves the host alone. */
-  async plan_schedule() {
+  /**
+   * 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 (room.limits?.reached || !ACTIVE_PHASES.includes(room.phase)) return null;
+    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, context: page.messages, host: room.host };
+    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 null;
+      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: message.id };
+      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) };
@@ -361,16 +369,41 @@ export class DiscussionRunner {
       // A note after the plan ran out falls through to deciding the next round.
       if (decision.action !== 'note') return plan;
     }
-    if (room.named_followup || room.queued_turns.length || !room.rounds?.at(-1)?.completed) return null;
+    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: room.latest_id };
+    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, '');
@@ -468,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) {

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

@@ -179,7 +179,7 @@ export class FreeRoomRunner {
     const message = page.messages.find(item => item.id === request.message_id);
     if (!message) return;
     const decision = await route_free_message(this.config.api_home, this.config.scheduler,
-      { title: room.title, context: page.messages, message, host: host.name, members }, this.fetch);
+      { 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,

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,66 +59,92 @@ 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 };
 }
 
 /**
  * Decide one interjection in a discussion: continue the plan (note), ask one expert (ask) or wake the host (host).
  * Anything but a confident note or ask is returned as host.
  */
-export async function decide_interjection(home, scheduler, { title, context, message, host, experts }, fetch_impl) {
+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 { choice, confidence = null } = answers.handling || {};
+  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: '交给主持人处理这条留言' };
+  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, context, host, experts, last_speaker }, fetch_impl) {
+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 = [`讨论：${title || ''}`, recent.length ? `本轮及最近发言（旧→新）：\n${recent.join('\n')}` : '还没有发言。'].join('\n\n');
-  const questions = [{ type: 'choice', name: 'next', instructions: '一轮发言刚结束。判断下一步：专家之间是否还有值得继续交锋的分歧？', choices: [
-    { value: 'continue', description: '继续下一轮：仍有未回应的质疑、分歧或新观点' },
-    { value: HOST_CHOICE, description: `交给主持人 ${host}：已可收束，或讨论跑偏、重复立场、卡住，需要主持人引导` }] }];
+  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, confidence = null } = answers.next || {};
+  const choice = answers.next?.choice;
+  const confidence = certainty(answers.next);
   if (choice !== 'continue' || confidence === null || confidence < ROUTE_CONFIDENCE || !candidates.length) {
-    return { action: 'host', confidence, label: '交给主持人：判断是否收束或调整方向' };
+    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} 发言` };

package/web/app.js

@@ -946,7 +946,7 @@ async function invite_member({ name, access, project_access = "read", session_id
     finish_member_request(room_id, token, record, result);
     if (state.room?.id === room_id) {
       state.free_notice = access === "online" ? `${record.member.name} 已加入，阅读通知与真实回答由你或授权主持人转交。`
-        : access === "manual" ? `${record.member.name} 已加入；点它的“启动指令”复制含凭证的整段说明，粘贴到你要用的 AI 会话即可。`
+        : access === "manual" ? `${record.member.name} 已加入；点它的“复制启动指令”，粘贴到你要用的 AI 会话即可。`
           : record.options?.session_id ? `${record.member.name} 已接入原会话；它工作时请不要在原窗口继续操作。`
           : state.room.mode === "free" ? `${record.member.name} 已加入，之后点名它即会由本机服务唤醒。`
             : `${record.member.name} 已加入讨论，主持人会重新安排发言。`;
@@ -1437,8 +1437,8 @@ async function local_launch_request(action, payload) {
     response = await fetch(`${local_connection?.endpoint || ""}/api/local/${action}`, {
       method: payload === undefined ? "GET" : "POST", headers, credentials: "omit", redirect: "error",
       body: payload === undefined ? undefined : JSON.stringify(payload),
-      ...(payload === undefined || ["room-models", "models", "api-check"].includes(action)
-        ? { signal: AbortSignal.timeout(["models", "api-check"].includes(action) ? MODEL_CATALOG_TIMEOUT_MS : LOCAL_CONNECTION_TIMEOUT_MS) } : {}) });
+      ...(payload === undefined || ["room-models", "models", "api-check", "scheduler-check"].includes(action)
+        ? { signal: AbortSignal.timeout(["models", "api-check", "scheduler-check"].includes(action) ? MODEL_CATALOG_TIMEOUT_MS : LOCAL_CONNECTION_TIMEOUT_MS) } : {}) });
   } catch (error) {
     if (!local_connection) throw error;
     throw new Error("无法连接本机服务：请在这台电脑运行 codiscuss local open，并允许浏览器访问本机网络，再重试原请求");
@@ -1778,6 +1778,12 @@ function write_scheduler(field, value) {
   publish_view();
 }
 
+/** Ask the local service to send the decision model one tiny question; throws its reason on failure. */
+async function check_scheduler() {
+  const { provider, model, api_key_ref } = state.launch.scheduler;
+  await local_launch_request("scheduler-check", { provider, model, api_key_ref });
+}
+
 /** Save the scheduling provider's key to the local private store, under that provider's official root. */
 async function save_scheduler_api_key(api_key) {
   const scheduler = state.launch.scheduler;
@@ -2200,7 +2206,7 @@ ${instruction}
 /** How a manual member learns it is its turn: free rooms are pulled by the member, discussions only on the host's assignment. */
 function manual_trigger_instruction(room) {
   return room.mode === "free" ? "首次复制后，可由人工或软件原生定时触发；自行提交，不必每轮复制回答。"
-    : "这是全自动讨论：只在主持人给你安排发言时才参与，先核对 turn current 是否轮到你，再按参与技能认领发言权并提交；没有安排就结束本次检查。你不会被自动唤醒，需要你或软件原生定时触发。";
+    : "这是全自动讨论：只在主持人给你安排发言时才参与，先核对 turn current 是否轮到你，再按参与技能认领发言权并提交；没有安排就结束本次检查。首次提交后，若你运行在 Claude Code 中，本机服务会自动接管你的会话并在后续轮次唤醒你；未被接管时才需要你或软件原生定时触发。";
 }
 
 /** Download a private per-room setup file for the independent local runner. */
@@ -3078,7 +3084,7 @@ function change_view_theme(theme) {
 
 window.discuss_view = { snapshot: view_snapshot, write_field: write_view_field,
   write_launch: write_launch_field, write_room_connection, write_room_adapter, launch_clients: LAUNCH_CLIENTS,
-  launch_model_state, load_launch_models, write_launch_model, save_launch_api_key, write_scheduler, save_scheduler_api_key, write_named_followup, check_launch_api, launch_summary, launch_can_set_access, launch_can_bind_session, pick_launch_directory, restore_launch_profile, reset_create_form, empty_discussion_message,
+  launch_model_state, load_launch_models, write_launch_model, save_launch_api_key, write_scheduler, save_scheduler_api_key, check_scheduler, write_named_followup, check_launch_api, launch_summary, launch_can_set_access, launch_can_bind_session, pick_launch_directory, restore_launch_profile, reset_create_form, empty_discussion_message,
   start_drag: start_directory_drag,
   attachment_markup, attachment_size, attachment_file_icon, drop_attachments, paste_attachments,
   write_expert: write_view_expert, add_instance: add_view_instance, platform_of, execute: execute_view_action, theme: change_view_theme,