npm - dsh-advisor-group - Versions diffs - 0.1.0 - Mend

dsh-advisor-group 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (8) hide show

package/lib/index.mjs ADDED Viewed

@@ -0,0 +1,2650 @@
+import Schema from "@deepseek-ai/schemastery";
+import { randomUUID } from "node:crypto";
+import { promises, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import { createUserMessage } from "@deepseek-ai/dsh-llm";
+import { defineTool } from "@deepseek-ai/dsh-tools";
+import { SettingsConflictError } from "@deepseek-ai/dsh-settings";
+import { KNOWN_SESSION_EVENT_TYPES } from "@deepseek-ai/dsh-session";
+//#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.")
+});
+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(12e4).description("Per-advisor call timeout in milliseconds (default 120000).")
+});
+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 Config = Schema.object({
+	enabled: Schema.boolean().default(true),
+	discussion: DiscussionConfig,
+	trigger: TriggerConfig,
+	ui: UiConfig,
+	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）或不确定性；
+- 如果没有把握，请明确写“不确定”，不要强行编造。
+`;
+/**
+* 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]);
+}
+//#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.
+*/
+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 options = {
+		provider: advisor.provider,
+		model: advisor.model,
+		system: `${advisor.systemPrompt}${ADVISOR_OUTPUT_POLICY}`,
+		messages,
+		temperature: advisor.temperature,
+		maxTokens: advisor.maxTokens,
+		signal: withTimeout(timeoutMs ?? 12e4, signal)
+	};
+	let text = "";
+	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") onDelta?.({ thinking: chunk.text });
+	return text;
+}
+//#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"],
+		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"],
+		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-k2.6", "kimi-k2.5"],
+		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-k2.6", "kimi-k2.5"],
+		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: [
+			"k3",
+			"k3-256k",
+			"kimi-for-coding",
+			"kimi-for-coding-highspeed"
+		],
+		modelsBaseURL: "https://api.kimi.com/coding/v1",
+		modelsAuthMode: "bearer",
+		notes: "Kimi Code 会员 API；模型 ID 为 k3 / k3-256k / kimi-for-coding / kimi-for-coding-highspeed。"
+	},
+	"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: [
+			"k3",
+			"k3-256k",
+			"kimi-for-coding",
+			"kimi-for-coding-highspeed"
+		],
+		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.7-plus",
+			"qwen3.7-max",
+			"qwen-max"
+		],
+		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.7-plus",
+			"qwen3.7-max",
+			"qwen-max"
+		],
+		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.7-plus",
+			"qwen3.7-max",
+			"qwen-max"
+		],
+		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.7-max",
+			"qwen3.7-plus",
+			"qwen3.6-plus",
+			"deepseek-v4-pro",
+			"deepseek-v4-flash",
+			"kimi-k2.6",
+			"glm-5.1"
+		],
+		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.7-max",
+			"qwen3.7-plus",
+			"qwen3.6-plus",
+			"deepseek-v4-pro",
+			"deepseek-v4-flash",
+			"kimi-k2.6",
+			"glm-5.1"
+		],
+		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.7-max",
+			"qwen3.7-plus",
+			"qwen3.6-plus",
+			"deepseek-v4-pro",
+			"deepseek-v4-flash",
+			"kimi-k2.6",
+			"glm-5.1"
+		],
+		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.7-max",
+			"qwen3.7-plus",
+			"qwen3.6-plus",
+			"deepseek-v4-pro",
+			"deepseek-v4-flash",
+			"kimi-k2.6",
+			"glm-5.1"
+		],
+		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.7-max",
+			"qwen3.7-plus",
+			"qwen3.6-plus",
+			"deepseek-v4-pro",
+			"deepseek-v4-flash",
+			"kimi-k2.6",
+			"glm-5.1"
+		],
+		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.7-max",
+			"qwen3.7-plus",
+			"qwen3.6-plus",
+			"deepseek-v4-pro",
+			"deepseek-v4-flash",
+			"kimi-k2.6",
+			"glm-5.1"
+		],
+		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.2",
+			"glm-5",
+			"glm-4.6",
+			"glm-4.6v",
+			"glm-4.6v-flashx",
+			"glm-4.5v"
+		],
+		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.2",
+			"glm-5",
+			"glm-4.6",
+			"glm-4.6v",
+			"glm-4.6v-flashx",
+			"glm-4.5v"
+		],
+		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-5", "gpt-5-mini"],
+		notes: "Official OpenAI API."
+	},
+	anthropic: {
+		id: "anthropic",
+		label: "Claude",
+		protocol: "anthropic",
+		baseURL: "https://api.anthropic.com",
+		apiKeyEnv: "ANTHROPIC_API_KEY",
+		defaultModels: ["claude-sonnet-4-5", "claude-opus-4-1"],
+		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-flash-preview", "gemini-3-pro-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", "Qwen/Qwen3-235B-A22B"],
+		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",
+			"moonshotai/Kimi-K2-Instruct",
+			"Qwen/Qwen3-32B"
+		],
+		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",
+			"claude-sonnet-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-1",
+			"gpt-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",
+			"anthropic/claude-sonnet-4.5",
+			"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.5",
+			"anthropic/claude-opus-4-1",
+			"openai/gpt-5",
+			"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/providers/direct-http.ts
+/** Stream an advisor response through direct HTTP (OpenAI/Anthropic SSE). */
+async function streamDirectHttp(advisor, transcript, onDelta, signal, timeoutMs) {
+	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";
+	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");
+	switch (protocol) {
+		case "openai": return streamOpenAICompatible(baseURL, advisor, apiKey, transcriptText, onDelta, signal, timeoutMs);
+		case "anthropic": return streamAnthropic(baseURL, advisor, apiKey, transcriptText, authMode, onDelta, signal, timeoutMs);
+		case "gemini": {
+			const content = await callGemini(baseURL, advisor, apiKey, transcriptText, signal, timeoutMs);
+			onDelta({ text: content });
+			return {
+				content,
+				thinking: ""
+			};
+		}
+		default: throw new Error(`Unsupported protocol: ${String(protocol)}`);
+	}
+}
+async function streamOpenAICompatible(baseURL, advisor, apiKey, transcriptText, onDelta, signal, timeoutMs) {
+	const endpoint = baseURL.endsWith("/chat/completions") ? baseURL : `${baseURL.replace(/\/+$/, "")}/chat/completions`;
+	const response = await fetch(endpoint, {
+		method: "POST",
+		headers: {
+			"content-type": "application/json",
+			authorization: `Bearer ${apiKey}`
+		},
+		body: JSON.stringify({
+			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,
+			stream: true
+		}),
+		signal: withTimeout(timeoutMs ?? 12e4, 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 = "";
+	while (true) {
+		let done;
+		let value;
+		try {
+			const read = await reader.read();
+			done = read.done;
+			value = read.value;
+		} catch (error) {
+			if (signal?.aborted || error?.name === "AbortError") throw error;
+			break;
+		}
+		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 (text) {
+						content += text;
+						onDelta({ text });
+					}
+					if (think) {
+						thinking += think;
+						onDelta({ thinking: think });
+					}
+				} catch {}
+			}
+		}
+	}
+	return {
+		content,
+		thinking
+	};
+}
+async function streamAnthropic(baseURL, advisor, apiKey, transcriptText, authMode, onDelta, signal, timeoutMs) {
+	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 response = await fetch(endpoint, {
+		method: "POST",
+		headers,
+		body: JSON.stringify({
+			model: advisor.model,
+			system: advisor.systemPrompt + ADVISOR_OUTPUT_POLICY,
+			messages: [{
+				role: "user",
+				content: transcriptText
+			}],
+			temperature: advisor.temperature ?? .3,
+			max_tokens: advisor.maxTokens ?? 16384,
+			stream: true
+		}),
+		signal: withTimeout(timeoutMs ?? 12e4, 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 = "";
+	while (true) {
+		let done;
+		let value;
+		try {
+			const read = await reader.read();
+			done = read.done;
+			value = read.value;
+		} catch (error) {
+			if (signal?.aborted || error?.name === "AbortError") throw error;
+			break;
+		}
+		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_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 });
+						}
+					}
+				} catch {}
+			}
+		}
+	}
+	return {
+		content,
+		thinking
+	};
+}
+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
+			}
+		}),
+		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) {
+	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: 600,
+			signal: withTimeout(6e4, signal)
+		};
+		let text = "";
+		for await (const chunk of ctx.llm.stream(options)) if (chunk.type === "text-delta") text += chunk.text;
+		return text.trim() || void 0;
+	} catch {
+		return;
+	}
+}
+/** One deepening question for the next round (never throws; returns fallback text). */
+async function generateDeepenQuestion(ctx, session, source, signal) {
+	if (!source) return FALLBACK_DEEPEN_QUESTION;
+	return await generateWith(ctx, source, DRIVER_SYSTEM_PROMPT, `以下是一轮顾问群的讨论记录：\n\n${transcriptOf(session)}\n\n请给出下一步的深入追问。`, signal) || "请基于以上全部讨论，针对仍然存在的分歧、未验证的假设与主要风险，提出一个有深度的后续问题。";
+}
+/** Final synthesis after all rounds (never throws; returns fallback text). */
+async function generateConclusion(ctx, session, source, signal) {
+	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) || "请综合以上全部讨论，给出结论：各位顾问的共识、分歧，以及最可靠的行动建议。";
+}
+//#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 }
+	};
+	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.done === void 0 ? {} : { done: delta.done }
+	};
+	log.append("advisor-group/delta", data);
+}
+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 } : {}
+		}
+	};
+	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/service.ts
+function isAbortError(error, signal) {
+	if (signal?.aborted) return true;
+	return error instanceof Error && error.name === "AbortError";
+}
+const MAX_DAILY_CONSULTATIONS = 50;
+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();
+	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.loadDailyGuard();
+		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));
+		});
+	}
+	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.
+	*/
+	getDailyGuard() {
+		const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+		const used = this.dailyConsultationDate === today ? this.dailyConsultationCount : 0;
+		return {
+			used,
+			limit: MAX_DAILY_CONSULTATIONS,
+			remaining: Math.max(0, MAX_DAILY_CONSULTATIONS - used)
+		};
+	}
+	/**
+	* 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 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.dailyConsultationCount >= MAX_DAILY_CONSULTATIONS) return {
+			ok: false,
+			reason: "今日顾问咨询次数已达上限，请明天再试或调整配置。"
+		};
+		this.dailyConsultationCount += 1;
+		this.persistDailyGuard();
+		return { ok: true };
+	}
+	getSession(id) {
+		return this.sessions.get(id);
+	}
+	createSession(question, context, advisorIds = []) {
+		const maxAdvisors = this.config.discussion.maxAdvisorsPerCall;
+		const advisors = this.resolveAdvisors(advisorIds).slice(0, maxAdvisors);
+		const session = {
+			id: randomUUID(),
+			status: "active",
+			question,
+			context,
+			advisors,
+			maxRounds: this.config.discussion.maxRounds,
+			messages: [{
+				role: "system",
+				content: `顾问群已建立，共 ${advisors.length} 位顾问。`,
+				ts: Date.now()
+			}, {
+				role: "main",
+				content: context ? `${context}\n\n${question}` : question,
+				ts: Date.now()
+			}],
+			createdAt: Date.now(),
+			updatedAt: Date.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.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.ctx.emit("advisor-group/message", {
+			sessionId: session.id,
+			message
+		});
+		return session;
+	}
+	async runOneRound(session, signal, sessionLog) {
+		const advisorCount = Math.max(1, session.advisors.length);
+		const round = Math.floor(session.messages.filter((message) => message.role === "advisor").length / advisorCount) + 1;
+		for (let index = 0; index < session.advisors.length; index++) {
+			const advisor = session.advisors[index];
+			const transcript = this.buildTranscript(session);
+			await this.callAdvisor(session, advisor, transcript, round, index + 1, signal, sessionLog);
+		}
+		session.status = "active";
+		session.updatedAt = Date.now();
+	}
+	/**
+	* 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.
+	*/
+	async runAutoPipeline(session, signal, sessionLog) {
+		while (!this.hasReachedMaxRounds(session)) {
+			if (this.getRoundCount(session) + 1 > 1 && this.config.discussion.autoDeepen) {
+				const question = await generateDeepenQuestion(this.ctx, session, resolveDriverSource(sessionLog, this.config.discussion.driverModel), signal);
+				this.appendMainMessage(session, question, sessionLog);
+			}
+			await this.runOneRound(session, signal, sessionLog);
+		}
+		session.status = "completed";
+		session.updatedAt = Date.now();
+		const summary = this.buildSummary(session, false);
+		const conclusion = await generateConclusion(this.ctx, session, resolveDriverSource(sessionLog, this.config.discussion.driverModel), signal);
+		const finalSummary = {
+			...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.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) {
+		await this.runOneRound(session, signal, sessionLog);
+		session.status = "completed";
+		session.updatedAt = Date.now();
+		const summary = this.buildSummary(session, false);
+		if (sessionLog) appendAdvisorEnd(sessionLog, session, summary);
+		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(-20).map((message) => {
+			if (message.role === "main") return {
+				role: "main",
+				name: "主模型",
+				content: message.content.slice(0, 4e3)
+			};
+			if (message.role === "advisor" && message.advisorName) return {
+				role: "advisor",
+				name: message.advisorName,
+				content: message.content.slice(0, 4e3)
+			};
+			return null;
+		}).filter((entry) => entry !== null);
+	}
+	async callAdvisor(session, advisor, transcript, round, joinIndex, signal, sessionLog) {
+		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) => {
+				if (delta.text) {
+					message.content += delta.text;
+					pendingText += delta.text;
+				}
+				if (delta.thinking) {
+					message.thinking = (message.thinking ?? "") + delta.thinking;
+					pendingThinking += delta.thinking;
+				}
+				publish(session.id, {
+					advisorId: advisor.id,
+					advisorName: advisor.name,
+					contentDelta: delta.text,
+					thinkingDelta: delta.thinking,
+					done: false
+				});
+				if (!timer) timer = setTimeout(flush, 200);
+			};
+			const advisorTimeoutMs = this.config.discussion.advisorTimeoutMs;
+			if (!isDshLlmProvider || advisor.baseURL || advisor.apiKey || advisor.apiKeyEnv) {
+				const streamResult = await streamDirectHttp(relational, transcript, emitDelta, signal, advisorTimeoutMs);
+				flush();
+				content = streamResult.content;
+				message.thinking = streamResult.thinking;
+			} else {
+				content = await callViaCtxLlm(this.ctx, relational, transcript, signal, emitDelta, advisorTimeoutMs);
+				flush();
+			}
+			message.content = content;
+		} 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,
+			done: true
+		});
+		session.messages.push(message);
+		if (sessionLog) appendAdvisorMessage(sessionLog, session.id, message);
+		session.updatedAt = Date.now();
+		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("（顾问调用失败"));
+			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 (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);
+				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);
+			if (sessionLog) appendAdvisorStart(sessionLog, session);
+			const summary = await service.runAutoPipeline(session, exec.signal, sessionLog);
+			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 body = message.content && message.content.trim() ? message.content : message.thinking && message.thinking.trim() ? `（思维链）\n${message.thinking}` : "（顾问未返回正文）";
+			lines.push(`【${message.advisorName ?? message.advisorId ?? "顾问"}】：${body}`);
+		}
+		lines.push("");
+	}
+	lines.push("（以上是顾问模型与主模型的对话记录，主模型可直接基于其中内容继续思考或追问。）");
+	return lines.join("\n");
+}
+//#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 === "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"
+];
+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"
+];
+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 };