ai_co_discuss 0.3.11 → 0.3.13

package/runner/discussion_sidecar.mjs

@@ -1,50 +1,5 @@
-/** Run ONLY inside an Antigravity-managed Sidecar configured for one IPC directory. */
-import { execFileSync } from 'node:child_process';
-import { existsSync, readFileSync, readdirSync, writeFileSync } from 'node:fs';
-import { join, resolve } from 'node:path';
-import { atomic_json } from './discussion_adapters.mjs';
-
-const directory = resolve(process.env.CODISCUSS_IPC_DIRECTORY || process.cwd());
-const agentapi = process.env.ANTIGRAVITY_AGENTAPI_EXE;
-if (!agentapi) throw new Error('此程序必须由 Antigravity App Sidecar 启动');
-
-/** Consume each request once; a crash after claim leaves an explicit uncertain result. */
-async function process_request(name) {
-  const request = JSON.parse(readFileSync(join(directory, name), 'utf8'));
-  if (!/^[a-zA-Z0-9_-]+$/.test(request.id) || name !== `${request.id}.request.json`) return;
-  const claim = join(directory, `${request.id}.claimed`);
-  const receipt = join(directory, `${request.id}.result.json`);
-  if (existsSync(claim) || existsSync(receipt)) return;
-  writeFileSync(claim, String(process.pid), { flag: 'wx', mode: 0o600 });
-  try {
-    const access = JSON.parse(readFileSync(request.access_path, 'utf8'));
-    if (request.mode !== 'free') throw new Error('Sidecar 只支持自由协作执行请求，旧讨论事件已停用');
-    const response = await fetch(`${access.site}/api/rooms/${access.room}/executions/${request.event_id}`, {
-      method: 'GET', redirect: 'error', signal: AbortSignal.timeout(10000),
-      headers: { 'Content-Type': 'application/json', 'X-Discussion-Token': access.token },
-    });
-    const event = await response.json();
-    if (!response.ok || event.status !== 'dispatched') throw new Error('请求已撤销或状态不明，未调用软件');
-    if (event.lease_until <= Math.floor(Date.now() / 1000)) throw new Error('执行租约已到期，未调用软件');
-    const args = request.session_id ? ['send-message', request.session_id, request.prompt] : ['new-conversation', request.prompt];
-    const raw = execFileSync(agentapi, ['agentapi', ...args], { encoding: 'utf8', windowsHide: true, timeout: 30000 });
-    const result = JSON.parse(raw);
-    const session_id = request.session_id || result.response?.newConversation?.conversationId;
-    if (!session_id) throw new Error('未取得真实 conversation ID；创建结果待核对');
-    atomic_json(request.access_path, { ...access, session_id });
-    atomic_json(receipt, { id: request.id, session_id, status: 'accepted' });
-  } catch (error) {
-    atomic_json(receipt, { id: request.id, status: 'uncertain', error: String(error.message).slice(0, 500) });
-  }
-}
-
-/** Scan only our own private IPC directory; this performs no model polling. */
-async function scan_requests() {
-  for (const name of readdirSync(directory).filter(name => name.endsWith('.request.json'))) {
-    try { await process_request(name); } catch (error) { process.stderr.write(`${error.message}\n`); }
-  }
-}
-
-atomic_json(join(directory, 'ready.json'), { pid: process.pid, ready_at: Date.now(), project_id: process.env.ANTIGRAVITY_PROJECT_ID || '' });
-scan_requests();
-setInterval(scan_requests, 1000);
+/**
+ * Entry the Antigravity App starts for an installed Sidecar. Installed Sidecars record this path, so it stays here;
+ * the Sidecar itself is part of the Antigravity App adapter.
+ */
+import './adapters/antigravity_sidecar.mjs';

package/runner/discussion_skills.mjs

