ai_co_discuss 0.2.97 → 0.2.99

package/runner/discussion_service.mjs

@@ -13,6 +13,10 @@ import { DiscussionRunner, DiscussionStore, acquire_lock, api, load_config, paus
 import { FreeRoomRunner } from './free_runner.mjs';
 
 const POLL_MS = 2000;
+// A hosted site is polled less often than a local one: every request spends its database quota.
+const REMOTE_POLL_MS = 10_000;
+const UPDATE_RETRY_MS = 5000;
+const LOOPBACK = new Set(['127.0.0.1', 'localhost', '[::1]']);
 const REMOTE_SYNC_MS = 3000;
 const START_WAIT_MS = 5000;
 const STOP_WAIT_MS = 20_000;
@@ -274,7 +278,7 @@ class RoomWorker {
     }
     this.state.config_version = snapshot.version;
   }
-  /** A manual Claude or Codex expert that has registered and whose CLI reported its session is handed to the service, which resumes that session from the next turn on. */
+  /** A manual Claude, Codex or agy expert that has registered and whose CLI reported its session is handed to the service, which resumes that session from the next turn on. */
   async adopt_manual_members() {
     // A discussion runner lists members itself; a free room's registered manual members come from the room view.
     const members = this.config.mode === 'free' ? (await api(this.config, '')).free?.members || [] : this.runner.members || [];
@@ -344,32 +348,103 @@ export class DiscussionService {
     this.create_runner = create_runner;
     this.log = log;
     this.workers = new Map();
+    // How often each room is checked without a push: a local site costs nothing, a hosted one spends its database quota.
+    this.intervals = { local: POLL_MS, remote: REMOTE_POLL_MS };
+    // The resident service turns this on so a site's update stream checks its rooms at once; tests leave it off.
+    this.push = false;
+    this.streams = new Map();
+    this.closed = false;
   }
-  /** Reload the registry, close removed rooms, then tick every registered room. */
-  async tick() {
+  /**
+   * Reload the registry, close removed rooms, then tick the rooms that are due. `wait: true` ticks every idle room and
+   * waits for them; `wait: false` returns at once, so a slow remote site never delays the other rooms.
+   */
+  async tick({ wait = true } = {}) {
     const configs = read_registry(this.home);
     for (const [path, worker] of this.workers) {
-      if (!configs.includes(path)) { await worker.close(true); this.workers.delete(path); }
+      if (!configs.includes(path)) { await worker.busy; await worker.close(true); this.workers.delete(path); }
     }
     for (const path of configs) {
       if (!this.workers.has(path)) this.workers.set(path, new RoomWorker(path, this.create_runner, this.log, this.home));
       const worker = this.workers.get(path);
-      await worker.tick();
-      if (!worker.removed) continue;
-      // The room no longer exists on its website, so there is nothing to pause; drop the registration once.
-      const directory = worker.config?.directory;
-      await worker.close(false);
-      this.workers.delete(path);
-      try { unregister_room(this.home, path); } catch { /* Already removed by another command. */ }
-      // Its runtime, task files and answer drafts serve no one now; a file still held is left to the periodic sweep.
-      try { remove_room_files(this.home, path, directory); } catch (error) { this.log(`${worker.state.room || path}: 本机文件未能删除，稍后清理：${error.message}`); }
-      this.log(`${worker.state.site || ''}/${worker.state.room || path}: 房间已在网站删除，已撤销登记并删除本机文件`);
+      if (!worker.busy && (wait || Date.now() >= (worker.next_at ?? 0))) this.start(path, worker);
     }
+    if (this.push) for (const site of new Set([...this.workers.values()].map(worker => worker.state.site).filter(Boolean))) this.watch(site);
+    if (wait) await Promise.all([...this.workers.values()].map(worker => worker.busy));
+    this.write_status();
+  }
+  /** Start one room's tick; a room asked again while busy ticks once more right after. */
+  start(path, worker) {
+    if (this.closed) return;
+    if (worker.busy) { worker.woken = true; return; }
+    // Nothing awaits this tick, so its failure is logged here instead of crashing the service.
+    worker.busy = this.tick_worker(path, worker).catch(error => this.log(`${worker.state.room || path}: 检查失败：${error.message}`))
+      .finally(() => {
+        // Counted from the end of the tick, once the room's site is known; a slow site does not poll back to back.
+        const local = !worker.state.site || LOOPBACK.has(new URL(worker.state.site).hostname);
+        worker.next_at = Date.now() + (local ? this.intervals.local : this.intervals.remote);
+        worker.busy = null;
+        if (worker.woken && this.workers.get(path) === worker) { worker.woken = false; this.start(path, worker); }
+      });
+  }
+  /** Check every room of a site now, as its website reported a change. */
+  wake(site) {
+    for (const [path, worker] of this.workers) if (worker.state.site === site) this.start(path, worker);
+  }
+  /**
+   * Follow a site's `/api/updates` stream and wake its rooms on each change, so a message reaches the AI within
+   * milliseconds instead of the next poll. A site without push (204) is left to polling; a dropped stream reconnects.
+   */
+  watch(site) {
+    if (this.streams.has(site) || this.closed) return;
+    const controller = new AbortController();
+    const done = (async () => {
+      while (!controller.signal.aborted) {
+        try {
+          const response = await fetch(`${site}/api/updates`, { signal: controller.signal, headers: { accept: 'text/event-stream' } });
+          if (response.status === 204) return;
+          if (!response.ok || !response.body) throw new Error(`HTTP ${response.status}`);
+          const decoder = new TextDecoder();
+          let buffer = '';
+          for await (const chunk of response.body) {
+            buffer += decoder.decode(chunk, { stream: true }).replaceAll('\r\n', '\n');
+            for (let end = buffer.indexOf('\n\n'); end >= 0; end = buffer.indexOf('\n\n')) {
+              // `ready` comes on every (re)connection, so changes missed while disconnected are picked up too.
+              if (/^event: (change|ready)$/m.test(buffer.slice(0, end))) this.wake(site);
+              buffer = buffer.slice(end + 2);
+            }
+          }
+        } catch { /* Reconnect below; polling covers the gap. */ }
+        await sleep(UPDATE_RETRY_MS, undefined, { signal: controller.signal }).catch(() => {});
+      }
+    })();
+    this.streams.set(site, { controller, done });
+  }
+  /** Publish every room's latest state for `codiscuss status` and the website's service check. */
+  write_status() {
     atomic_json(join(this.home, 'status.json'), { pid: process.pid, updated_at: Math.floor(Date.now() / 1000),
       rooms: [...this.workers.values()].map(worker => worker.state) });
   }
-  /** Pause running rooms and release every lock and child process. */
+  /** Tick one room; a room deleted on its website is unregistered here. */
+  async tick_worker(path, worker) {
+    await worker.tick();
+    if (!worker.removed) return this.write_status();
+    // The room no longer exists on its website, so there is nothing to pause; drop the registration once.
+    const directory = worker.config?.directory;
+    await worker.close(false);
+    this.workers.delete(path);
+    try { unregister_room(this.home, path); } catch { /* Already removed by another command. */ }
+    // Its runtime, task files and answer drafts serve no one now; a file still held is left to the periodic sweep.
+    try { remove_room_files(this.home, path, directory); } catch (error) { this.log(`${worker.state.room || path}: 本机文件未能删除，稍后清理：${error.message}`); }
+    this.log(`${worker.state.site || ''}/${worker.state.room || path}: 房间已在网站删除，已撤销登记并删除本机文件`);
+  }
+  /** Pause running rooms and release every lock and child process, once their current ticks finish. */
   async close() {
+    this.closed = true;
+    for (const stream of this.streams.values()) stream.controller.abort();
+    await Promise.all([...this.streams.values()].map(stream => stream.done));
+    this.streams.clear();
+    await Promise.all([...this.workers.values()].map(worker => worker.busy));
     for (const worker of this.workers.values()) await worker.close(true);
     this.workers.clear();
   }
@@ -460,9 +535,10 @@ export async function run_service(home, output = () => {}) {
     output(line);
   };
   const service = new DiscussionService(home, undefined, log_line);
+  service.push = true;
   const stop_path = join(home, 'stop.request');
   if (existsSync(stop_path)) unlinkSync(stop_path);
-  let stopped = false;
+  let stopped = false, syncing = null;
   const stop = () => { stopped = true; };
   process.once('SIGINT', stop);
   process.once('SIGTERM', stop);
@@ -474,7 +550,7 @@ export async function run_service(home, output = () => {}) {
     const { sync_remote_launches } = await import('./remote_launch.mjs');
     let synced_at = 0, swept_at = 0;
     while (!stopped && !existsSync(stop_path)) {
-      try { await service.tick(); } catch (error) { log_line(`服务检查失败：${error.message}`); }
+      try { await service.tick({ wait: false }); } catch (error) { log_line(`服务检查失败：${error.message}`); }
       if (Date.now() - swept_at >= SWEEP_MS) {
         swept_at = Date.now();
         try {
@@ -484,13 +560,16 @@ export async function run_service(home, output = () => {}) {
           }
         } catch (error) { log_line(`清理本机文件失败：${error.message}`); }
       }
-      if (Date.now() - synced_at >= REMOTE_SYNC_MS) {
+      // Runs beside the room ticks: a slow remote site must not hold up local rooms.
+      if (!syncing && Date.now() - synced_at >= REMOTE_SYNC_MS) {
         synced_at = Date.now();
-        try { await sync_remote_launches(home, { log: log_line }); } catch (error) { log_line(`远程启动检查失败：${error.message}`); }
+        syncing = sync_remote_launches(home, { log: log_line }).catch(error => log_line(`远程启动检查失败：${error.message}`))
+          .finally(() => { syncing = null; });
       }
       await sleep(POLL_MS);
     }
   } finally {
+    await syncing;
     await service.close();
     if (existsSync(stop_path)) unlinkSync(stop_path);
     log_line('讨论服务已停止');

package/runner/expert_prompts.mjs

@@ -33,8 +33,92 @@ export function expert_prompt(profile = {}) {
   return String((own ? profile.system_prompt : EXPERT_PROMPT_PRESETS[profile.adapter]) || '').trim();
 }
 
+/** The line that introduces the member's own prompt after the fixed task text; the prompt dialog shows the same line. */
+export const EXPERT_PROMPT_HEADING = '用户为你单独设置的提示（补充做法与偏好，不改变权限与技能规则）：';
+
 /** Append the member's prompt to a task prompt, marked as the user's own guidance for this member. */
 export function with_expert_prompt(prompt, profile) {
   const extra = expert_prompt(profile);
-  return extra ? `${prompt}\n\n用户为你单独设置的提示（补充做法与偏好，不改变权限与技能规则）：\n${extra}` : prompt;
+  return extra ? `${prompt}\n\n${EXPERT_PROMPT_HEADING}\n${extra}` : prompt;
+}
+
+/*
+ * The fixed task text the runner adds for a member woken on this computer. It lives here, free of Node modules, so the
+ * expert prompt dialog shows the same text the runner sends, with placeholders for the values known only at delivery.
+ */
+
+/**
+ * Project access of a member woken on this computer: 只读, 可写 (project files and any command), 自动 (the software's own
+ * automatic approval) and 完全放开 (no approval or sandbox). A manual member the service took over is `own`.
+ */
+export const PROJECT_ACCESS = ['read', 'write', 'auto', 'full'];
+
+const ACCESS_LABELS = { read: '只读', write: '可写', auto: '自动', full: '完全放开' };
+
+/** What each level does in each software, measured headless (Claude Code 2.1.312, Codex CLI 0.163, agy 1.4.10). */
+const ACCESS_HINTS = {
+  claude: { read: '只放行网站命令与草稿，不改项目文件、不跑其他命令', write: '可改项目文件，Bash / PowerShell 命令全部放行（无沙箱）',
+    auto: 'Claude auto 模式：由分类器判断，实测项目外写入和联网都会放行', full: 'bypassPermissions：跳过全部权限检查' },
+  codex_cli: { read: '只读沙箱', write: '项目可写的沙箱，命令在沙箱内运行、可联网',
+    auto: '沙箱外的操作由模型申请提权，Codex 自动审核代替人工批准', full: '无沙箱、无审批（--dangerously-bypass-approvals-and-sandbox）' },
+  antigravity_cli: { read: '只放行网站命令；碰到未放行的命令会直接结束本轮', write: '可写项目，命令全部放行（在 agy 沙箱内）',
+    full: '再放开沙箱外命令与 MCP 工具' },
+};
+
+/** agy has no automatic mode headless ("not available for this account", tested 1.4.10), so it offers no 自动. */
+export function access_levels(adapter) {
+  return adapter === 'antigravity_cli' ? PROJECT_ACCESS.filter(level => level !== 'auto') : PROJECT_ACCESS;
+}
+
+/** The levels a software supports, labelled for the page, with what each does there on hover. */
+export function access_options(adapter) {
+  return access_levels(adapter).map(value => ({ value, label: ACCESS_LABELS[value], hint: ACCESS_HINTS[adapter]?.[value] || '' }));
+}
+
+/** The page's name for a level; `own` reads as decided by the member's own session. */
+export function access_label(level) { return level === 'own' ? '自行决定' : ACCESS_LABELS[level] || '只读'; }
+
+/**
+ * Whether a member may run commands beyond the codiscuss subcommands: every level but 只读, and 可写 only with a project.
+ * A taken-over manual member (`own`) keeps its own session's permissions, so the room's limits do not apply.
+ */
+export function runs_commands(config) {
+  const access = config.project_access;
+  return ['own', 'auto', 'full'].includes(access) || (access === 'write' && Boolean(config.cwd || config.workdir));
+}
+
+/** The task text's rule for project files and commands; `purpose` says what the member works for (按请求 / 按议题需要). */
+export function project_rule(profile, purpose) {
+  if (profile.project_access === 'own') return '项目文件与命令权限沿用你自己会话的软件设置。';
+  if (profile.project_access === 'auto') return `由软件自动审批：可${purpose}修改项目文件并运行所需命令；被沙箱或审批拦下时按软件方式申请放行（Codex 申请提权），仍被拒绝就在回答中说明。`;
+  if (profile.project_access === 'full') return `已跳过软件审批与沙箱，可${purpose}修改文件并运行所需命令。`;
+  if (!profile.cwd) return '未指定项目目录。';
+  return profile.project_access === 'write' ? `用户允许${purpose}修改 cwd 中的项目文件并运行所需命令。` : 'cwd 中的项目文件只读，不修改。';
+}
+
+/** A read-only agy project allows only codiscuss commands and headless agy ends the turn on a denied one, so every such agy task states it; no member prompt can drop it. */
+export function agy_command_rule(adapter, cli, config = {}) {
+  return adapter === 'antigravity_cli' && !runs_commands(config) ? `无人值守下 run_command 只能运行 ${cli} 的 subcommands 子命令，其他命令会被自动拒绝并使会话直接结束；列目录、搜索或读取文件用 list_dir、find_by_name、grep_search、view_file。` : '';
+}
+
+/** Windows PowerShell mis-decodes UTF-8 files; the runner adds this where the member's commands can run rg. */
+export const READ_RULE = '读取含中文的技能或文本文件时用 rg --encoding utf-8 . 文件路径，不用 Get-Content（Windows PowerShell 会按系统编码读出乱码，需要反复重试）。';
+
+/**
+ * A free-room task's fixed text: `instructions` saved in the task file and `prompt` sent with each wake-up, followed by
+ * the member's own prompt. `discussion` is a direct question asked while a discussion runs in the room.
+ */
+export function free_task_text({ name, role, discussion, profile, cli, room, messages, read_after, execution_id, task_path, read_rule = '', inbox = false }) {
+  // A task posted into a member's own open window has no process environment of ours, so it names the credential file.
+  const bound_access = !inbox && ['claude', 'codex_cli', 'antigravity_cli'].includes(profile.adapter);
+  const access_arg = bound_access ? '' : ' --access-file 凭据路径';
+  const access_rule = bound_access ? '本次凭据文件已通过进程环境 DISCUSS_ACCESS_FILE 绑定，codiscuss 自动读取，命令无需 --access-file。' : '';
+  const files_rule = project_rule(profile, '按请求');
+  // The host routes unnamed messages and receives hand-backs; it may name members in its answer.
+  const host_rule = role === 'host' && !discussion
+    ? `你是本房间的主持人：按任务 skills 中 discuss-host 的自由协作主持说明处理 route、handoff 与 all 请求。先用 ${cli} room view ${room} 查看成员与状态；派活在回答中加 --to 成员名（不能点名自己），只点名一位且还要它交回时加 --handoff。`
+    : '';
+  const instructions = `${agy_command_rule(profile.adapter, cli, profile)}${discussion ? '讨论房间：用户直接向你提问（' + messages + '）。这不是你的发言安排，不要领取发言权、不要安排他人，也不改变讨论进度，只回答这个提问。' : '自由协作房间：用户点名了你（' + messages + '）。'}${access_rule}先用 ${cli} message list ${room} --after ${read_after}${access_arg} 读取新消息，按时间顺序处理，后面的消息可能修正前面的，以最新指令为准。${host_rule}完成后用 ${cli} message post ${room} --as ${name} --kind chat --execution ${execution_id} --body-file 草稿 --submission-id 新UUID${access_arg} 提交一次回答。提交被拒绝说明本次执行已被打断或过期：保留草稿并结束，不要去掉 --execution 改作普通发言。草稿只写入 draft_directory；${files_rule}不读取或打印凭据内容，不建定时任务。`;
+  const prompt = `用户在${discussion ? '讨论' : '自由协作'}房间点名了你（${name}），对应消息 ${messages}。请先读取任务文件：${task_path}，按其中说明读取新消息、完成请求，并用 ${cli} message post 带 --execution ${execution_id} 提交一次回答后结束。${runs_commands(profile) ? '网站读写' : '命令'}只用任务内 subcommands 列出的 ${cli} 子命令；${files_rule}不读取凭据内容。${read_rule}`;
+  return { instructions, prompt };
 }

package/runner/free_runner.mjs

@@ -3,9 +3,10 @@ import { spawnSync } from 'node:child_process';
 import { createHash, randomUUID } from 'node:crypto';
 import { appendFileSync, mkdirSync, readFileSync, statSync } from 'node:fs';
 import { basename, join, resolve } from 'node:path';
-import { agy_command_rule, atomic_json, deliver_task, SegmentLog, sidecar_receipt, TASK_SUBCOMMANDS } from './discussion_adapters.mjs';
-import { api, CODEX_ADAPTERS } from './discussion_runner.mjs';
-import { with_expert_prompt } from './expert_prompts.mjs';
+import { atomic_json, claude_inbox_ready, deliver_task, SegmentLog, sidecar_receipt, TASK_SUBCOMMANDS } from './discussion_adapters.mjs';
+import { api, CODEX_ADAPTERS, read_rule } from './discussion_runner.mjs';
+import { free_task_text, with_expert_prompt } from './expert_prompts.mjs';
+import { BRANCHABLE_ADAPTERS, branch_session, session_exists } from './session_cut.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;
@@ -68,17 +69,11 @@ export function free_task_files(config, member, execution, binding) {
   atomic_json(access_path, { site: config.site, room: config.room, token: config.members[member.name].token,
     session_id: binding.session_id || '' });
   const cli = process.platform === 'win32' && profile.adapter !== 'claude' ? 'codiscuss.cmd' : 'codiscuss';
-  const bound_access = ['claude', 'codex_cli', 'antigravity_cli'].includes(profile.adapter);
-  const access_arg = bound_access ? '' : ' --access-file 凭据路径';
-  const access_rule = bound_access ? '本次凭据文件已通过进程环境 DISCUSS_ACCESS_FILE 绑定，codiscuss 自动读取，命令无需 --access-file。' : '';
-  const project_rule = !profile.cwd ? '未指定项目目录。'
-    : profile.project_access === 'write' ? '用户允许按请求修改 cwd 中的项目文件。' : 'cwd 中的项目文件只读，不修改。';
+  const inbox = claude_inbox_ready(profile, binding);
+  const bound_access = !inbox && ['claude', 'codex_cli', 'antigravity_cli'].includes(profile.adapter);
   const messages = execution.requests.map(item => `#${item.message_id}`).join('、');
-  // The host routes unnamed messages and receives hand-backs; it may name members in its answer.
-  const discussion = config.mode !== 'free';
-  const host_rule = member.role === 'host' && !discussion
-    ? `你是本房间的主持人：按任务 skills 中 discuss-host 的自由协作主持说明处理 route、handoff 与 all 请求。先用 ${cli} room view ${config.room} 查看成员与状态；派活在回答中加 --to 成员名（不能点名自己），只点名一位且还要它交回时加 --handoff。`
-    : '';
+  const { instructions, prompt } = free_task_text({ name: member.name, role: member.role, discussion: config.mode !== 'free', profile, cli,
+    room: config.room, messages, read_after: execution.read_until, execution_id: execution.id, task_path, read_rule: read_rule(profile.adapter), inbox });
   atomic_json(task_path, { site: config.site, room: config.room, mode: 'free', member: member.name,
     execution_id: execution.id, request_messages: execution.requests.map(item => item.message_id),
     request_purposes: execution.requests.map(item => item.purpose || 'ask'), role: member.role || 'member',
@@ -87,11 +82,9 @@ export function free_task_files(config, member, execution, binding) {
     skills: [...['discuss-participant/SKILL.md', 'discuss-participant/references/free.md'],
       ...member.role === 'host' ? ['discuss-host/SKILL.md', 'discuss-host/references/free.md'] : []].map(file => join(config.project, '.agents/skills', file)),
     cli, subcommands: TASK_SUBCOMMANDS,
-    ...(bound_access ? { access_env: 'DISCUSS_ACCESS_FILE' } : { access_file: access_path }),
-    instructions: `${agy_command_rule(profile.adapter, cli)}${discussion ? '讨论房间：用户直接向你提问（' + messages + '）。这不是你的发言安排，不要领取发言权、不要安排他人，也不改变讨论进度，只回答这个提问。' : '自由协作房间：用户点名了你（' + messages + '）。'}${access_rule}先用 ${cli} message list ${config.room} --after ${execution.read_until}${access_arg} 读取新消息，按时间顺序处理，后面的消息可能修正前面的，以最新指令为准。${host_rule}完成后用 ${cli} message post ${config.room} --as ${member.name} --kind chat --execution ${execution.id} --body-file 草稿 --submission-id 新UUID${access_arg} 提交一次回答。提交被拒绝说明本次执行已被打断或过期：保留草稿并结束，不要去掉 --execution 改作普通发言。草稿只写入 draft_directory；${project_rule}不读取或打印凭据内容，不建定时任务。` });
-  const prompt = `用户在${discussion ? '讨论' : '自由协作'}房间点名了你（${member.name}），对应消息 ${messages}。请先读取任务文件：${task_path}，按其中说明读取新消息、完成请求，并用 ${cli} message post 带 --execution ${execution.id} 提交一次回答后结束。命令只用任务内 subcommands 列出的 ${cli} 子命令；${project_rule}不读取凭据内容。`;
+    ...(bound_access ? { access_env: 'DISCUSS_ACCESS_FILE' } : { access_file: access_path }), instructions });
   return { id, participant: member.name, directory: config.directory, draft_directory,
-    skills_directory: join(config.project, '.agents', 'skills'), access_path, prompt: with_expert_prompt(prompt, profile) };
+    skills_directory: join(config.project, '.agents', 'skills'), access_path, prompt: with_expert_prompt(prompt, profile), inbox };
 }
 
 const ADAPTER_LABELS = { codex: 'Codex App', codex_cli: 'Codex CLI', claude: 'Claude Code', antigravity: 'Antigravity App',
@@ -100,8 +93,8 @@ const ADAPTER_LABELS = { codex: 'Codex App', codex_cli: 'Codex CLI', claude: 'Cl
 /** What a scheduler can know about a member without a role field: its software, project access and the messages it is on. */
 function member_description(name, profile, work) {
   const project = profile.project_name || (profile.cwd ? basename(profile.cwd) : '');
-  const access = profile.adapter === 'api' ? '' : !profile.cwd ? '，未指定项目目录'
-    : profile.project_access === 'write' ? `，可修改项目 ${project} 的文件` : `，项目 ${project} 只读`;
+  const access = profile.adapter === 'api' ? '' : profile.project_access === 'own' ? '，权限沿用其会话设置' : !profile.cwd ? '，未指定项目目录'
+    : profile.project_access === 'read' ? `，项目 ${project} 只读` : `，可修改项目 ${project} 的文件并运行命令`;
   return `${name}（${ADAPTER_LABELS[profile.adapter] || profile.adapter}${access}${work}）`;
 }
 
@@ -346,12 +339,15 @@ export class FreeRoomRunner {
     const before = workspace_snapshot(directory);
     if (before) this.snapshots.set(execution.id, { member: member.name, directory, before });
     const binding = this.store.binding(member.name);
-    if (!binding.session_id && adapter.session_id) binding.session_id = adapter.session_id;
+    // A member whose session a rewind restarted is bound to '' and must not fall back to the session it was invited with.
+    if (binding.session_id === undefined && adapter.session_id) binding.session_id = adapter.session_id;
     let invoked = false;
     try {
+      const warning = await this.cut_rewound(member.name, adapter, binding, execution);
       const task = free_task_files(this.config, member, execution, binding);
       invoked = true;
       this.segments.start(execution.id);
+      if (warning) this.note(execution.id, warning);
       const result = await this.deliver(adapter, binding, { ...task, room_title: this.room_title,
         api_context: { site: this.config.site, room: this.config.room, token: this.config.members[member.name].token,
           home: this.config.api_home, mode: 'free', role: member.role || 'member', execution_id: execution.id,
@@ -364,6 +360,8 @@ export class FreeRoomRunner {
         // 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: denial => this.exited.set(execution.id, denial || ''),
+        // Shown beside the answer or failure so the owner can allow them; a lost report only hides the list.
+        on_denials: denials => api(this.config, `/executions/${execution.id}`, { action: 'denials', denials }).catch(() => {}),
       });
       if (result.session_id) this.store.bind(member.name, result.session_id);
       this.save(member.name, { status: result.status === 'sidecar_pending' ? 'sidecar_pending' : 'running', attempts: 0 });
@@ -376,6 +374,26 @@ export class FreeRoomRunner {
       this.save(member.name, { status: 'idle', attempts, error: error.message });
     }
   }
+  /**
+   * Before a member works again after a rewind, branch its session before the executions the rewind took back.
+   * A Claude fork happens on its next turn, so it stays pending until that session exists. Returns a warning when the
+   * session could not be cut and the member continues in the old one.
+   */
+  async cut_rewound(name, adapter, binding, execution) {
+    const key = `session-fork:${name}`;
+    const pending = this.store.db.prepare('SELECT value FROM metadata WHERE key=?').get(key)?.value;
+    if (pending && !session_exists(adapter.adapter, binding.session_id)) { binding.fork = JSON.parse(pending); return ''; }
+    if (pending) this.store.db.prepare('DELETE FROM metadata WHERE key=?').run(key);
+    if (!binding.session_id || !execution.rewound_executions?.length || !BRANCHABLE_ADAPTERS.includes(adapter.adapter)) return '';
+    try {
+      const cut = await branch_session(adapter, binding.session_id, execution.rewound_executions);
+      if (!cut) return '';
+      if (cut.fork) this.store.db.prepare('INSERT INTO metadata VALUES (?,?) ON CONFLICT(key) DO UPDATE SET value=excluded.value').run(key, JSON.stringify(cut.fork));
+      this.store.bind(name, cut.session_id);
+      Object.assign(binding, cut);
+      return '';
+    } catch (error) { return `会话未能回退（${error.message}），本次沿用原会话，它可能仍记得已回退的内容`; }
+  }
   /** Follow the website's verdict; stop only this member's processes when its execution ends. */
   async reconcile(member, row, active, minutes) {
     if (row.status === 'reserving') return this.reserve(member, row);

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 = 5;
+export const ROUTE_PROMPT_VERSION = 6;
 const HOST_CHOICE = '__host__';
 const NOTE_CHOICE = '__note__';
 const ALL_CHOICE = '__all__';
@@ -148,11 +148,11 @@ 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}：没有指向任何人（如单独一句“hi”“你好”这类问候、闲聊，由主持人代表房间回应），或需要分工、排先后、互相回应` },
-    { 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: '这条用户消息没有用 @ 点名成员。判断它的回应对象，按下面的顺序：1）正文叫了某位成员的名字，或在向其提问（包括“X在吗”“X还在吗”“X你怎么看”），选该成员，即使上一条是别人的回答；2）正文没有指向任何人时，看它是否在延续某位成员的回答（追问、要求修改、引用，或“回复”指向其消息），或在补充、纠正一条正由某位成员处理的消息，是则选该成员，是主持人就选主持人；3）明确要求所有成员各自回应一次（用了“大家”“都”“各自”等）选全体；4）单独的问候或闲聊（如“hi”）既没有指向某位成员，也没有要求大家一起回应，选主持人；5）只是确认、致谢或旁注选无需回应；6）对象不明确，或需要分工、排先后、互相回应时选主持人。' }];
+    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);

package/runner/session_cut.mjs

@@ -0,0 +1,167 @@
+/**
+ * Branch a member's software session so a rewound or forked room continues from an earlier point. The original
+ * session is never changed: Claude forks through its own CLI on the next turn (--fork-session), Codex through its app
+ * server's thread/fork, and agy by copying its conversation database. Each execution's prompt names its task file
+ * (`free-<id>.task.json`), which marks where that execution entered the session.
+ */
+import { spawn } from 'node:child_process';
+import { randomUUID } from 'node:crypto';
+import { existsSync, readFileSync, readdirSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { createInterface } from 'node:readline';
+import { DatabaseSync } from 'node:sqlite';
+
+const FORK_TIMEOUT_MS = 60_000;
+// Software whose session this machine can branch; the website lists taken-back executions only for these members.
+export const BRANCHABLE_ADAPTERS = ['claude', 'codex', 'codex_cli', 'antigravity_cli'];
+
+/** The task file name an execution's prompt carries. */
+export const execution_marker = id => `free-${id}.task.json`;
+
+/** Where each software keeps one session, or '' when this machine has none by that ID. */
+function session_path(adapter, session_id, env, home) {
+  if (adapter === 'claude') {
+    const projects = join(env.CLAUDE_CONFIG_DIR || join(home, '.claude'), 'projects');
+    if (!existsSync(projects)) return '';
+    return readdirSync(projects).map(dir => join(projects, dir, `${session_id}.jsonl`)).find(existsSync) || '';
+  }
+  if (adapter === 'codex_cli') {
+    const sessions = join(env.CODEX_HOME || join(home, '.codex'), 'sessions');
+    if (!existsSync(sessions)) return '';
+    const found = readdirSync(sessions, { recursive: true }).map(String).find(path => path.endsWith(`-${session_id}.jsonl`));
+    return found ? join(sessions, found) : '';
+  }
+  const file = join(home, '.gemini', 'antigravity-cli', 'conversations', `${session_id}.db`);
+  return existsSync(file) ? file : '';
+}
+
+/** Whether a session exists on this machine, e.g. to tell if a pending Claude fork already happened. */
+export function session_exists(adapter, session_id, { env = process.env, home = homedir() } = {}) {
+  return Boolean(session_id && session_path(adapter, session_id, env, home));
+}
+
+/** JSON lines of a session log; lines the software wrote in another shape are skipped. */
+function log_entries(file) {
+  return readFileSync(file, 'utf8').split('\n').flatMap(line => { try { return [JSON.parse(line)]; } catch { return []; } });
+}
+
+/** The text of a prompt as the software stored it: a string, or text parts (tool results carry no prompt). */
+function prompt_text(content) {
+  if (typeof content === 'string') return content;
+  return Array.isArray(content) ? content.filter(part => ['text', 'input_text'].includes(part?.type)).map(part => part.text || '').join('\n') : '';
+}
+
+const marked = (text, markers) => markers.some(marker => text.includes(marker));
+
+/** Claude: fork on the next turn at the last answer before the first marked prompt; a cut before any answer starts anew. */
+function claude_branch(session_id, markers, always, env, home) {
+  const file = session_path('claude', session_id, env, home);
+  if (!file) throw new Error(`本机找不到 Claude 会话 ${session_id}`);
+  const entries = log_entries(file);
+  const index = entries.findIndex(entry => entry.type === 'user' && marked(prompt_text(entry.message?.content), markers));
+  if (index < 0) return always ? { session_id: randomUUID(), fork: { from: session_id, at: '' } } : null;
+  const at = entries.slice(0, index).findLast(entry => entry.type === 'assistant' && entry.uuid)?.uuid;
+  return at ? { session_id: randomUUID(), fork: { from: session_id, at } } : { session_id: '' };
+}
+
+/** Codex turns in order, and the index of the first turn whose user prompt carries a marker (-1 when none does). */
+function codex_turns(file, markers) {
+  const turns = [];
+  let cut = -1;
+  for (const entry of log_entries(file)) {
+    const payload = entry.payload || {};
+    if (entry.type === 'event_msg' && payload.type === 'task_started' && payload.turn_id) turns.push(payload.turn_id);
+    else if (cut < 0 && turns.length && entry.type === 'response_item' && payload.type === 'message' && payload.role === 'user'
+      && marked(prompt_text(payload.content), markers)) cut = turns.length - 1;
+  }
+  return { turns, cut };
+}
+
+/** Ask Codex's app server to fork a thread, through `last_turn` when given; returns the new thread's ID. */
+function codex_fork(profile, thread_id, last_turn, spawn_process) {
+  return new Promise((resolve_fork, reject) => {
+    const child = spawn_process(profile.executable, ['app-server'], { windowsHide: true, shell: false, stdio: ['pipe', 'pipe', 'pipe'] });
+    const lines = createInterface({ input: child.stdout, crlfDelay: Infinity });
+    let settled = false;
+    const finish = (error, value) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer); lines.close(); child.stdin.destroy(); child.kill();
+      if (error) reject(error); else resolve_fork(value);
+    };
+    const timer = setTimeout(() => finish(new Error('Codex 分叉会话超时')), FORK_TIMEOUT_MS);
+    const send = value => child.stdin.write(`${JSON.stringify(value)}\n`);
+    child.once('error', error => finish(error));
+    child.once('close', () => finish(new Error('Codex app-server 未完成分叉就退出了')));
+    child.stdin.on('error', error => finish(error));
+    child.stderr.resume();
+    lines.on('line', line => {
+      let reply;
+      try { reply = JSON.parse(line); } catch { return; }
+      if (reply.error && [1, 2].includes(reply.id)) return finish(new Error(`Codex 分叉会话失败：${reply.error.message}`));
+      if (reply.id === 1) {
+        send({ method: 'initialized', params: {} });
+        send({ id: 2, method: 'thread/fork', params: { threadId: thread_id, excludeTurns: true, ...(last_turn ? { lastTurnId: last_turn } : {}) } });
+      } else if (reply.id === 2) {
+        const id = reply.result?.thread?.id;
+        finish(id ? null : new Error('Codex 分叉会话没有返回新会话 ID'), id);
+      }
+    });
+    send({ id: 1, method: 'initialize', params: { clientInfo: { name: 'codiscuss', version: '0.1.0' } } });
+  });
+}
+
+/** Codex: fork through the turn before the first marked one; a cut at the first turn starts anew. */
+async function codex_branch(profile, session_id, markers, always, env, home, spawn_process) {
+  const file = session_path('codex_cli', session_id, env, home);
+  if (!file) throw new Error(`本机找不到 Codex 会话 ${session_id}`);
+  const { turns, cut } = codex_turns(file, markers);
+  if (cut < 0 && !always) return null;
+  if (cut === 0) return { session_id: '' };
+  return { session_id: await codex_fork(profile, session_id, cut > 0 ? turns[cut - 1] : '', spawn_process) };
+}
+
+/** agy: copy the conversation database under a new ID, without the steps from the first marked one on. */
+function agy_branch(session_id, markers, always, home) {
+  const file = session_path('antigravity_cli', session_id, process.env, home);
+  if (!file) throw new Error(`本机找不到 agy 会话 ${session_id}`);
+  const encoded = markers.map(marker => Buffer.from(marker, 'utf8'));
+  const source = new DatabaseSync(file, { readOnly: true });
+  const target = join(file, '..', `${randomUUID()}.db`);
+  let cut;
+  try {
+    // The prompt is stored inside the step's protobuf payload, as UTF-8 text.
+    cut = source.prepare('SELECT idx,step_payload FROM steps ORDER BY idx').all()
+      .find(row => row.step_payload && encoded.some(marker => Buffer.from(row.step_payload).includes(marker)))?.idx;
+    if (cut === undefined && !always) return null;
+    if (cut === 0) return { session_id: '' };
+    source.exec(`VACUUM INTO '${target.replaceAll("'", "''")}'`);
+  } finally { source.close(); }
+  const id = target.slice(-39, -3);
+  const copy = new DatabaseSync(target);
+  try {
+    if (cut !== undefined) copy.prepare('DELETE FROM steps WHERE idx>=?').run(cut);
+    copy.prepare('UPDATE trajectory_meta SET cascade_id=?').run(id);
+  } finally { copy.close(); }
+  return { session_id: id };
+}
+
+/**
+ * Branch a session before the first of some taken-back executions it contains, leaving the original untouched.
+ *
+ * @param {object} profile The member's local software profile (`adapter`, `executable`).
+ * @param {string} session_id The session the member is bound to.
+ * @param {number[]} executions Execution IDs whose turns the branch must not contain.
+ * @param {object} options `always` branches even when none of them is in the session (a forked room needs its own copy).
+ * @returns {Promise<null|{session_id: string, fork?: {from: string, at: string}}>} null when nothing needs cutting;
+ *   an empty session_id starts a new conversation; `fork` asks Claude's next turn to fork into session_id.
+ */
+export async function branch_session(profile, session_id, executions, { always = false, env = process.env, home = homedir(), spawn_process = spawn } = {}) {
+  const markers = executions.map(execution_marker);
+  if (profile.adapter === 'claude') return claude_branch(session_id, markers, always, env, home);
+  // A Codex App chat is stored like a CLI one; the App loads the fork when the first message is sent to it.
+  if (['codex', 'codex_cli'].includes(profile.adapter)) return codex_branch(profile, session_id, markers, always, env, home, spawn_process);
+  if (profile.adapter === 'antigravity_cli') return agy_branch(session_id, markers, always, home);
+  throw new Error(`${profile.adapter} 的会话不能由本机截断`);
+}