@y9931666/dsh-plugin-roundtable 1.0.0-rc.2

package/lib/index.js

@@ -0,0 +1,4535 @@
+import { C as withMeetingLock, D as writeTextAtomic, E as writeReview, S as stateRootOf, T as writeMeeting, _ as readUserActions, a as clearFeedback, b as sanitizeKey, c as listMeetings, f as readFeedback, g as readTranscript, h as readReview, i as appendUtterance, l as meetingDirOf, m as readMeeting, n as appendFeedback, o as clearFeedbackForMeeting, p as readKbDigest, r as appendUserAction, s as clearUserActions, v as readUserActionsReport, w as writeKbDigest, x as setViewpointStatus, y as resetMeetingDirectory } from "./state-BzBQig2q.js";
+import { n as workspaceCandidates, t as setWorkspaceCandidates } from "./workspace-candidates-DNmGPpSc.js";
+import z from "@deepseek-ai/schemastery";
+import { defineTool } from "@deepseek-ai/dsh-tools";
+import { randomUUID } from "node:crypto";
+import { mkdir, readFile, readdir, rm, stat } from "node:fs/promises";
+import { dirname, extname, isAbsolute, join } from "node:path";
+import { ReasoningEffortId, createUserMessage } from "@deepseek-ai/dsh-llm";
+import { homedir } from "node:os";
+
+//#region src/types.ts
+/** Node statuses that still count as participants. */
+const ACTIVE_NODE_STATUSES = [
+	"idle",
+	"working",
+	"ready"
+];
+/** Reserved speaker key of the captain (the owning session). */
+const CAPTAIN_KEY = "captain";
+/** Reserved speaker key of the aggregation gateway. */
+const AGGREGATOR_KEY = "aggregator";
+
+//#endregion
+//#region src/kb-digest.ts
+/** 缓存条目数上限；超出按 `ts` 最旧淘汰。 */
+const KB_DIGEST_MAX_ENTRIES = 50;
+/** 单条摘要字符上限；超出截断（缓存是"要点"，不是全文副本）。 */
+const KB_DIGEST_MAX_CHARS = 2e3;
+/**
+* 失效判定（纯函数）：失效键完全一致才算命中。
+*
+* `current === undefined`（文件已不存在 / 读不到）一律视为失效——宁可让
+* 主持人多读一次，也不要拿一份可能过期的摘要去回答专家。
+*/
+function digestIsFresh(entry, current) {
+	if (current === void 0) return false;
+	return entry.size === current.size && entry.mtimeMs === current.mtimeMs;
+}
+/**
+* 合并一条摘要（纯函数）：同 `path` 覆盖，其余按 `ts` 从新到旧保留，
+* 超出 `maxEntries` 的部分淘汰最旧。返回新数组，不改动入参。
+*/
+function mergeKbDigestEntry(entries, next, maxEntries = KB_DIGEST_MAX_ENTRIES) {
+	const kept = entries.filter((entry) => entry.path !== next.path);
+	kept.push({
+		...next,
+		digest: next.digest.slice(0, KB_DIGEST_MAX_CHARS)
+	});
+	kept.sort((a, b) => b.ts - a.ts);
+	return kept.slice(0, Math.max(1, maxEntries));
+}
+/**
+* 用磁盘现状标注每条缓存的 `valid`。
+*
+* 每条一次 `stat`：条目上限是 {@link KB_DIGEST_MAX_ENTRIES}（50），
+* 而且只在 `roundtable_status` 里调用，成本可忽略。
+*/
+async function evaluateKbDigests(entries) {
+	const out = [];
+	for (const entry of entries) {
+		let valid = false;
+		try {
+			const info = await stat(entry.path);
+			valid = info.isFile() && digestIsFresh(entry, {
+				size: info.size,
+				mtimeMs: info.mtimeMs
+			});
+		} catch {
+			valid = false;
+		}
+		out.push({
+			...entry,
+			valid
+		});
+	}
+	return out;
+}
+
+//#endregion
+//#region src/version.ts
+/**
+* 插件版本号的源码侧单一来源。
+*
+* `package.json` 的 `version` 是发布侧的权威值，两者必须一致：
+* `test/version.test.mjs` 会在不一致时直接让测试失败。加这道闸门是因为
+* `renderReviewMarkdown` 的导出头部曾长期硬编码 `v0.2.21`，而 package.json
+* 已经走到 0.2.32 —— 导出物里的版本号说了谎，却没有任何测试会发现。
+*
+* @module dsh-plugin-roundtable/version
+*/
+/** 当前插件版本（必须与 package.json 的 version 逐字一致）。 */
+const PLUGIN_VERSION = "1.0.0-rc.2";
+/** 导出物头部使用的插件标识行。 */
+const PLUGIN_ID = `@y9931666/dsh-plugin-roundtable v${PLUGIN_VERSION}`;
+/** DeepSeek Harness 版本区间（导出头部展示用）。
+*
+*  必须与 `compatibility.json` 的 `recommendedHost` 一致 —— 由
+*  `test/compatibility.test.mjs` 强制，`scripts/compatibility.mjs` 参与发布门禁。
+*  此前这里是硬编码字符串，与 devDependencies 一起漂到了 rc.2 而无人发现；
+*  0.2.0-rc.2 这次跨大版本升级同样由这两道闸门兜住。 */
+const HARNESS_RANGE = "DeepSeek Harness 0.2.0-rc.2+";
+
+//#endregion
+//#region src/charter.ts
+/** Build the charter text for one meeting's current roster and edges. */
+function buildCharter(meeting) {
+	const roster = meeting.nodes.filter((node) => node.status !== "removed").map((node) => `${node.key}${node.role !== void 0 && node.role !== "" ? `（${node.role}）` : ""}`).join("、");
+	const edges = meeting.edges.map((edge) => `${edge.from} ${edge.direction === "bidirectional" ? "⇄" : "→"} ${edge.to}`).join("、");
+	const redteamRules = meeting.mode === "redteam" ? [
+		"",
+		"五、针锋相对评审协议（本会议为「针锋相对」模式）",
+		"- 只找主持人已定稿方案的真实缺陷与认知盲区，严禁提出替代方案；指出问题要具体，不抬杠。",
+		"- 每条观点只聚焦一个缺陷（1~3 条）；如无缺陷可明确说明\"暂无\"。",
+		"- 证据分级：代码/bug 类缺陷附可复现步骤（\"可复现：1. …\"）；设计类缺陷附论证链（\"论证：因为…所以…\"），不得为设计类缺陷编造伪复现步骤。",
+		"- 闭环复审只核对上一轮已认定的缺陷是否被修复，禁止引入全新打分项。"
+	] : [];
+	return [
+		"《全局协作总纲》",
+		"",
+		"一、会议背景与核心目标",
+		meeting.goal.trim() === "" ? "（未提供，以主持人现场说明为准）" : meeting.goal,
+		"",
+		"二、团队成员与角色边界",
+		"主持人（DeepSeek）：全局编排与最终汇总，唯一对用户负责。",
+		`专家节点：${roster === "" ? "（暂无）" : roster}`,
+		`连线通道：${edges === "" ? "（暂无）" : edges}`,
+		"权限隔离：节点只做本职，严禁越权代管其他节点的工作；只有主持人可以创建/移除节点、修改连线、发起人类决策、结束会议。",
+		"",
+		"三、标准化协作协议",
+		"- 每次发言以 [当前状态] 开头、以 [核心产出] 与 [下一步建议] 结尾；严禁\"好的\"\"收到\"这类无信息量内容。",
+		"- 发言通过 roundtable_speak 写入会议记录（to 留空 = 交汇聚网关；定向回复填对方 key）。",
+		"",
+		"四、全局约束与安全红线",
+		"- 遇到分歧或无法独自决定的事项，建议主持人触发 [需人类决策]，严禁自行替用户拍板。",
+		"- 严禁编造不存在的 API、数据或事实；不确定时明确说明。",
+		"- 超预算（轮数/Token）时会议自动闭麦。",
+		...redteamRules
+	].join("\n");
+}
+
+//#endregion
+//#region src/aggregator.ts
+const MAX_LENGTH = 4e3;
+const MAX_PER_UTTERANCE = 160;
+/** Pull the "core output" / stance out of a formatted contribution, else compact the whole text.
+*
+*  导出给 `roundtable_status` 复用：同一条 400 字符的配额，取 `[核心产出]`
+*  比取发言开头（`[当前状态]`）信息量大得多 —— 不是配额不够，是取错了地方。 */
+function extractCore(text) {
+	const core = text.match(/\[核心产出\]\s*([\s\S]*?)(?=\n\s*\[|$)/)?.[1]?.trim();
+	if (core) return core;
+	const stance = text.match(/(?:立场|主张|观点|结论)[：:]\s*([\s\S]*?)(?=\n|$)/)?.[1]?.trim();
+	if (stance) return stance;
+	return text.replace(/\s+/g, " ").trim();
+}
+function compact(text, limit) {
+	const single = text.replace(/\s+/g, " ").trim();
+	return single.length > limit ? `${single.slice(0, limit)}…` : single;
+}
+/** Merge utterances into a compact, chronological exchange (who → whom: core point). */
+function aggregateUtterances(utterances, maxLength = MAX_LENGTH) {
+	const lines = [];
+	for (const utterance of utterances) {
+		if (utterance.kind !== "speech" && utterance.kind !== "proxy-thinking") continue;
+		const from = utterance.nodeKey;
+		const to = utterance.to ?? "网关";
+		const body = compact(extractCore(utterance.summary ?? utterance.content), MAX_PER_UTTERANCE);
+		lines.push(`[R${utterance.round}] ${from} → ${to}\n${body}`);
+	}
+	const text = `[汇聚网关·交锋摘要]\n${lines.join("\n\n") || "（暂无发言）"}`;
+	return text.length > maxLength ? `${text.slice(0, maxLength)}\n…(截断)` : text;
+}
+
+//#endregion
+//#region src/budget.ts
+/** Which budget axis is exceeded, if any. */
+function budgetExceeded(meeting) {
+	if (meeting.round > meeting.budget.maxRounds) return "rounds";
+	if (meeting.budget.usedTokens >= meeting.budget.maxTokens) return "tokens";
+}
+/** Error when the meeting has ended. */
+var MeetingEndedError = class extends Error {
+	constructor(meetingId) {
+		super(`roundtable: meeting "${meetingId}" has ended — start a new meeting`);
+		this.name = "MeetingEndedError";
+	}
+};
+/** Error when the meeting is muted (闭麦) on a budget axis. */
+var MeetingMutedError = class extends Error {
+	axis;
+	constructor(meetingId, axis) {
+		super(`roundtable: meeting "${meetingId}" is muted on ${axis} — the captain may top up the budget with roundtable_set_budget or close the meeting`);
+		this.name = "MeetingMutedError";
+		this.axis = axis;
+	}
+};
+/**
+* Gate a write against the meeting's status and budget WITHOUT mutating it.
+*
+* The previous `ensureActive` both flipped `status` to `'muted'` and then threw
+* on the same call. Because the throw happened before the caller could persist
+* anything, `muted` never reached disk, and the very tools meant to resolve the
+* situation (`roundtable_set_budget`, `roundtable_close`, the two exporters)
+* were rejected by that same gate — a meeting that had spent its budget stayed
+* `active` forever while refusing every action.
+*
+* @param meeting - meeting to test.
+* @param options.allowMuted - resolve/escalate paths (top up the budget, close,
+*   export, clear the user-action queue) stay reachable while muted; everything
+*   that produces new work still throws.
+*/
+function assertUsable(meeting, options = {}) {
+	if (meeting.status === "ended" || meeting.status === "archived") throw new MeetingEndedError(meeting.id);
+	if (options.allowMuted === true) return;
+	const axis = budgetExceeded(meeting);
+	if (axis !== void 0) throw new MeetingMutedError(meeting.id, axis);
+}
+/**
+* Persist the fact that the meeting is out of budget.
+*
+* @param meeting - meeting mutated in place.
+* @returns true when the status just became `'muted'`, in which case the caller
+*   owns writing the meeting back so the mute is actually observable.
+*/
+function markMuted(meeting) {
+	if (meeting.status !== "active") return false;
+	if (budgetExceeded(meeting) === void 0) return false;
+	meeting.status = "muted";
+	return true;
+}
+/** Estimate the token cost of a text (coarse: ~0.6 tokens per CJK char, ~0.3 per latin). */
+function estimateTokens(text) {
+	let cjk = 0;
+	let other = 0;
+	for (const char of text) if ((char.codePointAt(0) ?? 0) >= 11904) cjk += 1;
+	else if (char.trim() !== "") other += 1;
+	return Math.ceil(cjk * .6 + other * .3);
+}
+/** Advance the meeting round and return the new round number. */
+function beginRound(meeting) {
+	meeting.round += 1;
+	meeting.budget.usedRounds = meeting.round;
+	return meeting.round;
+}
+
+//#endregion
+//#region src/node-events.ts
+/** childId → meeting location. Process-local on purpose (see module docs). */
+const nodeIndex = /* @__PURE__ */ new Map();
+/** Remember which meeting a freshly spawned node belongs to. */
+function registerNodeChild(childId, location) {
+	if (childId === "") return;
+	nodeIndex.set(childId, location);
+}
+/** Drop one node's index entry (node removed, or failed spawn rolled back). */
+function forgetNodeChild(childId) {
+	if (childId === "") return;
+	nodeIndex.delete(childId);
+}
+/** Look up a node's meeting by its child session id. */
+function locateNodeChild(childId) {
+	return nodeIndex.get(childId);
+}
+/** Meeting-level lock key; mirrors `meetingLockKey` in tools.ts. */
+function lockKey(location) {
+	return `meeting:${location.stateRoot}:${location.meetingId}`;
+}
+/** Flatten the text blocks of one assistant output (empty when there is none). */
+function blocksToText(blocks) {
+	if (blocks === void 0 || blocks.length === 0) return "";
+	const parts = [];
+	for (const block of blocks) {
+		const candidate = block;
+		if (candidate.type === "text" && typeof candidate.text === "string") parts.push(candidate.text);
+	}
+	return parts.join("\n").trim();
+}
+/**
+* Decide what a settled child run contributes to its meeting.
+*
+* A run that ends `completed` but carries no text is *not* a hard failure (the
+* expert may have only acknowledged), so it gets its own wording — the point is
+* to never leave the captain guessing between "still working" and "died".
+*/
+function describeNodeEnd(info) {
+	const text = blocksToText(info.lastAssistantMessage);
+	if (text !== "") return {
+		text,
+		note: ""
+	};
+	const reason = info.stopReason ?? "unknown";
+	return {
+		text: "",
+		note: reason === "completed" ? "本轮结束但没有产出内容（可能只回了确认，未见 roundtable_speak）" : `本轮未产出内容（stopReason=${reason}）`
+	};
+}
+/** One-line readable description of a provider request failure. */
+function describeRequestFailure(provider, failure) {
+	const status = typeof failure?.status === "number" ? ` HTTP ${failure.status}` : "";
+	const code = typeof failure?.code === "string" && failure.code !== "" ? ` ${failure.code}` : "";
+	const message = typeof failure?.message === "string" ? failure.message.trim().slice(0, 200) : "";
+	return `请求失败（provider=${provider}${status}${code}）${message === "" ? "" : `：${message}`}`;
+}
+/** Write one node-level note (cleared by passing `undefined`). */
+async function writeNodeNote(location, childId, note) {
+	await withMeetingLock(lockKey(location), async () => {
+		const meeting = await readMeeting(location.stateRoot, location.meetingId);
+		if (meeting === void 0) return;
+		const node = meeting.nodes.find((candidate) => candidate.id === childId && candidate.status !== "removed");
+		if (node === void 0) return;
+		if (node.lastError === note) return;
+		node.lastError = note;
+		meeting.updatedAt = Date.now();
+		await writeMeeting(location.stateRoot, meeting);
+	});
+}
+/**
+* Capture one settled child run.
+*
+* With output: append it as an `auto-capture` utterance and clear `lastError`,
+* so a node that spoke via the event path still lands in the transcript even
+* though it never called `roundtable_speak`.
+* Without output: leave a readable `lastError` on the node.
+*/
+async function onNodeEnd(ctx, info) {
+	const childId = String(info.id ?? "");
+	if (childId === "") return;
+	const location = locateNodeChild(childId);
+	if (location === void 0) return;
+	const outcome = describeNodeEnd(info);
+	try {
+		if (outcome.text === "") {
+			await writeNodeNote(location, childId, outcome.note);
+			return;
+		}
+		await withMeetingLock(lockKey(location), async () => {
+			const meeting = await readMeeting(location.stateRoot, location.meetingId);
+			if (meeting === void 0) return;
+			const node = meeting.nodes.find((candidate) => candidate.id === childId && candidate.status !== "removed");
+			if (node === void 0) return;
+			const utterance = {
+				id: randomUUID(),
+				nodeKey: node.key,
+				kind: "auto-capture",
+				content: outcome.text,
+				round: meeting.round,
+				ts: Date.now()
+			};
+			await appendUtterance(location.stateRoot, meeting.id, utterance);
+			meeting.budget.usedTokens += estimateTokens(outcome.text);
+			node.lastError = void 0;
+			meeting.updatedAt = Date.now();
+			await writeMeeting(location.stateRoot, meeting);
+		});
+	} catch (error) {
+		ctx.logger.warn(`roundtable: capturing output of node ${childId} failed: ${String(error)}`);
+	}
+}
+/** Remember the last provider failure per node (observability, not recovery). */
+function onRequestError(ctx, payload) {
+	const agentId = String(payload.agent?.id ?? "");
+	if (agentId === "") return;
+	const location = locateNodeChild(agentId);
+	if (location === void 0) return;
+	writeNodeNote(location, agentId, describeRequestFailure(String(payload.provider ?? ""), payload.failure)).catch((error) => {
+		ctx.logger.warn(`roundtable: recording request failure of node ${agentId} failed: ${String(error)}`);
+	});
+}
+/**
+* Subscribe the two host events that make expert output and expert failure
+* visible.
+*
+* Deliberately non-invasive: `subagent/end` is a plain emit, and the
+* `agent/request-error` waterfall listener always delegates through `next()` so
+* the host's own retry/recovery policy is untouched — this plugin only observes.
+*/
+function attachNodeEvents(ctx) {
+	ctx.on("subagent/end", (info) => {
+		onNodeEnd(ctx, info);
+	});
+	ctx.on("agent/request-error", (payload, next) => {
+		try {
+			onRequestError(ctx, payload);
+		} catch {}
+		return next();
+	});
+}
+/** Host-known durable child ids; `undefined` when the catalog is unavailable. */
+async function knownChildIds(ctx, parentSessionId) {
+	try {
+		const children = await ctx.subagents.listChildren(parentSessionId);
+		return new Set(children.map((child) => String(child.id)));
+	} catch (error) {
+		ctx.logger.warn(`roundtable: listing child subagents failed: ${String(error)}`);
+		return;
+	}
+}
+/**
+* Reconcile node liveness against the host's real subagent tree.
+*
+* `ctx.agents.get(id)` only knows **live** drivers, so a node whose process is
+* gone looks exactly like one that is merely between turns — both report
+* `ready`, and the captain cannot tell "待唤醒" from "已经没了". Asking the
+* durable catalog separates them: an id the host still lists is a cold-but-real
+* child, an id it no longer knows is `missing` — which is precisely the old
+* "把消息投进死节点、静默丢一整轮" failure seen in the meeting records.
+*
+* Runs one listing per meeting (not per node) and degrades to the previous
+* semantics when the catalog is unavailable.
+*/
+async function reconcileNodeLiveness(ctx, captainSessionId, nodes) {
+	const result = /* @__PURE__ */ new Map();
+	let catalog;
+	for (const node of nodes) {
+		if (node.id === "" || !ACTIVE_NODE_STATUSES.includes(node.status)) continue;
+		const live = ctx.agents.get(node.id);
+		if (live !== void 0) {
+			result.set(node.key, live.status === "running" ? "running" : "idle");
+			continue;
+		}
+		if (catalog === void 0) catalog = await knownChildIds(ctx, captainSessionId);
+		result.set(node.key, catalog === void 0 || catalog.has(node.id) ? "ready" : "missing");
+	}
+	return result;
+}
+
+//#endregion
+//#region src/harness-compat.ts
+/** 进程级审计表：每个能力只记第一次探测（避免 1 秒轮询刷爆）。 */
+const audit = /* @__PURE__ */ new Map();
+/**
+* 记录一次探测结果（**每个能力只保留第一条**）。
+*
+* 只记第一条是刻意的：探测点常在 tick / 轮询路径上，每次都记会把内存和日志
+* 都吃掉；而"第一次看到它是什么状态"已经足够定位问题。
+*/
+function noteCapability(id, state, note) {
+	if (!audit.has(id)) audit.set(id, {
+		state,
+		note,
+		ts: Date.now()
+	});
+	return state;
+}
+/**
+* 读一个**可选**宿主服务。
+*
+* 统一走 `ctx.get`（cordis 核心、非严格：缺失返回 `undefined`）而不是属性访问
+* —— 后者在没有 `inject` 时会**直接抛错**：
+* `cannot get property "connection" without inject`。
+*/
+function optionalService(ctx, name$1) {
+	const getter = ctx.get;
+	if (typeof getter !== "function") {
+		noteCapability(name$1, "missing", "ctx.get 不存在（宿主 Context 形状变化）");
+		return;
+	}
+	let service;
+	try {
+		service = getter.call(ctx, name$1);
+	} catch (error) {
+		noteCapability(name$1, "degraded", `ctx.get('${name$1}') 抛错：${error instanceof Error ? error.message : String(error)}`);
+		return;
+	}
+	if (service === void 0 || service === null) {
+		noteCapability(name$1, "missing", "宿主未挂载该服务");
+		return;
+	}
+	noteCapability(name$1, "available", "已解析");
+	return service;
+}
+/** 可选服务键的结构式候选（宿主可能改名；按序取第一个可用的）。 */
+const WEB_SERVER_KEYS = ["webServer", "httpServer"];
+const WORKSPACE_KEYS = ["workspaceRegistry", "workspace"];
+/**
+* 解析 webServer 服务面。
+*
+* 服务键是**结构式候选**而非固定名：宿主可能把 `webServer` 换成别的名字，
+* 所以按 `WEB_SERVER_KEYS` 顺序探测。headless profile 下取不到属预期，
+* 只降级不报错。
+*/
+function webRouteHostOf(ctx) {
+	for (const key of WEB_SERVER_KEYS) {
+		const host = optionalService(ctx, key);
+		if (host !== void 0 && typeof host.register === "function") {
+			noteCapability("webServer", "available", `经 ${key} 解析`);
+			return host;
+		}
+	}
+	noteCapability("webServer", "missing", `候选键都不可用：${WEB_SERVER_KEYS.join(" / ")}`);
+}
+/** 解析 workspace 注册表面（同上，结构式候选 + 降级留痕）。 */
+function workspaceRegistryOf(ctx) {
+	for (const key of WORKSPACE_KEYS) {
+		const host = optionalService(ctx, key);
+		if (host !== void 0 && typeof host.list === "function") {
+			noteCapability("workspaceRegistry", "available", `经 ${key} 解析`);
+			return host;
+		}
+	}
+	noteCapability("workspaceRegistry", "missing", `候选键都不可用：${WORKSPACE_KEYS.join(" / ")}`);
+}
+/**
+* 判定一个 `rpc.handle(...)` 返回值能不能当清理函数用。
+*
+* 宿主签名在 rc 线上变过：0.1.1 时代第三参 `{ authority }` 被移除，返回值在
+* 不同版本里出现过 `disposer` / `undefined` / Promise。这里只做**形状判定**，
+* 不 import 宿主类型：合法就交出去，不合法就交给调用方记一条降级。
+*/
+function asDisposer(value) {
+	return typeof value === "function" ? value : void 0;
+}
+/**
+* 在可选的清理函数存在时注册一个 effect。
+*
+* `connection.rpc.handle` 的返回值形状随版本变化，直接 `ctx.effect(() => () =>
+* release())` 会在返回值不是函数时静默留下一个永远不执行的清理器（通道泄漏）。
+*/
+function effectWithOptionalDisposer(ctx, disposer, label) {
+	const release = asDisposer(disposer);
+	if (release === void 0) return false;
+	ctx.effect(() => () => {
+		release();
+	}, label);
+	return true;
+}
+/**
+* 读一个 live session 的投影值。
+*
+* **返回 `undefined`，绝不抛错**：测量用量是观察行为，不能因为宿主投影形状
+* 变化就把 `roundtable_status` 弄崩 —— 与 `token-usage.ts` 的既有契约一致。
+*/
+function projectionValuesOf(ctx, session) {
+	if (session === void 0 || session === null) return void 0;
+	try {
+		const projections = optionalService(ctx, "sessionProjections");
+		if (projections === void 0 || typeof projections.snapshot !== "function") return void 0;
+		const values = projections.snapshot(session, ["tokenUsage", "contextPressure"])?.values;
+		if (values === null || typeof values !== "object") return void 0;
+		return values;
+	} catch (error) {
+		noteCapability("sessionProjections", "degraded", `snapshot() 抛错：${error instanceof Error ? error.message : String(error)}`);
+		return;
+	}
+}
+/**
+* ## 0.2.0-rc.2 —— 两处真破坏（核对日期 2026-09-30）
+*
+* 从 0.1.5-rc.3 抬到 0.2.0-rc.2 后，**宿主侧 `tsc` 只有 4 个错误**，浏览器侧 0 个。
+* 4 个错误归为两类，两类都不是「改一行签名」能解决的。
+*
+* ### ① `settings` 服务被重构成 `SettingsForms`
+*
+* | | 0.1.5-rc.3 | 0.2.0-rc.2 |
+* | --- | --- | --- |
+* | 形状 | `SettingsScope`：插件注册自己的命名空间 | `SettingsForms`：把 profile 配置投影成表单 |
+* | API | `settings.register(ns, schema, { base })` | `configure` / `describe` / `update` / `replace` / `mutate` |
+* | 插件自管偏好 | `scope.get` / `update` / `watch` | **没有对应物** |
+*
+* 编译期症状：
+*   `Property 'register' does not exist on type 'SettingsForms'`
+*   `Module '"@deepseek-ai/dsh-settings"' has no exported member 'SettingsScope'`
+*
+* **应对**：偏好改为自持久化（`src/preferences.ts` →
+* `<DSH_HOME>/roundtable/preferences.json`），并同步从 `OPTIONAL_CAPABILITIES`、
+* `CAPABILITY_SPECS`、`compatibility.json` 三处移除 `settings`。
+*
+* ⚠️ **不要再试图用 `ctx.inject(['settings'])` 注册命名空间** —— 那个能力在新模型
+* 里不存在。插件现在的可配置面是它自己的 Cordis `Config`（Loader YAML 提供、宿主
+* 自动生成配置页），而写 `Config` 会触发 entry 重载，不适合承载"改一个偏好"。
+*
+* ### ② `MessageSourceMap` 不再有 catch-all 的 `plugin` kind
+*
+* 基础表只剩 `user` / `model` / `tool` / `system-prompt`，其余由**生产者在自己
+* 的模块里** `declare module '@deepseek-ai/dsh-llm'` 补上 —— 宿主内部插件
+* （`tool-registry`、`ptc-mode`、`agent-message`、`subagent-settled` …）都是这么做的。
+* 原文注释写得很直白：**"there is no shared catch-all `plugin` kind"**。
+*
+* 编译期症状：
+*   `Type '"plugin"' is not assignable to type '"user" | "model" | "tool" | …'`
+*
+* **应对**：`src/members.ts` 自声明 `roundtable` kind（`{ kind: 'roundtable'; plugin: string }`），
+* 而不是退化成匿名的 `user` —— 转录消费者需要把"插件注入的提示"与"用户说的话"分开。
+*
+* ### 保持不变的（本轮逐项复核确认）
+*
+* `inject` 的四个必需服务、`ctx.subagents` 的派发与 `interruptByParent`、
+* `ctx.agents.get`、`subagent/end` 与 `agent/request-error` 事件、
+* `webServer.register` 的形状、`connection.rpc.handle` 的两参签名与 disposer
+* 返回值、`ctx.skills` / `ctx.userQuestions` / `sessionProjections.snapshot(session, keys)`、
+* 以及全部浏览器侧槽位（`conversation.view` / `settings.section` /
+* `tool.call.toolview`）—— 一律原样可用。
+*
+* ### 环境侧的老教训仍然有效
+*
+* 升级后**先跑 `node scripts/doctor.mjs`**：cordis 必须是同一物理副本，否则
+* `declare module` 合并失效，会出现几十处「Context 上不存在某属性」的假故障，
+* 看起来像 API 全崩。本轮 doctor 一次通过（混装 ✓ / cordis 同一性 ✓）。
+*/
+
+//#endregion
+//#region src/token-usage.ts
+function countOf(raw, key) {
+	const value = raw[key];
+	if (typeof value !== "number" || !Number.isFinite(value)) return 0;
+	return Math.max(0, Math.floor(value));
+}
+/** Coerce one projection value into a {@link SessionUsage}; undefined when empty. */
+function normalizeUsage(value) {
+	if (value === null || typeof value !== "object") return void 0;
+	const raw = value;
+	const inputTokens = countOf(raw, "uncachedInputTokens");
+	const outputTokens = countOf(raw, "outputTokens");
+	const cacheReadTokens = countOf(raw, "cacheReadTokens");
+	const cacheWriteTokens = countOf(raw, "cacheWriteTokens");
+	const total = inputTokens + outputTokens + cacheReadTokens + cacheWriteTokens;
+	if (total === 0) return void 0;
+	return {
+		inputTokens,
+		outputTokens,
+		cacheReadTokens,
+		cacheWriteTokens,
+		total
+	};
+}
+/**
+* Read the projection values of one LIVE session.
+*
+* Returns `undefined` — never throws — when the agent is not live, the
+* projection service is unmounted, or the host shape differs: measuring cost is
+* an observation, and it must never be able to break `roundtable_status`.
+*/
+function projectionValuesOf$1(ctx, sessionId) {
+	if (sessionId === "") return void 0;
+	try {
+		return projectionValuesOf(ctx, ctx.agents.get(sessionId)?.session);
+	} catch {
+		return;
+	}
+}
+/** Provider-reported usage of one live session (undefined when unavailable). */
+function liveSessionUsage(ctx, sessionId) {
+	return normalizeUsage(projectionValuesOf$1(ctx, sessionId)?.tokenUsage);
+}
+/**
+* Sum real usage across one meeting's expert child sessions.
+*
+* Each distinct session is measured once; ids that no longer resolve to a live
+* agent are counted as `unmeasuredSessions` so the caller can say "3 of 5
+* measured" instead of silently reporting a too-small total.
+*/
+function meetingRealUsage(ctx, sessionIds) {
+	const seen = /* @__PURE__ */ new Set();
+	let measuredTotal = 0;
+	let measuredSessions = 0;
+	let unmeasuredSessions = 0;
+	for (const id of sessionIds) {
+		if (id === "" || seen.has(id)) continue;
+		seen.add(id);
+		const usage = liveSessionUsage(ctx, id);
+		if (usage === void 0) {
+			unmeasuredSessions += 1;
+			continue;
+		}
+		measuredTotal += usage.total;
+		measuredSessions += 1;
+	}
+	return {
+		measuredTotal,
+		measuredSessions,
+		unmeasuredSessions
+	};
+}
+
+//#endregion
+//#region src/proxy-thinking.ts
+/**
+* Proxy Thinking (代理思考): when a black-box worker model (no visible
+* reasoning) must execute a task, the director model (DeepSeek) first writes
+* its own reasoning as `[DeepSeek 代理思考]`, then translates the goal into
+* exact worker parameters. The UI prefixes stages with
+* `[DeepSeek 代理思考]` / `[<worker> 渲染中]`.
+* @module dsh-plugin-roundtable/proxy-thinking
+*/
+/** The director-side prompt template (spec §6.2). */
+const PROXY_THINKING_TEMPLATE = `【代理思考（Proxy Thinking）—— 导演模型侧】
+
+你当前扮演"导演模型"，负责把一个模糊目标交给一个"无思考过程的干活模型" <worker_model> 执行。
+<worker_model> 不会展示思考过程、不会自我纠错、不会追问澄清。
+因此你的职责是替它完成思考，并把任务翻译成它能直接执行的指令。
+
+请严格按以下顺序输出，不要遗漏任何一节：
+
+一、[DeepSeek 代理思考]
+用自然语言写出你的完整推理过程，至少覆盖：
+- 你如何理解这个目标（拆解成哪些子意图）
+- 你选择什么策略，为什么
+- 关键参数为什么这样定（给出取舍理由）
+- 预期结果是什么
+- 可能的失败点与兜底方案
+（这一节是"代理思考"，直接展示给用户，补齐 <worker_model> 缺失的透明性。）
+
+二、[参数翻译 → <worker_model>]
+把目标翻译成 <worker_model> 能直接执行的精确指令/参数：
+- 字段必须符合 <worker_model> 的输入规范（schema）
+- 禁止含糊描述：不用"好看一点/高级一点"，必须给出具体风格、构图、时长、尺寸、语气等
+- 输出为结构化 JSON 或精确指令文本（以 <worker_model> 实际接受的格式为准）
+
+三、[预期与兜底]
+- 预期结果：执行成功时应得到什么
+- 失败兜底：若结果不符合预期，你接下来如何修正或降级`;
+/** Compose the director-side prompt for one worker task. */
+function proxyThinkingPrompt(workerModel, task) {
+	return `${PROXY_THINKING_TEMPLATE.replaceAll("<worker_model>", workerModel)}\n\n本次任务：\n${task}`;
+}
+
+//#endregion
+//#region src/prompt.ts
+/** 任务信封（主持人 → 专家）：固定四段，可机械转发，不粘贴全文。 */
+const TASK_ENVELOPE = "[TASK R{轮} → {key}] 目标｜输入（引用 R{n}[{发言人}] 或文件路径）｜约束｜期望产出";
+/** 报告信封（专家 → 网关/主持人）：`[核心产出]` 就是网关抓取的段落。 */
+const REPORT_ENVELOPE = "[REPORT R{轮} {key}] 结论（≤3 条）｜证据｜待决策";
+/**
+* 主持人（DeepSeek 本体）的常驻 usage 段。
+*
+* **它每一次请求都要付费**，包括完全不开会的日常对话。因此这里只保留
+* "何时触发、按什么顺序、红线在哪"，把流程细节交给各工具的 description。
+* 也**不再逐个列出工具名**：工具 schema 本来就在请求里，列一遍是纯冗余。
+*/
+function usageSectionText() {
+	return `When the user asks to run a round-table meeting (圆桌会议) you are the captain (主持人). This section only fixes WHEN each tool applies; each tool's own description carries its details.
+
+1. Never create a meeting directly: call roundtable_plan_meeting first (name, goal, intended experts, parameters) — it shows the human a SETTINGS CARD and blocks. Create only with the confirmed values, and always show the card, even for a single expert.
+2. Then roundtable_add_node once per expert and roundtable_connect to wire the topology. A node inherits your provider/model unless the user explicitly asked for another route.
+3. Delegate, do not duplicate: hand work to nodes, watch with roundtable_status, pull roundtable_summarize. Two channels — never both for the same content: roundtable_speak is the durable record and gateway input (nobody is woken); roundtable_send_message wakes the recipient and is only for something they must act on now.
+4. Relay compactly. Forward with ${TASK_ENVELOPE} — quote the transcript reference instead of pasting the full text, since an expert can read the transcript itself. Experts answer as ${REPORT_ENVELOPE}, and [核心产出] is exactly the segment the gateway captures.
+5. Open every round with roundtable_status: execute each pending_actions line with the matching tool, and call roundtable_actions_clear only after every one succeeded. Pass back its next_since cursor so each poll returns only new lines.
+6. Real forks go to the human via roundtable_request_decision. Never decide for the user.
+7. Budget honesty: the token figure is an ESTIMATE OF SPOKEN TEXT (≈0.6 token/CJK char), NOT the real spend — say so when you report it. Provider-reported real usage is shown when measurable. A muted (闭麦) meeting is topped up with roundtable_set_budget.
+8. Knowledge base and skills are relayed by you, never copied wholesale: read the one file or skill, hand over only what the expert needs, and cache the distilled points with roundtable_kb_digest — a later HIT then costs nothing.
+9. 针锋相对: when a plan is settled, ASK the user first, then roundtable_start_review; red-team experts only attack the plan, and a re-review may only re-check the previous pass's endorsed flaws. Close the meeting with roundtable_export_meeting (or roundtable_export_review for the review record alone).
+10. Handing work to a black-box worker model (image/video) goes through roundtable_proxy_think so the reasoning chain stays visible.`;
+}
+/**
+* skill 段落：把"选了哪些 skill / 用哪种方式"写进 persona。
+*
+* direct 模式下这是**必须**的：`skill` 工具本身不带白名单参数，专家只有
+* 在 persona 里被告知可用清单，才知道能调什么（R2.3）。
+*/
+function skillSection(meeting, skill) {
+	const names = (skill.names ?? meeting.skills ?? []).filter((name$1) => name$1 !== "");
+	const delivery = skill.delivery ?? meeting.skillDelivery ?? "relay";
+	if (names.length === 0 && delivery !== "direct") return "";
+	const list = names.length === 0 ? "（本次会议未选中任何 skill）" : names.map((name$1) => `\`${name$1}\``).join("、");
+	if (delivery === "direct") return `skill：${list}。传递方式为「专家直接调用」：${names.length > 0 && skill.skillToolAvailable === true ? "需要完整说明时自己调用 `skill` 工具（name 传上方清单里的名字）加载全文，并严格按其约束工作。" : "当前 `skill` 工具不可用或未选中 skill，不要尝试调用，用你自己的通用能力完成任务。"}`;
+	return `skill：${list}。传递方式为「主持人中转」：主持人会把要点转交给你，你不要也不应该自己调用 \`skill\` 工具；把这些 skill 的约束当作既定工作前提。`;
+}
+/** The node's system prompt (persona): the charter plus node working rules.
+*
+*  与 charter 严格分工：**总纲写共同红线（格式、编造、拍板），这里只写
+*  "你这个节点具体怎么做"**。同一约束绝不在这两处各写一遍 —— persona 会
+*  跟着专家的每一次请求付费。 */
+function nodePersona(meeting, node, stateDir, limits = {}, skill = {}) {
+	const modeRule = meeting.mode === "egalitarian" ? "- 协作模式为\"多模型平等\"：你可以用 roundtable_send_message 直接与其他节点交换意见，无需主持人中转。" : "- 协作模式为\"主持人统筹\"：你只向主持人汇报，其他节点的观点由主持人转达。";
+	const opinionRule = limits.maxOpinions !== void 0 && limits.maxOpinions > 0 ? ` 每轮最多 ${limits.maxOpinions} 条意见，宁缺毋滥。` : "";
+	return `${meeting.charter}
+
+你是会议"${meeting.name}"中的专家节点 ${node.key}${node.role !== void 0 && node.role !== "" ? `，角色：${node.role}` : ""}。
+
+工作规则：
+1. 收到任务后执行一整轮工作，再用 roundtable_speak 汇报（to 留空 = 交网关）；只有需要某人**立刻行动**时才用 roundtable_send_message。
+2. 按总纲第三节的格式发言，并采用报告信封 ${REPORT_ENVELOPE}：结论 ≤3 条，其余内容一律省略（[核心产出] 即网关抓取的段落）。
+3. 主持人转来的引用不足以判断时，自己读 ${stateDir}/${meeting.id}/transcript.jsonl 取原文（只读，严禁直接修改；一切状态变更走 roundtable_* 工具）。
+4. 你是专家不是主持人：不创建/移除节点、不修改连线、不发起人类决策、不结束会议。
+${skillSection(meeting, skill)}
+${modeRule}
+
+回答限制（省 token，务必遵守）：
+- 只回答与议题直接相关的内容；无关问题直接说明"与议题无关"。
+- 不用假设代替事实；不确定就明确说"不确定"。
+- 不举无关的例子；举例必须直接服务于论点。
+- 语言简洁明了，不用华丽修辞与空话套话。${opinionRule}`;
+}
+/** The initial user message delivered when the node is created. */
+function nodeWelcome(meeting, node) {
+	return `你已加入圆桌会议"${meeting.name}"（会议 id ${meeting.id}）作为专家节点 ${node.key}。主持人会通过消息布置任务或转达其他节点的观点；收到后执行一整轮工作并用 roundtable_speak 汇报。现在等待主持人的指令。`;
+}
+
+//#endregion
+//#region src/members.ts
+/** Node display label prefix persisted as the child's creation label. */
+const NODE_LABEL_PREFIX = "roundtable:";
+/** Captain-only RoundTable tools hidden from expert nodes. */
+const NODE_DENIED_TOOLS = [
+	"roundtable_create",
+	"roundtable_plan_meeting",
+	"roundtable_add_node",
+	"roundtable_remove_node",
+	"roundtable_connect",
+	"roundtable_disconnect",
+	"roundtable_request_decision",
+	"roundtable_set_budget",
+	"roundtable_close",
+	"roundtable_collect_review",
+	"roundtable_finish_review",
+	"roundtable_export_review",
+	"roundtable_export_meeting",
+	"roundtable_kb_digest"
+];
+/**
+* 专家节点在 direct 模式下可以保留的工具白名单。
+*
+* `allow` 的语义是"只有列出的全局工具保持可见"，因此这里必须列全专家
+* 真正需要的工具（文件/搜索/shell/技能/协作/自身管理）；一旦宿主改名，
+* 专家会失去该能力但**不会**因此获得额外权限 —— 这是刻意选择的失败方向。
+* `deny` 仍然保留（两者是与关系）：它保证将来有人从本清单里删掉某项时，
+* 主持人专属工具不会顺带被放开。
+*/
+const NODE_ALLOWED_TOOLS = [
+	"read",
+	"read_image",
+	"write",
+	"edit",
+	"str_replace_editor",
+	"glob",
+	"grep",
+	"pwsh",
+	"bash",
+	"todo_write",
+	"web_search",
+	"web_fetch",
+	"send_message",
+	"interrupt_agent",
+	"list_agents",
+	"list_subagent_models",
+	"job_list",
+	"job_output",
+	"job_kill",
+	"roundtable_speak",
+	"roundtable_send_message",
+	"roundtable_summarize",
+	"roundtable_status",
+	"roundtable_actions_clear",
+	"roundtable_start_review",
+	"roundtable_proxy_think",
+	"skill"
+];
+/** The node's tool restriction: deny captain-only tools, and — in direct
+*  skill-delivery mode — narrow the surface to the explicit expert allowlist
+*  so the host's `skill` loader is reachable from a node. */
+function nodeToolRestriction(skillDelivery = "relay") {
+	if (skillDelivery === "direct") return {
+		allow: [...NODE_ALLOWED_TOOLS],
+		deny: [...NODE_DENIED_TOOLS]
+	};
+	return { deny: [...NODE_DENIED_TOOLS] };
+}
+/**
+* Spawn one node as a durable continuable subagent of the captain and fill
+* `node.id` with its child session id. On failure nothing is persisted.
+*/
+async function spawnNode(ctx, config, meeting, node, captain, stateDir, signal, limits = {}, skill = {}) {
+	const provider = ctx.subagents.getProvider(config.provider);
+	if (provider === void 0) throw new Error(`roundtable: no subagent provider "${config.provider}" is registered (available: ${ctx.subagents.list().join(", ") || "none"}) — check that the subagent provider row (e.g. subagent-spawn) is mounted in the composition`);
+	if (provider.prepareContinuable === void 0) throw new Error(`roundtable: provider "${config.provider}" does not support continuable nodes`);
+	if (!provider.capabilities.persona) throw new Error(`roundtable: provider "${config.provider}" cannot apply a node persona`);
+	if (!provider.capabilities.toolFilter) throw new Error(`roundtable: provider "${config.provider}" cannot restrict captain-only tools for nodes`);
+	const label = `${NODE_LABEL_PREFIX}${meeting.id}:${node.key}`;
+	const agentOptions = {};
+	if (node.provider !== void 0 && node.model !== void 0) {
+		agentOptions.provider = node.provider;
+		agentOptions.model = node.model;
+	}
+	const reasoningEffort = node.reasoningEffort?.trim() ?? "";
+	if (reasoningEffort !== "") agentOptions.reasoningEffort = ReasoningEffortId(reasoningEffort);
+	if (limits.maxTokens !== void 0 && limits.maxTokens > 0) agentOptions.maxTokens = limits.maxTokens;
+	const delivery = skill.delivery ?? meeting.skillDelivery ?? "relay";
+	const skillToolAvailable = ctx.tools.get("skill", captain) !== void 0;
+	const started = await ctx.subagents.startContinuable({
+		provider: config.provider,
+		label,
+		request: {
+			prompt: [{
+				type: "text",
+				text: nodeWelcome(meeting, node)
+			}],
+			parent: captain,
+			persona: nodePersona(meeting, node, stateDir, limits, {
+				...skill,
+				delivery,
+				skillToolAvailable
+			}),
+			toolFilter: nodeToolRestriction(delivery),
+			...Object.keys(agentOptions).length > 0 ? { agentOptions } : {},
+			...config.maxDepth !== void 0 ? { maxDepth: config.maxDepth } : {}
+		},
+		signal
+	});
+	node.id = String(started.childId);
+}
+/**
+* Deliver one message to a node as its next FIFO turn. Best effort: a failure
+* is logged and reported as `false` so the caller can decide.
+*/
+async function deliverToNode(ctx, captain, childId, text, signal) {
+	try {
+		await ctx.subagents.sendMessage(captain, childId, [{
+			type: "text",
+			text
+		}], { signal });
+		return true;
+	} catch (error) {
+		ctx.logger.warn(`roundtable: followup to node ${childId} failed: ${String(error)}`);
+		return false;
+	}
+}
+/** Request cancellation of one live node's current turn (fire and return). */
+function interruptNode(ctx, captain, childId) {
+	try {
+		ctx.subagents.interrupt(childId, {
+			kind: "ancestor",
+			agent: captain
+		});
+	} catch (error) {
+		ctx.logger.warn(`roundtable: interrupt of node ${childId} failed: ${String(error)}`);
+	}
+}
+/**
+* Interrupt one node **without** needing a live captain Agent.
+*
+* `ctx.subagents.interrupt` needs an ancestor Agent as its authority, so it is
+* useless on paths that only hold session ids (the RPC surface, or a captain
+* whose Agent is offline). The host's remote face is explicitly documented as
+* "what keeps a live child interruptible while its parent Agent is offline".
+*
+* @returns true when the host accepted the request.
+*/
+function interruptNodeByParent(ctx, childId, parentSessionId) {
+	if (childId === "" || parentSessionId === "") return false;
+	const subagents = ctx.subagents;
+	if (typeof subagents.interruptByParent !== "function") return false;
+	try {
+		subagents.interruptByParent(childId, parentSessionId, "continuable");
+		return true;
+	} catch (error) {
+		ctx.logger.warn(`roundtable: interruptByParent of node ${childId} failed: ${String(error)}`);
+		return false;
+	}
+}
+/** Steer a live message into the captain at its nearest model boundary (best effort). */
+function steerCaptain(captain, text) {
+	try {
+		captain.steer(createUserMessage({
+			content: [{
+				type: "text",
+				text
+			}],
+			source: {
+				kind: "roundtable",
+				plugin: "dsh-plugin-roundtable"
+			}
+		}));
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+//#endregion
+//#region src/review-split.ts
+/** 拆分工具的 JSON schema（防线①）。 */
+const SPLIT_TOOL = {
+	name: "split_redteam_viewpoint",
+	description: "把一条红队专家发言拆成 1~3 条独立观点（每条观点只含一个缺陷）。",
+	parameters: {
+		type: "object",
+		additionalProperties: false,
+		properties: { viewpoints: {
+			type: "array",
+			minItems: 1,
+			maxItems: 3,
+			items: {
+				type: "object",
+				additionalProperties: false,
+				properties: {
+					content: {
+						type: "string",
+						description: "单条观点/缺陷的完整表述。"
+					},
+					quote: {
+						type: "string",
+						description: "发言原文中与该观点对应的子串（可选，必须逐字来自发言原文）。"
+					},
+					dimension: {
+						type: "string",
+						description: "维度标签，如 交互/数据/安全/性能/兼容/流程（不确定用\"其他\"）。"
+					},
+					evidence: {
+						type: "object",
+						description: "证据分级（C1）：代码/bug 类缺陷填 repro（附可复现步骤 1. 2. 3.）；设计类缺陷填 argument（附论证链，不编造伪复现步骤）。无法给出证据时省略该字段。",
+						additionalProperties: false,
+						properties: {
+							kind: {
+								type: "string",
+								enum: ["repro", "argument"],
+								description: "repro=可复现步骤（代码/bug 类）；argument=论证链（设计类）。"
+							},
+							text: {
+								type: "string",
+								description: "证据正文：复现步骤（编号 1. 2. 3.）或论证链，≤600 字符。"
+							}
+						},
+						required: ["kind", "text"]
+					}
+				},
+				required: ["content", "dimension"]
+			}
+		} },
+		required: ["viewpoints"]
+	}
+};
+const SPLIT_TIMEOUT_MS = 6e4;
+/** 调用 LLM 一次，收集工具调用参数（或文本 JSON）为字符串；失败返回 null。 */
+async function callSplitLlm(llm, config, system, userText) {
+	const controller = new AbortController();
+	const timer = setTimeout(() => controller.abort(), SPLIT_TIMEOUT_MS);
+	try {
+		const deltas = [];
+		let assembled = null;
+		const stream = llm.stream({
+			provider: config.provider,
+			model: config.model,
+			messages: [{
+				id: randomUUID(),
+				role: "user",
+				content: [{
+					type: "text",
+					text: userText
+				}],
+				source: { kind: "user" }
+			}],
+			system,
+			tools: [SPLIT_TOOL],
+			temperature: 0,
+			maxTokens: 1024,
+			signal: controller.signal
+		});
+		for await (const chunk of stream) {
+			const raw$1 = chunk;
+			if (raw$1.type === "tool-call-delta" && typeof raw$1.argumentsDelta === "string") deltas.push(raw$1.argumentsDelta);
+			else if (raw$1.type === "block-end" && raw$1.block?.type === "tool-call" && typeof raw$1.block.arguments === "string") assembled = raw$1.block.arguments;
+			else if (raw$1.type === "text" && typeof raw$1.delta === "string") deltas.push(raw$1.delta);
+			else if (raw$1.type === "text" && typeof raw$1.text === "string") deltas.push(raw$1.text);
+			else if (raw$1.type === "text-delta" && typeof raw$1.text === "string") deltas.push(raw$1.text);
+		}
+		const raw = (assembled ?? deltas.join("")).trim();
+		return raw === "" ? null : raw;
+	} catch {
+		return null;
+	} finally {
+		clearTimeout(timer);
+	}
+}
+/**
+* 本地启发式兜底拆分（零 token、确定性）：红队专家发言通常按
+* "**观点 N（指向 X，维度Y）**" 的固定结构分条，直接按该标记切段，
+* 并从段首括号里提取维度标签。找不到任何观点标记时返回 null，
+* 由调用方整条兜底（seq=0）。
+*/
+const VIEWPOINT_MARKER = /(?:\*{1,2})?\s*观点\s*(\d+)\s*[（(]([^）)]*)[）)]/g;
+const TAIL_SECTION = /\[(?:核心产出|下一步建议)[^\]]*\]/;
+function splitByMarkers(content) {
+	const trimmed = content.replace(/\s+/g, " ").trim();
+	if (trimmed === "") return null;
+	const marks = [];
+	VIEWPOINT_MARKER.lastIndex = 0;
+	let m;
+	while ((m = VIEWPOINT_MARKER.exec(trimmed)) !== null) marks.push({
+		start: m.index,
+		end: m.index + m[0].length,
+		label: m[1] ?? "",
+		head: m[2] ?? ""
+	});
+	if (marks.length === 0) return null;
+	const lines = [];
+	for (let i = 0; i < marks.length; i++) {
+		const mark = marks[i];
+		if (mark === void 0) continue;
+		const next = marks[i + 1];
+		const rawEnd = next !== void 0 ? next.start : trimmed.length;
+		let raw = trimmed.slice(mark.end, rawEnd);
+		const tail = raw.search(TAIL_SECTION);
+		if (tail !== -1) raw = raw.slice(0, tail);
+		const text = raw.replace(/^[\s*:：]+/, "").replace(/\s+/g, " ").trim();
+		if (text === "") continue;
+		const dims = (mark.head.match(/[①-④]/g) ?? []).join("+");
+		lines.push({
+			content: `观点 ${mark.label}（${mark.head}）：${text}`,
+			dimension: dims !== "" ? `维度${dims}` : "其他",
+			quote: void 0
+		});
+	}
+	return lines.length > 0 ? lines : null;
+}
+/**
+* 拆分一条发言为若干独立观点；任何失败返回 null（调用方整条兜底）。
+* quote 与发言原文做规范化子串校验（防线③），不匹配即丢弃。
+*/
+async function splitUtterance(llm, config, nodeKey, content) {
+	const trimmed = content.replace(/\s+/g, " ").trim();
+	if (trimmed === "") return null;
+	const raw = await callSplitLlm(llm, config, "你是 RoundTable「针锋相对」评审的观点拆分器。把下面一条红队专家发言拆成 1~3 条独立观点，每条观点只包含一个缺陷，不得发明原文没有的内容。对每条观点给出证据分级（C1）：代码/bug 类缺陷的 evidence.kind=repro 并写可复现步骤（1. 2. 3.）；设计类缺陷的 evidence.kind=argument 并写论证链——禁止为设计类缺陷编造\"运行某命令即可复现\"这类伪复现步骤。无法从原文提取证据时省略 evidence 字段。必须调用 split_redteam_viewpoint 工具返回结构化结果。", `专家 ${nodeKey} 的发言：\n${trimmed}`);
+	if (raw !== null) {
+		let parsed;
+		try {
+			parsed = JSON.parse(raw);
+		} catch {
+			parsed = void 0;
+		}
+		const list = parsed?.viewpoints;
+		if (Array.isArray(list) && list.length > 0) {
+			const lines = [];
+			for (const item of list) {
+				const obj = item;
+				const line$1 = typeof obj?.content === "string" ? obj.content.replace(/\s+/g, " ").trim() : "";
+				if (line$1 === "") continue;
+				let quote;
+				if (typeof obj?.quote === "string") {
+					const candidate = obj.quote.replace(/\s+/g, " ").trim();
+					if (candidate !== "" && candidate.length <= 120 && trimmed.includes(candidate)) quote = candidate;
+				}
+				const dimension = typeof obj?.dimension === "string" && obj.dimension.trim() !== "" ? obj.dimension.trim().slice(0, 20) : "其他";
+				let evidence;
+				const ev = obj?.evidence;
+				if (ev !== null && typeof ev === "object" && (ev.kind === "repro" || ev.kind === "argument") && typeof ev.text === "string") {
+					const text = ev.text.replace(/\s+/g, " ").trim();
+					if (text !== "") evidence = {
+						kind: ev.kind,
+						text: text.slice(0, 600)
+					};
+				}
+				lines.push({
+					content: line$1,
+					quote,
+					dimension,
+					evidence
+				});
+				if (lines.length >= Math.max(1, config.maxOpinions)) break;
+			}
+			if (lines.length > 0) return lines;
+		}
+	}
+	return splitByMarkers(trimmed);
+}
+
+//#endregion
+//#region src/plan.ts
+/** 卡片上"按此创建"选项的固定标签；`intent.approve` 必须与它逐字一致。 */
+const PLAN_APPROVE_LABEL = "按此创建";
+/** 卡片上的次选项：用户想改点什么。 */
+const PLAN_REVISE_LABEL = "我要修改";
+/** 一行 `键：值`，值为空时显示占位符。 */
+function line(label, value, empty = "（未设置）") {
+	return `- **${label}**：${value.trim() === "" ? empty : value.trim()}`;
+}
+/** 可选 skill 清单在卡片上最多列出的条数（超出只给数量）。 */
+const SKILL_LIST_LIMIT = 12;
+/**
+* 把一份草案渲染成卡片正文（Markdown）。
+*
+* 这里是"让用户看懂将要创建什么"的唯一位置：每一项参数都显示当前值，
+* 专家逐个列出 key / 角色 / 路由，并把**当前可选**的 skill 清单也列出来
+* （用户要在「我要修改」的自由文本里增删 skill，就得先看得到名字）。
+* 禁止在其中塞伪交互说明。
+*/
+function formatMeetingDraft(draft, experts, options = {}) {
+	const modeLabel = draft.mode === "orchestrated" ? "orchestrated（主持人统筹，一切经由主持人转达）" : draft.mode === "egalitarian" ? "egalitarian（多模型平等，专家互相直达，超预算闭麦）" : "redteam（针锋相对，专家只挑已定稿方案的毛病）";
+	const roster = experts.length === 0 ? "（暂无专家——建议至少 1 位）" : experts.map((expert, index) => {
+		const role = expert.role !== void 0 && expert.role.trim() !== "" ? expert.role.trim() : "（未填角色）";
+		const route = expert.provider !== void 0 && expert.provider !== "" && expert.model !== void 0 && expert.model !== "" ? `${expert.provider}/${expert.model}` : "继承主持人当前 provider/model";
+		return `${index + 1}. \`${expert.key}\` — ${role} — ${route}`;
+	}).join("\n");
+	const skills = draft.skills.length === 0 ? "（未选）" : draft.skills.map((skill) => `\`${skill}\``).join("、");
+	const deliveryLabel = draft.skillDelivery === "relay" ? "relay（主持人中转：主持人读正文后按需转交，省 token、行为可预测）" : "direct（专家直接调用：专家自己用 `skill` 工具加载，更自主、各自读取）";
+	return [
+		`# 会议设置确认 · ${draft.name.trim() === "" ? "（未命名）" : draft.name.trim()}`,
+		"",
+		options.revised === true ? "> 已按你的意见更新草案，请再确认一次；还有出入就再选「我要修改」。" : "> 以下是主持人推导的会议草案。**确认后才会真正创建会议。**",
+		"",
+		"## 会议参数",
+		line("会议名称", draft.name, "（未命名）"),
+		line("协作模式", modeLabel),
+		line("轮数上限", `${draft.maxRounds} 轮（超限自动闭麦）`),
+		line("Token 预算", `${draft.maxTokens} tokens（超限自动闭麦）`),
+		line("知识库", draft.kbPath, "（未设置：专家需要资料时由主持人按需读取转交）"),
+		line("选中 skill", skills, "（未选）"),
+		line("skill 传递方式", deliveryLabel),
+		"",
+		"## 专家名单",
+		roster,
+		"",
+		"## 可选 skill 清单（写进「我要修改」的说明里即可增删）",
+		formatAvailableSkills(options.availableSkills ?? []),
+		"",
+		"## 议题 / 目标",
+		draft.goal.trim() === "" ? "（未提供，以主持人现场说明为准）" : draft.goal.trim(),
+		"",
+		"---",
+		"选「我要修改」时，请在输入框里写清改什么（例：把 reviewer 换成 zai-coding-cn/glm-5.2、预算降到 5 轮、加上 skill `pdf-fill`）。主持人据此更新草案后**会再弹一次**这张卡片。"
+	].join("\n");
+}
+/** 渲染"当前可选 skill"清单（空清单给出可操作提示）。 */
+function formatAvailableSkills(available) {
+	if (available.length === 0) return "（本机当前没有可选 skill：把 skill 放进 `<工作区>/.dsh/skills/`、`<工作区>/.agents/skills/` 或 `<DSH_HOME>/skills/` 即会出现）";
+	const lines = available.slice(0, SKILL_LIST_LIMIT).map((skill) => {
+		const description = skill.description === void 0 || skill.description.trim() === "" ? "" : ` — ${skill.description.trim()}`;
+		return `  - \`${skill.name}\`${description}`;
+	});
+	if (available.length > SKILL_LIST_LIMIT) lines.push(`  - …另有 ${available.length - SKILL_LIST_LIMIT} 个`);
+	return lines.join("\n");
+}
+/**
+* 解析用户的卡片回答。
+*
+* 协议与 `intent.kind: 'plan-review'` 的语义一致：`selected` 含
+* `PLAN_APPROVE_LABEL` 即视为批准，其余选项（或只有 custom 文本）视为
+* 要求修改。不识别 intent 的 UI 会退回普通选项列表，答复编码完全相同。
+*/
+function resolvePlanConfirmation(answer, approveLabel = PLAN_APPROVE_LABEL) {
+	if (answer === void 0) return {
+		kind: "unavailable",
+		note: ""
+	};
+	const selected = Array.isArray(answer.selected) ? answer.selected : [];
+	const note = answer.custom === void 0 ? "" : answer.custom.trim();
+	if (selected.includes(approveLabel)) return { kind: "approved" };
+	if (note !== "") return {
+		kind: "revise",
+		note
+	};
+	return {
+		kind: "unavailable",
+		note: ""
+	};
+}
+
+//#endregion
+//#region src/skills.ts
+/** 读取 skill 服务；未挂载时返回 undefined（不抛错、不影响插件加载）。 */
+function skillRegistryOf(ctx) {
+	const skills = ctx.get("skills");
+	if (skills === void 0 || skills === null || typeof skills.list !== "function") return void 0;
+	return skills;
+}
+/**
+* 列出某个工作区可见的、**可被模型调用**的 skill 清单。
+*
+* 服务缺失、发现失败或工作区不可读时都降级为空数组：设置卡片上的 skill
+* 列表因此永远不会成为创建会议的阻塞点。
+*/
+async function listInvocableSkills(ctx, cwd, signal) {
+	const registry = skillRegistryOf(ctx);
+	if (registry === void 0) return [];
+	let summaries;
+	try {
+		summaries = await registry.list({
+			cwd,
+			...signal !== void 0 ? { signal } : {}
+		});
+	} catch {
+		return [];
+	}
+	return summaries.filter((summary) => summary !== void 0 && typeof summary.name === "string" && summary.name !== "").filter((summary) => summary.invocation?.modelInvocable !== false).sort((left, right) => left.name.localeCompare(right.name));
+}
+
+//#endregion
+//#region src/tools.ts
+const DEFAULT_MAX_ROUNDS = 10;
+const DEFAULT_MAX_TOKENS = 2e5;
+/** The caller agent, or a loud failure for non-agent callers. */
+function requireCaptain(exec) {
+	if (exec.agent === void 0) throw new Error("roundtable tools require a calling agent (exec.agent was undefined)");
+	return exec.agent;
+}
+/** The captain's workspace directory (meeting state root parent). */
+function workspaceOf(agent) {
+	return agent.session.header?.cwd ?? process.cwd();
+}
+/** Process-local lock key enforcing one active meeting per captain session. */
+function captainLockKey(stateRoot, captainId) {
+	return `captain:${stateRoot}:${captainId}`;
+}
+/** Process-local lock key for one meeting directory. */
+function meetingLockKey(stateRoot, meetingId) {
+	return `meeting:${stateRoot}:${meetingId}`;
+}
+/** Find the active meeting this captain leads (or undefined). */
+async function findMeetingByCaptain(stateRoot, captainId) {
+	const { listMeetings: listMeetings$1 } = await import("./state-pJShWoUr.js");
+	for (const id of await listMeetings$1(stateRoot)) {
+		const meeting = await readMeeting(stateRoot, id);
+		if (meeting !== void 0 && meeting.captainSessionId === captainId && meeting.status !== "ended" && meeting.status !== "archived") return meeting;
+	}
+}
+/** Find the active meeting this agent participates in (captain or node). */
+async function findMeetingByParticipant(stateRoot, agentId) {
+	const { listMeetings: listMeetings$1 } = await import("./state-pJShWoUr.js");
+	for (const id of await listMeetings$1(stateRoot)) {
+		const meeting = await readMeeting(stateRoot, id);
+		if (meeting === void 0 || meeting.status === "ended" || meeting.status === "archived") continue;
+		if (meeting.captainSessionId === agentId) return meeting;
+		if (meeting.nodes.some((node) => node.id === agentId && ACTIVE_NODE_STATUSES.includes(node.status))) return meeting;
+	}
+}
+/** Locate the meeting the captain leads, or fail loudly (captain-tool boilerplate). */
+async function locateCaptainMeeting(stateRoot, captainId) {
+	const located = await findMeetingByCaptain(stateRoot, captainId);
+	if (located === void 0) throw new Error("you are not leading any meeting — call roundtable_create first");
+	return located;
+}
+/** Locate the meeting the caller participates in, or fail loudly. */
+async function locateParticipantMeeting(stateRoot, agentId) {
+	const located = await findMeetingByParticipant(stateRoot, agentId);
+	if (located === void 0) throw new Error("you do not belong to any active meeting yet");
+	return located;
+}
+/** Lock + captain-permission gate + budget gate: the inner captain-tool boilerplate. */
+async function withCaptainLock(stateRoot, meetingId, captainId, action, operation, options = {}) {
+	return withMeetingLock(meetingLockKey(stateRoot, meetingId), async () => {
+		const fresh = await readMeeting(stateRoot, meetingId);
+		if (fresh === void 0 || fresh.captainSessionId !== captainId) throw new Error(`only the captain of meeting "${meetingId}" may ${action}`);
+		assertUsable(fresh, options);
+		return operation(fresh);
+	});
+}
+/**
+* Assert a write may proceed, and make the muted fact durable before rethrowing.
+*
+* `assertUsable` never mutates, so somebody has to persist the mute — otherwise
+* the UI keeps showing an `active` meeting that rejects everything (P1).
+*/
+async function assertUsablePersisting(stateRoot, meeting) {
+	try {
+		assertUsable(meeting);
+	} catch (error) {
+		if (markMuted(meeting)) {
+			meeting.updatedAt = Date.now();
+			await writeMeeting(stateRoot, meeting);
+		}
+		throw error;
+	}
+}
+/** Derive the caller's role from fresh state. */
+function participantIdentityOf(meeting, agentId) {
+	if (meeting.captainSessionId === agentId) return { kind: "captain" };
+	const node = meeting.nodes.find((candidate) => candidate.id === agentId && candidate.status !== "removed");
+	return node === void 0 ? void 0 : {
+		kind: "node",
+		name: node.key
+	};
+}
+/** Fresh meeting plus caller identity, rechecked inside the lock. */
+async function requireFreshParticipant(stateRoot, meetingId, callerId) {
+	const fresh = await readMeeting(stateRoot, meetingId);
+	if (fresh === void 0) throw new Error(`meeting "${meetingId}" no longer exists`);
+	const identity = participantIdentityOf(fresh, callerId);
+	if (identity === void 0) throw new Error(`you are no longer a participant in meeting "${fresh.name}"`);
+	return {
+		meeting: fresh,
+		identity
+	};
+}
+/** Look up one live node by key. */
+function requireNode(meeting, key) {
+	const node = meeting.nodes.find((candidate) => candidate.key === key && candidate.status !== "removed");
+	if (node === void 0) throw new Error(`no active node named "${key}" in meeting "${meeting.name}"`);
+	return node;
+}
+/** Resolve a node for the given key (captain/aggregator are not nodes). */
+function isNodeKey(meeting, key) {
+	return meeting.nodes.some((candidate) => candidate.key === key && candidate.status !== "removed");
+}
+/** Valid edge endpoints: captain, aggregator, or a live node. */
+function validEndpoint(meeting, key) {
+	return key === CAPTAIN_KEY || key === AGGREGATOR_KEY || isNodeKey(meeting, key);
+}
+/** Record one utterance and its token cost; throws when the meeting is muted. */
+async function recordUtterance(stateRoot, meeting, utterance, options = {}) {
+	if (options.opensNewRound === true) beginRound(meeting);
+	await assertUsablePersisting(stateRoot, meeting);
+	const full = {
+		...utterance,
+		id: randomUUID(),
+		round: meeting.round,
+		ts: Date.now()
+	};
+	meeting.budget.usedTokens += estimateTokens(full.content);
+	meeting.updatedAt = Date.now();
+	await appendUtterance(stateRoot, meeting.id, full);
+	await writeMeeting(stateRoot, meeting);
+	return full;
+}
+/** Normalize one meeting-mode argument (throws on garbage). */
+function normalizeMode(value, fallback) {
+	if (value === void 0 || value === null) return fallback;
+	if (value === "orchestrated" || value === "egalitarian" || value === "redteam") return value;
+	throw new Error(`mode must be "orchestrated" | "egalitarian" | "redteam", got "${String(value)}"`);
+}
+/** Normalize one skill-delivery argument (throws on garbage). */
+function normalizeSkillDelivery(value, fallback) {
+	if (value === void 0 || value === null) return fallback;
+	if (value === "relay" || value === "direct") return value;
+	throw new Error(`skill_delivery must be "relay" | "direct", got "${String(value)}"`);
+}
+/** Sanitize a skill-name list: trim, drop empties, de-duplicate, cap at 20. */
+function normalizeSkillNames(value) {
+	if (!Array.isArray(value)) return [];
+	const out = [];
+	for (const item of value) {
+		const name$1 = String(item ?? "").trim();
+		if (name$1 === "" || out.includes(name$1)) continue;
+		out.push(name$1);
+		if (out.length >= 20) break;
+	}
+	return out;
+}
+/** 会议参数显式传入 > 设置页偏好 > Config 默认值。 */
+function plannedDefaults(config, args) {
+	const injected = config.getPlannedDefaults?.() ?? {
+		mode: config.defaultMode,
+		maxRounds: DEFAULT_MAX_ROUNDS,
+		maxTokens: DEFAULT_MAX_TOKENS,
+		skillDelivery: "relay"
+	};
+	const maxRounds = typeof args.max_rounds === "number" && Number.isFinite(args.max_rounds) && args.max_rounds >= 1 ? Math.floor(args.max_rounds) : injected.maxRounds;
+	const maxTokens = typeof args.max_tokens === "number" && Number.isFinite(args.max_tokens) && args.max_tokens >= 1e3 ? Math.floor(args.max_tokens) : injected.maxTokens;
+	return {
+		mode: normalizeMode(args.mode, injected.mode),
+		maxRounds,
+		maxTokens,
+		skillDelivery: normalizeSkillDelivery(args.skill_delivery, injected.skillDelivery)
+	};
+}
+/** 渲染一张设置卡片的正文（放 `AskUserQuestionItem.detail`）。
+*  渲染规则集中在 plan.ts，这里只做"加上当前可选 skill 清单"的转接。 */
+function renderPlanCard(draft, experts, available, options) {
+	return formatMeetingDraft(draft, experts, {
+		revised: options.revised,
+		availableSkills: available
+	});
+}
+/** Register every `roundtable_*` tool into the shared tools registry. */
+function registerRoundTableTools(ctx, config) {
+	ctx.tools.register(defineTool({
+		name: "roundtable_create",
+		description: "Create a new RoundTable meeting: you (the calling agent) become the captain (主持人). A captain leads one active meeting at a time. Preferred flow (v0.2.31): call roundtable_plan_meeting first, let the user confirm the draft card, then create the meeting with exactly the confirmed values (name/goal/mode/max_rounds/max_tokens/kb_path/skills/skill_delivery). Choose the collaboration mode: \"orchestrated\" means you decide who speaks and relay everything; \"egalitarian\" means experts message each other directly (a budget of max rounds/tokens then mutes the meeting — 闭麦).",
+		parameters: {
+			name: {
+				type: "string",
+				required: true,
+				description: "Name for the new meeting (used as its stable id)."
+			},
+			goal: {
+				type: "string",
+				required: true,
+				description: "Meeting background and core goal (charter section one) — the ultimate deliverable."
+			},
+			mode: {
+				type: "string",
+				enum: [
+					"orchestrated",
+					"egalitarian",
+					"redteam"
+				],
+				description: `Collaboration mode. Defaults to "${config.defaultMode}". "orchestrated" = captain relays everything; "egalitarian" = experts debate peer-to-peer under a budget (use max_rounds/max_tokens to bound it); "redteam" = 针锋相对评审 of a settled plan (experts attack the plan).`
+			},
+			max_rounds: {
+				type: "integer",
+				description: `Debate round cap (default ${DEFAULT_MAX_ROUNDS}); exceeding it mutes the meeting.`
+			},
+			max_tokens: {
+				type: "integer",
+				description: `Total token budget for the meeting transcript (default ${DEFAULT_MAX_TOKENS}); exceeding it mutes the meeting.`
+			},
+			kb_path: {
+				type: "string",
+				description: "知识库目录（可选）：主持人按需读取其中文件并转交专家。相对路径按工作区解析。"
+			},
+			skills: {
+				type: "array",
+				items: { type: "string" },
+				description: "本次会议选中的 skill 名称清单（可选，来自 roundtable_plan_meeting 的卡片确认结果）。"
+			},
+			skill_delivery: {
+				type: "string",
+				enum: ["relay", "direct"],
+				description: "skill 传递方式：relay=主持人中转（默认）；direct=专家自行用 skill 工具调用。"
+			}
+		},
+		output: {
+			schema: {
+				type: "object",
+				additionalProperties: false,
+				properties: {
+					meeting_id: {
+						type: "string",
+						required: true
+					},
+					meeting_name: {
+						type: "string",
+						required: true
+					},
+					mode: {
+						type: "string",
+						required: true
+					},
+					max_rounds: {
+						type: "integer",
+						required: true
+					},
+					max_tokens: {
+						type: "integer",
+						required: true
+					},
+					kb_path: {
+						type: "string",
+						required: true
+					},
+					skills: {
+						type: "array",
+						required: true,
+						items: { type: "string" }
+					},
+					skill_delivery: {
+						type: "string",
+						required: true
+					}
+				}
+			},
+			render: (_args, value) => [{
+				type: "text",
+				text: `RoundTable meeting "${value.meeting_name}" created (id ${value.meeting_id}, mode ${value.mode}, budget ${value.max_rounds} rounds / ${value.max_tokens} tokens, kb ${value.kb_path === "" ? "none" : value.kb_path}, skills ${value.skills.length === 0 ? "none" : value.skills.join(", ")} via ${value.skill_delivery}). You are the captain. Add expert nodes with roundtable_add_node.`
+			}]
+		},
+		async execute(args, exec) {
+			const captain = requireCaptain(exec);
+			const stateRoot = stateRootOf(workspaceOf(captain), config.stateDir);
+			const meetingName = String(args.name ?? "").trim();
+			if (meetingName === "") throw new Error("meeting name must not be empty");
+			const meetingId = sanitizeKey(meetingName);
+			const defaults = plannedDefaults(config, args);
+			const mode = defaults.mode;
+			const requestedSkills = normalizeSkillNames(args.skills);
+			const skillDelivery = defaults.skillDelivery;
+			const kbPath = typeof args.kb_path === "string" ? args.kb_path.trim() : "";
+			const maxRounds = defaults.maxRounds;
+			const maxTokens = defaults.maxTokens;
+			return withMeetingLock(captainLockKey(stateRoot, captain.id), async () => {
+				const current = await findMeetingByCaptain(stateRoot, captain.id);
+				if (current !== void 0) throw new Error(`you already lead meeting "${current.name}" — close it before creating another`);
+				return withMeetingLock(meetingLockKey(stateRoot, meetingId), async () => {
+					const existing = await readMeeting(stateRoot, meetingId);
+					if (existing !== void 0 && existing.status !== "ended" && existing.status !== "archived") throw new Error(`meeting id "${meetingId}" is taken — pick a different meeting name`);
+					if (existing !== void 0) await resetMeetingDirectory(stateRoot, meetingId);
+					const now = Date.now();
+					const meeting = {
+						id: meetingId,
+						name: meetingName,
+						goal: String(args.goal ?? ""),
+						mode,
+						captainSessionId: captain.id,
+						charter: "",
+						nodes: [],
+						edges: [],
+						decisions: [],
+						budget: {
+							maxRounds,
+							maxTokens,
+							usedRounds: 0,
+							usedTokens: 0
+						},
+						round: 0,
+						...kbPath === "" ? {} : { kbPath },
+						...requestedSkills.length === 0 ? {} : { skills: requestedSkills },
+						skillDelivery,
+						status: "active",
+						createdAt: now,
+						updatedAt: now
+					};
+					meeting.charter = buildCharter(meeting);
+					await writeMeeting(stateRoot, meeting);
+					return {
+						meeting_id: meeting.id,
+						meeting_name: meeting.name,
+						mode: meeting.mode,
+						max_rounds: meeting.budget.maxRounds,
+						max_tokens: meeting.budget.maxTokens,
+						kb_path: meeting.kbPath ?? "",
+						skills: meeting.skills ?? [],
+						skill_delivery: meeting.skillDelivery ?? skillDelivery
+					};
+				});
+			});
+		}
+	}));
+	ctx.tools.register(defineTool({
+		name: "roundtable_plan_meeting",
+		description: "Show the human a MEETING SETTINGS CARD before creating anything (R1). This tool does NOT create a meeting: it composes a readable draft (experts, mode, budget, knowledge base, selected skills) from the user's request plus your plugin defaults, then BLOCKS until the user confirms. Returns decision=\"approved\" plus the confirmed plan to pass to roundtable_create, or decision=\"revise\" with the user's own words — update the draft and call this tool again (the card is shown again, revised=true). Call it for EVERY meeting, even a single-expert one.",
+		parameters: {
+			name: {
+				type: "string",
+				required: true,
+				description: "草案里的会议名称（也是会议 id 的来源）。"
+			},
+			goal: {
+				type: "string",
+				required: true,
+				description: "会议背景与核心目标（总纲第一节）。"
+			},
+			mode: {
+				type: "string",
+				enum: [
+					"orchestrated",
+					"egalitarian",
+					"redteam"
+				],
+				description: "协作模式；缺省用设置页的默认模式。"
+			},
+			experts: {
+				type: "array",
+				description: "草案里的专家名单（卡片上逐个列出）。",
+				items: {
+					type: "object",
+					additionalProperties: false,
+					properties: {
+						key: {
+							type: "string",
+							required: true,
+							description: "专家唯一标识，如 researcher。"
+						},
+						role: {
+							type: "string",
+							description: "角色说明，如 安全审查。"
+						},
+						provider: {
+							type: "string",
+							description: "模型路由（与 model 同时给出才生效；缺省继承主持人当前路由）。"
+						},
+						model: {
+							type: "string",
+							description: "模型名。"
+						}
+					}
+				}
+			},
+			max_rounds: {
+				type: "integer",
+				description: "轮数上限；缺省用设置页默认值。"
+			},
+			max_tokens: {
+				type: "integer",
+				description: "Token 预算；缺省用设置页默认值。"
+			},
+			kb_path: {
+				type: "string",
+				description: "知识库目录（可空）。"
+			},
+			skills: {
+				type: "array",
+				items: { type: "string" },
+				description: "选中 skill 的名称清单（可空）。"
+			},
+			skill_delivery: {
+				type: "string",
+				enum: ["relay", "direct"],
+				description: "skill 传递方式；缺省用设置页默认值。"
+			},
+			revised: {
+				type: "boolean",
+				description: "本次是\"用户要求修改后\"的再次确认（卡片会标注已按意见更新）。"
+			}
+		},
+		output: {
+			schema: {
+				type: "object",
+				additionalProperties: false,
+				properties: {
+					decision: {
+						type: "string",
+						required: true
+					},
+					user_note: {
+						type: "string",
+						required: true
+					},
+					name: {
+						type: "string",
+						required: true
+					},
+					goal: {
+						type: "string",
+						required: true
+					},
+					mode: {
+						type: "string",
+						required: true
+					},
+					max_rounds: {
+						type: "integer",
+						required: true
+					},
+					max_tokens: {
+						type: "integer",
+						required: true
+					},
+					kb_path: {
+						type: "string",
+						required: true
+					},
+					skills: {
+						type: "array",
+						required: true,
+						items: { type: "string" }
+					},
+					skill_delivery: {
+						type: "string",
+						required: true
+					}
+				}
+			},
+			render: (_args, value) => [{
+				type: "text",
+				text: value.decision === "approved" ? `用户已确认会议设置：创建 "${value.name}"（${value.mode}，${value.max_rounds} 轮 / ${value.max_tokens} tokens，kb ${value.kb_path === "" ? "未设置" : value.kb_path}，skills ${value.skills.length === 0 ? "未选" : value.skills.join(", ")}，skill 传递 ${value.skill_delivery}）。请用 roundtable_create 按这些值创建会议，然后逐个 roundtable_add_node。` : value.decision === "revise" ? `用户要求修改：${value.user_note}\n请据此更新草案（保持未改动的项原样），再次调用 roundtable_plan_meeting 让用户确认；确认前不要创建会议。` : `设置卡片未能取得用户答复（userQuestions 服务不可用或被中止）${value.user_note === "" ? "" : `：${value.user_note}`}。请把草案内容用文字告知用户，取得明确同意后再调用 roundtable_create。`
+			}]
+		},
+		async execute(args, exec) {
+			const captain = requireCaptain(exec);
+			const workspace = workspaceOf(captain);
+			const defaults = plannedDefaults(config, args);
+			const name$1 = String(args.name ?? "").trim();
+			const goal = String(args.goal ?? "").trim();
+			const kbPath = typeof args.kb_path === "string" ? args.kb_path.trim() : "";
+			const skills = normalizeSkillNames(args.skills);
+			const experts = Array.isArray(args.experts) ? args.experts.flatMap((raw) => {
+				const entry = raw;
+				const key = String(entry?.key ?? "").trim();
+				if (key === "") return [];
+				return [{
+					key,
+					role: entry?.role === void 0 ? void 0 : String(entry.role),
+					provider: entry?.provider === void 0 ? void 0 : String(entry.provider),
+					model: entry?.model === void 0 ? void 0 : String(entry.model)
+				}];
+			}) : [];
+			const draft = {
+				name: name$1,
+				goal,
+				mode: defaults.mode,
+				maxRounds: defaults.maxRounds,
+				maxTokens: defaults.maxTokens,
+				kbPath,
+				skills,
+				skillDelivery: defaults.skillDelivery
+			};
+			const detail = renderPlanCard(draft, experts, await listInvocableSkills(ctx, workspace, exec.signal), { revised: args.revised === true });
+			const userQuestions = ctx.get("userQuestions");
+			const fallback = {
+				decision: "unavailable",
+				user_note: userQuestions === void 0 ? "the userQuestions service is not mounted in this composition" : "",
+				name: draft.name,
+				goal: draft.goal,
+				mode: draft.mode,
+				max_rounds: draft.maxRounds,
+				max_tokens: draft.maxTokens,
+				kb_path: draft.kbPath,
+				skills: draft.skills,
+				skill_delivery: draft.skillDelivery
+			};
+			if (userQuestions === void 0) return fallback;
+			const questionId = randomUUID();
+			let answer;
+			try {
+				answer = await userQuestions.ask({
+					questions: [{
+						id: questionId,
+						question: `确认「${draft.name.trim() === "" ? "未命名会议" : draft.name.trim()}」的会议设置？`,
+						detail,
+						header: "圆桌会议 · 会议设置确认",
+						options: [{
+							label: PLAN_APPROVE_LABEL,
+							description: "按上方参数创建会议（专家随后由主持人逐个拉入）"
+						}, {
+							label: PLAN_REVISE_LABEL,
+							description: "在输入框写明要改的地方，主持人会更新草案并再弹一次"
+						}],
+						intent: {
+							kind: "plan-review",
+							approve: PLAN_APPROVE_LABEL
+						}
+					}],
+					agent: captain,
+					signal: exec.signal
+				});
+			} catch (error) {
+				return {
+					...fallback,
+					decision: "unavailable",
+					user_note: `设置卡片不可用：${error.message}`
+				};
+			}
+			const confirmation = resolvePlanConfirmation(answer.answers.find((candidate) => candidate.id === questionId));
+			return {
+				decision: confirmation.kind,
+				user_note: confirmation.kind === "revise" || confirmation.kind === "unavailable" ? confirmation.note : "",
+				name: draft.name,
+				goal: draft.goal,
+				mode: draft.mode,
+				max_rounds: draft.maxRounds,
+				max_tokens: draft.maxTokens,
+				kb_path: draft.kbPath,
+				skills: draft.skills,
+				skill_delivery: draft.skillDelivery
+			};
+		}
+	}));
+	ctx.tools.register(defineTool({
+		name: "roundtable_add_node",
+		description: "Add an expert node to your meeting: spawns a durable continuable subagent with the meeting charter as its persona. By default the node inherits your current provider/model. Supply provider/model only when the user explicitly wants a different route for this expert.",
+		parameters: {
+			name: {
+				type: "string",
+				required: true,
+				description: "Unique node key inside the meeting (e.g. researcher, engineer, reviewer)."
+			},
+			role: {
+				type: "string",
+				description: "Role description for this expert (e.g. \"security reviewer\")."
+			},
+			provider: {
+				type: "string",
+				description: "Optional LLM provider route. Use only when the user explicitly requests a different provider; requires model."
+			},
+			model: {
+				type: "string",
+				description: "Optional model override. Omit to inherit your current model."
+			},
+			reasoning_effort: {
+				type: "string",
+				description: "Optional adapter-owned reasoning-effort id for this expert (e.g. high / medium / low — the exact vocabulary is defined by the model capability, not by this plugin). Omit to inherit your own route-owned effort."
+			}
+		},
+		output: {
+			schema: {
+				type: "object",
+				additionalProperties: false,
+				properties: {
+					node_name: {
+						type: "string",
+						required: true
+					},
+					node_id: {
+						type: "string",
+						required: true
+					},
+					provider: {
+						type: "string",
+						required: true
+					},
+					model: {
+						type: "string",
+						required: true
+					},
+					reasoning_effort: {
+						type: "string",
+						required: true
+					},
+					status: {
+						type: "string",
+						required: true
+					}
+				}
+			},
+			render: (_args, value) => [{
+				type: "text",
+				text: `Node "${value.node_name}" joined (subagent id ${value.node_id}, ${value.provider}/${value.model}${value.reasoning_effort === "" ? "" : ` @ ${value.reasoning_effort}`}, status ${value.status}).`
+			}]
+		},
+		async execute(args, exec) {
+			const captain = requireCaptain(exec);
+			const stateRoot = stateRootOf(workspaceOf(captain), config.stateDir);
+			const located = await findMeetingByCaptain(stateRoot, captain.id);
+			if (located === void 0) throw new Error("you are not leading any meeting — call roundtable_create first");
+			const meetingId = located.id;
+			return await withCaptainLock(stateRoot, meetingId, captain.id, "add nodes", async (fresh) => {
+				const nodeKey = sanitizeKey(String(args.name ?? "").trim());
+				if (nodeKey === "") throw new Error("node name must not be empty");
+				if (nodeKey === CAPTAIN_KEY || nodeKey === AGGREGATOR_KEY) throw new Error(`node name "${nodeKey}" is reserved`);
+				if (fresh.nodes.some((candidate) => candidate.key === nodeKey && candidate.status !== "removed")) throw new Error(`node "${nodeKey}" already exists in meeting "${fresh.name}"`);
+				if (fresh.nodes.filter((candidate) => candidate.status !== "removed").length >= config.maxNodes) throw new Error(`meeting "${fresh.name}" is at its node cap (${config.maxNodes})`);
+				const reasoningEffort = args.reasoning_effort !== void 0 ? String(args.reasoning_effort).trim() : "";
+				const node = {
+					id: "",
+					key: nodeKey,
+					role: args.role !== void 0 ? String(args.role) : void 0,
+					provider: args.provider !== void 0 ? String(args.provider) : captain.options.provider,
+					model: args.model !== void 0 ? String(args.model) : captain.options.model,
+					reasoningEffort: reasoningEffort === "" ? void 0 : reasoningEffort,
+					status: "idle",
+					joinedAt: Date.now()
+				};
+				const limits = config.getExpertLimits?.() ?? {
+					maxTokens: 0,
+					maxOpinions: 0
+				};
+				await spawnNode(ctx, {
+					provider: config.memberProvider,
+					maxDepth: config.memberMaxDepth
+				}, fresh, node, captain, config.stateDir, exec.signal, limits, {
+					names: fresh.skills ?? [],
+					delivery: fresh.skillDelivery ?? config.getSkillDelivery?.() ?? "relay"
+				});
+				fresh.nodes.push(node);
+				fresh.charter = buildCharter(fresh);
+				try {
+					await writeMeeting(stateRoot, fresh);
+				} catch (error) {
+					if (node.id !== "") interruptNode(ctx, captain, node.id);
+					throw error;
+				}
+				registerNodeChild(node.id, {
+					stateRoot,
+					meetingId
+				});
+				return {
+					node_name: node.key,
+					node_id: node.id,
+					provider: node.provider ?? "",
+					model: node.model ?? "",
+					reasoning_effort: node.reasoningEffort ?? "",
+					status: node.status
+				};
+			});
+		}
+	}));
+	ctx.tools.register(defineTool({
+		name: "roundtable_remove_node",
+		description: "Remove an expert node from your meeting: interrupts its live turn, marks it removed, and drops every edge touching it.",
+		parameters: { name: {
+			type: "string",
+			required: true,
+			description: "Key of the node to remove."
+		} },
+		output: {
+			schema: {
+				type: "object",
+				additionalProperties: false,
+				properties: {
+					node_name: {
+						type: "string",
+						required: true
+					},
+					removed_edges: {
+						type: "integer",
+						required: true
+					}
+				}
+			},
+			render: (_args, value) => [{
+				type: "text",
+				text: `Node "${value.node_name}" removed; ${value.removed_edges} edge(s) dropped.`
+			}]
+		},
+		async execute(args, exec) {
+			const captain = requireCaptain(exec);
+			const stateRoot = stateRootOf(workspaceOf(captain), config.stateDir);
+			const removed = await withCaptainLock(stateRoot, (await locateCaptainMeeting(stateRoot, captain.id)).id, captain.id, "remove nodes", async (fresh) => {
+				const node = requireNode(fresh, String(args.name ?? ""));
+				node.status = "removed";
+				const before = fresh.edges.length;
+				fresh.edges = fresh.edges.filter((edge) => edge.from !== node.key && edge.to !== node.key);
+				fresh.charter = buildCharter(fresh);
+				await writeMeeting(stateRoot, fresh);
+				return {
+					node,
+					removedEdges: before - fresh.edges.length
+				};
+			});
+			if (removed.node.id !== "") interruptNode(ctx, captain, removed.node.id);
+			forgetNodeChild(removed.node.id);
+			return {
+				node_name: removed.node.key,
+				removed_edges: removed.removedEdges
+			};
+		}
+	}));
+	ctx.tools.register(defineTool({
+		name: "roundtable_connect",
+		description: "Create a directed channel between two participants (a node key, \"captain\", or \"aggregator\"). Direction \"forward\" = pipeline hand-off; \"bidirectional\" = debate channel (both sides may address each other).",
+		parameters: {
+			from: {
+				type: "string",
+				required: true,
+				description: "Source endpoint: a node key, \"captain\", or \"aggregator\"."
+			},
+			to: {
+				type: "string",
+				required: true,
+				description: "Target endpoint: a node key, \"captain\", or \"aggregator\"."
+			},
+			direction: {
+				type: "string",
+				enum: ["forward", "bidirectional"],
+				description: "Channel direction (default forward)."
+			}
+		},
+		output: {
+			schema: {
+				type: "object",
+				additionalProperties: false,
+				properties: {
+					edge_id: {
+						type: "string",
+						required: true
+					},
+					from: {
+						type: "string",
+						required: true
+					},
+					to: {
+						type: "string",
+						required: true
+					},
+					direction: {
+						type: "string",
+						required: true
+					}
+				}
+			},
+			render: (_args, value) => [{
+				type: "text",
+				text: `Channel ${value.edge_id}: ${value.from} → ${value.to} (${value.direction}).`
+			}]
+		},
+		async execute(args, exec) {
+			const captain = requireCaptain(exec);
+			const stateRoot = stateRootOf(workspaceOf(captain), config.stateDir);
+			return withCaptainLock(stateRoot, (await locateCaptainMeeting(stateRoot, captain.id)).id, captain.id, "edit channels", async (fresh) => {
+				const from = String(args.from ?? "").trim();
+				const to = String(args.to ?? "").trim();
+				if (!validEndpoint(fresh, from)) throw new Error(`unknown endpoint "${from}"`);
+				if (!validEndpoint(fresh, to)) throw new Error(`unknown endpoint "${to}"`);
+				if (from === to) throw new Error("an edge cannot connect a participant to itself");
+				if (fresh.edges.some((edge$1) => edge$1.from === from && edge$1.to === to)) throw new Error(`channel ${from} → ${to} already exists`);
+				const direction = args.direction ?? "forward";
+				const edge = {
+					id: randomUUID(),
+					from,
+					to,
+					direction,
+					createdAt: Date.now()
+				};
+				fresh.edges.push(edge);
+				fresh.charter = buildCharter(fresh);
+				await writeMeeting(stateRoot, fresh);
+				return {
+					edge_id: edge.id,
+					from,
+					to,
+					direction
+				};
+			});
+		}
+	}));
+	ctx.tools.register(defineTool({
+		name: "roundtable_disconnect",
+		description: "Remove a channel by edge id, or by its from/to endpoints.",
+		parameters: {
+			edge_id: {
+				type: "string",
+				description: "Id of the edge to remove (from roundtable_status or connect)."
+			},
+			from: {
+				type: "string",
+				description: "Source endpoint (alternative to edge_id)."
+			},
+			to: {
+				type: "string",
+				description: "Target endpoint (alternative to edge_id)."
+			}
+		},
+		output: {
+			schema: {
+				type: "object",
+				additionalProperties: false,
+				properties: { removed: {
+					type: "boolean",
+					required: true
+				} }
+			},
+			render: (_args, value) => [{
+				type: "text",
+				text: value.removed ? "Channel removed." : "No matching channel found."
+			}]
+		},
+		async execute(args, exec) {
+			const captain = requireCaptain(exec);
+			const stateRoot = stateRootOf(workspaceOf(captain), config.stateDir);
+			return withCaptainLock(stateRoot, (await locateCaptainMeeting(stateRoot, captain.id)).id, captain.id, "edit channels", async (fresh) => {
+				const before = fresh.edges.length;
+				if (args.edge_id !== void 0) fresh.edges = fresh.edges.filter((edge) => edge.id !== String(args.edge_id));
+				else if (args.from !== void 0 && args.to !== void 0) fresh.edges = fresh.edges.filter((edge) => edge.from !== String(args.from) || edge.to !== String(args.to));
+				else throw new Error("provide edge_id, or both from and to");
+				fresh.charter = buildCharter(fresh);
+				await writeMeeting(stateRoot, fresh);
+				return { removed: before !== fresh.edges.length };
+			});
+		}
+	}));
+	ctx.tools.register(defineTool({
+		name: "roundtable_speak",
+		description: "Report into the meeting transcript — the default channel: durable, feeds the aggregation gateway, and wakes nobody. Use this instead of roundtable_send_message unless someone must act right now. Keep the charter format and the report envelope [REPORT R{轮} {key}] 结论（≤3 条）｜证据｜待决策; [核心产出] is the exact segment the gateway captures. Leave `to` empty to submit to the gateway; set it to a participant key for a directed remark.",
+		parameters: {
+			content: {
+				type: "string",
+				required: true,
+				description: "The full contribution text."
+			},
+			to: {
+				type: "string",
+				description: "Directed audience: a node key or \"captain\". Empty submits to the aggregation gateway."
+			},
+			kind: {
+				type: "string",
+				enum: [
+					"speech",
+					"proxy-thinking",
+					"retrieval"
+				],
+				description: "Contribution kind (default speech). Use \"proxy-thinking\" when you speak for a black-box worker model, \"retrieval\" when reporting knowledge-base retrieval."
+			}
+		},
+		output: {
+			schema: {
+				type: "object",
+				additionalProperties: false,
+				properties: {
+					utterance_id: {
+						type: "string",
+						required: true
+					},
+					round: {
+						type: "integer",
+						required: true
+					},
+					tokens_used: {
+						type: "integer",
+						required: true
+					},
+					budget_remaining_tokens: {
+						type: "integer",
+						required: true
+					}
+				}
+			},
+			render: (_args, value) => [{
+				type: "text",
+				text: `Contribution recorded (id ${value.utterance_id}, round ${value.round}); meeting token budget remaining ${value.budget_remaining_tokens}.`
+			}]
+		},
+		async execute(args, exec) {
+			const caller = requireCaptain(exec);
+			const stateRoot = stateRootOf(workspaceOf(caller), config.stateDir);
+			const located = await locateParticipantMeeting(stateRoot, caller.id);
+			return await withMeetingLock(meetingLockKey(stateRoot, located.id), async () => {
+				const { meeting, identity } = await requireFreshParticipant(stateRoot, located.id, caller.id);
+				const content = String(args.content ?? "").trim();
+				if (content === "") throw new Error("content must not be empty");
+				const speaker = identity.kind === "captain" ? CAPTAIN_KEY : identity.name;
+				const to = args.to !== void 0 ? String(args.to).trim() : void 0;
+				if (to !== void 0 && to !== "" && !validEndpoint(meeting, to)) throw new Error(`unknown directed audience "${to}"`);
+				const utterance = await recordUtterance(stateRoot, meeting, {
+					nodeKey: speaker,
+					kind: args.kind ?? "speech",
+					content,
+					to: to === "" ? void 0 : to
+				}, { opensNewRound: identity.kind === "captain" });
+				return {
+					utterance_id: utterance.id,
+					round: utterance.round,
+					tokens_used: estimateTokens(content),
+					budget_remaining_tokens: Math.max(0, meeting.budget.maxTokens - meeting.budget.usedTokens)
+				};
+			});
+		}
+	}));
+	ctx.tools.register(defineTool({
+		name: "roundtable_send_message",
+		description: "Send a direct message that WAKES the recipient as its next turn — use it only when they must act right now; ordinary reporting goes through roundtable_speak (durable, wakes nobody). When forwarding someone else's opinion, quote the reference R{n}[{speaker}] instead of pasting the full text. In \"orchestrated\" mode only the captain may message nodes (nodes report to the captain); in \"egalitarian\" mode any participant may message any other — this is how experts debate peer-to-peer.",
+		parameters: {
+			to: {
+				type: "string",
+				required: true,
+				description: "Recipient: \"captain\" or a node key."
+			},
+			content: {
+				type: "string",
+				required: true,
+				description: "The message text."
+			}
+		},
+		output: {
+			schema: {
+				type: "object",
+				additionalProperties: false,
+				properties: { delivered: {
+					type: "string",
+					required: true,
+					description: "wake (recipient node woken), live (captain steered), or dropped (best effort failed)."
+				} }
+			},
+			render: (_args, value) => [{
+				type: "text",
+				text: `Message delivered via ${value.delivered}.`
+			}]
+		},
+		async execute(args, exec) {
+			const caller = requireCaptain(exec);
+			const stateRoot = stateRootOf(workspaceOf(caller), config.stateDir);
+			const located = await locateParticipantMeeting(stateRoot, caller.id);
+			const content = String(args.content ?? "").trim();
+			if (content === "") throw new Error("content must not be empty");
+			const to = String(args.to ?? "").trim();
+			if (to === "") throw new Error("recipient must not be empty");
+			const prepared = await withMeetingLock(meetingLockKey(stateRoot, located.id), async () => {
+				const { meeting, identity } = await requireFreshParticipant(stateRoot, located.id, caller.id);
+				await assertUsablePersisting(stateRoot, meeting);
+				const speaker = identity.kind === "captain" ? CAPTAIN_KEY : identity.name;
+				if (meeting.mode !== "egalitarian" && identity.kind === "node" && to !== CAPTAIN_KEY) throw new Error("orchestrated/redteam mode: nodes report to the captain only — the captain relays between nodes");
+				if (to === CAPTAIN_KEY) {
+					await recordUtterance(stateRoot, meeting, {
+						nodeKey: speaker,
+						kind: "speech",
+						content,
+						to: CAPTAIN_KEY
+					});
+					return {
+						kind: "captain",
+						meeting,
+						speaker
+					};
+				}
+				const recipient = requireNode(meeting, to);
+				if (recipient.id === "") throw new Error(`node "${to}" has no live subagent yet`);
+				await recordUtterance(stateRoot, meeting, {
+					nodeKey: speaker,
+					kind: "speech",
+					content,
+					to
+				});
+				return {
+					kind: "node",
+					meeting,
+					speaker,
+					recipient
+				};
+			});
+			const captainLive = ctx.agents.get(prepared.meeting.captainSessionId);
+			if (prepared.kind === "captain") {
+				if (captainLive !== void 0 && prepared.speaker !== CAPTAIN_KEY) return { delivered: steerCaptain(captainLive, `RoundTable message from ${prepared.speaker}:\n\n${content}`) ? "live" : "dropped" };
+				return { delivered: "dropped" };
+			}
+			if (captainLive !== void 0) return { delivered: await deliverToNode(ctx, captainLive, prepared.recipient.id, content, exec.signal) ? "wake" : "dropped" };
+			return { delivered: "dropped" };
+		}
+	}));
+	ctx.tools.register(defineTool({
+		name: "roundtable_summarize",
+		description: "Pull the aggregation gateway digest: a deterministic structured merge of the transcript (per-speaker recent lines). Use it to stay aligned without reading every raw line; you may then condense it further in your own reply.",
+		parameters: {},
+		output: {
+			schema: {
+				type: "object",
+				additionalProperties: false,
+				properties: {
+					digest: {
+						type: "string",
+						required: true
+					},
+					speech_count: {
+						type: "integer",
+						required: true
+					}
+				}
+			},
+			render: (_args, value) => [{
+				type: "text",
+				text: `[Gateway digest]\n${value.digest}`
+			}]
+		},
+		async execute(_args, exec) {
+			const caller = requireCaptain(exec);
+			const stateRoot = stateRootOf(workspaceOf(caller), config.stateDir);
+			const utterances = await readTranscript(stateRoot, (await locateParticipantMeeting(stateRoot, caller.id)).id);
+			return {
+				digest: aggregateUtterances(utterances),
+				speech_count: utterances.filter((utterance) => utterance.kind === "speech" || utterance.kind === "proxy-thinking").length
+			};
+		}
+	}));
+	ctx.tools.register(defineTool({
+		name: "roundtable_request_decision",
+		description: "Pause the meeting and ask the human for a decision (Human-in-the-loop). The user picks one option or types their own. The meeting turn blocks until the user answers; the answer is then returned to you. Use for real forks or disagreements the experts cannot settle.",
+		parameters: {
+			question: {
+				type: "string",
+				required: true,
+				description: "The decision to put to the user (e.g. \"架构方案 A 还是 B？\")."
+			},
+			options: {
+				type: "array",
+				items: { type: "string" },
+				description: "Option labels (e.g. [\"方案 A：模块化\", \"方案 B：一体化\"]). The user may also type a custom answer."
+			},
+			multi_select: {
+				type: "boolean",
+				description: "Let the user tick MORE THAN ONE option in a single card. Use it for \"which of these findings are real?\" (review endorsements, defect shortlists) instead of asking one card per item — the selected labels come back joined by \" · \". Leave it off for \"pick one plan\" decisions."
+			}
+		},
+		output: {
+			schema: {
+				type: "object",
+				additionalProperties: false,
+				properties: {
+					decision_id: {
+						type: "string",
+						required: true
+					},
+					chosen: {
+						type: "string",
+						required: true
+					},
+					custom_answer: { type: "string" }
+				}
+			},
+			render: (_args, value) => [{
+				type: "text",
+				text: `Human decision ${value.decision_id}: ${value.chosen}${value.custom_answer !== void 0 && value.custom_answer !== "" ? ` (custom: ${value.custom_answer})` : ""}`
+			}]
+		},
+		async execute(args, exec) {
+			const captain = requireCaptain(exec);
+			const stateRoot = stateRootOf(workspaceOf(captain), config.stateDir);
+			const located = await locateCaptainMeeting(stateRoot, captain.id);
+			const multiSelect = args.multi_select === true;
+			const question = String(args.question ?? "").trim();
+			if (question === "") throw new Error("question must not be empty");
+			const optionLabels = Array.isArray(args.options) ? args.options.map((option) => String(option).trim()).filter((option) => option !== "") : [];
+			const decision = {
+				id: randomUUID(),
+				question,
+				options: optionLabels,
+				status: "pending",
+				ts: Date.now()
+			};
+			await withCaptainLock(stateRoot, located.id, captain.id, "request decisions", async (fresh) => {
+				fresh.decisions.push(decision);
+				await writeMeeting(stateRoot, fresh);
+			});
+			const userQuestions = ctx.get("userQuestions");
+			if (userQuestions === void 0) {
+				decision.status = "resolved";
+				decision.chosen = "(unavailable)";
+				await withMeetingLock(meetingLockKey(stateRoot, located.id), async () => {
+					const fresh = await readMeeting(stateRoot, located.id);
+					if (fresh !== void 0) await writeMeeting(stateRoot, fresh);
+				});
+				throw new Error("roundtable: human decision unavailable — the userQuestions service is not mounted in this composition");
+			}
+			const item = (await userQuestions.ask({
+				questions: [{
+					id: decision.id,
+					question,
+					header: "圆桌会议 · 需人类决策",
+					...optionLabels.length > 0 ? { options: optionLabels.map((label) => ({ label })) } : {},
+					...multiSelect ? { multiSelect: true } : {}
+				}],
+				agent: captain,
+				signal: exec.signal
+			})).answers.find((candidate) => candidate.id === decision.id);
+			const selected = Array.isArray(item?.selected) ? item.selected : [];
+			const chosen = multiSelect && selected.length > 1 ? selected.join(" · ") : selected[0];
+			const customAnswer = item?.custom !== void 0 && item.custom !== "" ? item.custom : void 0;
+			await withMeetingLock(meetingLockKey(stateRoot, located.id), async () => {
+				const fresh = await readMeeting(stateRoot, located.id);
+				if (fresh === void 0) return;
+				const target = fresh.decisions.find((candidate) => candidate.id === decision.id);
+				if (target !== void 0) {
+					target.status = "resolved";
+					target.chosen = chosen;
+					if (customAnswer !== void 0) target.customAnswer = customAnswer;
+				}
+				await writeMeeting(stateRoot, fresh);
+			});
+			return {
+				decision_id: decision.id,
+				chosen: chosen ?? "(no selection)",
+				...customAnswer !== void 0 ? { custom_answer: customAnswer } : {}
+			};
+		}
+	}));
+	ctx.tools.register(defineTool({
+		name: "roundtable_status",
+		description: "Meeting snapshot: nodes with live activity, edges, budget, pending decisions, and the transcript tail. Poll it at the start of every round. Pass since=<the previous call's next_since> to receive ONLY new lines — cursor pagination that never skips a line; omitted, it returns the last 10. The cached knowledge-base digests print as one line each unless you pass kb_full=true.",
+		parameters: {
+			since: {
+				type: "integer",
+				description: "Cursor returned as next_since by the previous call: return only utterances at or after it. Omit to get the last 10."
+			},
+			kb_full: {
+				type: "boolean",
+				description: "Print the full cached KB digests instead of only their first line (default false — keeps every poll cheap)."
+			}
+		},
+		output: {
+			schema: {
+				type: "object",
+				additionalProperties: true,
+				properties: {}
+			},
+			render: (_args, value) => [{
+				type: "text",
+				text: renderStatus(value)
+			}]
+		},
+		async execute(args, exec) {
+			const caller = requireCaptain(exec);
+			const stateRoot = stateRootOf(workspaceOf(caller), config.stateDir);
+			const located = await locateParticipantMeeting(stateRoot, caller.id);
+			const { meeting, identity } = await withMeetingLock(meetingLockKey(stateRoot, located.id), () => requireFreshParticipant(stateRoot, located.id, caller.id));
+			const activity = await reconcileNodeLiveness(ctx, meeting.captainSessionId, meeting.nodes);
+			const utterances = await readTranscript(stateRoot, meeting.id);
+			const userActions = await readUserActions(stateRoot, meeting.id);
+			const sinceArg = args.since;
+			const since = typeof sinceArg === "number" && Number.isFinite(sinceArg) && sinceArg > 0 ? Math.min(Math.floor(sinceArg), utterances.length) : Math.max(0, utterances.length - STATUS_TAIL_DEFAULT);
+			const tail = utterances.slice(since);
+			const shownUtterances = tail.slice(0, STATUS_TAIL_MAX);
+			const nextSince = since + shownUtterances.length;
+			const kbFull = args.kb_full === true;
+			const realUsage = meetingRealUsage(ctx, meeting.nodes.filter((node) => node.status !== "removed" && node.id !== "").map((node) => node.id));
+			if (realUsage.measuredSessions > 0 && meeting.budget.usedTokensReal !== realUsage.measuredTotal) try {
+				await withMeetingLock(meetingLockKey(stateRoot, meeting.id), async () => {
+					const fresh = await readMeeting(stateRoot, meeting.id);
+					if (fresh === void 0) return;
+					fresh.budget.usedTokensReal = realUsage.measuredTotal;
+					await writeMeeting(stateRoot, fresh);
+				});
+			} catch {}
+			return {
+				meeting_id: meeting.id,
+				meeting_name: meeting.name,
+				mode: meeting.mode,
+				status: meeting.status,
+				viewer: identity.kind === "captain" ? CAPTAIN_KEY : identity.name,
+				round: meeting.round,
+				kb_path: meeting.kbPath ?? "",
+				skills: meeting.skills ?? [],
+				skill_delivery: meeting.skillDelivery ?? config.getSkillDelivery?.() ?? "relay",
+				budget: {
+					max_rounds: meeting.budget.maxRounds,
+					max_tokens: meeting.budget.maxTokens,
+					used_rounds: meeting.budget.usedRounds,
+					used_tokens: meeting.budget.usedTokens
+				},
+				tokens_real: {
+					measured_total: realUsage.measuredTotal,
+					measured_sessions: realUsage.measuredSessions,
+					unmeasured_sessions: realUsage.unmeasuredSessions
+				},
+				nodes: meeting.nodes.filter((node) => node.status !== "removed").map((node) => ({
+					key: node.key,
+					role: node.role ?? "",
+					provider: node.provider ?? "",
+					model: node.model ?? "",
+					reasoning_effort: node.reasoningEffort ?? "",
+					status: node.status,
+					activity: activity.get(node.key) ?? "unspawned",
+					last_error: node.lastError ?? ""
+				})),
+				edges: meeting.edges.map((edge) => ({
+					id: edge.id,
+					from: edge.from,
+					to: edge.to,
+					direction: edge.direction
+				})),
+				pending_decisions: meeting.decisions.filter((decision) => decision.status === "pending").map((decision) => ({
+					id: decision.id,
+					question: decision.question,
+					options: decision.options
+				})),
+				pending_actions: userActions.map((action) => ({
+					id: action.id,
+					kind: action.kind,
+					node_key: action.nodeKey ?? "",
+					role: action.role ?? "",
+					provider: action.provider ?? "",
+					model: action.model ?? "",
+					text: action.text
+				})),
+				recent_utterances: shownUtterances.map((utterance) => ({
+					speaker: utterance.nodeKey,
+					kind: utterance.kind,
+					content: extractCore(utterance.summary ?? utterance.content).slice(0, STATUS_LINE_CHARS),
+					to: utterance.to ?? "",
+					round: utterance.round
+				})),
+				next_since: nextSince,
+				has_more: tail.length > shownUtterances.length,
+				kb_full: kbFull,
+				kb_digest: await kbDigestOverview(stateRoot, meeting.id)
+			};
+		}
+	}));
+	ctx.tools.register(defineTool({
+		name: "roundtable_kb_digest",
+		description: "Record (or refresh) a knowledge-base digest in the meeting cache after YOU read a KB file. The plugin stats the file itself and stores path+size+mtimeMs as the invalidation key; from then on roundtable_status shows that entry with valid=true and you reuse the summary instead of reading the file again — this is what stops you and the expert paying for the same file twice, and the cache itself costs no tokens. Check roundtable_status FIRST: if the entry is already valid, reuse it and do not read the file. Requires the captain.",
+		parameters: {
+			path: {
+				type: "string",
+				required: true,
+				description: "KB file path: absolute, or relative to the meeting's kb_path."
+			},
+			digest: {
+				type: "string",
+				required: true,
+				description: "The distilled points you will actually reuse (a summary, not a copy of the file)."
+			}
+		},
+		output: {
+			schema: {
+				type: "object",
+				additionalProperties: false,
+				properties: {
+					path: {
+						type: "string",
+						required: true
+					},
+					size: {
+						type: "integer",
+						required: true
+					},
+					mtime_ms: {
+						type: "integer",
+						required: true
+					},
+					cached_entries: {
+						type: "integer",
+						required: true
+					}
+				}
+			},
+			render: (_args, value) => [{
+				type: "text",
+				text: `Knowledge-base digest cached for ${value.path} (${value.size} bytes); ${value.cached_entries} entry(ies) in this meeting's cache.`
+			}]
+		},
+		async execute(args, exec) {
+			const captain = requireCaptain(exec);
+			const stateRoot = stateRootOf(workspaceOf(captain), config.stateDir);
+			return withCaptainLock(stateRoot, (await locateCaptainMeeting(stateRoot, captain.id)).id, captain.id, "record a knowledge-base digest", async (fresh) => {
+				const raw = String(args.path ?? "").trim();
+				if (raw === "") throw new Error("path must not be empty");
+				const kbPath = fresh.kbPath ?? "";
+				const resolved = isAbsolute(raw) ? raw : kbPath === "" ? raw : join(kbPath, raw);
+				let info;
+				try {
+					info = await stat(resolved);
+				} catch {
+					throw new Error(`knowledge-base file not found or unreadable: ${resolved}`);
+				}
+				if (!info.isFile()) throw new Error(`not a file: ${resolved}`);
+				const digestText = String(args.digest ?? "").trim();
+				if (digestText === "") throw new Error("digest must not be empty");
+				const entries = mergeKbDigestEntry((await readKbDigest(stateRoot, fresh.id)).entries, {
+					path: resolved,
+					size: info.size,
+					mtimeMs: info.mtimeMs,
+					digest: digestText,
+					ts: Date.now()
+				});
+				await writeKbDigest(stateRoot, fresh.id, entries);
+				return {
+					path: resolved,
+					size: info.size,
+					mtime_ms: Math.round(info.mtimeMs),
+					cached_entries: entries.length
+				};
+			});
+		}
+	}));
+	ctx.tools.register(defineTool({
+		name: "roundtable_actions_clear",
+		description: "Clear the meeting's pending user-actions file (user-actions.jsonl) after you executed every recorded action with the roundtable_* tools. Only call this after each action was applied successfully; on a failure keep the record and explain why. Returns how many actions were cleared, plus how many unparseable lines had to be dropped (report a non-zero count to the user — an action was lost).",
+		parameters: {},
+		output: {
+			schema: {
+				type: "object",
+				additionalProperties: false,
+				properties: {
+					cleared: {
+						type: "integer",
+						required: true
+					},
+					malformed: {
+						type: "integer",
+						required: true
+					}
+				}
+			},
+			render: (_args, value) => [{
+				type: "text",
+				text: value.malformed > 0 ? `Cleared ${value.cleared} pending user action(s), and dropped ${value.malformed} unparseable line(s) — tell the user those operations were lost and could not be executed.` : `Cleared ${value.cleared} pending user action(s).`
+			}]
+		},
+		async execute(_args, exec) {
+			const captain = requireCaptain(exec);
+			const stateRoot = stateRootOf(workspaceOf(captain), config.stateDir);
+			return withCaptainLock(stateRoot, (await locateCaptainMeeting(stateRoot, captain.id)).id, captain.id, "clear user actions", async (fresh) => {
+				return clearUserActions(stateRoot, fresh.id);
+			}, { allowMuted: true });
+		}
+	}));
+	ctx.tools.register(defineTool({
+		name: "roundtable_start_review",
+		description: "Start a 针锋相对 (adversarial) review pass of a settled plan: records the user's original question and the captain's plan into review.json, so the Web review window can show them. First pass = reviewPass 1. After a previous pass was finished (status done), calling this again starts the next review pass (reviewPass + 1, closed loop 闭环复审) and preserves the previous pass in history; the captain may open at most 2 re-review passes beyond the first (maxReviewPass 3). To go beyond the cap, the user must have explicitly approved: pass user_approved_extra_pass=true. Requires the captain.",
+		parameters: {
+			question: {
+				type: "string",
+				required: true,
+				description: "The user's original question / topic."
+			},
+			plan: {
+				type: "string",
+				required: true,
+				description: "The settled plan and its explanation (the object under review)."
+			},
+			user_approved_extra_pass: {
+				type: "boolean",
+				description: "Set true ONLY when the user explicitly approved exceeding the re-review cap (maxReviewPass). Never set on your own."
+			}
+		},
+		output: {
+			schema: {
+				type: "object",
+				additionalProperties: false,
+				properties: {
+					review_id: {
+						type: "string",
+						required: true
+					},
+					status: {
+						type: "string",
+						required: true
+					},
+					review_pass: {
+						type: "integer",
+						required: true
+					},
+					max_review_pass: {
+						type: "integer",
+						required: true
+					}
+				}
+			},
+			render: (_args, value) => [{
+				type: "text",
+				text: `Review started (id ${value.review_id}, status ${value.status}, review pass ${value.review_pass}/${value.max_review_pass}). Tell the experts to attack ONLY the plan (red-team).`
+			}]
+		},
+		async execute(args, exec) {
+			const captain = requireCaptain(exec);
+			const stateRoot = stateRootOf(workspaceOf(captain), config.stateDir);
+			const located = await locateCaptainMeeting(stateRoot, captain.id);
+			const question = String(args.question ?? "").trim();
+			const plan = String(args.plan ?? "").trim();
+			if (question === "" || plan === "") throw new Error("question and plan must not be empty");
+			return withCaptainLock(stateRoot, located.id, captain.id, "start a review", async (fresh) => {
+				const existing = await readReview(stateRoot, fresh.id);
+				if (existing !== void 0 && existing.status !== "done") throw new Error(`a review is already in progress (status ${existing.status}) — finish it before starting a new pass`);
+				const reviewPass = (existing?.status === "done" && typeof existing.reviewPass === "number" ? existing.reviewPass : 0) + 1;
+				const maxReviewPass = existing?.maxReviewPass ?? 3;
+				if (reviewPass > maxReviewPass && args.user_approved_extra_pass !== true) throw new Error(`re-review cap reached (pass ${reviewPass} > max ${maxReviewPass}) — ask the user to approve continuing, then retry with user_approved_extra_pass=true, or export and finish the review`);
+				const now = Date.now();
+				const review = {
+					meetingId: fresh.id,
+					question,
+					plan,
+					status: "reviewing",
+					reviewPass,
+					maxReviewPass,
+					schemaVersion: 2,
+					viewpoints: [],
+					startedAt: now,
+					updatedAt: now,
+					history: existing?.status === "done" ? [...existing.history ?? [], {
+						pass: existing.reviewPass,
+						question: existing.question,
+						plan: existing.plan,
+						viewpoints: existing.viewpoints,
+						finishedAt: existing.finishedAt ?? now
+					}] : []
+				};
+				await writeReview(stateRoot, fresh.id, review);
+				return {
+					review_id: fresh.id,
+					status: review.status,
+					review_pass: review.reviewPass,
+					max_review_pass: review.maxReviewPass
+				};
+			});
+		}
+	}));
+	ctx.tools.register(defineTool({
+		name: "roundtable_collect_review",
+		description: "Collect the red-team experts' objections from the transcript into review.json (viewpoints), then the Web review window becomes ready. Call this after the experts have spoken (roundtable_speak). Idempotent: already-collected utterances are skipped. Requires the captain.",
+		parameters: {},
+		output: {
+			schema: {
+				type: "object",
+				additionalProperties: false,
+				properties: {
+					collected: {
+						type: "integer",
+						required: true
+					},
+					split_attempts: {
+						type: "integer",
+						required: true
+					},
+					status: {
+						type: "string",
+						required: true
+					}
+				}
+			},
+			render: (_args, value) => [{
+				type: "text",
+				text: `Review collected: ${value.collected} viewpoint(s) (${value.split_attempts} split attempt(s)), status ${value.status}.`
+			}]
+		},
+		async execute(_args, exec) {
+			const captain = requireCaptain(exec);
+			const stateRoot = stateRootOf(workspaceOf(captain), config.stateDir);
+			return withCaptainLock(stateRoot, (await locateCaptainMeeting(stateRoot, captain.id)).id, captain.id, "collect review", async (fresh) => {
+				const review = await readReview(stateRoot, fresh.id);
+				if (review === void 0) throw new Error("no review in progress — call roundtable_start_review first");
+				const collectedUtteranceIds = new Set(review.viewpoints.map((viewpoint) => viewpoint.utteranceId));
+				const utterances = await readTranscript(stateRoot, fresh.id);
+				const llm = ctx.get("llm");
+				const splitConfig = config.reviewSplit;
+				let collected = 0;
+				let splitAttempts = 0;
+				for (const utterance of utterances) {
+					if (utterance.nodeKey === CAPTAIN_KEY) continue;
+					if (utterance.kind !== "speech" && utterance.kind !== "proxy-thinking") continue;
+					if (utterance.ts < review.startedAt) continue;
+					if (collectedUtteranceIds.has(utterance.id)) continue;
+					const content = utterance.content.replace(/\s+/g, " ").trim();
+					if (content === "") continue;
+					let lines = null;
+					if (llm !== void 0 && splitConfig !== void 0) try {
+						lines = await splitUtterance(llm, splitConfig, utterance.nodeKey, content);
+						splitAttempts += 1;
+					} catch {
+						lines = null;
+					}
+					if (lines === null) try {
+						lines = splitByMarkers(content);
+					} catch {
+						lines = null;
+					}
+					if (lines !== null && lines.length > 0) lines.forEach((line$1, index) => {
+						review.viewpoints.push({
+							id: `${utterance.id}#${index + 1}`,
+							utteranceId: utterance.id,
+							nodeKey: utterance.nodeKey,
+							content: line$1.content,
+							status: "pending",
+							quote: line$1.quote,
+							dimension: line$1.dimension,
+							evidence: line$1.evidence,
+							ts: utterance.ts,
+							seq: index + 1
+						});
+						collected += 1;
+					});
+					else {
+						review.viewpoints.push({
+							id: `${utterance.id}#0`,
+							utteranceId: utterance.id,
+							nodeKey: utterance.nodeKey,
+							content,
+							status: "pending",
+							dimension: "其他",
+							ts: utterance.ts,
+							seq: 0
+						});
+						collected += 1;
+					}
+				}
+				if (collected > 0) review.status = "ready";
+				await writeReview(stateRoot, fresh.id, review);
+				return {
+					collected,
+					split_attempts: splitAttempts,
+					status: review.status
+				};
+			});
+		}
+	}));
+	ctx.tools.register(defineTool({
+		name: "roundtable_finish_review",
+		description: "Finish the current 针锋相对 review pass: marks it done (closed loop 闭环 can then start the next pass with roundtable_start_review). Records remaining endorsed (已认定) defects as the known-flaws checklist. Call this after the user finished endorsing/rejecting viewpoints and you have revised the plan (or decided to stop). Requires the captain.",
+		parameters: { revised_plan_summary: {
+			type: "string",
+			description: "Optional one-line summary of how the endorsed defects were addressed in the revised plan (写入历史，供下一轮核对)."
+		} },
+		output: {
+			schema: {
+				type: "object",
+				additionalProperties: false,
+				properties: {
+					status: {
+						type: "string",
+						required: true
+					},
+					review_pass: {
+						type: "integer",
+						required: true
+					},
+					endorsed_count: {
+						type: "integer",
+						required: true
+					},
+					can_review_again: {
+						type: "boolean",
+						required: true
+					}
+				}
+			},
+			render: (_args, value) => [{
+				type: "text",
+				text: `Review pass ${value.review_pass} finished (status ${value.status}, ${value.endorsed_count} endorsed defect(s)). ${value.can_review_again ? "You may start the next re-review pass with roundtable_start_review." : "Re-review cap reached — export the record and present the consolidated result."}`
+			}]
+		},
+		async execute(args, exec) {
+			const captain = requireCaptain(exec);
+			const stateRoot = stateRootOf(workspaceOf(captain), config.stateDir);
+			return withCaptainLock(stateRoot, (await locateCaptainMeeting(stateRoot, captain.id)).id, captain.id, "finish the review", async (fresh) => {
+				const review = await readReview(stateRoot, fresh.id);
+				if (review === void 0) throw new Error("no review in progress — call roundtable_start_review first");
+				if (review.status === "done") return {
+					status: review.status,
+					review_pass: review.reviewPass,
+					endorsed_count: countEndorsed(review),
+					can_review_again: review.reviewPass < review.maxReviewPass
+				};
+				if (review.status === "reviewing") throw new Error("review is still collecting viewpoints — call roundtable_collect_review before finishing");
+				review.status = "done";
+				review.finishedAt = Date.now();
+				const summary = String(args.revised_plan_summary ?? "").trim();
+				if (summary !== "") {
+					const last = review.history.length > 0 ? review.history[review.history.length - 1] : void 0;
+					if (last !== void 0 && last.pass === review.reviewPass) last.revisedPlanSummary = summary;
+					else review.history.push({
+						pass: review.reviewPass,
+						question: review.question,
+						plan: review.plan,
+						viewpoints: review.viewpoints,
+						finishedAt: Date.now(),
+						revisedPlanSummary: summary
+					});
+				}
+				await writeReview(stateRoot, fresh.id, review);
+				return {
+					status: review.status,
+					review_pass: review.reviewPass,
+					endorsed_count: countEndorsed(review),
+					can_review_again: review.reviewPass < review.maxReviewPass
+				};
+			});
+		}
+	}));
+	ctx.tools.register(defineTool({
+		name: "roundtable_export_review",
+		description: "Export the full 针锋相对 review record (all passes, viewpoints, endorsements, reject reasons, revision summaries) as a Markdown deliverable with a prefilled issue header (plugin version, mode, expert providers/models) — ready to paste into a GitHub issue or keep as a review record. Requires the captain.",
+		parameters: {},
+		output: {
+			schema: {
+				type: "object",
+				additionalProperties: false,
+				properties: { markdown: {
+					type: "string",
+					required: true
+				} }
+			},
+			render: (_args, value) => [{
+				type: "text",
+				text: value.markdown
+			}]
+		},
+		async execute(_args, exec) {
+			const captain = requireCaptain(exec);
+			const stateRoot = stateRootOf(workspaceOf(captain), config.stateDir);
+			return withCaptainLock(stateRoot, (await locateCaptainMeeting(stateRoot, captain.id)).id, captain.id, "export the review", async (fresh) => {
+				const review = await readReview(stateRoot, fresh.id);
+				if (review === void 0) throw new Error("no review record yet — call roundtable_start_review first");
+				return { markdown: renderReviewMarkdown(review, fresh) };
+			}, { allowMuted: true });
+		}
+	}));
+	ctx.tools.register(defineTool({
+		name: "roundtable_export_meeting",
+		description: "Export the WHOLE meeting — issue-style header (plugin version, mode, time span, budget), goal, expert roster, the decision log, every round of the transcript with speaker → audience, the review record when one exists, and the user adjustment log — as a Markdown deliverable. Returns the Markdown AND writes it to <meetingDir>/export.md so the user can open the file directly. It works on an in-progress meeting too (the header then marks it as a snapshot). Requires the captain.",
+		parameters: { save: {
+			type: "boolean",
+			description: "Also write the Markdown to <meetingDir>/export.md (default true). Pass false to only return the text."
+		} },
+		output: {
+			schema: {
+				type: "object",
+				additionalProperties: false,
+				properties: {
+					markdown: {
+						type: "string",
+						required: true
+					},
+					saved_to: {
+						type: "string",
+						required: true
+					},
+					bytes: {
+						type: "integer",
+						required: true
+					}
+				}
+			},
+			render: (_args, value) => [{
+				type: "text",
+				text: value.saved_to === "" ? value.markdown : `${value.markdown}\n\n---\n（已同时写入 ${value.saved_to}，${value.bytes} 字节）`
+			}]
+		},
+		async execute(args, exec) {
+			const captain = requireCaptain(exec);
+			const stateRoot = stateRootOf(workspaceOf(captain), config.stateDir);
+			return withCaptainLock(stateRoot, (await locateCaptainMeeting(stateRoot, captain.id)).id, captain.id, "export the meeting", async (fresh) => {
+				const utterances = await readTranscript(stateRoot, fresh.id);
+				const { actions } = await readUserActionsReport(stateRoot, fresh.id);
+				const markdown = renderMeetingMarkdown(fresh, utterances, actions, await readReview(stateRoot, fresh.id));
+				const bytes = Buffer.byteLength(markdown, "utf8");
+				if (args.save === false) return {
+					markdown,
+					saved_to: "",
+					bytes
+				};
+				const file = join(meetingDirOf(stateRoot, fresh.id), "export.md");
+				await writeTextAtomic(file, markdown);
+				return {
+					markdown,
+					saved_to: file,
+					bytes
+				};
+			}, { allowMuted: true });
+		}
+	}));
+	ctx.tools.register(defineTool({
+		name: "roundtable_set_budget",
+		description: "Adjust the meeting budget. Top up max_rounds/max_tokens to unmute (闭麦后恢复) a muted meeting, or tighten them. Requires the captain.",
+		parameters: {
+			max_rounds: {
+				type: "integer",
+				description: "New round cap."
+			},
+			max_tokens: {
+				type: "integer",
+				description: "New total token budget."
+			}
+		},
+		output: {
+			schema: {
+				type: "object",
+				additionalProperties: false,
+				properties: {
+					status: {
+						type: "string",
+						required: true
+					},
+					max_rounds: {
+						type: "integer",
+						required: true
+					},
+					max_tokens: {
+						type: "integer",
+						required: true
+					}
+				}
+			},
+			render: (_args, value) => [{
+				type: "text",
+				text: `Budget updated: ${value.max_rounds} rounds / ${value.max_tokens} tokens (meeting status ${value.status}).`
+			}]
+		},
+		async execute(args, exec) {
+			const captain = requireCaptain(exec);
+			const stateRoot = stateRootOf(workspaceOf(captain), config.stateDir);
+			return withCaptainLock(stateRoot, (await locateCaptainMeeting(stateRoot, captain.id)).id, captain.id, "change the budget", async (fresh) => {
+				if (typeof args.max_rounds === "number") fresh.budget.maxRounds = Math.floor(args.max_rounds);
+				if (typeof args.max_tokens === "number") fresh.budget.maxTokens = Math.floor(args.max_tokens);
+				if (fresh.status === "muted" && budgetExceeded(fresh) === void 0) fresh.status = "active";
+				await writeMeeting(stateRoot, fresh);
+				return {
+					status: fresh.status,
+					max_rounds: fresh.budget.maxRounds,
+					max_tokens: fresh.budget.maxTokens
+				};
+			}, { allowMuted: true });
+		}
+	}));
+	ctx.tools.register(defineTool({
+		name: "roundtable_close",
+		description: "End your meeting: interrupts all nodes (best effort) and marks the meeting ended. The record stays on disk for review.",
+		parameters: {},
+		output: {
+			schema: {
+				type: "object",
+				additionalProperties: false,
+				properties: {
+					closed: {
+						type: "boolean",
+						required: true
+					},
+					meeting_name: {
+						type: "string",
+						required: true
+					}
+				}
+			},
+			render: (_args, value) => [{
+				type: "text",
+				text: `Meeting "${value.meeting_name}" closed.`
+			}]
+		},
+		async execute(_args, exec) {
+			const captain = requireCaptain(exec);
+			const stateRoot = stateRootOf(workspaceOf(captain), config.stateDir);
+			const located = await locateCaptainMeeting(stateRoot, captain.id);
+			const nodes = await withCaptainLock(stateRoot, located.id, captain.id, "close it", async (fresh) => {
+				const roster = fresh.nodes.map((node) => ({ ...node }));
+				for (const node of fresh.nodes) if (node.status !== "removed") node.status = "removed";
+				fresh.status = "ended";
+				await writeMeeting(stateRoot, fresh);
+				return roster;
+			}, { allowMuted: true });
+			for (const node of nodes) if (node.id !== "") interruptNode(ctx, captain, node.id);
+			return {
+				closed: true,
+				meeting_name: located.name
+			};
+		}
+	}));
+	ctx.tools.register(defineTool({
+		name: "roundtable_proxy_think",
+		description: "Proxy Thinking (代理思考): prepare to hand a task to a black-box worker model (no visible reasoning). Returns the director-side template you must fill in: write [DeepSeek 代理思考] reasoning, translate the task into exact worker parameters, and state expectations/fallbacks. Then deliver the translated parameters to the worker model.",
+		parameters: {
+			worker_model: {
+				type: "string",
+				required: true,
+				description: "The black-box worker model (e.g. seedance, an image model)."
+			},
+			task: {
+				type: "string",
+				required: true,
+				description: "The goal to translate for the worker model."
+			}
+		},
+		output: {
+			schema: {
+				type: "object",
+				additionalProperties: false,
+				properties: { template: {
+					type: "string",
+					required: true
+				} }
+			},
+			render: (_args, value) => [{
+				type: "text",
+				text: value.template
+			}]
+		},
+		async execute(args, exec) {
+			const caller = requireCaptain(exec);
+			const stateRoot = stateRootOf(workspaceOf(caller), config.stateDir);
+			const located = await findMeetingByParticipant(stateRoot, caller.id);
+			const workerModel = String(args.worker_model ?? "").trim();
+			const task = String(args.task ?? "").trim();
+			if (workerModel === "" || task === "") throw new Error("worker_model and task must not be empty");
+			if (located !== void 0) await withMeetingLock(meetingLockKey(stateRoot, located.id), async () => {
+				const { meeting, identity } = await requireFreshParticipant(stateRoot, located.id, caller.id);
+				await recordUtterance(stateRoot, meeting, {
+					nodeKey: identity.kind === "captain" ? CAPTAIN_KEY : identity.name,
+					kind: "proxy-thinking",
+					content: `[代理思考 → ${workerModel}] ${task}`
+				});
+			});
+			return { template: proxyThinkingPrompt(workerModel, task) };
+		}
+	}));
+}
+/** Render the status snapshot as compact text for the model. */
+/** 知识库摘要缓存概览（C2）。
+*
+*  每条都用磁盘现状标注 valid：主持人据此决定"直接用摘要"还是"重读文件"，
+*  不必自己猜 mtime。条目上限 50、每条摘要上限 2000 字符（见 kb-digest.ts）。 */
+async function kbDigestOverview(stateRoot, meetingId) {
+	const evaluated = await evaluateKbDigests((await readKbDigest(stateRoot, meetingId)).entries);
+	return {
+		count: evaluated.length,
+		valid_count: evaluated.filter((entry) => entry.valid).length,
+		entries: evaluated.map((entry) => ({
+			path: entry.path,
+			size: entry.size,
+			mtime_ms: Math.round(entry.mtimeMs),
+			digest: entry.digest,
+			valid: entry.valid,
+			updated_at: new Date(entry.ts).toISOString()
+		}))
+	};
+}
+/** 状态行里最多列几条缓存、每条摘要最多显示多少字符（避免状态输出失控）。 */
+const KB_DIGEST_RENDER_LIMIT = 10;
+const KB_DIGEST_RENDER_CHARS = 800;
+/** KB 摘要的默认呈现宽度（只印首行）：每次轮询都重印整份缓存是最容易被忽视
+*  的重复成本 —— 正文只在主持人真要照它干活时才用 kb_full=true 取。 */
+const KB_DIGEST_PREVIEW_CHARS = 120;
+/** 无 since 时返回的尾部条数（与原行为一致）。 */
+const STATUS_TAIL_DEFAULT = 10;
+/** 单次最多返回条数；超出部分留给下一次 since 调用，绝不跳过任何一条。 */
+const STATUS_TAIL_MAX = 40;
+/** status 里每条发言的字符上限（已先用 extractCore 取出核心产出）。 */
+const STATUS_LINE_CHARS = 240;
+/** 取摘要的第一行作为预览（跳过空行）。 */
+function digestFirstLine(digest, limit) {
+	const line$1 = digest.split("\n").map((part) => part.trim()).find((part) => part !== "") ?? "";
+	return line$1.length > limit ? `${line$1.slice(0, limit)}…` : line$1;
+}
+function renderStatus(value) {
+	const nodes = Array.isArray(value.nodes) ? value.nodes : [];
+	const edges = Array.isArray(value.edges) ? value.edges : [];
+	const budget = value.budget ?? {};
+	const pending = Array.isArray(value.pending_decisions) ? value.pending_decisions : [];
+	const pendingActions = Array.isArray(value.pending_actions) ? value.pending_actions : [];
+	const recent = Array.isArray(value.recent_utterances) ? value.recent_utterances : [];
+	const kbDigest = value.kb_digest ?? {};
+	const real = value.tokens_real ?? {};
+	const realMeasured = Number(real.measured_sessions ?? 0);
+	const realMissing = Number(real.unmeasured_sessions ?? 0);
+	const realLine = realMeasured === 0 ? "Real token usage: not measurable right now (provider-reported usage requires a live child session)" : `Real token usage (provider-reported): ${String(real.measured_total ?? 0)} tokens across ${realMeasured} expert session(s)${realMissing > 0 ? `; ${realMissing} not measurable` : ""}`;
+	const kbEntries = Array.isArray(kbDigest.entries) ? kbDigest.entries : [];
+	const kbListed = kbEntries.slice(0, KB_DIGEST_RENDER_LIMIT);
+	const kbFull = value.kb_full === true;
+	const nextSince = Number(value.next_since ?? 0);
+	const hasMore = value.has_more === true;
+	return [
+		`Meeting "${String(value.meeting_name)}" (id ${String(value.meeting_id)}, mode ${String(value.mode)}, status ${String(value.status)}, round ${String(value.round)})`,
+		`Knowledge base path: ${String(value.kb_path ?? "") === "" ? "(none)" : String(value.kb_path)}`,
+		`Budget: ${String(budget.used_rounds)}/${String(budget.max_rounds)} rounds, ${String(budget.used_tokens)}/${String(budget.max_tokens)} tokens (spoken-text estimate only — NOT the real LLM spend)`,
+		realLine,
+		`Nodes (${nodes.length}):`,
+		...nodes.map((node) => {
+			const effort = String(node.reasoning_effort ?? "");
+			const activity = String(node.activity ?? "");
+			const base = `  - ${String(node.key)} [${String(node.role ?? "")}] ${String(node.status)}/${activity} · ${String(node.provider ?? "")}/${String(node.model ?? "")}${effort === "" ? "" : ` @${effort}`}`;
+			const orphan = activity === "missing" ? "\n      ⚠ 宿主已不认识该专家的子代理（消息会投进虚空，建议重加）" : "";
+			const error = String(node.last_error ?? "");
+			return `${base}${orphan}${error === "" ? "" : `\n      ⚠ ${error}`}`;
+		}),
+		`Edges (${edges.length}):`,
+		...edges.map((edge) => `  - ${String(edge.from)} → ${String(edge.to)} (${String(edge.direction)})`),
+		`Pending decisions: ${pending.length === 0 ? "none" : pending.map((decision) => `"${String(decision.question)}"`).join("; ")}`,
+		`Pending user actions (${pendingActions.length}): ${pendingActions.length === 0 ? "none" : pendingActions.map((action) => `"${String(action.text)}"`).join("; ")}`,
+		`KB digest cache: ${String(kbDigest.count ?? 0)} entry(ies), ${String(kbDigest.valid_count ?? 0)} still valid (HIT = reuse the digest; STALE = the file changed, read it again):`,
+		...kbListed.map((entry) => {
+			const digest = String(entry.digest ?? "");
+			const shown = kbFull ? digest.length > KB_DIGEST_RENDER_CHARS ? `${digest.slice(0, KB_DIGEST_RENDER_CHARS)}…` : digest : digestFirstLine(digest, KB_DIGEST_PREVIEW_CHARS);
+			return `  - [${entry.valid === true ? "HIT" : "STALE"}] ${String(entry.path)}: ${shown}`;
+		}),
+		...kbEntries.length > kbListed.length ? [`  - …and ${kbEntries.length - kbListed.length} more cached entr(ies)`] : [],
+		...!kbFull && kbListed.length > 0 ? ["  (pass kb_full=true only if you actually need these digests in full)"] : [],
+		`Transcript${hasMore ? " (more new lines remain — poll again with the cursor below)" : ""}:`,
+		...recent.map((utterance) => {
+			const kind = String(utterance.kind ?? "");
+			const tag = kind === "" || kind === "speech" ? "" : ` {${kind}}`;
+			return `  [R${String(utterance.round)}] ${String(utterance.speaker)}${tag}${String(utterance.to ?? "") === "" ? "" : ` → ${String(utterance.to)}`}: ${String(utterance.content)}`;
+		}),
+		`Cursor: pass since=${nextSince} on the next poll to receive only new lines.`
+	].join("\n");
+}
+/** Count endorsed (已认定) viewpoints in the current pass. */
+function countEndorsed(review) {
+	return review.viewpoints.filter((viewpoint) => viewpoint.status === "endorsed").length;
+}
+/** One-line viewpoint marker inside the exported markdown. */
+function viewpointStatusLabel(status) {
+	if (status === "endorsed") return "✅ 已认定";
+	if (status === "rejected") return "❌ 已驳回";
+	return "⬜ 未表态";
+}
+/** Evidence line inside the exported markdown. */
+function evidenceLine(evidence) {
+	if (evidence === void 0) return "";
+	return `\n  - **${evidence.kind === "repro" ? "证据（可复现步骤）" : "证据（论证链）"}**：${evidence.text}`;
+}
+/** Render the full review record as a Markdown deliverable (C5/E2).
+*  The header carries prefilled issue metadata: plugin version, meeting mode,
+*  expert providers/models and budget usage — ready to paste into a
+*  GitHub issue. */
+function renderReviewMarkdown(review, meeting) {
+	const out = [];
+	out.push("# 针锋相对评审记录", "");
+	out.push("---");
+	out.push("<!-- 以下为预填的 issue 元数据，可整段作为 GitHub issue 模板 -->");
+	out.push(`- **插件**：${PLUGIN_ID}（${HARNESS_RANGE}）`);
+	out.push(`- **协作模式**：${meeting.mode}`);
+	const expertRoutes = meeting.nodes.filter((node) => node.status !== "removed").map((node) => `${node.key}（${node.provider ?? "-"}/${node.model ?? "-"}）`);
+	out.push(`- **专家**：${expertRoutes.length === 0 ? "-" : expertRoutes.join("、")}`);
+	out.push(`- **预算用量**：${meeting.budget.usedRounds}/${meeting.budget.maxRounds} 轮 · ${meeting.budget.usedTokens}/${meeting.budget.maxTokens} token`);
+	out.push(`- **真实用量（provider 上报）**：${meeting.budget.usedTokensReal ?? 0} token —— 上面的 token 数是"发言文本粗估"，不是真实账单`);
+	out.push("---", "");
+	out.push(renderReviewBody(review));
+	return out.join("\n");
+}
+/** 评审主体（不含 issue 头部）：整场会议导出复用它，避免头部重复。 */
+function renderReviewBody(review) {
+	const out = [];
+	out.push(`## 评审轮次 ${review.reviewPass}/${review.maxReviewPass} · ${review.status === "done" ? "已完成" : review.status === "ready" ? "待表态" : "收集中"}`);
+	out.push("", "## 原始问题", "", review.question, "", "## 本轮方案（待攻击对象）", "", review.plan, "");
+	const endorsed = review.viewpoints.filter((viewpoint) => viewpoint.status === "endorsed");
+	const rejected = review.viewpoints.filter((viewpoint) => viewpoint.status === "rejected");
+	const pending = review.viewpoints.filter((viewpoint) => viewpoint.status === "pending");
+	out.push(`## 本轮观点（${review.viewpoints.length} 条：已认定 ${endorsed.length} / 已驳回 ${rejected.length} / 未表态 ${pending.length}）`, "");
+	if (review.viewpoints.length === 0) out.push("（暂无观点）");
+	for (const viewpoint of review.viewpoints) {
+		out.push(`- **[${viewpointStatusLabel(viewpoint.status)}]** 观点 ${viewpoint.seq}（${viewpoint.dimension}，来自 ${viewpoint.nodeKey}）`, "", `  ${viewpoint.content}`, evidenceLine(viewpoint.evidence));
+		if (viewpoint.quote !== void 0) out.push(`\n  > 原文引用：${viewpoint.quote}`);
+		if (viewpoint.status === "rejected" && viewpoint.rejectReason !== void 0) out.push(`\n  - **驳回理由**：${viewpoint.rejectReason}`);
+		out.push("");
+	}
+	if (review.history !== void 0 && review.history.length > 0) {
+		out.push("---", "", "## 历史轮次（闭环复审对照）", "");
+		for (const pass of review.history) {
+			out.push(`### 第 ${pass.pass} 轮`, "", `- 问题：${pass.question}`, `- 方案：${pass.plan}`);
+			if (pass.revisedPlanSummary !== void 0) out.push(`- 修订说明：${pass.revisedPlanSummary}`);
+			const endorsedInPass = pass.viewpoints.filter((viewpoint) => viewpoint.status === "endorsed");
+			if (endorsedInPass.length > 0) {
+				out.push("- 该轮已认定缺陷：");
+				for (const viewpoint of endorsedInPass) out.push(`  - ${viewpoint.content}`);
+			}
+			out.push("");
+		}
+	}
+	return out.join("\n");
+}
+/** 单条发言在导出里的字符上限（超出截断并标注，避免导出物失控）。 */
+const EXPORT_UTTERANCE_CHARS = 4e3;
+/** 本地时区的可读时间戳（导出物是给人看的，不用 UTC）。 */
+function formatStamp(ts) {
+	const date = new Date(ts);
+	const pad = (value) => String(value).padStart(2, "0");
+	return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())} ${pad(date.getHours())}:${pad(date.getMinutes())}:${pad(date.getSeconds())}`;
+}
+/**
+* 把一场会议整体渲染成 Markdown 交付物（B6）。
+*
+* 只读既有磁盘状态（`meeting.json` / `transcript.jsonl` / `review.json` /
+* `user-actions.jsonl`），**不新增任何状态**；会议进行中也能导出，此时头部
+* 会标注"进行中快照"，避免把半场会议误当成结论。
+*/
+function renderMeetingMarkdown(meeting, utterances, userActions, review) {
+	const out = [];
+	const running = meeting.status !== "ended";
+	out.push(`# 圆桌会议记录 · ${meeting.name}`, "");
+	out.push("---");
+	out.push("<!-- 以下为预填的会议元数据，可整段作为 issue / 归档记录的头部 -->");
+	out.push(`- **插件**：${PLUGIN_ID}（${HARNESS_RANGE}）`);
+	out.push(`- **会议 id**：${meeting.id}`);
+	out.push(`- **协作模式**：${meeting.mode}`);
+	out.push(`- **状态**：${meeting.status}${running ? "（进行中快照）" : ""}`);
+	out.push(`- **创建时间**：${formatStamp(meeting.createdAt)}`);
+	out.push(`- **${running ? "最后更新" : "结束时间"}**：${formatStamp(meeting.updatedAt)}`);
+	out.push(`- **预算用量**：${meeting.budget.usedRounds}/${meeting.budget.maxRounds} 轮 · ${meeting.budget.usedTokens}/${meeting.budget.maxTokens} token`);
+	out.push(`- **真实用量（provider 上报）**：${meeting.budget.usedTokensReal ?? 0} token —— 上面的 token 数是"发言文本粗估"，不是真实账单`);
+	if ((meeting.kbPath ?? "") !== "") out.push(`- **知识库**：${meeting.kbPath}`);
+	if ((meeting.skills ?? []).length > 0) out.push(`- **skill**：${(meeting.skills ?? []).map((skill) => `\`${skill}\``).join("、")}（传递方式 ${meeting.skillDelivery ?? "relay"}）`);
+	out.push("---", "");
+	out.push("## 议题 / 目标", "", meeting.goal.trim() === "" ? "（未提供）" : meeting.goal.trim(), "");
+	out.push(`## 专家名单（${meeting.nodes.length}）`, "");
+	if (meeting.nodes.length === 0) out.push("（无）");
+	for (const node of meeting.nodes) {
+		const route = `${node.provider ?? "（继承主持人）"}/${node.model ?? "（继承主持人）"}`;
+		const effort = (node.reasoningEffort ?? "") === "" ? "" : ` @${node.reasoningEffort}`;
+		const role = (node.role ?? "") === "" ? "（未填角色）" : node.role;
+		out.push(`- \`${node.key}\` — ${role} — ${route}${effort} — 状态 ${node.status}`);
+	}
+	out.push("");
+	out.push(`## 决策记录（${meeting.decisions.length}）`, "");
+	if (meeting.decisions.length === 0) out.push("（无）");
+	for (const decision of meeting.decisions) {
+		out.push(`- **[${decision.status === "resolved" ? "已决" : "待决"}]** ${decision.question}`);
+		out.push(`  - 选项：${decision.options.length === 0 ? "（无）" : decision.options.join(" / ")}`);
+		if (decision.chosen !== void 0) out.push(`  - 用户选择：${decision.chosen}`);
+		if (decision.customAnswer !== void 0) out.push(`  - 自定义答案：${decision.customAnswer}`);
+		out.push(`  - 时间：${formatStamp(decision.ts)}`);
+	}
+	out.push("");
+	out.push(`## 发言记录（${utterances.length} 条）`, "");
+	if (utterances.length === 0) out.push("（无）", "");
+	else {
+		const rounds = [...new Set(utterances.map((utterance) => utterance.round))].sort((a, b) => a - b);
+		for (const round of rounds) {
+			out.push(`### 第 ${round} 轮`, "");
+			for (const utterance of utterances.filter((candidate) => candidate.round === round)) {
+				const audience = (utterance.to ?? "") === "" ? "汇聚网关" : utterance.to;
+				const kind = utterance.kind === "speech" ? "" : ` · ${utterance.kind}`;
+				out.push(`**${utterance.nodeKey} → ${audience}** · ${formatStamp(utterance.ts)}${kind}`);
+				const shown = utterance.content.length > EXPORT_UTTERANCE_CHARS ? `${utterance.content.slice(0, EXPORT_UTTERANCE_CHARS)}\n\n…（已截断，原长 ${utterance.content.length} 字符）` : utterance.content;
+				out.push("", shown, "");
+			}
+		}
+	}
+	if (review !== void 0) out.push("---", "", "# 针锋相对评审记录", "", renderReviewBody(review), "");
+	out.push("---", "", `## 用户调整记录（${userActions.length}）`, "");
+	out.push("> 只包含尚未被主持人清空的记录；已执行并清空的调整不会出现在导出里。", "");
+	if (userActions.length === 0) out.push("（无）");
+	for (const action of userActions) {
+		const key = (action.nodeKey ?? "") === "" ? "" : ` · ${action.nodeKey}`;
+		out.push(`- ${formatStamp(action.ts)} · ${action.kind}${key}：${action.text}`);
+	}
+	out.push("");
+	return out.join("\n");
+}
+
+//#endregion
+//#region src/web-guard.ts
+/** Request-body cap for the plugin RPC route (1 MiB — same order as the host's own API). */
+const MAX_RPC_BODY_BYTES = 1048576;
+/** Pick the fence out of a possibly-absent service (never load-gating). */
+function connectionFenceOf(service) {
+	if (service === null || service === void 0) return void 0;
+	const candidate = service;
+	if (typeof candidate.requestRejection !== "function") return void 0;
+	return candidate;
+}
+/**
+* Decide whether one inbound request may proceed.
+*
+* @returns the HTTP status to reject with, or `undefined` to proceed.
+*
+* A composition without the Connection service has no fence to apply and is let
+* through — the plugin must stay usable in minimal profiles. A fence that
+* *throws* is treated as a rejection: this is a security boundary, and failing
+* open would silently undo it.
+*/
+function rejectWebRequest(fence, headers) {
+	if (fence === void 0) return void 0;
+	try {
+		return fence.requestRejection({ headers });
+	} catch {
+		return 403;
+	}
+}
+
+//#endregion
+//#region src/snapshot.ts
+/** 按 key 去重节点列表：同名 key 多次加入（删了重建）时保留最新一条，
+*  且非 removed 优先。返回顺序 = meeting.nodes 首次出现顺序。 */
+function dedupeNodesByKey(nodes) {
+	const byKey = /* @__PURE__ */ new Map();
+	for (const node of nodes) {
+		const prev = byKey.get(node.key);
+		if (prev === void 0) {
+			byKey.set(node.key, node);
+			continue;
+		}
+		const prevActive = prev.status !== "removed";
+		const nodeActive = node.status !== "removed";
+		if (nodeActive !== prevActive) {
+			if (nodeActive) byKey.set(node.key, node);
+			continue;
+		}
+		if ((node.joinedAt ?? 0) >= (prev.joinedAt ?? 0)) byKey.set(node.key, node);
+	}
+	return [...byKey.values()];
+}
+/** Orchestrated meetings show an implicit star topology even before the
+* captain wires explicit edges: captain ⇄ each node, each node → aggregator.
+*
+* Real edges (the ones the user drags) are always included AND the synthetic
+* skeleton is kept as a faded backdrop for any pair not explicitly wired, so
+* dragging a new channel never makes the whole topology jump/vanish — the
+* user sees their wire land on top of a stable skeleton instead of the
+* skeleton disappearing the moment they add one edge.
+*/
+function synthesizedEdges(meeting) {
+	const removedKeys = new Set(meeting.nodes.filter((node) => node.status === "removed").map((node) => node.key));
+	const real = meeting.edges.filter((edge) => !removedKeys.has(edge.from) && !removedKeys.has(edge.to)).map((edge) => ({
+		id: edge.id,
+		from: edge.from,
+		to: edge.to,
+		direction: edge.direction
+	}));
+	if (meeting.mode === "egalitarian") return real;
+	const covered = new Set(real.flatMap((edge) => [`${edge.from}→${edge.to}`, `${edge.to}→${edge.from}`]));
+	const out = [...real];
+	for (const node of meeting.nodes) {
+		if (node.status === "removed") continue;
+		if (!covered.has(`${CAPTAIN_KEY}→${node.key}`)) out.push({
+			id: `synthetic:${CAPTAIN_KEY}:${node.key}`,
+			from: CAPTAIN_KEY,
+			to: node.key,
+			direction: "bidirectional"
+		});
+		if (!covered.has(`${node.key}→${AGGREGATOR_KEY}`)) out.push({
+			id: `synthetic:${node.key}:${AGGREGATOR_KEY}`,
+			from: node.key,
+			to: AGGREGATOR_KEY,
+			direction: "forward"
+		});
+	}
+	return out;
+}
+/** Recent directed message pulses for the flow animation (newest first). */
+function recentDirectedMessages(utterances) {
+	const out = [];
+	for (let i = utterances.length - 1; i >= 0 && out.length < 8; i--) {
+		const utterance = utterances[i];
+		if (utterance === void 0) continue;
+		if (utterance.kind !== "speech" && utterance.kind !== "proxy-thinking") continue;
+		out.push({
+			id: utterance.id,
+			from: utterance.nodeKey,
+			to: utterance.to ?? AGGREGATOR_KEY,
+			ts: utterance.ts
+		});
+	}
+	return out;
+}
+/** One-line compaction for the sidebar timeline. */
+function compactText(text, limit) {
+	const single = text.replace(/\s+/g, " ").trim();
+	return single.length > limit ? `${single.slice(0, limit)}…` : single;
+}
+/** Recent contributions for the sidebar activity log (newest first). */
+function recentUtterances(utterances) {
+	const out = [];
+	for (let i = utterances.length - 1; i >= 0 && out.length < 20; i--) {
+		const utterance = utterances[i];
+		if (utterance === void 0) continue;
+		if (utterance.kind !== "speech" && utterance.kind !== "proxy-thinking") continue;
+		out.push({
+			id: utterance.id,
+			from: utterance.nodeKey,
+			to: utterance.to ?? AGGREGATOR_KEY,
+			text: compactText(utterance.summary ?? utterance.content, 90),
+			ts: utterance.ts,
+			round: utterance.round
+		});
+	}
+	return out;
+}
+/** Collect snapshots across state roots, optionally filtered by captain session. */
+async function collectMeetingSnapshots(ctx, roots, sessionFilter) {
+	const wireAction = (action) => ({
+		id: action.id,
+		kind: action.kind,
+		nodeKey: action.nodeKey ?? "",
+		role: action.role ?? "",
+		provider: action.provider ?? "",
+		model: action.model ?? "",
+		text: action.text
+	});
+	const snapshots = [];
+	for (const root of roots) for (const meetingId of await listMeetings(root.stateRoot)) {
+		const meeting = await readMeeting(root.stateRoot, meetingId);
+		if (meeting === void 0) continue;
+		if (sessionFilter !== void 0 && meeting.captainSessionId !== sessionFilter) continue;
+		const utterances = await readTranscript(root.stateRoot, meetingId);
+		const userActions = await readUserActions(root.stateRoot, meetingId);
+		const review = await readReview(root.stateRoot, meetingId);
+		snapshots.push({
+			id: meeting.id,
+			name: meeting.name,
+			goal: meeting.goal,
+			mode: meeting.mode,
+			status: meeting.status,
+			round: meeting.round,
+			workspace: root.workspace,
+			captainSessionId: meeting.captainSessionId,
+			kbPath: meeting.kbPath ?? "",
+			skills: meeting.skills ?? [],
+			skillDelivery: meeting.skillDelivery ?? "relay",
+			budget: {
+				maxRounds: meeting.budget.maxRounds,
+				maxTokens: meeting.budget.maxTokens,
+				usedRounds: meeting.budget.usedRounds,
+				usedTokens: meeting.budget.usedTokens,
+				usedTokensReal: meeting.budget.usedTokensReal ?? 0
+			},
+			nodes: dedupeNodesByKey(meeting.nodes).map((node) => {
+				let activity = "unspawned";
+				if (node.status === "removed") activity = "removed";
+				else if (node.id !== "" && ACTIVE_NODE_STATUSES.includes(node.status)) {
+					const live = ctx.agents.get(node.id);
+					activity = live === void 0 ? "ready" : live.status;
+				}
+				return {
+					id: node.id,
+					key: node.key,
+					role: node.role ?? "",
+					provider: node.provider ?? "",
+					model: node.model ?? "",
+					status: node.status,
+					activity
+				};
+			}),
+			edges: synthesizedEdges(meeting),
+			pendingDecisions: meeting.decisions.filter((decision) => decision.status === "pending").map((decision) => ({
+				id: decision.id,
+				question: decision.question,
+				options: decision.options
+			})),
+			pendingActions: userActions.map(wireAction),
+			review: review === void 0 ? null : {
+				status: review.status,
+				reviewPass: review.reviewPass ?? 1,
+				maxReviewPass: review.maxReviewPass ?? 3,
+				question: review.question,
+				plan: review.plan,
+				viewpoints: review.viewpoints.map((viewpoint) => ({
+					id: viewpoint.id,
+					utteranceId: viewpoint.utteranceId,
+					nodeKey: viewpoint.nodeKey,
+					content: viewpoint.content,
+					status: viewpoint.status,
+					endorsed: viewpoint.status === "endorsed",
+					rejected: viewpoint.status === "rejected",
+					rejectReason: viewpoint.rejectReason,
+					evidence: viewpoint.evidence,
+					quote: viewpoint.quote,
+					dimension: viewpoint.dimension,
+					seq: viewpoint.seq
+				}))
+			},
+			digest: aggregateUtterances(utterances),
+			messages: recentDirectedMessages(utterances),
+			recent: recentUtterances(utterances)
+		});
+	}
+	return snapshots;
+}
+
+//#endregion
+//#region src/preferences.ts
+/**
+* 解析 DeepSeek Harness home。
+*
+* 与宿主 `@deepseek-ai/dsh-home-paths` 的 `resolveDshHome` 优先级对齐：
+* `configured` > `$DSH_HOME` > `~/.dsh`。只有第一级做不到 —— 它是宿主进程内部
+* 传入的显式覆盖，插件拿不到 —— 但环境变量与默认值这两级完全一致，因此在
+* 任何正常启动的宿主里都会落到同一个目录。
+*
+* 刻意**不**静态 import `@deepseek-ai/dsh-home-paths`：那会把它变成加载门禁，
+* 而本模块只是要一个路径（见 harness-compat 的铁律 #1）。
+*/
+function dshHomeDir() {
+	const fromEnv = process.env.DSH_HOME?.trim();
+	if (fromEnv !== void 0 && fromEnv !== "") return fromEnv;
+	return join(homedir(), ".dsh");
+}
+/** 偏好文件的绝对路径（DSH home 下的 `roundtable/preferences.json`）。 */
+function preferencesFilePath() {
+	return join(dshHomeDir(), "roundtable", "preferences.json");
+}
+/** 没有任何持久化数据时的偏好。`defaultMode` 由调用方按插件 Config 覆盖。 */
+function defaultPreferences(defaultMode) {
+	return {
+		defaultMode,
+		maxRounds: 10,
+		maxTokens: 2e5,
+		showAllMeetings: true,
+		expertMaxTokens: 0,
+		expertMaxOpinions: 0,
+		feedbackEnabled: true,
+		skillDelivery: "relay",
+		hiddenPanels: [],
+		legendHidden: false,
+		rolePresets: [],
+		squads: []
+	};
+}
+/** 右栏可隐藏的面板 id（客户端与服务端共用的稳定标识）。 */
+const ROUNDTABLE_PANELS = [
+	"agents",
+	"tasks",
+	"kb",
+	"skills",
+	"activity",
+	"review",
+	"files"
+];
+/** 把任意输入收敛成合法的隐藏面板清单（未知 id 丢弃，去重）。 */
+function sanitizeHiddenPanels(value) {
+	if (!Array.isArray(value)) return [];
+	const out = [];
+	for (const item of value) {
+		const id = typeof item === "string" ? item.trim() : "";
+		if (id === "" || !ROUNDTABLE_PANELS.includes(id) || out.includes(id)) continue;
+		out.push(id);
+	}
+	return out;
+}
+/** 预设条目的硬上限（客户端与服务端共用；服务端截断，客户端提前拦截）。 */
+const ROLE_PRESET_MAX = 50;
+const ROLE_PRESET_ID_MAX = 64;
+const ROLE_PRESET_NAME_MAX = 40;
+const ROLE_PRESET_ROLE_MAX = 400;
+/**
+* 把任意输入收敛成合法的角色预设清单（B3）。
+*
+* schemastery 的 `z.object` 在 resolve 阶段**不校验缺失的 required 字段**
+* （`s({ rolePresets: [{ id: 'a' }] })` 直接通过），所以条目级校验不能依赖
+* schema，必须在这里手写 —— 与 {@link sanitizeHiddenPanels} 同一套路：
+*   - `name` 与 `role` 非空是硬要求，二者缺一即丢弃该条；
+*   - `id` 为空或与前面的条目重复时**重新分配**（保数据，不静默丢条目）；
+*   - `provider`/`model` 必须成对出现，否则整体视为"继承主持人"；
+*   - 单字段超长截断，总条数超 {@link ROLE_PRESET_MAX} 截断。
+*/
+function sanitizeRolePresets(value) {
+	if (!Array.isArray(value)) return [];
+	const out = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const item of value) {
+		if (out.length >= ROLE_PRESET_MAX) break;
+		if (item === null || typeof item !== "object") continue;
+		const raw = item;
+		const name$1 = typeof raw.name === "string" ? raw.name.trim().slice(0, ROLE_PRESET_NAME_MAX) : "";
+		const role = typeof raw.role === "string" ? raw.role.trim().slice(0, ROLE_PRESET_ROLE_MAX) : "";
+		if (name$1 === "" || role === "") continue;
+		const candidate = typeof raw.id === "string" ? raw.id.trim().slice(0, ROLE_PRESET_ID_MAX) : "";
+		const id = candidate === "" || seen.has(candidate) ? randomUUID() : candidate;
+		seen.add(id);
+		const provider = typeof raw.provider === "string" ? raw.provider.trim() : "";
+		const model = typeof raw.model === "string" ? raw.model.trim() : "";
+		const routed = provider !== "" && model !== "";
+		out.push({
+			id,
+			name: name$1,
+			role,
+			...routed ? {
+				provider,
+				model
+			} : {}
+		});
+	}
+	return out;
+}
+/** 阵容预设的硬上限（客户端与服务端共用；服务端截断，客户端提前拦截）。 */
+const SQUAD_MAX = 20;
+const SQUAD_MEMBER_MAX = 8;
+const SQUAD_ID_MAX = 64;
+const SQUAD_NAME_MAX = 40;
+const SQUAD_MEMBER_ROLE_MAX = 400;
+/** 阵容成员 key 的净化规则：与客户端 `sanitizeKey` 同源
+*  （小写、保留中日韩、非法字符折成 '-'、去首尾）。 */
+function sanitizeSquadKey(value) {
+	return (typeof value === "string" ? value.trim().toLowerCase() : "").replace(/[^a-z0-9\u4e00-\u9fff]+/g, "-").replace(/^-+|-+$/g, "");
+}
+/**
+* 把任意输入收敛成合法的阵容预设清单（B3+）。
+*
+* 与 {@link sanitizeRolePresets} 同一套路（schemastery 不校验 required，
+* 条目级校验只能手写），差别只有两条：
+*   - 成员的**去重键是 key**（同一阵容里不能有两位同名专家）；
+*   - **没有任何成员的阵容被丢弃** —— 否则设置页会出现一条点了没反应的条目。
+*
+* 兼容性（这一条就是"结构变更必须自带迁移"的落地方式）：`squads` 是
+* **可选新增字段**，旧偏好对象里没有它时读到的是 `[]`，读侧归一化、
+* 只有用户真的保存时才写回，因此不需要版本号迁移，也不可能损坏已有数据。
+*/
+function sanitizeSquads(value) {
+	if (!Array.isArray(value)) return [];
+	const out = [];
+	const seenIds = /* @__PURE__ */ new Set();
+	for (const item of value) {
+		if (out.length >= SQUAD_MAX) break;
+		if (item === null || typeof item !== "object") continue;
+		const raw = item;
+		const name$1 = typeof raw.name === "string" ? raw.name.trim().slice(0, SQUAD_NAME_MAX) : "";
+		if (name$1 === "") continue;
+		const members = [];
+		const seenKeys = /* @__PURE__ */ new Set();
+		if (Array.isArray(raw.members)) for (const entry of raw.members) {
+			if (members.length >= SQUAD_MEMBER_MAX) break;
+			if (entry === null || typeof entry !== "object") continue;
+			const member = entry;
+			const key = sanitizeSquadKey(member.key);
+			if (key === "" || seenKeys.has(key)) continue;
+			seenKeys.add(key);
+			const role = typeof member.role === "string" ? member.role.trim().slice(0, SQUAD_MEMBER_ROLE_MAX) : "";
+			const provider = typeof member.provider === "string" ? member.provider.trim() : "";
+			const model = typeof member.model === "string" ? member.model.trim() : "";
+			const routed = provider !== "" && model !== "";
+			members.push({
+				key,
+				role,
+				...routed ? {
+					provider,
+					model
+				} : {}
+			});
+		}
+		if (members.length === 0) continue;
+		const candidate = typeof raw.id === "string" ? raw.id.trim().slice(0, SQUAD_ID_MAX) : "";
+		const id = candidate === "" || seenIds.has(candidate) ? randomUUID() : candidate;
+		seenIds.add(id);
+		out.push({
+			id,
+			name: name$1,
+			members
+		});
+	}
+	return out;
+}
+/** 0 = 不限制；任何有限非负整数都接受。 */
+function clampLimit(value, fallback) {
+	return typeof value === "number" && Number.isFinite(value) && value >= 0 ? Math.floor(value) : fallback;
+}
+/**
+* 把 `layer` 叠在 `base` 之上并逐字段净化。
+*
+* 语义与宿主 `SettingsScope.update(patch)` + `get()` 的组合一致：**只覆盖
+* `layer` 中出现的字段**，其余沿用 `base`。因此同一个函数同时服务于两条路径：
+*   - 读盘：`normalizePreferences(fileContent, defaults)` —— 旧文件缺新字段时补默认；
+*   - 写入：`normalizePreferences(patch, current)` —— 设置页的部分更新。
+*/
+function normalizePreferences(layer, base) {
+	const raw = layer !== null && typeof layer === "object" ? layer : {};
+	const pick = (key, fallback, accept) => {
+		if (!(key in raw)) return fallback;
+		const accepted = accept(raw[key]);
+		return accepted === void 0 ? fallback : accepted;
+	};
+	const asMode = (value) => value === "orchestrated" || value === "egalitarian" || value === "redteam" ? value : void 0;
+	const asPositiveInt = (value) => typeof value === "number" && Number.isFinite(value) && value >= 1 ? Math.floor(value) : void 0;
+	const asTokens = (value) => typeof value === "number" && Number.isFinite(value) && value >= 1e3 ? Math.floor(value) : void 0;
+	const asBoolean = (value) => typeof value === "boolean" ? value : void 0;
+	const asDelivery = (value) => value === "relay" || value === "direct" ? value : void 0;
+	return {
+		defaultMode: pick("defaultMode", base.defaultMode, asMode),
+		maxRounds: pick("maxRounds", base.maxRounds, asPositiveInt),
+		maxTokens: pick("maxTokens", base.maxTokens, asTokens),
+		showAllMeetings: pick("showAllMeetings", base.showAllMeetings, asBoolean),
+		expertMaxTokens: pick("expertMaxTokens", base.expertMaxTokens, (value) => clampLimit(value, base.expertMaxTokens)),
+		expertMaxOpinions: pick("expertMaxOpinions", base.expertMaxOpinions, (value) => clampLimit(value, base.expertMaxOpinions)),
+		feedbackEnabled: pick("feedbackEnabled", base.feedbackEnabled, asBoolean),
+		skillDelivery: pick("skillDelivery", base.skillDelivery, asDelivery),
+		hiddenPanels: pick("hiddenPanels", base.hiddenPanels, sanitizeHiddenPanels),
+		legendHidden: pick("legendHidden", base.legendHidden, asBoolean),
+		rolePresets: pick("rolePresets", base.rolePresets, sanitizeRolePresets),
+		squads: pick("squads", base.squads, sanitizeSquads)
+	};
+}
+/**
+* 创建偏好存储。
+*
+* 读盘是**惰性且异步**的（构造后立刻开始），因此 `get()` 在首次读盘完成前
+* 返回基准值而不是阻塞宿主启动 —— 这与宿主设置服务的可用性无关，也是它比
+* `ctx.inject(['settings'])` 更稳的地方：没有可选能力可缺。
+*/
+function createPreferenceStore(options) {
+	const file = options.file ?? preferencesFilePath();
+	let current = options.base;
+	let writeQueue = Promise.resolve();
+	const listeners = /* @__PURE__ */ new Set();
+	const load = (async () => {
+		try {
+			const text = await readFile(file, "utf8");
+			current = normalizePreferences(JSON.parse(text), options.base);
+		} catch (error) {
+			if (error.code !== "ENOENT") options.log?.(`roundtable: preferences at ${file} unreadable; using defaults`, error);
+		}
+	})();
+	const publish = (next) => {
+		current = next;
+		for (const listener of listeners) try {
+			listener(next);
+		} catch (error) {
+			options.log?.("roundtable: a preference listener threw", error);
+		}
+	};
+	return {
+		get: () => current,
+		ready: () => load.then(() => void 0),
+		watch(listener) {
+			listeners.add(listener);
+			return () => {
+				listeners.delete(listener);
+			};
+		},
+		async update(patch) {
+			await load;
+			const next = normalizePreferences(patch, current);
+			publish(next);
+			writeQueue = writeQueue.then(async () => {
+				try {
+					await mkdir(dirname(file), { recursive: true });
+					await writeTextAtomic(file, JSON.stringify(next, null, 2));
+				} catch (error) {
+					options.log?.(`roundtable: failed to persist preferences to ${file}`, error);
+				}
+			});
+			await writeQueue;
+			return next;
+		}
+	};
+}
+
+//#endregion
+//#region src/rpc.ts
+/**
+* Browser-facing POST route for this plugin's RPC.
+*
+* It mirrors the snapshot route's transport (the plugin's own `webServer`
+* registration) instead of relying on the host's generic connection channel,
+* which is what the client actually reaches.
+*/
+const RPC_ROUTE = "/plugins/dsh-plugin-roundtable/rpc";
+function ok(value) {
+	return {
+		ok: true,
+		value
+	};
+}
+function fail(message) {
+	return {
+		ok: false,
+		error: {
+			code: "internal",
+			message
+		}
+	};
+}
+/** Run one meeting mutation under the meeting lock, resolving its state root first. */
+async function withMeetingRpcLock(runtime, meetingId, operation, options = {}) {
+	const { workspaceOfMeeting } = await import("./edge-helper-iqXOG5o_.js");
+	const workspace = await workspaceOfMeeting(runtime.stateDir, meetingId);
+	if (workspace === void 0) return fail(`meeting "${meetingId}" not found in any workspace`);
+	const stateRoot = stateRootOf(workspace, runtime.stateDir);
+	return withMeetingLock(`meeting:${stateRoot}:${meetingId}`, async () => {
+		if (options.requireActive === true) {
+			const meeting = await readMeeting(stateRoot, meetingId);
+			if (meeting !== void 0 && (meeting.status === "ended" || meeting.status === "archived")) return fail(`meeting "${meetingId}" has ended — its topology is read-only`);
+		}
+		return operation(stateRoot);
+	});
+}
+/** 观点三态写入（V0.2.2）。幂等；状态变化时写结构化 user-action（V2 回写负载）。
+*  驳回必须附理由（C2），由 setViewpointStatus 强制非空。
+*  P1 务实降级：connection 通道不暴露调用者 session 身份（handler 仅
+*  endpoint/payload/signal），无法做 captainSessionId 校验——以「会议归属
+*  校验（withMeetingRpcLock）+ 状态机校验（reviewing 阶段拒绝）」作为防线。 */
+async function applyViewpointStatus(runtime, meetingId, viewpointId, status, rejectReason) {
+	return withMeetingRpcLock(runtime, meetingId, async (stateRoot) => {
+		const review = await readReview(stateRoot, meetingId);
+		if (review === void 0) return fail(`no review in progress for meeting "${meetingId}"`);
+		const viewpoint = review.viewpoints.find((candidate) => candidate.id === viewpointId);
+		if (viewpoint === void 0) return fail(`viewpoint "${viewpointId}" not found`);
+		if (review.status === "reviewing") return fail("review is still collecting viewpoints — call roundtable_collect_review before endorsing or rejecting");
+		if (review.status === "done") return fail("this review pass is finished — start a new pass (roundtable_start_review) to re-review");
+		let changed;
+		try {
+			changed = await setViewpointStatus(stateRoot, meetingId, viewpointId, status, rejectReason);
+		} catch (error) {
+			return fail(error.message);
+		}
+		if (changed && status !== "pending") {
+			const label = status === "endorsed" ? "用户认定缺陷" : "用户驳回观点";
+			const reasonText = status === "rejected" && rejectReason !== void 0 && rejectReason.trim() !== "" ? `；理由：${rejectReason.trim().replace(/\s+/g, " ").slice(0, 120)}` : "";
+			await appendUserAction(stateRoot, meetingId, {
+				id: randomUUID(),
+				ts: Date.now(),
+				kind: "other",
+				nodeKey: viewpoint.nodeKey,
+				text: `${label}（针锋相对评审 ${viewpoint.id}）${reasonText}：${viewpoint.content.replace(/\s+/g, " ").slice(0, 60)}`
+			});
+		}
+		return ok({
+			changed,
+			status
+		});
+	});
+}
+/**
+* Register the RoundTable RPC handler.
+*
+* Two transports share ONE dispatch body, so the browser can reach the plugin
+* even when the host's generic `connection` channel is not mounted (or its
+* `/roundtable` prefix got dropped by a live plugin reload):
+*   1. the host `connection` RPC channel `/roundtable` (kept for compatibility);
+*   2. the plugin's own `webServer` POST route `<RPC_ROUTE>` — the same
+*      transport as the `/plugins/dsh-plugin-roundtable/state` snapshot route,
+*      which is what the browser actually uses.
+*
+* @returns the dispatch function, so the caller can mount it on a web route.
+*/
+function registerRpc(ctx, runtime) {
+	const dispatch = async (endpoint, payload) => {
+		try {
+			switch (endpoint) {
+				case "roundtable/prefs.get": {
+					const prefs = runtime.prefs.get();
+					return ok({
+						defaultMode: prefs.defaultMode,
+						maxRounds: prefs.maxRounds,
+						maxTokens: prefs.maxTokens,
+						showAllMeetings: prefs.showAllMeetings,
+						expertMaxTokens: prefs.expertMaxTokens ?? 0,
+						expertMaxOpinions: prefs.expertMaxOpinions ?? 0,
+						feedbackEnabled: prefs.feedbackEnabled ?? true,
+						skillDelivery: prefs.skillDelivery === "direct" ? "direct" : "relay",
+						hiddenPanels: sanitizeHiddenPanels(prefs.hiddenPanels),
+						legendHidden: prefs.legendHidden === true,
+						rolePresets: sanitizeRolePresets(prefs.rolePresets),
+						squads: sanitizeSquads(prefs.squads)
+					});
+				}
+				case "roundtable/prefs.set": {
+					const patch = payload;
+					if (patch === void 0 || typeof patch !== "object" || patch === null) return fail("payload must be a preferences patch object");
+					const sanitized = { ...patch };
+					if (patch.hiddenPanels !== void 0) sanitized.hiddenPanels = sanitizeHiddenPanels(patch.hiddenPanels);
+					if (patch.legendHidden !== void 0) sanitized.legendHidden = patch.legendHidden === true;
+					if (patch.rolePresets !== void 0) sanitized.rolePresets = sanitizeRolePresets(patch.rolePresets);
+					if (patch.squads !== void 0) sanitized.squads = sanitizeSquads(patch.squads);
+					const next = await runtime.prefs.update(sanitized);
+					return ok({
+						defaultMode: next.defaultMode,
+						maxRounds: next.maxRounds,
+						maxTokens: next.maxTokens,
+						showAllMeetings: next.showAllMeetings,
+						expertMaxTokens: next.expertMaxTokens ?? 0,
+						expertMaxOpinions: next.expertMaxOpinions ?? 0,
+						feedbackEnabled: next.feedbackEnabled ?? true,
+						skillDelivery: next.skillDelivery === "direct" ? "direct" : "relay",
+						hiddenPanels: sanitizeHiddenPanels(next.hiddenPanels),
+						legendHidden: next.legendHidden === true,
+						rolePresets: sanitizeRolePresets(next.rolePresets),
+						squads: sanitizeSquads(next.squads)
+					});
+				}
+				case "roundtable/edge.set": {
+					const body = payload;
+					const meetingId = typeof body?.meetingId === "string" ? body.meetingId : "";
+					const edgeId = typeof body?.edgeId === "string" ? body.edgeId : "";
+					if (meetingId === "" || edgeId === "") return fail("payload must be { meetingId, edgeId, direction }");
+					const directionRaw = typeof body?.direction === "string" ? body.direction : "";
+					if (directionRaw !== "forward" && directionRaw !== "bidirectional") return fail("direction must be \"forward\" or \"bidirectional\"");
+					const direction = directionRaw;
+					return withMeetingRpcLock(runtime, meetingId, async (stateRoot) => {
+						const meeting = await readMeeting(stateRoot, meetingId);
+						if (meeting === void 0) return fail(`meeting "${meetingId}" not found`);
+						const edge = meeting.edges.find((candidate) => candidate.id === edgeId);
+						if (edge === void 0) return fail(`edge "${edgeId}" not found`);
+						edge.direction = direction;
+						meeting.charter = buildCharter(meeting);
+						await writeMeeting(stateRoot, meeting);
+						return ok({ direction: edge.direction });
+					}, { requireActive: true });
+				}
+				case "roundtable/edge.add": {
+					const body = payload;
+					const meetingId = typeof body?.meetingId === "string" ? body.meetingId : "";
+					const from = typeof body?.from === "string" ? body.from.trim() : "";
+					const to = typeof body?.to === "string" ? body.to.trim() : "";
+					if (meetingId === "" || from === "" || to === "") return fail("payload must be { meetingId, from, to, direction }");
+					const direction = body?.direction === "bidirectional" ? "bidirectional" : "forward";
+					return withMeetingRpcLock(runtime, meetingId, async (stateRoot) => {
+						const meeting = await readMeeting(stateRoot, meetingId);
+						if (meeting === void 0) return fail(`meeting "${meetingId}" not found`);
+						const valid = (key) => key === "captain" || key === "aggregator" || meeting.nodes.some((node) => node.key === key && node.status !== "removed");
+						if (!valid(from)) return fail(`unknown endpoint "${from}"`);
+						if (!valid(to)) return fail(`unknown endpoint "${to}"`);
+						if (from === to) return fail("an edge cannot connect a participant to itself");
+						if (meeting.edges.some((edge$1) => edge$1.from === from && edge$1.to === to)) return fail(`channel ${from} → ${to} already exists`);
+						const edge = {
+							id: randomUUID(),
+							from,
+							to,
+							direction,
+							createdAt: Date.now()
+						};
+						meeting.edges.push(edge);
+						meeting.charter = buildCharter(meeting);
+						await writeMeeting(stateRoot, meeting);
+						return ok({
+							edgeId: edge.id,
+							from: edge.from,
+							to: edge.to,
+							direction: edge.direction
+						});
+					}, { requireActive: true });
+				}
+				case "roundtable/edge.remove": {
+					const body = payload;
+					const meetingId = typeof body?.meetingId === "string" ? body.meetingId : "";
+					const edgeId = typeof body?.edgeId === "string" ? body.edgeId : "";
+					if (meetingId === "" || edgeId === "") return fail("payload must be { meetingId, edgeId }");
+					return withMeetingRpcLock(runtime, meetingId, async (stateRoot) => {
+						const meeting = await readMeeting(stateRoot, meetingId);
+						if (meeting === void 0) return fail(`meeting "${meetingId}" not found`);
+						const before = meeting.edges.length;
+						meeting.edges = meeting.edges.filter((edge) => edge.id !== edgeId);
+						meeting.charter = buildCharter(meeting);
+						await writeMeeting(stateRoot, meeting);
+						return ok({ removed: before !== meeting.edges.length });
+					}, { requireActive: true });
+				}
+				case "roundtable/meeting.delete": {
+					const body = payload;
+					const meetingId = typeof body?.meetingId === "string" ? body.meetingId : "";
+					if (meetingId === "") return fail("payload must be { meetingId }");
+					return withMeetingRpcLock(runtime, meetingId, async (stateRoot) => {
+						const meeting = await readMeeting(stateRoot, meetingId);
+						if (meeting === void 0) return ok({ deleted: false });
+						for (const node of meeting.nodes) {
+							if (node.id === "") continue;
+							if (interruptNodeByParent(ctx, node.id, meeting.captainSessionId)) continue;
+							const agents = ctx.agents;
+							try {
+								agents?.interrupt?.(node.id);
+							} catch {}
+						}
+						await rm(meetingDirOf(stateRoot, meetingId), {
+							recursive: true,
+							force: true
+						});
+						return ok({ deleted: true });
+					});
+				}
+				case "roundtable/user-actions.append": {
+					const body = payload;
+					const meetingId = typeof body?.meetingId === "string" ? body.meetingId : "";
+					const kindRaw = typeof body?.kind === "string" ? body.kind : "";
+					if (meetingId === "" || kindRaw !== "add-node" && kindRaw !== "remove-node" && kindRaw !== "kb-path" && kindRaw !== "other") return fail("payload must be { meetingId, kind, text } with kind in add-node|remove-node|kb-path|other");
+					const text = typeof body?.text === "string" ? body.text.trim() : "";
+					if (text === "") return fail("payload must include a non-empty text sentence");
+					return withMeetingRpcLock(runtime, meetingId, async (stateRoot) => {
+						const action = {
+							id: randomUUID(),
+							ts: Date.now(),
+							kind: kindRaw,
+							nodeKey: typeof body?.nodeKey === "string" && body.nodeKey.trim() !== "" ? body.nodeKey.trim() : void 0,
+							role: typeof body?.role === "string" && body.role.trim() !== "" ? body.role.trim() : void 0,
+							provider: typeof body?.provider === "string" && body.provider.trim() !== "" ? body.provider.trim() : void 0,
+							model: typeof body?.model === "string" && body.model.trim() !== "" ? body.model.trim() : void 0,
+							text
+						};
+						await appendUserAction(stateRoot, meetingId, action);
+						return ok({ id: action.id });
+					}, { requireActive: true });
+				}
+				case "roundtable/user-actions.list": {
+					const body = payload;
+					const meetingId = typeof body?.meetingId === "string" ? body.meetingId : "";
+					if (meetingId === "") return fail("payload must be { meetingId }");
+					return withMeetingRpcLock(runtime, meetingId, async (stateRoot) => {
+						return ok(await readUserActions(stateRoot, meetingId));
+					});
+				}
+				case "roundtable/models.list": {
+					const llm = ctx.get("llm");
+					if (llm === void 0) return ok({ providers: [] });
+					const providers = [];
+					for (const provider of llm.listProviders()) {
+						let models = [];
+						try {
+							models = await llm.listModels(provider.id);
+						} catch {
+							models = [];
+						}
+						providers.push({
+							id: provider.id,
+							name: provider.name,
+							models: models.map((model) => ({
+								id: model.id,
+								name: model.name
+							}))
+						});
+					}
+					return ok({ providers });
+				}
+				case "roundtable/kb.path.set": {
+					const body = payload;
+					const meetingId = typeof body?.meetingId === "string" ? body.meetingId : "";
+					const raw = typeof body?.path === "string" ? body.path.trim() : "";
+					if (meetingId === "" || raw === "") return fail("payload must be { meetingId, path }");
+					return withMeetingRpcLock(runtime, meetingId, async (stateRoot) => {
+						const meeting = await readMeeting(stateRoot, meetingId);
+						if (meeting === void 0) return fail(`meeting "${meetingId}" not found`);
+						const workspace = dirname(stateRoot);
+						const resolved = isAbsolute(raw) ? raw : join(workspace, raw);
+						let info;
+						try {
+							info = await stat(resolved);
+						} catch {
+							return fail(`path not found or unreadable: ${resolved}`);
+						}
+						if (!info.isDirectory()) return fail(`path is not a directory: ${resolved}`);
+						meeting.kbPath = resolved;
+						await writeMeeting(stateRoot, meeting);
+						return ok({ path: resolved });
+					}, { requireActive: true });
+				}
+				case "roundtable/kb.list": {
+					const body = payload;
+					const meetingId = typeof body?.meetingId === "string" ? body.meetingId : "";
+					if (meetingId === "") return fail("payload must be { meetingId }");
+					return withMeetingRpcLock(runtime, meetingId, async (stateRoot) => {
+						const meeting = await readMeeting(stateRoot, meetingId);
+						if (meeting === void 0) return fail(`meeting "${meetingId}" not found`);
+						const configured = meeting.kbPath ?? "";
+						if (configured === "") return ok({
+							path: "",
+							configured: false,
+							error: "",
+							files: []
+						});
+						const listing = await listKbDirectory(configured);
+						return ok({
+							path: configured,
+							configured: true,
+							error: listing.error,
+							files: listing.files
+						});
+					});
+				}
+				case "roundtable/review.get": {
+					const body = payload;
+					const meetingId = typeof body?.meetingId === "string" ? body.meetingId : "";
+					if (meetingId === "") return fail("payload must be { meetingId }");
+					return withMeetingRpcLock(runtime, meetingId, async (stateRoot) => {
+						return ok({ review: await readReview(stateRoot, meetingId) ?? null });
+					});
+				}
+				case "roundtable/review.endorse": {
+					const body = payload;
+					const meetingId = typeof body?.meetingId === "string" ? body.meetingId : "";
+					const viewpointId = typeof body?.viewpointId === "string" ? body.viewpointId : "";
+					if (meetingId === "" || viewpointId === "") return fail("payload must be { meetingId, viewpointId }");
+					return applyViewpointStatus(runtime, meetingId, viewpointId, "endorsed");
+				}
+				case "roundtable/review.setStatus": {
+					const body = payload;
+					const meetingId = typeof body?.meetingId === "string" ? body.meetingId : "";
+					const viewpointId = typeof body?.viewpointId === "string" ? body.viewpointId : "";
+					const status = body?.status;
+					if (meetingId === "" || viewpointId === "") return fail("payload must be { meetingId, viewpointId, status }");
+					if (status !== "pending" && status !== "endorsed" && status !== "rejected") return fail("status must be \"pending\" | \"endorsed\" | \"rejected\"");
+					const rejectReason = typeof body?.reject_reason === "string" ? body.reject_reason : void 0;
+					if (status === "rejected" && (rejectReason === void 0 || rejectReason.trim() === "")) return fail("rejecting a viewpoint requires a non-empty reject_reason (驳回必填理由)");
+					return applyViewpointStatus(runtime, meetingId, viewpointId, status, rejectReason);
+				}
+				case "roundtable/feedback.append": {
+					const body = payload;
+					const meetingId = typeof body?.meetingId === "string" ? body.meetingId : "";
+					const mode = typeof body?.mode === "string" ? body.mode : "";
+					if (meetingId === "" || mode === "") return fail("payload must be { meetingId, mode, rating, ... }");
+					const ratingRaw = typeof body?.rating === "string" ? body.rating : "";
+					if (ratingRaw !== "good" && ratingRaw !== "meh" && ratingRaw !== "bad") return fail("rating must be \"good\" | \"meh\" | \"bad\"");
+					const asStringList = (value) => Array.isArray(value) ? value.filter((item) => typeof item === "string").slice(0, 20) : [];
+					const note = typeof body?.note === "string" ? body.note.trim().slice(0, 1e3) : "";
+					const entry = {
+						id: randomUUID(),
+						ts: Date.now(),
+						meetingId,
+						mode,
+						providers: asStringList(body?.providers),
+						models: asStringList(body?.models),
+						usedRounds: typeof body?.usedRounds === "number" ? Math.max(0, Math.floor(body.usedRounds)) : 0,
+						usedTokens: typeof body?.usedTokens === "number" ? Math.max(0, Math.floor(body.usedTokens)) : 0,
+						rating: ratingRaw,
+						note: note === "" ? void 0 : note
+					};
+					return withMeetingRpcLock(runtime, meetingId, async (stateRoot) => {
+						await clearFeedbackForMeeting(stateRoot, meetingId);
+						await appendFeedback(stateRoot, entry);
+						return ok({ id: entry.id });
+					});
+				}
+				case "roundtable/feedback.list": {
+					const body = payload;
+					const roots = await feedbackStateRoots(runtime, typeof body?.workspace === "string" ? body.workspace : "");
+					const entries = [];
+					for (const stateRoot of roots) entries.push(...await readFeedback(stateRoot));
+					entries.sort((a, b) => b.ts - a.ts);
+					return ok({ entries: entries.slice(0, 200) });
+				}
+				case "roundtable/feedback.clear": {
+					const body = payload;
+					const roots = await feedbackStateRoots(runtime, typeof body?.workspace === "string" ? body.workspace : "");
+					let cleared = 0;
+					for (const stateRoot of roots) cleared += await clearFeedback(stateRoot);
+					return ok({ cleared });
+				}
+				default: return fail(`unknown endpoint: ${endpoint}`);
+			}
+		} catch (error) {
+			return fail(error instanceof Error ? error.message : String(error));
+		}
+	};
+	ctx.inject(["connection"], (connectionCtx) => {
+		effectWithOptionalDisposer(connectionCtx, connectionCtx.connection.rpc.handle("/roundtable", dispatch), "roundtable: rpc channel");
+	});
+	return dispatch;
+}
+/**
+* Resolve the state roots whose feedback.jsonl should be read/cleared:
+* every known workspace candidate (optionally narrowed to one named
+* workspace). A candidate whose state root directory does not exist yet
+* contributes nothing.
+*/
+async function feedbackStateRoots(runtime, workspaceName) {
+	const { workspaceCandidates: workspaceCandidates$1 } = await import("./workspace-candidates-B7isleLt.js");
+	const { stat: stat$1 } = await import("node:fs/promises");
+	const candidates = workspaceCandidates$1().filter((candidate) => workspaceName === void 0 || candidate.title === workspaceName);
+	const roots = [];
+	for (const candidate of candidates) {
+		const root = stateRootOf(candidate.path, runtime.stateDir);
+		try {
+			if ((await stat$1(root)).isDirectory()) roots.push(root);
+		} catch {}
+	}
+	return roots;
+}
+/**
+* List the first level of a knowledge-base directory (browse-only): skips
+* dot-hidden entries, caps the result at 300 items so a huge folder cannot
+* blow up the UI, and tolerates per-entry stat failures.
+*/
+async function listKbDirectory(dir) {
+	let info;
+	try {
+		info = await stat(dir);
+	} catch {
+		return {
+			error: "path not found or unreadable",
+			files: []
+		};
+	}
+	if (!info.isDirectory()) return {
+		error: "not a directory",
+		files: []
+	};
+	let entries;
+	try {
+		entries = await readdir(dir, { withFileTypes: true });
+	} catch {
+		return {
+			error: "directory unreadable",
+			files: []
+		};
+	}
+	const files = [];
+	for (const entry of entries) {
+		if (entry.name.startsWith(".")) continue;
+		const full = join(dir, entry.name);
+		let size = 0;
+		let mtimeMs = 0;
+		try {
+			const entryStat = await stat(full);
+			size = entryStat.size;
+			mtimeMs = entryStat.mtimeMs;
+		} catch {}
+		files.push({
+			name: entry.name,
+			kind: entry.isDirectory() ? "dir" : "file",
+			ext: entry.isDirectory() ? "" : extname(entry.name).replace(/^\./, "").toLowerCase(),
+			size,
+			mtimeMs
+		});
+		if (files.length >= 300) break;
+	}
+	return {
+		error: "",
+		files
+	};
+}
+
+//#endregion
+//#region src/index.ts
+const name = "roundtable";
+/**
+* REQUIRED services only — and the list is load-gating, which is why it is
+* short. cordis has no "optional inject" form (`Inject` is `string[] | Record`
+* and the record form is only intercept config), so every name listed here
+* keeps the whole plugin fiber PENDING until that service exists: no
+* `roundtable_*` tools, no `/plugins/dsh-plugin-roundtable/*` routes and no GUI
+* tab. A missing OPTIONAL capability listed here therefore presents to the user
+* as "圆桌会议整个不见了 / 无法调用界面" with no error anywhere.
+*
+* `userQuestions` and `skills` are deliberately NOT listed: both are optional
+* capabilities that the plugin reads live through `ctx.get(...)`:
+*   - skills.ts hard constraint #1 — the plugin MUST load in a profile without
+*     the skill service and degrade to an empty catalog;
+*   - tools.ts falls back to `decision: 'unavailable'` when the userQuestions
+*     service is absent (the captain then states the draft in words).
+* v0.2.36 removed both from this list; v0.2.21 had already fixed the mirrored
+* over-constraint on the browser half (`connection`).
+*/
+const inject = [
+	"tools",
+	"subagents",
+	"agents",
+	"systemPrompt"
+];
+const Config = z.object({
+	stateDir: z.string().default(".roundtable"),
+	memberProvider: z.string().default("spawn"),
+	maxNodes: z.natural().min(1).default(8),
+	defaultMode: z.union([
+		"orchestrated",
+		"egalitarian",
+		"redteam"
+	]).default("orchestrated"),
+	memberMaxDepth: z.natural().default(1),
+	promptSectionOrder: z.natural().default(116)
+});
+function apply(ctx, config) {
+	const resolved = {
+		stateDir: config.stateDir ?? ".roundtable",
+		memberProvider: config.memberProvider ?? "spawn",
+		maxNodes: config.maxNodes ?? 8,
+		defaultMode: config.defaultMode ?? "orchestrated",
+		memberMaxDepth: config.memberMaxDepth ?? 1
+	};
+	ctx.systemPrompt.section({
+		name: "roundtable:usage",
+		order: config.promptSectionOrder ?? 116,
+		text: usageSectionText()
+	});
+	const runtime = {
+		prefs: createPreferenceStore({
+			base: defaultPreferences(resolved.defaultMode),
+			log: (message, error) => {
+				if (error === void 0) ctx.logger.warn(message);
+				else ctx.logger.warn(message, error);
+			}
+		}),
+		stateDir: resolved.stateDir
+	};
+	const applyDefaultMode = (preference) => {
+		if (preference.defaultMode === "orchestrated" || preference.defaultMode === "egalitarian" || preference.defaultMode === "redteam") resolved.defaultMode = preference.defaultMode;
+	};
+	runtime.prefs.watch(applyDefaultMode);
+	runtime.prefs.ready().then(() => {
+		applyDefaultMode(runtime.prefs.get());
+	}).catch(() => {});
+	registerRoundTableTools(ctx, {
+		stateDir: resolved.stateDir,
+		memberProvider: resolved.memberProvider,
+		maxNodes: resolved.maxNodes,
+		defaultMode: resolved.defaultMode,
+		memberMaxDepth: resolved.memberMaxDepth,
+		reviewSplit: {
+			provider: "deepseek-official",
+			model: "deepseek-v4-flash",
+			maxOpinions: 3
+		},
+		getExpertLimits: () => {
+			const prefs = runtime.prefs.get();
+			return {
+				maxTokens: prefs.expertMaxTokens ?? 0,
+				maxOpinions: prefs.expertMaxOpinions ?? 0
+			};
+		},
+		getSkillDelivery: () => runtime.prefs.get().skillDelivery ?? "relay",
+		getPlannedDefaults: () => {
+			const prefs = runtime.prefs.get();
+			return {
+				mode: prefs.defaultMode,
+				maxRounds: prefs.maxRounds,
+				maxTokens: prefs.maxTokens,
+				skillDelivery: prefs.skillDelivery ?? "relay"
+			};
+		}
+	});
+	attachNodeEvents(ctx);
+	const dispatchRpc = registerRpc(ctx, runtime);
+	let webRegistered = false;
+	let rpcRouteRegistered = false;
+	const registerWebSurface = () => {
+		const webServer = webRouteHostOf(ctx);
+		if (webServer === void 0) return;
+		const fence = connectionFenceOf(ctx.get("connection"));
+		if (!rpcRouteRegistered) {
+			rpcRouteRegistered = true;
+			ctx.effect(() => webServer.register({
+				kind: "exact",
+				path: RPC_ROUTE,
+				handler: async (req, res) => {
+					const send = (status, body$1) => {
+						res.writeHead(status, {
+							"content-type": "application/json; charset=utf-8",
+							"cache-control": "no-store"
+						});
+						res.end(JSON.stringify(body$1));
+					};
+					const rejection = rejectWebRequest(fence, req.headers);
+					if (rejection !== void 0) {
+						send(rejection, {
+							ok: false,
+							error: {
+								code: "forbidden",
+								message: "connection trust check failed"
+							}
+						});
+						return;
+					}
+					if ((req.method ?? "GET").toUpperCase() !== "POST") {
+						send(405, {
+							ok: false,
+							error: {
+								code: "internal",
+								message: "this route accepts POST only"
+							}
+						});
+						return;
+					}
+					let body;
+					try {
+						const chunks = [];
+						let size = 0;
+						for await (const chunk of req) {
+							size += chunk.length;
+							if (size > MAX_RPC_BODY_BYTES) {
+								send(413, {
+									ok: false,
+									error: {
+										code: "internal",
+										message: "request body too large"
+									}
+								});
+								return;
+							}
+							chunks.push(chunk);
+						}
+						body = JSON.parse(Buffer.concat(chunks).toString("utf8"));
+					} catch {
+						send(400, {
+							ok: false,
+							error: {
+								code: "internal",
+								message: "body must be JSON"
+							}
+						});
+						return;
+					}
+					const message = body;
+					if (message === null || typeof message !== "object" || typeof message.endpoint !== "string") {
+						send(400, {
+							ok: false,
+							error: {
+								code: "internal",
+								message: "body must be { endpoint, payload? }"
+							}
+						});
+						return;
+					}
+					send(200, await dispatchRpc(message.endpoint, message.payload));
+				}
+			}), "roundtable: rpc route");
+		}
+		if (webRegistered) return;
+		const workspaceRegistry = workspaceRegistryOf(ctx);
+		if (workspaceRegistry === void 0) return;
+		webRegistered = true;
+		const refreshCandidates = () => {
+			setWorkspaceCandidates(workspaceRegistry.list().map((workspace) => ({
+				title: workspace.title,
+				path: workspace.path
+			})));
+		};
+		refreshCandidates();
+		ctx.effect(() => webServer.register({
+			kind: "exact",
+			path: "/plugins/dsh-plugin-roundtable/state",
+			handler: async (req, res) => {
+				const rejection = rejectWebRequest(fence, req.headers);
+				if (rejection !== void 0) {
+					res.writeHead(rejection, {
+						"content-type": "application/json; charset=utf-8",
+						"cache-control": "no-store"
+					});
+					res.end(JSON.stringify({ meetings: [] }));
+					return;
+				}
+				const url = new URL(req.url ?? "/", "http://x");
+				const snapshots = await collectMeetingSnapshots(ctx, workspaceCandidates().map((workspace) => ({
+					workspace: workspace.title,
+					stateRoot: join(workspace.path, resolved.stateDir)
+				})), url.searchParams.get("session") ?? void 0);
+				res.writeHead(200, {
+					"content-type": "application/json; charset=utf-8",
+					"cache-control": "no-store"
+				});
+				res.end(JSON.stringify({ meetings: snapshots }));
+			}
+		}), "roundtable: snapshot route");
+	};
+	registerWebSurface();
+	ctx.on("internal/service", (serviceName) => {
+		if (WEB_SERVER_KEYS.includes(serviceName) || WORKSPACE_KEYS.includes(serviceName)) registerWebSurface();
+	});
+}
+
+//#endregion
+export { Config, apply, inject, name };