dsh-advisor-group 0.1.3 → 0.1.4

package/lib/index.mjs

@@ -1,6 +1,6 @@
 import Schema from "@deepseek-ai/schemastery";
 import { randomUUID } from "node:crypto";
-import { appendFileSync, mkdirSync, promises, readFileSync, readdirSync, rmSync, statSync, unlinkSync, writeFileSync } from "node:fs";
+import { appendFileSync, mkdirSync, promises, readFileSync, readdirSync, renameSync, 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";
@@ -114,12 +114,29 @@ const QuotaConfig = Schema.object({
 	enabled: Schema.boolean().default(true).description("Enable the daily new-consultation cap (cost safety valve)."),
 	maxPerDay: Schema.natural().min(1).max(1e5).default(50).description("Max new consultations per UTC day (1–100000); ignored when enabled is false.")
 });
+const SwarmConfig = Schema.object({
+	enabled: Schema.boolean().default(true).description("Master switch for cross-session asks; off makes ask_session / list_sessions / ask_result refuse with swarm-disabled."),
+	defaultMode: Schema.union([Schema.const("wait"), Schema.const("detach")]).default("wait").description("Default response mode when the caller omits both waitMs and detach: wait (block for the answer) or detach (return an askId, read later with ask_result)."),
+	defaultWaitMs: Schema.number().min(1e3).max(6e5).default(18e4).description("Default wait ceiling in milliseconds when the caller omits waitMs (1–10 minutes)."),
+	resultTtlHours: Schema.number().min(1).max(720).default(24).description("How long detached ask results are kept on disk, in hours (clamped to 1–720 before pruning)."),
+	rosterIncludeSubagents: Schema.boolean().default(false).description("List subagent sessions in the session roster."),
+	routingEnabled: Schema.boolean().default(true).description("Route an unnamed question to candidate sessions by keyword (no model call) instead of guessing a target; off keeps the old missing-target refusal."),
+	routingTopN: Schema.number().min(1).max(8).default(3).description("How many routing candidates ask_session returns when the caller names no target (1–8)."),
+	routingEngine: Schema.union([Schema.const("local"), Schema.const("jev")]).default("local").description("Which engine orders the routing candidates: local (keyword scorer alone, default) or jev (recall stays local, then Jev re-ranks the closed candidate list; any Jev failure falls back to the local order silently). Jev reuses the trigger Jev credentials/endpoint."),
+	routingAsk: Schema.union([
+		Schema.const("off"),
+		Schema.const("gated"),
+		Schema.const("always")
+	]).default("gated").description("Whether a user turn asks Jev for a cross-session suggestion: off (never), gated (default; only when the local, network-free prefilter thinks the turn points at another session/task) or always (one batched Jev call on every turn). The answer is only a one-turn hint; nothing is delivered."),
+	routingExclude: Schema.array(Schema.string()).default([]).description("Sessions excluded from the whole swarm: each entry matches a session id (exact, case-insensitive) or is a case-insensitive substring of its title / fallback display name. Excluded sessions are hidden from the roster and routing candidates, their routing aliases are dropped, and an explicit ask_session target that resolves to one is refused.")
+});
 const Config = Schema.object({
 	enabled: Schema.boolean().default(true).volatile(),
 	discussion: DiscussionConfig.volatile(),
 	trigger: TriggerConfig.volatile(),
 	ui: UiConfig.volatile(),
 	quota: QuotaConfig.volatile(),
+	swarm: SwarmConfig.volatile(),
 	advisors: Schema.array(AdvisorConfig).default([]).volatile()
 });
 function unwrapVolatileConfig(value) {
@@ -280,6 +297,12 @@ async function callViaCtxLlm(ctx, advisor, transcript, signal, onDelta, timeoutM
 }
 //#endregion
 //#region src/providers/presets.ts
+/**
+* Stable routing key OpenCode Go asks every client for. A fixed value makes the
+* same trade-off the DSH-side route took on 2026-09-17 (static header: works
+* immediately, costs cache locality) — per-conversation ids stay an upgrade.
+*/
+const OPENCODE_GO_SESSION_ID = "dsh-advisor-group";
 const PROVIDER_PRESETS = {
 	deepseek: {
 		id: "deepseek",
@@ -701,6 +724,72 @@ const PROVIDER_PRESETS = {
 		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）。"
+	},
+	/**
+	* OpenCode Go — subscription plan ($10/月 Go、$40/月 Go Plus). KB X:
+	* `01-AI大模型供应/opencode/05-Console/05-Go.md`（2026-10-06 收录）。
+	*
+	* Live probe (2026-10-06, `GET/POST https://opencode.ai/zen/go/v1/…`) settled
+	* two things the KB table alone did not: the gateway serves nearly the whole
+	* catalogue on **both** surfaces (its per-model table describes the OpenCode
+	* client's preferred routing, not a hard restriction), and the Anthropic
+	* surface authenticates with `x-api-key` — a Bearer header there comes back
+	* as 「Missing API key」. Only `grok-4.6`/`grok-4.7` are excluded: they answer
+	* 「not supported for format oa-compat」/「…format anthropic」, i.e. they need
+	* the `/v1/responses` API, which neither the direct-HTTP path nor these
+	* presets speak.
+	*/
+	"opencode-go-openai": {
+		id: "opencode-go-openai",
+		label: "OpenCode Go（订阅制 · OpenAI 兼容）",
+		protocol: "openai",
+		baseURL: "https://opencode.ai/zen/go/v1",
+		apiKeyEnv: "OPENCODE_GO_API_KEY",
+		defaultModels: [
+			"glm-5.3-flash",
+			"glm-5.3",
+			"glm-5.2",
+			"kimi-k3",
+			"kimi-k2.7-code",
+			"kimi-k2.6",
+			"longcat-2.0",
+			"longcat-2.5-preview-free",
+			"deepseek-v4.1-flash",
+			"deepseek-v4-pro",
+			"deepseek-v4-flash",
+			"deepseek-v4-flash-vision-exp",
+			"mimo-v2.6-flash",
+			"mimo-v2.6-pro",
+			"mimo-v2.5",
+			"mimo-v2.5-pro",
+			"hy4-preview",
+			"hy3",
+			"space-bunny"
+		],
+		authMode: "bearer",
+		modelsBaseURL: "https://opencode.ai/zen/go/v1",
+		modelsAuthMode: "bearer",
+		headers: { "x-opencode-session": OPENCODE_GO_SESSION_ID },
+		notes: "订阅制：在 opencode.ai/console 订阅后复制 API key（Go $10/月、Go Plus $40/月）。这条端点用 Authorization: Bearer，并要求每次请求带稳定的 x-opencode-session 会话号——直连通道用固定标识 dsh-advisor-group，DSH 线路则由宿主按会话自动带。grok-4.6/4.7 只能用 /v1/responses（插件不支持），故不在清单内。"
+	},
+	"opencode-go-anthropic": {
+		id: "opencode-go-anthropic",
+		label: "OpenCode Go（订阅制 · Anthropic 兼容）",
+		protocol: "anthropic",
+		baseURL: "https://opencode.ai/zen/go/v1",
+		apiKeyEnv: "OPENCODE_GO_API_KEY",
+		defaultModels: [
+			"minimax-m3",
+			"minimax-m2.7",
+			"qwen3.8-max",
+			"qwen3.8-flash",
+			"qwen3.7-plus"
+		],
+		authMode: "x-api-key",
+		modelsBaseURL: "https://opencode.ai/zen/go/v1",
+		modelsAuthMode: "bearer",
+		headers: { "x-opencode-session": OPENCODE_GO_SESSION_ID },
+		notes: "同一份订阅与 key，走 Anthropic 的 /v1/messages。**认证必须用 x-api-key（不是 Bearer）**——2026-10-06 实测：Bearer 会被网关判为未携带钥匙而 401；插件会自动补 anthropic-version。可用的模型与 OpenAI 兼容那条基本相同，选一条即可。"
 	}
 };
 function getProviderPreset(id) {
@@ -923,10 +1012,10 @@ async function streamDirectHttp(advisor, transcript, onDelta, signal, timeoutMs,
 	let result;
 	switch (protocol) {
 		case "openai":
-			result = await streamOpenAICompatible(baseURL, advisor, apiKey, transcriptText, onDelta, signal, timeoutMs, tools);
+			result = await streamOpenAICompatible(baseURL, advisor, apiKey, transcriptText, onDelta, signal, timeoutMs, tools, preset?.headers);
 			break;
 		case "anthropic":
-			result = await streamAnthropic(baseURL, advisor, apiKey, transcriptText, authMode, onDelta, signal, timeoutMs, tools);
+			result = await streamAnthropic(baseURL, advisor, apiKey, transcriptText, authMode, onDelta, signal, timeoutMs, tools, preset?.headers);
 			break;
 		case "gemini": {
 			const content = await callGemini(baseURL, advisor, apiKey, transcriptText, signal, timeoutMs);
@@ -950,7 +1039,7 @@ async function streamDirectHttp(advisor, transcript, onDelta, signal, timeoutMs,
 	}
 	return result;
 }
-async function streamOpenAICompatible(baseURL, advisor, apiKey, transcriptText, onDelta, signal, timeoutMs, tools) {
+async function streamOpenAICompatible(baseURL, advisor, apiKey, transcriptText, onDelta, signal, timeoutMs, tools, extraHeaders) {
 	const endpoint = baseURL.endsWith("/chat/completions") ? baseURL : `${baseURL.replace(/\/+$/, "")}/chat/completions`;
 	const pair = timeoutSignalPair(timeoutMs ?? 12e4, signal);
 	const body = {
@@ -979,7 +1068,8 @@ async function streamOpenAICompatible(baseURL, advisor, apiKey, transcriptText,
 		method: "POST",
 		headers: {
 			"content-type": "application/json",
-			authorization: `Bearer ${apiKey}`
+			authorization: `Bearer ${apiKey}`,
+			...extraHeaders
 		},
 		body: JSON.stringify(body),
 		signal: pair.signal
@@ -1080,11 +1170,12 @@ function collectToolCalls(byIndex) {
 	}
 	return calls.length > 0 ? calls : void 0;
 }
-async function streamAnthropic(baseURL, advisor, apiKey, transcriptText, authMode, onDelta, signal, timeoutMs, tools) {
+async function streamAnthropic(baseURL, advisor, apiKey, transcriptText, authMode, onDelta, signal, timeoutMs, tools, extraHeaders) {
 	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"
+		"anthropic-version": "2023-06-01",
+		...extraHeaders
 	};
 	if (authMode === "bearer") headers["authorization"] = `Bearer ${apiKey}`;
 	else headers["x-api-key"] = apiKey;
@@ -3109,10 +3200,32 @@ function parseResponse(body, config, advisors) {
 		provider: config.provider
 	};
 }
-async function classifyWithJev(question, context, advisors, config, signal, questionEn) {
-	const endpoint = config.baseURL?.trim() || DEFAULT_ENDPOINTS[config.provider];
+/** The effective endpoint for a Jev config. */
+function jevEndpointOf(config) {
+	return config.baseURL?.trim() || DEFAULT_ENDPOINTS[config.provider];
+}
+/** The effective API key: the configured env var first, then the stored key. */
+function jevApiKeyOf(config) {
 	const storedKey = typeof config.apiKey === "string" ? config.apiKey : config.apiKey && typeof config.apiKey === "object" && "value" in config.apiKey ? String(config.apiKey.value ?? "") : void 0;
-	const apiKey = (config.apiKeyEnv ? process.env[config.apiKeyEnv] : void 0) || storedKey;
+	return (config.apiKeyEnv ? process.env[config.apiKeyEnv] : void 0) || storedKey;
+}
+/**
+* True when Jev can actually be called: a config exists and resolves to a
+* non-empty API key. The routing engine uses this to tell "not configured"
+* (local order plus a note) from "configured but failed" (silent fallback).
+*/
+function jevConfigured(config) {
+	if (config === void 0 || config === null || typeof config !== "object") return false;
+	const key = jevApiKeyOf(config);
+	return key !== void 0 && key.length > 0;
+}
+/**
+* POST one serialised payload to the configured Jev endpoint. Timeout and the
+* caller's abort signal are handled once, here, for every request shape.
+*/
+async function postJev(config, payload, signal) {
+	const endpoint = jevEndpointOf(config);
+	const apiKey = jevApiKeyOf(config);
 	if (!apiKey) throw new Error("Jev 未配置 API key");
 	const controller = new AbortController();
 	const timeout = setTimeout(() => controller.abort(/* @__PURE__ */ new Error(`Jev 超时（${config.timeoutMs}ms）`)), config.timeoutMs);
@@ -3125,211 +3238,1833 @@ async function classifyWithJev(question, context, advisors, config, signal, ques
 				authorization: `Bearer ${apiKey}`,
 				"content-type": "application/json"
 			},
-			body: JSON.stringify({
-				state: config.useEnglishState && questionEn?.trim() ? questionEn.trim() : `${question}\n\n背景：${context || "无"}`,
-				model: config.model || "jev-latest",
-				questions: {
-					needs_advisor: {
-						type: "noul",
-						instructions: "Does answering this question require expert-level knowledge?",
-						criteria: {
-							true: {
-								what: "The subject matter is professional, specialist, or long-tail knowledge a competent generalist would not reliably get right, or the field itself has no single settled answer without specialist judgment.",
-								examples: [
-									"professional-domain judgment such as accounting treatment, engineering trade-offs, or contract drafting",
-									"rare or long-tail situations with little public consensus",
-									"topics where reasonable experts disagree and picking correctly matters"
-								]
-							},
-							false: {
-								what: "A competent generalist can answer from common knowledge, widely documented facts, or ordinary reasoning without specialist judgment.",
-								examples: ["everyday facts, definitions, or casual opinions", "well-documented mainstream topics with an agreed answer"]
-							}
-						}
-					},
-					web_search: {
-						type: "noul",
-						instructions: "Does answering this question primarily require current, real-time, or externally verifiable information?",
-						criteria: {
-							true: {
-								what: "The correct answer depends on facts that change over time or live outside the provided state, so it must be looked up rather than reasoned out.",
-								examples: [
-									"today’s weather, prices, exchange rates, or quotes",
-									"recent releases, news, or version-specific changelogs",
-									"local or niche facts with no authoritative source in memory"
-								]
-							},
-							false: {
-								what: "The answer follows from stable knowledge or reasoning already available in the state.",
-								examples: ["concepts, definitions, and established best practices", "questions fully answerable from the provided background"]
-							}
-						}
-					},
-					high_risk: {
-						type: "noul",
-						instructions: "Does this question involve medical, legal, financial, safety, compliance, or other high-risk advice?",
-						criteria: {
-							true: {
-								what: "A wrong or careless answer could materially harm the asker or a third party in health, money, safety, or legal standing.",
-								examples: [
-									"medical symptoms, medication, diagnosis, or treatment decisions",
-									"legal rights, contracts, litigation, or regulatory compliance",
-									"investment, insurance, tax, or other money decisions with real downside",
-									"physical safety, hazardous actions, or regulated activities"
-								]
-							},
-							false: {
-								what: "Being wrong carries no material harm to health, money, safety, or legal standing.",
-								examples: ["general knowledge, opinions, or entertainment questions", "technical details whose worst case is wasted time"]
-							}
-						}
-					},
-					domain: {
-						type: "choice",
-						instructions: "Which domain best describes this question?",
-						criteria: {
-							legal: "law, contracts, litigation, compliance, or taxation",
-							medical: "medicine, symptoms, medication, diagnosis, or treatment",
-							finance: "investment, insurance, accounting, or financial risk",
-							code: "software, programming, architecture, debugging, or APIs",
-							general: "none of the listed domains"
-						}
-					}
-				}
-			}),
+			body: payload,
 			signal: controller.signal
 		});
 		if (!response.ok) throw new Error(`Jev HTTP ${response.status}`);
-		return parseResponse(await response.json(), config, advisors);
+		return await response.json();
 	} finally {
 		clearTimeout(timeout);
 		signal?.removeEventListener("abort", abort);
 	}
 }
+async function classifyWithJev(question, context, advisors, config, signal, questionEn) {
+	return parseResponse(await postJev(config, JSON.stringify({
+		state: config.useEnglishState && questionEn?.trim() ? questionEn.trim() : `${question}\n\n背景：${context || "无"}`,
+		model: config.model || "jev-latest",
+		questions: {
+			needs_advisor: {
+				type: "noul",
+				instructions: "Does answering this question require expert-level knowledge?",
+				criteria: {
+					true: {
+						what: "The subject matter is professional, specialist, or long-tail knowledge a competent generalist would not reliably get right, or the field itself has no single settled answer without specialist judgment.",
+						examples: [
+							"professional-domain judgment such as accounting treatment, engineering trade-offs, or contract drafting",
+							"rare or long-tail situations with little public consensus",
+							"topics where reasonable experts disagree and picking correctly matters"
+						]
+					},
+					false: {
+						what: "A competent generalist can answer from common knowledge, widely documented facts, or ordinary reasoning without specialist judgment.",
+						examples: ["everyday facts, definitions, or casual opinions", "well-documented mainstream topics with an agreed answer"]
+					}
+				}
+			},
+			web_search: {
+				type: "noul",
+				instructions: "Does answering this question primarily require current, real-time, or externally verifiable information?",
+				criteria: {
+					true: {
+						what: "The correct answer depends on facts that change over time or live outside the provided state, so it must be looked up rather than reasoned out.",
+						examples: [
+							"today’s weather, prices, exchange rates, or quotes",
+							"recent releases, news, or version-specific changelogs",
+							"local or niche facts with no authoritative source in memory"
+						]
+					},
+					false: {
+						what: "The answer follows from stable knowledge or reasoning already available in the state.",
+						examples: ["concepts, definitions, and established best practices", "questions fully answerable from the provided background"]
+					}
+				}
+			},
+			high_risk: {
+				type: "noul",
+				instructions: "Does this question involve medical, legal, financial, safety, compliance, or other high-risk advice?",
+				criteria: {
+					true: {
+						what: "A wrong or careless answer could materially harm the asker or a third party in health, money, safety, or legal standing.",
+						examples: [
+							"medical symptoms, medication, diagnosis, or treatment decisions",
+							"legal rights, contracts, litigation, or regulatory compliance",
+							"investment, insurance, tax, or other money decisions with real downside",
+							"physical safety, hazardous actions, or regulated activities"
+						]
+					},
+					false: {
+						what: "Being wrong carries no material harm to health, money, safety, or legal standing.",
+						examples: ["general knowledge, opinions, or entertainment questions", "technical details whose worst case is wasted time"]
+					}
+				}
+			},
+			domain: {
+				type: "choice",
+				instructions: "Which domain best describes this question?",
+				criteria: {
+					legal: "law, contracts, litigation, compliance, or taxation",
+					medical: "medicine, symptoms, medication, diagnosis, or treatment",
+					finance: "investment, insurance, accounting, or financial risk",
+					code: "software, programming, architecture, debugging, or APIs",
+					general: "none of the listed domains"
+				}
+			}
+		}
+	}), signal), config, advisors);
+}
+/** The escape option: Jev says none of the listed candidates is the target. */
+const JEV_NONE_OPTION = "none";
+/** Finite numbers only, keyed by option id; undefined when nothing usable is left. */
+function numberMap(value) {
+	if (value === null || typeof value !== "object" || Array.isArray(value)) return void 0;
+	const out = {};
+	for (const [key, raw] of Object.entries(value)) {
+		const number = numberValue(raw);
+		if (number !== void 0) out[key] = number;
+	}
+	return Object.keys(out).length === 0 ? void 0 : out;
+}
+/**
+* Read one closed-set routing answer. Throws on anything unparseable (no
+* answers, no route answer, no usable choice) so the router keeps the local
+* order instead of acting on a guess.
+*/
+function parseRouteResponse(body) {
+	if (!body || typeof body !== "object") throw new Error("Jev 响应不是对象");
+	const answers = body.answers;
+	if (!answers || typeof answers !== "object") throw new Error("Jev 响应缺少 answers");
+	const answer = answers.route;
+	if (answer === null || typeof answer !== "object") throw new Error("Jev 响应缺少 route 判定");
+	const choice = typeof answer.choice === "string" ? answer.choice.trim() : "";
+	if (choice.length === 0) throw new Error("Jev 响应缺少 route.choice");
+	const probabilities = numberMap(answer.probabilities);
+	const confidence = numberValue(answer.confidence) ?? probabilities?.[choice] ?? (probabilities === void 0 ? void 0 : Math.max(...Object.values(probabilities)));
+	const reportedModel = body.model;
+	return {
+		choice,
+		...confidence === void 0 ? {} : { confidence },
+		...probabilities === void 0 ? {} : { probabilities },
+		...typeof reportedModel === "string" ? { model: reportedModel } : {}
+	};
+}
+/** Closed-set criteria for the candidates: id → `title — scope`, plus the escape. */
+function optionCriteria(options, noneText) {
+	const criteria = {};
+	for (const option of options) {
+		const id = typeof option.id === "string" ? option.id.trim() : "";
+		if (id.length === 0) continue;
+		const title = typeof option.title === "string" ? option.title.trim() : "";
+		const scope = typeof option.scope === "string" ? option.scope.trim() : "";
+		criteria[id] = scope.length > 0 ? `${title} — ${scope}` : title;
+	}
+	criteria[JEV_NONE_OPTION] = noneText;
+	return criteria;
+}
+/**
+* Ask Jev which routed candidate is the best target: one closed-set `choice`
+* question, English instructions, an explicit `none` escape, and the
+* candidates' own titles/scopes kept in their original language.
+*
+* Rejects (never resolves to a guess) on a missing key, an empty option list,
+* any transport/HTTP failure, or a malformed response; the router treats every
+* rejection as "keep the local order".
+*/
+async function routeWithJev(question, questionEn, options, config, signal) {
+	if (!jevConfigured(config)) throw new Error("Jev 未配置 API key");
+	if (!Array.isArray(options) || options.length === 0) throw new Error("Jev 路由没有候选可判断");
+	const criteria = optionCriteria(options, "None of the listed sessions is the right target for this question.");
+	const gloss = typeof questionEn === "string" ? questionEn.trim() : "";
+	const state = [
+		"A user asked a question and wants it sent to exactly one existing session. Choose the option whose session is the best target for that question.",
+		gloss.length > 0 ? `English gloss of the question: ${gloss}` : void 0,
+		`Question (verbatim, may be Chinese): ${question}`
+	].filter((line) => line !== void 0).join("\n");
+	return parseRouteResponse(await postJev(config, JSON.stringify({
+		state,
+		model: config.model || "jev-latest",
+		questions: { route: {
+			type: "choice",
+			instructions: "Pick exactly one option: the session this question should be sent to. Pick none when no listed session fits.",
+			criteria
+		} }
+	}), signal));
+}
+/** A noul answer's confidence: the explicit `confidence`, else the `noul` value. */
+function noulConfidence(answer) {
+	return numberValue(answer?.confidence) ?? numberValue(answer?.noul);
+}
+/** Read one batched judgment; throws unless `ask` and `sensitive` are usable. */
+function parseCrossSessionResponse(body) {
+	if (!body || typeof body !== "object") throw new Error("Jev 响应不是对象");
+	const answers = body.answers;
+	if (!answers || typeof answers !== "object") throw new Error("Jev 响应缺少 answers");
+	const askConfidence = noulConfidence(answers.ask);
+	if (askConfidence === void 0) throw new Error("Jev 响应缺少 ask 的有效判定");
+	const sensitiveConfidence = noulConfidence(answers.sensitive);
+	if (sensitiveConfidence === void 0) throw new Error("Jev 响应缺少 sensitive 的有效判定");
+	const pickAnswer = answers.pick;
+	const pick = pickAnswer !== null && typeof pickAnswer === "object" && typeof pickAnswer.choice === "string" ? pickAnswer.choice.trim() : "";
+	const probabilities = pickAnswer !== null && typeof pickAnswer === "object" ? numberMap(pickAnswer.probabilities) : void 0;
+	const pickConfidence = pick.length === 0 ? void 0 : numberValue(pickAnswer?.confidence) ?? probabilities?.[pick] ?? (probabilities === void 0 ? void 0 : Math.max(...Object.values(probabilities)));
+	const reportedModel = body.model;
+	return {
+		askConfidence,
+		sensitiveConfidence,
+		...pick.length === 0 ? {} : { pick },
+		...pickConfidence === void 0 ? {} : { pickConfidence },
+		...typeof reportedModel === "string" ? { model: reportedModel } : {}
+	};
+}
+/**
+* One batched judgment for the cross-session suggestion: `ask` (noul), `pick`
+* (choice, present only when there are candidates) and `sensitive` (noul) all
+* travel in a single request, so one hint costs one call. English
+* instructions; candidate titles/scopes stay in their original language.
+*
+* Throws when the response is missing or its ask/sensitive answers are
+* unusable; the caller treats that as "no hint".
+*/
+async function judgeCrossSessionWithJev(text, textEn, candidates, config, signal) {
+	if (!jevConfigured(config)) throw new Error("Jev 未配置 API key");
+	const options = Array.isArray(candidates) ? candidates : [];
+	const questions = {
+		ask: {
+			type: "noul",
+			instructions: "Should answering this turn consult another existing session of the same user?",
+			criteria: {
+				true: {
+					what: "The turn depends on facts that live in another session: the state, progress, recent changes, or version of a project or task that session has been working on.",
+					examples: [
+						"asking for the current progress or status of work started elsewhere",
+						"asking what a different session decided, changed, or last talked about",
+						"continuing a task whose details were only ever discussed in another session"
+					]
+				},
+				false: {
+					what: "The turn can be answered from this session alone, from general knowledge, or does not depend on any other session.",
+					examples: [
+						"self-contained coding or writing requests",
+						"general questions and opinions",
+						"questions about this very session only"
+					]
+				}
+			}
+		},
+		sensitive: {
+			type: "noul",
+			instructions: "Is this turn private or sensitive enough that it must not be routed to another session automatically?",
+			criteria: {
+				true: {
+					what: "The content carries secrets or personal or confidential material that should not leave this session on its own.",
+					examples: [
+						"credentials, API keys, tokens, passwords, or private keys",
+						"personal, medical, legal, or financial details about a person",
+						"content the user marked private, confidential, or off the record"
+					]
+				},
+				false: {
+					what: "Ordinary project, technical, or general questions with nothing private in them.",
+					examples: ["code, build, and repository questions", "general knowledge or everyday planning"]
+				}
+			}
+		}
+	};
+	if (options.length > 0) questions.pick = {
+		type: "choice",
+		instructions: "Which of these sessions is the best one to ask about this turn? Pick none when none of them fits.",
+		criteria: optionCriteria(options, "None of the listed sessions is the right target for this turn.")
+	};
+	const gloss = typeof textEn === "string" ? textEn.trim() : "";
+	const state = [
+		"A user turn arrived in one session of a coding agent. Judge that turn for the three questions in this request.",
+		gloss.length > 0 ? `English gloss of the turn: ${gloss}` : void 0,
+		`Turn (verbatim, may be Chinese): ${text}`
+	].filter((line) => line !== void 0).join("\n");
+	return parseCrossSessionResponse(await postJev(config, JSON.stringify({
+		state,
+		model: config.model || "jev-latest",
+		questions
+	}), signal));
+}
 //#endregion
-//#region src/cross-session.ts
+//#region src/ask-store.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.
+* Durable store for detached (async) asks: `ask_session` will deliver a
+* question now and collect the answer later, possibly in a later turn, so the
+* settled result must survive a turn boundary. One JSON file per ask under
+* `<baseDir>/asks/<askId>.json`; no host services, no timers.
 *
-* 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.
+* Follows the persistence conventions of this repo: plain `node:fs`,
+* atomic tmp+rename writes, and reads that degrade to `undefined` instead of
+* throwing on a missing or damaged file.
+*/
+/** askId doubles as a file name, so it must never escape the store directory. */
+const ASK_ID_PATTERN = /^[A-Za-z0-9._-]{1,80}$/;
+const STATES = /* @__PURE__ */ new Set([
+	"waiting",
+	"done",
+	"timeout",
+	"error"
+]);
+/** The store directory for a base dir such as `$DSH_HOME/storages/advisor-group`. */
+function askStoreDir(baseDir) {
+	return `${baseDir}/asks`;
+}
+function assertAskId(askId) {
+	if (!ASK_ID_PATTERN.test(askId)) throw new Error("invalid askId");
+}
+function isAskRecord(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const record = value;
+	return typeof record.askId === "string" && typeof record.sessionId === "string" && typeof record.question === "string" && typeof record.createdAt === "number" && typeof record.state === "string" && STATES.has(record.state);
+}
+function parseRecord(text) {
+	let value;
+	try {
+		value = JSON.parse(text);
+	} catch {
+		return;
+	}
+	return isAskRecord(value) ? value : void 0;
+}
+/**
+* Write one record atomically: tmp file + rename, so a concurrent reader never
+* sees a half-written JSON document. Creates `dir` when missing.
+*/
+function writeAskRecord(dir, record) {
+	assertAskId(record.askId);
+	mkdirSync(dir, { recursive: true });
+	const file = join(dir, `${record.askId}.json`);
+	const tmp = `${file}.tmp`;
+	writeFileSync(tmp, JSON.stringify(record, null, 2), "utf8");
+	renameSync(tmp, file);
+}
+/** Missing or unparsable records read as `undefined`; only a bad id throws. */
+function readAskRecord(dir, askId) {
+	assertAskId(askId);
+	try {
+		return parseRecord(readFileSync(join(dir, `${askId}.json`), "utf8"));
+	} catch {
+		return;
+	}
+}
+/** All valid records, newest `createdAt` first, optionally filtered. */
+function listAskRecords(dir, filter) {
+	let names;
+	try {
+		names = readdirSync(dir);
+	} catch {
+		return [];
+	}
+	const records = [];
+	for (const name of names) {
+		if (!name.endsWith(".json")) continue;
+		let text;
+		try {
+			text = readFileSync(join(dir, name), "utf8");
+		} catch {
+			continue;
+		}
+		const record = parseRecord(text);
+		if (record === void 0) continue;
+		if (filter?.sessionId !== void 0 && record.sessionId !== filter.sessionId) continue;
+		if (filter?.state !== void 0 && record.state !== filter.state) continue;
+		records.push(record);
+	}
+	records.sort((a, b) => b.createdAt - a.createdAt);
+	return records;
+}
+/**
+* Delete settled-or-ageing records (age keyed on `settledAt ?? createdAt`) and
+* stray `.tmp` files left by a crashed writer; returns how many files went.
+* Best-effort by design: a missing directory is 0, per-file failures are skipped.
+*/
+function pruneAskRecords(dir, olderThanMs, now = Date.now()) {
+	let names;
+	try {
+		names = readdirSync(dir);
+	} catch {
+		return 0;
+	}
+	const cutoff = now - olderThanMs;
+	let removed = 0;
+	for (const name of names) {
+		const file = join(dir, name);
+		try {
+			if (name.endsWith(".tmp")) {
+				unlinkSync(file);
+				removed += 1;
+				continue;
+			}
+			if (!name.endsWith(".json")) continue;
+			const record = parseRecord(readFileSync(file, "utf8"));
+			if (record === void 0) continue;
+			if ((record.settledAt ?? record.createdAt) < cutoff) {
+				unlinkSync(file);
+				removed += 1;
+			}
+		} catch {}
+	}
+	return removed;
+}
+//#endregion
+//#region src/session-roster.ts
+/**
+* Session roster (pure): turn `sessionController.list()` rows into a compact,
+* model-readable list. No host services; the only I/O is one bounded probe of
+* `$DSH_HOME/sessions/` for the log-size hint (see {@link sessionLogSizes}).
 *
-* The pure helpers below never touch `ctx`; only `askSession()` does I/O.
+* The title projection is published by the host (`dsh-session-title`) as a
+* **plain string**; a `{ title }` wrapper is accepted for older cached rows.
+* Every miss degrades to the same cwd+time fallback `cross-session.ts` uses,
+* and no malformed row may throw.
 */
-/** 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;
+const UNKNOWN_CWD = "（未知工作目录）";
+const UNKNOWN_TIME = "（未知时间）";
+const DEFAULT_LIMIT = 30;
+const MIN_LIMIT = 1;
+const MAX_LIMIT = 50;
+/** Hard cap for one hint line, keeping each roster entry readable. */
+const HINT_MAX = 40;
+/** Separator the fallback label puts between the working directory and the ISO time. */
+const FALLBACK_SEPARATOR = " · ";
+/** ISO-8601 UTC stamp, the time half of the fallback label. */
+const ISO_TIME = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?Z$/u;
+const PATH_SPLIT$1 = /[\\/]+/u;
+const DRIVE_SEGMENT$1 = /^[A-Za-z]:$/u;
 /**
-* 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.
+* The exclusion list for roster/routing candidates: titles that carry no
+* meaning. `生成会话标题` is the leftover of the title-generation session,
+* and a bare greeting is an empty chat that never named itself.
 */
-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;
+const NOISE_TITLE_PATTERN = /生成会话标题|^你好[，,\s]*$/u;
+function isRecord(value) {
+	return value !== null && typeof value === "object";
 }
 /**
-* 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.
+* Read the title projection: the host plain string first, then the legacy
+* `{ title }` wrapper. Returns '' when neither yields a non-empty string.
 */
-function buildAskMessage(envelope, source) {
-	return createUserMessage({
-		content: envelope,
-		source
-	});
+function titleOf$1(projections) {
+	if (!isRecord(projections)) return "";
+	const values = projections.values;
+	if (!isRecord(values)) return "";
+	const raw = values.title;
+	return (typeof raw === "string" ? raw : isRecord(raw) && typeof raw.title === "string" ? raw.title : "").trim();
 }
 /**
-* 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.
+* Whether a raw roster row must stay out of the roster and the routing pool:
+* a blank session, a title-generation leftover, or the asking session itself.
+* Malformed input reads as "keep" here — the caller's own parser degrades it.
+* @param session - any raw row.
+* @param currentSessionId - the asking session, dropped when its id matches.
 */
-function askContentBytes(question, context) {
-	return Buffer.byteLength(question, "utf8") + (context === void 0 ? 0 : Buffer.byteLength(context, "utf8"));
+function isNoiseSession(session, currentSessionId) {
+	if (!isRecord(session)) return false;
+	if (session.blank === true) return true;
+	const title = titleOf$1(session.projections);
+	if (title.length > 0 && NOISE_TITLE_PATTERN.test(title)) return true;
+	return typeof currentSessionId === "string" && currentSessionId.length > 0 && session.sessionId === currentSessionId;
+}
+/** Last non-empty segment of a path, for the human-readable fallback name. */
+function lastPathSegment(path) {
+	const parts = path.split(PATH_SPLIT$1).filter((part) => part.length > 0);
+	return parts.length === 0 ? "" : parts[parts.length - 1];
 }
-/** 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()}`;
+/**
+* Turn the fallback display name (`<path> · <ISO time>`) into something a
+* person can read: the last path segment. A real title is returned unchanged,
+* so this is safe to call at every render site.
+*
+* The last segment is used as-is; when it carries no name of its own (a bare
+* drive such as `I:`) the label adds ` · 未命名`.
+* @param name - the row name as the host/renderer produced it.
+* @param cwd - the row's working directory, used to confirm the fallback shape.
+* @returns a short display name, or `name` unchanged.
+*/
+function shortSessionName(name, cwd) {
+	if (typeof name !== "string" || name.length === 0) return name;
+	const at = name.lastIndexOf(FALLBACK_SEPARATOR);
+	if (at < 0) return name;
+	const where = name.slice(0, at);
+	const when = name.slice(at + 3);
+	if (!ISO_TIME.test(when)) return name;
+	if (!(cwd !== void 0 && cwd.length > 0 ? where === cwd : /^[A-Za-z]:[\\/]/u.test(where) || where.startsWith("\\\\"))) return name;
+	const segment = lastPathSegment(where);
+	if (segment.length === 0) return "未命名";
+	if (DRIVE_SEGMENT$1.test(segment)) return `${segment} · 未命名`;
+	return segment;
 }
 /**
-* 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.
+* Deterministic fallback label, identical to `fallbackSessionName` in
+* `cross-session.ts`: working directory plus the ISO time, or only the
+* directory when the time is unknown.
 */
-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 fallbackName(cwd, updatedAt) {
+	const where = cwd === void 0 ? UNKNOWN_CWD : cwd;
+	if (typeof updatedAt !== "number" || !Number.isFinite(updatedAt)) return where;
+	const at = new Date(updatedAt);
+	return `${where} · ${Number.isNaN(at.getTime()) ? String(updatedAt) : at.toISOString()}`;
 }
-function candidateOf(summary) {
-	return {
-		sessionId: summary.sessionId,
-		name: sessionDisplayName(summary),
-		hint: fallbackSessionName(summary.cwd, summary.updatedAt)
-	};
+/** Relative recency in Chinese: 刚刚 / N 分钟前 / N 小时前 / N 天前. */
+function relativeTime(updatedAt) {
+	const diff = Date.now() - updatedAt;
+	if (!Number.isFinite(diff)) return UNKNOWN_TIME;
+	if (diff < 6e4) return "刚刚";
+	if (diff < 36e5) return `${Math.floor(diff / 6e4)} 分钟前`;
+	if (diff < 864e5) return `${Math.floor(diff / 36e5)} 小时前`;
+	return `${Math.floor(diff / 864e5)} 天前`;
+}
+/** Directory plus recency, truncated so the whole hint stays within {@link HINT_MAX}. */
+function buildHint(cwd, updatedAt) {
+	const where = cwd === void 0 ? UNKNOWN_CWD : cwd;
+	const suffix = ` · ${updatedAt === void 0 ? UNKNOWN_TIME : relativeTime(updatedAt)}`;
+	const room = HINT_MAX - suffix.length;
+	return `${where.length <= room ? where : `${where.slice(0, Math.max(0, room - 1))}…`}${suffix}`;
+}
+/** Default 30, hard-clamped to 1..50; a malformed limit falls back to the default. */
+function clampLimit(value) {
+	if (typeof value !== "number" || !Number.isFinite(value)) return DEFAULT_LIMIT;
+	return Math.min(MAX_LIMIT, Math.max(MIN_LIMIT, Math.floor(value)));
+}
+/** Running sessions first, then most recently updated first. */
+function compareRows(a, b) {
+	if (a.running !== b.running) return a.running ? -1 : 1;
+	if (a.updatedAt === b.updatedAt) return 0;
+	return a.updatedAt > b.updatedAt ? -1 : 1;
+}
+function matchesQuery(row, query) {
+	return row.name.toLowerCase().includes(query) || row.cwd !== void 0 && row.cwd.toLowerCase().includes(query) || row.hint.toLowerCase().includes(query);
+}
+/** Uncompressed or zstd log file inside a session directory. */
+const SESSION_LOG = /^session(?:\.v\d+)?\.jsonl(?:\.zstd)?$/u;
+/** Flat layout: `<id>*.jsonl[.zstd]` / `session-<id>*.jsonl[.zstd]` under the root. */
+const FLAT_LOG = /^(?:session-)?(.+?)\.jsonl(?:\.zstd)?$/u;
+/** A byte count from an untrusted value: finite and non-negative, or undefined. */
+function bytesOf$1(value) {
+	return typeof value === "number" && Number.isFinite(value) && value >= 0 ? Math.floor(value) : void 0;
+}
+/** Root of the host's session logs; `DSH_HOME` mirrors the host default (`~/.dsh`). */
+function sessionLogRoot() {
+	const dshHome = process.env.DSH_HOME ?? join(homedir(), ".dsh");
+	return join(dshHome, "sessions");
+}
+/** Bytes of one log file, or undefined when it is missing or not a file. */
+function fileBytes(file) {
+	try {
+		const stat = statSync(file);
+		return stat.isFile() ? stat.size : void 0;
+	} catch {
+		return;
+	}
 }
-/** 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;
-	});
+/** Bytes of the log inside one session directory: the plain file first, then the zstd one. */
+function logBytesIn(dir) {
+	let names;
+	try {
+		names = readdirSync(dir);
+	} catch {
+		return;
+	}
+	const logs = names.filter((name) => SESSION_LOG.test(name)).sort();
+	const picked = logs.find((name) => !name.endsWith(".zstd")) ?? logs[0];
+	return picked === void 0 ? void 0 : fileBytes(join(dir, picked));
+}
+/** The wanted session id a flat log name belongs to, if any (longest id wins). */
+function flatLogId(name, wanted) {
+	const match = FLAT_LOG.exec(name);
+	if (match === null) return void 0;
+	const stem = match[1] ?? "";
+	if (wanted.has(stem)) return stem;
+	let best;
+	for (const id of wanted) if (stem.startsWith(id) && (best === void 0 || id.length > best.length)) best = id;
+	return best;
 }
-/** 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".
+* Byte sizes of the given sessions' own logs, keyed by session id.
+*
+* One bounded pass: `readdir` of `$DSH_HOME/sessions/`, then one level of cwd
+* groups, then the log file inside each matching session directory (the nested
+* layout) or matching flat file names at the root. Unknown layouts, missing
+* directories and unreadable entries are simply absent — never an exception,
+* and no session is touched beyond reading its file size.
+* @param sessionIds - ids to look up; non-string and empty ids are ignored.
+* @returns id → bytes; ids without a readable log are missing from the map.
 */
-function matchTargetSession(sessions, reference) {
-	const needle = reference.trim();
-	if (needle.length === 0) return { kind: "missing" };
-	const byId = sessions.find((session) => session.sessionId === needle);
+function sessionLogSizes(sessionIds) {
+	const sizes = /* @__PURE__ */ new Map();
+	const wanted = new Set((Array.isArray(sessionIds) ? sessionIds : []).filter((id) => typeof id === "string" && id.length > 0));
+	if (wanted.size === 0) return sizes;
+	const root = sessionLogRoot();
+	let entries;
+	try {
+		entries = readdirSync(root, { withFileTypes: true });
+	} catch {
+		return sizes;
+	}
+	for (const entry of entries) {
+		if (entry.isDirectory()) {
+			const group = join(root, entry.name);
+			let children;
+			try {
+				children = readdirSync(group, { withFileTypes: true });
+			} catch {
+				continue;
+			}
+			for (const child of children) {
+				if (!wanted.has(child.name) || sizes.has(child.name)) continue;
+				const size = child.isDirectory() ? logBytesIn(join(group, child.name)) : fileBytes(join(group, child.name));
+				if (size !== void 0) sizes.set(child.name, size);
+			}
+			continue;
+		}
+		if (!entry.isFile()) continue;
+		const id = flatLogId(entry.name, wanted);
+		if (id === void 0 || sizes.has(id)) continue;
+		const size = fileBytes(join(root, entry.name));
+		if (size !== void 0) sizes.set(id, size);
+	}
+	return sizes;
+}
+/**
+* Attach the log-size hint (`sizeBytes`) to every row that does not carry one,
+* probing once for the whole batch. Rows that already know their size and
+* malformed entries pass through untouched.
+* @param sessions - roster rows; the input is never mutated.
+* @returns rows, with `sizeBytes` filled where a log was found.
+*/
+function withSessionLogSizes(sessions) {
+	const rows = Array.isArray(sessions) ? sessions : [];
+	const missing = [];
+	for (const row of rows) {
+		if (!isRecord(row) || bytesOf$1(row.sizeBytes) !== void 0) continue;
+		if (typeof row.sessionId === "string" && row.sessionId.length > 0) missing.push(row.sessionId);
+	}
+	const sizes = sessionLogSizes(missing);
+	return rows.map((row) => {
+		if (!isRecord(row) || bytesOf$1(row.sizeBytes) !== void 0) return row;
+		const size = typeof row.sessionId === "string" ? sizes.get(row.sessionId) : void 0;
+		return size === void 0 ? row : {
+			...row,
+			sizeBytes: size
+		};
+	});
+}
+/**
+* Build the roster: drop unusable rows, filter (optional), order, then cap.
+* @param sessions - rows from `sessionController.list()`; malformed rows are degraded, never fatal.
+* @param options.query - case-insensitive substring over name, cwd, or hint; empty means no filter.
+* @param options.limit - max rows, default 30, clamped to 1..50.
+* @param options.hideSubagents - also drop subagent rows (the setting's default).
+* @returns ordered rows with display names, flags, and recency hints.
+*/
+function buildSessionRoster(sessions, options) {
+	const query = typeof options?.query === "string" ? options.query.trim().toLowerCase() : "";
+	const rows = [];
+	for (const session of sessions) {
+		if (!isRecord(session)) continue;
+		if (isNoiseSession(session)) continue;
+		const raw = session;
+		if (options?.hideSubagents === true && raw.origin === "subagent") continue;
+		const cwd = typeof raw.cwd === "string" && raw.cwd.length > 0 ? raw.cwd : void 0;
+		const hasTime = typeof raw.updatedAt === "number" && Number.isFinite(raw.updatedAt);
+		const title = titleOf$1(raw.projections);
+		const sizeHint = bytesOf$1(raw.sizeBytes);
+		const row = {
+			sessionId: typeof raw.sessionId === "string" ? raw.sessionId : "",
+			name: title || fallbackName(cwd, raw.updatedAt),
+			...cwd === void 0 ? {} : { cwd },
+			updatedAt: hasTime ? raw.updatedAt : 0,
+			running: raw.running === true,
+			subagent: raw.origin === "subagent",
+			hint: buildHint(cwd, hasTime ? raw.updatedAt : void 0),
+			hasTitle: title.length > 0,
+			...sizeHint === void 0 ? {} : { sizeHint }
+		};
+		if (query.length > 0 && !matchesQuery(row, query)) continue;
+		rows.push(row);
+	}
+	rows.sort(compareRows);
+	const kept = rows.slice(0, clampLimit(options?.limit));
+	const unknown = kept.filter((row) => row.sizeHint === void 0).map((row) => row.sessionId);
+	if (unknown.length === 0) return kept;
+	const sizes = sessionLogSizes(unknown);
+	return kept.map((row) => {
+		if (row.sizeHint !== void 0) return row;
+		const size = sizes.get(row.sessionId);
+		return size === void 0 ? row : {
+			...row,
+			sizeHint: size
+		};
+	});
+}
+/**
+* Render the roster as the text the model reads. `hasTitle` stays out of the
+* text on purpose: it is a diagnostic fact, not a hint for the model.
+* @param rows - ordered rows from {@link buildSessionRoster}.
+* @param options.filtered - true when a query produced these rows, so the head reads 匹配.
+* @returns heading plus one `- <name> — <hint>` line per row, or the empty notice.
+*/
+function renderRoster(rows, options) {
+	if (rows.length === 0) return "没有匹配的会话。";
+	return [`${options?.filtered === true ? "匹配" : "共"} ${rows.length} 个会话`, ...rows.map((row) => {
+		const flags = `${row.running ? " · 运行中" : ""}${row.subagent ? " · 子代理" : ""}`;
+		return `- ${shortSessionName(row.name, row.cwd)} — ${row.hint}${flags}`;
+	})].join("\n");
+}
+//#endregion
+//#region src/session-router.ts
+/**
+* Question → session router (pure): the keyword retrieval layer behind
+* "ask a question without naming a session". `ask_session` hands an unnamed
+* question to {@link routeSessions}, gets back a small candidate list, and
+* returns it to the caller for the USER to pick — nothing is guessed and
+* nothing is delivered here.
+*
+* Determinism notes:
+* - No model call, no network. The only I/O is the alias-file pair at the
+*   bottom, which the tool layer uses to remember a user's own phrasing.
+* - The one time input is `updatedAt` from the roster, so a test can freeze
+*   time by choosing the rows; the wide-pool decay is measured from the newest
+*   row, never from the wall clock. (The activity label and the route cache are
+*   the two exceptions: both are coarse, wall-clock facts.)
+* - Odd input (a null row, a missing title, a NaN timestamp, a corrupt alias
+*   file) degrades to "no match", never to an exception.
+*/
+/**
+* Pure exclusion matcher (swarm.routingExclude): an entry matches when it
+* equals the session id (case-insensitive) or is a case-insensitive substring
+* of any provided name — the session's title and/or its fallback display name.
+* Blank entries never match, so an empty list excludes nothing.
+*/
+function isSessionExcluded(entries, session) {
+	const list = Array.isArray(entries) ? entries : [];
+	if (list.length === 0 || session === void 0 || session === null) return false;
+	const id = typeof session.sessionId === "string" ? session.sessionId.trim().toLowerCase() : "";
+	const names = Array.isArray(session.names) ? session.names.filter((name) => typeof name === "string" && name.trim().length > 0).map((name) => name.trim().toLowerCase()) : [];
+	for (const raw of list) {
+		if (typeof raw !== "string") continue;
+		const entry = raw.trim().toLowerCase();
+		if (entry.length === 0) continue;
+		if (id.length > 0 && entry === id) return true;
+		if (names.some((name) => name.includes(entry))) return true;
+	}
+	return false;
+}
+/** Cache-key fragment: the exclusion list, normalised so order/case do not matter. */
+function excludeKey(entries) {
+	return (Array.isArray(entries) ? entries : []).filter((entry) => typeof entry === "string").map((entry) => entry.trim().toLowerCase()).filter((entry) => entry.length > 0).sort().join("\0");
+}
+/** True when this indexed row is on the exclusion list. */
+function rowExcluded(entries, row) {
+	const names = row.hasTitle ? [row.name] : [row.name, row.cwd];
+	return isSessionExcluded(entries, {
+		sessionId: row.sessionId,
+		names
+	});
+}
+/** Default and hard caps for how many candidates one pass returns (schema: 1–8). */
+const DEFAULT_TOP_N = 3;
+const MIN_TOP_N = 1;
+const MAX_TOP_N = 8;
+/** Jev routing: at/above this confidence the pick moves to the front. */
+const JEV_RECOMMEND_THRESHOLD = .75;
+/** Below this the answer is not even a preference; 0.45–0.75 keeps the local order. */
+const JEV_DEFER_THRESHOLD = .45;
+/** Candidate notes for the Jev engine. */
+const JEV_PICK_NOTE = " · Jev 推荐";
+const JEV_UNCONFIGURED_NOTE = " · Jev 未配置";
+/** Shortest run that may act as an exact keyword; also the CJK bigram width. */
+const MIN_KEYWORD_LENGTH = 2;
+/**
+* A bigram-only match needs this many shared bigrams. One shared bigram is
+* almost noise (2–3 character titles would otherwise float to the top on a
+* single accidental pair).
+*/
+const BIGRAM_MIN_HITS = 2;
+/**
+* The Dice/bigram contribution is a fuzzy signal: it is capped here so a
+* merely similar title can never outrank a real hit, whatever its length.
+*/
+const DICE_SCORE_CAP = 40;
+/**
+* Hard-channel bonuses, added on top of the capped Dice score and clamped at
+* 100. They stay decisive: any one of them lifts the row above the fuzzy cap.
+*/
+const TITLE_KEYWORD_BONUS = 40;
+const CWD_KEYWORD_BONUS = 30;
+const FULL_PHRASE_BONUS = 60;
+const ALIAS_BONUS = 60;
+const RUNNING_BONUS = 10;
+/** Activity-label boundaries: 热 ≤ 1h, 温 ≤ 24h, anything older is 冷. */
+const HOT_WINDOW_MS = 36e5;
+const WARM_WINDOW_MS = 864e5;
+/** Route cache: the same question inside this window reuses one routing pass. */
+const ROUTE_CACHE_TTL_MS = 18e4;
+const ROUTE_CACHE_MAX = 64;
+/**
+* In-memory route cache: routing reads only the roster and the question, so the
+* same question inside the TTL can reuse the previous answer. Bounded (oldest
+* evicted) and never persisted; {@link clearRouteCache} is the test seam.
+*/
+const routeCache = /* @__PURE__ */ new Map();
+/**
+* A title hit must outrank a plain directory-only hit whatever their Dice
+* similarity: the directory channel's own contribution tops out at
+* DICE_SCORE_CAP + CWD_KEYWORD_BONUS (= 70), so every title hit is lifted above
+* that ceiling. Without this a title's extra token can lower its Dice score and
+* invert the intended priority — the live bug: a titled row at 27 behind
+* cwd-only rows at 28.
+*/
+const TITLE_HIT_FLOOR = 71;
+/**
+* Shortest run of a session's own name that counts as "the question named this
+* session" when spoken inside the question. Chinese is written without spaces,
+* so a project name is normally embedded in a longer run ("那个做极简遥控器的
+* 会话"); a run this long is specific enough to be a hard channel, while a
+* shorter one stays fuzzy (3 characters are routinely a coincidence).
+*/
+const TITLE_MENTION_MIN_CHARS = 4;
+/**
+* The same, for one working-directory segment. A folder name is a project
+* identifier rather than prose, so one character less already carries weight.
+*/
+const CWD_MENTION_MIN_CHARS = 3;
+/** Zero-hit fallback pool: fuzzy top 20 ∪ most recent 10, deduped. */
+const WIDE_FUZZY_LIMIT = 20;
+const WIDE_RECENT_LIMIT = 10;
+/** Half-life of the fallback time decay, measured from the newest row. */
+const DECAY_HALF_LIFE_MS = 864e5;
+const CJK_CHAR = /[\u3400-\u4dbf\u4e00-\u9fff\uf900-\ufaff]/u;
+const TOKEN_RUN = /[\p{L}\p{N}]+/gu;
+const RUN_SEGMENT = /[\u3400-\u4dbf\u4e00-\u9fff\uf900-\ufaff]+|[A-Za-z0-9]+/gu;
+const PATH_SPLIT = /[\\/]+/u;
+const DRIVE_SEGMENT = /^[A-Za-z]:$/u;
+/** Whitespace, punctuation and symbols carry no routing signal. */
+const NOISE = /[\s\p{P}\p{S}]+/gu;
+function emptyTokens() {
+	return {
+		words: /* @__PURE__ */ new Set(),
+		bigrams: /* @__PURE__ */ new Set(),
+		phrases: /* @__PURE__ */ new Set()
+	};
+}
+/** The host publishes the title as a plain string; the `{ title }` wrapper is tolerated. */
+function titleOf(projections) {
+	if (projections === null || typeof projections !== "object") return "";
+	const values = projections.values;
+	if (values === null || typeof values !== "object") return "";
+	const raw = values.title;
+	return (typeof raw === "string" ? raw : raw !== null && typeof raw === "object" && typeof raw.title === "string" ? raw.title : "").trim();
+}
+/**
+* Lowercase, then strip whitespace/punctuation/symbols. This is the key form
+* used for exact keywords, whole-phrase containment and alias entries, so a
+* user's phrasing survives their own spacing and punctuation.
+* @param text - any string; a non-string reads as ''.
+* @returns the normalised key (possibly empty).
+*/
+function normalizeAliasKey(text) {
+	if (typeof text !== "string") return "";
+	return text.toLowerCase().replace(NOISE, "");
+}
+/**
+* How recently a session was active, as one readable character: 热 ≤ 1h,
+* 温 ≤ 24h, 冷 beyond that (a week old and yesterday alike). A label only —
+* nothing is excluded from the candidates on account of it.
+* @param updatedAt - the row's last-activity timestamp (ms).
+* @param now - the clock to measure against, passed in so tests can pin it.
+* @returns the label; a non-finite age reads as 冷.
+*/
+function activityLabel(updatedAt, now) {
+	const age = now - updatedAt;
+	if (!Number.isFinite(age)) return "冷";
+	if (age <= HOT_WINDOW_MS) return "热";
+	if (age <= WARM_WINDOW_MS) return "温";
+	return "冷";
+}
+/**
+* Add one text's tokens to a token set.
+*
+* CJK runs are additionally cut into 2-character bigrams; ASCII runs stay whole
+* words. A CJK run that is a single character is skipped — too weak to carry a
+* routing decision on its own.
+*/
+function addText(target, text) {
+	if (typeof text !== "string" || text.length === 0) return;
+	for (const run of text.match(TOKEN_RUN) ?? []) {
+		if (!CJK_CHAR.test(run)) {
+			const word = run.toLowerCase();
+			target.words.add(word);
+			if (word.length >= MIN_KEYWORD_LENGTH) target.phrases.add(word);
+			continue;
+		}
+		for (const segment of run.match(RUN_SEGMENT) ?? []) {
+			if (!CJK_CHAR.test(segment)) {
+				const word = segment.toLowerCase();
+				target.words.add(word);
+				if (word.length >= MIN_KEYWORD_LENGTH) target.phrases.add(word);
+				continue;
+			}
+			if (segment.length < MIN_KEYWORD_LENGTH) continue;
+			target.phrases.add(segment);
+			for (let i = 0; i + MIN_KEYWORD_LENGTH <= segment.length; i += 1) target.bigrams.add(segment.slice(i, i + MIN_KEYWORD_LENGTH));
+		}
+	}
+}
+/** Index one roster row; a row without a sessionId cannot be routed and is skipped. */
+function indexSession(session) {
+	if (session === null || typeof session !== "object") return void 0;
+	const raw = session;
+	const sessionId = typeof raw.sessionId === "string" ? raw.sessionId : "";
+	if (sessionId.length === 0) return void 0;
+	const title = titleOf(raw.projections);
+	const cwd = typeof raw.cwd === "string" ? raw.cwd : "";
+	const cwdSegments = cwd.split(PATH_SPLIT).filter((segment) => segment.length > 0 && !DRIVE_SEGMENT.test(segment));
+	const tokens = emptyTokens();
+	const cwdTexts = [];
+	if (title.length > 0) addText(tokens, title);
+	for (const segment of cwdSegments) {
+		addText(tokens, segment);
+		cwdTexts.push(normalizeAliasKey(segment));
+	}
+	const folderName = cwdSegments.length > 0 ? cwdSegments[cwdSegments.length - 1] : "";
+	const sizeHint = bytesOf(raw.sizeHint ?? raw.sizeBytes);
+	return {
+		sessionId,
+		name: title.length > 0 ? title : folderName.length > 0 ? folderName : cwd.length > 0 ? cwd : sessionId,
+		...cwd.length > 0 ? { cwd } : {},
+		titleText: normalizeAliasKey(title),
+		hasTitle: title.length > 0,
+		cwdTexts,
+		tokens,
+		running: raw.running === true,
+		updatedAt: typeof raw.updatedAt === "number" && Number.isFinite(raw.updatedAt) ? raw.updatedAt : 0,
+		...sizeHint === void 0 ? {} : { sizeHint }
+	};
+}
+/** A byte count from an untrusted value: finite and non-negative, or undefined. */
+function bytesOf(value) {
+	return typeof value === "number" && Number.isFinite(value) && value >= 0 ? Math.floor(value) : void 0;
+}
+/** Read the question once: tokens, longest-first keywords, and the whole phrase. */
+function readQuestion(question) {
+	const text = typeof question === "string" ? question : "";
+	const tokens = emptyTokens();
+	addText(tokens, text);
+	return {
+		tokens,
+		keywords: [...tokens.phrases].map((phrase) => normalizeAliasKey(phrase)).filter((phrase) => phrase.length >= MIN_KEYWORD_LENGTH).sort((a, b) => b.length - a.length || (a < b ? -1 : a > b ? 1 : 0)),
+		phrase: normalizeAliasKey(text)
+	};
+}
+/** Shared token count, iterating the smaller set. */
+function intersectionSize(a, b) {
+	const [small, large] = a.size <= b.size ? [a, b] : [b, a];
+	let hits = 0;
+	for (const token of small) if (large.has(token)) hits += 1;
+	return hits;
+}
+/** Dice coefficient over the two token sets: 2|A∩B|/(|A|+|B|). */
+function diceScore(question, session) {
+	const total = question.words.size + question.bigrams.size + session.words.size + session.bigrams.size;
+	if (total === 0) return 0;
+	return 2 * (intersectionSize(question.words, session.words) + intersectionSize(question.bigrams, session.bigrams)) / total;
+}
+/** Longest keyword found as an exact substring of any haystack, or undefined. */
+function keywordHit(keywords, haystacks) {
+	for (const keyword of keywords) for (const haystack of haystacks) if (haystack.length > 0 && haystack.includes(keyword)) return keyword;
+}
+/**
+* Longest run of `text` that also occurs inside `phrase`, provided it is at
+* least `minChars` long; undefined otherwise.
+*
+* This is the reverse direction of {@link keywordHit}: it asks whether a
+* session's own name was spoken inside the question. Chinese has no spaces, so
+* "那个做极简遥控器的会话" never yields a keyword, yet it clearly names 极简遥控器.
+* Anchoring on a minimum length keeps a short accidental overlap fuzzy.
+*/
+function mentionIn(text, phrase, minChars) {
+	if (text.length < minChars || phrase.length === 0) return void 0;
+	let best = "";
+	for (let start = 0; start + minChars <= text.length; start += 1) {
+		const seed = text.slice(start, start + minChars);
+		for (let at = phrase.indexOf(seed); at >= 0; at = phrase.indexOf(seed, at + 1)) {
+			let length = minChars;
+			while (start + length < text.length && at + length < phrase.length && text[start + length] === phrase[at + length]) length += 1;
+			if (length > best.length) best = text.slice(start, start + length);
+		}
+	}
+	return best.length > 0 ? best : void 0;
+}
+/** The longest mention across several haystacks, or undefined. */
+function mentionInAny(texts, phrase, minChars) {
+	let best;
+	for (const text of texts) {
+		const hit = mentionIn(text, phrase, minChars);
+		if (hit !== void 0 && (best === void 0 || hit.length > best.length)) best = hit;
+	}
+	return best;
+}
+/** Score one indexed row, or return undefined when it is neither matched nor hard-channel. */
+function scoreRow(row, query, aliasHit) {
+	const wordHits = intersectionSize(query.tokens.words, row.tokens.words);
+	const bigramHits = intersectionSize(query.tokens.bigrams, row.tokens.bigrams);
+	const matched = wordHits > 0 || bigramHits >= BIGRAM_MIN_HITS;
+	const titleHit = keywordHit(query.keywords, [row.titleText]) ?? mentionIn(row.titleText, query.phrase, TITLE_MENTION_MIN_CHARS);
+	const cwdKeyword = titleHit === void 0 ? keywordHit(query.keywords, row.cwdTexts) : void 0;
+	const cwdHit = titleHit !== void 0 ? void 0 : cwdKeyword ?? mentionInAny(row.cwdTexts, query.phrase, CWD_MENTION_MIN_CHARS);
+	const fullPhrase = query.phrase.length >= MIN_KEYWORD_LENGTH && (row.titleText.includes(query.phrase) || row.cwdTexts.some((text) => text.includes(query.phrase)));
+	let score = matched ? Math.min(DICE_SCORE_CAP, Math.round(diceScore(query.tokens, row.tokens) * 100)) : 0;
+	if (titleHit !== void 0) score += TITLE_KEYWORD_BONUS;
+	else if (cwdHit !== void 0) score += CWD_KEYWORD_BONUS;
+	if (fullPhrase) score += FULL_PHRASE_BONUS;
+	if (aliasHit !== void 0) score += ALIAS_BONUS;
+	if (row.running) score += RUNNING_BONUS;
+	score = Math.min(100, Math.max(0, score));
+	if (titleHit !== void 0) score = Math.max(score, TITLE_HIT_FLOOR);
+	const hard = titleHit !== void 0 || cwdHit !== void 0 || fullPhrase || aliasHit !== void 0 || row.running;
+	if (!matched && !hard) return void 0;
+	const reason = aliasHit !== void 0 ? "别名命中" : titleHit !== void 0 ? `标题命中「${titleHit}」` : cwdHit !== void 0 ? "目录命中" : fullPhrase ? "整句命中" : matched ? "问题相关" : "运行中";
+	return {
+		row,
+		score,
+		reason,
+		titleHit: titleHit !== void 0
+	};
+}
+/** Project identity for the size tie-break: separators and case are not identity. */
+function projectKey(cwd) {
+	if (typeof cwd !== "string") return "";
+	return cwd.trim().replace(/[\\/]+/gu, "/").replace(/\/+$/u, "").toLowerCase();
+}
+/** Same project = both rows name the same normalised cwd; an unknown cwd never matches. */
+function sameProject(a, b) {
+	const left = projectKey(a.cwd);
+	return left.length > 0 && left === projectKey(b.cwd);
+}
+/**
+* Recency band as an order key: 热 = 0, 温 = 1, 冷 = 2. The three bands are the
+* ones {@link activityLabel} already defines, so the order and the label a
+* candidate shows can never disagree.
+*/
+function bandRank(updatedAt, now) {
+	const label = activityLabel(updatedAt, now);
+	return label === "热" ? 0 : label === "温" ? 1 : 2;
+}
+/**
+* True when the row's log size is known AND below {@link ROUTE_MIN_CONTEXT_BYTES}.
+* An unknown size is never thin: a probe miss must not cost a session a slot.
+*/
+function tooThin(row) {
+	return row.sizeHint !== void 0 && row.sizeHint < 160380;
+}
+/**
+* Deterministic order: score desc, a title hit above a directory-only hit,
+* running first, then substance (a known-small row behind every row that
+* clears the floor), then the recency band (热 > 温 > 冷), then the bigger
+* known context inside one project of the SAME band, then recency, then
+* shorter title.
+*/
+function compareScored(a, b, now) {
+	if (a.score !== b.score) return b.score - a.score;
+	if (a.titleHit !== b.titleHit) return a.titleHit ? -1 : 1;
+	if (a.row.running !== b.row.running) return a.row.running ? -1 : 1;
+	const thinA = tooThin(a.row);
+	if (thinA !== tooThin(b.row)) return thinA ? 1 : -1;
+	const bandA = bandRank(a.row.updatedAt, now);
+	const bandB = bandRank(b.row.updatedAt, now);
+	if (bandA !== bandB) return bandA - bandB;
+	if (sameProject(a.row, b.row)) {
+		const left = a.row.sizeHint;
+		const right = b.row.sizeHint;
+		if (left !== void 0 && right !== void 0 && left !== right) return right - left;
+	}
+	if (a.row.updatedAt !== b.row.updatedAt) return b.row.updatedAt - a.row.updatedAt;
+	if (a.row.name.length !== b.row.name.length) return a.row.name.length - b.row.name.length;
+	return a.row.sessionId < b.row.sessionId ? -1 : a.row.sessionId > b.row.sessionId ? 1 : 0;
+}
+/** Default 3; a non-finite value falls back to it, everything else is clamped to 1..8. */
+function clampTopN(value) {
+	if (typeof value !== "number" || !Number.isFinite(value)) return DEFAULT_TOP_N;
+	return Math.min(MAX_TOP_N, Math.max(MIN_TOP_N, Math.floor(value)));
+}
+/** Normalised alias phrasing → sessionId; malformed entries are dropped. */
+function readAliasMap(aliases) {
+	const map = /* @__PURE__ */ new Map();
+	if (aliases === null || typeof aliases !== "object" || Array.isArray(aliases)) return map;
+	for (const [phrasing, sessionId] of Object.entries(aliases)) {
+		if (typeof sessionId !== "string" || sessionId.length === 0) continue;
+		const key = normalizeAliasKey(phrasing);
+		if (key.length === 0) continue;
+		map.set(key, sessionId);
+	}
+	return map;
+}
+/** Sessions whose phrasing occurs inside the question; the longest phrasing per session wins. */
+function aliasHits(questionPhrase, aliases) {
+	const hits = /* @__PURE__ */ new Map();
+	if (questionPhrase.length === 0) return hits;
+	for (const [phrasing, sessionId] of aliases) {
+		if (!questionPhrase.includes(phrasing)) continue;
+		const current = hits.get(sessionId);
+		if (current === void 0 || phrasing.length > current.length) hits.set(sessionId, phrasing);
+	}
+	return hits;
+}
+function candidateOf$1(scored, now) {
+	const thin = tooThin(scored.row) ? " · 体积小" : "";
+	return {
+		sessionId: scored.row.sessionId,
+		name: shortSessionName(scored.row.name, scored.row.cwd),
+		score: scored.score,
+		reason: `${scored.reason} · ${activityLabel(scored.row.updatedAt, now)}${thin}`
+	};
+}
+/**
+* True when only the bigger known context puts `a` ahead of `b`: equal rank
+* keys, the same recency band, same project, and without the size key `b` would
+* come first (newer, then shorter title, then id). Used only to label the reason
+* 「积累多」, so the label never claims a placement the score or the freshness
+* band already decided.
+*/
+function sizeDecided(a, b, now) {
+	if (a.score !== b.score || a.titleHit !== b.titleHit || a.row.running !== b.row.running) return false;
+	if (bandRank(a.row.updatedAt, now) !== bandRank(b.row.updatedAt, now)) return false;
+	if (!sameProject(a.row, b.row)) return false;
+	const left = a.row.sizeHint;
+	const right = b.row.sizeHint;
+	if (left === void 0 || right === void 0 || left <= right) return false;
+	if (a.row.updatedAt !== b.row.updatedAt) return b.row.updatedAt > a.row.updatedAt;
+	if (a.row.name.length !== b.row.name.length) return b.row.name.length < a.row.name.length;
+	return b.row.sessionId < a.row.sessionId;
+}
+/**
+* Take the best `topN` rows, in order, without spending two slots on one
+* fallback name: several untitled sessions in the same folder all render as
+* "极简遥控器", and letting them fill the list hides the titled match behind
+* identical labels. A titled row is never skipped or displaced by that rule —
+* only a title-less row whose label an earlier title-less row already used.
+*/
+function selectTop(scored, topN, now) {
+	const usedFallbackNames = /* @__PURE__ */ new Set();
+	const picked = [];
+	for (const row of scored) {
+		if (!row.row.hasTitle) {
+			const label = shortSessionName(row.row.name, row.row.cwd);
+			if (usedFallbackNames.has(label)) continue;
+			usedFallbackNames.add(label);
+		}
+		picked.push(row);
+		if (picked.length >= topN) break;
+	}
+	return picked.map((row, index) => {
+		const candidate = candidateOf$1(row, now);
+		const next = picked[index + 1];
+		return next !== void 0 && sizeDecided(row, next, now) ? {
+			...candidate,
+			reason: `${candidate.reason} · 积累多`
+		} : candidate;
+	});
+}
+/**
+* Zero-hit fallback: fuzzy top 20 ∪ most recent 10, deduped, then scored by the
+* same Dice formula under a time decay. The decay is measured from the newest
+* row in the pool, so the result depends only on the roster, not on the clock.
+*/
+function widePool(indexed, query, topN, now) {
+	const newest = indexed.reduce((max, row) => row.updatedAt > max ? row.updatedAt : max, 0);
+	const pool = /* @__PURE__ */ new Map();
+	const byDice = [...indexed].sort((a, b) => diceScore(query.tokens, b.tokens) - diceScore(query.tokens, a.tokens));
+	for (const row of byDice.slice(0, WIDE_FUZZY_LIMIT)) pool.set(row.sessionId, row);
+	const byRecency = [...indexed].sort((a, b) => b.updatedAt - a.updatedAt);
+	for (const row of byRecency.slice(0, WIDE_RECENT_LIMIT)) pool.set(row.sessionId, row);
+	const scored = [...pool.values()].map((row) => {
+		const base = Math.min(DICE_SCORE_CAP, Math.round(diceScore(query.tokens, row.tokens) * 100));
+		const age = newest - row.updatedAt;
+		const decay = age > 0 ? Math.pow(.5, age / DECAY_HALF_LIFE_MS) : 1;
+		return {
+			row,
+			score: Math.min(100, Math.max(0, Math.round(base * decay))),
+			reason: base > 0 ? "弱匹配" : "最近活跃",
+			titleHit: false
+		};
+	});
+	scored.sort((a, b) => compareScored(a, b, now));
+	return selectTop(scored, topN, now);
+}
+/**
+* Score every roster session against a question and return the candidates.
+*
+* Hard channels always join the candidate set regardless of score (unless the
+* topN cap pushes them out): a title (or directory) name spoken inside the
+* question, a whole question keyword inside the title, a known alias phrasing,
+* and "the session is running". Everything else must clear the bigram
+* threshold. When nothing matches, the wide pool answers with the most
+* relevant/recent sessions instead of an empty list.
+*
+* The result is cached in memory for 180 s (64 entries, oldest evicted), keyed
+* by the normalised question, the cap, and the asking session: the same
+* question asked twice does no duplicate work and returns the same candidates.
+*
+* @param sessions - rows from `sessionController.list()`; malformed rows are skipped.
+* @param question - the question as the caller wrote it; no target name needed.
+* @param options.topN - max candidates, default 3, clamped to 1..8.
+* @param options.aliases - normalised user phrasing → sessionId; the caller
+*   drops entries whose session is no longer in the roster.
+* @param options.currentSessionId - the asking session, filtered out so the
+*   model is never offered the session it is already in.
+* @param options.cache - false bypasses (and does not fill) the route cache.
+* @param options.engine - which engine owns the cache entry; the local pass
+*   itself is engine-agnostic (Jev re-ranks afterwards, see
+*   {@link routeSessionsWithEngine}).
+* @returns candidates ordered best-first; never throws, never delivers.
+*/
+function routeSessions(sessions, question, options) {
+	const topN = clampTopN(options?.topN);
+	const engine = options?.engine === "jev" ? "jev" : "local";
+	const cache = options?.cache !== false;
+	const key = routeCacheKey(question, topN, options?.currentSessionId, engine, options?.exclude);
+	if (cache) {
+		const cached = readCachedRoute(key);
+		if (cached !== void 0) return [...cached];
+	}
+	const candidates = routeUncached(sessions, question, topN, options);
+	if (cache) writeCachedRoute(key, candidates);
+	return [...candidates];
+}
+/**
+* What a Jev route answer amounts to — the single source of truth for both the
+* ordering below and the diagnostics log:
+* - `recommend`: ≥ 0.75 and the picked candidate is in the list and not first;
+* - `keep`: 0.45–0.75, or a confident pick that is already first (nothing moves);
+* - `none`: missing/unknown/"none"/low confidence (below 0.45).
+*/
+function classifyJevRouteDecision(candidates, decision) {
+	if (decision === void 0 || decision === null) return { kind: "none" };
+	const choice = typeof decision.choice === "string" ? decision.choice.trim() : "";
+	const confidence = typeof decision.confidence === "number" && Number.isFinite(decision.confidence) ? decision.confidence : void 0;
+	if (choice.length === 0 || confidence === void 0) return { kind: "none" };
+	const picked = candidates.find((candidate) => candidate.sessionId === choice);
+	if (confidence < JEV_DEFER_THRESHOLD) return {
+		kind: "none",
+		confidence
+	};
+	if (confidence < JEV_RECOMMEND_THRESHOLD) return {
+		kind: "keep",
+		confidence,
+		...picked === void 0 ? {} : { picked }
+	};
+	if (picked === void 0) return {
+		kind: "none",
+		confidence
+	};
+	if (candidates[0]?.sessionId === picked.sessionId) return {
+		kind: "keep",
+		confidence,
+		picked
+	};
+	return {
+		kind: "recommend",
+		confidence,
+		picked
+	};
+}
+/**
+* Re-order the local candidate list with Jev's closed-set answer.
+*
+* Only a confident pick (≥ {@link JEV_RECOMMEND_THRESHOLD}) for a session that
+* is actually in the list is obeyed: that option moves to the front and carries
+* 「Jev 推荐」. The 0.45–0.75 band keeps the local order, and so do a lower
+* confidence, the explicit "none" escape, an unknown id and a missing value.
+*/
+function applyJevDecision(candidates, decision) {
+	const list = Array.isArray(candidates) ? [...candidates] : [];
+	const verdict = classifyJevRouteDecision(list, decision);
+	if (verdict.kind !== "recommend") return list;
+	const picked = verdict.picked;
+	if (picked === void 0) return list;
+	const index = list.findIndex((candidate) => candidate.sessionId === picked.sessionId);
+	if (index <= 0) return list;
+	const [found] = list.splice(index, 1);
+	return [{
+		...found,
+		reason: `${found.reason}${JEV_PICK_NOTE}`
+	}, ...list];
+}
+/**
+* Route with the selected engine.
+*
+* The local scorer always runs first: it is the recall step AND the safety net.
+* In `jev` mode its top candidates are handed to Jev as a closed set and
+* {@link applyJevDecision} applies the answer. Every failure — missing
+* credentials, timeout, HTTP error, unparseable response, an id that is not in
+* the list — silently returns the local order and never throws: routing is a
+* proposal, never a delivery, so an engine fault must not fail the ask.
+*
+* Diagnostics: one log line per Jev decision attempt (a pure local pass writes
+* nothing). Logging is injected so this module stays free of the store.
+*/
+async function routeSessionsWithEngine(sessions, question, options) {
+	const engine = options?.engine === "jev" ? "jev" : "local";
+	const local = routeSessions(sessions, question, {
+		...options,
+		engine
+	});
+	if (engine !== "jev") return local;
+	const log = options?.log;
+	const recorded = {
+		kind: "route",
+		question,
+		candidates: local.map((candidate) => ({
+			id: candidate.sessionId,
+			title: candidate.name
+		}))
+	};
+	if (local.length === 0) {
+		log?.({
+			...recorded,
+			called: false,
+			configured: options?.jev !== void 0,
+			decision: "skipped"
+		});
+		return local;
+	}
+	if (options?.jev === void 0) {
+		log?.({
+			...recorded,
+			called: false,
+			configured: false,
+			decision: "skipped"
+		});
+		return local.map((candidate) => ({
+			...candidate,
+			reason: `${candidate.reason}${JEV_UNCONFIGURED_NOTE}`
+		}));
+	}
+	try {
+		const decision = await options.jev({
+			question,
+			questionEn: options.questionEn,
+			candidates: local
+		});
+		const verdict = classifyJevRouteDecision(local, decision);
+		const picked = verdict.picked;
+		const confidence = verdict.confidence;
+		log?.({
+			...recorded,
+			called: true,
+			configured: true,
+			decision: verdict.kind,
+			...picked === void 0 ? {} : {
+				pickedId: picked.sessionId,
+				pickedTitle: picked.name
+			},
+			...confidence === void 0 ? {} : { confidence }
+		});
+		return applyJevDecision(local, decision);
+	} catch (error) {
+		log?.({
+			...recorded,
+			called: true,
+			configured: true,
+			decision: "error",
+			error: error instanceof Error ? error.message : String(error)
+		});
+		return local;
+	}
+}
+/** At/above this confidence an answer counts as "yes" (ask / sensitive alike). */
+const CROSS_SESSION_THRESHOLD = .6;
+/**
+* Phrases that point at work which may already live in another session. Kept
+* deliberately narrow: this prefilter is the whole cost control for `gated`
+* mode, so a normal self-contained request should not pass it.
+*/
+const CROSS_SESSION_POINTERS = [
+	"问一下",
+	"问下",
+	"问一问",
+	"帮我问",
+	"帮忙问",
+	"请问一下",
+	"那个会话",
+	"这个会话",
+	"另一个会话",
+	"别的会话",
+	"其他会话",
+	"那个窗口",
+	"另一个窗口",
+	"别处",
+	"别的地方",
+	"另一个地方",
+	"进度",
+	"版本",
+	"状态",
+	"最近",
+	"之前",
+	"上次",
+	"说过",
+	"聊过",
+	"话题"
+];
+/** A concrete path or hyphenated project id, e.g. `I:\DSH\dsh-advisor-group`. */
+const PROJECT_LIKE = /[a-z]:[\\/]|(?:[a-z0-9][a-z0-9._-]*[\\/][a-z0-9._-]+)|(?:[a-z]{2,}(?:-[a-z0-9]{2,}){1,})/iu;
+/** The turn already names where to go: a tool call, a session id, a quoted title. */
+const EXPLICIT_TARGET = [
+	/ask_session/iu,
+	/(?:session-)?[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/iu,
+	/(?:问(?:一下|下)?|发给|发到|投递到|对)\s*[「『"][^」』"]{1,60}[」』"]\s*(?:那个)?会话/u
+];
+/**
+* Harness-injected context blocks. They arrive as user-role messages but are
+* never the user's own words, so the cross-session judgment must ignore them.
+* Observed live (2026-10-20): the runtime-context snapshot, the Mnemon memory
+* snapshot and the per-turn time line were each judged as a user turn.
+*/
+const INJECTED_CONTEXT_PREFIXES = [
+	"Current runtime context",
+	"MNEM RUNTIME MEMORY SNAPSHOT",
+	"Time sampled while preparing turn",
+	"Browser time zone for this request",
+	"You are an AI agent powered by DeepSeek Harness"
+];
+/**
+* True when the trimmed text starts with a known harness-injected prefix. This
+* is the belt-and-braces guard behind the source-kind gate: a host that
+* mislabels injected context as a user prompt still must not trigger a Jev call.
+*/
+function isInjectedContextText(text) {
+	if (typeof text !== "string") return false;
+	const trimmed = text.trim();
+	if (trimmed.length === 0) return false;
+	return INJECTED_CONTEXT_PREFIXES.some((prefix) => trimmed.startsWith(prefix));
+}
+/** Text blocks of one inbound `user/message` event, joined; undefined otherwise. */
+function userMessageTextOf(event) {
+	if (event === null || typeof event !== "object") return void 0;
+	const value = event;
+	if (value.type !== "user/message") return void 0;
+	const data = value.data;
+	if (data === null || typeof data !== "object") return void 0;
+	const content = data.content;
+	if (!Array.isArray(content)) return void 0;
+	const text = content.filter((part) => part !== null && typeof part === "object").filter((part) => part.type === "text" && typeof part.text === "string").map((part) => part.text).join(" ").trim();
+	return text.length > 0 ? text : void 0;
+}
+/**
+* True only when the event is a genuine human prompt.
+*
+* Evidence (DSH `MessageSourceMap` in `@deepseek-ai/dsh-llm` + this host's real
+* session logs): a `user/message` event carries its producer on
+* `data.source` — a typed prompt is `{ kind: 'user' }`, an injected runtime
+* context snapshot is `{ kind: 'runtime-context', form: 'snapshot', sections:
+* [...] }`, and a cross-session relay is `{ kind: 'session-ask', askId, ... }`.
+* Anything other than exactly `kind: 'user'` (including a missing source) is
+* not the user's own words.
+*/
+function isGenuineUserPrompt(event) {
+	if (event === null || typeof event !== "object") return false;
+	const value = event;
+	if (value.type !== "user/message") return false;
+	const source = value.data?.source;
+	if (source === null || typeof source !== "object") return false;
+	return source.kind === "user";
+}
+/**
+* Per-session mark: an injected-context skip was already logged for the current
+* turn, so the next injected block stays silent. One line per turn, never one
+* line per block.
+*/
+const injectedSkipLogged = /* @__PURE__ */ new Set();
+/** True when this injected block should write its once-per-turn skip line. */
+function shouldLogInjectedSkip(sessionId) {
+	if (typeof sessionId !== "string" || sessionId.length === 0) return true;
+	if (injectedSkipLogged.has(sessionId)) return false;
+	injectedSkipLogged.add(sessionId);
+	return true;
+}
+/** A genuine prompt starts a new turn: allow the next injected skip line. */
+function resetInjectedSkipLog(sessionId) {
+	if (typeof sessionId === "string" && sessionId.length > 0) injectedSkipLogged.delete(sessionId);
+}
+/**
+* Pure, network-free prefilter: does this text look like it points at another
+* session or at work another session has already done? True only when a
+* pointer phrase / project-like token is present AND the turn does not already
+* name an explicit target (a session id, the ask_session tool, or a quoted
+* session title being addressed).
+*/
+function shouldConsiderCrossSession(text) {
+	if (typeof text !== "string") return false;
+	const trimmed = text.trim();
+	if (trimmed.length === 0) return false;
+	if (EXPLICIT_TARGET.some((pattern) => pattern.test(trimmed))) return false;
+	return CROSS_SESSION_POINTERS.some((phrase) => trimmed.includes(phrase)) || PROJECT_LIKE.test(trimmed);
+}
+/**
+* The one-line suggestion for a judgment, or undefined when it must stay
+* silent: no yes (ask < 0.6), a sensitive question (sensitive ≥ 0.6), no pick,
+* "none", or an id that is not one of the offered candidates.
+*/
+function crossSessionSuggestionLine(judgment, candidates) {
+	if (judgment === void 0 || judgment === null) return void 0;
+	const ask = judgment.askConfidence;
+	if (typeof ask !== "number" || !Number.isFinite(ask) || ask < CROSS_SESSION_THRESHOLD) return void 0;
+	const sensitive = judgment.sensitiveConfidence;
+	if (typeof sensitive === "number" && Number.isFinite(sensitive) && sensitive >= CROSS_SESSION_THRESHOLD) return;
+	const pick = typeof judgment.pick === "string" ? judgment.pick.trim() : "";
+	if (pick.length === 0) return void 0;
+	const chosen = candidates.find((candidate) => candidate.sessionId === pick);
+	if (chosen === void 0) return void 0;
+	return `「这件事可能更适合问：${chosen.name}（ask_session）」`;
+}
+/**
+* Decide whether this turn earns a hint: `off` never asks, `gated` asks only
+* after the prefilter passes, `always` asks on every turn. Never throws and
+* never returns a hint for a sensitive / low-confidence / unparseable answer.
+*
+* Diagnostics: one log line per judgment attempt — injected context, a
+* prefilter stop or a no-candidates stop is recorded as `skipped` with
+* `called: false` (a deliberate `off` mode writes nothing), and a Jev answer as
+* `recommend` (a hint was produced) or `none` (any veto).
+*/
+async function crossSessionHintForTurn(input) {
+	if (input.mode === "off") return void 0;
+	const candidates = Array.isArray(input.candidates) ? input.candidates : [];
+	const recorded = {
+		kind: "ask",
+		question: input.text,
+		candidates: candidates.map((candidate) => ({
+			id: candidate.sessionId,
+			title: candidate.name
+		}))
+	};
+	if (isInjectedContextText(input.text)) {
+		input.log?.({
+			...recorded,
+			called: false,
+			configured: input.judge !== void 0,
+			decision: "skipped"
+		});
+		return;
+	}
+	if (input.mode === "gated" && !shouldConsiderCrossSession(input.text)) {
+		input.log?.({
+			...recorded,
+			called: false,
+			configured: input.judge !== void 0,
+			decision: "skipped"
+		});
+		return;
+	}
+	if (candidates.length === 0) {
+		input.log?.({
+			...recorded,
+			called: false,
+			configured: input.judge !== void 0,
+			decision: "skipped"
+		});
+		return;
+	}
+	if (input.judge === void 0) {
+		input.log?.({
+			...recorded,
+			called: false,
+			configured: false,
+			decision: "skipped"
+		});
+		return;
+	}
+	try {
+		const judgment = await input.judge({
+			text: input.text,
+			...input.textEn === void 0 ? {} : { textEn: input.textEn },
+			candidates
+		});
+		const hint = crossSessionSuggestionLine(judgment, candidates);
+		const pickId = judgment === void 0 || typeof judgment.pick !== "string" ? "" : judgment.pick.trim();
+		const picked = pickId.length > 0 ? candidates.find((candidate) => candidate.sessionId === pickId) : void 0;
+		const confidence = judgment !== void 0 && typeof judgment.askConfidence === "number" ? judgment.askConfidence : void 0;
+		input.log?.({
+			...recorded,
+			called: true,
+			configured: true,
+			decision: hint === void 0 ? "none" : "recommend",
+			...picked === void 0 ? {} : {
+				pickedId: picked.sessionId,
+				pickedTitle: picked.name
+			},
+			...confidence === void 0 ? {} : { confidence }
+		});
+		return hint;
+	} catch (error) {
+		input.log?.({
+			...recorded,
+			called: true,
+			configured: true,
+			decision: "error",
+			error: error instanceof Error ? error.message : String(error)
+		});
+		return;
+	}
+}
+/** Pending one-turn hints, per agent session. */
+const pendingCrossSessionHints = /* @__PURE__ */ new Map();
+/** Remember the hint for this session's next prompt assembly (overwrites). */
+function rememberCrossSessionHint(sessionId, hint) {
+	if (typeof sessionId !== "string" || sessionId.length === 0) return;
+	if (typeof hint !== "string" || hint.trim().length === 0) return;
+	pendingCrossSessionHints.set(sessionId, hint.trim());
+}
+/** Consume the pending hint: it is returned once, then forgotten. */
+function takeCrossSessionHint(sessionId) {
+	if (typeof sessionId !== "string" || sessionId.length === 0) return void 0;
+	const hint = pendingCrossSessionHints.get(sessionId);
+	if (hint === void 0) return void 0;
+	pendingCrossSessionHints.delete(sessionId);
+	return hint;
+}
+/**
+* Append (and consume) the pending cross-session hint to one assembled system
+* prompt. One-turn timing: the background judgment of turn N stores the hint,
+* the NEXT assembly reads and clears it — so the hint is visible for exactly
+* one assembly and never repeats.
+*/
+function appendCrossSessionHint(prompt, sessionId) {
+	const hint = takeCrossSessionHint(sessionId);
+	if (hint === void 0) return prompt;
+	return prompt.length === 0 ? hint : `${prompt}\n\n${hint}`;
+}
+/** Cache key: normalised question, cap, asking session, engine, and exclusions. */
+function routeCacheKey(question, topN, currentSessionId, engine, exclude) {
+	return `${normalizeAliasKey(typeof question === "string" ? question : "")}\u0000${topN}\u0000${typeof currentSessionId === "string" ? currentSessionId : ""}\u0000${engine}\u0000${excludeKey(exclude)}`;
+}
+/** A live cache entry, or undefined when it is absent or older than the TTL. */
+function readCachedRoute(key) {
+	const entry = routeCache.get(key);
+	if (entry === void 0) return void 0;
+	if (Date.now() - entry.at > ROUTE_CACHE_TTL_MS) {
+		routeCache.delete(key);
+		return;
+	}
+	return entry.candidates;
+}
+/** Store one route, evicting the oldest entries beyond {@link ROUTE_CACHE_MAX}. */
+function writeCachedRoute(key, candidates) {
+	routeCache.delete(key);
+	routeCache.set(key, {
+		at: Date.now(),
+		candidates: [...candidates]
+	});
+	while (routeCache.size > ROUTE_CACHE_MAX) {
+		const oldest = routeCache.keys().next().value;
+		if (oldest === void 0) break;
+		routeCache.delete(oldest);
+	}
+}
+/** The uncached routing pass: score, order, and label the candidates. */
+function routeUncached(sessions, question, topN, options) {
+	const now = Date.now();
+	const query = readQuestion(question);
+	const hitsBySession = aliasHits(query.phrase, readAliasMap(options?.aliases));
+	const indexed = [];
+	for (const session of Array.isArray(sessions) ? sessions : []) {
+		if (isNoiseSession(session, options?.currentSessionId)) continue;
+		const row = indexSession(session);
+		if (row !== void 0 && !rowExcluded(options?.exclude, row)) indexed.push(row);
+	}
+	if (indexed.length === 0) return [];
+	const scored = [];
+	for (const row of indexed) {
+		const hit = scoreRow(row, query, hitsBySession.get(row.sessionId));
+		if (hit !== void 0) scored.push(hit);
+	}
+	if (scored.length > 0) {
+		scored.sort((a, b) => compareScored(a, b, now));
+		return selectTop(scored, topN, now);
+	}
+	return widePool(indexed, query, topN, now);
+}
+/**
+* Read the alias file: normalised phrasing → sessionId.
+* A missing, unreadable or corrupt file reads as {}, and no call ever throws.
+* @param file - absolute path of the JSON alias file.
+* @returns the usable alias map.
+*/
+function loadAliases(file) {
+	if (typeof file !== "string" || file.length === 0) return {};
+	let text;
+	try {
+		text = readFileSync(file, "utf8");
+	} catch {
+		return {};
+	}
+	let value;
+	try {
+		value = JSON.parse(text);
+	} catch {
+		return {};
+	}
+	if (value === null || typeof value !== "object" || Array.isArray(value)) return {};
+	const aliases = {};
+	for (const [phrasing, sessionId] of Object.entries(value)) {
+		if (typeof sessionId !== "string" || sessionId.length === 0) continue;
+		const key = normalizeAliasKey(phrasing);
+		if (key.length === 0) continue;
+		aliases[key] = sessionId;
+	}
+	return aliases;
+}
+//#endregion
+//#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, then the reply convention.
+* @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, askId) {
+	const blocks = [{
+		type: "text",
+		text: askId === void 0 || askId.length === 0 ? `【来自会话「${senderName}」的提问】` : `【来自会话「${senderName}」的提问 · askId=${askId}】`
+	}, {
+		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 host publishes the `title`
+* projection as a **plain string** (`dsh-session-title`: `z.string().min(1).nullable()`),
+* so a string is the normal shape here; the `{ title }` wrapper is accepted as
+* well because older cached rows used it. Every miss degrades to the cwd+time
+* fallback instead of throwing.
+*/
+function sessionDisplayName(summary) {
+	const raw = summary.projections?.values?.title;
+	const title = (typeof raw === "string" ? raw : 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;
+/** When nothing matches, this many recent sessions come back as candidates. */
+const NOT_FOUND_CANDIDATE_LIMIT = 8;
+/** The exclusion entries carried by `swarm.routingExclude`; malformed values are ignored. */
+function exclusionEntries$1(value) {
+	return Array.isArray(value) ? value.filter((entry) => typeof entry === "string") : [];
+}
+/** True when this listed session is on the user's exclusion list. */
+function summaryExcluded(entries, summary) {
+	return isSessionExcluded(entries, {
+		sessionId: summary.sessionId,
+		names: [sessionDisplayName(summary)]
+	});
+}
+/**
+* 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: {
@@ -3385,6 +5120,22 @@ function nextAskHop(events) {
 	return 0;
 }
 /**
+* The askId of the inbound cross-session ask this session is currently
+* answering, if any. Reads the same source vocabulary as {@link nextAskHop}
+* but only the newest user message: once a plain human prompt arrives, the
+* model is answering that instead, so no parent is recorded. Returns undefined
+* when there is no inbound ask — the id is never parsed out of message text.
+* @param events - this session's log events in order.
+*/
+function inboundAskId(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;
+		return source?.kind === "session-ask" && typeof source.askId === "string" && source.askId.length > 0 ? source.askId : void 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
@@ -3413,6 +5164,33 @@ function collectAnswer(events, fromSeq) {
 function joinAnswerPieces(pieces) {
 	return pieces.join("\n\n");
 }
+/** One 「结论：…」-style line, tolerating markdown bullets and bold markers. */
+const REPLY_FIELD = /^[\s>*#`-]*(结论|依据|不确定)[*\s]*[:：]\s*(.*)$/u;
+/** Best-effort parse of the reply convention; undefined when the text ignores it. */
+function parseAskReply(answer) {
+	const fields = {};
+	for (const line of answer.split(/\r?\n/u)) {
+		const match = REPLY_FIELD.exec(line);
+		if (match === null) continue;
+		const value = (match[2] ?? "").trim();
+		if (value.length === 0) continue;
+		if (match[1] === "结论" && fields.conclusion === void 0) fields.conclusion = value;
+		else if (match[1] === "依据" && fields.basis === void 0) fields.basis = value;
+		else if (match[1] === "不确定" && fields.uncertainty === void 0) fields.uncertainty = value;
+	}
+	return fields.conclusion === void 0 && fields.basis === void 0 && fields.uncertainty === void 0 ? void 0 : fields;
+}
+/**
+* `ok` = the peer settled idle and named a conclusion; `partial` = a timeout, a
+* missing conclusion, or prose that ignored the convention; `failed` = an error
+* or nothing said. An unfinished async ask is still `waiting`, never `failed`.
+*/
+function askStatus(input) {
+	if (input.endedBecause === "error") return "failed";
+	if (input.answer.trim().length === 0) return "failed";
+	if (input.endedBecause !== "idle") return "partial";
+	return "ok";
+}
 /** Highest event seq present, or -1 for an empty log (the session-cursor convention). */
 function logWatermark(events) {
 	let highest = -1;
@@ -3421,9 +5199,21 @@ function logWatermark(events) {
 }
 /** Human-readable text the main model reads for one settled ask_session call. */
 function renderAskResult(value) {
+	const reply = value.reply;
+	const structured = reply === void 0 ? "" : [
+		reply.conclusion === void 0 ? "" : `结论：${reply.conclusion}`,
+		reply.basis === void 0 ? "" : `依据：${reply.basis}`,
+		reply.uncertainty === void 0 ? "" : `不确定：${reply.uncertainty}`
+	].filter((line) => line.length > 0).join("\n");
+	const body = structured.length > 0 ? structured : value.answer.trim().length > 0 ? value.answer : value.status === void 0 && value.askId !== void 0 ? "（已异步投递，结果稍后用 ask_result 读取。）" : "（该区间内对方没有产出正文。）";
+	const who = [
+		value.targetName === void 0 ? "" : `来自「${value.targetName}」`,
+		value.askId === void 0 || value.askId.length === 0 ? "" : `askId=${value.askId}`,
+		value.status === void 0 ? "" : `状态 ${value.status}`
+	].filter((part) => part.length > 0).join(" · ");
 	return [{
 		type: "text",
-		text: `${value.answer.trim().length > 0 ? value.answer : "（该区间内对方没有产出正文。）"}\n\n${value.note}`
+		text: `${who.length > 0 ? `【${who}】\n` : ""}${body}\n\n${value.note}`
 	}];
 }
 /**
@@ -3438,8 +5228,63 @@ function isSubagentDeliveryRejection(error) {
 	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();
+/** One unsettled wait per session: at most one ask_session may be in flight. */
+const pendingWaits = /* @__PURE__ */ new Set();
+/** Directory holding detached (async) ask results. */
+function askStoreRoot() {
+	const dshHome = process.env.DSH_HOME ?? join(homedir(), ".dsh");
+	return askStoreDir(join(dshHome, "storages", "advisor-group"));
+}
+/** Longest question text kept in one diagnostics line. */
+const JEV_LOG_QUESTION_MAX = 300;
+/** Longest candidate title kept in one diagnostics line. */
+const JEV_LOG_TITLE_MAX = 80;
+/** Clamp a diagnostic string; non-strings read as ''. */
+function clipLogText(value, max) {
+	const text = typeof value === "string" ? value : "";
+	return text.length <= max ? text : text.slice(0, max);
+}
+/**
+* Append ONE JSON line describing a Jev decision attempt to
+* `<askStoreRoot()>/routing-jev.log`.
+*
+* Diagnostics only: the directory is created on demand, `question` is clamped
+* to 300 characters and each candidate title to 80, and EVERY failure is
+* ignored so a log write can never disturb the routing path. Nothing reads the
+* file back; humans (and the settings diagnostics) do.
+* @param entry - the attempt: kind, question, whether Jev was called/configured,
+*   the resulting decision, and (when known) the pick and its confidence.
+*/
+function logJevDecision(entry) {
+	try {
+		const line = JSON.stringify({
+			at: typeof entry.at === "string" && entry.at.length > 0 ? entry.at : (/* @__PURE__ */ new Date()).toISOString(),
+			kind: entry.kind === "ask" ? "ask" : "route",
+			question: clipLogText(entry.question, JEV_LOG_QUESTION_MAX),
+			called: entry.called === true,
+			configured: entry.configured === true,
+			decision: entry.decision,
+			...typeof entry.pickedId === "string" && entry.pickedId.length > 0 ? { pickedId: entry.pickedId } : {},
+			...typeof entry.pickedTitle === "string" && entry.pickedTitle.length > 0 ? { pickedTitle: clipLogText(entry.pickedTitle, JEV_LOG_TITLE_MAX) } : {},
+			...typeof entry.confidence === "number" && Number.isFinite(entry.confidence) ? { confidence: entry.confidence } : {},
+			...Array.isArray(entry.candidates) ? { candidates: entry.candidates.map((candidate) => ({
+				id: clipLogText(candidate?.id, JEV_LOG_TITLE_MAX),
+				title: clipLogText(candidate?.title, JEV_LOG_TITLE_MAX)
+			})) } : {},
+			...typeof entry.error === "string" && entry.error.length > 0 ? { error: entry.error } : {}
+		});
+		const dir = askStoreRoot();
+		mkdirSync(dir, { recursive: true });
+		appendFileSync(join(dir, "routing-jev.log"), `${line}\n`, "utf8");
+	} catch {}
+}
+/** Background loops started by `detach: true`; cancelled when the plugin unloads. */
+const detachedControllers = /* @__PURE__ */ new Set();
+/** Cancel every detached wait (plugin dispose). Safe to call repeatedly. */
+function cancelDetachedAsks() {
+	for (const controller of detachedControllers) controller.abort();
+	detachedControllers.clear();
+}
 /** Whether this session already has an unsettled ask_session wait. */
 function isWaiting(sessionId) {
 	return pendingWaits.has(sessionId);
@@ -3499,7 +5344,7 @@ async function sleep(ms, signal) {
 * 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);
+	const envelope = buildAskEnvelope(input.source.senderName, input.question, input.context, input.source.askId);
 	try {
 		const resolved = await controller.resolveAgent(input.target.sessionId);
 		if ("agent" in resolved && resolved.agent) {
@@ -3696,7 +5541,8 @@ function checkAskGuards(input) {
 	const { guards, match } = input;
 	if (match.kind === "missing") return {
 		code: "target-not-found",
-		message: "没有找到匹配的会话。请用会话列表里的标题或 sessionId 指定目标；不确认时先列出候选再让用户选择。"
+		message: "没有找到匹配的会话。下面列出最近的会话，请把候选交给用户挑选（标题或 sessionId 都可以）；不要再去翻会话日志或目录找 id。",
+		candidates: orderCandidates(input.sessions).slice(0, NOT_FOUND_CANDIDATE_LIMIT).map(candidateOf)
 	};
 	if (match.kind === "ambiguous") return {
 		code: "target-ambiguous",
@@ -3743,11 +5589,21 @@ async function askSession(ctx, signal, input) {
 	pendingWaits.add(input.currentSessionId);
 	try {
 		const sessions = [];
+		const allowed = [];
+		const entries = exclusionEntries$1(input.exclude);
 		let match = { kind: "missing" };
 		try {
 			const listed = await controller.list({}, signal);
 			sessions.push(...listed.items);
-			match = matchTargetSession(sessions, input.target ?? "");
+			for (const session of sessions) if (!summaryExcluded(entries, session)) allowed.push(session);
+			match = matchTargetSession(allowed, input.target ?? "");
+			if (match.kind === "missing" && entries.length > 0) {
+				const full = matchTargetSession(sessions, input.target ?? "");
+				if ((full.kind === "unique" ? sessions.some((session) => session.sessionId === full.target.sessionId && summaryExcluded(entries, session)) : full.kind === "ambiguous" && full.candidates.some((candidate) => !allowed.some((session) => session.sessionId === candidate.sessionId))) && (input.target ?? "").trim().length > 0) return toToolError({
+					code: "swarm-excluded",
+					message: "这个会话被设置为不参与蜂群（设置 → 插件 → 顾问群 → 全局蜂群 → 不参与路由的会话）。"
+				});
+			}
 		} catch (error) {
 			return {
 				ok: false,
@@ -3756,7 +5612,7 @@ async function askSession(ctx, signal, input) {
 			};
 		}
 		return await runAsk(ctx, controller, signal, input, {
-			sessions,
+			sessions: allowed,
 			match,
 			log: input.log ?? (() => {})
 		});
@@ -3788,6 +5644,7 @@ async function runAsk(ctx, controller, signal, input, listed) {
 	};
 	const targetRow = listed.sessions.find((session) => session.sessionId === target.sessionId);
 	const askId = nextAskId();
+	const parentAskId = inboundAskId(input.currentEvents);
 	const source = {
 		kind: "session-ask",
 		form: "relay",
@@ -3816,6 +5673,84 @@ async function runAsk(ctx, controller, signal, input, listed) {
 		senderName: input.senderName,
 		targetName: target.name
 	});
+	if (input.detach === true) {
+		const storeDir = askStoreRoot();
+		const record = {
+			askId,
+			sessionId: input.currentSessionId,
+			targetSessionId: target.sessionId,
+			targetName: target.name,
+			question: input.question,
+			state: "waiting",
+			createdAt: Date.now(),
+			from,
+			...parentAskId === void 0 ? {} : { parentAskId }
+		};
+		try {
+			writeAskRecord(storeDir, record);
+		} catch (error) {
+			console.warn("[dsh-advisor-group] 异步结果落盘失败（投递仍已发出）：", error);
+		}
+		const background = new AbortController();
+		detachedControllers.add(background);
+		(async () => {
+			let settled = {};
+			try {
+				const outcome = await waitForTargetIdle(controller, background.signal, {
+					sessionId: target.sessionId,
+					targetWasRunning: delivery.receipt.targetWasRunning,
+					waitMs,
+					log: listed.log,
+					fromSeq: delivery.receipt.fromSeq
+				});
+				const rawAnswer = joinAnswerPieces((await collectTargetAnswer(controller, target.sessionId, delivery.receipt.fromSeq)).pieces);
+				const reply = parseAskReply(rawAnswer);
+				settled = {
+					state: outcome.endedBecause === "idle" ? "done" : outcome.endedBecause === "timeout" ? "timeout" : "error",
+					answer: rawAnswer,
+					...reply === void 0 ? {} : { reply },
+					status: askStatus({
+						endedBecause: outcome.endedBecause,
+						answer: rawAnswer
+					}),
+					note: outcome.note
+				};
+			} catch (error) {
+				settled = {
+					state: "error",
+					error: error instanceof Error ? error.message : String(error)
+				};
+			} finally {
+				try {
+					writeAskRecord(storeDir, {
+						...record,
+						...settled,
+						settledAt: Date.now()
+					});
+				} catch (error) {
+					console.warn("[dsh-advisor-group] 异步结果落盘失败：", error);
+				}
+				detachedControllers.delete(background);
+			}
+		})();
+		return {
+			ok: true,
+			detached: true,
+			target: {
+				sessionId: target.sessionId,
+				name: target.name
+			},
+			delivered: delivery.receipt.delivered,
+			askId,
+			interval: {
+				from,
+				to: null,
+				endedBecause: "detached"
+			},
+			answer: "",
+			note: `已投递（异步）：问题已交给「${target.name}」，本次调用不等待答复。稍后用 ask_result（askId=${askId}）读取结果。`
+		};
+	}
 	const outcome = await waitForTargetIdle(controller, signal, {
 		sessionId: target.sessionId,
 		targetWasRunning: delivery.receipt.targetWasRunning,
@@ -3824,7 +5759,13 @@ async function runAsk(ctx, controller, signal, input, listed) {
 		fromSeq: delivery.receipt.fromSeq
 	});
 	const collected = await collectTargetAnswer(controller, target.sessionId, delivery.receipt.fromSeq);
-	const answer = joinAnswerPieces(collected.pieces);
+	const rawAnswer = joinAnswerPieces(collected.pieces);
+	const answer = rawAnswer;
+	const reply = parseAskReply(rawAnswer);
+	const status = askStatus({
+		endedBecause: outcome.endedBecause,
+		answer
+	});
 	const to = outcome.endedBecause === "idle" ? (/* @__PURE__ */ new Date()).toISOString() : null;
 	const note = [
 		"区间语义：从投递回执到对方会话下一次整体空闲，这两个时刻之间对方产出的文字都算在内——这是「这个区间里对方说的话」，不是逐条对应的回答。",
@@ -3837,7 +5778,7 @@ async function runAsk(ctx, controller, signal, input, listed) {
 		askId,
 		question: input.question,
 		targetName: target.name,
-		answer,
+		answer: rawAnswer,
 		note
 	});
 	return {
@@ -3854,6 +5795,8 @@ async function runAsk(ctx, controller, signal, input, listed) {
 			endedBecause: outcome.endedBecause
 		},
 		answer,
+		...reply === void 0 ? {} : { reply },
+		status,
 		note
 	};
 }
@@ -4133,8 +6076,7 @@ function registerAdvisorTools(service, ctx) {
 			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
+					description: "The target session, named the way the user names it: its exact title as shown in the session list (the session name in the sidebar), a natural partial name, or a full sessionId. A title or the workspace/directory name is usually enough (「极简遥控器」 matches sessions under I:\\极简遥控器\\…). One unique match is used directly; several matches return the candidates (running / most recently active first) and a miss returns the recent sessions — both for the USER to choose: never guess, and do NOT search session logs or directories for session ids."
 				},
 				question: {
 					type: "string",
@@ -4145,9 +6087,17 @@ function registerAdvisorTools(service, ctx) {
 					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."
 				},
+				questionEn: {
+					type: "string",
+					description: "Optional one-line English gloss of the question. Sent to the Jev routing engine as extra context when 「路由方式」 is Jev; the question, the candidates and every session record keep the original language."
+				},
 				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.`
+				},
+				detach: {
+					type: "boolean",
+					description: "Deliver without waiting: return immediately with an askId, then read the answer later with ask_result. Use it when the other session may take minutes, so this turn is not blocked. Ignored when waitMs is also given: pass only one."
 				}
 			},
 			output: {
@@ -4177,6 +6127,7 @@ function registerAdvisorTools(service, ctx) {
 							type: "string",
 							enum: ["native", "fallback"]
 						},
+						detached: { type: "boolean" },
 						askId: { type: "string" },
 						interval: {
 							type: "object",
@@ -4192,7 +6143,8 @@ function registerAdvisorTools(service, ctx) {
 									enum: [
 										"idle",
 										"timeout",
-										"error"
+										"error",
+										"detached"
 									],
 									required: true
 								}
@@ -4203,6 +6155,23 @@ function registerAdvisorTools(service, ctx) {
 							type: "string",
 							required: true
 						},
+						status: {
+							type: "string",
+							enum: [
+								"ok",
+								"partial",
+								"failed"
+							]
+						},
+						reply: {
+							type: "object",
+							additionalProperties: false,
+							properties: {
+								conclusion: { type: "string" },
+								basis: { type: "string" },
+								uncertainty: { type: "string" }
+							}
+						},
 						note: {
 							type: "string",
 							required: true
@@ -4229,18 +6198,57 @@ function registerAdvisorTools(service, ctx) {
 									}
 								}
 							}
+						},
+						routeCandidates: {
+							type: "array",
+							items: {
+								type: "object",
+								additionalProperties: false,
+								properties: {
+									sessionId: {
+										type: "string",
+										required: true
+									},
+									name: {
+										type: "string",
+										required: true
+									},
+									score: {
+										type: "number",
+										required: true
+									},
+									reason: {
+										type: "string",
+										required: true
+									}
+								}
+							}
 						}
 					}
 				},
 				render: (_args, value) => value.ok === true ? renderAskResult({
 					answer: String(value.answer ?? ""),
-					note: String(value.note ?? "")
+					note: String(value.note ?? ""),
+					targetName: String(value.target?.name ?? ""),
+					askId: String(value.askId ?? ""),
+					...value.status === "ok" || value.status === "partial" || value.status === "failed" ? { status: value.status } : {},
+					...value.reply === null || typeof value.reply !== "object" ? {} : { reply: value.reply }
 				}) : [{
 					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")}` : ""}`
+					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")}` : ""}${renderRouteCandidates(value.routeCandidates)}`
 				}]
 			},
 			async execute(args, exec) {
+				const swarm = service.getConfig().swarm;
+				if (swarm.enabled === false) return {
+					ok: false,
+					error: "swarm-disabled",
+					message: SWARM_DISABLED_MESSAGE,
+					answer: "",
+					note: "",
+					interval: errorInterval()
+				};
+				const hidden = exclusionEntries(swarm);
 				const controller = getSessionController(ctx);
 				if (!controller) return {
 					ok: false,
@@ -4263,10 +6271,38 @@ function registerAdvisorTools(service, ctx) {
 				const question = typeof args.question === "string" ? args.question : "";
 				const context = typeof args.context === "string" ? args.context : void 0;
 				let senderName = "未命名会话";
+				let listedItems = [];
 				try {
-					const own = (await controller.list({}, exec.signal)).items.find((item) => item.sessionId === sessionId);
+					const listed = await controller.list({}, exec.signal);
+					listedItems = listed.items;
+					const own = listed.items.find((item) => item.sessionId === sessionId);
 					if (own) senderName = sessionDisplayName(own);
 				} catch {}
+				if ((typeof args.target === "string" ? args.target.trim() : "").length === 0 && swarm.routingEnabled !== false) {
+					const roster = visibleRosterSessions(listedItems, swarm.rosterIncludeSubagents).filter((row) => !isSessionExcluded(hidden, {
+						sessionId: row.sessionId,
+						names: [sessionDisplayName(row)]
+					}));
+					const routeCandidates = await routeSessionsWithEngine(withSessionLogSizes(roster), question, {
+						topN: swarm.routingTopN,
+						aliases: knownRoutingAliases(routingAliasFile(), roster),
+						currentSessionId: sessionId,
+						engine: swarm.routingEngine === "jev" ? "jev" : "local",
+						exclude: hidden,
+						questionEn: typeof args.questionEn === "string" ? args.questionEn : void 0,
+						jev: routingJevRouter(service.getConfig().trigger.jev, exec.signal),
+						log: logJevDecision
+					});
+					if (routeCandidates.length > 0) return {
+						ok: false,
+						error: "target-unspecified",
+						message: "没有指定会话。下面按问题匹配出的候选，请让用户挑一个（或直接点名会话）再投递。",
+						answer: "",
+						note: "",
+						interval: errorInterval(),
+						routeCandidates: markRecentAsks(routeCandidates, sessionId)
+					};
+				}
 				const cardLog = session;
 				const onDelivered = (info) => {
 					if (!cardLog) return;
@@ -4284,6 +6320,7 @@ function registerAdvisorTools(service, ctx) {
 						console.warn("[dsh-advisor-group] 跨会话卡片（结束）写入失败：", error);
 					}
 				};
+				const answerMode = resolveAskDefaults(args, swarm);
 				const value = await askSession(ctx, exec.signal, {
 					onDelivered,
 					onSettled,
@@ -4293,7 +6330,9 @@ function registerAdvisorTools(service, ctx) {
 					target: typeof args.target === "string" ? args.target : "",
 					question,
 					context,
-					waitMs: args.waitMs,
+					waitMs: answerMode.waitMs,
+					detach: answerMode.detach,
+					exclude: hidden,
 					log: (message) => console.log(`[dsh-advisor-group] ask_session: ${message}`)
 				});
 				if (value.ok !== true) return {
@@ -4312,12 +6351,286 @@ function registerAdvisorTools(service, ctx) {
 					askId: String(value.askId ?? ""),
 					interval: value.interval,
 					answer: String(value.answer ?? ""),
+					...value.detached === true ? { detached: true } : {},
+					...value.reply === null || typeof value.reply !== "object" ? {} : { reply: value.reply },
 					note: String(value.note ?? "")
 				};
 			}
+		}),
+		defineTool({
+			name: "list_sessions",
+			description: "List the sessions this host knows: the title shown in the session list, its sessionId, working directory, how long ago it was active, and whether it is running. Use it when the user names a session but you are unsure which one they mean, or after ask_session returns target-not-found / target-ambiguous — show the rows to the user instead of digging session ids out of log files. Read-only: it never wakes a session and costs no model call.",
+			parameters: {
+				query: {
+					type: "string",
+					description: "Optional case-insensitive filter over the session title, its working directory, or its activity hint. Empty lists the most recent sessions (running first)."
+				},
+				limit: {
+					type: "number",
+					description: "Maximum rows (default 30, clamped to 1–50)."
+				}
+			},
+			output: {
+				schema: {
+					type: "object",
+					additionalProperties: false,
+					properties: {
+						ok: {
+							type: "boolean",
+							required: true
+						},
+						count: {
+							type: "number",
+							required: true
+						},
+						sessions: {
+							type: "array",
+							required: true,
+							items: {
+								type: "object",
+								additionalProperties: false,
+								properties: {
+									sessionId: {
+										type: "string",
+										required: true
+									},
+									name: {
+										type: "string",
+										required: true
+									},
+									cwd: { type: "string" },
+									updatedAt: {
+										type: "number",
+										required: true
+									},
+									running: {
+										type: "boolean",
+										required: true
+									},
+									subagent: {
+										type: "boolean",
+										required: true
+									},
+									hint: {
+										type: "string",
+										required: true
+									},
+									hasTitle: {
+										type: "boolean",
+										required: true
+									},
+									sizeHint: { type: "number" }
+								}
+							}
+						},
+						error: { type: "string" },
+						message: { type: "string" }
+					}
+				},
+				render: (args, value) => value.ok === true ? [{
+					type: "text",
+					text: renderRoster(value.sessions, { filtered: String(args.query ?? "").trim().length > 0 })
+				}] : [{
+					type: "text",
+					text: `【list_sessions 失败：${String(value.error ?? "unknown")}】\n${String(value.message ?? "")}`
+				}]
+			},
+			async execute(args, exec) {
+				const swarm = service.getConfig().swarm;
+				if (swarm.enabled === false) return {
+					ok: false,
+					count: 0,
+					sessions: [],
+					error: "swarm-disabled",
+					message: SWARM_DISABLED_MESSAGE
+				};
+				const controller = getSessionController(ctx);
+				if (controller === void 0) return {
+					ok: false,
+					count: 0,
+					sessions: [],
+					error: "service-missing",
+					message: "宿主没有提供 sessionController，无法列出会话。"
+				};
+				try {
+					const sessions = buildSessionRoster((await controller.list({}, exec.signal)).items.filter((item) => !isHiddenSession(swarm, item)), {
+						query: typeof args.query === "string" ? args.query : "",
+						limit: typeof args.limit === "number" ? args.limit : void 0,
+						hideSubagents: swarm.rosterIncludeSubagents !== true
+					}).map((row) => ({
+						...row,
+						name: shortSessionName(row.name, row.cwd)
+					}));
+					return {
+						ok: true,
+						count: sessions.length,
+						sessions
+					};
+				} catch (error) {
+					return {
+						ok: false,
+						count: 0,
+						sessions: [],
+						error: "list-failed",
+						message: String(error instanceof Error ? error.message : error)
+					};
+				}
+			}
+		}),
+		defineTool({
+			name: "ask_result",
+			description: "Read the result of a detached ask_session (called with detach: true). Pass askId for one result, or omit it to list this session's recent asks. States: waiting (the peer is still working — this is NOT a failure and NOT a reason to ask again; the send was already durable), done (answer ready), timeout (the wait window ended; a partial answer may exist), error. Read-only: it never wakes the target.",
+			parameters: { askId: {
+				type: "string",
+				description: "The askId returned by ask_session with detach: true. Omit it to list the recent asks this session started."
+			} },
+			output: {
+				schema: {
+					type: "object",
+					additionalProperties: false,
+					properties: {
+						ok: {
+							type: "boolean",
+							required: true
+						},
+						count: {
+							type: "number",
+							required: true
+						},
+						results: {
+							type: "array",
+							required: true,
+							items: {
+								type: "object",
+								additionalProperties: false,
+								properties: {
+									askId: {
+										type: "string",
+										required: true
+									},
+									sessionId: { type: "string" },
+									targetSessionId: { type: "string" },
+									/** Inbound ask this one descends from (call-chain trace), when any. */
+									parentAskId: { type: "string" },
+									from: { type: "string" },
+									status: {
+										type: "string",
+										enum: [
+											"ok",
+											"partial",
+											"failed"
+										]
+									},
+									targetName: {
+										type: "string",
+										required: true
+									},
+									question: {
+										type: "string",
+										required: true
+									},
+									state: {
+										type: "string",
+										required: true
+									},
+									createdAt: {
+										type: "number",
+										required: true
+									},
+									settledAt: { type: "number" },
+									answer: { type: "string" },
+									reply: {
+										type: "object",
+										additionalProperties: false,
+										properties: {
+											conclusion: { type: "string" },
+											basis: { type: "string" },
+											uncertainty: { type: "string" }
+										}
+									},
+									note: { type: "string" },
+									error: { type: "string" }
+								}
+							}
+						},
+						error: { type: "string" },
+						message: { type: "string" }
+					}
+				},
+				render: (_args, value) => {
+					if (value.ok !== true) return [{
+						type: "text",
+						text: `【ask_result 失败：${String(value.error ?? "unknown")}】\n${String(value.message ?? "")}`
+					}];
+					const rows = Array.isArray(value.results) ? value.results : [];
+					if (rows.length === 0) return [{
+						type: "text",
+						text: "没有找到异步提问的结果。"
+					}];
+					return [{
+						type: "text",
+						text: renderAskRecords(rows)
+					}];
+				}
+			},
+			async execute(args, exec) {
+				const swarm = service.getConfig().swarm;
+				if (swarm.enabled === false) return {
+					ok: false,
+					count: 0,
+					results: [],
+					error: "swarm-disabled",
+					message: SWARM_DISABLED_MESSAGE
+				};
+				const session = getCurrentSessionFrom(exec);
+				const sessionId = typeof session?.id === "string" ? session.id : "";
+				try {
+					const dir = askStoreRoot();
+					const ttlHours = Math.min(720, Math.max(1, Math.floor(swarm.resultTtlHours)));
+					try {
+						pruneAskRecords(dir, ttlHours * 36e5);
+					} catch {}
+					const askId = typeof args.askId === "string" ? args.askId.trim() : "";
+					const results = askId.length > 0 ? [readAskRecord(dir, askId)].filter((row) => row !== void 0) : listAskRecords(dir, sessionId.length > 0 ? { sessionId } : void 0).slice(0, 20);
+					return {
+						ok: true,
+						count: results.length,
+						results
+					};
+				} catch (error) {
+					return {
+						ok: false,
+						count: 0,
+						results: [],
+						error: "store-failed",
+						message: String(error instanceof Error ? error.message : error)
+					};
+				}
+			}
 		})
 	];
 }
+/** One compact block per detached ask result, for the model to read. */
+function renderAskRecords(rows) {
+	const stateLabel = {
+		waiting: "等待中",
+		done: "已完成",
+		timeout: "超时",
+		error: "出错"
+	};
+	return rows.map((row) => {
+		return [
+			`- [${stateLabel[row.state]}] ${row.targetName} · askId=${row.askId}`,
+			row.parentAskId === void 0 ? "" : `  （由 ${row.parentAskId} 转问）`,
+			`  问题：${row.question.replace(/\s+/gu, " ").slice(0, 120)}`,
+			row.reply !== void 0 ? [
+				row.reply.conclusion === void 0 ? "" : `  结论：${row.reply.conclusion}`,
+				row.reply.basis === void 0 ? "" : `  依据：${row.reply.basis}`,
+				row.reply.uncertainty === void 0 ? "" : `  不确定：${row.reply.uncertainty}`
+			].filter((line) => line.length > 0).join("\n") : row.answer !== void 0 && row.answer.length > 0 ? `  ${row.answer.slice(0, 600)}` : row.error !== void 0 ? `  错误：${row.error}` : ""
+		].filter((line) => line.length > 0).join("\n");
+	}).join("\n\n");
+}
 /**
 * 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
@@ -4342,6 +6655,101 @@ function errorInterval() {
 		endedBecause: "error"
 	};
 }
+/** Refusal text shared by the three cross-session tools when the swarm switch is off. */
+const SWARM_DISABLED_MESSAGE = "蜂群模式已在设置里关闭（设置 → 插件 → 顾问群 → 全局蜂群）。";
+/**
+* Effective ask mode: an argument the caller passes always wins; an omitted
+* one falls back to the configured default (`defaultMode` / `defaultWaitMs`).
+*/
+function resolveAskDefaults(args, swarm) {
+	return {
+		waitMs: typeof args.waitMs === "number" ? args.waitMs : swarm.defaultWaitMs,
+		detach: typeof args.detach === "boolean" ? args.detach : swarm.defaultMode === "detach"
+	};
+}
+/**
+* Roster visibility: subagent sessions are dropped unless the setting lists
+* them. Pure, so the filter is testable without a host session controller.
+*/
+function visibleRosterSessions(sessions, includeSubagents) {
+	return includeSubagents ? sessions : sessions.filter((session) => session.origin !== "subagent");
+}
+/** The exclusion entries from settings; anything malformed is ignored. */
+function exclusionEntries(swarm) {
+	return Array.isArray(swarm.routingExclude) ? swarm.routingExclude.filter((entry) => typeof entry === "string") : [];
+}
+/** The exclusion matcher's view of one listed session (title or fallback name). */
+function excludableOf(summary) {
+	return {
+		sessionId: summary.sessionId,
+		names: [sessionDisplayName(summary)]
+	};
+}
+/** True when this listed session is hidden by `swarm.routingExclude`. */
+function isHiddenSession(swarm, summary) {
+	return isSessionExcluded(exclusionEntries(swarm), excludableOf(summary));
+}
+/** Alias file location: beside the detached ask records, under the plugin store. */
+function routingAliasFile() {
+	return `${askStoreRoot()}/aliases.json`;
+}
+/**
+* Alias map restricted to sessions that still exist. A remembered phrasing that
+* points at a deleted session is dropped here — the router never decides that.
+*/
+function knownRoutingAliases(file, sessions) {
+	const known = new Set(sessions.map((session) => session.sessionId));
+	return Object.fromEntries(Object.entries(loadAliases(file)).filter(([, sessionId]) => known.has(sessionId)));
+}
+/**
+* The Jev re-ranker for the routing engine, or undefined when Jev has no
+* usable credentials. `undefined` is meaningful: the router then behaves
+* exactly like the local engine and says so on the candidates, instead of
+* logging a failure on every routing pass.
+*/
+function routingJevRouter(config, signal) {
+	if (config === void 0 || !jevConfigured(config)) return void 0;
+	const jev = config;
+	return async (input) => {
+		const decision = await routeWithJev(input.question, input.questionEn, input.candidates.map((candidate) => ({
+			id: candidate.sessionId,
+			title: candidate.name,
+			scope: candidate.reason
+		})), jev, signal);
+		return {
+			choice: decision.choice,
+			...decision.confidence === void 0 ? {} : { confidence: decision.confidence }
+		};
+	};
+}
+/** Error-path render of the routing candidates: the user picks one, then names it. */
+function renderRouteCandidates(value) {
+	if (!Array.isArray(value) || value.length === 0) return "";
+	return `\n按问题匹配出的候选：\n${value.map((item) => {
+		const row = item;
+		return `- ${typeof row.name === "string" ? row.name : ""} · ${typeof row.sessionId === "string" ? row.sessionId : ""} · ${typeof row.reason === "string" ? row.reason : ""}${typeof row.score === "number" ? `（${row.score} 分）` : ""}`;
+	}).join("\n")}`;
+}
+/** A repeat ask inside this window earns the 「刚问过」 hint. */
+const RECENT_ASK_WINDOW_MS = 6e5;
+/**
+* Append 「刚问过」 to a candidate this asking session already asked in the last
+* ten minutes, so a repeat is visible before delivering. Best effort and
+* side-effect free: a missing or damaged ask store only means no hint.
+*/
+function markRecentAsks(candidates, sessionId, now = Date.now()) {
+	let recent;
+	try {
+		recent = new Set(listAskRecords(askStoreRoot(), { sessionId }).filter((record) => now - record.createdAt <= RECENT_ASK_WINDOW_MS).map((record) => record.targetSessionId).filter((id) => typeof id === "string" && id.length > 0));
+	} catch {
+		return [...candidates];
+	}
+	if (recent.size === 0) return [...candidates];
+	return candidates.map((candidate) => recent.has(candidate.sessionId) ? {
+		...candidate,
+		reason: `${candidate.reason} · 刚问过`
+	} : candidate);
+}
 function formatRiskNotes(summary) {
 	return summary.riskNotes.length > 0 ? `\n\n【风险提示】\n${summary.riskNotes.join("\n")}` : "";
 }
@@ -4664,6 +7072,22 @@ async function parseLookupParams(req) {
 const ALLOWED_API_KEY_ENVS = new Set(Object.values(PROVIDER_PRESETS).map((preset) => preset.apiKeyEnv));
 ALLOWED_API_KEY_ENVS.add("TYPESAFE_API_KEY");
 ALLOWED_API_KEY_ENVS.add("OPENROUTER_API_KEY");
+/**
+* Env names the diagnostics may read. Presets contribute their fixed names; on top of that we
+* trust every name the user has already **saved** in this plugin's config — that is what lets a
+* custom provider use its own variable. Trusting the saved config keeps the guard meaningful: a
+* caller cannot invent a name, only reuse one the user declared here.
+*/
+function allowedApiKeyEnvs(config) {
+	const allowed = new Set(ALLOWED_API_KEY_ENVS);
+	for (const advisor of config.advisors ?? []) {
+		const env = advisor.apiKeyEnv?.trim();
+		if (env) allowed.add(env);
+	}
+	const jevEnv = config.trigger?.jev?.apiKeyEnv?.trim();
+	if (jevEnv) allowed.add(jevEnv);
+	return allowed;
+}
 function validateSecurity(input) {
 	if (input.trigger.jev?.baseURL) {
 		const url = input.trigger.jev.baseURL.trim();
@@ -4680,7 +7104,7 @@ function validateSecurity(input) {
 		}
 		if (advisor.apiKeyEnv) {
 			const env = advisor.apiKeyEnv.trim();
-			if (!ALLOWED_API_KEY_ENVS.has(env)) return `顾问 ${advisor.id} 的 API Key 不被允许：${env}。请使用预设供应商对应的 API Key。`;
+			if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(env)) return `顾问 ${advisor.id} 的 API Key 环境变量名无效：${env}`;
 		}
 	}
 	return null;
@@ -4826,10 +7250,10 @@ async function handleModelsRequest(ctx, service, req, res) {
 		});
 		return;
 	}
-	if (!apiKey && effectiveEnv && !ALLOWED_API_KEY_ENVS.has(effectiveEnv)) {
+	if (!apiKey && effectiveEnv && !allowedApiKeyEnvs(service.getConfig()).has(effectiveEnv)) {
 		sendJson(res, 400, {
 			ok: false,
-			error: "API Key 不能使用该环境变量名"
+			error: `环境变量 ${effectiveEnv} 还不能用于测试：自定义供应商请先保存设置，或直接在「API Key」里填密钥。`
 		});
 		return;
 	}
@@ -4916,10 +7340,10 @@ async function handleTestConnectionRequest(ctx, service, req, res) {
 		});
 		return;
 	}
-	if (!apiKey && effectiveEnv && !ALLOWED_API_KEY_ENVS.has(effectiveEnv)) {
+	if (!apiKey && effectiveEnv && !allowedApiKeyEnvs(service.getConfig()).has(effectiveEnv)) {
 		sendJson(res, 400, {
 			ok: false,
-			error: "API Key 不能使用该环境变量名"
+			error: `环境变量 ${effectiveEnv} 还不能用于测试：自定义供应商请先保存设置，或直接在「API Key」里填密钥。`
 		});
 		return;
 	}
@@ -5358,6 +7782,39 @@ const inject = [
 	"systemPrompt",
 	"sessions"
 ];
+/**
+* One background cross-session suggestion pass: recall the local candidates
+* for this turn, ask Jev the batched judgment, and remember a one-turn hint.
+* Everything is best effort — no hint, no error, no delivery on any failure.
+*/
+async function suggestCrossSession(input) {
+	try {
+		const controller = getSessionController(input.ctx);
+		if (controller === void 0) return;
+		const config = input.service.getConfig();
+		const candidates = routeSessions(withSessionLogSizes(visibleRosterSessions((await controller.list({}, input.signal)).items, config.swarm.rosterIncludeSubagents)), input.text, {
+			topN: config.swarm.routingTopN,
+			currentSessionId: input.sessionId,
+			cache: false,
+			exclude: Array.isArray(config.swarm.routingExclude) ? config.swarm.routingExclude : []
+		});
+		const judge = async (turn) => judgeCrossSessionWithJev(turn.text, turn.textEn, turn.candidates.map((candidate) => ({
+			id: candidate.sessionId,
+			title: candidate.name,
+			scope: candidate.reason
+		})), input.jev, input.signal);
+		const hint = await crossSessionHintForTurn({
+			text: input.text,
+			mode: config.swarm.routingAsk ?? "gated",
+			candidates,
+			judge,
+			log: logJevDecision
+		});
+		if (hint === void 0) return;
+		rememberCrossSessionHint(input.sessionId, hint);
+		console.log(`[dsh-advisor-group] 跨会话提示（仅本轮）：${hint}`);
+	} catch {}
+}
 function apply(ctx, config) {
 	const guarded = guardAdvisorPrompts(unwrapVolatileConfig(config));
 	reportPromptGuardFindings(guarded.findings);
@@ -5365,12 +7822,65 @@ function apply(ctx, config) {
 	registerAdvisorSettingsAndRoutes(ctx, guarded.config, service);
 	for (const tool of registerAdvisorTools(service, ctx)) ctx.tools.register(tool);
 	const systemPrompt = ctx.systemPrompt;
+	ctx.effect(() => () => cancelDetachedAsks());
+	const hintAborts = new AbortController();
+	ctx.effect(() => () => hintAborts.abort());
+	ctx.on("session/event", (session, event) => {
+		const text = userMessageTextOf(event);
+		if (text === void 0) return;
+		const cfg = service.getConfig();
+		if (cfg.enabled === false || cfg.swarm.enabled === false) return;
+		const mode = cfg.swarm.routingAsk ?? "gated";
+		if (mode === "off") return;
+		const injected = isInjectedContextText(text);
+		if (!isGenuineUserPrompt(event) || injected) {
+			if (injected && shouldLogInjectedSkip(session.id)) logJevDecision({
+				kind: "ask",
+				question: text,
+				called: false,
+				configured: jevConfigured(cfg.trigger.jev),
+				decision: "skipped"
+			});
+			return;
+		}
+		resetInjectedSkipLog(session.id);
+		const configured = jevConfigured(cfg.trigger.jev);
+		if (mode === "gated" && !shouldConsiderCrossSession(text)) {
+			logJevDecision({
+				kind: "ask",
+				question: text,
+				called: false,
+				configured,
+				decision: "skipped"
+			});
+			return;
+		}
+		const jev = cfg.trigger.jev;
+		if (jev === void 0 || !configured) {
+			logJevDecision({
+				kind: "ask",
+				question: text,
+				called: false,
+				configured: false,
+				decision: "skipped"
+			});
+			return;
+		}
+		suggestCrossSession({
+			ctx,
+			service,
+			jev,
+			sessionId: session.id,
+			text,
+			signal: hintAborts.signal
+		});
+	});
 	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));
+			return appendCrossSessionHint(buildAdvisorPrompt(service.getConfig(), service.getRepeatPressure(sessionId)), sessionId);
 		}
 	}), "dsh-advisor-group: system prompt section");
 }