@@ -4,7 +4,7 @@ import { cpSync, existsSync, lstatSync, mkdirSync, readFileSync, readdirSync, rm
 import { dirname, join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 
-import { atomic_json } from './discussion_adapters.mjs';
+import { atomic_json } from './files.mjs';
 
 const SOURCE = fileURLToPath(new URL('../.agents/skills/', import.meta.url));
 export const SKILLS = ['discuss-host', 'discuss-participant', 'discuss-report'];

package/runner/execution_progress.mjs

@@ -0,0 +1,99 @@
+/**
+ * What each execution's software showed while it worked, kept until reported to the website: phase segments and
+ * progress notes. Fed by whichever adapter reached the software (see adapters/), read by the room runner.
+ */
+
+/** Segments one execution may record, how many one report carries, and a tool name's length; the website enforces the same. */
+export const MAX_EXECUTION_SEGMENTS = 400;
+export const MAX_SEGMENTS_PER_REPORT = 40;
+export const MAX_SEGMENT_TOOL = 60;
+/** Progress notes kept per execution, each cut to this length, and how many one report carries; the website enforces the same. */
+export const MAX_EXECUTION_NOTES = 50;
+export const MAX_NOTE_LENGTH = 500;
+export const MAX_NOTES_PER_REPORT = 10;
+
+/**
+ * What each execution's software showed while it worked, waiting to be reported: the phases it went through, as
+ * millisecond offsets from its delivery on this machine's clock, and its progress notes. Consecutive events of the same
+ * phase and tool extend one segment. The open segment is reported as far as it has run and again once it runs further;
+ * numbering makes a resent report harmless.
+ */
+export class SegmentLog {
+  constructor(now = Date.now) {
+    this.now = now;
+    this.executions = new Map();
+  }
+  /** Begin timing one execution at its delivery; a repeated start keeps the first origin. */
+  start(id) {
+    if (!this.executions.has(id)) this.executions.set(id, { origin: this.now(), last: 0, open: null, closed: [], next_seq: 0,
+      notes: [], next_note: 0, open_sent: null, reported: 0 });
+  }
+  /** Queue one progress note; notes past the cap are dropped. Cut by UTF-16 units like the website's check, never mid-pair. */
+  note(id, text) {
+    const log = this.executions.get(id);
+    if (!log || log.next_note >= MAX_EXECUTION_NOTES) return;
+    log.next_note += 1;
+    log.notes.push({ seq: log.next_note, text: text.slice(0, MAX_NOTE_LENGTH).replace(/[\uD800-\uDBFF]$/, '') });
+  }
+  /** The software produced output now; a phase, when the output names one, starts a new segment unless it continues the open one. */
+  mark(id, phase = '', tool = '') {
+    const log = this.executions.get(id);
+    if (!log) return;
+    log.last = this.now() - log.origin;
+    if (log.open) log.open.end_ms = log.last;
+    if (!phase) return;
+    tool = tool.slice(0, MAX_SEGMENT_TOOL).replace(/[\uD800-\uDBFF]$/, '');
+    if (log.open?.phase === phase && log.open.tool === tool) return;
+    if (log.open) log.closed.push(log.open);
+    log.open = null;
+    if (log.next_seq >= MAX_EXECUTION_SEGMENTS) return;
+    log.next_seq += 1;
+    log.open = { seq: log.next_seq, phase, tool, start_ms: log.last, end_ms: log.last };
+  }
+  /** Whether something new waits to be reported (an open segment only once it ran further) and the last report is `interval_ms` old. */
+  due(id, interval_ms) {
+    const log = this.executions.get(id);
+    const open_moved = log?.open && !(log.open_sent?.seq === log.open.seq && log.open_sent.end_ms === log.open.end_ms);
+    return Boolean(log && (log.closed.length || log.notes.length || open_moved) && this.now() - log.reported >= interval_ms);
+  }
+  /** The next report: closed segments first, then the open one as it stands, and the queued notes. `final` closes the open segment. */
+  batch(id, final = false) {
+    const log = this.executions.get(id);
+    if (!log) return { segments: [], notes: [] };
+    if (final && log.open) { log.closed.push(log.open); log.open = null; }
+    const segments = log.closed.slice(0, MAX_SEGMENTS_PER_REPORT);
+    if (log.open && segments.length < MAX_SEGMENTS_PER_REPORT) segments.push({ ...log.open });
+    return { segments, notes: log.notes.slice(0, MAX_NOTES_PER_REPORT) };
+  }
+  /** Forget what a successful report carried in full; a segment that ran on since it was sent stays. */
+  sent(id, batch) {
+    const log = this.executions.get(id);
+    if (!log) return;
+    const ends = new Map(batch.segments.map(segment => [segment.seq, segment.end_ms]));
+    log.closed = log.closed.filter(segment => !(ends.has(segment.seq) && segment.end_ms <= ends.get(segment.seq)));
+    const notes = new Set(batch.notes.map(note => note.seq));
+    log.notes = log.notes.filter(note => !notes.has(note.seq));
+    const open = log.open && batch.segments.find(segment => segment.seq === log.open.seq);
+    if (open) log.open_sent = { seq: open.seq, end_ms: open.end_ms };
+    log.reported = this.now();
+  }
+  /**
+   * Send the execution's segments and notes with `send({segments, notes})`. `final` closes the open segment, sends
+   * everything left and forgets the execution. A refused report drops them and any other failure keeps them for the
+   * next try; it never throws, so a progress report cannot fail the execution it describes.
+   */
+  async report(id, final, send) {
+    do {
+      const batch = this.batch(id, final);
+      if (!batch.segments.length && !batch.notes.length) break;
+      try { await send(batch); }
+      catch (error) {
+        if (/HTTP 4\d\d/.test(error.message)) this.drop(id);
+        return;
+      }
+      this.sent(id, batch);
+    } while (final && (this.executions.get(id)?.closed.length || this.executions.get(id)?.notes.length));
+    if (final) this.drop(id);
+  }
+  drop(id) { this.executions.delete(id); }
+}

package/runner/expert_prompts.mjs

@@ -3,10 +3,12 @@
  * software or one member needs. Presets exist only where a software needs one; a member's own
  * system_prompt, even an empty one, replaces its preset. They add guidance and never widen permissions.
  */
+// Plain data with no imports of its own, so this module stays loadable by the web page.
+import { adapter_profile } from './adapters/profiles.mjs';
 
 export const MAX_EXPERT_PROMPT = 4000;
 
-// A software's must-know rules are fixed by the runner (agy below, API in its system prompt), so no preset is needed now.
+// A software's must-know rules are fixed by the runner (its adapter profile's task_rules, API in its system prompt), so no preset is needed now.
 export const EXPERT_PROMPT_PRESETS = {};
 
 /**
@@ -51,35 +53,28 @@ 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: '跳过全部权限确认（--dangerously-skip-permissions），并放开沙箱外命令与 MCP 工具' },
-};
-
-/** agy offers 自动 only in its interactive window; headless `--mode auto` is "not available for this account" (1.4.10–1.4.11). */
+/** The levels a software can enforce headless, from its adapter profile; an App or API member is offered all of them. */
 export function access_levels(adapter) {
-  return adapter === 'antigravity_cli' ? PROJECT_ACCESS.filter(level => level !== 'auto') : PROJECT_ACCESS;
+  return adapter_profile(adapter)?.access_levels || PROJECT_ACCESS;
 }
 
-// Why a level a software lacks is shown but disabled, so every CLI card lines up the same four levels.
-const UNSUPPORTED_HINTS = { antigravity_cli: { auto: 'agy 只在交互窗口提供自动模式，后台运行（-p）不支持' } };
-
-/** All four levels labelled for the page, with what each does in this software on hover; ones it lacks are disabled. */
+/**
+ * All four levels labelled for the page, with what each does in this software on hover; ones it lacks are shown but
+ * disabled, so every CLI card lines up the same four levels.
+ */
 export function access_options(adapter) {
-  const levels = access_levels(adapter);
+  const levels = access_levels(adapter), profile = adapter_profile(adapter);
   return PROJECT_ACCESS.map(value => levels.includes(value)
-    ? { value, label: ACCESS_LABELS[value], hint: ACCESS_HINTS[adapter]?.[value] || '' }
-    : { value, label: ACCESS_LABELS[value], hint: UNSUPPORTED_HINTS[adapter]?.[value] || '该软件不支持此档位', disabled: true });
+    ? { value, label: ACCESS_LABELS[value], hint: profile?.access_hints?.[value] || '' }
+    : { value, label: ACCESS_LABELS[value], hint: profile?.unsupported_hints?.[value] || '该软件不支持此档位', disabled: true });
 }
 
 /** 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] || '只读'; }
 
+/** Website subcommands an automatic task may run; service, launch, run, api and setup stay unapproved. */
+export const TASK_SUBCOMMANDS = ['room', 'message', 'turn', 'state', 'review', 'execution', 'health', 'schema'];
+
 /**
  * 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.
@@ -98,14 +93,9 @@ export function project_rule(profile, purpose) {
   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。` : '';
-}
-
-/** agy streams no thinking text, so without a word at each turning point the page cannot show how far it got; fixed, so no member prompt drops it. */
-export function agy_progress_rule(adapter) {
-  return adapter === 'antigravity_cli' ? '多步任务中，在关键转折处用一句话写出进展再继续：agy 不输出思考过程，网页只能靠这些话显示你做到哪一步。' : '';
+/** The fixed rules one software needs in every task, from its adapter profile; no member prompt can drop them. */
+export function software_rules(config, cli) {
+  return adapter_profile(config.adapter)?.task_rules?.(cli, { runs_commands: runs_commands(config) }) || '';
 }
 
 /** Windows PowerShell mis-decodes UTF-8 files; the runner adds this where the member's commands can run rg. */
@@ -123,7 +113,7 @@ export const READ_RULE = '读含中文的文件用 rg --encoding utf-8 . 文件
 export function free_task_text({ name, discussion, discussion_request, profile, cli, room, messages, read_after, execution_id, task_path, access_file = '', read_rule = '' }) {
   const scope = discussion ? `讨论进行中，用户直接向你提问（${messages}）：只回答这个提问，不改变讨论安排和进度。` : '';
   const commands = runs_commands(profile) ? '' : `命令只用 subcommands 列出的 ${cli} 子命令。`;
-  const instructions = `${agy_command_rule(profile.adapter, cli, profile)}${agy_progress_rule(profile.adapter)}${scope}${project_rule(profile, '按请求')}${commands}草稿写在 draft_directory。`;
+  const instructions = `${software_rules(profile, cli)}${scope}${project_rule(profile, '按请求')}${commands}草稿写在 draft_directory。`;
   if (discussion_request) {
     const role = discussion_request.purpose === 'discuss_host' ? '主持任务' : '发言请求';
     const prompt = `你（${name}）收到了讨论中的${role}。先读任务文件 ${task_path}，按其中列出的技能处理本次请求并保存结果。${read_rule}`;

package/runner/files.mjs

@@ -0,0 +1,10 @@
+/** Small private files the runner keeps on this machine. */
+import { randomUUID } from 'node:crypto';
+import { renameSync, writeFileSync } from 'node:fs';
+
+/** Persist small private state atomically without logging its contents. */
+export function atomic_json(path, value) {
+  const temporary = `${path}.${randomUUID()}.tmp`;
+  writeFileSync(temporary, JSON.stringify(value, null, 2), { mode: 0o600 });
+  renameSync(temporary, path);
+}

package/runner/free_runner.mjs

@@ -3,12 +3,13 @@ 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 { atomic_json, claude_inbox_ready, deliver_task, remove_agy_projects, 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 { adapter_of, BRANCHABLE_ADAPTERS, branch_session, capabilities_of, cleanup_room, deliver_task, delivery_receipt, session_exists, stored_delivery } from './adapters/index.mjs';
+import { api, read_rule } from './discussion_runner.mjs';
+import { SegmentLog } from './execution_progress.mjs';
+import { free_task_text, TASK_SUBCOMMANDS, with_expert_prompt } from './expert_prompts.mjs';
+import { atomic_json } from './files.mjs';
 import { SessionDriver } from './session_driver.mjs';
-import { BRANCHABLE_ADAPTERS, branch_session, session_exists } from './session_cut.mjs';
-import { REVIEW_CONFIDENCE, REVIEW_PROMPT_VERSION, ROUTE_CONFIDENCE, ROUTE_CONTEXT_MESSAGES, ROUTE_PROMPT_VERSION, ROUTE_WIDE_CONFIDENCE, decide_group_order, decide_review_completion, route_free_message } from './scheduler.mjs';
+import { DEFAULT_SCHEDULER_MODE, REVIEW_CONFIDENCE, REVIEW_PROMPT_VERSION, ROUTE_CONFIDENCE, ROUTE_CONTEXT_MESSAGES, ROUTE_PROMPT_VERSION, ROUTE_WIDE_CONFIDENCE, decide_group_order, decide_review_completion, route_free_message, route_prompt_version } from './scheduler.mjs';
 
 const PACKAGE_VERSION = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8')).version;
 const RENEW_MS = 30_000;
@@ -28,7 +29,7 @@ const GIT_TIMEOUT_MS = 15_000;
 /** Fingerprint configurations whose adapter can enforce project read-only access; no local paths leave this function. */
 export function review_capability_version(profile, member, config) {
   if (!profile || profile.project_access !== 'read' || member.access !== 'runner' || member.session_mode !== 'new'
-    || profile.adapter !== 'codex_cli' || profile.adapter !== member.adapter
+    || !capabilities_of(profile.adapter).enforces_read_only || profile.adapter !== member.adapter
     || !profile.cwd || profile.allowed_tools?.length) return '';
   const project = cwd_key(profile.cwd), drafts = cwd_key(config.draft_directory || `${config.directory}-drafts`);
   if (drafts === project || drafts.startsWith(`${project}/`)) return '';
@@ -77,7 +78,7 @@ export function changed_between(before, after) {
 }
 
 /** Write a non-secret task and a member-only credential file for one execution. */
-export function free_task_files(config, member, execution, binding, { session = null, suggestions = [], reviews = [], process_access = true } = {}) {
+export function free_task_files(config, member, execution, binding, { session = null, suggestions = [], reviews = [], stopped = [], process_access = true } = {}) {
   const id = `free-${execution.id}`;
   const draft_directory = config.draft_directory || `${config.directory}-drafts`;
   mkdirSync(draft_directory, { recursive: true });
@@ -86,9 +87,10 @@ export function free_task_files(config, member, execution, binding, { session =
   const profile = config.participants[member.name];
   atomic_json(access_path, { site: config.site, room: config.room, token: config.members[member.name].token,
     session_id: binding.session_id || '', execution_id: execution.id });
-  const cli = process.platform === 'win32' && profile.adapter !== 'claude' ? 'codiscuss.cmd' : 'codiscuss';
-  const inbox = claude_inbox_ready(profile, binding);
-  const bound_access = process_access && !inbox && ['claude', 'codex_cli', 'antigravity_cli'].includes(profile.adapter);
+  const adapter = adapter_of(profile.adapter);
+  const cli = process.platform === 'win32' ? adapter?.windows_command || 'codiscuss.cmd' : 'codiscuss';
+  const inbox = Boolean(adapter?.into_window?.(profile, binding));
+  const bound_access = process_access && !inbox && Boolean(adapter?.capabilities.access_env);
   const messages = execution.requests.map(item => `#${item.message_id}`).join('、');
   const requests = execution.requests || [];
   const discussion_request = requests.find(item => item.session_request_id && ['discuss', 'discuss_host'].includes(item.purpose)) || null;
@@ -111,6 +113,7 @@ export function free_task_files(config, member, execution, binding, { session =
       goal: session.goal, named_followup: session.named_followup } } : {}),
     ...(suggestions.length ? { scheduler_suggestions: suggestions } : {}),
     ...(reviews.length ? { review_handoffs: reviews } : {}),
+    ...(stopped.length ? { stopped_executions: stopped } : {}),
     role: member.role || 'member',
     read_after: execution.read_until, cwd: profile.cwd || null, project_access: profile.project_access, draft_directory,
     skills: skills.map(file => join(config.project, '.agents/skills', file)),
@@ -120,15 +123,13 @@ export function free_task_files(config, member, execution, binding, { session =
     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',
-  antigravity_cli: 'Antigravity CLI', api: '模型 API，只能读写房间消息' };
 
 /** 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.project_access === 'own' ? '，权限沿用其会话设置' : !profile.cwd ? '，未指定项目目录'
+  const access = !capabilities_of(profile.adapter).project ? '，只能读写房间消息' : profile.project_access === 'own' ? '，权限沿用其会话设置' : !profile.cwd ? '，未指定项目目录'
     : profile.project_access === 'read' ? `，项目 ${project} 只读` : `，可修改项目 ${project} 的文件并运行命令`;
-  return `${name}（${ADAPTER_LABELS[profile.adapter] || profile.adapter}${access}${work}）`;
+  return `${name}（${adapter_of(profile.adapter)?.label || profile.adapter}${access}${work}）`;
 }
 
 /** The other messages a member is answering or has queued, so a correction can follow the message it corrects. */
@@ -165,6 +166,8 @@ export class FreeRoomRunner {
     this.routing = new Set();
     this.children = new Set();
     this.members = new Map();
+    // An empty set proves every tracked handle for this execution closed; a missing set proves nothing after restart.
+    this.execution_processes = new Map();
     // Execution id -> why its session ended on its own, such as a command refused in unattended mode ('' when unknown).
     this.exited = new Map();
     this.snapshots = new Map();
@@ -210,7 +213,7 @@ export class FreeRoomRunner {
    */
   same_context(name, previous, current) {
     const [before, after] = [JSON.parse(previous), JSON.parse(current)];
-    for (const context of [before, after]) if (CODEX_ADAPTERS.includes(context[0])) context[0] = 'codex';
+    for (const context of [before, after]) context[0] = adapter_of(context[0])?.session_family || context[0];
     const bound = this.store.binding(name).session_id;
     if (before[5] !== after[5] && [before[5], after[5]].includes('') && [before[5], after[5]].includes(bound)) after[5] = before[5];
     return JSON.stringify(before) === JSON.stringify(after);
@@ -225,10 +228,11 @@ export class FreeRoomRunner {
       room = await api(this.config, '');
     }
     catch (error) {
-      if (error.message === 'HTTP 404: 房间不存在') remove_agy_projects(this.config.directory);
+      if (error.message === 'HTTP 404: 房间不存在') cleanup_room(this.config.directory);
       throw error;
     }
     if (!inbox.archived) await this.sync_review_capabilities(inbox);
+    if (!inbox.archived) await this.sync_member_capabilities(inbox);
     if (!inbox.archived && room.mode === 'free' && room.session?.status === 'active'
       && await this.session_driver.tick(room, inbox)) {
       // A scheduled plan completes the pending host request and creates a speaker request.
@@ -249,14 +253,17 @@ export class FreeRoomRunner {
       if (LIVE.includes(row.status) && !present.has(row.member)) { this.stop_member(row.member); this.save(row.member, { status: 'idle' }); }
     }
     await this.report_finished(active);
+    const pending_stops = await this.report_stops(active);
     // Start in the room's speaking order: execution ids follow it, and the website lays out working cards by them.
     const rank = (room.speaking_order?.items || []).map(item => item.name);
     const place = name => rank.includes(name) ? rank.indexOf(name) : rank.length;
     for (const member of [...inbox.members].sort((left, right) => place(left.name) - place(right.name))) {
       const row = this.row(member.name);
       if (row && LIVE.includes(row.status)) await this.reconcile(member, row, active);
+      // A member voided in a window or App the runner could not stop waits until that turn ends (`held_until`).
       else if (!inbox.archived && member.pending.some(request => request.purpose !== 'group') && !this.members.get(member.name)?.size
-        && !member.pending.some(request => this.routing.has(request.id))) await this.start(member, row);
+        && !pending_stops.has(member.name)
+        && !member.pending.some(request => this.routing.has(request.id)) && !(member.held_until * 1000 > Date.now())) await this.start(member, row);
     }
   }
   /** Publish only changed local facts, using member revisions supplied by the owner's inbox. */
@@ -274,6 +281,18 @@ export class FreeRoomRunner {
       } catch (error) { this.log(`只读评审能力未同步：${member.name}：${error.message}`); }
     }
   }
+  /** Tell the site what a rewind does to each member's session, as its adapter says; only a change is sent. */
+  async sync_member_capabilities(inbox) {
+    for (const member of inbox.members) {
+      const profile = this.config.participants[member.name];
+      // An older site lists no effect and takes no report.
+      if (member.rewind === undefined || !profile) continue;
+      const rewind = capabilities_of(profile.adapter).rewind;
+      if (member.rewind === rewind) continue;
+      try { await api(this.config, `/members/${member.id}/capabilities`, { rewind }); member.rewind = rewind; }
+      catch (error) { this.log(`成员会话能力未同步：${member.name}：${error.message}`); }
+    }
+  }
   /** Hold only pending review handoffs while their preauthorized next step is judged. */
   schedule_reviews(inbox) {
     const host = inbox.members.find(member => member.role === 'host');
@@ -432,7 +451,8 @@ export class FreeRoomRunner {
     let record;
     if (decision.detail) {
       if (result.status === 'failed') label += '（未生效，网站写入失败）';
-      record = await this.record_decision(request.message_id, decision, label, result.applied && decision.action !== 'host');
+      // The @全体成员 question has one wording in every mode.
+      record = await this.record_decision(request.message_id, decision, label, result.applied && decision.action !== 'host', { prompt: ROUTE_PROMPT_VERSION });
     }
     this.save_suggestion(request, { action: decision.action, actual_action,
       applied: result.applied && decision.action !== 'host', model_judgment: Boolean(decision.detail),
@@ -462,7 +482,10 @@ export class FreeRoomRunner {
       const work = member_work(requests, member.name, message_id);
       const profile = this.config.participants[member.name];
       const described = room.descriptions?.[member.name] ? `；用户描述：${room.descriptions[member.name]}` : '';
-      return { id: member.id, name: member.name, role: member.role, description: profile ? member_description(member.name, profile, `${work}${described}`)
+      // The model and the last finished message are only read by the guided wording.
+      const finished = (room.free?.requests || []).filter(item => item.member === member.name && item.status === 'completed' && item.message_id !== message_id).at(-1);
+      return { id: member.id, name: member.name, role: member.role, model: profile?.model || '', finished: finished ? `#${finished.message_id}` : '',
+        description: profile ? member_description(member.name, profile, `${work}${described}`)
         : `${member.name}（${member.access === 'online' ? '网页 AI' : '手动接入'}，由用户代为触发${work}${described}）` };
     });
   }
@@ -523,7 +546,7 @@ export class FreeRoomRunner {
       return await api(this.config, '/scheduler-decisions', { kind: 'interjection', label, confidence: decision.confidence ?? null,
         applied, provider: this.config.scheduler.provider, after_message_id: message_id, detail: decision.detail, input: decision.input,
         context: { model: this.config.scheduler.model, threshold: ROUTE_CONFIDENCE, wide_threshold: ROUTE_WIDE_CONFIDENCE,
-          prompt: ROUTE_PROMPT_VERSION, package: PACKAGE_VERSION, ...context } });
+          mode: this.config.scheduler.mode || DEFAULT_SCHEDULER_MODE, prompt: route_prompt_version(this.config.scheduler.mode || DEFAULT_SCHEDULER_MODE), package: PACKAGE_VERSION, ...context } });
     } catch (error) { this.log(`智能调度 #${message_id} 决策记录未保存：${error.message}`); }
   }
   /** Reserve with a persisted client id before invoking any software. */
@@ -536,7 +559,7 @@ export class FreeRoomRunner {
   async reserve(member, record) {
     let execution;
     const profile = this.config.participants[member.name];
-    const cwd = profile?.adapter === 'api' ? '' : cwd_key(profile?.cwd || this.config.cwd);
+    const cwd = profile && !capabilities_of(profile.adapter).project ? '' : cwd_key(profile?.cwd || this.config.cwd);
     try { execution = await api(this.config, '/executions', { member_id: member.id, client_id: record.client_id, cwd }); }
     catch (error) {
       if (/HTTP (404|409)/.test(error.message)) return this.save(member.name, { status: 'idle', error: '' });
@@ -556,7 +579,7 @@ export class FreeRoomRunner {
     }
     if (!adapter) return this.fail(member.name, execution.id, `未配置 ${member.name} 的本机接入`);
     if (this.context_errors.has(member.name)) return this.fail(member.name, execution.id, this.context_errors.get(member.name));
-    const directory = adapter.adapter === 'api' ? undefined : adapter.cwd || this.config.cwd;
+    const directory = capabilities_of(adapter.adapter).project ? adapter.cwd || this.config.cwd : undefined;
     // A read-only member's software cannot write the project, so files changing meanwhile were written by someone else.
     const before = adapter.project_access === 'read' ? null : workspace_snapshot(directory);
     if (before) this.snapshots.set(execution.id, { member: member.name, directory, before });
@@ -572,8 +595,11 @@ export class FreeRoomRunner {
         : session_request?.purpose === 'discuss_host' ? this.session_driver.take_suggestions(session_request.id)
           : execution.requests.map(request => this.saved_suggestion(request.id)).filter(Boolean);
       const review_handoffs = await this.review_handoffs(execution);
+      // Executions the user stopped that this session may still hold; a rewind already cut its own out, and a new session holds none.
+      const rewound = new Set(execution.rewound_executions || []);
+      const stopped = binding.session_id ? this.stopped_executions(member.name).filter(id => !rewound.has(id)) : [];
       const task = free_task_files(this.config, member, execution, binding, {
-        session, suggestions: scheduler_suggestions, reviews: review_handoffs,
+        session, suggestions: scheduler_suggestions, reviews: review_handoffs, stopped,
       });
       invoked = true;
       this.segments.start(execution.id);
@@ -585,7 +611,7 @@ export class FreeRoomRunner {
           requests: execution.requests, read_after: execution.read_until, session, discussion_request: session_request,
           scheduler_suggestions, review_handoffs },
         on_binding: session => this.store.bind(member.name, session),
-        on_process: child => this.track(member.name, child),
+        on_process: child => this.track(member.name, child, execution.id),
         on_output: (path, chunk) => { appendFileSync(path, chunk, { mode: 0o600 }); this.touch(execution.id); this.segments.mark(execution.id); },
         on_activity: (phase, tool) => { this.touch(execution.id, phase); this.segments.mark(execution.id, phase, tool); },
         on_note: text => this.note(execution.id, text),
@@ -596,7 +622,9 @@ export class FreeRoomRunner {
         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.clear_stopped(member.name);
       this.save(member.name, { status: result.status === 'sidecar_pending' ? 'sidecar_pending' : 'running', attempts: 0 });
+      await this.report_delivery(execution.id, result.capabilities || capabilities_of(adapter.adapter).delivery, member.name);
     } catch (error) {
       if (review_request && error.delivery_status === 'not_sent') return this.reject_review(member, execution, error.message);
       if (adapter.project_access === 'own') return this.retry_or_fail(member.name, execution, `投递失败：${error.message}`);
@@ -660,7 +688,7 @@ export class FreeRoomRunner {
   async reconcile(member, row, active) {
     if (row.status === 'reserving') return this.reserve(member, row);
     if (row.status === 'sidecar_pending') {
-      const receipt = sidecar_receipt(this.config.participants[member.name], `free-${row.execution_id}`);
+      const receipt = delivery_receipt(this.config.participants[member.name], `free-${row.execution_id}`);
       if (receipt?.status === 'accepted' && receipt.session_id) {
         this.store.bind(member.name, receipt.session_id);
         this.save(member.name, { status: 'running' });
@@ -705,6 +733,79 @@ export class FreeRoomRunner {
       this.save(member.name, { last_renew: Date.now() });
     }
   }
+  /**
+   * Tell the site what this delivery can do, as the adapter reported it: whether the runner can stop it and see its
+   * progress. Kept locally until the execution ends so a restarted runner still knows whether it could stop it.
+   * A lost report is retained for the final stop result; sites and runners must use the same capability protocol.
+   */
+  async report_delivery(execution_id, { stoppable, progress }, member) {
+    this.store.db.prepare('INSERT OR REPLACE INTO metadata VALUES (?,?)').run(`delivery:${execution_id}`, JSON.stringify({ stoppable, progress, member }));
+    await api(this.config, `/executions/${execution_id}`, { action: 'delivery', stoppable, progress })
+      .catch(error => this.log(`执行 #${execution_id} 的投递能力未能上报：${error.message}`));
+  }
+  /** Retry durable stop reports even after the member went idle, left, or started a later execution. */
+  async report_stops(active) {
+    const pending = new Set();
+    for (const { key, value } of this.store.db.prepare("SELECT key,value FROM metadata WHERE key LIKE 'delivery:%'").all()) {
+      const execution_id = Number(key.slice('delivery:'.length));
+      if (active.has(execution_id)) continue;
+      const delivery = stored_delivery(value);
+      const name = delivery.member || this.store.db.prepare('SELECT member FROM free_deliveries WHERE execution_id=?').get(execution_id)?.member;
+      if (!name) continue;
+      for (const child of this.execution_processes.get(execution_id) || []) this.request_stop(child);
+      try { await this.report_stop(name, execution_id); }
+      catch (error) { pending.add(name); this.log(`执行 #${execution_id} 的停止结果未能上报：${error.message}`); }
+    }
+    return pending;
+  }
+  /** Report observed termination, never infer it from a capability or a successfully sent kill signal. */
+  async report_stop(name, execution_id) {
+    const key = `delivery:${execution_id}`;
+    const value = this.store.db.prepare('SELECT value FROM metadata WHERE key=?').get(key)?.value;
+    if (!value) return;
+    const delivery = stored_delivery(value), processes = this.execution_processes.get(execution_id);
+    const ended = processes ? processes.size === 0 : this.exited.has(execution_id);
+    const result = delivery.pending_result && delivery.pending_result !== 'unconfirmed' ? delivery.pending_result
+      : !delivery.stoppable ? 'unstoppable' : ended ? 'stopped' : 'unconfirmed';
+    if (delivery.stop_result === result) return;
+    // Keep the observed outcome before sending: a restart after a lost response must retry the same fact.
+    this.store.db.prepare('UPDATE metadata SET value=? WHERE key=?')
+      .run(JSON.stringify({ ...delivery, member: name, pending_result: result }), key);
+    try { await api(this.config, `/executions/${execution_id}`, { action: 'stopped', result }); }
+    catch (error) {
+      if (!/HTTP 409:/.test(error.message)) throw error;
+      const latest = await api(this.config, `/executions/${execution_id}`);
+      // A conflict is not necessarily normal completion: keep cancelled reports until an idempotent receipt arrives.
+      if (!['completed', 'failed'].includes(latest.status)) throw error;
+      this.store.db.prepare('DELETE FROM metadata WHERE key=?').run(key);
+      this.execution_processes.delete(execution_id);
+      return;
+    }
+    this.store.db.prepare('INSERT OR REPLACE INTO metadata VALUES (?,?)')
+      .run(`stopped:${name}`, JSON.stringify([...new Set([...this.stopped_executions(name), execution_id])]));
+    if (result === 'unconfirmed') {
+      this.store.db.prepare('UPDATE metadata SET value=? WHERE key=?')
+        .run(JSON.stringify({ ...delivery, member: name, pending_result: result, stop_result: result }), key);
+      // The site's bounded hold now controls the next delivery; retain handles to observe and retry termination.
+      for (const child of processes || []) this.members.get(name)?.delete(child);
+    }
+    else { this.store.db.prepare('DELETE FROM metadata WHERE key=?').run(key); this.execution_processes.delete(execution_id); }
+  }
+  /** Once a new task received the stop reminders, retire acknowledged unconfirmed reports for its old turns. */
+  clear_stopped(name) {
+    for (const id of this.stopped_executions(name)) {
+      const key = `delivery:${id}`, value = this.store.db.prepare('SELECT value FROM metadata WHERE key=?').get(key)?.value;
+      if (value && stored_delivery(value).stop_result === 'unconfirmed') {
+        this.store.db.prepare('DELETE FROM metadata WHERE key=?').run(key);
+        this.execution_processes.delete(id);
+      }
+    }
+    this.store.db.prepare('DELETE FROM metadata WHERE key=?').run(`stopped:${name}`);
+  }
+  /** Executions the user stopped since this member's last delivered task. */
+  stopped_executions(name) {
+    return JSON.parse(this.store.db.prepare('SELECT value FROM metadata WHERE key=?').get(`stopped:${name}`)?.value || '[]');
+  }
   /** Send the execution's recorded segments and progress notes; `final` sends the rest once it has ended. */
   report_segments(execution_id, final = false) {
     return this.segments.report(execution_id, final, ({ segments, notes }) =>
@@ -726,7 +827,7 @@ export class FreeRoomRunner {
   /** Report observed file changes once an execution has ended and its member's processes have exited. */
   async report_finished(active) {
     for (const [execution_id, snapshot] of this.snapshots) {
-      if (active.has(execution_id) || this.members.get(snapshot.member)?.size) continue;
+      if (active.has(execution_id) || this.execution_processes.get(execution_id)?.size) continue;
       this.snapshots.delete(execution_id);
       const after = workspace_snapshot(snapshot.directory);
       if (!after) continue;
@@ -759,14 +860,19 @@ export class FreeRoomRunner {
     this.stop_member(name);
   }
   /** Count live processes per member so one session never has two writers. */
-  track(name, child) {
+  track(name, child, execution_id = this.row(name)?.execution_id) {
     this.children.add(child);
     if (!this.members.has(name)) this.members.set(name, new Set());
     this.members.get(name).add(child);
-    child.once('close', () => { this.children.delete(child); this.members.get(name).delete(child); });
+    if (!this.execution_processes.has(execution_id)) this.execution_processes.set(execution_id, new Set());
+    const processes = this.execution_processes.get(execution_id);
+    processes.add(child);
+    child.once('close', () => { processes.delete(child); this.children.delete(child); this.members.get(name).delete(child); });
   }
+  /** Request termination; only a later close event proves it happened. */
+  request_stop(child) { try { child.kill(); } catch { /* The stop report remains unconfirmed. */ } }
   /** Stop one member's processes without touching other members or desktop apps. */
-  stop_member(name) { for (const child of this.members.get(name) || []) child.kill(); }
+  stop_member(name) { for (const child of this.members.get(name) || []) this.request_stop(child); }
   /** Stop every process this runner created. */
-  stop_children() { for (const child of this.children) child.kill(); }
+  stop_children() { for (const child of this.children) this.request_stop(child); }
 }