dsh-advisor-group 0.1.1 → 0.1.2

package/lib/index.mjs

@@ -1,6 +1,6 @@
 import Schema from "@deepseek-ai/schemastery";
 import { randomUUID } from "node:crypto";
-import { mkdirSync, promises, readFileSync, readdirSync, rmSync, statSync, unlinkSync, writeFileSync } from "node:fs";
+import { appendFileSync, mkdirSync, promises, readFileSync, readdirSync, rmSync, statSync, unlinkSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { dirname, isAbsolute, join } from "node:path";
 import { KNOWN_SESSION_EVENT_TYPES, Session } from "@deepseek-ai/dsh-session";
@@ -1439,6 +1439,61 @@ function appendAdvisorEnd(log, session, summary) {
 	};
 	log.append("advisor-group/end", data);
 }
+/**
+* Open the cross-session ask card (waiting state). Reuses the registered
+* `advisor-group/start` event with `kind:'ask'` so no new event type needs
+* persistence registration; the client branches on `kind` for the ask layout.
+*/
+function appendAskStart(log, info) {
+	const { turn, step } = latestTurnStep(log);
+	log.append("advisor-group/start", {
+		sessionId: info.askId,
+		turn,
+		step,
+		kind: "ask",
+		question: info.question,
+		...info.context === void 0 ? {} : { context: info.context },
+		advisors: [{
+			id: "ask-sender",
+			name: info.senderName
+		}, {
+			id: "ask-target",
+			name: info.targetName
+		}]
+	});
+}
+/**
+* Close the cross-session ask card: the target's answer as an advisor-role
+* bubble, then the end event whose `summary.conclusion` is the note line.
+* Message is appended BEFORE end so the assembled state has the answer in
+* place when the status flips to completed.
+*/
+function appendAskAnswer(log, info) {
+	const { turn, step } = latestTurnStep(log);
+	log.append("advisor-group/message", {
+		sessionId: info.askId,
+		turn,
+		step,
+		role: "advisor",
+		advisorId: "ask-target",
+		advisorName: info.targetName,
+		content: info.answer.trim() ? info.answer : "（未收到回复，详见下方投递说明）"
+	});
+	log.append("advisor-group/end", {
+		sessionId: info.askId,
+		turn,
+		step,
+		summary: {
+			question: info.question,
+			advisors: [{
+				advisorId: "ask-target",
+				advisorName: info.targetName,
+				corePoints: []
+			}],
+			conclusion: info.note
+		}
+	});
+}
 //#endregion
 //#region src/stream-channel.ts
 const BOOT_ID = `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
@@ -3136,265 +3191,1140 @@ async function classifyWithJev(question, context, advisors, config, signal, ques
 	}
 }
 //#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."
-			},
-			questionEn: {
-				type: "string",
-				description: "Optional self-contained English gist of the question plus key background. Used as the Jev pre-classification input only when the「Jev 英文判定」setting is enabled; the displayed question, session records, and duplicate detection always keep using question/context in Chinese. Omit it otherwise."
-			}
-		},
-		output: {
-			schema: {
-				type: "object",
-				additionalProperties: false,
-				properties: {
-					sessionId: {
-						type: "string",
-						required: true
-					},
-					advice: {
-						type: "string",
-						required: true
-					},
-					skipped: { type: "boolean" },
-					reason: { type: "string" }
+//#region src/cross-session.ts
+/**
+* Cross-session ask (v0): let the current session deliver one question to
+* another existing ordinary session, wake it, and report what that session
+* said between the delivery receipt and its next whole-session idle.
+*
+* Facts this module is built on (DSH 0.2.0-rc.1/rc.2 types, verified):
+* - `ctx.sessionController.resolveAgent(sessionId)` yields the live Agent
+*   (`{ agent }` or `{ error }`), resuming a cold session.
+* - `agent.followup(createUserMessage({ content, source }))` queues one
+*   ordinary follow-up turn and wakes the driver.
+* - `ctx.sessionController.prompt({ sessionId, content, mode:'queue', requestId })`
+*   is the cheap fallback, but the Host hardcodes `source` to a user prompt, so
+*   that path is identity-dishonest and must be reported as such.
+* - There is NO API that returns "the answer to this message". The Host only
+*   guarantees delivery, so this module reports an INTERVAL, never a reply.
+* - The Host enforces no caller identity, no cycle guard, and hard-excludes
+*   subagent sessions, so every guard in `ask_session` lives here.
+*
+* The pure helpers below never touch `ctx`; only `askSession()` does I/O.
+*/
+/** Maximum combined UTF-8 bytes of question + context (design §六.5). */
+const ASK_CONTENT_MAX_BYTES = 32e3;
+/** Default and maximum wait for the target's next idle (design §十). */
+const ASK_WAIT_DEFAULT_MS = 18e4;
+const ASK_WAIT_MAX_MS = 6e5;
+/** Poll interval while waiting for the target to reach whole-session idle. */
+const ASK_POLL_INTERVAL_MS = 1e3;
+/**
+* Envelope the receiving model reads. The Host offers no registration point for
+* this framing (the official Agent Teams build their own too), so the identity
+* is carried in the content itself: a header block naming the asking session,
+* then the question, then optional background.
+* @param senderName - title (or cwd+time fallback) of the asking session.
+* @param question - the question to hand over.
+* @param context - optional background; permanently recorded in the target log.
+* @returns content blocks, envelope first.
+*/
+function buildAskEnvelope(senderName, question, context) {
+	const blocks = [{
+		type: "text",
+		text: `【来自会话「${senderName}」的提问】`
+	}, {
+		type: "text",
+		text: question
+	}];
+	if (context !== void 0 && context.trim().length > 0) blocks.push({
+		type: "text",
+		text: `【对方补充的背景】\n${context}`
+	});
+	return blocks;
+}
+/**
+* Build the identified user message handed to `agent.followup()`.
+* @param envelope - content blocks produced by {@link buildAskEnvelope}.
+* @param source - producer-declared session-ask source.
+* @returns an immutable identified user message carrying our source kind.
+*/
+function buildAskMessage(envelope, source) {
+	return createUserMessage({
+		content: envelope,
+		source
+	});
+}
+/**
+* UTF-8 byte length of the text a caller wants to hand over.
+* @param question - the question text.
+* @param context - optional background text.
+* @returns byte length of question + context.
+*/
+function askContentBytes(question, context) {
+	return Buffer.byteLength(question, "utf8") + (context === void 0 ? 0 : Buffer.byteLength(context, "utf8"));
+}
+/** Deterministic fallback label: working directory plus most recent activity. */
+function fallbackSessionName(cwd, updatedAt) {
+	const where = cwd === void 0 || cwd.length === 0 ? "（未知工作目录）" : cwd;
+	if (updatedAt === void 0 || !Number.isFinite(updatedAt)) return where;
+	const at = new Date(updatedAt);
+	return `${where} · ${Number.isNaN(at.getTime()) ? String(updatedAt) : at.toISOString()}`;
+}
+/**
+* Model-visible name of one listed session. The title lives in the `title`
+* projection (a snapshot object), is optional, and may be a stale cache value,
+* so every failure degrades to the cwd+time fallback instead of throwing.
+*/
+function sessionDisplayName(summary) {
+	const raw = summary.projections?.values?.title;
+	const title = raw !== null && typeof raw === "object" && typeof raw.title === "string" ? raw.title.trim() : "";
+	if (title.length > 0) return title;
+	return fallbackSessionName(summary.cwd, summary.updatedAt);
+}
+function candidateOf(summary) {
+	return {
+		sessionId: summary.sessionId,
+		name: sessionDisplayName(summary),
+		hint: fallbackSessionName(summary.cwd, summary.updatedAt)
+	};
+}
+/** Most-recently-active first, running sessions ahead of idle ones. */
+function orderCandidates(rows) {
+	return [...rows].sort((a, b) => {
+		if (a.running !== b.running) return a.running ? -1 : 1;
+		return b.updatedAt - a.updatedAt;
+	});
+}
+/** Partial candidates are capped: a broad needle must stay a readable list. */
+const PARTIAL_CANDIDATE_LIMIT = 10;
+/**
+* Resolve a user/model-supplied target reference against the session list.
+* Ladder, in order: exact sessionId → exact display name → partial natural
+* name (substring of the display name OR of the workspace cwd, case-insensitive)
+* → missing. One hit resolves outright; several hits become candidates —
+* this function NEVER guesses. Partial candidates are ordered most-recently-
+* active first (running sessions first) and capped, so "ask the 极简遥控器
+* session" works without anyone digging session ids out of log directories.
+* @param sessions - rows from `sessionController.list()`.
+* @param reference - a session id, display name, or natural partial name.
+* @returns the unique target, the candidate list, or "missing".
+*/
+function matchTargetSession(sessions, reference) {
+	const needle = reference.trim();
+	if (needle.length === 0) return { kind: "missing" };
+	const byId = sessions.find((session) => session.sessionId === needle);
+	if (byId) return {
+		kind: "unique",
+		target: {
+			sessionId: byId.sessionId,
+			name: sessionDisplayName(byId)
+		}
+	};
+	const folded = needle.toLowerCase();
+	const exact = sessions.filter((session) => sessionDisplayName(session).toLowerCase() === folded);
+	if (exact.length === 1) return {
+		kind: "unique",
+		target: {
+			sessionId: exact[0].sessionId,
+			name: sessionDisplayName(exact[0])
+		}
+	};
+	if (exact.length > 1) return {
+		kind: "ambiguous",
+		candidates: orderCandidates(exact).map(candidateOf)
+	};
+	const partial = sessions.filter((session) => sessionDisplayName(session).toLowerCase().includes(folded) || session.cwd !== void 0 && session.cwd.toLowerCase().includes(folded));
+	if (partial.length === 1) return {
+		kind: "unique",
+		target: {
+			sessionId: partial[0].sessionId,
+			name: sessionDisplayName(partial[0])
+		}
+	};
+	if (partial.length === 0) return { kind: "missing" };
+	return {
+		kind: "ambiguous",
+		candidates: orderCandidates(partial).slice(0, PARTIAL_CANDIDATE_LIMIT).map(candidateOf)
+	};
+}
+/**
+* Hop guard counter: the hop of the question this session is about to send.
+* The value is carried by the asking message that reached this session, so it
+* is read from the most recent inbound `user/message` whose source is
+* `session-ask`; a later plain human prompt does not reset it, because the
+* question being asked here still descends from that relay. No session-ask
+* source anywhere means this is a fresh, top-level question (hop 0).
+* @param events - this session's log events in order.
+* @returns the hop to stamp on the outgoing message.
+*/
+function nextAskHop(events) {
+	for (let i = events.length - 1; i >= 0; i -= 1) {
+		const event = events[i];
+		if (event.type !== "user/message") continue;
+		const source = event.data.message?.source;
+		if (source?.kind !== "session-ask") continue;
+		return typeof source.hop === "number" && Number.isFinite(source.hop) ? source.hop + 1 : 1;
+	}
+	return 0;
+}
+/**
+* Collect what the target session said inside the interval. Only
+* `assistant/message` events strictly after the delivery watermark count, so a
+* reply that predates the delivery cannot be reported as an answer. The
+* watermark (highest seq already present at delivery) is the authoritative cut;
+* `fromMs` is kept only as the recorded interval start.
+* @param events - the target session's log events in order.
+* @param fromSeq - highest event seq already present at delivery time.
+* @returns the newest event time seen and the per-message text pieces.
+*/
+function collectAnswer(events, fromSeq) {
+	const pieces = [];
+	let latestEventTime = null;
+	for (const event of events) {
+		if (Number.isFinite(event.time) && (latestEventTime === null || event.time > latestEventTime)) latestEventTime = event.time;
+		if (event.type !== "assistant/message") continue;
+		if (!(event.seq > fromSeq)) continue;
+		const text = (event.data?.message?.content ?? []).filter((block) => block.type === "text" && typeof block.text === "string").map((block) => block.text).join("").trim();
+		if (text.length > 0) pieces.push(text);
+	}
+	return {
+		latestEventTime,
+		pieces
+	};
+}
+/** Join the interval's text pieces into the returned answer body. */
+function joinAnswerPieces(pieces) {
+	return pieces.join("\n\n");
+}
+/** Highest event seq present, or -1 for an empty log (the session-cursor convention). */
+function logWatermark(events) {
+	let highest = -1;
+	for (const event of events) if (typeof event.seq === "number" && event.seq > highest) highest = event.seq;
+	return highest;
+}
+/** Human-readable text the main model reads for one settled ask_session call. */
+function renderAskResult(value) {
+	return [{
+		type: "text",
+		text: `${value.answer.trim().length > 0 ? value.answer : "（该区间内对方没有产出正文。）"}\n\n${value.note}`
+	}];
+}
+/**
+* The Host hard-excludes subagent sessions with `session/agent-busy` and the
+* reason "use subagent delivery for this child session"; recognise it so the
+* caller gets the actionable `subagent-target` code instead of `delivery-failed`.
+*/
+function isSubagentDeliveryRejection(error) {
+	if (error === null || typeof error !== "object") return false;
+	const shape = error;
+	const reason = shape.details !== null && typeof shape.details === "object" ? shape.details.reason : void 0;
+	const haystack = `${typeof reason === "string" ? reason : ""} ${typeof shape.message === "string" ? shape.message : ""}`;
+	return haystack.includes("subagent delivery") || haystack.includes("owned by subagent routing");
+}
+/** One unsettled wait per session: at most one ask_session may be in flight. */
+const pendingWaits = /* @__PURE__ */ new Set();
+/** Whether this session already has an unsettled ask_session wait. */
+function isWaiting(sessionId) {
+	return pendingWaits.has(sessionId);
+}
+let askCounter = 0;
+/** Process-unique ask id (the receiver side may dedupe on it). */
+function nextAskId() {
+	askCounter += 1;
+	return `ask-${Date.now().toString(36)}-${askCounter}-${Math.random().toString(36).slice(2, 8)}`;
+}
+/**
+* Lazy host-service access: never a hard `inject` (older hosts lack this service).
+*
+* A bare `ctx.sessionController` read is gated by the plugin's `inject` list and
+* throws `cannot get property "sessionController" without inject` when the key is
+* not declared — so the property read itself must not be used. `ctx.get(name)` is
+* Cordis's documented read "without the inject requirement": it returns the service
+* or `undefined` when (not yet) provided.
+*/
+function getSessionController(ctx) {
+	if (ctx === null || ctx === void 0) return void 0;
+	try {
+		const context = ctx;
+		const controller = typeof context.get === "function" ? context.get.call(ctx, "sessionController") : context.sessionController;
+		if (controller === null || typeof controller !== "object") return void 0;
+		const candidate = controller;
+		if (typeof candidate.list !== "function" || typeof candidate.resolveAgent !== "function") return void 0;
+		return candidate;
+	} catch {
+		return;
+	}
+}
+/** Read a live Agent's own log through a defensive view (the log API is read-only here). */
+function agentEvents(agent) {
+	try {
+		return agent.session?.snapshotEvents() ?? [];
+	} catch {
+		return [];
+	}
+}
+async function sleep(ms, signal) {
+	if (signal.aborted) return;
+	await new Promise((resolve) => {
+		const timer = setTimeout(resolve, ms);
+		signal.addEventListener("abort", () => {
+			clearTimeout(timer);
+			resolve();
+		}, { once: true });
+	});
+}
+/**
+* Hand the question to the target session.
+*
+* Preferred path: `resolveAgent` + `agent.followup(...)`, which preserves our
+* own source kind. Fallback: `sessionController.prompt(...)`, which the Host
+* stamps as a user prompt — the envelope still names us, and the caller is told
+* in `note` that this identity-dishonest path was used.
+*/
+async function deliverAsk(controller, signal, input) {
+	const envelope = buildAskEnvelope(input.source.senderName, input.question, input.context);
+	try {
+		const resolved = await controller.resolveAgent(input.target.sessionId);
+		if ("agent" in resolved && resolved.agent) {
+			const agent = resolved.agent;
+			agent.followup(buildAskMessage(envelope, input.source));
+			return {
+				ok: true,
+				receipt: {
+					delivered: "native",
+					note: "本次投递走了首选通道（自定义来源），对方模型能看到这条消息来自另一个会话。",
+					fromSeq: logWatermark(agentEvents(agent)),
+					fromMs: Date.now(),
+					targetWasRunning: input.targetWasRunning
 				}
-			},
-			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"
+		}
+		const reason = "error" in resolved ? resolved.error : void 0;
+		if (isSubagentDeliveryRejection(reason)) return {
+			ok: false,
+			code: "subagent-target",
+			message: `目标会话 ${input.target.sessionId} 属于子代理（subagent）会话，跨会话投递被宿主硬性排除。请改用子代理通道（subagent / send_message）。`
+		};
+		return deliverViaPrompt(controller, signal, envelope, input, `首选通道不可用（${describeHostError(reason)}）`);
+	} catch (error) {
+		if (signal.aborted) throw error;
+		if (isSubagentDeliveryRejection(error)) return {
+			ok: false,
+			code: "subagent-target",
+			message: `目标会话 ${input.target.sessionId} 属于子代理（subagent）会话，跨会话投递被宿主硬性排除。请改用子代理通道（subagent / send_message）。`
+		};
+		if (isTargetNotFound(error)) return {
+			ok: false,
+			code: "target-not-found",
+			message: `找不到会话 ${input.target.sessionId}（宿主报告 session/not-found）。`
+		};
+		return deliverViaPrompt(controller, signal, envelope, input, `首选通道报错（${describeHostError(error)}）`);
+	}
+}
+async function deliverViaPrompt(controller, _signal, envelope, input, why) {
+	try {
+		await controller.prompt({
+			requestId: input.source.askId,
+			sessionId: input.target.sessionId,
+			mode: "queue",
+			content: envelope
+		});
+		const floor = await watermarkViaResolve(controller, input.target.sessionId);
+		return {
+			ok: true,
+			receipt: {
+				delivered: "fallback",
+				note: `本次投递走了降级通道（宿主的 prompt 接口），宿主把来源写死成「用户输入」，对方模型会以为这是用户打的字；身份只能靠正文里的信封说明。原因：${why}`,
+				fromSeq: floor,
+				fromMs: Date.now(),
+				targetWasRunning: input.targetWasRunning
+			}
+		};
+	} catch (error) {
+		if (isSubagentDeliveryRejection(error)) return {
+			ok: false,
+			code: "subagent-target",
+			message: `目标会话 ${input.target.sessionId} 属于子代理（subagent）会话，跨会话投递被宿主硬性排除。请改用子代理通道（subagent / send_message）。`
+		};
+		if (isTargetNotFound(error)) return {
+			ok: false,
+			code: "target-not-found",
+			message: `找不到会话 ${input.target.sessionId}（宿主报告 session/not-found）。`
+		};
+		return {
+			ok: false,
+			code: "delivery-failed",
+			message: `投递失败：首选通道与降级通道都未能把问题送进目标会话。${why} 降级通道报错：${describeHostError(error)}`
+		};
+	}
+}
+async function watermarkViaResolve(controller, sessionId) {
+	try {
+		const resolved = await controller.resolveAgent(sessionId);
+		if ("agent" in resolved && resolved.agent) return logWatermark(agentEvents(resolved.agent));
+	} catch {}
+	return -1;
+}
+function isTargetNotFound(error) {
+	if (error === null || typeof error !== "object") return false;
+	return error.code === "session/not-found";
+}
+function describeHostError(error) {
+	if (error === null || error === void 0) return "未提供原因";
+	if (typeof error === "string") return error;
+	if (typeof error === "object") {
+		const shape = error;
+		const code = typeof shape.code === "string" ? shape.code : "";
+		const message = typeof shape.message === "string" ? shape.message : "";
+		if (code.length > 0 || message.length > 0) return `${code}${code && message ? " " : ""}${message}`;
+		try {
+			return JSON.stringify(error);
+		} catch {
+			return "宿主返回了无法序列化的错误";
+		}
+	}
+	return String(error);
+}
+/**
+* Wait for the target session's next whole-session idle after delivery.
+* Never cancels the target turn — a timeout stops only this session's waiting.
+*/
+async function waitForTargetIdle(controller, signal, input) {
+	const startedAt = Date.now();
+	let targetRunning = input.targetWasRunning;
+	let observedBusy = input.targetWasRunning;
+	const watermark = async () => {
+		try {
+			const resolved = await controller.resolveAgent(input.sessionId);
+			if (!("agent" in resolved) || !resolved.agent) return void 0;
+			return logWatermark(agentEvents(resolved.agent));
+		} catch {
+			return;
+		}
+	};
+	while (true) {
+		if (signal.aborted) return {
+			endedBecause: "error",
+			lastRunning: targetRunning,
+			note: "本次调用被取消，等待中止；没有取消对方的回合，对方可能仍在作答。"
+		};
+		const elapsed = Date.now() - startedAt;
+		if (elapsed >= input.waitMs) return {
+			endedBecause: "timeout",
+			lastRunning: targetRunning,
+			note: `等待达到上限（${input.waitMs}ms），已返回当前区间内收集到的内容；没有取消对方的回合，对方可能仍在作答。`
+		};
+		await sleep(Math.min(ASK_POLL_INTERVAL_MS, Math.max(0, input.waitMs - elapsed)), signal);
+		let row;
+		try {
+			row = (await controller.list({}, signal)).items.find((item) => item.sessionId === input.sessionId);
+		} catch (error) {
+			if (signal.aborted) return {
+				endedBecause: "error",
+				lastRunning: targetRunning,
+				note: "本次调用被取消，等待中止；没有取消对方的回合。"
 			};
-			if (cfg.advisors.length === 0) return {
-				sessionId: "",
-				advice: "顾问群尚未配置任何顾问。请先到 设置 → 插件 → 顾问群 添加顾问。",
-				skipped: true,
-				reason: "no-advisors"
+			return {
+				endedBecause: "error",
+				lastRunning: targetRunning,
+				note: `等待期间读取会话列表失败（${describeHostError(error)}），已返回当前区间内收集到的内容。`
 			};
-			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"
+		}
+		if (!row) continue;
+		if (row.running) {
+			observedBusy = true;
+			targetRunning = true;
+			continue;
+		}
+		if (observedBusy) return {
+			endedBecause: "idle",
+			lastRunning: false,
+			note: "等待结束于该会话整体空闲（idle）。"
+		};
+		if (input.fromSeq !== void 0) {
+			const now = await watermark();
+			if (now !== void 0 && now > input.fromSeq) return {
+				endedBecause: "idle",
+				lastRunning: false,
+				note: "等待结束：该会话已追加新内容且当前不忙（对方的回合发生在两次轮询之间，忙的状态未被采到）。"
 			};
-			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 repeatCount = service.getRepeatPressure(sessionLog?.id)?.count ?? 0;
-			const forcedByRepeat = repeatCount >= 3;
-			let shadow;
-			let shadowWritten = false;
-			const recordShadow = (launched) => {
-				if (!shadow || shadowWritten) return;
-				shadowWritten = true;
-				appendShadowSample({
-					...shadow,
-					launched
-				});
+		}
+		input.log(`waiting for ${input.sessionId} to start the delivered turn`);
+		targetRunning = false;
+	}
+}
+/** Read the target's log back and collect what it said inside the interval. */
+async function collectTargetAnswer(controller, sessionId, fromSeq) {
+	try {
+		const resolved = await controller.resolveAgent(sessionId);
+		if (!("agent" in resolved) || !resolved.agent) return {
+			pieces: [],
+			readError: describeHostError("error" in resolved ? resolved.error : void 0)
+		};
+		return { pieces: collectAnswer(agentEvents(resolved.agent), fromSeq).pieces };
+	} catch (error) {
+		return {
+			pieces: [],
+			readError: describeHostError(error)
+		};
+	}
+}
+/**
+* Every pre-delivery guard, in one place. Pure: takes plain facts, returns a
+* rejection or nothing. Order matters — identity before ownership, ownership
+* before budget, budget before hop.
+* @returns the rejection, or undefined when the ask may proceed.
+*/
+function checkAskGuards(input) {
+	const { guards, match } = input;
+	if (match.kind === "missing") return {
+		code: "target-not-found",
+		message: "没有找到匹配的会话。请用会话列表里的标题或 sessionId 指定目标；不确认时先列出候选再让用户选择。"
+	};
+	if (match.kind === "ambiguous") return {
+		code: "target-ambiguous",
+		message: `有 ${match.candidates.length} 个会话都叫这个名字，不能猜。请把候选交给用户挑选（用 sessionId 指定即可精确命中）。`,
+		candidates: match.candidates
+	};
+	const target = input.target ?? match.target;
+	if (target.sessionId === guards.currentSessionId) return {
+		code: "self-target",
+		message: "目标是当前会话自己，拒绝自问自答。"
+	};
+	if (input.sessions.find((session) => session.sessionId === target.sessionId)?.origin === "subagent") return {
+		code: "subagent-target",
+		message: "目标会话是子代理（subagent）会话，跨会话投递被宿主硬性排除。请改用子代理通道（subagent / send_message）。"
+	};
+	const bytes = askContentBytes(input.question, input.context);
+	if (bytes > 32e3) return {
+		code: "content-too-large",
+		message: `问题加背景共 ${bytes} 字节，超过上限 ${ASK_CONTENT_MAX_BYTES} 字节。请缩短问题，或把背景留在自己的会话里分次提问。`
+	};
+	if (guards.hop > 2) return {
+		code: "hop-limit",
+		message: `本次提问会形成第 ${guards.hop} 跳转发（上限 3 跳：0→2）。会话链式互问会绕成环，已拒绝；请由用户直接指定目标会话，或让当前会话自己作答。`
+	};
+}
+/** Normalise and validate the model-supplied wait budget. */
+function normalizeWaitMs(value) {
+	if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) return ASK_WAIT_DEFAULT_MS;
+	return Math.min(Math.floor(value), ASK_WAIT_MAX_MS);
+}
+async function askSession(ctx, signal, input) {
+	const controller = getSessionController(ctx);
+	if (!controller) return {
+		ok: false,
+		error: "service-missing",
+		message: "此功能需要较新的 DSH 宿主：当前宿主没有提供 sessionController 服务，无法向其他会话投递问题。"
+	};
+	const waitMs = normalizeWaitMs(input.waitMs);
+	if (typeof input.waitMs === "number" && input.waitMs > 6e5) (input.log ?? (() => {}))(`ask_session waitMs 超出上限，已按 ${waitMs}ms 处理`);
+	if (isWaiting(input.currentSessionId)) return toToolError({
+		code: "already-waiting",
+		message: "当前会话已经在等另一个会话的答复（同一时刻只允许等一个），请等这次返回后再发起新的提问。"
+	});
+	pendingWaits.add(input.currentSessionId);
+	try {
+		const sessions = [];
+		let match = { kind: "missing" };
+		try {
+			const listed = await controller.list({}, signal);
+			sessions.push(...listed.items);
+			match = matchTargetSession(sessions, input.target ?? "");
+		} catch (error) {
+			return {
+				ok: false,
+				error: "service-missing",
+				message: `读取会话列表失败：${describeHostError(error)}`
 			};
-			if (args.sessionId) {
-				if (!args.followUp) return {
-					sessionId: args.sessionId,
-					advice: "继续追问需要提供 followUp 参数。",
+		}
+		return await runAsk(ctx, controller, signal, input, {
+			sessions,
+			match,
+			log: input.log ?? (() => {})
+		});
+	} finally {
+		pendingWaits.delete(input.currentSessionId);
+	}
+}
+/**
+* The ask itself, after the target list has been read and the wait latch is
+* held by the caller.
+*/
+async function runAsk(ctx, controller, signal, input, listed) {
+	const waitMs = normalizeWaitMs(input.waitMs);
+	const hop = nextAskHop(input.currentEvents);
+	const rejectionBase = checkAskGuards({
+		guards: {
+			currentSessionId: input.currentSessionId,
+			hop
+		},
+		match: listed.match,
+		sessions: listed.sessions,
+		question: input.question,
+		context: input.context
+	});
+	if (rejectionBase) return toToolError(rejectionBase);
+	const target = listed.match.kind === "unique" ? listed.match.target : {
+		sessionId: "",
+		name: ""
+	};
+	const targetRow = listed.sessions.find((session) => session.sessionId === target.sessionId);
+	const askId = nextAskId();
+	const source = {
+		kind: "session-ask",
+		form: "relay",
+		askId,
+		senderSessionId: input.currentSessionId,
+		senderName: input.senderName,
+		hop
+	};
+	const from = (/* @__PURE__ */ new Date()).toISOString();
+	const delivery = await deliverAsk(controller, signal, {
+		target,
+		question: input.question,
+		context: input.context,
+		source,
+		targetWasRunning: targetRow?.running === true
+	});
+	if (!delivery.ok) return {
+		ok: false,
+		error: delivery.code,
+		message: delivery.message
+	};
+	input.onDelivered?.({
+		askId,
+		question: input.question,
+		...input.context === void 0 ? {} : { context: input.context },
+		senderName: input.senderName,
+		targetName: target.name
+	});
+	const outcome = await waitForTargetIdle(controller, signal, {
+		sessionId: target.sessionId,
+		targetWasRunning: delivery.receipt.targetWasRunning,
+		waitMs,
+		log: listed.log,
+		fromSeq: delivery.receipt.fromSeq
+	});
+	const collected = await collectTargetAnswer(controller, target.sessionId, delivery.receipt.fromSeq);
+	const answer = joinAnswerPieces(collected.pieces);
+	const to = outcome.endedBecause === "idle" ? (/* @__PURE__ */ new Date()).toISOString() : null;
+	const note = [
+		"区间语义：从投递回执到对方会话下一次整体空闲，这两个时刻之间对方产出的文字都算在内——这是「这个区间里对方说的话」，不是逐条对应的回答。",
+		delivery.receipt.note,
+		outcome.note,
+		delivery.receipt.targetWasRunning ? "投递时对方正在忙，问题已排队，会在它当前回合结束后进入新回合。" : "投递时对方不忙，宿主已唤醒它开一个新回合。",
+		collected.readError === void 0 ? "" : `读取对方会话日志时出错，answer 可能不完整：${collected.readError}`
+	].filter((line) => line.length > 0).join("\n");
+	input.onSettled?.({
+		askId,
+		question: input.question,
+		targetName: target.name,
+		answer,
+		note
+	});
+	return {
+		ok: true,
+		target: {
+			sessionId: target.sessionId,
+			name: target.name
+		},
+		delivered: delivery.receipt.delivered,
+		askId,
+		interval: {
+			from,
+			to,
+			endedBecause: outcome.endedBecause
+		},
+		answer,
+		note
+	};
+}
+function toToolError(rejection) {
+	return {
+		ok: false,
+		error: rejection.code,
+		message: rejection.message,
+		...rejection.candidates ? { candidates: rejection.candidates } : {}
+	};
+}
+//#endregion
+//#region src/tools.ts
+function registerAdvisorTools(service, ctx) {
+	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."
+				},
+				questionEn: {
+					type: "string",
+					description: "Optional self-contained English gist of the question plus key background. Used as the Jev pre-classification input only when the「Jev 英文判定」setting is enabled; the displayed question, session records, and duplicate detection always keep using question/context in Chinese. Omit it otherwise."
+				}
+			},
+			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: "missing-follow-up"
+					reason: "invalid-confidence"
 				};
-				const session = service.getSession(args.sessionId);
-				if (!session) return {
-					sessionId: args.sessionId,
-					advice: "顾问群会话不存在或已过期，请重新发起 ask_advisors。",
+				if (!service.isEnabled()) return {
+					sessionId: "",
+					advice: "顾问群插件已禁用。请先调用 toggle_advisor_group 启用。",
 					skipped: true,
-					reason: "session-not-found"
+					reason: "disabled"
 				};
-				if (service.isSessionRunning(session.id)) return {
-					sessionId: session.id,
-					advice: "该顾问群会话正在运行中，请等本轮结束后再追问。",
+				if (cfg.advisors.length === 0) return {
+					sessionId: "",
+					advice: "顾问群尚未配置任何顾问。请先到 设置 → 插件 → 顾问群 添加顾问。",
 					skipped: true,
-					reason: "session-running"
+					reason: "no-advisors"
 				};
-				if (service.hasReachedMaxRounds(session)) return {
-					sessionId: session.id,
-					advice: "本轮已是顾问群讨论的最后一轮，请综合现有顾问意见给出最终答复，不要再追问。",
+				const withoutModel = advisorsMissingModel(cfg);
+				if (withoutModel.length > 0) return {
+					sessionId: "",
+					advice: `顾问群中有 ${withoutModel.length} 位顾问未配置模型（${withoutModel.map((a) => a.name).join("、")}）。请先到 设置 → 插件 → 顾问群 补全模型后再发起，避免整轮调用失败。`,
 					skipped: true,
-					reason: "max-rounds-reached"
-				};
-				service.appendFollowUp(session.id, args.followUp, sessionLog);
-				const summary = await service.runOneRoundAndSummarize(session, exec.signal, sessionLog, exec.agent);
-				const canContinue = !service.hasReachedMaxRounds(session);
-				return {
-					sessionId: session.id,
-					advice: formatConversation(session) + formatRiskNotes(summary) + (canContinue ? "\n\n（如需继续，可再次传入 sessionId 和 followUp 追问。）" : "\n\n（讨论轮数已达上限，请综合顾问意见给出最终答复。）"),
-					skipped: false
+					reason: "advisor-model-missing"
 				};
-			}
-			if (!args.question) return {
-				sessionId: "",
-				advice: "发起新讨论需要提供 question 参数。",
-				skipped: true,
-				reason: "missing-question"
-			};
-			if (cfg.trigger.requireClassifier && !mentionedAdvisorGroup && !forcedByRepeat) {
-				let classification;
-				let jevResult;
-				let jevError;
-				let jevLatencyMs;
-				const jev = cfg.trigger.jev;
-				if (jev?.enabled) {
-					const jevStartedAt = Date.now();
-					try {
-						jevResult = await classifyWithJev(args.question, args.context, cfg.advisors, jev, exec.signal, typeof args.questionEn === "string" ? args.questionEn : void 0);
-						classification = jevResult;
-					} catch (error) {
-						if (exec.signal.aborted) throw error;
-						jevError = error instanceof Error ? error.message : String(error);
-						console.warn("[dsh-advisor-group] Jev 分类失败，回退到本地分类器：", sessionLog?.id ?? "no-session", jevError);
-					} finally {
-						jevLatencyMs = Date.now() - jevStartedAt;
-					}
-				}
-				classification ??= classifyRequest(args.question, args.context, cfg.advisors, args.confidence, cfg.trigger.confidenceThreshold);
-				shadow = {
-					ts: Date.now(),
-					question: args.question,
-					...typeof args.confidence === "number" ? { confidence: args.confidence } : {},
-					shouldEscalate: classification.shouldEscalate,
-					reason: classification.reason,
-					suggestWebSearch: classification.suggestWebSearch,
-					provider: jevResult ? "jev" : "local",
-					...jevError === void 0 ? {} : { jevError },
-					...jevLatencyMs === void 0 ? {} : { jevLatencyMs },
-					...repeatCount > 0 ? { repeatCount } : {},
-					...jevResult?.rawAnswers ? { scores: jevResult.rawAnswers } : {},
-					...jevResult?.model ? { model: jevResult.model } : {}
+				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 repeatCount = service.getRepeatPressure(sessionLog?.id)?.count ?? 0;
+				const forcedByRepeat = repeatCount >= 3;
+				let shadow;
+				let shadowWritten = false;
+				const recordShadow = (launched) => {
+					if (!shadow || shadowWritten) return;
+					shadowWritten = true;
+					appendShadowSample({
+						...shadow,
+						launched
+					});
 				};
-				if (!classification.shouldEscalate) {
-					recordShadow(false);
-					if (classification.suggestWebSearch && cfg.trigger.allowWebFallback) return {
-						sessionId: "",
-						advice: `前置分类器建议不启动顾问群：${classification.reason}`,
+				if (args.sessionId) {
+					if (!args.followUp) return {
+						sessionId: args.sessionId,
+						advice: "继续追问需要提供 followUp 参数。",
 						skipped: true,
-						reason: "web-search-recommended"
+						reason: "missing-follow-up"
 					};
-					return {
-						sessionId: "",
-						advice: `前置分类器建议不启动顾问群：${classification.reason}`,
+					const session = service.getSession(args.sessionId);
+					if (!session) return {
+						sessionId: args.sessionId,
+						advice: "顾问群会话不存在或已过期，请重新发起 ask_advisors。",
+						skipped: true,
+						reason: "session-not-found"
+					};
+					if (service.isSessionRunning(session.id)) return {
+						sessionId: session.id,
+						advice: "该顾问群会话正在运行中，请等本轮结束后再追问。",
+						skipped: true,
+						reason: "session-running"
+					};
+					if (service.hasReachedMaxRounds(session)) return {
+						sessionId: session.id,
+						advice: "本轮已是顾问群讨论的最后一轮，请综合现有顾问意见给出最终答复，不要再追问。",
 						skipped: true,
-						reason: "classifier-rejected"
+						reason: "max-rounds-reached"
+					};
+					service.appendFollowUp(session.id, args.followUp, sessionLog);
+					const summary = await service.runOneRoundAndSummarize(session, exec.signal, sessionLog, exec.agent);
+					const canContinue = !service.hasReachedMaxRounds(session);
+					return {
+						sessionId: session.id,
+						advice: formatConversation(session) + formatRiskNotes(summary) + (canContinue ? "\n\n（如需继续，可再次传入 sessionId 和 followUp 追问。）" : "\n\n（讨论轮数已达上限，请综合顾问意见给出最终答复。）"),
+						skipped: false
 					};
 				}
-			} else if (cfg.trigger.requireClassifier) shadow = {
-				ts: Date.now(),
-				question: args.question,
-				shouldEscalate: true,
-				reason: mentionedAdvisorGroup ? "用户点名 @顾问群，跳过前置分类器。" : `同一问题已重复 ${repeatCount} 次，强制升级跳过前置分类器。`,
-				suggestWebSearch: false,
-				provider: "bypass",
-				bypass: mentionedAdvisorGroup ? "mention" : "repeat",
-				repeatCount
-			};
-			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) {
+				if (!args.question) return {
+					sessionId: "",
+					advice: "发起新讨论需要提供 question 参数。",
+					skipped: true,
+					reason: "missing-question"
+				};
+				if (cfg.trigger.requireClassifier && !mentionedAdvisorGroup && !forcedByRepeat) {
+					let classification;
+					let jevResult;
+					let jevError;
+					let jevLatencyMs;
+					const jev = cfg.trigger.jev;
+					if (jev?.enabled) {
+						const jevStartedAt = Date.now();
+						try {
+							jevResult = await classifyWithJev(args.question, args.context, cfg.advisors, jev, exec.signal, typeof args.questionEn === "string" ? args.questionEn : void 0);
+							classification = jevResult;
+						} catch (error) {
+							if (exec.signal.aborted) throw error;
+							jevError = error instanceof Error ? error.message : String(error);
+							console.warn("[dsh-advisor-group] Jev 分类失败，回退到本地分类器：", sessionLog?.id ?? "no-session", jevError);
+						} finally {
+							jevLatencyMs = Date.now() - jevStartedAt;
+						}
+					}
+					classification ??= classifyRequest(args.question, args.context, cfg.advisors, args.confidence, cfg.trigger.confidenceThreshold);
+					shadow = {
+						ts: Date.now(),
+						question: args.question,
+						...typeof args.confidence === "number" ? { confidence: args.confidence } : {},
+						shouldEscalate: classification.shouldEscalate,
+						reason: classification.reason,
+						suggestWebSearch: classification.suggestWebSearch,
+						provider: jevResult ? "jev" : "local",
+						...jevError === void 0 ? {} : { jevError },
+						...jevLatencyMs === void 0 ? {} : { jevLatencyMs },
+						...repeatCount > 0 ? { repeatCount } : {},
+						...jevResult?.rawAnswers ? { scores: jevResult.rawAnswers } : {},
+						...jevResult?.model ? { model: jevResult.model } : {}
+					};
+					if (!classification.shouldEscalate) {
+						recordShadow(false);
+						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"
+						};
+					}
+				} else if (cfg.trigger.requireClassifier) shadow = {
+					ts: Date.now(),
+					question: args.question,
+					shouldEscalate: true,
+					reason: mentionedAdvisorGroup ? "用户点名 @顾问群，跳过前置分类器。" : `同一问题已重复 ${repeatCount} 次，强制升级跳过前置分类器。`,
+					suggestWebSearch: false,
+					provider: "bypass",
+					bypass: mentionedAdvisorGroup ? "mention" : "repeat",
+					repeatCount
+				};
+				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) {
+						recordShadow(false);
+						return {
+							sessionId: "",
+							advice: "未匹配到任何指定顾问，请检查 advisorIds 是否与设置中的顾问 id 一致。",
+							skipped: true,
+							reason: "no-matching-advisors"
+						};
+					}
+				}
+				const costGuard = service.tryStartConsultation();
+				if (!costGuard.ok) {
 					recordShadow(false);
 					return {
 						sessionId: "",
-						advice: "未匹配到任何指定顾问，请检查 advisorIds 是否与设置中的顾问 id 一致。",
+						advice: costGuard.reason,
 						skipped: true,
-						reason: "no-matching-advisors"
+						reason: "daily-limit-reached"
 					};
 				}
-			}
-			const costGuard = service.tryStartConsultation();
-			if (!costGuard.ok) {
-				recordShadow(false);
+				const session = service.createSession(args.question, args.context, args.advisorIds, sessionLog ? sessionLog.header.cwd : void 0, sessionLog ? sessionLog.id : void 0);
+				if (sessionLog) appendAdvisorStart(sessionLog, session);
+				recordShadow(true);
+				const summary = await service.runAutoPipeline(session, exec.signal, sessionLog, exec.agent);
 				return {
-					sessionId: "",
-					advice: costGuard.reason,
-					skipped: true,
-					reason: "daily-limit-reached"
+					sessionId: session.id,
+					advice: formatConversation(session) + (summary.conclusion ? `\n\n【综合结论】\n${summary.conclusion}` : "") + formatRiskNotes(summary) + (service.hasReachedMaxRounds(session) ? "\n\n（已达设置的最大讨论轮数，请参考上述顾问意见与综合结论给出最终答复。）" : ""),
+					skipped: false
 				};
 			}
-			const session = service.createSession(args.question, args.context, args.advisorIds, sessionLog ? sessionLog.header.cwd : void 0, sessionLog ? sessionLog.id : void 0);
-			if (sessionLog) appendAdvisorStart(sessionLog, session);
-			recordShadow(true);
-			const summary = await service.runAutoPipeline(session, exec.signal, sessionLog, exec.agent);
-			return {
-				sessionId: session.id,
-				advice: formatConversation(session) + (summary.conclusion ? `\n\n【综合结论】\n${summary.conclusion}` : "") + formatRiskNotes(summary) + (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",
+		}),
+		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) };
+			}
+		}),
+		defineTool({
+			name: "ask_session",
+			description: "Ask another EXISTING ordinary session (another window/tab the user opened) a question, wake it, and return what that session said. Use ONLY when the user explicitly asks to ask another session/window (「去问另一个会话」「问一下那个窗口」). It wakes the target session and consumes its quota. The returned text is NOT a one-to-one reply: it is everything the target said between the delivery receipt and its next whole-session idle, so never present it as \"the answer to my message\". When the target title is ambiguous you MUST return the candidates and let the user choose — never guess. Never use it for subagent sessions or for yourself.",
+			parameters: {
+				target: {
+					type: "string",
+					description: "The target session: its full sessionId, its exact display title, or a natural partial name — the workspace/directory name the user mentioned is enough (「极简遥控器」 matches sessions under I:\\极简遥控器\\…). One unique match is used directly; several matches return the candidates (running / most recently active first) for the user to choose — never guess. Pass the name the user said — do NOT search log files or directories for session ids.",
 					required: true
-				} }
+				},
+				question: {
+					type: "string",
+					description: "The question to hand over. It is permanently recorded in the target session log, so write it self-contained.",
+					required: true
+				},
+				context: {
+					type: "string",
+					description: "Optional background the target needs. Default: none. Anything sent here stays in the target session log forever, so send only what is necessary."
+				},
+				waitMs: {
+					type: "number",
+					description: `How long to wait for the target to finish, in milliseconds (default ${ASK_WAIT_DEFAULT_MS}, max ${ASK_WAIT_MAX_MS}). On timeout the already-collected text is returned and the target is NOT interrupted.`
+				}
 			},
-			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) };
-		}
-	})];
+			output: {
+				schema: {
+					type: "object",
+					additionalProperties: false,
+					properties: {
+						ok: {
+							type: "boolean",
+							required: true
+						},
+						target: {
+							type: "object",
+							additionalProperties: false,
+							properties: {
+								sessionId: {
+									type: "string",
+									required: true
+								},
+								name: {
+									type: "string",
+									required: true
+								}
+							}
+						},
+						delivered: {
+							type: "string",
+							enum: ["native", "fallback"]
+						},
+						askId: { type: "string" },
+						interval: {
+							type: "object",
+							additionalProperties: false,
+							properties: {
+								from: {
+									type: "string",
+									required: true
+								},
+								to: { oneOf: [{ type: "string" }, { type: "null" }] },
+								endedBecause: {
+									type: "string",
+									enum: [
+										"idle",
+										"timeout",
+										"error"
+									],
+									required: true
+								}
+							},
+							required: true
+						},
+						answer: {
+							type: "string",
+							required: true
+						},
+						note: {
+							type: "string",
+							required: true
+						},
+						error: { type: "string" },
+						message: { type: "string" },
+						candidates: {
+							type: "array",
+							items: {
+								type: "object",
+								additionalProperties: false,
+								properties: {
+									sessionId: {
+										type: "string",
+										required: true
+									},
+									name: {
+										type: "string",
+										required: true
+									},
+									hint: {
+										type: "string",
+										required: true
+									}
+								}
+							}
+						}
+					}
+				},
+				render: (_args, value) => value.ok === true ? renderAskResult({
+					answer: String(value.answer ?? ""),
+					note: String(value.note ?? "")
+				}) : [{
+					type: "text",
+					text: `【ask_session 未完成：${String(value.error ?? "unknown")}】\n${String(value.message ?? "")}${Array.isArray(value.candidates) && value.candidates.length > 0 ? `\n候选会话：\n${value.candidates.map((item) => `- ${String(item.name ?? "")} · ${String(item.sessionId ?? "")}`).join("\n")}` : ""}`
+				}]
+			},
+			async execute(args, exec) {
+				const controller = getSessionController(ctx);
+				if (!controller) return {
+					ok: false,
+					error: "service-missing",
+					message: "此功能需要较新的 DSH 宿主：当前宿主没有提供 sessionController 服务，无法向其他会话投递问题。",
+					answer: "",
+					note: "",
+					interval: errorInterval()
+				};
+				const session = exec.agent?.session ?? getCurrentSessionFrom(exec);
+				const sessionId = session?.id;
+				if (typeof sessionId !== "string" || sessionId.length === 0) return {
+					ok: false,
+					error: "service-missing",
+					message: "无法确定当前会话的身份（工具执行上下文没有暴露会话），已拒绝投递。",
+					answer: "",
+					note: "",
+					interval: errorInterval()
+				};
+				const question = typeof args.question === "string" ? args.question : "";
+				const context = typeof args.context === "string" ? args.context : void 0;
+				let senderName = "未命名会话";
+				try {
+					const own = (await controller.list({}, exec.signal)).items.find((item) => item.sessionId === sessionId);
+					if (own) senderName = sessionDisplayName(own);
+				} catch {}
+				const cardLog = session;
+				const onDelivered = (info) => {
+					if (!cardLog) return;
+					try {
+						appendAskStart(cardLog, info);
+					} catch (error) {
+						console.warn("[dsh-advisor-group] 跨会话卡片（开始）写入失败：", error);
+					}
+				};
+				const onSettled = (info) => {
+					if (!cardLog) return;
+					try {
+						appendAskAnswer(cardLog, info);
+					} catch (error) {
+						console.warn("[dsh-advisor-group] 跨会话卡片（结束）写入失败：", error);
+					}
+				};
+				const value = await askSession(ctx, exec.signal, {
+					onDelivered,
+					onSettled,
+					currentSessionId: sessionId,
+					senderName,
+					currentEvents: readCurrentEvents(session),
+					target: typeof args.target === "string" ? args.target : "",
+					question,
+					context,
+					waitMs: args.waitMs,
+					log: (message) => console.log(`[dsh-advisor-group] ask_session: ${message}`)
+				});
+				if (value.ok !== true) return {
+					ok: false,
+					error: String(value.error ?? "delivery-failed"),
+					message: String(value.message ?? ""),
+					...Array.isArray(value.candidates) ? { candidates: value.candidates } : {},
+					answer: "",
+					note: "",
+					interval: errorInterval()
+				};
+				return {
+					ok: true,
+					target: value.target,
+					delivered: value.delivered,
+					askId: String(value.askId ?? ""),
+					interval: value.interval,
+					answer: String(value.answer ?? ""),
+					note: String(value.note ?? "")
+				};
+			}
+		})
+	];
+}
+/**
+* Current session id from the tool execution context. `exec.agent.session` is
+* the Agent on whose behalf the call runs (same access `ask_advisors` uses for
+* `exec.agent?.session`); the fallback covers hosts that only expose a raw
+* session object on the execution input.
+*/
+function getCurrentSessionFrom(exec) {
+	return exec?.session;
+}
+/** Read this session's own log for the inbound-source / hop guard; empty on failure. */
+function readCurrentEvents(session) {
+	try {
+		return session?.snapshotEvents() ?? [];
+	} catch {
+		return [];
+	}
+}
+/** Empty interval carried on every not-ok result (no reply window ever opened). */
+function errorInterval() {
+	return {
+		from: (/* @__PURE__ */ new Date()).toISOString(),
+		endedBecause: "error"
+	};
 }
 function formatRiskNotes(summary) {
 	return summary.riskNotes.length > 0 ? `\n\n【风险提示】\n${summary.riskNotes.join("\n")}` : "";
@@ -4040,12 +4970,95 @@ function handleStreamRequest(req, res) {
 		subscribe(sessionId, res, lastEventId, bootId);
 	});
 }
+/** First value of a possibly repeated header field. */
+function headerValue(value) {
+	return Array.isArray(value) ? value[0] ?? "" : value ?? "";
+}
+/** Origin of an http(s) URL; `''` for absent, opaque (`null`) or non-web values. */
+function webOrigin(value) {
+	if (value === "" || value === "null") return "";
+	try {
+		const parsed = new URL(value);
+		return parsed.protocol === "http:" || parsed.protocol === "https:" ? parsed.origin : "";
+	} catch {
+		return "";
+	}
+}
+/**
+* True when the handshake request may be handed the token. Only a *provably
+* foreign web page* is refused: an `Origin`/`Referer` that parses as http(s) on
+* another host. Same-origin pages pass, and so do callers carrying no web
+* provenance at all — the desktop shell, which forwards the page's request
+* without those headers, and any local program, which could forge them anyway.
+*
+* What actually keeps the token from a foreign page is not this check but the
+* absent CORS header: a cross-origin fetch cannot read a response body without
+* `Access-Control-Allow-Origin`, and this route never sends one. The check only
+* decides whether a foreign page is answered at all.
+*/
+function mayReadBootToken(req) {
+	const host = headerValue(req.headers.host);
+	const fromForeignPage = (value) => {
+		const origin = webOrigin(value);
+		if (origin === "" || host === "") return false;
+		return origin !== `http://${host}` && origin !== `https://${host}`;
+	};
+	if (fromForeignPage(headerValue(req.headers.origin))) return false;
+	if (fromForeignPage(headerValue(req.headers.referer))) return false;
+	return true;
+}
+/** Set once the process has logged an accepted handshake (refusals always log). */
+let bootTokenAcceptedLogged = false;
+/**
+* Records one handshake attempt in
+* `$DSH_HOME/storages/advisor-group/boot-token.log`. Whether the desktop shell's
+* request even reaches this route is otherwise invisible from outside the app,
+* so each decision leaves a line; the file keeps only its most recent lines.
+* Query strings are dropped and the referer is reduced to its origin, so no
+* token can land in the log. A write failure never breaks the handshake.
+*/
+function recordBootTokenAttempt(req, allowed) {
+	if (allowed && bootTokenAcceptedLogged) return;
+	bootTokenAcceptedLogged = true;
+	try {
+		const dshHome = process.env.DSH_HOME || join(homedir(), ".dsh");
+		const target = join(dshHome, "storages", "advisor-group", "boot-token.log");
+		const line = `${[
+			(/* @__PURE__ */ new Date()).toISOString(),
+			allowed ? "allow" : "deny",
+			`site=${headerValue(req.headers["sec-fetch-site"]) || "-"}`,
+			`origin=${headerValue(req.headers.origin) || "-"}`,
+			`referer=${webOrigin(headerValue(req.headers.referer)) || "-"}`,
+			`host=${headerValue(req.headers.host) || "-"}`,
+			`ua=${headerValue(req.headers["user-agent"]).slice(0, 48) || "-"}`
+		].join(" ")}\n`;
+		mkdirSync(dirname(target), { recursive: true });
+		appendFileSync(target, line);
+		if (statSync(target).size > 8192) writeFileSync(target, readFileSync(target, "utf8").split("\n").slice(-20).join("\n"));
+	} catch {}
+}
 function handleConfigRequest(ctx, scopedCtx, service, authToken) {
 	const namespace = "dsh-advisor-group";
 	return async (req, res) => {
 		const rawUrl = req.url ?? "";
 		const url = new URL(rawUrl, "http://localhost");
 		const pathname = url.pathname.replace(/\/+$/, "") || "/";
+		if (req.method === "GET" && (pathname === "/advisor-group/boot-token" || pathname === "/advisor-group/boot-token/")) {
+			const allowed = mayReadBootToken(req);
+			recordBootTokenAttempt(req, allowed);
+			if (!allowed) {
+				sendJson(res, 403, {
+					ok: false,
+					error: "forbidden"
+				});
+				return;
+			}
+			sendJson(res, 200, {
+				ok: true,
+				token: authToken
+			});
+			return;
+		}
 		const token = String(req.headers["x-advisor-group-token"] ?? url.searchParams.get("token") ?? "");
 		if (authToken && token !== authToken) {
 			sendJson(res, 401, {
@@ -4334,7 +5347,7 @@ function apply(ctx, config) {
 	reportPromptGuardFindings(guarded.findings);
 	const service = new AdvisorGroupService(ctx, guarded.config);
 	registerAdvisorSettingsAndRoutes(ctx, guarded.config, service);
-	for (const tool of registerAdvisorTools(service)) ctx.tools.register(tool);
+	for (const tool of registerAdvisorTools(service, ctx)) ctx.tools.register(tool);
 	const systemPrompt = ctx.systemPrompt;
 	if (systemPrompt) ctx.effect(() => systemPrompt.section({
 		name: "advisor-group-boundary",