dsh-advisor-group 0.0.1

package/lib/index.mjs

@@ -0,0 +1,3871 @@
+import Schema from "@deepseek-ai/schemastery";
+import { randomUUID } from "node:crypto";
+import { mkdirSync, promises, readFileSync, readdirSync, rmSync, statSync, unlinkSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, isAbsolute, join } from "node:path";
+import { KNOWN_SESSION_EVENT_TYPES, Session } from "@deepseek-ai/dsh-session";
+import { createUserMessage } from "@deepseek-ai/dsh-llm";
+import { defineTool } from "@deepseek-ai/dsh-tools";
+import { SettingsConflictError } from "@deepseek-ai/dsh-settings";
+//#region src/defaults.ts
+const DEFAULT_ADVISOR_PROMPT = `
+你是顾问群中的资深专家。你的任务不是替用户执行，而是提供高质量的专业意见供主模型参考。
+
+回答要求：
+1. 先给出明确结论，再说明理由、依据或经验；
+2. 内容要具体、可执行，避免空话套话；
+3. 明确区分事实、推测和建议；
+4. 如果信息不足，明确说明缺少什么、需要什么信息，不要强行编造；
+5. 涉及专业风险时，主动提示风险点和适用边界；
+6. 在讨论轮次中：
+   - 第 1 轮：独立给出你的专业意见；
+   - 后续轮次：参考其他顾问的观点，明确表示同意/补充/反对，不要简单重复；
+7. 尽量用分点/结构化输出，方便主模型综合。
+
+结尾按约定标注置信度或不确定性。
+`.trim();
+//#endregion
+//#region src/config.ts
+const ProviderProtocol = Schema.union([
+	Schema.const("openai"),
+	Schema.const("anthropic"),
+	Schema.const("gemini")
+]);
+const ProviderAuthMode = Schema.union([Schema.const("x-api-key"), Schema.const("bearer")]);
+const AdvisorConfig = Schema.object({
+	id: Schema.string().required().description("Unique advisor id used by ask_advisors."),
+	name: Schema.string().required().description("Display name shown in the chat group."),
+	avatar: Schema.string().description("Short emoji or ASCII avatar."),
+	provider: Schema.string().required().description("Provider route passed to ctx.llm, e.g. deepseek-official or openai."),
+	model: Schema.string().required().description("Model id on that provider route."),
+	systemPrompt: Schema.string().default(DEFAULT_ADVISOR_PROMPT),
+	temperature: Schema.number().min(0).max(2),
+	maxTokens: Schema.number().min(1),
+	baseURL: Schema.string().description("Optional direct-http fallback base URL."),
+	apiKey: Schema.string().role("secret").description("Direct API key used for direct-http fallback. Stored in local config; prefer apiKeyEnv if you do not want the key in settings.yaml."),
+	apiKeysByProvider: Schema.dict(Schema.string()).role("secret").default({}).description("Server-side per-provider key history; never returned to the browser. Marked secret so the official settings redaction (describe) never sends it over any wire."),
+	clearApiKey: Schema.boolean().description("Transient client intent: clear the current provider direct key. Stripped before persistence."),
+	apiKeyEnv: Schema.string().description("Optional env var name for direct-http fallback."),
+	protocol: ProviderProtocol,
+	authMode: ProviderAuthMode.description("Anthropic auth header style: x-api-key or bearer."),
+	thinking: Schema.union([Schema.const("enabled"), Schema.const("disabled")]).description("Per-advisor thinking mode; unset = provider default. disabled forces no thinking block (DSH built-in channel maps it to reasoningEffort off)."),
+	reasoningEffort: Schema.union([
+		Schema.const("off"),
+		Schema.const("low"),
+		Schema.const("high"),
+		Schema.const("max")
+	]).description("Per-advisor thinking strength; unset = provider/model default. Standard DSH effort ids; off disables thinking per request."),
+	tools: Schema.union([
+		Schema.const("readonly"),
+		Schema.const("all"),
+		Schema.const("off")
+	]).description("Per-advisor tool calling scope override; unset = follow the global discussion.advisorTools default.")
+});
+const DriverModel = Schema.object({
+	provider: Schema.string().required().description("Provider route of the fallback driver model."),
+	model: Schema.string().required().description("Model id of the fallback driver model.")
+});
+const DiscussionConfig = Schema.object({
+	maxRounds: Schema.natural().min(1).max(5).default(2).description("Total rounds of the auto-deepen consultation (each round = driver deep-question + all advisors in relay order)."),
+	maxAdvisorsPerCall: Schema.natural().min(1).max(10).default(3).description("Maximum number of advisors consulted in one ask_advisors call."),
+	parallel: Schema.boolean().default(true).description("Deprecated: rounds are a sequential A→B→C relay; kept for stored-config compatibility."),
+	autoDeepen: Schema.boolean().default(true).description("Run the auto-deepen pipeline: after each round the driver model asks a deeper follow-up, and a final conclusion closes the consultation."),
+	driverModel: Schema.union([DriverModel, Schema.const(void 0)]).description("Fallback driver model (provider/model) used when the session header cannot be read."),
+	stopOnConsensus: Schema.boolean().default(false).description("Deprecated: dormant under the auto-deepen pipeline; kept for stored-config compatibility."),
+	advisorTimeoutMs: Schema.number().min(1e3).max(6e5).default(6e5).description("Per-advisor call timeout in milliseconds (default 600000 = 10 min). Long-reasoning models can exhaust shorter budgets on the thinking chain and lose the answer body; a timeout keeps the partial thinking chain and marks the message as truncated."),
+	driverTimeoutMs: Schema.number().min(1e3).max(12e5).default(6e5).description("Driver generation timeout in milliseconds (deep-question / conclusion; default 600000 = 10 min). Long discussions with many tool results need a real budget."),
+	advisorTools: Schema.union([
+		Schema.const("readonly"),
+		Schema.const("all"),
+		Schema.const("off")
+	]).default("readonly").description("Global default advisor tool calling scope for advisors that do not set their own `tools` field: readonly (default; read-only session tools), all (every session-visible tool incl. writable ones), off (disabled). Only the direct-http OpenAI/Anthropic channel supports tool calling.")
+});
+const TriggerConfig = Schema.object({
+	requireClassifier: Schema.boolean().default(true).description("Run the pre-classifier before starting a consultation."),
+	allowWebFallback: Schema.boolean().default(true).description("When classifier says web search is better, return that hint to the main model."),
+	confidenceThreshold: Schema.number().min(0).max(1).default(.6).description("Below this confidence score, ask_advisors should escalate even without domain keywords.")
+});
+const UiConfig = Schema.object({
+	theme: Schema.union([
+		Schema.const("retro-green"),
+		Schema.const("retro-amber"),
+		Schema.const("retro-blue")
+	]).default("retro-green"),
+	showTimestamps: Schema.boolean().default(true),
+	autoExpand: Schema.boolean().default(true)
+});
+const QuotaConfig = Schema.object({
+	enabled: Schema.boolean().default(true).description("Enable the daily new-consultation cap (cost safety valve)."),
+	maxPerDay: Schema.natural().min(1).max(1e5).default(50).description("Max new consultations per UTC day (1–100000); ignored when enabled is false.")
+});
+const Config = Schema.object({
+	enabled: Schema.boolean().default(true),
+	discussion: DiscussionConfig,
+	trigger: TriggerConfig,
+	ui: UiConfig,
+	quota: QuotaConfig,
+	advisors: Schema.array(AdvisorConfig).default([])
+});
+//#endregion
+//#region src/providers/advisor-prompt.ts
+/**
+* Standard suffix appended to every advisor system prompt.
+*
+* It asks the advisor to state its own confidence/uncertainty so the main
+* model can weigh the answer instead of treating all advisor output equally.
+*/
+const ADVISOR_OUTPUT_POLICY = `
+
+回答要求：
+- 先给结论，再简要说明依据；
+- 在回答末尾用一行标注：置信度（0-10）或不确定性；
+- 如果没有把握，请明确写“不确定”，不要强行编造；
+- **全程使用中文输出**：包括调用工具前的行动说明、正文与最终结论（代码、路径、专业术语可保留原文）；不要把“我接下来要做什么”的说明写成英文；
+- 思考（思维链）请保持精简：只列关键推理要点，切勿让思考链占满输出预算——必须保证正文完整（历史教训：长思考+长上下文会耗尽输出上限，导致正文丢失/中途截断）；
+- **最终答复必须输出一段完整的中文正文回答**：不要只输出工具调用描述/标记，不要输出空白或空消息——即使本轮没有新结论，也要用正文说明你的判断（这是硬性输出约束）。
+`;
+/**
+* Tool-calling guidance appended to an advisor's system prompt ONLY when the
+* advisor actually has tools configured and the session-visible set resolved
+* (callAdvisor adds it on the direct-http tool loop path).
+*/
+const ADVISOR_TOOL_GUIDANCE = `
+
+工具使用指引：
+- 你可以调用当前会话提供的工具（检索/读取/搜索等）来辅助回答；
+- 对于你不了解、不熟悉的内容，尤其是项目背景、代码细节、仓库状态等不在你知识范围内的情况，请优先使用联网工具（如 web_search、web_fetch）搜索核实，再基于实际信息给出意见；
+- 仅在确有必要时调用工具：先了解现状，再下结论；不要编造你未核实的事实；
+- **调用工具前必须先用一句中文说明你准备做什么**（行动说明），例如“我先读取 package.json 确认版本”；这段行动说明会显示在卡片上，不要用英文写。
+`;
+/**
+* Sequential-relay role hint appended to one advisor's system prompt.
+*
+* The first advisor answers the (main-model) question directly; every later
+* advisor joins the same turn AFTER its predecessors and is told to give its
+* OWN view against the full conversation (agree / complement / rebut), so the
+* turn reads as main-question → A → B(sees A) → C(sees A+B).
+*/
+function advisorJoinPrompt(joinIndex, advisorCount) {
+	if (joinIndex <= 1) return `
+本次你作为第 1 位接入的顾问：请直接、完整地回答主模型的问题；你在本轮中会最先发言，后续其他顾问会基于你的回答继续补充。
+`;
+	return `
+本次你作为第 ${joinIndex} / ${advisorCount} 位接入的顾问。你可以在上下文中看到：
+- 项目背景与主模型的问题；
+- 前面已接入顾问（第 1 至第 ${joinIndex - 1} 位）对本问题的完整回答。
+
+请给出你**自己的独立见解**：可以认同、补充、质疑或反驳前面顾问的观点，但请明确点出你的回答与前序观点的差异和理由；不要简单复述前序内容。
+`;
+}
+//#endregion
+//#region src/providers/timeout.ts
+/**
+* Combine an optional caller signal with a hard timeout.
+* Node 22+ provides AbortSignal.any and AbortSignal.timeout.
+*/
+function withTimeout(ms, signal) {
+	const timeout = AbortSignal.timeout(ms);
+	if (!signal) return timeout;
+	return AbortSignal.any([signal, timeout]);
+}
+/**
+* Same combination, but keeps the timeout signal reachable so the caller can
+* classify an aborted stream: timeout fired -> graceful truncation (keep the
+* partial thinking, mark `truncated`); caller signal fired -> cancellation.
+*/
+function timeoutSignalPair(ms, signal) {
+	const timeout = AbortSignal.timeout(ms);
+	return {
+		signal: signal ? AbortSignal.any([signal, timeout]) : timeout,
+		isTimeout: () => timeout.aborted
+	};
+}
+//#endregion
+//#region src/providers/ctx-llm.ts
+function formatTranscript(entries) {
+	return entries.map((entry) => `[${entry.role === "main" ? "主模型" : entry.name}]\n${entry.content}`).join("\n\n");
+}
+/**
+* Call an advisor through DSH's built-in ctx.llm seam.
+*
+* This is the primary path: it reuses whatever provider routes the user has
+* already configured in DSH (deepseek-official, llm-pi-ai providers, etc.),
+* including credentials resolved by the harness.
+*
+* Timeout semantics (root cause of "thinking cut mid-sentence, no body"): a
+* long-reasoning model can spend the whole advisor budget on its thinking
+* chain. When `timeoutMs` fires, the stream simply stops (it does not throw),
+* which used to produce a silent empty body. We now detect the timeout and
+* report `truncated` so the caller can surface it to the user instead of
+* treating the reply as complete. A caller-initiated abort still propagates.
+*/
+async function callViaCtxLlm(ctx, advisor, transcript, signal, onDelta, timeoutMs) {
+	const userText = formatTranscript(transcript);
+	const messages = [createUserMessage({
+		content: [{
+			type: "text",
+			text: userText
+		}],
+		source: {
+			kind: "plugin",
+			plugin: "dsh-advisor-group"
+		}
+	})];
+	const pair = timeoutSignalPair(timeoutMs ?? 12e4, signal);
+	const reasoningEffort = advisor.thinking === "disabled" ? "off" : advisor.reasoningEffort;
+	const options = {
+		provider: advisor.provider,
+		model: advisor.model,
+		system: `${advisor.systemPrompt}${ADVISOR_OUTPUT_POLICY}`,
+		messages,
+		...reasoningEffort === void 0 ? {} : { reasoningEffort },
+		temperature: advisor.temperature,
+		maxTokens: advisor.maxTokens ?? 16384,
+		signal: pair.signal
+	};
+	let text = "";
+	let thinking = "";
+	try {
+		for await (const chunk of ctx.llm.stream(options)) if (chunk.type === "text-delta") {
+			text += chunk.text;
+			onDelta?.({ text: chunk.text });
+		} else if (chunk.type === "reasoning-delta") {
+			thinking += chunk.text;
+			onDelta?.({ thinking: chunk.text });
+		}
+	} catch (error) {
+		if (pair.isTimeout()) return {
+			content: text,
+			thinking,
+			truncated: {
+				reason: "timeout",
+				atMs: Date.now()
+			}
+		};
+		throw error;
+	}
+	if (pair.isTimeout()) return {
+		content: text,
+		thinking,
+		truncated: {
+			reason: "timeout",
+			atMs: Date.now()
+		}
+	};
+	if (signal?.aborted) throw new DOMException("Aborted", "AbortError");
+	return {
+		content: text,
+		thinking
+	};
+}
+//#endregion
+//#region src/providers/presets.ts
+const PROVIDER_PRESETS = {
+	deepseek: {
+		id: "deepseek",
+		label: "DeepSeek",
+		protocol: "openai",
+		baseURL: "https://api.deepseek.com",
+		apiKeyEnv: "DEEPSEEK_API_KEY",
+		defaultModels: [
+			"deepseek-v4-flash",
+			"deepseek-v4-pro",
+			"deepseek-v4-flash-vision-exp"
+		],
+		notes: "Also available as deepseek-official via dsh-llm-deepseek, and Anthropic-compatible at https://api.deepseek.com/anthropic."
+	},
+	"deepseek-anthropic": {
+		id: "deepseek-anthropic",
+		label: "DeepSeek（Anthropic 兼容）",
+		protocol: "anthropic",
+		baseURL: "https://api.deepseek.com/anthropic",
+		apiKeyEnv: "DEEPSEEK_API_KEY",
+		defaultModels: [
+			"deepseek-v4-flash",
+			"deepseek-v4-pro",
+			"deepseek-v4-flash-vision-exp"
+		],
+		authMode: "x-api-key",
+		modelsBaseURL: "https://api.deepseek.com",
+		modelsAuthMode: "bearer",
+		notes: "DeepSeek Anthropic-compatible endpoint."
+	},
+	moonshot: {
+		id: "moonshot",
+		label: "月之暗面 Kimi",
+		protocol: "openai",
+		baseURL: "https://api.moonshot.cn/v1",
+		apiKeyEnv: "MOONSHOT_API_KEY",
+		defaultModels: [
+			"kimi-k3",
+			"kimi-k2.7-code",
+			"kimi-k2.7-code-highspeed",
+			"kimi-k2.6"
+		],
+		notes: "OpenAI-compatible; Anthropic-compatible endpoint at https://api.moonshot.cn/anthropic"
+	},
+	"moonshot-anthropic": {
+		id: "moonshot-anthropic",
+		label: "月之暗面 Kimi（Anthropic 兼容）",
+		protocol: "anthropic",
+		baseURL: "https://api.moonshot.cn/anthropic",
+		apiKeyEnv: "MOONSHOT_API_KEY",
+		defaultModels: [
+			"kimi-k3",
+			"kimi-k2.7-code",
+			"kimi-k2.7-code-highspeed",
+			"kimi-k2.6"
+		],
+		authMode: "bearer",
+		modelsBaseURL: "https://api.moonshot.cn/v1",
+		modelsAuthMode: "bearer",
+		notes: "Kimi Anthropic-compatible endpoint; 实际端点 /anthropic/v1/messages（官方 Claude Code 文档）。"
+	},
+	"kimi-code": {
+		id: "kimi-code",
+		label: "Kimi Code（OpenAI 兼容）",
+		protocol: "openai",
+		baseURL: "https://api.kimi.com/coding/v1",
+		apiKeyEnv: "KIMI_CODE_API_KEY",
+		defaultModels: [
+			"kimi-k3",
+			"kimi-k2.7-code",
+			"kimi-k2.7-code-highspeed",
+			"kimi-for-coding"
+		],
+		modelsBaseURL: "https://api.kimi.com/coding/v1",
+		modelsAuthMode: "bearer",
+		notes: "Kimi Code 会员 API；可用模型以会员页为准，常用 kimi-k3 / kimi-k2.7-code / kimi-k2.7-code-highspeed，旧 kimi-for-coding 仍兼容。"
+	},
+	"kimi-code-anthropic": {
+		id: "kimi-code-anthropic",
+		label: "Kimi Code（Anthropic 兼容）",
+		protocol: "anthropic",
+		baseURL: "https://api.kimi.com/coding",
+		apiKeyEnv: "KIMI_CODE_API_KEY",
+		defaultModels: [
+			"kimi-k3",
+			"kimi-k2.7-code",
+			"kimi-k2.7-code-highspeed",
+			"kimi-for-coding"
+		],
+		authMode: "bearer",
+		modelsBaseURL: "https://api.kimi.com/coding/v1",
+		modelsAuthMode: "bearer",
+		notes: "Kimi Code 会员 Anthropic 兼容端点；实际端点 /coding/v1/messages。"
+	},
+	bailian: {
+		id: "bailian",
+		label: "阿里云百炼",
+		protocol: "openai",
+		baseURL: "https://dashscope.aliyuncs.com/compatible-mode/v1",
+		apiKeyEnv: "DASHSCOPE_API_KEY",
+		defaultModels: [
+			"qwen3.8-max",
+			"qwen3.8-flash",
+			"qwen3.7-plus"
+		],
+		notes: "DashScope OpenAI-compatible endpoint（北京公共域名）。"
+	},
+	"bailian-openai-singapore": {
+		id: "bailian-openai-singapore",
+		label: "阿里云百炼（OpenAI 兼容 · 新加坡公共）",
+		protocol: "openai",
+		baseURL: "https://dashscope-intl.aliyuncs.com/compatible-mode/v1",
+		apiKeyEnv: "DASHSCOPE_API_KEY",
+		defaultModels: [
+			"qwen3.8-max",
+			"qwen3.8-flash",
+			"qwen3.7-plus"
+		],
+		notes: "DashScope 新加坡公共域名 OpenAI 兼容端点。"
+	},
+	"bailian-openai-us": {
+		id: "bailian-openai-us",
+		label: "阿里云百炼（OpenAI 兼容 · 美国公共）",
+		protocol: "openai",
+		baseURL: "https://dashscope-us.aliyuncs.com/compatible-mode/v1",
+		apiKeyEnv: "DASHSCOPE_API_KEY",
+		defaultModels: [
+			"qwen3.8-max",
+			"qwen3.8-flash",
+			"qwen3.7-plus"
+		],
+		notes: "DashScope 美国（弗吉尼亚）公共域名 OpenAI 兼容端点。"
+	},
+	"bailian-anthropic": {
+		id: "bailian-anthropic",
+		label: "阿里云百炼（Anthropic 兼容 · 按量付费 · 业务空间）",
+		protocol: "anthropic",
+		baseURL: "https://{WorkspaceId}.cn-beijing.maas.aliyuncs.com/apps/anthropic",
+		apiKeyEnv: "DASHSCOPE_API_KEY",
+		defaultModels: [
+			"qwen3.8-max",
+			"qwen3.8-flash",
+			"qwen3.7-plus",
+			"deepseek-v4-pro",
+			"deepseek-v4-flash",
+			"kimi-k3",
+			"glm-5.3"
+		],
+		authMode: "bearer",
+		modelsBaseURL: "https://dashscope.aliyuncs.com/compatible-mode/v1",
+		modelsAuthMode: "bearer",
+		notes: "需要把 {WorkspaceId} 替换为你的百炼业务空间 ID；API Key 为 sk- 开头（按量付费）。"
+	},
+	"bailian-anthropic-public": {
+		id: "bailian-anthropic-public",
+		label: "阿里云百炼（Anthropic 兼容 · 北京公共）",
+		protocol: "anthropic",
+		baseURL: "https://dashscope.aliyuncs.com/apps/anthropic",
+		apiKeyEnv: "DASHSCOPE_API_KEY",
+		defaultModels: [
+			"qwen3.8-max",
+			"qwen3.8-flash",
+			"qwen3.7-plus",
+			"deepseek-v4-pro",
+			"deepseek-v4-flash",
+			"kimi-k3",
+			"glm-5.3"
+		],
+		authMode: "bearer",
+		modelsBaseURL: "https://dashscope.aliyuncs.com/compatible-mode/v1",
+		modelsAuthMode: "bearer",
+		notes: "DashScope 北京公共域名 Anthropic 兼容端点。"
+	},
+	"bailian-anthropic-singapore-public": {
+		id: "bailian-anthropic-singapore-public",
+		label: "阿里云百炼（Anthropic 兼容 · 新加坡公共）",
+		protocol: "anthropic",
+		baseURL: "https://dashscope-intl.aliyuncs.com/apps/anthropic",
+		apiKeyEnv: "DASHSCOPE_API_KEY",
+		defaultModels: [
+			"qwen3.8-max",
+			"qwen3.8-flash",
+			"qwen3.7-plus",
+			"deepseek-v4-pro",
+			"deepseek-v4-flash",
+			"kimi-k3",
+			"glm-5.3"
+		],
+		authMode: "bearer",
+		modelsBaseURL: "https://dashscope-intl.aliyuncs.com/compatible-mode/v1",
+		modelsAuthMode: "bearer",
+		notes: "DashScope 新加坡公共域名 Anthropic 兼容端点。"
+	},
+	"bailian-anthropic-us-public": {
+		id: "bailian-anthropic-us-public",
+		label: "阿里云百炼（Anthropic 兼容 · 美国公共）",
+		protocol: "anthropic",
+		baseURL: "https://dashscope-us.aliyuncs.com/apps/anthropic",
+		apiKeyEnv: "DASHSCOPE_API_KEY",
+		defaultModels: [
+			"qwen3.8-max",
+			"qwen3.8-flash",
+			"qwen3.7-plus",
+			"deepseek-v4-pro",
+			"deepseek-v4-flash",
+			"kimi-k3",
+			"glm-5.3"
+		],
+		authMode: "bearer",
+		modelsBaseURL: "https://dashscope-us.aliyuncs.com/compatible-mode/v1",
+		modelsAuthMode: "bearer",
+		notes: "DashScope 美国（弗吉尼亚）公共域名 Anthropic 兼容端点。"
+	},
+	"bailian-token-plan-anthropic": {
+		id: "bailian-token-plan-anthropic",
+		label: "阿里云百炼（Anthropic 兼容 · Token Plan）",
+		protocol: "anthropic",
+		baseURL: "https://token-plan.cn-beijing.maas.aliyuncs.com/apps/anthropic",
+		apiKeyEnv: "DASHSCOPE_TOKEN_PLAN_API_KEY",
+		defaultModels: [
+			"qwen3.8-max",
+			"qwen3.8-flash",
+			"qwen3.7-plus",
+			"deepseek-v4-pro",
+			"deepseek-v4-flash",
+			"kimi-k3",
+			"glm-5.3"
+		],
+		authMode: "bearer",
+		modelsBaseURL: "https://dashscope.aliyuncs.com/compatible-mode/v1",
+		modelsAuthMode: "bearer",
+		notes: "API Key 为 sk-sp- 开头，必须与 Token Plan Base URL 配套使用。"
+	},
+	"bailian-coding-plan-anthropic": {
+		id: "bailian-coding-plan-anthropic",
+		label: "阿里云百炼（Anthropic 兼容 · Coding Plan）",
+		protocol: "anthropic",
+		baseURL: "https://coding.dashscope.aliyuncs.com/apps/anthropic",
+		apiKeyEnv: "DASHSCOPE_CODING_PLAN_API_KEY",
+		defaultModels: [
+			"qwen3.8-max",
+			"qwen3.8-flash",
+			"qwen3.7-plus",
+			"deepseek-v4-pro",
+			"deepseek-v4-flash",
+			"kimi-k3",
+			"glm-5.3"
+		],
+		authMode: "bearer",
+		modelsBaseURL: "https://dashscope.aliyuncs.com/compatible-mode/v1",
+		modelsAuthMode: "bearer",
+		notes: "API Key 为 sk-ws- 开头，必须与 Coding Plan Base URL 配套使用。"
+	},
+	zhipu: {
+		id: "zhipu",
+		label: "智谱 AI",
+		protocol: "openai",
+		baseURL: "https://open.bigmodel.cn/api/paas/v4",
+		apiKeyEnv: "ZHIPU_API_KEY",
+		defaultModels: [
+			"glm-5.3",
+			"glm-5.3-flash",
+			"glm-5.2",
+			"glm-5.1"
+		],
+		modelsBaseURL: "https://open.bigmodel.cn/api/paas/v4",
+		modelsAuthMode: "bearer",
+		notes: "智谱 AI OpenAI 兼容端点；chat completions 为 /v4/chat/completions，模型列表为 /v4/models。"
+	},
+	"zhipu-anthropic": {
+		id: "zhipu-anthropic",
+		label: "智谱 AI（Anthropic 兼容）",
+		protocol: "anthropic",
+		baseURL: "https://open.bigmodel.cn/api/anthropic",
+		apiKeyEnv: "ZHIPU_API_KEY",
+		defaultModels: [
+			"glm-5.3",
+			"glm-5.3-flash",
+			"glm-5.2",
+			"glm-5.1"
+		],
+		authMode: "bearer",
+		modelsBaseURL: "https://open.bigmodel.cn/api/paas/v4",
+		modelsAuthMode: "bearer",
+		notes: "智谱 AI Claude API 兼容端点；ANTHROPIC_BASE_URL=https://open.bigmodel.cn/api/anthropic。"
+	},
+	openai: {
+		id: "openai",
+		label: "OpenAI",
+		protocol: "openai",
+		baseURL: "https://api.openai.com/v1",
+		apiKeyEnv: "OPENAI_API_KEY",
+		defaultModels: [
+			"gpt-6-astra",
+			"gpt-5.6-sol",
+			"gpt-5.6-terra",
+			"gpt-5.6-luna",
+			"gpt-5.5",
+			"gpt-5.4"
+		],
+		notes: "Official OpenAI API."
+	},
+	anthropic: {
+		id: "anthropic",
+		label: "Claude",
+		protocol: "anthropic",
+		baseURL: "https://api.anthropic.com",
+		apiKeyEnv: "ANTHROPIC_API_KEY",
+		defaultModels: [
+			"claude-opus-5",
+			"claude-sonnet-5",
+			"claude-opus-4-8",
+			"claude-opus-4-7",
+			"claude-sonnet-4-6"
+		],
+		authMode: "x-api-key",
+		notes: "Anthropic Messages API; docs in D:/X/X/14-claude."
+	},
+	gemini: {
+		id: "gemini",
+		label: "Gemini",
+		protocol: "gemini",
+		baseURL: "https://generativelanguage.googleapis.com",
+		apiKeyEnv: "GEMINI_API_KEY",
+		defaultModels: [
+			"gemini-3.8-flash",
+			"gemini-3.7-flash",
+			"gemini-3.1-pro-preview",
+			"gemini-3-flash-preview"
+		],
+		notes: "Google Gemini API; docs in D:/X/X/13-gemini."
+	},
+	siliconflow: {
+		id: "siliconflow",
+		label: "硅基流动",
+		protocol: "openai",
+		baseURL: "https://api.siliconflow.cn/v1",
+		apiKeyEnv: "SILICONFLOW_API_KEY",
+		defaultModels: [
+			"deepseek-ai/DeepSeek-V3.2",
+			"Qwen/Qwen3-235B-A22B",
+			"zai-org/GLM-5.1"
+		],
+		notes: "OpenAI-compatible; also supports Anthropic-compatible at /v1/messages."
+	},
+	"siliconflow-anthropic": {
+		id: "siliconflow-anthropic",
+		label: "硅基流动（Anthropic 兼容）",
+		protocol: "anthropic",
+		baseURL: "https://api.siliconflow.cn/v1",
+		apiKeyEnv: "SILICONFLOW_API_KEY",
+		defaultModels: [
+			"deepseek-ai/DeepSeek-V3.2",
+			"Qwen/Qwen3-32B",
+			"zai-org/GLM-5.1"
+		],
+		authMode: "bearer",
+		modelsBaseURL: "https://api.siliconflow.cn/v1",
+		modelsAuthMode: "bearer",
+		notes: "SiliconFlow Anthropic-compatible endpoint: ANTHROPIC_BASE_URL=https://api.siliconflow.cn/ 或 /v1。"
+	},
+	aihubmix: {
+		id: "aihubmix",
+		label: "AIHubMix",
+		protocol: "openai",
+		baseURL: "https://aihubmix.com/v1",
+		apiKeyEnv: "AIHUBMIX_API_KEY",
+		defaultModels: [
+			"gpt-5.2",
+			"claude-sonnet-4-5",
+			"claude-opus-4-5",
+			"gemini-3-flash-preview"
+		],
+		notes: "Aggregator; also supports Anthropic-compatible at https://aihubmix.com."
+	},
+	"aihubmix-anthropic": {
+		id: "aihubmix-anthropic",
+		label: "AIHubMix（Anthropic 兼容）",
+		protocol: "anthropic",
+		baseURL: "https://aihubmix.com",
+		apiKeyEnv: "AIHUBMIX_API_KEY",
+		defaultModels: [
+			"claude-sonnet-4-5",
+			"claude-opus-4-6",
+			"claude-opus-4-5"
+		],
+		authMode: "x-api-key",
+		modelsBaseURL: "https://aihubmix.com/v1",
+		modelsAuthMode: "bearer",
+		notes: "AIHubMix Anthropic-compatible endpoint."
+	},
+	openrouter: {
+		id: "openrouter",
+		label: "OpenRouter",
+		protocol: "openai",
+		baseURL: "https://openrouter.ai/api/v1",
+		apiKeyEnv: "OPENROUTER_API_KEY",
+		defaultModels: [
+			"openai/gpt-5.6",
+			"openai/gpt-5.5",
+			"anthropic/claude-sonnet-4.6",
+			"deepseek/deepseek-chat"
+		],
+		notes: "OpenAI-compatible; docs in D:/X/X/06-OpenRouter."
+	},
+	"openrouter-anthropic": {
+		id: "openrouter-anthropic",
+		label: "OpenRouter（Anthropic 兼容）",
+		protocol: "anthropic",
+		baseURL: "https://openrouter.ai/api",
+		apiKeyEnv: "OPENROUTER_API_KEY",
+		defaultModels: [
+			"anthropic/claude-sonnet-4.6",
+			"anthropic/claude-opus-4-6",
+			"openai/gpt-5.6",
+			"deepseek/deepseek-chat"
+		],
+		authMode: "bearer",
+		modelsBaseURL: "https://openrouter.ai/api/v1",
+		modelsAuthMode: "bearer",
+		notes: "OpenRouter Anthropic Skin；使用 ANTHROPIC_BASE_URL=https://openrouter.ai/api + ANTHROPIC_AUTH_TOKEN=OpenRouter Key（Bearer）。"
+	}
+};
+function getProviderPreset(id) {
+	return PROVIDER_PRESETS[id];
+}
+//#endregion
+//#region src/dsml.ts
+const OUTER_OPEN = /<[｜|]{0,2}(?:DSML[｜|]{0,2})?(?:tool_calls|function_calls)\s*>/g;
+const OUTER_CLOSE_RE = /<\/[｜|]{0,2}(?:DSML[｜|]{0,2})?[｜|]{0,2}(?:tool_calls|function_calls)\s*>/;
+const INVOKE_RE = /<[｜|]{0,2}(?:DSML[｜|]{0,2})?[｜|]{0,2}\s*invoke\s+name="([^"]+)">([\s\S]*?)<\/[｜|]{0,2}(?:DSML[｜|]{0,2})?[｜|]{0,2}\s*invoke\s*>/g;
+const PARAM_RE = /<[｜|]{0,2}(?:DSML[｜|]{0,2})?[｜|]{0,2}\s*parameter\s+name="([^"]+)"(?:\s+string="true")?>([\s\S]*?)<\/[｜|]{0,2}(?:DSML[｜|]{0,2})?[｜|]{0,2}\s*parameter\s*>/g;
+const PARAM_OPEN_RE = /<[｜|]{0,2}(?:DSML[｜|]{0,2})?[｜|]{0,2}\s*parameter\s+name="[^"]+"/g;
+function insideFence(content, index) {
+	const fences = content.slice(0, index).match(/```/g);
+	return Boolean(fences && fences.length % 2 === 1);
+}
+/** Parse every invoke inside one outer block; null when any gate fails. */
+function parseOuterBlock(block, allowedNames) {
+	const calls = [];
+	INVOKE_RE.lastIndex = 0;
+	let invoke;
+	let invokeCount = 0;
+	while ((invoke = INVOKE_RE.exec(block)) !== null) {
+		invokeCount += 1;
+		const name = invoke[1];
+		if (!allowedNames.has(name)) return null;
+		const body = invoke[2];
+		const params = {};
+		PARAM_RE.lastIndex = 0;
+		let param;
+		let paramCount = 0;
+		while ((param = PARAM_RE.exec(body)) !== null) {
+			paramCount += 1;
+			if (PARAM_OPEN_RE.test(param[2])) return null;
+			params[param[1]] = param[2];
+			PARAM_OPEN_RE.lastIndex = 0;
+		}
+		if ((body.match(PARAM_OPEN_RE) ?? []).length !== paramCount) return null;
+		PARAM_OPEN_RE.lastIndex = 0;
+		calls.push({
+			id: `text-${calls.length}`,
+			name,
+			argumentsJson: paramCount > 0 ? JSON.stringify(params) : "{}"
+		});
+	}
+	if (invokeCount === 0) return null;
+	return calls;
+}
+/** Extract text tool calls; blocks outside code fences, whitelisted names. */
+function parseTextToolCalls(content, allowedNames) {
+	if (!content || allowedNames.size === 0) return {
+		toolCalls: [],
+		cleaned: content
+	};
+	const ranges = [];
+	const allCalls = [];
+	OUTER_OPEN.lastIndex = 0;
+	let match;
+	while ((match = OUTER_OPEN.exec(content)) !== null) {
+		const start = match.index;
+		if (insideFence(content, start)) continue;
+		const rest = content.slice(start);
+		const close = rest.match(OUTER_CLOSE_RE);
+		const calls = parseOuterBlock(close && close.index !== void 0 ? rest.slice(0, close.index) : rest, allowedNames);
+		if (calls === null) continue;
+		const end = close && close.index !== void 0 ? start + close.index + close[0].length : content.length;
+		allCalls.push(...calls);
+		ranges.push([start, end]);
+	}
+	if (allCalls.length === 0) return {
+		toolCalls: [],
+		cleaned: content
+	};
+	let cleaned = content;
+	for (let i = ranges.length - 1; i >= 0; i -= 1) {
+		const [from, to] = ranges[i];
+		cleaned = cleaned.slice(0, from) + cleaned.slice(to);
+	}
+	return {
+		toolCalls: allCalls,
+		cleaned: cleaned.trim()
+	};
+}
+//#endregion
+//#region src/providers/direct-http.ts
+/** True when the user asked to force thinking off, through either spelling. */
+function thinkingOff(advisor) {
+	return advisor.thinking === "disabled" || advisor.reasoningEffort === "off";
+}
+/**
+* OpenAI-compatible reasoning params, provider-aware (2026-09-05 知识 X 最新):
+* - DeepSeek: `thinking {type}` switch + `reasoning_effort` low/high/max.
+* - Kimi/Kimi Code: kimi-k3 = top-level `reasoning_effort` low/high/max (no
+*   `thinking`); kimi-k2.7-code = always thinking, no params; kimi-k2.6 =
+*   `thinking {type}` switch only.
+* - OpenAI official: `reasoning_effort` minimal|low|medium|high (no max, no off).
+* - 阿里云百炼: `enable_thinking` bool (Qwen chat completions).
+* - 智谱: `thinking {type}` switch + `reasoning_effort` (GLM-5.3 force-enabled,
+*   disabled→enabled+low; GLM-5.2/5.1/5 can disable).
+* - 硅基流动: `enable_thinking` + `thinking_budget`.
+* - Others (AIHubMix/OpenRouter/custom): best-effort `reasoning_effort`.
+*/
+function openAiThinkingParams(advisor) {
+	const provider = advisor.provider;
+	const model = advisor.model;
+	const effort = advisor.reasoningEffort;
+	if (provider === "deepseek") {
+		if (thinkingOff(advisor)) return { thinking: { type: "disabled" } };
+		return {
+			...advisor.thinking === "enabled" ? { thinking: { type: "enabled" } } : {},
+			...effort && effort !== "off" ? { reasoning_effort: effort } : {}
+		};
+	}
+	if (provider === "moonshot" || provider === "kimi-code") {
+		if (/^(k3|kimi-k3)(-|$)/i.test(model)) {
+			if (effort && effort !== "off") return { reasoning_effort: effort };
+			return {};
+		}
+		if (/kimi-k2\.7-code|kimi-for-coding/i.test(model)) return {};
+		if (advisor.thinking === "disabled") return { thinking: { type: "disabled" } };
+		if (advisor.thinking === "enabled") return { thinking: { type: "enabled" } };
+		return {};
+	}
+	if (provider === "openai") {
+		if (effort === "low") return { reasoning_effort: "low" };
+		if (effort === "high" || effort === "max") return { reasoning_effort: "high" };
+		return {};
+	}
+	if (provider === "bailian" || provider === "bailian-openai-singapore" || provider === "bailian-openai-us") {
+		if (thinkingOff(advisor)) return { enable_thinking: false };
+		if (advisor.thinking === "enabled") return { enable_thinking: true };
+		return {};
+	}
+	if (provider === "zhipu") {
+		if (/glm-5\.3/i.test(model)) return {
+			thinking: { type: "enabled" },
+			reasoning_effort: thinkingOff(advisor) ? "low" : effort && effort !== "off" ? effort : "max"
+		};
+		if (/glm-5/i.test(model)) {
+			if (thinkingOff(advisor)) return { thinking: { type: "disabled" } };
+			return {
+				...advisor.thinking === "enabled" ? { thinking: { type: "enabled" } } : {},
+				...effort && effort !== "off" ? { reasoning_effort: effort } : {}
+			};
+		}
+		if (advisor.thinking === "disabled") return { thinking: { type: "disabled" } };
+		if (advisor.thinking === "enabled") return { thinking: { type: "enabled" } };
+		return {};
+	}
+	if (provider === "siliconflow") {
+		if (thinkingOff(advisor)) return { enable_thinking: false };
+		const budget = effort === "low" ? 1024 : effort === "high" ? 8192 : effort === "max" ? 16384 : 0;
+		return {
+			...advisor.thinking === "enabled" || budget > 0 ? { enable_thinking: true } : {},
+			...budget > 0 ? { thinking_budget: budget } : {}
+		};
+	}
+	if (effort && effort !== "off") return { reasoning_effort: effort };
+	return {};
+}
+/** Anthropic Messages reasoning params, provider-aware.
+*  Official Anthropic: adaptive (`thinking:{type:'adaptive'}` + `output_config.effort`)
+*  for Opus 4.6/4.7/Sonnet 4.6/Mythos; manual `enabled`+`budget_tokens` for older
+*  models. DeepSeek's Anthropic-compatible endpoint uses `reasoning.effort` +
+*  `output_config.effort` (its `budget_tokens` is ignored). Other Anthropic skins
+*  follow the official Anthropic wire shape. */
+function anthropicThinkingParams(advisor) {
+	if (advisor.provider === "deepseek-anthropic") {
+		if (thinkingOff(advisor)) return { reasoning: { effort: "none" } };
+		if (advisor.reasoningEffort && advisor.reasoningEffort !== "off") return {
+			reasoning: { effort: advisor.reasoningEffort },
+			output_config: { effort: advisor.reasoningEffort }
+		};
+		return {};
+	}
+	if (thinkingOff(advisor)) return { thinking: { type: "disabled" } };
+	if (advisor.reasoningEffort && advisor.reasoningEffort !== "off") {
+		if (/(?:opus-4-[6-8]|opus-5|sonnet-4-6|sonnet-5|fable|mythos)/i.test(advisor.model)) return {
+			thinking: { type: "adaptive" },
+			output_config: { effort: advisor.reasoningEffort }
+		};
+		return { thinking: {
+			type: "enabled",
+			budget_tokens: advisor.reasoningEffort === "low" ? 2048 : advisor.reasoningEffort === "high" ? 8192 : 16384
+		} };
+	}
+	return {};
+}
+/** Gemini `generateContent` thinking config. Disabling thinking uses
+*  `thinkingBudget: 0` (NOT `includeThoughts:false`, which only hides returned
+*  thoughts). Effort uses `thinkingBudget`, the backward-compatible knob that
+*  works across Gemini 2.5 and Gemini 3 per Google's migration note. */
+function geminiThinkingParams(advisor) {
+	if (thinkingOff(advisor)) return { thinkingConfig: { thinkingBudget: 0 } };
+	const budget = advisor.reasoningEffort === "low" ? 1024 : advisor.reasoningEffort === "high" ? 8192 : advisor.reasoningEffort === "max" ? 16384 : 0;
+	if (budget > 0) return { thinkingConfig: { thinkingBudget: budget } };
+	return {};
+}
+/** Validate the per-advisor thinking fields at the direct-http boundary so a
+*  malformed stored config fails loudly instead of silently ignoring. */
+function assertThinkingParams(advisor) {
+	if (advisor.thinking !== void 0 && advisor.thinking !== "enabled" && advisor.thinking !== "disabled") throw new Error(`Unsupported thinking mode: ${String(advisor.thinking)}`);
+	if (advisor.reasoningEffort !== void 0 && ![
+		"off",
+		"low",
+		"high",
+		"max"
+	].includes(advisor.reasoningEffort)) throw new Error(`Unsupported reasoningEffort: ${String(advisor.reasoningEffort)}`);
+}
+/** Stream an advisor response through direct HTTP (OpenAI/Anthropic SSE). */
+async function streamDirectHttp(advisor, transcript, onDelta, signal, timeoutMs, tools, parseToolNames) {
+	const preset = advisor.provider ? getProviderPreset(advisor.provider) : void 0;
+	const baseURL = (advisor.baseURL ?? preset?.baseURL ?? "").replace(/\/+$/, "");
+	const apiKey = advisor.apiKey ?? process.env[advisor.apiKeyEnv ?? preset?.apiKeyEnv ?? ""] ?? "";
+	const protocol = advisor.protocol ?? preset?.protocol ?? "openai";
+	const authMode = advisor.authMode ?? preset?.authMode ?? "x-api-key";
+	assertThinkingParams(advisor);
+	if (!baseURL || !apiKey) throw new Error(`Direct HTTP fallback is not configured for advisor "${advisor.name}" (${advisor.provider}). Add baseURL/apiKey or configure the provider in DSH.`);
+	const transcriptText = transcript.map((entry) => `[${entry.role === "main" ? "主模型" : entry.name}]\n${entry.content}`).join("\n\n");
+	let result;
+	switch (protocol) {
+		case "openai":
+			result = await streamOpenAICompatible(baseURL, advisor, apiKey, transcriptText, onDelta, signal, timeoutMs, tools);
+			break;
+		case "anthropic":
+			result = await streamAnthropic(baseURL, advisor, apiKey, transcriptText, authMode, onDelta, signal, timeoutMs, tools);
+			break;
+		case "gemini": {
+			const content = await callGemini(baseURL, advisor, apiKey, transcriptText, signal, timeoutMs);
+			onDelta({ text: content });
+			result = {
+				content,
+				thinking: ""
+			};
+			break;
+		}
+		default: throw new Error(`Unsupported protocol: ${String(protocol)}`);
+	}
+	const parsed = parseTextToolCalls(result.content, new Set(parseToolNames ?? (tools ?? []).map((tool) => tool.name)));
+	if (parsed.toolCalls.length > 0) {
+		console.warn(`[dsh-advisor-group] 检测到文本工具调用（DSML/非结构流），已还原并交给 runAdvisorToolLoop 执行：${parsed.toolCalls.map((tool) => tool.name).join("、")}`);
+		return {
+			...result,
+			content: parsed.cleaned,
+			toolCalls: [...result.toolCalls ?? [], ...parsed.toolCalls]
+		};
+	}
+	return result;
+}
+async function streamOpenAICompatible(baseURL, advisor, apiKey, transcriptText, onDelta, signal, timeoutMs, tools) {
+	const endpoint = baseURL.endsWith("/chat/completions") ? baseURL : `${baseURL.replace(/\/+$/, "")}/chat/completions`;
+	const pair = timeoutSignalPair(timeoutMs ?? 12e4, signal);
+	const body = {
+		model: advisor.model,
+		messages: [{
+			role: "system",
+			content: advisor.systemPrompt + ADVISOR_OUTPUT_POLICY
+		}, {
+			role: "user",
+			content: transcriptText
+		}],
+		temperature: advisor.temperature ?? .3,
+		max_tokens: advisor.maxTokens ?? 16384,
+		...openAiThinkingParams(advisor),
+		stream: true
+	};
+	if (tools && tools.length > 0) body.tools = tools.map((tool) => ({
+		type: "function",
+		function: {
+			name: tool.name,
+			...tool.description === void 0 ? {} : { description: tool.description },
+			parameters: tool.parameters ?? { type: "object" }
+		}
+	}));
+	const response = await fetch(endpoint, {
+		method: "POST",
+		headers: {
+			"content-type": "application/json",
+			authorization: `Bearer ${apiKey}`
+		},
+		body: JSON.stringify(body),
+		signal: pair.signal
+	});
+	if (!response.ok) throw new Error(`OpenAI-compatible request failed: ${response.status} ${await response.text()}`);
+	if (!response.body) throw new Error("OpenAI-compatible response has no body");
+	const reader = response.body.getReader();
+	const decoder = new TextDecoder();
+	let buffer = "";
+	let content = "";
+	let thinking = "";
+	const toolCalls = /* @__PURE__ */ new Map();
+	while (true) {
+		let done;
+		let value;
+		try {
+			const read = await reader.read();
+			done = read.done;
+			value = read.value;
+		} catch (error) {
+			const errName = error?.name ?? "UnknownError";
+			const errMessage = error instanceof Error ? error.message : String(error);
+			console.warn(`[dsh-advisor-group] direct-http stream read error: name=${errName} msg=${errMessage} isTimeout=${pair.isTimeout()} signalAborted=${signal?.aborted ?? false} collectedChars=${content.length + thinking.length}`);
+			if (pair.isTimeout()) return {
+				content,
+				thinking,
+				toolCalls: collectToolCalls(toolCalls),
+				truncated: {
+					reason: "timeout",
+					atMs: Date.now()
+				}
+			};
+			if (signal?.aborted || error?.name === "AbortError") throw error;
+			return {
+				content,
+				thinking,
+				toolCalls: collectToolCalls(toolCalls),
+				truncated: {
+					reason: "network",
+					atMs: Date.now()
+				}
+			};
+		}
+		if (done) break;
+		buffer += decoder.decode(value, { stream: true });
+		let sep;
+		while ((sep = buffer.indexOf("\n\n")) >= 0) {
+			const raw = buffer.slice(0, sep);
+			buffer = buffer.slice(sep + 2);
+			for (const line of raw.split("\n")) {
+				if (!line.startsWith("data:")) continue;
+				const data = line.slice(5).trim();
+				if (!data || data === "[DONE]") continue;
+				try {
+					const delta = JSON.parse(data).choices?.[0]?.delta ?? {};
+					const text = typeof delta.content === "string" ? delta.content : "";
+					const think = typeof delta.reasoning_content === "string" ? delta.reasoning_content : typeof delta.reasoning === "string" ? delta.reasoning : "";
+					if (delta.tool_calls) for (const tc of delta.tool_calls) {
+						const idx = tc.index ?? 0;
+						const current = toolCalls.get(idx) ?? {
+							id: "",
+							name: "",
+							args: ""
+						};
+						if (tc.id) current.id = tc.id;
+						if (tc.function?.name) current.name = tc.function.name;
+						if (tc.function?.arguments) current.args += tc.function.arguments;
+						toolCalls.set(idx, current);
+					}
+					if (text) {
+						content += text;
+						onDelta({ text });
+					}
+					if (think) {
+						thinking += think;
+						onDelta({ thinking: think });
+					}
+				} catch {}
+			}
+		}
+	}
+	return {
+		content,
+		thinking,
+		toolCalls: collectToolCalls(toolCalls)
+	};
+}
+/** Map<index, {id,name,args}> → model-facing tool call list. */
+function collectToolCalls(byIndex) {
+	const calls = [];
+	for (const [, current] of byIndex) {
+		if (!current.name) continue;
+		calls.push({
+			id: current.id || `tool-${calls.length}`,
+			name: current.name,
+			argumentsJson: current.args
+		});
+	}
+	return calls.length > 0 ? calls : void 0;
+}
+async function streamAnthropic(baseURL, advisor, apiKey, transcriptText, authMode, onDelta, signal, timeoutMs, tools) {
+	const endpoint = baseURL.endsWith("/v1/messages") ? baseURL : baseURL.endsWith("/v1") ? `${baseURL}/messages` : `${baseURL.replace(/\/+$/, "")}/v1/messages`;
+	const headers = {
+		"content-type": "application/json",
+		"anthropic-version": "2023-06-01"
+	};
+	if (authMode === "bearer") headers["authorization"] = `Bearer ${apiKey}`;
+	else headers["x-api-key"] = apiKey;
+	const body = {
+		model: advisor.model,
+		system: advisor.systemPrompt + ADVISOR_OUTPUT_POLICY,
+		messages: [{
+			role: "user",
+			content: transcriptText
+		}],
+		temperature: advisor.temperature ?? .3,
+		max_tokens: advisor.maxTokens ?? 16384,
+		...anthropicThinkingParams(advisor),
+		stream: true
+	};
+	if (tools && tools.length > 0) body.tools = tools.map((tool) => ({
+		name: tool.name,
+		...tool.description === void 0 ? {} : { description: tool.description },
+		input_schema: tool.parameters ?? { type: "object" }
+	}));
+	const pair = timeoutSignalPair(timeoutMs ?? 12e4, signal);
+	const response = await fetch(endpoint, {
+		method: "POST",
+		headers,
+		body: JSON.stringify(body),
+		signal: pair.signal
+	});
+	if (!response.ok) throw new Error(`Anthropic request failed: ${response.status} ${await response.text()}`);
+	if (!response.body) throw new Error("Anthropic response has no body");
+	const reader = response.body.getReader();
+	const decoder = new TextDecoder();
+	let buffer = "";
+	let content = "";
+	let thinking = "";
+	let currentTool = null;
+	let activeTool = false;
+	const toolCalls = [];
+	while (true) {
+		let done;
+		let value;
+		try {
+			const read = await reader.read();
+			done = read.done;
+			value = read.value;
+		} catch (error) {
+			const errName = error?.name ?? "UnknownError";
+			const errMessage = error instanceof Error ? error.message : String(error);
+			console.warn(`[dsh-advisor-group] anthropic stream read error: name=${errName} msg=${errMessage} isTimeout=${pair.isTimeout()} signalAborted=${signal?.aborted ?? false} collectedChars=${content.length + thinking.length}`);
+			if (pair.isTimeout()) return {
+				content,
+				thinking,
+				toolCalls: toolCalls.length > 0 ? toolCalls : void 0,
+				truncated: {
+					reason: "timeout",
+					atMs: Date.now()
+				}
+			};
+			if (signal?.aborted || error?.name === "AbortError") throw error;
+			return {
+				content,
+				thinking,
+				toolCalls: toolCalls.length > 0 ? toolCalls : void 0,
+				truncated: {
+					reason: "network",
+					atMs: Date.now()
+				}
+			};
+		}
+		if (done) break;
+		buffer += decoder.decode(value, { stream: true });
+		let sep;
+		while ((sep = buffer.indexOf("\n\n")) >= 0) {
+			const raw = buffer.slice(0, sep);
+			buffer = buffer.slice(sep + 2);
+			for (const line of raw.split("\n")) {
+				if (!line.startsWith("data:")) continue;
+				const data = line.slice(5).trim();
+				if (!data) continue;
+				try {
+					const json = JSON.parse(data);
+					if (json.type === "content_block_start" && json.content_block?.type === "tool_use") {
+						currentTool = currentTool === null ? {
+							id: json.content_block.id ?? "",
+							name: json.content_block.name ?? "",
+							args: ""
+						} : currentTool;
+						activeTool = true;
+					} else if (json.type === "content_block_delta" && json.delta) {
+						if (json.delta.type === "text_delta" && typeof json.delta.text === "string") {
+							content += json.delta.text;
+							onDelta({ text: json.delta.text });
+						} else if (json.delta.type === "thinking_delta" && typeof json.delta.thinking === "string") {
+							thinking += json.delta.thinking;
+							onDelta({ thinking: json.delta.thinking });
+						} else if (json.delta.type === "input_json_delta" && typeof json.delta.partial_json === "string") {
+							if (currentTool) currentTool.args += json.delta.partial_json;
+						}
+					} else if (json.type === "content_block_stop") {
+						if (activeTool && currentTool) {
+							toolCalls.push({
+								id: currentTool.id,
+								name: currentTool.name,
+								argumentsJson: currentTool.args
+							});
+							currentTool = null;
+							activeTool = false;
+						}
+					}
+				} catch {}
+			}
+		}
+	}
+	return {
+		content,
+		thinking,
+		toolCalls: toolCalls.length > 0 ? toolCalls : void 0
+	};
+}
+async function callGemini(baseURL, advisor, apiKey, transcriptText, signal, timeoutMs) {
+	const model = encodeURIComponent(advisor.model);
+	const base = baseURL.replace(/\/+$/, "");
+	const endpoint = base.endsWith("/v1beta") ? `${base}/models/${model}:generateContent?key=${apiKey}` : `${base}/v1beta/models/${model}:generateContent?key=${apiKey}`;
+	const response = await fetch(endpoint, {
+		method: "POST",
+		headers: { "content-type": "application/json" },
+		body: JSON.stringify({
+			contents: [{
+				role: "user",
+				parts: [{ text: transcriptText }]
+			}],
+			systemInstruction: { parts: [{ text: advisor.systemPrompt + ADVISOR_OUTPUT_POLICY }] },
+			generationConfig: {
+				temperature: advisor.temperature ?? .3,
+				maxOutputTokens: advisor.maxTokens ?? 16384,
+				...geminiThinkingParams(advisor)
+			}
+		}),
+		signal: withTimeout(timeoutMs ?? 12e4, signal)
+	});
+	if (!response.ok) throw new Error(`Gemini request failed: ${response.status} ${await response.text()}`);
+	return (await response.json()).candidates?.[0]?.content?.parts?.map((part) => part.text ?? "").join("") ?? "";
+}
+//#endregion
+//#region src/driver.ts
+/**
+* The "driver model": a small internal client that reuses the CURRENT agent's
+* configured provider/model (read from the session's latest `request/header`
+* LlmCallConfig) to (a) deepen the consultation between rounds and (b) write
+* the final conclusion. If no header exists and no `discussion.driverModel`
+* fallback is configured, a static fallback text is used so the pipeline never
+* stalls. Any generation error degrades to the fallback text, never throws.
+*/
+const FALLBACK_DEEPEN_QUESTION = "请基于以上全部讨论，针对仍然存在的分歧、未验证的假设与主要风险，提出一个有深度的后续问题。";
+const FALLBACK_CONCLUSION = "（⚠ 驱动模型未能生成综合结论：请主模型以上述顾问讨论为基础，自行总结共识、分歧与最可靠的行动建议。）";
+const DRIVER_SYSTEM_PROMPT = `
+你是顾问群的主持人（驱动模型）。你的职责：
+1. 阅读项目背景、主模型问题与全部顾问回答；
+2. 提出一个更深入、聚焦的追问，推动讨论走向更细的根因、分歧或行动方案；
+3. 只输出追问本身（一句话，不超过 80 字），不要回答、不要打招呼、不要解释。
+`;
+const CONCLUSION_SYSTEM_PROMPT = `
+你是顾问群的主持人（驱动模型）。请综合全部讨论，输出最终结论：
+- 用 3 段以内：共识、关键分歧（简要列出）、最可靠的行动建议；
+- 不要复述每个顾问的完整回答，只提炼差异与要点。
+`;
+/** Resolve the current agent's model config from the session header, or the config fallback. */
+function resolveDriverSource(sessionLog, driverModel) {
+	if (sessionLog) try {
+		const header = sessionLog.requestHeader();
+		if (header?.config?.provider && header?.config?.model) return {
+			provider: header.config.provider,
+			model: header.config.model
+		};
+	} catch {}
+	if (driverModel?.provider && driverModel?.model) return {
+		provider: driverModel.provider,
+		model: driverModel.model
+	};
+}
+function transcriptOf(session) {
+	return session.messages.filter((message) => message.role !== "system").map((message) => {
+		return `[${message.role === "main" ? "主模型" : message.advisorName ?? message.advisorId ?? "顾问"}]\n${message.content}`;
+	}).join("\n\n").slice(-24e3);
+}
+async function generateWith(ctx, source, system, prompt, signal, timeoutMs = 6e5) {
+	try {
+		const options = {
+			provider: source.provider,
+			model: source.model,
+			system,
+			messages: [createUserMessage({
+				content: [{
+					type: "text",
+					text: prompt
+				}],
+				source: {
+					kind: "plugin",
+					plugin: "dsh-advisor-group"
+				}
+			})],
+			temperature: .7,
+			maxTokens: 2048,
+			signal: withTimeout(timeoutMs, signal)
+		};
+		let text = "";
+		let chunks = 0;
+		let textDeltas = 0;
+		let reasoningDeltas = 0;
+		for await (const chunk of ctx.llm.stream(options)) {
+			chunks += 1;
+			if (chunk.type === "text-delta") {
+				textDeltas += 1;
+				text += chunk.text;
+			} else reasoningDeltas += 1;
+		}
+		const trimmed = text.trim();
+		if (!trimmed) console.warn(`[dsh-advisor-group] 驱动模型空响应（${source.provider}/${source.model}）：chunks=${chunks} textDeltas=${textDeltas} reasoningDeltas=${reasoningDeltas}；建议配置 discussion.driverModel 或提高 maxTokens`);
+		return trimmed || void 0;
+	} catch (error) {
+		if (signal?.aborted) throw error;
+		console.warn(`[dsh-advisor-group] 驱动模型生成失败（${source.provider}/${source.model}）：`, error instanceof Error ? error.message : String(error));
+		return;
+	}
+}
+/** One deepening question for the next round (never throws; returns fallback text). */
+async function generateDeepenQuestion(ctx, session, source, signal, timeoutMs) {
+	if (!source) return FALLBACK_DEEPEN_QUESTION;
+	return await generateWith(ctx, source, DRIVER_SYSTEM_PROMPT, `以下是一轮顾问群的讨论记录：\n\n${transcriptOf(session)}\n\n请给出下一步的深入追问。`, signal, timeoutMs) || "请基于以上全部讨论，针对仍然存在的分歧、未验证的假设与主要风险，提出一个有深度的后续问题。";
+}
+/** Final synthesis after all rounds (never throws; returns fallback text). */
+async function generateConclusion(ctx, session, source, signal, timeoutMs) {
+	if (!source) return FALLBACK_CONCLUSION;
+	return await generateWith(ctx, source, CONCLUSION_SYSTEM_PROMPT, `以下是顾问群全部 ${session.messages.filter((m) => m.role === "advisor").length} 条顾问回答的讨论记录：\n\n${transcriptOf(session)}\n\n请给出综合结论。`, signal, timeoutMs) || "（⚠ 驱动模型未能生成综合结论：请主模型以上述顾问讨论为基础，自行总结共识、分歧与最可靠的行动建议。）";
+}
+//#endregion
+//#region src/session-log.ts
+/**
+* Derive the latest turn/step from the durable session log.
+*
+* ToolRunContext does not expose turn/step directly. The agent loop logs
+* `turn/start` and `step/start` before tool execution, so scanning backwards
+* gives the closest coordinates; fallback to 0 when none exist.
+*/
+function latestTurnStep(log) {
+	const events = log.snapshotEvents();
+	for (let i = events.length - 1; i >= 0; i--) {
+		const event = events[i];
+		if (event.type === "step/start") return {
+			turn: event.data.turn,
+			step: event.data.step
+		};
+		if (event.type === "turn/start") return {
+			turn: event.data.turn,
+			step: 0
+		};
+	}
+	return {
+		turn: 0,
+		step: 0
+	};
+}
+function appendAdvisorStart(log, session) {
+	const { turn, step } = latestTurnStep(log);
+	const advisors = session.advisors.map(({ id, name, avatar }) => avatar === void 0 ? {
+		id,
+		name
+	} : {
+		id,
+		name,
+		avatar
+	});
+	log.append("advisor-group/start", {
+		sessionId: session.id,
+		turn,
+		step,
+		question: session.question,
+		...session.context === void 0 ? {} : { context: session.context },
+		advisors
+	});
+}
+function appendAdvisorMessage(log, sessionId, message) {
+	const { turn, step } = latestTurnStep(log);
+	const data = {
+		sessionId,
+		turn,
+		step,
+		role: message.role,
+		content: message.content,
+		...message.advisorId === void 0 ? {} : { advisorId: message.advisorId },
+		...message.advisorName === void 0 ? {} : { advisorName: message.advisorName },
+		...message.round === void 0 ? {} : { round: message.round },
+		...message.thinking === void 0 ? {} : { thinking: message.thinking },
+		...message.thinkingSegments === void 0 ? {} : { thinkingSegments: message.thinkingSegments },
+		...message.actionDescriptions === void 0 ? {} : { actionDescriptions: message.actionDescriptions },
+		...message.toolSteps === void 0 ? {} : { toolSteps: message.toolSteps },
+		...message.truncated === void 0 ? {} : { truncated: message.truncated }
+	};
+	log.append("advisor-group/message", data);
+}
+function appendAdvisorDelta(log, sessionId, delta) {
+	const { turn, step } = latestTurnStep(log);
+	const data = {
+		sessionId,
+		turn,
+		step,
+		advisorId: delta.advisorId,
+		...delta.advisorName === void 0 ? {} : { advisorName: delta.advisorName },
+		...delta.round === void 0 ? {} : { round: delta.round },
+		...delta.contentDelta === void 0 ? {} : { contentDelta: delta.contentDelta },
+		...delta.thinkingDelta === void 0 ? {} : { thinkingDelta: delta.thinkingDelta },
+		...delta.toolStep === void 0 ? {} : { toolStep: delta.toolStep },
+		...delta.done === void 0 ? {} : { done: delta.done }
+	};
+	log.append("advisor-group/delta", data);
+}
+function appendAdvisorResume(log, sessionId) {
+	const { turn, step } = latestTurnStep(log);
+	log.append("advisor-group/resume", {
+		sessionId,
+		turn,
+		step
+	});
+}
+function appendAdvisorEnd(log, session, summary) {
+	const { turn, step } = latestTurnStep(log);
+	const data = {
+		sessionId: session.id,
+		turn,
+		step,
+		summary: {
+			question: summary.question,
+			advisors: summary.advisors.map(({ advisorId, advisorName, corePoints }) => ({
+				advisorId,
+				advisorName,
+				corePoints
+			})),
+			...summary.riskNotes.length > 0 ? { riskNotes: summary.riskNotes } : {},
+			...summary.stopped === void 0 ? {} : { stopped: summary.stopped },
+			...summary.conclusion === void 0 ? {} : { conclusion: summary.conclusion }
+		}
+	};
+	log.append("advisor-group/end", data);
+}
+//#endregion
+//#region src/stream-channel.ts
+const BOOT_ID = `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
+const subscribers = /* @__PURE__ */ new Map();
+const buffers = /* @__PURE__ */ new Map();
+const lastIds = /* @__PURE__ */ new Map();
+const REPLAY_LIMIT = 500;
+const BUFFER_TTL_MS = 3e5;
+function pruneBuffer(sessionId, buffer) {
+	const cutoff = Date.now() - BUFFER_TTL_MS;
+	const pruned = buffer.filter((frame) => frame.ts >= cutoff);
+	if (pruned.length === 0) {
+		buffers.delete(sessionId);
+		return [];
+	}
+	buffers.set(sessionId, pruned);
+	return pruned;
+}
+function writeFrame(res, frame) {
+	try {
+		res.write(`id: ${BOOT_ID}:${frame.id}\n${frame.payload}`);
+	} catch {}
+}
+function writeResync(res, reason) {
+	try {
+		res.write(`event: resync\ndata: ${JSON.stringify({ reason })}\n\n`);
+	} catch {}
+}
+function subscribe(sessionId, res, lastEventId = 0, bootId) {
+	const rawBuffer = buffers.get(sessionId);
+	const buffer = rawBuffer ? pruneBuffer(sessionId, rawBuffer) : void 0;
+	const firstBufferedId = buffer?.[0]?.id;
+	if (bootId && bootId !== BOOT_ID) writeResync(res, "restart");
+	else if (lastEventId > 0 && firstBufferedId !== void 0 && lastEventId < firstBufferedId - 1) writeResync(res, "gap");
+	else if (buffer) {
+		for (const frame of buffer) if (frame.id > lastEventId) writeFrame(res, frame);
+	}
+	let set = subscribers.get(sessionId);
+	if (!set) {
+		set = /* @__PURE__ */ new Set();
+		subscribers.set(sessionId, set);
+	}
+	set.add(res);
+	const cleanup = () => {
+		set?.delete(res);
+		if (set?.size === 0) subscribers.delete(sessionId);
+	};
+	res.on("close", cleanup);
+	return cleanup;
+}
+function publish(sessionId, delta) {
+	const id = (lastIds.get(sessionId) ?? 0) + 1;
+	lastIds.set(sessionId, id);
+	const frame = {
+		id,
+		payload: `data: ${JSON.stringify({
+			...delta,
+			eventId: id,
+			bootId: BOOT_ID
+		})}\n\n`,
+		ts: Date.now()
+	};
+	const rawBuffer = buffers.get(sessionId);
+	const buffer = rawBuffer ? pruneBuffer(sessionId, rawBuffer) : [];
+	buffer.push(frame);
+	if (buffer.length > REPLAY_LIMIT) buffer.shift();
+	buffers.set(sessionId, buffer);
+	const set = subscribers.get(sessionId);
+	if (!set || set.size === 0) return;
+	for (const res of set) writeFrame(res, frame);
+}
+//#endregion
+//#region src/advisor-tools.ts
+/** Raw tool-call / DSML markup that some providers echo as plain text instead
+*  of a structured tool call. Observed shapes (deepseek-v4-pro, anthropic
+*  channel):
+*   - plain `<tool_calls>…</tool_calls>` (line-start block)
+*   - piped `<｜｜tool_calls>\n<｜｜DSML｜…` without a closing tag (U+FF5C)
+*   - MID-LINE occurrence: `证据。<tool_calls><invoke name="bash">…` — the
+*     marker is glued to prose, so line-start anchoring alone is NOT enough. */
+const RAW_TOOL_CALL_BLOCK = /<(?:[｜|]{1,2})?(?:tool_calls|DSML)[\s\S]*?<\/(?:[｜|]{1,2})?(?:tool_calls|DSML)\s*>/g;
+/** Unclosed tail: cut from the first marker that is actually a STRUCTURED
+*  block (followed by `<invoke`/`<parameter`/`<｜｜DSML` within the next ~60
+*  chars). An isolated prose/code mention like `` `<tool_calls>` `` is never
+*  followed by those children, so it stays untouched. */
+const RAW_TOOL_CALL_TAIL = /<(?:[｜|]{1,2})?(?:tool_calls|DSML)[\s\S]{0,60}?(?:<invoke|<parameter|<[｜|]{1,2}DSML)[\s\S]*$/g;
+/**
+* Strip raw `<tool_calls>` / piped `<｜｜tool_calls>` / `<｜｜DSML｜` markup from
+* an advisor's final content (line-start OR mid-line, closed or unclosed).
+* Returns the cleaned text; when the content was only leaked tool markup, a
+* short notice replaces it so the bubble is never empty/raw (the thinking
+* panel and tool rows still carry the real substance).
+*/
+function sanitizeAdvisorContent(content) {
+	if (!content.trim()) return content;
+	return content.replace(RAW_TOOL_CALL_BLOCK, "").replace(RAW_TOOL_CALL_TAIL, "").trim() || "（顾问未生成正文：输出仅为工具调用描述，请参考其思维链与工具调用记录。）";
+}
+/** Conservative read-only whitelist for the default advisor tool scope. */
+const READONLY_TOOL_NAMES = /* @__PURE__ */ new Set([
+	"read",
+	"grep",
+	"glob",
+	"web_search",
+	"web_fetch",
+	"scan_discover",
+	"list_imported_sessions"
+]);
+const MAX_TOOL_ROUNDS = 4;
+const TOOL_EXEC_TIMEOUT_MS = 3e4;
+const TOOL_RESULT_MAX_CHARS = 8e3;
+/**
+* Resolve the advisor-visible tool schemas. `agent` (when provided) makes the
+* registry resolve the scoped view — exactly the tools that session's Agent
+* loop serves, honouring presets and restrict() filters.
+*/
+function resolveAdvisorToolSchemas(ctx, agent, mode) {
+	if (mode === "off") return [];
+	const schemas = ctx.tools?.schemas?.(agent) ?? [];
+	let list = schemas;
+	if (mode === "readonly") list = schemas.filter((schema) => typeof schema === "object" && schema !== null && READONLY_TOOL_NAMES.has(schema.name));
+	return list.map((schema) => {
+		const { name, description, parameters } = schema;
+		return {
+			name,
+			...typeof description === "string" ? { description } : {},
+			...parameters === void 0 ? {} : { parameters }
+		};
+	});
+}
+/** Human-readable one-line summary of a tool result (for the thinking panel). */
+function summarizeToolResult(result) {
+	let text = "";
+	if (result.isError) text = `（错误）${result.error?.message ?? "unknown"}`;
+	else {
+		text = (result.content ?? []).map((block) => typeof block === "object" && block !== null && "text" in block && typeof block.text === "string" ? block.text : "").join("").trim();
+		if (!text && result.value !== void 0) try {
+			text = JSON.stringify(result.value);
+		} catch {
+			text = String(result.value);
+		}
+	}
+	return text.length > TOOL_RESULT_MAX_CHARS ? `${text.slice(0, TOOL_RESULT_MAX_CHARS)}…（已截断）` : text;
+}
+/**
+* Execute one tool via the official pipeline (scoped dispatch when `agent` is
+* provided). Returns the model-facing text; never throws.
+*/
+async function executeAdvisorTool(ctx, agent, call, signal) {
+	const tools = ctx.tools;
+	if (!tools?.execute) return "（顾问工具执行不可用：当前环境未提供工具执行服务）";
+	let args = {};
+	try {
+		args = call.argumentsJson ? JSON.parse(call.argumentsJson) : {};
+	} catch {
+		return "（工具参数不是合法 JSON）";
+	}
+	try {
+		return summarizeToolResult(await tools.execute({
+			callId: call.id,
+			name: call.name,
+			arguments: args,
+			...agent === void 0 ? {} : { agent },
+			signal: withTimeout(TOOL_EXEC_TIMEOUT_MS, signal)
+		}));
+	} catch (error) {
+		return `（工具执行失败：${error instanceof Error ? error.message : String(error)}）`;
+	}
+}
+/**
+* Drive the tool-calling loop: stream with `tools` → execute every
+* model-requested call (each step surfaced via `onToolStep` as its own row) →
+* feed a compact "already executed" block back → repeat until the model
+* answers (or MAX_TOOL_ROUNDS, then one final no-tools round to force a text
+* answer).
+*/
+async function runAdvisorToolLoop(tools, streamOnce, executeTool, onToolStep) {
+	let extraContext = "";
+	let truncated;
+	const executedMemo = /* @__PURE__ */ new Map();
+	const executeDeduped = async (call) => {
+		const key = `${call.name}:${call.argumentsJson}`;
+		const cached = executedMemo.get(key);
+		if (cached !== void 0) {
+			console.warn(`[dsh-advisor-group] 同参工具调用去重（复用已执行结果）：${call.name}`);
+			return {
+				outcome: cached,
+				reused: true
+			};
+		}
+		const outcome = await executeTool(call);
+		executedMemo.set(key, outcome);
+		return {
+			outcome,
+			reused: false
+		};
+	};
+	/** Result fed back to the model: capped so extraContext never balloons
+	*  (display rows keep their own 240-char preview). */
+	const capOutcome = (outcome) => outcome.length > 800 ? `${outcome.slice(0, 800)}…` : outcome;
+	for (let round = 0; round < MAX_TOOL_ROUNDS; round += 1) {
+		const result = await streamOnce(tools, extraContext);
+		if (result.toolCalls.length === 0) return {
+			content: result.content,
+			truncated: result.truncated
+		};
+		truncated = result.truncated ?? truncated;
+		const executed = [];
+		for (const call of result.toolCalls) {
+			const argsPreview = call.argumentsJson.length > 120 ? `${call.argumentsJson.slice(0, 120)}…` : call.argumentsJson;
+			onToolStep({
+				kind: "call",
+				name: call.name,
+				text: argsPreview || "无参数"
+			});
+			if (!READONLY_TOOL_NAMES.has(call.name)) console.warn(`[dsh-advisor-group] 顾问调用非只读工具（${call.name}）：`, argsPreview);
+			const { outcome, reused } = await executeDeduped(call);
+			if (outcome.trim()) {
+				const preview = outcome.replace(/\n+/g, " ").slice(0, 240).trim();
+				onToolStep({
+					kind: "result",
+					name: call.name,
+					text: `${reused ? "（复用已执行结果）" : ""}${preview}`
+				});
+			}
+			executed.push(`- ${call.name}${call.argumentsJson ? ` 参数：${call.argumentsJson.slice(0, 200)}` : ""}\n结果：${capOutcome(outcome)}`);
+		}
+		extraContext = `${extraContext}\n\n【顾问已执行工具】\n${executed.join("\n\n")}`;
+	}
+	const final = await streamOnce([], extraContext);
+	if (final.toolCalls.length > 0) {
+		const executed = [];
+		for (const call of final.toolCalls) {
+			const argsPreview = call.argumentsJson.length > 120 ? `${call.argumentsJson.slice(0, 120)}…` : call.argumentsJson;
+			onToolStep({
+				kind: "call",
+				name: call.name,
+				text: argsPreview || "无参数"
+			});
+			if (!READONLY_TOOL_NAMES.has(call.name)) console.warn(`[dsh-advisor-group] 顾问调用非只读工具（${call.name}）：`, argsPreview);
+			const { outcome, reused } = await executeDeduped(call);
+			if (outcome.trim()) {
+				const preview = outcome.replace(/\n+/g, " ").slice(0, 240).trim();
+				onToolStep({
+					kind: "result",
+					name: call.name,
+					text: `${reused ? "（复用已执行结果）" : ""}${preview}`
+				});
+			}
+			executed.push(`- ${call.name}${call.argumentsJson ? ` 参数：${call.argumentsJson.slice(0, 200)}` : ""}\n结果：${capOutcome(outcome)}`);
+		}
+		const final2 = await streamOnce([], `${extraContext}\n\n【顾问已执行工具】\n${executed.join("\n\n")}`);
+		return {
+			content: final2.content,
+			truncated: final2.truncated ?? final.truncated ?? truncated
+		};
+	}
+	return {
+		content: final.content,
+		truncated: final.truncated ?? truncated
+	};
+}
+//#endregion
+//#region src/service.ts
+function isAbortError(error, signal) {
+	if (signal?.aborted) return true;
+	return error instanceof Error && error.name === "AbortError";
+}
+const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+/** Real consult ids are server-minted uuids; anything else is rejected. */
+function isSafeConsultId(id) {
+	return UUID_RE.test(id);
+}
+/** Agent DSH session ids look like `session-<uuid>` or a plain uuid. */
+function isSafeDshSessionId(id) {
+	return UUID_RE.test(id) || UUID_RE.test(id.replace(/^session-/i, ""));
+}
+function extractUserMessageText(event) {
+	if (event.type !== "user/message") return null;
+	const data = event.data;
+	if (!data?.content) return null;
+	const text = data.content.filter((part) => part.type === "text" && typeof part.text === "string").map((part) => part.text).join(" ").trim();
+	return text.length > 0 ? text : null;
+}
+var AdvisorGroupService = class {
+	ctx;
+	sessions = /* @__PURE__ */ new Map();
+	repeatTracker = /* @__PURE__ */ new Map();
+	persistEnabledCallback;
+	dailyConsultationDate = "";
+	dailyConsultationCount = 0;
+	/** Durable daily-guard counter fixture under the DSH home storage area. */
+	dailyGuardPath;
+	dailyWriteChain = Promise.resolve();
+	/** Per-session stop controllers for the auto-deepen pipeline. */
+	activeAborts = /* @__PURE__ */ new Map();
+	/** Durable consultation snapshots (usable after a dsh restart). */
+	sessionsDir;
+	sessionWriteChain = Promise.resolve();
+	enabled;
+	config;
+	constructor(ctx, config) {
+		this.ctx = ctx;
+		this.config = config;
+		this.enabled = config.enabled;
+		const dshHome = process.env.DSH_HOME || join(homedir(), ".dsh");
+		this.dailyGuardPath = join(dshHome, "storages", "advisor-group", "daily-guard.json");
+		this.sessionsDir = join(dshHome, "storages", "advisor-group", "sessions");
+		this.loadDailyGuard();
+		this.loadStoredSessions();
+		ctx.on("session/event", (session, event) => {
+			const text = extractUserMessageText(event);
+			if (!text) return;
+			const tracked = this.repeatTracker.get(session.id);
+			if (!tracked || tracked.text !== text) this.repeatTracker.set(session.id, {
+				text,
+				count: 1
+			});
+			else tracked.count += 1;
+		});
+	}
+	loadDailyGuard() {
+		try {
+			const parsed = JSON.parse(readFileSync(this.dailyGuardPath, "utf8"));
+			if (typeof parsed.date === "string" && typeof parsed.count === "number" && Number.isSafeInteger(parsed.count) && parsed.count >= 0) {
+				this.dailyConsultationDate = parsed.date;
+				this.dailyConsultationCount = parsed.count;
+			}
+		} catch {}
+	}
+	/** Serialized, atomic (tmp + rename) daily-guard persistence; never blocks a consultation. */
+	persistDailyGuard() {
+		const payload = JSON.stringify({
+			date: this.dailyConsultationDate,
+			count: this.dailyConsultationCount
+		});
+		this.dailyWriteChain = this.dailyWriteChain.then(async () => {
+			await promises.mkdir(dirname(this.dailyGuardPath), { recursive: true });
+			const tmp = `${this.dailyGuardPath}.tmp`;
+			await promises.writeFile(tmp, payload, "utf8");
+			await promises.rename(tmp, this.dailyGuardPath);
+		}).catch((error) => {
+			console.warn("[dsh-advisor-group] 每日护栏持久化失败：", error instanceof Error ? error.message : String(error));
+		});
+	}
+	/**
+	* Restore interrupted consultations from durable snapshots so the card's
+	* 「▶ 继续聊天」 button still works after a dsh restart. Completed sessions
+	* are not restored (they cannot resume) and their snapshot is cleaned up.
+	*/
+	loadStoredSessions() {
+		let files;
+		try {
+			files = readdirSync(this.sessionsDir).filter((name) => name.endsWith(".json"));
+		} catch {
+			return;
+		}
+		for (const file of files) try {
+			const raw = JSON.parse(readFileSync(join(this.sessionsDir, file), "utf8"));
+			if (raw.version !== 1 || typeof raw.id !== "string" || typeof raw.question !== "string") continue;
+			if (!isSafeConsultId(raw.id)) continue;
+			if (raw.dshSessionId !== void 0 && !isSafeDshSessionId(raw.dshSessionId)) continue;
+			if (raw.status === "completed") {
+				unlinkSync(join(this.sessionsDir, file));
+				continue;
+			}
+			const advisors = this.resolveAdvisors(raw.advisorIds);
+			if (advisors.length === 0) continue;
+			const session = {
+				id: raw.id,
+				status: "cancelled",
+				question: raw.question,
+				context: raw.context,
+				advisors,
+				maxRounds: raw.maxRounds,
+				messages: raw.messages.map((message) => ({
+					role: message.role,
+					advisorId: message.advisorId,
+					advisorName: message.advisorName,
+					content: message.content,
+					thinking: message.thinking,
+					thinkingSegments: message.thinkingSegments,
+					actionDescriptions: message.actionDescriptions,
+					round: message.round,
+					truncated: message.truncated,
+					toolSteps: message.toolSteps,
+					ts: message.ts
+				})),
+				cwd: raw.cwd,
+				dshSessionId: raw.dshSessionId,
+				driverSource: raw.driverSource,
+				stopReason: raw.stopReason,
+				createdAt: raw.createdAt,
+				updatedAt: raw.updatedAt
+			};
+			this.sessions.set(session.id, session);
+		} catch {}
+	}
+	/** Serialization-safe snapshot: advisor identity only, NEVER credentials. */
+	snapshotPayload(session) {
+		return {
+			version: 1,
+			id: session.id,
+			status: session.status,
+			question: session.question,
+			...session.context === void 0 ? {} : { context: session.context },
+			...session.cwd === void 0 ? {} : { cwd: session.cwd },
+			...session.dshSessionId === void 0 ? {} : { dshSessionId: session.dshSessionId },
+			...session.driverSource === void 0 ? {} : { driverSource: session.driverSource },
+			...session.stopReason === void 0 ? {} : { stopReason: session.stopReason },
+			advisorIds: session.advisors.map((advisor) => advisor.id),
+			maxRounds: session.maxRounds,
+			createdAt: session.createdAt,
+			updatedAt: session.updatedAt,
+			messages: session.messages.map((message) => ({
+				role: message.role,
+				...message.advisorId === void 0 ? {} : { advisorId: message.advisorId },
+				...message.advisorName === void 0 ? {} : { advisorName: message.advisorName },
+				content: message.content,
+				...message.thinking === void 0 ? {} : { thinking: message.thinking },
+				...message.thinkingSegments === void 0 ? {} : { thinkingSegments: message.thinkingSegments },
+				...message.actionDescriptions === void 0 ? {} : { actionDescriptions: message.actionDescriptions },
+				...message.round === void 0 ? {} : { round: message.round },
+				...message.truncated === void 0 ? {} : { truncated: message.truncated },
+				...message.toolSteps === void 0 ? {} : { toolSteps: message.toolSteps },
+				ts: message.ts
+			}))
+		};
+	}
+	/** Serialized, atomic (tmp + rename) consultation snapshot persistence. */
+	persistSession(session) {
+		if (!isSafeConsultId(session.id)) {
+			console.warn("[dsh-advisor-group] 拒绝持久化非法会话 id：", session.id);
+			return;
+		}
+		const payload = JSON.stringify(this.snapshotPayload(session));
+		const target = join(this.sessionsDir, `${session.id}.json`);
+		this.sessionWriteChain = this.sessionWriteChain.then(async () => {
+			await promises.mkdir(this.sessionsDir, { recursive: true });
+			const tmp = `${target}.tmp`;
+			await promises.writeFile(tmp, payload, "utf8");
+			await promises.rename(tmp, target);
+		}).catch((error) => {
+			console.warn("[dsh-advisor-group] 咨询快照持久化失败：", error instanceof Error ? error.message : String(error));
+		});
+	}
+	/** Wait for queued durable writes before a host or test tears down storage. */
+	async flushPersistence() {
+		await Promise.all([this.dailyWriteChain, this.sessionWriteChain]);
+	}
+	/** Structural view of the DSH in-memory session store (may be absent). */
+	get sessionStore() {
+		let store;
+		try {
+			store = this.ctx.sessions;
+		} catch {
+			return;
+		}
+		if (!store || typeof store !== "object") return void 0;
+		const typed = store;
+		if (typeof typed.get !== "function" || typeof typed.prepare !== "function" || typeof typed.enter !== "function" || typeof typed.flush !== "function") return;
+		return store;
+	}
+	/** Best-effort durability barrier for the advisor-group log events. */
+	async flushLog(sessionLog) {
+		if (!sessionLog) return;
+		const store = this.sessionStore;
+		if (!store) return;
+		try {
+			await store.flush(sessionLog);
+		} catch {}
+	}
+	/** Build a contiguous seed log from the snapshot (cross-restart resume). */
+	buildSeedEvents(session) {
+		const events = [];
+		let seq = 0;
+		events.push({
+			type: "advisor-group/start",
+			seq: seq++,
+			time: session.createdAt,
+			data: {
+				sessionId: session.id,
+				turn: 0,
+				step: 0,
+				question: session.question,
+				...session.context === void 0 ? {} : { context: session.context },
+				advisors: session.advisors.map(({ id, name, avatar }) => avatar === void 0 ? {
+					id,
+					name
+				} : {
+					id,
+					name,
+					avatar
+				})
+			}
+		});
+		for (const message of session.messages) {
+			if (message.role === "system") continue;
+			events.push({
+				type: "advisor-group/message",
+				seq: seq++,
+				time: message.ts || Date.now(),
+				data: {
+					sessionId: session.id,
+					turn: 0,
+					step: 0,
+					role: message.role,
+					content: message.content,
+					...message.advisorId === void 0 ? {} : { advisorId: message.advisorId },
+					...message.advisorName === void 0 ? {} : { advisorName: message.advisorName },
+					...message.thinking === void 0 ? {} : { thinking: message.thinking },
+					...message.round === void 0 ? {} : { round: message.round },
+					...message.truncated === void 0 ? {} : { truncated: message.truncated }
+				}
+			});
+		}
+		return events;
+	}
+	/**
+	* Obtain the DSH Session handle for durable log events. Prefers the live
+	* store entry (same process). After a restart the store is empty, so the
+	* session is rebuilt with `prepare` + `enter` (append hooks publish events
+	* and the persistence layer picks them up; the session is NOT announced, so
+	* no agent lifecycle reactivation is triggered). Falls back to a detached
+	* `Session.create` (live SSE + snapshot only, no durable log) when neither
+	* works.
+	*/
+	resolveSessionHandle(session) {
+		const store = this.sessionStore;
+		const resumeId = session.dshSessionId !== void 0 && isSafeDshSessionId(session.dshSessionId) ? session.dshSessionId : isSafeConsultId(session.id) ? session.id : "";
+		if (!resumeId) return void 0;
+		const live = store?.get(resumeId);
+		if (live) return live;
+		if (!store) return this.buildDetachedSession(session, resumeId);
+		try {
+			const meta = { cwd: session.cwd !== void 0 && isAbsolute(session.cwd) ? session.cwd : process.cwd() };
+			const prepared = store.prepare(resumeId, {
+				seed: this.buildSeedEvents(session),
+				meta
+			});
+			store.enter(prepared);
+			return prepared;
+		} catch (error) {
+			console.warn("[dsh-advisor-group] 重建会话句柄失败（降级为 detached）：", error instanceof Error ? error.message : String(error));
+			const again = store.get(resumeId);
+			if (again) return again;
+			return this.buildDetachedSession(session, resumeId);
+		}
+	}
+	buildDetachedSession(session, sessionId = session.id) {
+		try {
+			return Session.create(sessionId, this.buildSeedEvents(session), void 0, 0);
+		} catch {
+			return;
+		}
+	}
+	getRepeatPressure(sessionId) {
+		if (!sessionId) return void 0;
+		const tracked = this.repeatTracker.get(sessionId);
+		if (!tracked) return void 0;
+		return {
+			count: tracked.count,
+			text: tracked.text
+		};
+	}
+	getConfig() {
+		return this.config;
+	}
+	setConfig(config) {
+		this.config = config;
+		this.enabled = config.enabled;
+	}
+	isEnabled() {
+		return this.enabled;
+	}
+	setEnabled(enabled) {
+		this.enabled = enabled;
+		this.config = {
+			...this.config,
+			enabled
+		};
+	}
+	setPersistEnabled(callback) {
+		this.persistEnabledCallback = callback;
+	}
+	async toggleEnabled(enabled) {
+		this.setEnabled(enabled);
+		if (this.persistEnabledCallback) try {
+			await this.persistEnabledCallback(enabled);
+		} catch {}
+		return this.enabled;
+	}
+	/**
+	* Current daily-guard facts for display (does NOT increment — read-only).
+	* Rolls the in-memory counter to a new UTC day view without persisting.
+	* `enabled` reflects the configurable cap; `remaining` is -1 when the cap
+	* is disabled (the counter still accumulates for visibility).
+	*/
+	getDailyGuard() {
+		const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+		const used = this.dailyConsultationDate === today ? this.dailyConsultationCount : 0;
+		const enabled = this.config.quota.enabled;
+		const limit = this.config.quota.maxPerDay;
+		return {
+			used,
+			enabled,
+			limit,
+			remaining: enabled ? Math.max(0, limit - used) : -1
+		};
+	}
+	/**
+	* Minimal cost guard: atomically check and increment the per-day new
+	* consultation counter. Node is single-threaded, so doing both inside one
+	* synchronous block closes the TOCTOU window a two-step check would leave.
+	* The cap is configurable (`quota.enabled` / `quota.maxPerDay`); when the
+	* cap is disabled the counter still increments (used for display only).
+	* The counter is persisted (UTC day key) so a harness restart does not
+	* reset the quota; persistence is fire-and-forget after the sync block.
+	*/
+	tryStartConsultation() {
+		const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+		if (this.dailyConsultationDate !== today) {
+			this.dailyConsultationDate = today;
+			this.dailyConsultationCount = 0;
+		}
+		if (this.config.quota.enabled && this.dailyConsultationCount >= this.config.quota.maxPerDay) return {
+			ok: false,
+			reason: "今日顾问咨询次数已达上限，请明天再试，或在设置中调整每日咨询上限。"
+		};
+		this.dailyConsultationCount += 1;
+		this.persistDailyGuard();
+		return { ok: true };
+	}
+	getSession(id) {
+		return this.sessions.get(id);
+	}
+	createSession(question, context, advisorIds = [], cwd, dshSessionId) {
+		const maxAdvisors = this.config.discussion.maxAdvisorsPerCall;
+		const advisors = this.resolveAdvisors(advisorIds).slice(0, maxAdvisors);
+		const now = Date.now();
+		const session = {
+			id: randomUUID(),
+			status: "active",
+			question,
+			context,
+			advisors,
+			maxRounds: this.config.discussion.maxRounds,
+			messages: [{
+				role: "system",
+				content: `顾问群已建立，共 ${advisors.length} 位顾问。`,
+				ts: now
+			}, {
+				role: "main",
+				content: context ? `${context}\n\n${question}` : question,
+				ts: now
+			}],
+			cwd,
+			dshSessionId,
+			createdAt: now,
+			updatedAt: now
+		};
+		if (this.sessions.size >= 100) {
+			const oldest = this.sessions.keys().next().value;
+			if (oldest !== void 0) this.sessions.delete(oldest);
+		}
+		this.sessions.set(session.id, session);
+		this.persistSession(session);
+		this.ctx.emit("advisor-group/session-start", session);
+		return session;
+	}
+	appendFollowUp(sessionId, followUp, sessionLog) {
+		const session = this.sessions.get(sessionId);
+		if (!session) return void 0;
+		const message = {
+			role: "main",
+			content: followUp,
+			ts: Date.now()
+		};
+		session.messages.push(message);
+		session.updatedAt = Date.now();
+		if (sessionLog) appendAdvisorMessage(sessionLog, session.id, message);
+		this.persistSession(session);
+		this.ctx.emit("advisor-group/message", {
+			sessionId: session.id,
+			message
+		});
+		return session;
+	}
+	/**
+	* The next round that still needs work, derived from the durable messages:
+	* when the last round is incomplete (an advisor answered, a later one was
+	* cut by a stop), that round resumes with ONLY the missing advisors; when
+	* it is complete, the next round is fresh. `undefined` means finished.
+	*/
+	nextPendingRound(session) {
+		const advisorMessages = session.messages.filter((message) => message.role === "advisor");
+		const maxRound = advisorMessages.reduce((max, message) => Math.max(max, message.round ?? 1), 0);
+		const advisorCount = Math.max(1, session.advisors.length);
+		if (maxRound === 0) return {
+			round: 1,
+			answeredIds: []
+		};
+		if (maxRound > session.maxRounds) return void 0;
+		const answeredInMax = advisorMessages.filter((message) => (message.round ?? 1) === maxRound).map((message) => message.advisorId ?? "").filter((id) => id !== "");
+		const unique = [...new Set(answeredInMax)];
+		if (unique.length < advisorCount) return {
+			round: maxRound,
+			answeredIds: unique
+		};
+		if (maxRound + 1 > session.maxRounds) return void 0;
+		return {
+			round: maxRound + 1,
+			answeredIds: []
+		};
+	}
+	/** Number of main-model messages: the opening question + all deep-questions. */
+	mainMessageCount(session) {
+		return session.messages.filter((message) => message.role === "main").length;
+	}
+	/** Run exactly one round: every advisor that has NOT answered this round. */
+	async runRoundFrom(session, round, answeredIds, signal, sessionLog, agent) {
+		for (let index = 0; index < session.advisors.length; index++) {
+			const advisor = session.advisors[index];
+			if (answeredIds.includes(advisor.id)) continue;
+			const transcript = this.buildTranscript(session);
+			await this.callAdvisor(session, advisor, transcript, round, index + 1, signal, sessionLog, agent);
+		}
+		session.status = "active";
+		session.updatedAt = Date.now();
+		this.persistSession(session);
+	}
+	async runOneRound(session, signal, sessionLog, agent) {
+		const pending = this.nextPendingRound(session);
+		if (!pending) return;
+		await this.runRoundFrom(session, pending.round, pending.answeredIds, signal, sessionLog, agent);
+	}
+	/**
+	* Auto-deepen pipeline (2026-09-05): one ask_advisors call runs the whole
+	* consultation — up to `maxRounds` rounds, each round being
+	*   [driver deep-question (after the first)] → advisor A → advisor B (sees A)
+	*   → advisor C (sees A+B) → …
+	* and closes with a driver-generated conclusion. The pipeline is synchronous
+	* (SSE keeps the card streaming); `exec.signal` aborts the whole run and the
+	* user may stop it explicitly via `stopConsultation(sessionId)` (POST
+	* /advisor-group/stop) — a stop degrades to a graceful partial summary.
+	*
+	* Resumption: after a stop (or a dsh restart that restored the snapshot)
+	* `resumeConsultation()` re-enters the SAME pipeline; `nextPendingRound()`
+	* detects the interruption point — a partially-answered round is completed
+	* with only the missing advisors (the deep-question is NOT regenerated for
+	* that round), then remaining rounds run as usual.
+	*/
+	async runAutoPipeline(session, signal, sessionLog, agent) {
+		const stop = new AbortController();
+		this.activeAborts.set(session.id, stop);
+		const combined = signal ? AbortSignal.any([signal, stop.signal]) : stop.signal;
+		if (!session.driverSource) {
+			const source = resolveDriverSource(sessionLog, this.config.discussion.driverModel);
+			if (source) {
+				session.driverSource = source;
+				this.persistSession(session);
+			}
+		}
+		try {
+			while (true) {
+				const pending = this.nextPendingRound(session);
+				if (!pending) break;
+				const freshRound = pending.answeredIds.length === 0;
+				const questionAlreadyAsked = this.mainMessageCount(session) >= pending.round;
+				if (pending.round > 1 && freshRound && this.config.discussion.autoDeepen && !questionAlreadyAsked) {
+					const question = await generateDeepenQuestion(this.ctx, session, session.driverSource ?? resolveDriverSource(sessionLog, this.config.discussion.driverModel), combined, this.config.discussion.driverTimeoutMs);
+					this.appendMainMessage(session, question, sessionLog);
+				}
+				await this.runRoundFrom(session, pending.round, pending.answeredIds, combined, sessionLog, agent);
+			}
+			session.status = "completed";
+			session.stopReason = void 0;
+			const summary = await this.generateFinalSummary(session, combined, sessionLog, false);
+			this.persistSession(session);
+			await this.flushLog(sessionLog);
+			return summary;
+		} catch (error) {
+			if (isAbortError(error, combined) || stop.signal.aborted) {
+				if (stop.signal.aborted) session.stopReason = "user-stop";
+				else if (signal?.aborted) session.stopReason = "exec-cancel";
+				else session.stopReason = "abort-error";
+				session.status = "cancelled";
+				this.persistSession(session);
+				const summary = await this.generateFinalSummary(session, void 0, sessionLog, true);
+				await this.flushLog(sessionLog);
+				return summary;
+			}
+			throw error;
+		} finally {
+			this.activeAborts.delete(session.id);
+		}
+	}
+	/**
+	* User-initiated stop: aborts the in-flight consultation pipeline. Returns
+	* whether a running consultation was found and aborted.
+	*/
+	stopConsultation(sessionId) {
+		const stop = this.activeAborts.get(sessionId);
+		if (!stop) return false;
+		stop.abort();
+		return true;
+	}
+	/**
+	* Resume a stopped/interrupted consultation from its interruption point.
+	* Works for a user stop (live session) and after a dsh restart (snapshot
+	* restored; the DSH session handle is rebuilt via `prepare` + `enter`).
+	* Returns immediately; the pipeline runs in the background and streams over
+	* the existing SSE channel, then closes with a fresh `advisor-group/end`.
+	*/
+	resumeConsultation(sessionId) {
+		const session = this.sessions.get(sessionId);
+		if (!session) return {
+			ok: false,
+			reason: "咨询会话不存在或已过期，请重新发起咨询。"
+		};
+		if (this.activeAborts.has(sessionId)) return {
+			ok: false,
+			reason: "该咨询正在运行中，无需继续。"
+		};
+		if (session.status === "completed" || this.nextPendingRound(session) === void 0) return {
+			ok: false,
+			reason: "该咨询已完成，无需继续。"
+		};
+		if (session.advisors.length === 0) return {
+			ok: false,
+			reason: "恢复失败：当前配置无法匹配该咨询的原顾问（顾问配置可能已被修改）。"
+		};
+		if (!this.acquireResumeLock(session.id)) return {
+			ok: false,
+			reason: "该咨询正在另一实例中恢复，请稍后再试（若确认无其他实例运行，10 分钟后会自动接管该锁）。"
+		};
+		const dshSession = this.resolveSessionHandle(session);
+		const agentRegistry = this.ctx.agents;
+		const resumeAgent = session.dshSessionId !== void 0 && agentRegistry?.get ? agentRegistry.get(session.dshSessionId) : void 0;
+		session.status = "active";
+		session.stopReason = void 0;
+		session.updatedAt = Date.now();
+		this.persistSession(session);
+		if (dshSession) appendAdvisorResume(dshSession, session.id);
+		this.ctx.emit("advisor-group/resume", { sessionId: session.id });
+		this.runAutoPipeline(session, void 0, dshSession, resumeAgent).catch(() => {}).finally(() => this.releaseResumeLock(session.id));
+		return { ok: true };
+	}
+	/** Atomic cross-instance lock (mkdir-based, with stale takeover). */
+	acquireResumeLock(sessionId) {
+		const lockDir = join(this.sessionsDir, `${sessionId}.lock`);
+		try {
+			mkdirSync(this.sessionsDir, { recursive: true });
+			mkdirSync(lockDir);
+			try {
+				writeFileSync(join(lockDir, "owner"), String(process.pid), "utf8");
+			} catch {}
+			return true;
+		} catch {
+			try {
+				const stat = statSync(lockDir);
+				if (Date.now() - stat.mtimeMs > 6e5) {
+					rmSync(lockDir, {
+						recursive: true,
+						force: true
+					});
+					mkdirSync(lockDir);
+					return true;
+				}
+			} catch {}
+			return false;
+		}
+	}
+	releaseResumeLock(sessionId) {
+		try {
+			rmSync(join(this.sessionsDir, `${sessionId}.lock`), {
+				recursive: true,
+				force: true
+			});
+		} catch {}
+	}
+	async generateFinalSummary(session, signal, sessionLog, stopped) {
+		session.updatedAt = Date.now();
+		const summary = this.buildSummary(session, stopped);
+		const conclusion = stopped ? "" : await generateConclusion(this.ctx, session, session.driverSource ?? resolveDriverSource(sessionLog, this.config.discussion.driverModel), signal, this.config.discussion.driverTimeoutMs);
+		const finalSummary = stopped ? {
+			...summary,
+			stopped: true
+		} : {
+			...summary,
+			conclusion
+		};
+		if (sessionLog) appendAdvisorEnd(sessionLog, session, finalSummary);
+		this.ctx.emit("advisor-group/session-end", {
+			sessionId: session.id,
+			summary: finalSummary
+		});
+		return finalSummary;
+	}
+	appendMainMessage(session, content, sessionLog) {
+		const message = {
+			role: "main",
+			content,
+			ts: Date.now()
+		};
+		session.messages.push(message);
+		if (sessionLog) appendAdvisorMessage(sessionLog, session.id, message);
+		this.persistSession(session);
+		this.ctx.emit("advisor-group/message", {
+			sessionId: session.id,
+			message
+		});
+	}
+	/**
+	* Run exactly ONE discussion round: the main model's question -> each
+	* advisor answers once. Cross-advisor discussion is driven by the main model
+	* calling ask_advisors again with sessionId + followUp, never by the
+	* advisor models talking to themselves back-to-back.
+	*/
+	async runOneRoundAndSummarize(session, signal, sessionLog, agent) {
+		await this.runOneRound(session, signal, sessionLog, agent);
+		session.status = "completed";
+		session.updatedAt = Date.now();
+		const summary = this.buildSummary(session, false);
+		if (sessionLog) appendAdvisorEnd(sessionLog, session, summary);
+		this.persistSession(session);
+		await this.flushLog(sessionLog);
+		this.ctx.emit("advisor-group/session-end", {
+			sessionId: session.id,
+			summary
+		});
+		return summary;
+	}
+	getRoundCount(session) {
+		const advisorCount = Math.max(1, session.advisors.length);
+		return Math.floor(session.messages.filter((message) => message.role === "advisor").length / advisorCount);
+	}
+	hasReachedMaxRounds(session) {
+		const maxRounds = Math.max(1, session.maxRounds);
+		return this.getRoundCount(session) >= maxRounds;
+	}
+	resolveAdvisors(advisorIds) {
+		if (advisorIds.length === 0) return this.config.advisors;
+		return this.config.advisors.filter((advisor) => advisorIds.includes(advisor.id));
+	}
+	buildTranscript(session) {
+		return session.messages.filter((message) => message.role !== "system").slice(-12).map((message) => {
+			if (message.role === "main") return {
+				role: "main",
+				name: "主模型",
+				content: message.content.slice(0, 3e3)
+			};
+			if (message.role === "advisor" && message.advisorName) return {
+				role: "advisor",
+				name: message.advisorName,
+				content: message.content.slice(0, 3e3)
+			};
+			return null;
+		}).filter((entry) => entry !== null);
+	}
+	async callAdvisor(session, advisor, transcript, round, joinIndex, signal, sessionLog, agent) {
+		const relational = { ...advisor };
+		relational.systemPrompt = `${advisor.systemPrompt}\n${advisorJoinPrompt(joinIndex, session.advisors.length)}`;
+		const message = {
+			role: "advisor",
+			advisorId: advisor.id,
+			advisorName: advisor.name,
+			content: "",
+			round,
+			ts: Date.now()
+		};
+		try {
+			let content;
+			let isDshLlmProvider = false;
+			try {
+				isDshLlmProvider = this.ctx.llm.listProviders().some((item) => item.id === advisor.provider);
+			} catch {}
+			let pendingText = "";
+			let pendingThinking = "";
+			let timer = null;
+			const flush = () => {
+				if (timer) {
+					clearTimeout(timer);
+					timer = null;
+				}
+				if (!pendingText && !pendingThinking) return;
+				if (sessionLog) appendAdvisorDelta(sessionLog, session.id, {
+					sessionId: session.id,
+					advisorId: advisor.id,
+					advisorName: advisor.name,
+					round,
+					contentDelta: pendingText || void 0,
+					thinkingDelta: pendingThinking || void 0,
+					done: false
+				});
+				pendingText = "";
+				pendingThinking = "";
+			};
+			const emitDelta = (delta, phase = "answer") => {
+				if (delta.text) {
+					message.content += delta.text;
+					pendingText += delta.text;
+				}
+				if (delta.thinking) {
+					message.thinking = (message.thinking ?? "") + delta.thinking;
+					thinkingBuffer += delta.thinking;
+					pendingThinking += delta.thinking;
+				}
+				publish(session.id, {
+					advisorId: advisor.id,
+					advisorName: advisor.name,
+					round,
+					phase,
+					contentDelta: delta.text,
+					thinkingDelta: delta.thinking,
+					done: false
+				});
+				if (!timer) timer = setTimeout(flush, 200);
+			};
+			const advisorTimeoutMs = this.config.discussion.advisorTimeoutMs;
+			let truncated;
+			const thinkingSegments = [];
+			let thinkingBuffer = "";
+			const actionDescriptions = [];
+			if (!isDshLlmProvider || advisor.baseURL || advisor.apiKey || advisor.apiKeyEnv) {
+				const toolMode = advisor.tools ?? this.config.discussion.advisorTools ?? "readonly";
+				const toolSchemas = resolveAdvisorToolSchemas(this.ctx, agent, toolMode);
+				if (toolSchemas.length > 0) {
+					relational.systemPrompt = `${relational.systemPrompt}${ADVISOR_TOOL_GUIDANCE}`;
+					const messageToolSteps = [];
+					let narrationBuffer = "";
+					const emitToolStep = (step) => {
+						const full = {
+							...step,
+							atMs: Date.now()
+						};
+						const parts = [];
+						if (narrationBuffer.trim()) {
+							parts.push(narrationBuffer.trim());
+							narrationBuffer = "";
+						}
+						if (thinkingBuffer.trim()) parts.push(thinkingBuffer);
+						if (parts.length > 0) {
+							thinkingSegments.push(parts.join("\n\n"));
+							thinkingBuffer = "";
+						}
+						messageToolSteps.push(full);
+						if (sessionLog) appendAdvisorDelta(sessionLog, session.id, {
+							sessionId: session.id,
+							advisorId: advisor.id,
+							advisorName: advisor.name,
+							round,
+							toolStep: full
+						});
+						publish(session.id, {
+							advisorId: advisor.id,
+							advisorName: advisor.name,
+							round,
+							toolStep: full
+						});
+					};
+					const streamOnce = (tools, extra) => {
+						const withExtra = extra.trim() ? [...transcript, {
+							role: "main",
+							name: "已执行工具",
+							content: extra.trim()
+						}] : transcript;
+						const parseNames = toolSchemas.map((tool) => tool.name);
+						const emitRoundDelta = (delta) => emitDelta(delta, tools.length > 0 ? "tool" : "answer");
+						return streamDirectHttp(relational, withExtra, emitRoundDelta, signal, advisorTimeoutMs, tools, parseNames).then((result) => {
+							narrationBuffer = result.content.trim();
+							if (tools.length > 0 && narrationBuffer) actionDescriptions.push(narrationBuffer);
+							return {
+								content: result.content,
+								thinking: result.thinking,
+								toolCalls: result.toolCalls ?? [],
+								truncated: result.truncated
+							};
+						});
+					};
+					const loop = await runAdvisorToolLoop(toolSchemas, streamOnce, (call) => executeAdvisorTool(this.ctx, agent, call, signal), (step) => emitToolStep(step));
+					flush();
+					content = loop.content;
+					truncated = loop.truncated;
+					message.toolSteps = messageToolSteps;
+				} else {
+					const streamResult = await streamDirectHttp(relational, transcript, emitDelta, signal, advisorTimeoutMs);
+					flush();
+					content = streamResult.content;
+					message.thinking = streamResult.thinking;
+					truncated = streamResult.truncated;
+				}
+			} else {
+				const result = await callViaCtxLlm(this.ctx, relational, transcript, signal, emitDelta, advisorTimeoutMs);
+				flush();
+				content = result.content;
+				truncated = result.truncated;
+			}
+			message.content = sanitizeAdvisorContent(content);
+			if (truncated) message.truncated = truncated;
+			if (thinkingBuffer.trim()) thinkingSegments.push(thinkingBuffer);
+			if (thinkingSegments.length > 0) message.thinkingSegments = thinkingSegments;
+			if (actionDescriptions.length > 0) message.actionDescriptions = actionDescriptions;
+		} catch (error) {
+			if (isAbortError(error, signal)) throw error;
+			message.content = `（顾问调用失败：${error instanceof Error ? error.message : String(error)}）`;
+		}
+		publish(session.id, {
+			advisorId: advisor.id,
+			advisorName: advisor.name,
+			round,
+			done: true
+		});
+		session.messages.push(message);
+		if (sessionLog) appendAdvisorMessage(sessionLog, session.id, message);
+		session.updatedAt = Date.now();
+		this.persistSession(session);
+		this.ctx.emit("advisor-group/message", {
+			sessionId: session.id,
+			message
+		});
+	}
+	buildSummary(session, cancelled = false) {
+		const advisorMessages = session.messages.filter((message) => message.role === "advisor");
+		const byAdvisor = /* @__PURE__ */ new Map();
+		for (const message of advisorMessages) {
+			const list = byAdvisor.get(message.advisorId ?? "") ?? [];
+			list.push(message);
+			byAdvisor.set(message.advisorId ?? "", list);
+		}
+		const advisors = [...byAdvisor.entries()].map(([id, messages]) => {
+			const advisor = session.advisors.find((item) => item.id === id);
+			const meaningful = messages.filter((message) => message.content && message.content.trim() && !message.content.startsWith("（顾问调用失败") && !message.content.startsWith("（顾问未生成正文"));
+			const last = meaningful[meaningful.length - 1] ?? messages[messages.length - 1];
+			return {
+				advisorId: id,
+				advisorName: advisor?.name ?? id,
+				corePoints: last ? this.extractCorePoints(last.content) : []
+			};
+		});
+		const riskNotes = advisorMessages.some((message) => /风险|注意|不确定|risk|uncertain|confidence/i.test(message.content)) ? ["部分顾问提到了风险、不确定性或置信度较低，请主模型谨慎采用。"] : [];
+		if (advisorMessages.some((message) => message.truncated !== void 0)) riskNotes.push("有顾问输出在流式过程中被截断（超时或网络中断），其正文可能不完整，且该顾问本轮可能只提供了部分意见。");
+		if (cancelled) riskNotes.push("本次顾问群讨论已被用户或主模型取消，结论可能不完整。");
+		return {
+			sessionId: session.id,
+			question: session.question,
+			advisors,
+			consensus: [],
+			disagreements: [],
+			riskNotes
+		};
+	}
+	extractCorePoints(content) {
+		return content.split("\n").map((line) => line.trim()).filter(Boolean).slice(0, 5);
+	}
+};
+//#endregion
+//#region src/model-validation.ts
+/**
+* Advisors whose model is empty or whitespace-only.
+*
+* The ask_advisors tool refuses to start a consultation while any advisor is
+* missing a model (fast fail with a precise reason instead of a mid-round
+* failure); the settings card marks the field red in the same condition.
+*/
+function advisorsMissingModel(config) {
+	return (Array.isArray(config) ? config : config.advisors).filter((advisor) => !advisor.model || !advisor.model.trim());
+}
+/** Pure projection used by tests and storage: truncates and normalizes a sample. */
+function formatShadowSample(sample) {
+	return {
+		...sample,
+		ts: Number.isSafeInteger(sample.ts) ? sample.ts : Date.now(),
+		question: sample.question.length > 200 ? `${sample.question.slice(0, 200)}…` : sample.question
+	};
+}
+function shadowLogPath() {
+	const dshHome = process.env.DSH_HOME || join(homedir(), ".dsh");
+	return join(dshHome, "storages", "advisor-group", "classifier-shadow.jsonl");
+}
+let writeChain = Promise.resolve();
+/** Append one shadow sample (serialized; failures degrade to a silent no-op). */
+function appendShadowSample(sample) {
+	const line = `${JSON.stringify(formatShadowSample(sample))}\n`;
+	writeChain = writeChain.then(async () => {
+		const path = shadowLogPath();
+		await promises.mkdir(dirname(path), { recursive: true });
+		await promises.appendFile(path, line, "utf8");
+	}).catch((error) => {
+		console.warn("[dsh-advisor-group] 分类器影子样本写入失败：", error instanceof Error ? error.message : String(error));
+	});
+}
+/** Read the most recent `limit` samples plus lightweight statistics. */
+async function readShadowSamples(limit = 200) {
+	let raw = "";
+	try {
+		raw = await promises.readFile(shadowLogPath(), "utf8");
+	} catch {
+		return {
+			total: 0,
+			escalated: 0,
+			launched: 0,
+			samples: []
+		};
+	}
+	const all = [];
+	for (const line of raw.split("\n")) {
+		if (!line.trim()) continue;
+		try {
+			const parsed = JSON.parse(line);
+			if (typeof parsed.ts !== "number" || typeof parsed.question !== "string") continue;
+			all.push(formatShadowSample(parsed));
+		} catch {}
+	}
+	const tail = all.slice(-Math.max(1, Math.min(limit, 500)));
+	const withConfidence = all.filter((s) => typeof s.confidence === "number");
+	return {
+		total: all.length,
+		escalated: all.filter((s) => s.shouldEscalate).length,
+		launched: all.filter((s) => s.launched).length,
+		...withConfidence.length > 0 ? { avgConfidence: withConfidence.reduce((sum, s) => sum + (s.confidence ?? 0), 0) / withConfidence.length } : {},
+		samples: tail
+	};
+}
+//#endregion
+//#region src/classifier.ts
+const HIGH_RISK_KEYWORDS = [
+	"医疗",
+	"药物",
+	"剂量",
+	"手术",
+	"诊断",
+	"法律",
+	"合同",
+	"诉讼",
+	"合规",
+	"税务",
+	"投资",
+	"理财",
+	"保险",
+	"安全漏洞",
+	"漏洞利用",
+	"核保",
+	"判例",
+	"法条",
+	"责任",
+	"赔偿",
+	"监管",
+	"刑事",
+	"民事",
+	"仲裁",
+	"劳动法",
+	"知识产权"
+];
+const WEB_SEARCH_KEYWORDS = [
+	"最新",
+	"新闻",
+	"天气",
+	"汇率",
+	"股价",
+	"价格",
+	"API文档",
+	"版本",
+	"更新",
+	"公告",
+	"活动",
+	"时间",
+	"日期",
+	"在哪",
+	"怎么下载",
+	"官网",
+	"仓库地址",
+	"当前",
+	"实时",
+	"今日",
+	"本周",
+	"排行",
+	"销量",
+	"行情"
+];
+const WORLD_KNOWLEDGE_KEYWORDS = [
+	"历史",
+	"哲学",
+	"理论",
+	"学派",
+	"文化",
+	"术语",
+	"概念",
+	"原理",
+	"行业惯例",
+	"经验",
+	"经典",
+	"法理",
+	"判例",
+	"方法论",
+	"框架",
+	"最佳实践",
+	"架构评审",
+	"技术选型",
+	"代码审查",
+	"疑难",
+	"根因",
+	"学术",
+	"论文",
+	"研究",
+	"文献",
+	"政策",
+	"制度",
+	"机制",
+	"商业模式",
+	"战略",
+	"组织",
+	"管理",
+	"数学",
+	"证明",
+	"推导",
+	"统计",
+	"回归",
+	"概率",
+	"算法",
+	"复杂度",
+	"优化",
+	"物理",
+	"化学",
+	"生物",
+	"工程",
+	"材料",
+	"量子"
+];
+const DOMAIN_KEYWORDS = [
+	{
+		domain: "legal",
+		keywords: [
+			"法律",
+			"合同",
+			"诉讼",
+			"合规",
+			"税务",
+			"法条",
+			"判例",
+			"责任",
+			"仲裁",
+			"劳动法",
+			"知识产权"
+		]
+	},
+	{
+		domain: "code",
+		keywords: [
+			"代码",
+			"架构",
+			"技术选型",
+			"bug",
+			"调试",
+			"性能",
+			"安全漏洞",
+			"API",
+			"系统设计",
+			"数据库",
+			"前端",
+			"后端",
+			"微服务"
+		]
+	},
+	{
+		domain: "finance",
+		keywords: [
+			"投资",
+			"理财",
+			"金融",
+			"税务",
+			"保险",
+			"估值",
+			"财报",
+			"现金流",
+			"风险",
+			"股票",
+			"基金",
+			"债券"
+		]
+	},
+	{
+		domain: "medical",
+		keywords: [
+			"医疗",
+			"药物",
+			"剂量",
+			"症状",
+			"手术",
+			"疾病",
+			"诊断",
+			"治疗",
+			"康复"
+		]
+	},
+	{
+		domain: "domain",
+		keywords: [
+			"行业惯例",
+			"经验",
+			"历史",
+			"文化",
+			"术语",
+			"概念",
+			"原理",
+			"战略",
+			"商业模式",
+			"组织",
+			"管理"
+		]
+	},
+	{
+		domain: "technical",
+		keywords: [
+			"数学",
+			"证明",
+			"推导",
+			"统计",
+			"回归",
+			"概率",
+			"算法",
+			"复杂度",
+			"优化",
+			"物理",
+			"化学",
+			"生物",
+			"工程",
+			"材料",
+			"量子"
+		]
+	},
+	{
+		domain: "academic",
+		keywords: [
+			"学术",
+			"论文",
+			"研究",
+			"文献",
+			"理论",
+			"方法论"
+		]
+	}
+];
+function classifyRequest(question, context, advisors = [], confidence, confidenceThreshold = .6) {
+	const text = `${question}\n${context ?? ""}`;
+	const lowerText = text.toLowerCase();
+	if (text.includes("@顾问群") || text.includes("@顧問群")) return {
+		shouldEscalate: true,
+		reason: "用户点名顾问群，强制启动顾问咨询。",
+		suggestedAdvisors: matchAdvisors(lowerText, advisors),
+		suggestWebSearch: false
+	};
+	if (HIGH_RISK_KEYWORDS.some((keyword) => lowerText.includes(keyword.toLowerCase()))) return {
+		shouldEscalate: true,
+		reason: "命中高风险关键词，需要专业顾问参与并输出风险提示。",
+		suggestedAdvisors: matchAdvisors(lowerText, advisors),
+		suggestWebSearch: false
+	};
+	if (WORLD_KNOWLEDGE_KEYWORDS.some((keyword) => lowerText.includes(keyword.toLowerCase()))) return {
+		shouldEscalate: true,
+		reason: "命中世界知识/专业经验关键词，适合由顾问模型提供多视角解答。",
+		suggestedAdvisors: matchAdvisors(lowerText, advisors),
+		suggestWebSearch: false
+	};
+	if (typeof confidence === "number" && confidence < confidenceThreshold) return {
+		shouldEscalate: true,
+		reason: `主模型置信度 ${confidence} 低于阈值 ${confidenceThreshold}，建议升级到顾问群。`,
+		suggestedAdvisors: matchAdvisors(lowerText, advisors),
+		suggestWebSearch: false
+	};
+	if (WEB_SEARCH_KEYWORDS.some((keyword) => lowerText.includes(keyword.toLowerCase()))) return {
+		shouldEscalate: false,
+		reason: "该问题更依赖实时/事实信息，建议先联网搜索而不是启动顾问群。",
+		suggestedAdvisors: [],
+		suggestWebSearch: true
+	};
+	return {
+		shouldEscalate: false,
+		reason: "未识别出需要顾问参与的强信号，可由主模型自行处理。",
+		suggestedAdvisors: [],
+		suggestWebSearch: false
+	};
+}
+function matchAdvisors(text, advisors) {
+	if (advisors.length === 0) return [];
+	const matches = /* @__PURE__ */ new Set();
+	const lowerText = text.toLowerCase();
+	for (const advisor of advisors) {
+		const haystack = `${advisor.id} ${advisor.name} ${advisor.systemPrompt}`.toLowerCase();
+		for (const { domain, keywords } of DOMAIN_KEYWORDS) if (haystack.includes(domain)) {
+			if (keywords.some((keyword) => lowerText.includes(keyword.toLowerCase()))) matches.add(advisor.id);
+		}
+		if (lowerText.includes(advisor.name.toLowerCase()) || lowerText.includes(advisor.id.toLowerCase())) matches.add(advisor.id);
+	}
+	return [...matches];
+}
+//#endregion
+//#region src/tools.ts
+function registerAdvisorTools(service) {
+	return [defineTool({
+		name: "ask_advisors",
+		description: "Consult configured expert advisor models when the question is professional, long-tail world knowledge, high-risk, or the main model is uncertain. ALWAYS provide context with (a) a brief overview of the current project and (b) concrete details of the problem, including what has been tried and what went wrong. Also call immediately when the user @顾问群 or repeats the same question three times without resolution. Do NOT use for simple facts that web search can answer. Starting a new consultation runs the auto-deepen pipeline: up to maxRounds rounds of [driver deep-question → advisor A → advisor B (sees A) → advisor C (sees A+B) → …], closed by a driver-generated conclusion.",
+		parameters: {
+			question: {
+				type: "string",
+				description: "The question to ask the advisors. Required when starting a new consultation."
+			},
+			context: {
+				type: "string",
+				description: "Required background: (a) current project overview (domain/goal/stack/constraints) and (b) problem details (steps tried, expected vs actual, errors). Write \"该项背景未知\" for anything unknown; never leave it empty."
+			},
+			sessionId: {
+				type: "string",
+				description: "Existing consultation session id to continue."
+			},
+			followUp: {
+				type: "string",
+				description: "Follow-up question to send to the advisors in an existing session."
+			},
+			advisorIds: {
+				type: "array",
+				items: { type: "string" },
+				description: "Optional advisor ids to include; defaults to all configured advisors (capped by maxAdvisorsPerCall)."
+			},
+			confidence: {
+				type: "number",
+				description: "Optional self-assessed confidence 0-1. Values below the configured threshold escalate even without domain keywords."
+			}
+		},
+		output: {
+			schema: {
+				type: "object",
+				additionalProperties: false,
+				properties: {
+					sessionId: {
+						type: "string",
+						required: true
+					},
+					advice: {
+						type: "string",
+						required: true
+					},
+					skipped: { type: "boolean" },
+					reason: { type: "string" }
+				}
+			},
+			render: (_args, value) => [{
+				type: "text",
+				text: value.advice
+			}]
+		},
+		async execute(args, exec) {
+			const cfg = service.getConfig();
+			if (args.confidence !== void 0 && (args.confidence < 0 || args.confidence > 1)) return {
+				sessionId: "",
+				advice: "confidence 参数必须在 0-1 之间。",
+				skipped: true,
+				reason: "invalid-confidence"
+			};
+			if (!service.isEnabled()) return {
+				sessionId: "",
+				advice: "顾问群插件已禁用。请先调用 toggle_advisor_group 启用。",
+				skipped: true,
+				reason: "disabled"
+			};
+			if (cfg.advisors.length === 0) return {
+				sessionId: "",
+				advice: "顾问群尚未配置任何顾问。请先到 设置 → 插件 → 顾问群 添加顾问。",
+				skipped: true,
+				reason: "no-advisors"
+			};
+			const withoutModel = advisorsMissingModel(cfg);
+			if (withoutModel.length > 0) return {
+				sessionId: "",
+				advice: `顾问群中有 ${withoutModel.length} 位顾问未配置模型（${withoutModel.map((a) => a.name).join("、")}）。请先到 设置 → 插件 → 顾问群 补全模型后再发起，避免整轮调用失败。`,
+				skipped: true,
+				reason: "advisor-model-missing"
+			};
+			const sessionLog = exec.agent?.session;
+			const questionText = typeof args.question === "string" ? args.question : "";
+			const contextText = typeof args.context === "string" ? args.context : "";
+			const mentionedAdvisorGroup = /@顾问群|@顧問群/.test(`${questionText}\n${contextText}`);
+			const forcedByRepeat = (service.getRepeatPressure(sessionLog?.id)?.count ?? 0) >= 3;
+			if (args.sessionId) {
+				if (!args.followUp) return {
+					sessionId: args.sessionId,
+					advice: "继续追问需要提供 followUp 参数。",
+					skipped: true,
+					reason: "missing-follow-up"
+				};
+				const session = service.getSession(args.sessionId);
+				if (!session) return {
+					sessionId: args.sessionId,
+					advice: "顾问群会话不存在或已过期，请重新发起 ask_advisors。",
+					skipped: true,
+					reason: "session-not-found"
+				};
+				if (service.hasReachedMaxRounds(session)) return {
+					sessionId: session.id,
+					advice: "本轮已是顾问群讨论的最后一轮，请综合现有顾问意见给出最终答复，不要再追问。",
+					skipped: true,
+					reason: "max-rounds-reached"
+				};
+				service.appendFollowUp(session.id, args.followUp, sessionLog);
+				await service.runOneRoundAndSummarize(session, exec.signal, sessionLog, exec.agent);
+				const canContinue = !service.hasReachedMaxRounds(session);
+				return {
+					sessionId: session.id,
+					advice: formatConversation(session) + (canContinue ? "\n\n（如需继续，可再次传入 sessionId 和 followUp 追问。）" : "\n\n（讨论轮数已达上限，请综合顾问意见给出最终答复。）"),
+					skipped: false
+				};
+			}
+			if (!args.question) return {
+				sessionId: "",
+				advice: "发起新讨论需要提供 question 参数。",
+				skipped: true,
+				reason: "missing-question"
+			};
+			if (cfg.trigger.requireClassifier && !mentionedAdvisorGroup && !forcedByRepeat) {
+				const classification = classifyRequest(args.question, args.context, cfg.advisors, args.confidence, cfg.trigger.confidenceThreshold);
+				appendShadowSample({
+					ts: Date.now(),
+					question: args.question,
+					...typeof args.confidence === "number" ? { confidence: args.confidence } : {},
+					shouldEscalate: classification.shouldEscalate,
+					reason: classification.reason,
+					suggestWebSearch: classification.suggestWebSearch,
+					launched: classification.shouldEscalate
+				});
+				if (!classification.shouldEscalate) {
+					if (classification.suggestWebSearch && cfg.trigger.allowWebFallback) return {
+						sessionId: "",
+						advice: `前置分类器建议不启动顾问群：${classification.reason}`,
+						skipped: true,
+						reason: "web-search-recommended"
+					};
+					return {
+						sessionId: "",
+						advice: `前置分类器建议不启动顾问群：${classification.reason}`,
+						skipped: true,
+						reason: "classifier-rejected"
+					};
+				}
+			}
+			if (args.advisorIds && args.advisorIds.length > 0) {
+				const configuredIds = new Set(cfg.advisors.map((advisor) => advisor.id));
+				if (args.advisorIds.filter((id) => configuredIds.has(id)).length === 0) return {
+					sessionId: "",
+					advice: "未匹配到任何指定顾问，请检查 advisorIds 是否与设置中的顾问 id 一致。",
+					skipped: true,
+					reason: "no-matching-advisors"
+				};
+			}
+			const costGuard = service.tryStartConsultation();
+			if (!costGuard.ok) return {
+				sessionId: "",
+				advice: costGuard.reason,
+				skipped: true,
+				reason: "daily-limit-reached"
+			};
+			const session = service.createSession(args.question, args.context, args.advisorIds, sessionLog ? sessionLog.header.cwd : void 0, sessionLog ? sessionLog.id : void 0);
+			if (sessionLog) appendAdvisorStart(sessionLog, session);
+			const summary = await service.runAutoPipeline(session, exec.signal, sessionLog, exec.agent);
+			return {
+				sessionId: session.id,
+				advice: formatConversation(session) + (summary.conclusion ? `\n\n【综合结论】\n${summary.conclusion}` : "") + (service.hasReachedMaxRounds(session) ? "\n\n（已达设置的最大讨论轮数，请参考上述顾问意见与综合结论给出最终答复。）" : ""),
+				skipped: false
+			};
+		}
+	}), defineTool({
+		name: "toggle_advisor_group",
+		description: "Enable or disable the advisor group plugin at runtime. Omit enabled to toggle the current state.",
+		parameters: { enabled: {
+			type: "boolean",
+			description: "Optional desired state."
+		} },
+		output: {
+			schema: {
+				type: "object",
+				additionalProperties: false,
+				properties: { enabled: {
+					type: "boolean",
+					required: true
+				} }
+			},
+			render: (_args, value) => [{
+				type: "text",
+				text: `顾问群插件已${value.enabled ? "启用" : "禁用"}。`
+			}]
+		},
+		async execute(args) {
+			const next = typeof args.enabled === "boolean" ? args.enabled : !service.isEnabled();
+			return { enabled: await service.toggleEnabled(next) };
+		}
+	})];
+}
+function formatConversation(session) {
+	const lines = [`顾问群对话（session: ${session.id}）`, ""];
+	for (const message of session.messages) {
+		if (message.role === "system") continue;
+		if (message.role === "main") lines.push(`主模型：${message.content}`);
+		else if (message.role === "advisor") {
+			const truncatedNote = message.truncated === void 0 ? "" : `（顾问输出在流式过程中被截断：${message.truncated.reason === "timeout" ? "超时" : "网络中断"}，正文可能不完整）\n`;
+			const toolNote = message.toolSteps && message.toolSteps.length > 0 ? `${message.toolSteps.map((step) => step.kind === "call" ? `  ⛭ 调用 ${step.name} · ${step.text}` : `  ↳ ${step.text}`).join("\n")}\n` : "";
+			const body = message.content && message.content.trim() ? truncatedNote + toolNote + message.content : truncatedNote + toolNote + (message.thinking && message.thinking.trim() ? `（思维链）\n${message.thinking}` : "（顾问未返回正文）");
+			lines.push(`【${message.advisorName ?? message.advisorId ?? "顾问"}】：${body}`);
+		}
+		lines.push("");
+	}
+	const stopNote = session.status === "cancelled" && session.stopReason ? `（注意：本次咨询被中断（${STOP_REASON_TEXT[session.stopReason] ?? session.stopReason}）；可在对话卡片点击「▶ 继续聊天」从断点续跑。）` : "";
+	lines.push(stopNote);
+	lines.push("（以上是顾问模型与主模型的对话记录，主模型可直接基于其中内容继续思考或追问。）");
+	return lines.join("\n");
+}
+const STOP_REASON_TEXT = {
+	"user-stop": "用户主动停止",
+	"exec-cancel": "宿主取消",
+	"abort-error": "流异常中断",
+	timeout: "顾问响应超时",
+	network: "网络中断"
+};
+//#endregion
+//#region src/settings-api.ts
+function sendJson(res, status, body) {
+	res.writeHead(status, { "content-type": "application/json" });
+	res.end(JSON.stringify(body));
+}
+/** Mask a stored API key so it never leaves the host in plain text. */
+function maskApiKey(apiKey) {
+	if (!apiKey) return apiKey;
+	if (apiKey.length <= 4) return "*".repeat(apiKey.length);
+	return `${"*".repeat(apiKey.length - 4)}${apiKey.slice(-4)}`;
+}
+/**
+* Whether an inbound apiKey is a mask of the previously stored key.
+*
+* Accepts both the current length-preserving mask and the legacy 8-character
+* `****<last4>` mask so an unrefreshed settings page does not overwrite the
+* real key with a mask string after upgrading.
+*/
+function isMaskedApiKey(incoming, previous) {
+	if (!incoming || !previous) return false;
+	if (incoming === maskApiKey(previous)) return true;
+	if (previous.length <= 4) return incoming === "*".repeat(previous.length);
+	return incoming === `****${previous.slice(-4)}`;
+}
+/**
+* Return a copy of the config safe to send to the browser.
+*
+* 0.1.2-rc.1 SecretField convergence: no key material (not even a mask) leaves
+* the host. `apiKey` is returned empty and per-provider presence facts
+* (`configured` + `last4`) ride in `apiKeyMetaByProvider`, so the card can
+* render the official "已配置/未配置" badge and publish new/cleared keys
+* without ever round-tripping a mask.
+*/
+function sanitizeConfig(config) {
+	return {
+		...config,
+		advisors: config.advisors.map((advisor) => {
+			const { apiKeysByProvider: _apiKeysByProvider, clearApiKey: _clearApiKey, apiKeyMetaByProvider: _meta, ...rest } = advisor;
+			const meta = {};
+			for (const [provider, key] of Object.entries(advisor.apiKeysByProvider ?? {})) if (key) meta[provider] = {
+				configured: true,
+				last4: key.slice(-4)
+			};
+			if (advisor.apiKey && advisor.provider) meta[advisor.provider] = {
+				configured: true,
+				last4: advisor.apiKey.slice(-4)
+			};
+			return {
+				...rest,
+				apiKey: "",
+				...Object.keys(meta).length > 0 ? { apiKeyMetaByProvider: meta } : {}
+			};
+		})
+	};
+}
+/** Credential-affecting fields: changing any of these invalidates a stored key. */
+function hasSameCredentialScope(a, b) {
+	return a.provider === b.provider && normalizeBase(a.baseURL ?? "") === normalizeBase(b.baseURL ?? "") && (a.apiKeyEnv ?? "") === (b.apiKeyEnv ?? "") && (a.protocol ?? "openai") === (b.protocol ?? "openai") && (a.authMode ?? "x-api-key") === (b.authMode ?? "x-api-key");
+}
+/**
+* Reconcile inbound advisor config with the currently stored config.
+*
+* SecretField semantics (adopted from the official settings-card model):
+* - `clearApiKey: true` → drop the active key AND this provider's archived
+*   copy (the explicit "清除" action).
+* - An empty/undefined apiKey on the same credential scope → KEEP the stored
+*   key (an empty field never clears; the old mask-echo path is retained as a
+*   defensive fallback only).
+* - A new plain-text key wins and is remembered for the current provider.
+* - Credential scope changed with no new key → restore from per-provider
+*   history when one exists, otherwise the active key is undefined.
+* The transient `clearApiKey` flag is stripped before persistence.
+*/
+function reconcileApiKeys(incoming, previous) {
+	const previousById = new Map(previous.advisors.map((advisor) => [advisor.id, advisor]));
+	return {
+		...incoming,
+		advisors: incoming.advisors.map((advisor) => {
+			const { clearApiKey, ...advisorRest } = advisor;
+			const prev = previousById.get(advisor.id);
+			if (!prev) return {
+				...advisorRest,
+				apiKeysByProvider: advisorRest.apiKeysByProvider ?? {}
+			};
+			const history = { ...prev.apiKeysByProvider ?? {} };
+			if (prev.apiKey && prev.provider) history[prev.provider] = prev.apiKey;
+			const maskedSame = isMaskedApiKey(advisorRest.apiKey ?? void 0, prev.apiKey ?? void 0);
+			const sameScope = hasSameCredentialScope(advisorRest, prev);
+			let nextApiKey;
+			if (clearApiKey === true) {
+				nextApiKey = void 0;
+				if (advisorRest.provider) delete history[advisorRest.provider];
+			} else if (sameScope && maskedSame) nextApiKey = prev.apiKey;
+			else if (advisorRest.apiKey && !isMaskedApiKey(advisorRest.apiKey ?? void 0, prev.apiKey ?? void 0)) {
+				nextApiKey = advisorRest.apiKey;
+				if (advisorRest.provider) history[advisorRest.provider] = advisorRest.apiKey;
+			} else if (!sameScope) nextApiKey = advisorRest.provider ? history[advisorRest.provider] : void 0;
+			else nextApiKey = prev.apiKey;
+			const { apiKeyMetaByProvider: _inputMeta, ...clean } = advisorRest;
+			return {
+				...clean,
+				apiKey: nextApiKey,
+				apiKeysByProvider: history
+			};
+		})
+	};
+}
+function readBody(req, limit = 1048576) {
+	return new Promise((resolve, reject) => {
+		let data = "";
+		req.on("data", (chunk) => {
+			data += String(chunk);
+			if (data.length > limit) {
+				req.destroy();
+				reject(/* @__PURE__ */ new Error("body too large"));
+			}
+		});
+		req.on("end", () => resolve(data));
+		req.on("error", reject);
+	});
+}
+const LOOKUP_KEYS = [
+	"provider",
+	"baseURL",
+	"apiKey",
+	"apiKeyEnv",
+	"protocol",
+	"authMode",
+	"advisorId"
+];
+async function parseLookupParams(req) {
+	const url = new URL(req.url ?? "", "http://localhost");
+	const params = {};
+	for (const key of LOOKUP_KEYS) params[key] = url.searchParams.get(key) ?? "";
+	if (req.method === "POST") {
+		const raw = await readBody(req, 1048576);
+		if (raw) try {
+			const body = JSON.parse(raw);
+			for (const key of LOOKUP_KEYS) if (typeof body[key] === "string") params[key] = body[key];
+		} catch {}
+	}
+	return params;
+}
+const ALLOWED_API_KEY_ENVS = new Set(Object.values(PROVIDER_PRESETS).map((preset) => preset.apiKeyEnv));
+function validateSecurity(input) {
+	const ids = /* @__PURE__ */ new Set();
+	for (const advisor of input.advisors) {
+		if (ids.has(advisor.id)) return `顾问 id 重复：${advisor.id}`;
+		ids.add(advisor.id);
+		if (advisor.baseURL) {
+			const url = advisor.baseURL.trim();
+			if (!(url.startsWith("https://") || url.startsWith("http://127.0.0.1") || url.startsWith("http://localhost"))) return `顾问 ${advisor.id} 的 API 地址仅允许 https:// 或本机 http://127.0.0.1 / http://localhost`;
+		}
+		if (advisor.apiKeyEnv) {
+			const env = advisor.apiKeyEnv.trim();
+			if (!ALLOWED_API_KEY_ENVS.has(env)) return `顾问 ${advisor.id} 的 API Key 不被允许：${env}。请使用预设供应商对应的 API Key。`;
+		}
+	}
+	return null;
+}
+function normalizeBase(baseURL) {
+	return (baseURL ?? "").replace(/\/+$/, "");
+}
+/** Loopback hostnames explicitly permitted for local diagnostic HTTP. */
+const LOOPBACK_HOSTNAMES = /* @__PURE__ */ new Set([
+	"127.0.0.1",
+	"localhost",
+	"::1"
+]);
+/** IPv4 literals in non-public ranges (private, loopback, link-local, CGNAT meta). */
+const NON_PUBLIC_IPV4 = /^(?:10\.|127\.|169\.254\.|172\.(?:1[6-9]|2\d|3[0-1])\.|192\.168\.|0\.)/i;
+/** Well-known cloud metadata endpoints that must never be probed. */
+const METADATA_HOSTNAME = /(?:^|\.)(?:metadata\.google\.internal|metadata\.gcp\.internal|metadata\.azure\.com)$/i;
+function isIpLiteral(host) {
+	return /^\d{1,3}(?:\.\d{1,3}){3}$/.test(host) || host.includes(":");
+}
+/**
+* SSRF guard for the diagnostics endpoints (models list / connection test).
+*
+* Diagnostics accept a client-supplied baseURL at request time, so the same
+* https/loopback rule as `validateSecurity` is enforced HERE as well, plus
+* stricter host rules: no IP literals (private/loopback/link-local/metadata)
+* under https, and no cloud metadata hostnames. The fetch layer additionally
+* refuses redirects (`redirect: 'error'`). DNS-rebinding protection (a domain
+* resolving to an internal address) is out of scope for a local single-user
+* host and is documented as a known limit.
+*
+* @returns the rejection reason, or null when the base URL is acceptable.
+*/
+function assertSafeDiagnosticBase(raw) {
+	const trimmed = (raw ?? "").trim();
+	if (!trimmed) return "缺少 baseURL";
+	let url;
+	try {
+		url = new URL(trimmed);
+	} catch {
+		return "baseURL 不是合法 URL";
+	}
+	const host = url.hostname.toLowerCase();
+	if (url.protocol === "https:") {
+		if (isIpLiteral(host) || NON_PUBLIC_IPV4.test(host)) return "baseURL 不允许使用 IP 字面量";
+		if (METADATA_HOSTNAME.test(host)) return "baseURL 不允许访问云元数据地址";
+		return null;
+	}
+	if (url.protocol === "http:" && LOOPBACK_HOSTNAMES.has(host)) return null;
+	return "baseURL 仅允许 https:// 或本机 http://127.0.0.1 / http://localhost";
+}
+/**
+* Resolve the real API key for diagnostics (models list / connection test).
+*
+* The browser form can only ever hold a masked or empty key, so a direct
+* pass-through would send `****xxxx` (or nothing) to the provider and fail
+* with HTTP 401 — exactly what happens after switching a provider away and
+* back. The host keeps the real key (`advisor.apiKey` for the active scope +
+* `apiKeysByProvider` history), so when the inbound key is empty or a mask of
+* the stored key, substitute the stored one. A fresh plaintext key typed into
+* the form always wins.
+*/
+function resolveDiagnosticApiKey(service, advisorId, provider, baseURL, apiKeyEnv, protocol, incomingApiKey) {
+	if (!advisorId) return incomingApiKey;
+	const stored = service.getConfig().advisors.find((advisor) => advisor.id === advisorId);
+	if (!stored) return incomingApiKey;
+	const storedKey = stored.provider === provider && normalizeBase(stored.baseURL ?? "") === normalizeBase(baseURL) && (stored.apiKeyEnv ?? "") === apiKeyEnv && (stored.protocol ?? "openai") === (protocol || "openai") ? stored.apiKey : stored.apiKeysByProvider?.[provider];
+	if (!storedKey) return incomingApiKey;
+	if (!incomingApiKey || isMaskedApiKey(incomingApiKey, storedKey)) return storedKey;
+	return incomingApiKey;
+}
+async function queryOpenAiModels(baseURL, apiKey) {
+	const base = normalizeBase(baseURL);
+	const endpoint = base.endsWith("/models") ? base : `${base}/models`;
+	const response = await fetch(endpoint, {
+		headers: { authorization: `Bearer ${apiKey}` },
+		signal: AbortSignal.timeout(15e3),
+		redirect: "error"
+	});
+	if (!response.ok) throw new Error(`HTTP ${response.status}`);
+	return ((await response.json()).data ?? []).map((item) => item.id ?? "").filter(Boolean);
+}
+async function queryAnthropicModels(baseURL, apiKey, authMode = "x-api-key") {
+	const base = normalizeBase(baseURL);
+	const endpoint = base.endsWith("/v1/models") ? base : base.endsWith("/v1") ? `${base}/models` : `${base}/v1/models`;
+	const headers = { "anthropic-version": "2023-06-01" };
+	if (authMode === "bearer") headers["authorization"] = `Bearer ${apiKey}`;
+	else headers["x-api-key"] = apiKey;
+	const response = await fetch(endpoint, {
+		headers,
+		signal: AbortSignal.timeout(15e3),
+		redirect: "error"
+	});
+	if (!response.ok) throw new Error(`HTTP ${response.status}`);
+	return ((await response.json()).data ?? []).map((item) => item.id ?? "").filter(Boolean);
+}
+async function queryGeminiModels(baseURL, apiKey) {
+	const base = normalizeBase(baseURL);
+	const endpoint = base.endsWith("/v1beta") ? `${base}/models?key=${apiKey}` : `${base}/v1beta/models?key=${apiKey}`;
+	const response = await fetch(endpoint, {
+		signal: AbortSignal.timeout(15e3),
+		redirect: "error"
+	});
+	if (!response.ok) throw new Error(`HTTP ${response.status}`);
+	return ((await response.json()).models ?? []).map((item) => (item.name ?? "").replace(/^models\//, "")).filter(Boolean);
+}
+async function handleModelsRequest(ctx, service, req, res) {
+	const params = await parseLookupParams(req);
+	const provider = params.provider ?? "";
+	const baseURL = params.baseURL ?? "";
+	const apiKey = params.apiKey ?? "";
+	const apiKeyEnv = params.apiKeyEnv ?? "";
+	const protocol = params.protocol ?? "openai";
+	const advisorId = params.advisorId ?? "";
+	if (!provider) {
+		sendJson(res, 400, {
+			ok: false,
+			error: "缺少 provider 参数"
+		});
+		return;
+	}
+	try {
+		if ((await ctx.llm.listProviders()).some((item) => item.id === provider)) {
+			sendJson(res, 200, {
+				ok: true,
+				models: (await ctx.llm.listModels(provider)).map((item) => item.id)
+			});
+			return;
+		}
+	} catch {}
+	const preset = Object.values(PROVIDER_PRESETS).find((item) => item.id === provider);
+	const effectiveBase = normalizeBase(baseURL || preset?.baseURL);
+	const effectiveEnv = apiKeyEnv || preset?.apiKeyEnv || "";
+	const effectiveProtocol = protocol || preset?.protocol || "openai";
+	const effectiveAuthMode = preset?.authMode ?? "x-api-key";
+	const fetchBase = normalizeBase(preset?.modelsBaseURL || effectiveBase);
+	const fetchProtocol = preset?.modelsBaseURL ? "openai" : effectiveProtocol;
+	const fetchAuthMode = preset?.modelsAuthMode ?? (preset?.modelsBaseURL ? "bearer" : effectiveAuthMode);
+	if (!effectiveBase || !apiKey && !effectiveEnv) {
+		sendJson(res, 400, {
+			ok: false,
+			error: "该预设缺少 baseURL 或 API Key"
+		});
+		return;
+	}
+	if (!apiKey && effectiveEnv && !ALLOWED_API_KEY_ENVS.has(effectiveEnv)) {
+		sendJson(res, 400, {
+			ok: false,
+			error: "API Key 不能使用该环境变量名"
+		});
+		return;
+	}
+	const baseError = assertSafeDiagnosticBase(effectiveBase);
+	if (baseError) {
+		sendJson(res, 400, {
+			ok: false,
+			error: baseError
+		});
+		return;
+	}
+	const resolvedApiKey = resolveDiagnosticApiKey(service, advisorId, provider, baseURL, apiKeyEnv, protocol, apiKey) || (effectiveEnv ? process.env[effectiveEnv] ?? "" : "");
+	if (!resolvedApiKey) {
+		sendJson(res, 400, {
+			ok: false,
+			error: "API Key 未设置"
+		});
+		return;
+	}
+	try {
+		let models = [];
+		if (fetchProtocol === "anthropic") models = await queryAnthropicModels(fetchBase, resolvedApiKey, fetchAuthMode);
+		else if (fetchProtocol === "gemini") models = await queryGeminiModels(fetchBase, resolvedApiKey);
+		else models = await queryOpenAiModels(fetchBase, resolvedApiKey);
+		sendJson(res, 200, {
+			ok: true,
+			models
+		});
+	} catch (error) {
+		sendJson(res, 400, {
+			ok: false,
+			error: error instanceof Error ? error.message : String(error)
+		});
+	}
+}
+async function handleTestConnectionRequest(ctx, service, req, res) {
+	const params = await parseLookupParams(req);
+	const provider = params.provider ?? "";
+	const baseURL = params.baseURL ?? "";
+	const apiKey = params.apiKey ?? "";
+	const apiKeyEnv = params.apiKeyEnv ?? "";
+	const protocol = params.protocol ?? "openai";
+	const advisorId = params.advisorId ?? "";
+	if (!provider) {
+		sendJson(res, 400, {
+			ok: false,
+			error: "缺少 provider 参数"
+		});
+		return;
+	}
+	try {
+		if ((await ctx.llm.listProviders()).some((item) => item.id === provider)) {
+			sendJson(res, 200, {
+				ok: true,
+				message: "连接成功",
+				modelCount: (await ctx.llm.listModels(provider)).length
+			});
+			return;
+		}
+	} catch {}
+	const preset = Object.values(PROVIDER_PRESETS).find((item) => item.id === provider);
+	const effectiveBase = normalizeBase(baseURL || preset?.baseURL);
+	const effectiveEnv = apiKeyEnv || preset?.apiKeyEnv || "";
+	const effectiveProtocol = protocol || preset?.protocol || "openai";
+	const effectiveAuthMode = preset?.authMode ?? "x-api-key";
+	const fetchBase = normalizeBase(preset?.modelsBaseURL || effectiveBase);
+	const fetchProtocol = preset?.modelsBaseURL ? "openai" : effectiveProtocol;
+	const fetchAuthMode = preset?.modelsAuthMode ?? (preset?.modelsBaseURL ? "bearer" : effectiveAuthMode);
+	if (!effectiveBase || !apiKey && !effectiveEnv) {
+		sendJson(res, 400, {
+			ok: false,
+			error: "该预设缺少 baseURL 或 API Key"
+		});
+		return;
+	}
+	if (!apiKey && effectiveEnv && !ALLOWED_API_KEY_ENVS.has(effectiveEnv)) {
+		sendJson(res, 400, {
+			ok: false,
+			error: "API Key 不能使用该环境变量名"
+		});
+		return;
+	}
+	const baseError = assertSafeDiagnosticBase(effectiveBase);
+	if (baseError) {
+		sendJson(res, 400, {
+			ok: false,
+			error: baseError
+		});
+		return;
+	}
+	const resolvedApiKey = resolveDiagnosticApiKey(service, advisorId, provider, baseURL, apiKeyEnv, protocol, apiKey) || (effectiveEnv ? process.env[effectiveEnv] ?? "" : "");
+	if (!resolvedApiKey) {
+		sendJson(res, 400, {
+			ok: false,
+			error: "API Key 未设置"
+		});
+		return;
+	}
+	try {
+		let models = [];
+		if (fetchProtocol === "anthropic") models = await queryAnthropicModels(fetchBase, resolvedApiKey, fetchAuthMode);
+		else if (fetchProtocol === "gemini") models = await queryGeminiModels(fetchBase, resolvedApiKey);
+		else models = await queryOpenAiModels(fetchBase, resolvedApiKey);
+		sendJson(res, 200, {
+			ok: true,
+			message: "连接成功",
+			modelCount: models.length
+		});
+	} catch (error) {
+		sendJson(res, 400, {
+			ok: false,
+			error: error instanceof Error ? error.message : String(error)
+		});
+	}
+}
+function currentRevision(scopedCtx, namespace) {
+	return scopedCtx.settings.describe().find((descriptor) => descriptor.ns === namespace)?.revision ?? 0;
+}
+function handleStreamRequest(req, res) {
+	const url = new URL(req.url ?? "", "http://localhost");
+	const sessionId = url.searchParams.get("sessionId") ?? "";
+	if (!sessionId) {
+		res.writeHead(400, { "content-type": "application/json" });
+		res.end(JSON.stringify({
+			ok: false,
+			error: "缺少 sessionId"
+		}));
+		return Promise.resolve();
+	}
+	const lastEventIdRaw = url.searchParams.get("lastEventId") ?? req.headers["last-event-id"] ?? "0";
+	const lastEventId = Number.parseInt(String(lastEventIdRaw), 10) || 0;
+	const bootId = url.searchParams.get("bootId") ?? void 0;
+	res.writeHead(200, {
+		"content-type": "text/event-stream",
+		"cache-control": "no-cache",
+		connection: "keep-alive",
+		"access-control-allow-origin": "*",
+		"x-accel-buffering": "no"
+	});
+	res.write(": connected\n\n");
+	return new Promise((resolve) => {
+		res.on("close", resolve);
+		subscribe(sessionId, res, lastEventId, bootId);
+	});
+}
+function handleConfigRequest(ctx, scopedCtx, service, authToken) {
+	const namespace = "advisor-group";
+	return async (req, res) => {
+		const rawUrl = req.url ?? "";
+		const url = new URL(rawUrl, "http://localhost");
+		const pathname = url.pathname.replace(/\/+$/, "") || "/";
+		const token = String(req.headers["x-advisor-group-token"] ?? url.searchParams.get("token") ?? "");
+		if (authToken && token !== authToken) {
+			sendJson(res, 401, {
+				ok: false,
+				error: "unauthorized"
+			});
+			return;
+		}
+		if (req.method === "GET" && (pathname === "/advisor-group/stream" || pathname === "/advisor-group/stream/")) {
+			await handleStreamRequest(req, res);
+			return;
+		}
+		if ((req.method === "GET" || req.method === "POST") && (pathname === "/advisor-group/test-connection" || pathname === "/advisor-group/test-connection/")) {
+			await handleTestConnectionRequest(ctx, service, req, res);
+			return;
+		}
+		if ((req.method === "GET" || req.method === "POST") && (pathname === "/advisor-group/models" || pathname === "/advisor-group/models/")) {
+			await handleModelsRequest(ctx, service, req, res);
+			return;
+		}
+		if (req.method === "GET" && (pathname === "/advisor-group/providers" || pathname === "/advisor-group/providers/")) {
+			await sendProviders(ctx, res);
+			return;
+		}
+		if (req.method === "POST" && (pathname === "/advisor-group/stop" || pathname === "/advisor-group/stop/")) {
+			try {
+				const raw = await readBody(req);
+				const parsed = JSON.parse(raw);
+				if (typeof parsed.sessionId !== "string" || !parsed.sessionId) {
+					sendJson(res, 400, {
+						ok: false,
+						error: "缺少 sessionId"
+					});
+					return;
+				}
+				sendJson(res, 200, {
+					ok: true,
+					stopped: service.stopConsultation(parsed.sessionId)
+				});
+			} catch (error) {
+				sendJson(res, 400, {
+					ok: false,
+					error: error instanceof Error ? error.message : String(error)
+				});
+			}
+			return;
+		}
+		if (req.method === "POST" && (pathname === "/advisor-group/resume" || pathname === "/advisor-group/resume/")) {
+			try {
+				const raw = await readBody(req);
+				const parsed = JSON.parse(raw);
+				if (typeof parsed.sessionId !== "string" || !parsed.sessionId) {
+					sendJson(res, 400, {
+						ok: false,
+						error: "缺少 sessionId"
+					});
+					return;
+				}
+				const result = service.resumeConsultation(parsed.sessionId);
+				sendJson(res, result.ok ? 200 : 400, {
+					ok: result.ok,
+					...result.reason ? { error: result.reason } : {}
+				});
+			} catch (error) {
+				sendJson(res, 400, {
+					ok: false,
+					error: error instanceof Error ? error.message : String(error)
+				});
+			}
+			return;
+		}
+		if (req.method === "GET" && (pathname === "/advisor-group/shadow" || pathname === "/advisor-group/shadow/")) {
+			sendJson(res, 200, {
+				ok: true,
+				...await readShadowSamples(200)
+			});
+			return;
+		}
+		if (req.method === "GET" && (pathname === "/advisor-group/config" || pathname === "/advisor-group/config/")) {
+			sendJson(res, 200, {
+				ok: true,
+				config: sanitizeConfig(service.getConfig()),
+				revision: currentRevision(scopedCtx, namespace),
+				dailyGuard: service.getDailyGuard()
+			});
+			return;
+		}
+		if (req.method === "POST" && (pathname === "/advisor-group/config" || pathname === "/advisor-group/config/")) {
+			try {
+				const raw = await readBody(req);
+				const parsed = JSON.parse(raw);
+				const configInput = parsed.config ?? parsed;
+				const expectedRevision = typeof parsed.expectedRevision === "number" ? parsed.expectedRevision : currentRevision(scopedCtx, namespace);
+				const reconciled = reconcileApiKeys(Config(configInput), service.getConfig());
+				const securityError = validateSecurity(reconciled);
+				if (securityError) {
+					sendJson(res, 400, {
+						ok: false,
+						error: securityError
+					});
+					return;
+				}
+				await scopedCtx.settings.replace(namespace, reconciled, expectedRevision);
+				service.setConfig(reconciled);
+				sendJson(res, 200, {
+					ok: true,
+					config: sanitizeConfig(service.getConfig()),
+					revision: currentRevision(scopedCtx, namespace)
+				});
+			} catch (error) {
+				if (error instanceof SettingsConflictError) {
+					sendJson(res, 409, {
+						ok: false,
+						error: "配置已被其他窗口修改，请刷新后重试。"
+					});
+					return;
+				}
+				sendJson(res, 400, {
+					ok: false,
+					error: error instanceof Error ? error.message : String(error)
+				});
+			}
+			return;
+		}
+		sendJson(res, 404, {
+			ok: false,
+			error: "not found"
+		});
+	};
+}
+async function sendProviders(ctx, res) {
+	const providers = [];
+	try {
+		const llmProviders = await ctx.llm.listProviders();
+		const llmResults = await Promise.all(llmProviders.map(async (provider) => {
+			let models = [];
+			try {
+				models = (await ctx.llm.listModels(provider.id)).map((model) => model.id);
+			} catch {}
+			return {
+				id: provider.id,
+				name: provider.name,
+				kind: "llm",
+				models
+			};
+		}));
+		for (const item of llmResults) if (!providers.some((entry) => entry.id === item.id)) providers.push(item);
+	} catch {}
+	for (const preset of Object.values(PROVIDER_PRESETS)) if (!providers.some((item) => item.id === preset.id)) providers.push({
+		id: preset.id,
+		name: preset.label,
+		kind: "preset",
+		models: preset.defaultModels,
+		baseURL: preset.baseURL,
+		apiKeyEnv: preset.apiKeyEnv,
+		protocol: preset.protocol
+	});
+	sendJson(res, 200, {
+		ok: true,
+		providers
+	});
+}
+function registerAdvisorSettingsAndRoutes(ctx, config, service) {
+	const inject = ctx.inject;
+	if (!inject) return;
+	inject(["settings", "webServer"], (scoped) => {
+		const scopedCtx = scoped;
+		const namespace = "advisor-group";
+		const scope = scopedCtx.settings.register(namespace, Config, { base: config });
+		service.setConfig(scope.get());
+		service.setPersistEnabled(async (enabled) => {
+			await scopedCtx.settings.update(namespace, { enabled });
+		});
+		const watchDisposer = scope.watch((next) => {
+			service.setConfig(next);
+		});
+		const authToken = randomUUID();
+		const indexTapDisposer = scopedCtx.webServer.tapIndex ? scopedCtx.webServer.tapIndex((html) => html.replace("<head>", `<head><script>globalThis.__ADVISOR_GROUP_TOKEN__ = ${JSON.stringify(authToken)}<\/script>`)) : null;
+		const routeDisposer = scopedCtx.webServer.register({
+			kind: "prefix",
+			path: "/advisor-group",
+			handler: handleConfigRequest(ctx, scopedCtx, service, authToken)
+		});
+		ctx.effect(() => () => {
+			watchDisposer();
+			routeDisposer();
+			indexTapDisposer?.();
+		}, "dsh-advisor-group: settings watcher + config routes");
+	});
+}
+//#endregion
+//#region src/prompt.ts
+/**
+* Build the system-prompt section that teaches the main model when to call
+* ask_advisors. Keep it concise: it is injected into every model step.
+*/
+function buildAdvisorPrompt(config, repeatPressure) {
+	if (!config.enabled || config.advisors.length === 0) return "";
+	const advisorNames = config.advisors.slice(0, 3).map((advisor) => advisor.name).join("、");
+	const lines = [
+		"## 顾问群使用边界",
+		"你可以调用 ask_advisors 向专家顾问请教。请遵守以下边界：",
+		"",
+		"1. 优先调用 ask_advisors 的情况：",
+		"   - 专业/长尾世界知识：法律、医疗、金融、税务、行业经验、复杂理论等；",
+		"   - 高风险判断：医疗建议、法律承诺、投资决策、安全漏洞评估等；",
+		"   - 你对自己的答案没有把握（confidence 低于阈值）；",
+		"   - 需要多个视角或资深经验才能给出可靠结论；",
+		"   - 用户消息中明确 @顾问群、点名“顾问群/顾问模型”，或要求专家会诊：必须立即调用，不要跳过。",
+		"2. 不要调用 ask_advisors 的情况：",
+		"   - 可以直接联网查证的事实：新闻、价格、天气、API 文档、版本号等；",
+		"   - 简单常识、日常闲聊、纯创意；",
+		"   - 用户明确要求快速回答、不需要专家讨论。",
+		"3. 如果前置分类器建议先联网搜索，请先执行 web search；只有搜索无法解决或属于专业/高风险时再调用 ask_advisors。",
+		"4. 当你对自己没有把握时：先自评一个 0-1 的 confidence，并在调用 ask_advisors 时传入 confidence 字段，例如 confidence: 0.4。",
+		"5. 调用 ask_advisors 时，context 参数必须包含两部分背景信息：",
+		"   a) 当前项目的大致情况（领域/目标/技术栈/关键约束，一到三句话概括）；",
+		"   b) 遇到问题的具体细节（做了什么、期望什么、实际发生了什么、已尝试哪些步骤、相关报错或现象）。",
+		"   如果某项信息确实未知，明确写“该项背景未知”，不要留空 context，也不要让顾问在缺少背景的情况下猜测。",
+		"6. 拿到顾问结论后：自行判断、综合并执行，不要原样复制整段顾问回复。",
+		"7. 发起新咨询：插件会自动进行多轮深挖（默认 autoDeepen：每轮结束由驱动模型基于全部讨论生成更深入的追问，顾问按顺序 A→B→C 接力回答，直到 maxRounds 轮），并自动产出综合结论——你无需再手动 followUp；只有想追加一轮固定主题时才传 sessionId+followUp。"
+	];
+	if (repeatPressure && repeatPressure.count >= 3) lines.push("", `【强制升级】当前会话中同一问题已被用户重复 ${repeatPressure.count} 次仍未解决。你必须立即调用 ask_advisors，把用户最新一次的问题原样作为 question 传入，并在 context 中补充项目概况与已尝试步骤；不得再让用户重复或自行空转。`);
+	else if (repeatPressure && repeatPressure.count > 1) lines.push("", `【提醒】当前会话中同一问题已出现 ${repeatPressure.count} 次。若本轮仍无法解决，必须调用 ask_advisors 升级到顾问群。`);
+	lines.push(`当前可用的顾问：${advisorNames}（完整列表见设置页）。`);
+	return lines.join("\n");
+}
+//#endregion
+//#region src/session-events-host.ts
+/**
+* Host-only registration for the advisor-group session event vocabulary.
+*
+* The official 0.1.2-rc.1 compatibility mechanism is the per-event
+* `SessionEvent.ignorable: true` envelope marker: `dsh-session-persistence`
+* refuses unknown event types unless `KNOWN_SESSION_EVENT_TYPES.has(type)`
+* or the stored event is marked ignorable. However `Session.append()` exposes
+* options only for surface events, so a plugin writer currently cannot set
+* `ignorable` on its own log-only events through the public API.
+*
+* This module mutates the runtime `KNOWN_SESSION_EVENT_TYPES` Set so
+* advisor-group events survive restart/resume. This is a pragmatic workaround
+* for the current rc API; if a future DSH version lets plugin appends carry
+* `ignorable` (or adds an official plugin-event registration surface), replace
+* this module instead of mutating shared state.
+*/
+const ADVISOR_GROUP_EVENT_TYPES = [
+	"advisor-group/start",
+	"advisor-group/message",
+	"advisor-group/delta",
+	"advisor-group/end",
+	"advisor-group/resume"
+];
+function ensureAdvisorGroupSessionEventTypes() {
+	const known = KNOWN_SESSION_EVENT_TYPES;
+	if (!known || typeof known !== "object" || typeof known.add !== "function" || Object.isFrozen(known)) throw new Error("dsh-advisor-group: KNOWN_SESSION_EVENT_TYPES is not mutable. The plugin cannot safely register durable advisor-group events. Please update the plugin when DSH provides an official plugin-event registration API.");
+	const set = known;
+	for (const type of ADVISOR_GROUP_EVENT_TYPES) set.add(type);
+}
+ensureAdvisorGroupSessionEventTypes();
+//#endregion
+//#region src/index.ts
+const name = "dsh-advisor-group";
+const inject = [
+	"tools",
+	"llm",
+	"systemPrompt",
+	"sessions"
+];
+function apply(ctx, config) {
+	const service = new AdvisorGroupService(ctx, config);
+	registerAdvisorSettingsAndRoutes(ctx, config, service);
+	for (const tool of registerAdvisorTools(service)) ctx.tools.register(tool);
+	const systemPrompt = ctx.systemPrompt;
+	if (systemPrompt) ctx.effect(() => systemPrompt.section({
+		name: "advisor-group-boundary",
+		order: 150,
+		text: (assembly) => {
+			const sessionId = assembly?.agent?.session?.id;
+			return buildAdvisorPrompt(service.getConfig(), service.getRepeatPressure(sessionId));
+		}
+	}), "dsh-advisor-group: system prompt section");
+}
+//#endregion
+export { Config, apply, inject, name };