dsh-advisor-group 0.1.4 → 0.1.5

package/lib/index.mjs

@@ -119,6 +119,7 @@ const SwarmConfig = Schema.object({
 	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)."),
+	deliverBack: Schema.boolean().default(true).description("Copy a settled answer back into the asking session automatically (done only; timeout and error are never delivered back). Off leaves results readable only through ask_result."),
 	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)."),
@@ -3508,13 +3509,20 @@ async function judgeCrossSessionWithJev(text, textEn, candidates, config, signal
 * atomic tmp+rename writes, and reads that degrade to `undefined` instead of
 * throwing on a missing or damaged file.
 */
+/**
+* Identity of this host process. A record created by another process can no
+* longer be waited on (its background loop died with that process), so a
+* `waiting` record carrying a different boot id is reconciled when read.
+*/
+const ASK_BOOT_ID = randomUUID();
 /** 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"
+	"error",
+	"interrupted"
 ]);
 /** The store directory for a base dir such as `$DSH_HOME/storages/advisor-group`. */
 function askStoreDir(baseDir) {
@@ -3538,6 +3546,21 @@ function parseRecord(text) {
 	return isAskRecord(value) ? value : void 0;
 }
 /**
+* Settle a `waiting` record whose wait belonged to a previous host process.
+* The background loop that would have collected the answer died with that
+* process, so leaving the record `waiting` promises something that will never
+* happen. Returns the rewritten record, or undefined when nothing is stale.
+*/
+function reconcileStaleAsk(record, bootId = ASK_BOOT_ID) {
+	if (record.state !== "waiting" || record.bootId === bootId) return void 0;
+	return {
+		...record,
+		state: "interrupted",
+		settledAt: Date.now(),
+		note: record.bootId === void 0 ? "这条异步提问来自更早的插件版本，等待状态已无法确认；对方可能已经作答，但答案没有被自动收回。请到对方会话里查看，或重新提问。" : "宿主在等待期间重启，等待被中断；对方可能已经作答，但答案没有被自动收回。请到对方会话里查看，或重新提问。"
+	};
+}
+/**
 * Write one record atomically: tmp file + rename, so a concurrent reader never
 * sees a half-written JSON document. Creates `dir` when missing.
 */
@@ -3648,7 +3671,7 @@ const DRIVE_SEGMENT$1 = /^[A-Za-z]:$/u;
 * and a bare greeting is an empty chat that never named itself.
 */
 const NOISE_TITLE_PATTERN = /生成会话标题|^你好[，,\s]*$/u;
-function isRecord(value) {
+function isRecord$1(value) {
 	return value !== null && typeof value === "object";
 }
 /**
@@ -3656,11 +3679,11 @@ function isRecord(value) {
 * `{ title }` wrapper. Returns '' when neither yields a non-empty string.
 */
 function titleOf$1(projections) {
-	if (!isRecord(projections)) return "";
+	if (!isRecord$1(projections)) return "";
 	const values = projections.values;
-	if (!isRecord(values)) return "";
+	if (!isRecord$1(values)) return "";
 	const raw = values.title;
-	return (typeof raw === "string" ? raw : isRecord(raw) && typeof raw.title === "string" ? raw.title : "").trim();
+	return (typeof raw === "string" ? raw : isRecord$1(raw) && typeof raw.title === "string" ? raw.title : "").trim();
 }
 /**
 * Whether a raw roster row must stay out of the roster and the routing pool:
@@ -3670,7 +3693,7 @@ function titleOf$1(projections) {
 * @param currentSessionId - the asking session, dropped when its id matches.
 */
 function isNoiseSession(session, currentSessionId) {
-	if (!isRecord(session)) return false;
+	if (!isRecord$1(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;
@@ -3847,12 +3870,12 @@ 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 (!isRecord$1(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;
+		if (!isRecord$1(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,
@@ -3872,7 +3895,7 @@ 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 (!isRecord$1(session)) continue;
 		if (isNoiseSession(session)) continue;
 		const raw = session;
 		if (options?.hideSubagents === true && raw.origin === "subagent") continue;
@@ -3909,17 +3932,20 @@ function buildSessionRoster(sessions, options) {
 	});
 }
 /**
-* 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.
+* Render the roster as the text the model reads. The sessionId is appended to
+* every line so identical titles stay distinguishable (the structured rows
+* already carry it). `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.
+* @returns heading plus one `- <name> · <sessionId> — <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}`;
+		const corps = row.roleName === void 0 ? "" : ` · 顾问团「${row.roleName}」${row.duty !== void 0 && row.duty.length > 0 ? `（${row.duty}）` : ""}`;
+		return `- ${shortSessionName(row.name, row.cwd)} · ${row.sessionId} — ${row.hint}${flags}${corps}`;
 	})].join("\n");
 }
 //#endregion
@@ -4955,6 +4981,10 @@ 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;
+/** Refusal/skip reason for a session the user archived in the workspace. */
+const ARCHIVED_SESSION_MESSAGE = "这个会话已归档，先在工作区里取消归档才能唤醒它";
+/** Refusal/skip reason for a session no workspace registers (the sidebar hides it). */
+const UNREGISTERED_SESSION_MESSAGE = "这个会话不在任何工作区里（可能已被移出工作区），先从工作区里找到它才能唤醒";
 /**
 * 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
@@ -5020,13 +5050,79 @@ function sessionDisplayName(summary) {
 	if (title.length > 0) return title;
 	return fallbackSessionName(summary.cwd, summary.updatedAt);
 }
-function candidateOf(summary) {
+const AGE_MINUTE_MS = 6e4;
+/**
+* Human age for one session, for display only: 「刚刚」 / 「N 分钟前」 /
+* 「N 小时前」 / 「N 天前」 / 「N 个月前」 / 「N 年前」.
+* @param updatedAt - last-activity timestamp in ms.
+* @param now - clock to measure against.
+*/
+function relativeAge(updatedAt, now) {
+	const age = now - updatedAt;
+	if (!Number.isFinite(age)) return "（未知时间）";
+	if (age < AGE_MINUTE_MS) return "刚刚";
+	const minutes = Math.floor(age / AGE_MINUTE_MS);
+	if (minutes < 60) return `${minutes} 分钟前`;
+	const hours = Math.floor(minutes / 60);
+	if (hours < 24) return `${hours} 小时前`;
+	const days = Math.floor(hours / 24);
+	if (days < 30) return `${days} 天前`;
+	const months = Math.floor(days / 30);
+	if (months < 12) return `${months} 个月前`;
+	return `${Math.floor(months / 12)} 年前`;
+}
+function candidateOf(summary, now = Date.now()) {
+	const cwd = summary.cwd;
 	return {
 		sessionId: summary.sessionId,
 		name: sessionDisplayName(summary),
-		hint: fallbackSessionName(summary.cwd, summary.updatedAt)
+		hint: fallbackSessionName(cwd, summary.updatedAt),
+		...typeof cwd === "string" && cwd.length > 0 ? { cwd } : {},
+		age: relativeAge(summary.updatedAt, now)
 	};
 }
+/** `- name · sessionId · cwd · 多久前` for one candidate (display only). */
+function candidateLine(candidate) {
+	const cwd = typeof candidate.cwd === "string" && candidate.cwd.length > 0 ? candidate.cwd : "（未知工作目录）";
+	const age = typeof candidate.age === "string" && candidate.age.length > 0 ? candidate.age : "（未知时间）";
+	return `- ${candidate.name} · ${candidate.sessionId} · ${cwd} · ${age}`;
+}
+/**
+* The candidate block appended to an ambiguous / not-found refusal and to batch
+* skip reasons. Display only — matching never uses it.
+*
+* - One hint line when a title repeats.
+* - At most {@link CANDIDATE_DISPLAY_LIMIT} candidate lines, each carrying
+*   name · sessionId · cwd · 多久前.
+* - A remainder note when the list was truncated; the rest stay addressable by
+*   sessionId or directory, they are just not spread out.
+* - Ordering is the caller's: running first, then most recently updated. Names
+*   and ids are never used for sorting.
+* @param candidates - the ordered candidate pool (may be longer than the cap).
+* @param options.total - full match count when the pool is already capped.
+* @param options.sameTitle - false makes the remainder note say 「会话」 rather
+*   than 「同名会话」 (used for the not-found recent list).
+*/
+function renderCandidateBlock(candidates, options) {
+	const pool = Array.isArray(candidates) ? candidates : [];
+	const shown = pool.slice(0, 10);
+	const total = Math.max(shown.length, Math.floor(options?.total ?? pool.length));
+	const nameCounts = /* @__PURE__ */ new Map();
+	for (const candidate of pool) nameCounts.set(candidate.name, (nameCounts.get(candidate.name) ?? 0) + 1);
+	const repeated = [...nameCounts.values()].some((count) => count > 1);
+	const lines = [];
+	if (repeated) lines.push("同名会话较多：按下面的 sessionId 或目录指定");
+	lines.push(...shown.map(candidateLine));
+	if (total > shown.length) {
+		const noun = options?.sameTitle === false ? "个会话" : "个同名会话";
+		lines.push(`…还有 ${total - shown.length} ${noun}，可用目录关键词进一步收窄`);
+	}
+	return lines.join("\n");
+}
+/** Every listed session as a display candidate: running first, then most recent. */
+function recentCandidates(sessions, now = Date.now()) {
+	return orderCandidates(sessions).map((session) => candidateOf(session, now));
+}
 /** Most-recently-active first, running sessions ahead of idle ones. */
 function orderCandidates(rows) {
 	return [...rows].sort((a, b) => {
@@ -5034,10 +5130,8 @@ function orderCandidates(rows) {
 		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;
+const NOT_FOUND_CANDIDATE_LIMIT = 10;
 /** 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") : [];
@@ -5081,10 +5175,14 @@ function matchTargetSession(sessions, reference) {
 			name: sessionDisplayName(exact[0])
 		}
 	};
-	if (exact.length > 1) return {
-		kind: "ambiguous",
-		candidates: orderCandidates(exact).map(candidateOf)
-	};
+	if (exact.length > 1) {
+		const ordered = orderCandidates(exact).map((session) => candidateOf(session));
+		return {
+			kind: "ambiguous",
+			candidates: ordered.slice(0, 10),
+			total: ordered.length
+		};
+	}
 	const partial = sessions.filter((session) => sessionDisplayName(session).toLowerCase().includes(folded) || session.cwd !== void 0 && session.cwd.toLowerCase().includes(folded));
 	if (partial.length === 1) return {
 		kind: "unique",
@@ -5094,9 +5192,11 @@ function matchTargetSession(sessions, reference) {
 		}
 	};
 	if (partial.length === 0) return { kind: "missing" };
+	const ordered = orderCandidates(partial).map((session) => candidateOf(session));
 	return {
 		kind: "ambiguous",
-		candidates: orderCandidates(partial).slice(0, PARTIAL_CANDIDATE_LIMIT).map(candidateOf)
+		candidates: ordered.slice(0, 10),
+		total: ordered.length
 	};
 }
 /**
@@ -5164,6 +5264,55 @@ function collectAnswer(events, fromSeq) {
 function joinAnswerPieces(pieces) {
 	return pieces.join("\n\n");
 }
+/** A provisional body longer than this is truncated for display. */
+const PROVISIONAL_BODY_LIMIT = 2e3;
+/**
+* Reconstruct the delivery watermark from the recorded delivery time: the
+* highest event seq at or before `fromMs`. The waiting record does not persist
+* the seq cut, so this recovers an equivalent floor from timestamps for a
+* read-only probe (settling still uses the real recorded watermark).
+* @param events - the target's log events in order.
+* @param fromMs - delivery time in ms since epoch.
+*/
+function deliveryWatermark(events, fromMs) {
+	if (!Number.isFinite(fromMs)) return -1;
+	let highest = -1;
+	for (const event of events) {
+		if (!Number.isFinite(event.time) || event.time > fromMs) continue;
+		if (typeof event.seq === "number" && event.seq > highest) highest = event.seq;
+	}
+	return highest;
+}
+/**
+* Read-only probe for a still-waiting detached ask: did the target already
+* write body text after this delivery? Reuses {@link collectAnswer} with the
+* reconstructed watermark. Display only — nothing is written back and the
+* record stays `waiting`. Any failure (bad timestamp, missing agent, host
+* error) returns undefined so the caller keeps the old output.
+*/
+async function probeWaitingBody(controller, record) {
+	try {
+		const fromMs = Date.parse(record.from);
+		if (!Number.isFinite(fromMs)) return void 0;
+		const resolved = await controller.resolveAgent(record.targetSessionId);
+		if (!("agent" in resolved) || !resolved.agent) return void 0;
+		const events = agentEvents(resolved.agent);
+		const text = joinAnswerPieces(collectAnswer(events, deliveryWatermark(events, fromMs)).pieces).trim();
+		return text.length > 0 ? text : void 0;
+	} catch {
+		return;
+	}
+}
+/**
+* One labelled provisional-body block (display only), truncated with a note.
+* @param text - the body collected so far.
+* @returns a two-part block, or undefined when there is no body.
+*/
+function provisionalBodySection(text) {
+	const trimmed = text.trim();
+	if (trimmed.length === 0) return void 0;
+	return `（尚未落定：目标可能仍在继续，下面是目前已收到的正文）\n${trimmed.slice(0, PROVISIONAL_BODY_LIMIT)}${trimmed.length > 2e3 ? "\n…（正文过长，仅显示前 2000 字）" : ""}`;
+}
 /** 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. */
@@ -5280,6 +5429,17 @@ function logJevDecision(entry) {
 }
 /** Background loops started by `detach: true`; cancelled when the plugin unloads. */
 const detachedControllers = /* @__PURE__ */ new Set();
+/**
+* Track one background AbortController so plugin dispose ({@link
+* cancelDetachedAsks}) aborts it. Returns a disposer that stops tracking it.
+* The batch fan-out uses it so every in-flight target is cancelled on unload.
+*/
+function trackBackgroundController(controller) {
+	detachedControllers.add(controller);
+	return () => {
+		detachedControllers.delete(controller);
+	};
+}
 /** Cancel every detached wait (plugin dispose). Safe to call repeatedly. */
 function cancelDetachedAsks() {
 	for (const controller of detachedControllers) controller.abort();
@@ -5420,6 +5580,68 @@ async function deliverViaPrompt(controller, _signal, envelope, input, why) {
 		};
 	}
 }
+/** One answer-copy message: source line plus the FULL answer (never truncated). */
+function buildAnswerBackText(targetName, askId, answer) {
+	return `【来自「${targetName}」 · askId=${askId}】\n${answer}`;
+}
+/**
+* Copy-back text used when the ask already rendered a card in the asking
+* session: the full answer lives in that card and in the stored record, so the
+* chat message points at it instead of printing the same text a second time.
+*/
+function buildAnswerBackNotice(targetName, askId) {
+	return `【来自「${targetName}」 · askId=${askId}】答复已就绪，并显示在跨会话卡片中。需要原文时调用 ask_result（askId=${askId}）。`;
+}
+/** The merged batch copy-back: one message for every done answer. */
+function buildBatchAnswerBackText(entries) {
+	if (entries.length === 1) {
+		const only = entries[0];
+		return buildAnswerBackText(only.targetName, only.askId, only.answer);
+	}
+	const blocks = entries.map((entry) => buildAnswerBackText(entry.targetName, entry.askId, entry.answer));
+	return [`【批量回送 · 共 ${entries.length} 条】`, ...blocks].join("\n\n");
+}
+/**
+* Copy one settled answer back into the asking session. Reuses the same two
+* delivery paths as a question (native `followup`, then the host `prompt` queue
+* when the agent is not resolvable), so a busy asker simply receives it through
+* the host's inbox. Every failure is returned, never thrown.
+*/
+async function deliverAnswerBack(controller, input, text) {
+	const content = [{
+		type: "text",
+		text
+	}];
+	const source = {
+		kind: "session-ask",
+		form: "relay",
+		askId: `${input.askId}-answer`,
+		senderSessionId: input.targetSessionId,
+		senderName: input.targetName,
+		hop: 0
+	};
+	try {
+		const resolved = await controller.resolveAgent(input.askerSessionId);
+		if ("agent" in resolved && resolved.agent) {
+			resolved.agent.followup(buildAskMessage(content, source));
+			return { ok: true };
+		}
+	} catch {}
+	try {
+		await controller.prompt({
+			requestId: `${input.askId}-answer`,
+			sessionId: input.askerSessionId,
+			mode: "queue",
+			content
+		});
+		return { ok: true };
+	} catch (error) {
+		return {
+			ok: false,
+			error: describeHostError(error)
+		};
+	}
+}
 async function watermarkViaResolve(controller, sessionId) {
 	try {
 		const resolved = await controller.resolveAgent(sessionId);
@@ -5532,6 +5754,167 @@ async function collectTargetAnswer(controller, sessionId, fromSeq) {
 	}
 }
 /**
+* Wait for the target's next whole-session idle, then collect what it said in
+* the interval. Shared by `ask_session` and the `ask_sessions` fan-out, so the
+* wait/collect/classify semantics have exactly one implementation.
+*
+* All failure paths are already converted into outcome notes by
+* {@link waitForTargetIdle} / {@link collectTargetAnswer}; this helper only
+* throws if the caller's own abort mechanism throws.
+*/
+async function collectDeliveredAsk(controller, signal, input) {
+	const outcome = await waitForTargetIdle(controller, signal, {
+		sessionId: input.target.sessionId,
+		targetWasRunning: input.targetWasRunning,
+		waitMs: input.waitMs,
+		log: input.log,
+		fromSeq: input.fromSeq
+	});
+	const collected = await collectTargetAnswer(controller, input.target.sessionId, input.fromSeq);
+	const rawAnswer = joinAnswerPieces(collected.pieces);
+	const reply = parseAskReply(rawAnswer);
+	const status = askStatus({
+		endedBecause: outcome.endedBecause,
+		answer: rawAnswer
+	});
+	const to = outcome.endedBecause === "idle" ? (/* @__PURE__ */ new Date()).toISOString() : null;
+	const notes = [
+		"区间语义：从投递回执到对方会话下一次整体空闲，这两个时刻之间对方产出的文字都算在内——这是「这个区间里对方说的话」，不是逐条对应的回答。",
+		input.deliveryNote,
+		outcome.note,
+		input.targetWasRunning ? "投递时对方正在忙，问题已排队，会在它当前回合结束后进入新回合。" : "投递时对方不忙，宿主已唤醒它开一个新回合。",
+		collected.readError === void 0 ? "" : `读取对方会话日志时出错，answer 可能不完整：${collected.readError}`
+	].filter((line) => line.length > 0);
+	return {
+		interval: {
+			from: input.from,
+			to,
+			endedBecause: outcome.endedBecause
+		},
+		rawAnswer,
+		...reply === void 0 ? {} : { reply },
+		status,
+		note: notes.join("\n"),
+		answer: rawAnswer
+	};
+}
+let registryProbeLogged = false;
+/** Print the registry probe at most once per process, for host-log diagnosis. */
+function logRegistryProbe(found, workspaces, sessions) {
+	if (registryProbeLogged) return;
+	registryProbeLogged = true;
+	console.log(found ? `[dsh-advisor-group] workspaceRegistry: ok (${workspaces} 个工区, ${sessions} 个已登记会话)` : "[dsh-advisor-group] workspaceRegistry: unavailable — 已退回不过滤");
+}
+/**
+* Resolve the host workspace registry from the plugin context. Cordis exposes a
+* service either as a plain property or through reflection (`ctx.reflect.get`,
+* which in non-strict mode returns undefined when the service is absent); a
+* plain `ctx.get` is accepted as the last resort. Every path is tried in order
+* and any throw falls through, so a host without the service simply yields
+* `undefined` (no filtering) instead of failing the caller.
+*/
+function workspaceRegistryService(ctx) {
+	const paths = [
+		() => ctx?.workspaceRegistry,
+		() => {
+			const reflect = ctx?.reflect;
+			const get = reflect?.get;
+			if (typeof get !== "function") return void 0;
+			return get.call(reflect, "workspaceRegistry", false);
+		},
+		() => {
+			const get = ctx?.get;
+			if (typeof get !== "function") return void 0;
+			return get.call(ctx, "workspaceRegistry");
+		}
+	];
+	for (const resolve of paths) try {
+		const value = resolve();
+		if (value !== null && typeof value === "object") return value;
+	} catch {}
+}
+/**
+* Archived session ids from the host workspace registry
+* (`workspaceRegistry.archivedSessionIds`, iterable). Used for the explicit
+* "this session is archived" refusal, and subtracted from the registered set.
+*
+* The registry is resolved through {@link workspaceRegistryService}; a missing
+* service (older host) or a throwing accessor yields an empty set: no
+* filtering, no error.
+*/
+function archivedSessionIds(ctx) {
+	try {
+		const ids = workspaceRegistryService(ctx)?.archivedSessionIds;
+		if (ids === null || ids === void 0) return /* @__PURE__ */ new Set();
+		if (typeof ids[Symbol.iterator] !== "function") return /* @__PURE__ */ new Set();
+		return new Set([...ids].map((id) => String(id)));
+	} catch {
+		return /* @__PURE__ */ new Set();
+	}
+}
+/**
+* The session ids the host's sidebar shows: the union of every workspace's
+* `sessionIds` (`workspaceRegistry.list()`), minus the archived ones.
+*
+* This is the display universe: `sessionController.list()` also returns
+* sessions that no workspace registers (e.g. sessions the user moved out of
+* every workspace), and the sidebar hides those. Callers filter with this set.
+*
+* The registry itself is resolved through {@link workspaceRegistryService}
+* (plain property, then `ctx.reflect.get(..., false)`, then `ctx.get`), so it
+* works on hosts that only expose the service through reflection.
+*
+* Returns `undefined` when the host has no workspace registry, its `list` is not
+* a function, `list()` does not return an array, or anything throws — callers
+* then skip the filter entirely (old-host behaviour), never fail. The outcome
+* is logged once per process for diagnosis.
+*/
+function registeredSessionIds(ctx) {
+	try {
+		const registry = workspaceRegistryService(ctx);
+		if (registry === void 0) {
+			logRegistryProbe(false, 0, 0);
+			return;
+		}
+		const list = registry.list;
+		if (typeof list !== "function") {
+			logRegistryProbe(false, 0, 0);
+			return;
+		}
+		const workspaces = list.call(registry);
+		if (!Array.isArray(workspaces)) {
+			logRegistryProbe(false, 0, 0);
+			return;
+		}
+		const ids = /* @__PURE__ */ new Set();
+		let workspaceCount = 0;
+		for (const workspace of workspaces) {
+			if (workspace === null || typeof workspace !== "object") continue;
+			workspaceCount += 1;
+			const sessionIds = workspace.sessionIds;
+			if (sessionIds === null || sessionIds === void 0) continue;
+			if (typeof sessionIds[Symbol.iterator] !== "function") continue;
+			for (const id of sessionIds) ids.add(String(id));
+		}
+		for (const archived of archivedSessionIds(ctx)) ids.delete(archived);
+		logRegistryProbe(true, workspaceCount, ids.size);
+		return ids;
+	} catch {
+		logRegistryProbe(false, 0, 0);
+		return;
+	}
+}
+/**
+* The listed sessions that may take part in an ask: `swarm.routingExclude`
+* matches are dropped, and so is every session the workspace registry does not
+* register. A `undefined` registered set means "no registry": no filtering.
+* Shared by `ask_session` and `ask_sessions`.
+*/
+function allowedAskSessions(sessions, exclude, registered) {
+	const entries = exclusionEntries$1(exclude);
+	return sessions.filter((session) => !summaryExcluded(entries, session) && (registered === void 0 || registered.has(session.sessionId)));
+}
+/**
 * Every pre-delivery guard, in one place. Pure: takes plain facts, returns a
 * rejection or nothing. Order matters — identity before ownership, ownership
 * before budget, budget before hop.
@@ -5539,16 +5922,24 @@ async function collectTargetAnswer(controller, sessionId, fromSeq) {
 */
 function checkAskGuards(input) {
 	const { guards, match } = input;
-	if (match.kind === "missing") return {
-		code: "target-not-found",
-		message: "没有找到匹配的会话。下面列出最近的会话，请把候选交给用户挑选（标题或 sessionId 都可以）；不要再去翻会话日志或目录找 id。",
-		candidates: orderCandidates(input.sessions).slice(0, NOT_FOUND_CANDIDATE_LIMIT).map(candidateOf)
-	};
-	if (match.kind === "ambiguous") return {
-		code: "target-ambiguous",
-		message: `有 ${match.candidates.length} 个会话都叫这个名字，不能猜。请把候选交给用户挑选（用 sessionId 指定即可精确命中）。`,
-		candidates: match.candidates
-	};
+	if (match.kind === "missing") {
+		const pool = recentCandidates(input.sessions);
+		const block = renderCandidateBlock(pool, { sameTitle: false });
+		return {
+			code: "target-not-found",
+			message: `没有找到匹配的会话。下面列出最近的会话，请把候选交给用户挑选（标题或 sessionId 都可以）；不要再去翻会话日志或目录找 id。${block.length > 0 ? `\n${block}` : ""}`,
+			candidates: pool.slice(0, NOT_FOUND_CANDIDATE_LIMIT)
+		};
+	}
+	if (match.kind === "ambiguous") {
+		const total = Math.max(match.candidates.length, match.total ?? match.candidates.length);
+		const block = renderCandidateBlock(match.candidates, { total });
+		return {
+			code: "target-ambiguous",
+			message: `有 ${total} 个会话都叫这个名字，不能猜。请把候选交给用户挑选（用 sessionId 指定即可精确命中）。${block.length > 0 ? `\n${block}` : ""}`,
+			candidates: match.candidates
+		};
+	}
 	const target = input.target ?? match.target;
 	if (target.sessionId === guards.currentSessionId) return {
 		code: "self-target",
@@ -5591,15 +5982,32 @@ async function askSession(ctx, signal, input) {
 		const sessions = [];
 		const allowed = [];
 		const entries = exclusionEntries$1(input.exclude);
+		const archived = archivedSessionIds(ctx);
+		const registered = registeredSessionIds(ctx);
 		let match = { kind: "missing" };
 		try {
 			const listed = await controller.list({}, signal);
 			sessions.push(...listed.items);
-			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({
+			for (const session of sessions) {
+				if (summaryExcluded(entries, session)) continue;
+				if (registered !== void 0 && !registered.has(session.sessionId)) continue;
+				allowed.push(session);
+			}
+			const targetText = (input.target ?? "").trim();
+			match = matchTargetSession(allowed, targetText);
+			if (match.kind === "missing" && targetText.length > 0) {
+				const full = matchTargetSession(sessions, targetText);
+				if (full.kind === "unique") {
+					if (archived.has(full.target.sessionId)) return toToolError({
+						code: "session-archived",
+						message: ARCHIVED_SESSION_MESSAGE
+					});
+					if (registered !== void 0 && !registered.has(full.target.sessionId)) return toToolError({
+						code: "session-unregistered",
+						message: UNREGISTERED_SESSION_MESSAGE
+					});
+				}
+				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))) return toToolError({
 					code: "swarm-excluded",
 					message: "这个会话被设置为不参与蜂群（设置 → 插件 → 顾问群 → 全局蜂群 → 不参与路由的会话）。"
 				});
@@ -5684,6 +6092,8 @@ async function runAsk(ctx, controller, signal, input, listed) {
 			state: "waiting",
 			createdAt: Date.now(),
 			from,
+			bootId: ASK_BOOT_ID,
+			fromSeq: delivery.receipt.fromSeq,
 			...parentAskId === void 0 ? {} : { parentAskId }
 		};
 		try {
@@ -5721,15 +6131,47 @@ async function runAsk(ctx, controller, signal, input, listed) {
 					error: error instanceof Error ? error.message : String(error)
 				};
 			} finally {
+				let finalRecord = {
+					...record,
+					...settled,
+					settledAt: Date.now()
+				};
 				try {
-					writeAskRecord(storeDir, {
-						...record,
-						...settled,
-						settledAt: Date.now()
-					});
+					writeAskRecord(storeDir, finalRecord);
 				} catch (error) {
 					console.warn("[dsh-advisor-group] 异步结果落盘失败：", error);
 				}
+				if (input.onSettled) try {
+					input.onSettled({
+						askId,
+						question: input.question,
+						targetName: target.name,
+						answer: finalRecord.answer ?? "",
+						note: finalRecord.note ?? (finalRecord.error ? `等待/收集失败：${finalRecord.error}` : "等待结束。")
+					});
+				} catch (error) {
+					console.warn("[dsh-advisor-group] 跨会话卡片（结束）回调失败：", error);
+				}
+				if (finalRecord.state === "done" && input.deliverBack !== false) {
+					const outcome = await deliverAnswerBack(controller, {
+						askerSessionId: finalRecord.sessionId,
+						targetSessionId: finalRecord.targetSessionId,
+						targetName: finalRecord.targetName,
+						askId: finalRecord.askId
+					}, input.onSettled ? buildAnswerBackNotice(finalRecord.targetName, finalRecord.askId) : buildAnswerBackText(finalRecord.targetName, finalRecord.askId, finalRecord.answer ?? ""));
+					finalRecord = outcome.ok ? {
+						...finalRecord,
+						deliveredBack: true
+					} : {
+						...finalRecord,
+						deliverBackNote: `自动回送失败：${outcome.error ?? "unknown"}（答案仍在记录里，可用 ask_result 取回）`
+					};
+					try {
+						writeAskRecord(storeDir, finalRecord);
+					} catch (error) {
+						console.warn("[dsh-advisor-group] 回送状态落盘失败：", error);
+					}
+				}
 				detachedControllers.delete(background);
 			}
 		})();
@@ -5751,35 +6193,21 @@ async function runAsk(ctx, controller, signal, input, listed) {
 			note: `已投递（异步）：问题已交给「${target.name}」，本次调用不等待答复。稍后用 ask_result（askId=${askId}）读取结果。`
 		};
 	}
-	const outcome = await waitForTargetIdle(controller, signal, {
-		sessionId: target.sessionId,
-		targetWasRunning: delivery.receipt.targetWasRunning,
+	const collected = await collectDeliveredAsk(controller, signal, {
+		target,
 		waitMs,
-		log: listed.log,
-		fromSeq: delivery.receipt.fromSeq
-	});
-	const collected = await collectTargetAnswer(controller, target.sessionId, delivery.receipt.fromSeq);
-	const rawAnswer = joinAnswerPieces(collected.pieces);
-	const answer = rawAnswer;
-	const reply = parseAskReply(rawAnswer);
-	const status = askStatus({
-		endedBecause: outcome.endedBecause,
-		answer
+		from,
+		targetWasRunning: delivery.receipt.targetWasRunning,
+		fromSeq: delivery.receipt.fromSeq,
+		deliveryNote: delivery.receipt.note,
+		log: listed.log
 	});
-	const to = outcome.endedBecause === "idle" ? (/* @__PURE__ */ new Date()).toISOString() : null;
-	const note = [
-		"区间语义：从投递回执到对方会话下一次整体空闲，这两个时刻之间对方产出的文字都算在内——这是「这个区间里对方说的话」，不是逐条对应的回答。",
-		delivery.receipt.note,
-		outcome.note,
-		delivery.receipt.targetWasRunning ? "投递时对方正在忙，问题已排队，会在它当前回合结束后进入新回合。" : "投递时对方不忙，宿主已唤醒它开一个新回合。",
-		collected.readError === void 0 ? "" : `读取对方会话日志时出错，answer 可能不完整：${collected.readError}`
-	].filter((line) => line.length > 0).join("\n");
 	input.onSettled?.({
 		askId,
 		question: input.question,
 		targetName: target.name,
-		answer: rawAnswer,
-		note
+		answer: collected.rawAnswer,
+		note: collected.note
 	});
 	return {
 		ok: true,
@@ -5789,15 +6217,11 @@ async function runAsk(ctx, controller, signal, input, listed) {
 		},
 		delivered: delivery.receipt.delivered,
 		askId,
-		interval: {
-			from,
-			to,
-			endedBecause: outcome.endedBecause
-		},
-		answer,
-		...reply === void 0 ? {} : { reply },
-		status,
-		note
+		interval: collected.interval,
+		answer: collected.answer,
+		...collected.reply === void 0 ? {} : { reply: collected.reply },
+		status: collected.status,
+		note: collected.note
 	};
 }
 function toToolError(rejection) {
@@ -5808,46 +6232,536 @@ function toToolError(rejection) {
 		...rejection.candidates ? { candidates: rejection.candidates } : {}
 	};
 }
+const SESSION_ID_MAX = 200;
+/** Path of the role-card fixture under the DSH home. */
+function corpsFile() {
+	const home = process.env.DSH_HOME || join(homedir(), ".dsh");
+	return join(home, "storages", "advisor-group", "corps.json");
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/**
+* Read the card map. A missing, damaged or partially invalid file degrades to
+* the valid cards it still contains (never throws): the panel and the target
+* resolver must keep working.
+*/
+function loadCorpsCards(file = corpsFile()) {
+	let parsed;
+	try {
+		parsed = JSON.parse(readFileSync(file, "utf8"));
+	} catch {
+		return {};
+	}
+	if (!isRecord(parsed) || !isRecord(parsed.cards)) return {};
+	const cards = {};
+	for (const [sessionId, value] of Object.entries(parsed.cards)) {
+		if (sessionId.length === 0 || sessionId.length > SESSION_ID_MAX || !isRecord(value)) continue;
+		const name = typeof value.name === "string" ? value.name.trim() : "";
+		const duty = typeof value.duty === "string" ? value.duty.trim() : "";
+		if (name.length === 0 || name.length > 40 || duty.length > 200) continue;
+		cards[sessionId] = {
+			name,
+			duty,
+			updatedAt: typeof value.updatedAt === "number" && Number.isFinite(value.updatedAt) ? value.updatedAt : Date.now()
+		};
+	}
+	return cards;
+}
+/** Atomic tmp+rename write; creates the directory when missing. */
+function saveCorpsCards(cards, file = corpsFile()) {
+	mkdirSync(dirname(file), { recursive: true });
+	const tmp = `${file}.tmp`;
+	writeFileSync(tmp, JSON.stringify({
+		version: 1,
+		cards
+	}, null, 2), "utf8");
+	renameSync(tmp, file);
+}
+/**
+* Upsert one card. An empty name deletes that session's card (the panel's
+* 「移除」 action). Names are unique case-insensitively across the whole map —
+* `ask_session` resolves a role name to exactly one session, never a guess.
+*/
+function upsertCorpsCard(cards, sessionId, rawName, rawDuty, now = Date.now()) {
+	const id = sessionId.trim();
+	if (id.length === 0 || id.length > SESSION_ID_MAX) return {
+		ok: false,
+		code: "invalid-session",
+		error: "会话 id 不合法。"
+	};
+	const name = rawName.trim();
+	const duty = rawDuty.trim();
+	if (name.length === 0) {
+		const next = { ...cards };
+		delete next[id];
+		return {
+			ok: true,
+			cards: next
+		};
+	}
+	if (name.length > 40) return {
+		ok: false,
+		code: "invalid-name",
+		error: `姓名不能超过 40 个字符。`
+	};
+	if (duty.length > 200) return {
+		ok: false,
+		code: "invalid-duty",
+		error: `职责不能超过 200 个字符。`
+	};
+	const lower = name.toLowerCase();
+	for (const [otherId, card] of Object.entries(cards)) if (otherId !== id && card.name.toLowerCase() === lower) return {
+		ok: false,
+		code: "duplicate-name",
+		error: `姓名「${name}」已经被另一个会话使用，请换一个。`
+	};
+	const card = {
+		name,
+		duty,
+		updatedAt: now
+	};
+	return {
+		ok: true,
+		cards: {
+			...cards,
+			[id]: card
+		},
+		card
+	};
+}
+/**
+* Exact, case-insensitive role-name lookup. Duplicate names (only possible in a
+* hand-edited file) resolve to nothing, so a target is never guessed.
+*/
+function findCorpsSession(cards, target) {
+	const wanted = target.trim().toLowerCase();
+	if (wanted.length === 0) return void 0;
+	const hits = Object.entries(cards).filter(([, card]) => card.name.toLowerCase() === wanted);
+	return hits.length === 1 ? hits[0][0] : void 0;
+}
 //#endregion
-//#region src/tools.ts
-function registerAdvisorTools(service, ctx) {
-	return [
-		defineTool({
-			name: "ask_advisors",
-			description: "Consult configured expert advisor models when the question is professional, long-tail world knowledge, high-risk, or the main model is uncertain. ALWAYS provide context with (a) a brief overview of the current project and (b) concrete details of the problem, including what has been tried and what went wrong. Also call immediately when the user @顾问群 or repeats the same question three times without resolution. Do NOT use for simple facts that web search can answer. Starting a new consultation runs the auto-deepen pipeline: up to maxRounds rounds of [driver deep-question → advisor A → advisor B (sees A) → advisor C (sees A+B) → …], closed by a driver-generated conclusion.",
-			parameters: {
-				question: {
-					type: "string",
-					description: "The question to ask the advisors. Required when starting a new consultation."
-				},
-				context: {
-					type: "string",
-					description: "Required background: (a) current project overview (domain/goal/stack/constraints) and (b) problem details (steps tried, expected vs actual, errors). Write \"该项背景未知\" for anything unknown; never leave it empty."
-				},
-				sessionId: {
-					type: "string",
-					description: "Existing consultation session id to continue."
-				},
-				followUp: {
-					type: "string",
-					description: "Follow-up question to send to the advisors in an existing session."
-				},
-				advisorIds: {
-					type: "array",
-					items: { type: "string" },
-					description: "Optional advisor ids to include; defaults to all configured advisors (capped by maxAdvisorsPerCall)."
-				},
-				confidence: {
-					type: "number",
-					description: "Optional self-assessed confidence 0-1. Values below the configured threshold escalate even without domain keywords."
-				},
-				questionEn: {
-					type: "string",
-					description: "Optional self-contained English gist of the question plus key background. Used as the Jev pre-classification input only when the「Jev 英文判定」setting is enabled; the displayed question, session records, and duplicate detection always keep using question/context in Chinese. Omit it otherwise."
-				}
-			},
-			output: {
-				schema: {
+//#region src/multi-ask.ts
+/**
+* Batch cross-session ask (`ask_sessions`): one question to 1–8 targets in one
+* call, with every result collected into one summary. Each target gets its own
+* delivery, its own wait and its own AskRecord, so `ask_result <askId>` keeps
+* working afterwards and `parentAskId` is filled the same way `ask_session`
+* fills it.
+*
+* This module owns no delivery or collection logic: it reuses
+* {@link deliverAsk} for the handover and {@link collectDeliveredAsk} for the
+* wait/collect half, plus {@link matchTargetSession} / {@link checkAskGuards}
+* for resolution and the per-target guards. There is no routing here: an
+* unnamed or ambiguous target is skipped with a reason, never guessed.
+*/
+/** Schema cap for one batch; extra targets are dropped (the schema says 1–8). */
+const BATCH_MAX_TARGETS = 8;
+const BATCH_SWARM_DISABLED = "蜂群模式已在设置里关闭（设置 → 插件 → 顾问群 → 全局蜂群）。";
+/** Concise per-target reason for a guard rejection (ask_session wording is long). */
+function skipReasonFor(rejection) {
+	switch (rejection.code) {
+		case "self-target": return "目标是当前会话自己";
+		case "subagent-target": return "目标会话是子代理（subagent）会话";
+		case "hop-limit": return "本次提问会超过 2 跳转发上限";
+		default: return rejection.message;
+	}
+}
+/** One child signal that aborts with its parent and on plugin dispose. */
+function linkedSignal(parent) {
+	const controller = new AbortController();
+	const onAbort = () => controller.abort();
+	if (parent.aborted) controller.abort();
+	else parent.addEventListener("abort", onAbort, { once: true });
+	const untrack = trackBackgroundController(controller);
+	return {
+		signal: controller.signal,
+		dispose: () => {
+			parent.removeEventListener("abort", onAbort);
+			untrack();
+		}
+	};
+}
+/**
+* Deliver to one target, write its waiting record, then wait/collect and write
+* the settled record. Never throws: a failure becomes an `error` result (and,
+* once delivered, an `error` record so `ask_result` still reports it).
+*/
+async function askOne(plan, batch) {
+	const askId = nextAskId();
+	const from = (/* @__PURE__ */ new Date()).toISOString();
+	const linked = linkedSignal(batch.parentSignal);
+	let record;
+	try {
+		const source = {
+			kind: "session-ask",
+			form: "relay",
+			askId,
+			senderSessionId: batch.currentSessionId,
+			senderName: batch.senderName,
+			hop: batch.hop
+		};
+		const delivery = await deliverAsk(batch.controller, linked.signal, {
+			target: plan.target,
+			question: batch.question,
+			context: batch.context,
+			source,
+			targetWasRunning: plan.targetWasRunning
+		});
+		if (!delivery.ok) return {
+			sessionId: plan.target.sessionId,
+			name: plan.target.name,
+			askId,
+			state: "error",
+			answer: "",
+			error: `${delivery.code}: ${delivery.message}`
+		};
+		const waitingRecord = {
+			askId,
+			sessionId: batch.currentSessionId,
+			targetSessionId: plan.target.sessionId,
+			targetName: plan.target.name,
+			question: batch.question,
+			state: "waiting",
+			createdAt: Date.now(),
+			from,
+			bootId: ASK_BOOT_ID,
+			fromSeq: delivery.receipt.fromSeq,
+			...batch.parentAskId === void 0 ? {} : { parentAskId: batch.parentAskId }
+		};
+		record = waitingRecord;
+		try {
+			writeAskRecord(batch.storeDir, waitingRecord);
+		} catch (error) {
+			console.warn("[dsh-advisor-group] 批量提问记录落盘失败（投递仍已发出）：", error);
+		}
+		const collected = await collectDeliveredAsk(batch.controller, linked.signal, {
+			target: plan.target,
+			waitMs: batch.waitMs,
+			from,
+			targetWasRunning: delivery.receipt.targetWasRunning,
+			fromSeq: delivery.receipt.fromSeq,
+			deliveryNote: delivery.receipt.note,
+			log: batch.log
+		});
+		const state = collected.interval.endedBecause === "idle" ? "done" : collected.interval.endedBecause === "timeout" ? "timeout" : "error";
+		try {
+			writeAskRecord(batch.storeDir, {
+				...waitingRecord,
+				state,
+				answer: collected.rawAnswer,
+				...collected.reply === void 0 ? {} : { reply: collected.reply },
+				status: collected.status,
+				note: collected.note,
+				settledAt: Date.now()
+			});
+		} catch (error) {
+			console.warn("[dsh-advisor-group] 批量提问记录落盘失败：", error);
+		}
+		return {
+			sessionId: plan.target.sessionId,
+			name: plan.target.name,
+			askId,
+			state,
+			answer: collected.answer,
+			status: collected.status,
+			note: collected.note
+		};
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		if (record !== void 0) try {
+			writeAskRecord(batch.storeDir, {
+				...record,
+				state: "error",
+				error: message,
+				settledAt: Date.now()
+			});
+		} catch {}
+		return {
+			sessionId: plan.target.sessionId,
+			name: plan.target.name,
+			askId,
+			state: "error",
+			answer: "",
+			error: message
+		};
+	} finally {
+		linked.dispose();
+	}
+}
+/**
+* One merged copy-back for the whole batch: only `done` answers are included
+* (timeout / error stay silent), sent after every target settled, and the
+* done records are marked (or annotated on failure). Best effort throughout:
+* a copy-back failure must never throw or lose the stored answer.
+*/
+async function deliverMergedBack(batch, results) {
+	if (!batch.deliverBack) return;
+	const done = results.filter((row) => row.state === "done");
+	if (done.length === 0) return;
+	const text = buildBatchAnswerBackText(done.map((row) => ({
+		targetName: row.name,
+		askId: row.askId,
+		answer: row.answer
+	})));
+	const outcome = await deliverAnswerBack(batch.controller, {
+		askerSessionId: batch.currentSessionId,
+		targetSessionId: done[0].sessionId,
+		targetName: done[0].name,
+		askId: nextAskId()
+	}, text);
+	for (const row of done) try {
+		const record = readAskRecord(batch.storeDir, row.askId);
+		if (record === void 0 || record.deliveredBack === true) continue;
+		writeAskRecord(batch.storeDir, outcome.ok ? {
+			...record,
+			deliveredBack: true
+		} : {
+			...record,
+			deliverBackNote: `自动回送失败：${outcome.error ?? "unknown"}（答案仍在记录里，可用 ask_result 取回）`
+		});
+	} catch {}
+}
+/** `targets` → trimmed, de-duplicated (exact spelling), capped at the schema limit. */
+function readTargets(targets) {
+	const values = Array.isArray(targets) ? targets : [];
+	const seen = /* @__PURE__ */ new Set();
+	const picked = [];
+	for (const value of values) {
+		if (typeof value !== "string") continue;
+		const trimmed = value.trim();
+		if (seen.has(trimmed)) continue;
+		seen.add(trimmed);
+		picked.push(trimmed);
+		if (picked.length >= BATCH_MAX_TARGETS) break;
+	}
+	return picked;
+}
+/** All-skipped answer: `ok: false` with the reasons, never an exception. */
+function skippedOnly(skipped) {
+	return {
+		ok: false,
+		count: 0,
+		results: [],
+		skipped
+	};
+}
+/**
+* Run one batch ask: resolve targets, apply every per-target guard, deliver
+* concurrently and collect the results.
+*
+* - `all`: wait for every target to settle (or its own ceiling).
+* - `any`: return the first settled target; the others keep running in the
+*   background and still write their own settled AskRecords.
+*
+* Never guesses: unnamed, ambiguous, missing, excluded or guard-rejected
+* targets land in `skipped`. When every target is skipped the call reports
+* `ok: false` with those reasons instead of failing with an exception.
+*/
+async function askSessions(ctx, signal, input) {
+	const mode = input.mode === "any" ? "any" : "all";
+	const waitMs = normalizeWaitMs(typeof input.waitMs === "number" ? input.waitMs : input.defaultWaitMs);
+	const log = input.log ?? (() => {});
+	const targets = readTargets(input.targets);
+	const skipped = [];
+	if (targets.length === 0) return skippedOnly(skipped);
+	if (!input.swarmEnabled) {
+		for (const target of targets) skipped.push({
+			target,
+			reason: BATCH_SWARM_DISABLED
+		});
+		return skippedOnly(skipped);
+	}
+	if (typeof input.question !== "string" || input.question.trim().length === 0) {
+		for (const target of targets) skipped.push({
+			target,
+			reason: "缺少问题"
+		});
+		return skippedOnly(skipped);
+	}
+	const controller = getSessionController(ctx);
+	if (controller === void 0) {
+		for (const target of targets) skipped.push({
+			target,
+			reason: "宿主没有提供 sessionController"
+		});
+		return skippedOnly(skipped);
+	}
+	if (typeof input.currentSessionId !== "string" || input.currentSessionId.length === 0) {
+		for (const target of targets) skipped.push({
+			target,
+			reason: "无法确定当前会话的身份"
+		});
+		return skippedOnly(skipped);
+	}
+	let full;
+	try {
+		full = [...(await controller.list({}, signal)).items];
+	} catch {
+		for (const target of targets) skipped.push({
+			target,
+			reason: "读取会话列表失败"
+		});
+		return skippedOnly(skipped);
+	}
+	const archived = archivedSessionIds(ctx);
+	const registered = registeredSessionIds(ctx);
+	const allowed = allowedAskSessions(full, input.exclude, registered);
+	const own = full.find((session) => session.sessionId === input.currentSessionId);
+	const senderName = own === void 0 ? "未命名会话" : sessionDisplayName(own);
+	const hop = nextAskHop(input.currentEvents);
+	const parentAskId = inboundAskId(input.currentEvents);
+	const plans = [];
+	const plannedIds = /* @__PURE__ */ new Set();
+	for (const target of targets) {
+		if (target.length === 0) {
+			skipped.push({
+				target,
+				reason: "没点名"
+			});
+			continue;
+		}
+		const match = matchTargetSession(allowed, target);
+		if (match.kind === "ambiguous") {
+			const total = Math.max(match.candidates.length, match.total ?? match.candidates.length);
+			const block = renderCandidateBlock(match.candidates, { total });
+			skipped.push({
+				target,
+				reason: `有 ${total} 个同名会话${block.length > 0 ? `\n${block}` : ""}`
+			});
+			continue;
+		}
+		if (match.kind === "missing") {
+			const fullMatch = matchTargetSession(full, target);
+			if (fullMatch.kind === "unique" && archived.has(fullMatch.target.sessionId)) skipped.push({
+				target,
+				reason: ARCHIVED_SESSION_MESSAGE
+			});
+			else if (fullMatch.kind === "unique" && registered !== void 0 && !registered.has(fullMatch.target.sessionId)) skipped.push({
+				target,
+				reason: UNREGISTERED_SESSION_MESSAGE
+			});
+			else if (fullMatch.kind === "unique" && !allowed.some((session) => session.sessionId === fullMatch.target.sessionId)) skipped.push({
+				target,
+				reason: "这个会话被设置为不参与蜂群"
+			});
+			else if (fullMatch.kind === "ambiguous") {
+				const total = Math.max(fullMatch.candidates.length, fullMatch.total ?? fullMatch.candidates.length);
+				const block = renderCandidateBlock(fullMatch.candidates, { total });
+				skipped.push({
+					target,
+					reason: `有 ${total} 个同名会话${block.length > 0 ? `\n${block}` : ""}`
+				});
+			} else {
+				const block = renderCandidateBlock(recentCandidates(allowed), { sameTitle: false });
+				skipped.push({
+					target,
+					reason: `没有找到匹配的会话${block.length > 0 ? `\n${block}` : ""}`
+				});
+			}
+			continue;
+		}
+		if (plannedIds.has(match.target.sessionId)) continue;
+		const rejection = checkAskGuards({
+			guards: {
+				currentSessionId: input.currentSessionId,
+				hop
+			},
+			match,
+			sessions: allowed,
+			question: input.question,
+			context: input.context
+		});
+		if (rejection !== void 0) {
+			skipped.push({
+				target,
+				reason: skipReasonFor(rejection)
+			});
+			continue;
+		}
+		const row = allowed.find((session) => session.sessionId === match.target.sessionId);
+		plannedIds.add(match.target.sessionId);
+		plans.push({
+			target: match.target,
+			targetWasRunning: row?.running === true
+		});
+	}
+	if (plans.length === 0) return skippedOnly(skipped);
+	const batch = {
+		controller,
+		currentSessionId: input.currentSessionId,
+		senderName,
+		question: input.question,
+		context: input.context,
+		hop,
+		parentAskId,
+		waitMs,
+		storeDir: askStoreRoot(),
+		log,
+		parentSignal: signal,
+		deliverBack: input.deliverBack !== false
+	};
+	const tasks = plans.map((plan) => askOne(plan, batch));
+	if (mode === "any") {
+		const allSettled = Promise.all(tasks);
+		const results = [await Promise.race(tasks)];
+		allSettled.then((all) => deliverMergedBack(batch, all));
+		return {
+			ok: true,
+			count: results.length,
+			results,
+			skipped
+		};
+	}
+	const results = await Promise.all(tasks);
+	await deliverMergedBack(batch, results);
+	return {
+		ok: true,
+		count: results.length,
+		results,
+		skipped
+	};
+}
+//#endregion
+//#region src/tools.ts
+function registerAdvisorTools(service, ctx) {
+	return [
+		defineTool({
+			name: "ask_advisors",
+			description: "Consult configured expert advisor models when the question is professional, long-tail world knowledge, high-risk, or the main model is uncertain. ALWAYS provide context with (a) a brief overview of the current project and (b) concrete details of the problem, including what has been tried and what went wrong. Also call immediately when the user @顾问群 or repeats the same question three times without resolution. Do NOT use for simple facts that web search can answer. Starting a new consultation runs the auto-deepen pipeline: up to maxRounds rounds of [driver deep-question → advisor A → advisor B (sees A) → advisor C (sees A+B) → …], closed by a driver-generated conclusion.",
+			parameters: {
+				question: {
+					type: "string",
+					description: "The question to ask the advisors. Required when starting a new consultation."
+				},
+				context: {
+					type: "string",
+					description: "Required background: (a) current project overview (domain/goal/stack/constraints) and (b) problem details (steps tried, expected vs actual, errors). Write \"该项背景未知\" for anything unknown; never leave it empty."
+				},
+				sessionId: {
+					type: "string",
+					description: "Existing consultation session id to continue."
+				},
+				followUp: {
+					type: "string",
+					description: "Follow-up question to send to the advisors in an existing session."
+				},
+				advisorIds: {
+					type: "array",
+					items: { type: "string" },
+					description: "Optional advisor ids to include; defaults to all configured advisors (capped by maxAdvisorsPerCall)."
+				},
+				confidence: {
+					type: "number",
+					description: "Optional self-assessed confidence 0-1. Values below the configured threshold escalate even without domain keywords."
+				},
+				questionEn: {
+					type: "string",
+					description: "Optional self-contained English gist of the question plus key background. Used as the Jev pre-classification input only when the「Jev 英文判定」setting is enabled; the displayed question, session records, and duplicate detection always keep using question/context in Chinese. Omit it otherwise."
+				}
+			},
+			output: {
+				schema: {
 					type: "object",
 					additionalProperties: false,
 					properties: {
@@ -6076,7 +6990,7 @@ function registerAdvisorTools(service, ctx) {
 			parameters: {
 				target: {
 					type: "string",
-					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."
+					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, a full sessionId, or an exact advisor-corps role name (see list_sessions). A title or the workspace/directory name is usually enough (「极简遥控器」 matches sessions under I:\\极简遥控器\\…). An exact role name resolves to the session it is assigned to and takes precedence over a same-named title. 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",
@@ -6097,7 +7011,7 @@ function registerAdvisorTools(service, ctx) {
 				},
 				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."
+					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. When detach is omitted, passing waitMs means wait; pass only one of them."
 				}
 			},
 			output: {
@@ -6195,7 +7109,10 @@ function registerAdvisorTools(service, ctx) {
 									hint: {
 										type: "string",
 										required: true
-									}
+									},
+									/** Display-only fields that tell identical titles apart. */
+									cwd: { type: "string" },
+									age: { type: "string" }
 								}
 							}
 						},
@@ -6235,7 +7152,7 @@ function registerAdvisorTools(service, ctx) {
 					...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")}` : ""}${renderRouteCandidates(value.routeCandidates)}`
+					text: `【ask_session 未完成：${String(value.error ?? "unknown")}】\n${String(value.message ?? "")}${renderRouteCandidates(value.routeCandidates)}`
 				}]
 			},
 			async execute(args, exec) {
@@ -6278,8 +7195,11 @@ function registerAdvisorTools(service, ctx) {
 					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, {
+				const targetText = typeof args.target === "string" ? args.target.trim() : "";
+				const corpsTarget = targetText.length > 0 ? findCorpsSession(loadCorpsCards(), targetText) : void 0;
+				if (targetText.length === 0 && swarm.routingEnabled !== false) {
+					const registered = registeredSessionIds(ctx);
+					const roster = visibleRosterSessions(listedItems, swarm.rosterIncludeSubagents).filter((row) => (registered === void 0 || registered.has(row.sessionId)) && !isSessionExcluded(hidden, {
 						sessionId: row.sessionId,
 						names: [sessionDisplayName(row)]
 					}));
@@ -6327,12 +7247,13 @@ function registerAdvisorTools(service, ctx) {
 					currentSessionId: sessionId,
 					senderName,
 					currentEvents: readCurrentEvents(session),
-					target: typeof args.target === "string" ? args.target : "",
+					target: corpsTarget ?? targetText,
 					question,
 					context,
 					waitMs: answerMode.waitMs,
 					detach: answerMode.detach,
 					exclude: hidden,
+					deliverBack: swarm.deliverBack !== false,
 					log: (message) => console.log(`[dsh-advisor-group] ask_session: ${message}`)
 				});
 				if (value.ok !== true) return {
@@ -6357,9 +7278,165 @@ function registerAdvisorTools(service, ctx) {
 				};
 			}
 		}),
+		defineTool({
+			name: "ask_sessions",
+			description: "Ask ONE question to 1–8 existing sessions in a single call and collect the results. targets uses the same spelling as ask_session (exact sessionId, exact title, or a natural partial name). mode \"all\" (default) waits until every target settles or its own ceiling passes; mode \"any\" returns as soon as the first target settles while the others keep running in the background (their ask_result records still settle). There is NO routing here: an unnamed or ambiguous target is skipped with a reason instead of being guessed. Every delivered target gets its own askId; read a later result with ask_result.",
+			parameters: {
+				targets: {
+					type: "array",
+					items: { type: "string" },
+					description: "The sessions to ask, 1–8 entries, same spelling as ask_session (exact id, exact title, exact advisor-corps role name, or a natural partial name). Duplicates collapse into one; unresolvable or excluded targets are skipped with a reason.",
+					required: true
+				},
+				question: {
+					type: "string",
+					description: "The question to hand to every target. It is permanently recorded in each target session log, so write it self-contained.",
+					required: true
+				},
+				context: {
+					type: "string",
+					description: "Optional background every target needs. Default: none. Anything sent here stays in every target session log forever, so send only what is necessary."
+				},
+				mode: {
+					type: "string",
+					enum: ["all", "any"],
+					description: "all (default): wait for every target. any: return at the first settled target; the rest keep running in the background."
+				},
+				waitMs: {
+					type: "number",
+					description: `Per-target wait ceiling in milliseconds (default ${ASK_WAIT_DEFAULT_MS}, max ${ASK_WAIT_MAX_MS}). A ceiling stops only this call's wait; the target turn is never cancelled.`
+				}
+			},
+			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: {
+									sessionId: {
+										type: "string",
+										required: true
+									},
+									name: {
+										type: "string",
+										required: true
+									},
+									askId: {
+										type: "string",
+										required: true
+									},
+									state: {
+										type: "string",
+										enum: [
+											"done",
+											"timeout",
+											"error"
+										],
+										required: true
+									},
+									answer: {
+										type: "string",
+										required: true
+									},
+									status: {
+										type: "string",
+										enum: [
+											"ok",
+											"partial",
+											"failed"
+										]
+									},
+									note: { type: "string" },
+									error: { type: "string" }
+								}
+							}
+						},
+						skipped: {
+							type: "array",
+							required: true,
+							items: {
+								type: "object",
+								additionalProperties: false,
+								properties: {
+									target: {
+										type: "string",
+										required: true
+									},
+									reason: {
+										type: "string",
+										required: true
+									}
+								}
+							}
+						}
+					}
+				},
+				render: (_args, value) => {
+					const results = Array.isArray(value.results) ? value.results : [];
+					const skipped = Array.isArray(value.skipped) ? value.skipped : [];
+					const stateLabel = {
+						done: "已完成",
+						timeout: "超时",
+						error: "出错"
+					};
+					const blocks = results.map((row) => {
+						const head = `- ${String(row.name ?? "")} · ${stateLabel[String(row.state ?? "")] ?? String(row.state ?? "")}`;
+						const answer = String(row.answer ?? "").trim();
+						const note = String(row.note ?? "").trim();
+						const error = String(row.error ?? "").trim();
+						return `${head}\n  ${answer.length > 0 ? answer : error.length > 0 ? `错误：${error}` : note}`.trimEnd();
+					});
+					if (skipped.length > 0) blocks.push("跳过：", ...skipped.map((row) => {
+						const reason = String(row.reason ?? "").split("\n").join("\n  ");
+						return `- ${String(row.target ?? "")}：${reason}`;
+					}));
+					return [{
+						type: "text",
+						text: blocks.length > 0 ? blocks.join("\n") : "没有投递任何会话。"
+					}];
+				}
+			},
+			async execute(args, exec) {
+				const swarm = service.getConfig().swarm;
+				const session = exec.agent?.session ?? getCurrentSessionFrom(exec);
+				const sessionId = session?.id;
+				const corpsCards = loadCorpsCards();
+				return await askSessions(ctx, exec.signal, {
+					currentSessionId: typeof sessionId === "string" ? sessionId : "",
+					currentEvents: readCurrentEvents(session),
+					targets: Array.isArray(args.targets) ? args.targets.map((target) => {
+						const text = typeof target === "string" ? target : "";
+						return findCorpsSession(corpsCards, text) ?? text;
+					}) : [],
+					question: typeof args.question === "string" ? args.question : "",
+					context: typeof args.context === "string" ? args.context : void 0,
+					mode: args.mode === "any" ? "any" : "all",
+					waitMs: typeof args.waitMs === "number" ? args.waitMs : void 0,
+					defaultWaitMs: swarm.defaultWaitMs,
+					exclude: exclusionEntries(swarm),
+					swarmEnabled: swarm.enabled !== false,
+					deliverBack: swarm.deliverBack !== false,
+					log: (message) => console.log(`[dsh-advisor-group] ask_sessions: ${message}`)
+				});
+			}
+		}),
 		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.",
+			description: "List the sessions this host knows: the title shown in the session list, its sessionId, working directory, how long ago it was active, whether it is running, and its advisor-corps role name and duty when assigned. Use it when the user names a session but you are unsure which one they mean, when you want to address a member by role name, 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",
@@ -6419,17 +7496,20 @@ function registerAdvisorTools(service, ctx) {
 										type: "boolean",
 										required: true
 									},
+									roleName: { type: "string" },
+									duty: { type: "string" },
 									sizeHint: { type: "number" }
 								}
 							}
 						},
 						error: { type: "string" },
-						message: { type: "string" }
+						message: { type: "string" },
+						note: { type: "string" }
 					}
 				},
 				render: (args, value) => value.ok === true ? [{
 					type: "text",
-					text: renderRoster(value.sessions, { filtered: String(args.query ?? "").trim().length > 0 })
+					text: renderRoster(value.sessions, { filtered: String(args.query ?? "").trim().length > 0 }) + (typeof value.note === "string" && value.note.length > 0 ? `\n\n${value.note}` : "")
 				}] : [{
 					type: "text",
 					text: `【list_sessions 失败：${String(value.error ?? "unknown")}】\n${String(value.message ?? "")}`
@@ -6453,18 +7533,30 @@ function registerAdvisorTools(service, ctx) {
 					message: "宿主没有提供 sessionController，无法列出会话。"
 				};
 				try {
-					const sessions = buildSessionRoster((await controller.list({}, exec.signal)).items.filter((item) => !isHiddenSession(swarm, item)), {
+					const listed = await controller.list({}, exec.signal);
+					const registered = registeredSessionIds(ctx);
+					const rows = buildSessionRoster(listed.items.filter((item) => !isHiddenSession(swarm, item) && (registered === void 0 || registered.has(item.sessionId))), {
 						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)
-					}));
+					});
+					const corpsCards = loadCorpsCards();
+					const sessions = rows.map((row) => {
+						const card = corpsCards[row.sessionId];
+						return {
+							...row,
+							name: shortSessionName(row.name, row.cwd),
+							...card === void 0 ? {} : {
+								roleName: card.name,
+								duty: card.duty
+							}
+						};
+					});
 					return {
 						ok: true,
 						count: sessions.length,
-						sessions
+						sessions,
+						...registered === void 0 ? { note: "当前宿主未提供工作区登记信息，名录未做「只显示侧栏可见会话」的过滤。" } : {}
 					};
 				} catch (error) {
 					return {
@@ -6479,7 +7571,7 @@ function registerAdvisorTools(service, ctx) {
 		}),
 		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.",
+			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, interrupted (the host restarted while waiting, so the answer was never collected — check the target session or ask again). 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."
@@ -6549,7 +7641,13 @@ function registerAdvisorTools(service, ctx) {
 										}
 									},
 									note: { type: "string" },
-									error: { type: "string" }
+									error: { type: "string" },
+									/** Display only: body probed from a still-waiting target. */
+									provisional: { type: "string" },
+									/** True when the settled answer was copied back automatically. */
+									deliveredBack: { type: "boolean" },
+									/** Why the automatic copy-back did not happen, when it failed. */
+									deliverBackNote: { type: "string" }
 								}
 							}
 						},
@@ -6591,11 +7689,15 @@ function registerAdvisorTools(service, ctx) {
 						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);
+					const records = askId.length > 0 ? [readAskRecord(dir, askId)].filter((row) => row !== void 0) : listAskRecords(dir, sessionId.length > 0 ? { sessionId } : void 0).slice(0, 20);
+					const visible = (await withProvisionalBodies(getSessionController(ctx), records)).map((row) => {
+						const { bootId: _bootId, fromSeq: _fromSeq, ...rest } = row;
+						return rest;
+					});
 					return {
 						ok: true,
-						count: results.length,
-						results
+						count: visible.length,
+						results: visible
 					};
 				} catch (error) {
 					return {
@@ -6610,24 +7712,59 @@ function registerAdvisorTools(service, ctx) {
 		})
 	];
 }
+/**
+* Attach the provisional body to still-waiting records (display only). Skips
+* the probe entirely when the host exposes no session controller, and a failed
+* probe leaves the record unchanged, so the old output survives.
+*/
+async function withProvisionalBodies(controller, records) {
+	return Promise.all(records.map(async (row) => {
+		const stale = reconcileStaleAsk(row);
+		if (stale !== void 0) {
+			try {
+				writeAskRecord(askStoreRoot(), stale);
+			} catch (error) {
+				console.warn("[dsh-advisor-group] 中断记录落盘失败：", error);
+			}
+			return { ...stale };
+		}
+		if (row.state !== "waiting" || controller === void 0) return { ...row };
+		const text = await probeWaitingBody(controller, row);
+		return text === void 0 ? { ...row } : {
+			...row,
+			provisional: text
+		};
+	}));
+}
 /** One compact block per detached ask result, for the model to read. */
 function renderAskRecords(rows) {
 	const stateLabel = {
 		waiting: "等待中",
 		done: "已完成",
 		timeout: "超时",
-		error: "出错"
+		error: "出错",
+		interrupted: "已中断"
 	};
 	return rows.map((row) => {
+		const head = `- [${stateLabel[row.state]}] ${row.targetName} · askId=${row.askId}${row.deliveredBack === true ? " · 已自动回送" : ""}`;
+		const parent = row.parentAskId === void 0 ? "" : `  （由 ${row.parentAskId} 转问）`;
+		const question = `  问题：${row.question.replace(/\s+/gu, " ").slice(0, 120)}`;
+		const backNote = row.deliverBackNote === void 0 ? "" : `  回送说明：${row.deliverBackNote.replace(/\s+/gu, " ")}`;
+		const body = 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}` : "";
+		const provisional = row.provisional === void 0 ? "" : provisionalBodySection(row.provisional) ?? "";
+		const provisionalLines = provisional.length === 0 ? [] : provisional.split("\n").map((line) => `  ${line}`);
 		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}` : ""
+			head,
+			parent,
+			question,
+			body,
+			row.note === void 0 || row.note.length === 0 ? "" : `  说明：${row.note.replace(/\s+/gu, " ")}`,
+			backNote,
+			...provisionalLines
 		].filter((line) => line.length > 0).join("\n");
 	}).join("\n\n");
 }
@@ -6662,9 +7799,18 @@ const SWARM_DISABLED_MESSAGE = "蜂群模式已在设置里关闭（设置 →
 * one falls back to the configured default (`defaultMode` / `defaultWaitMs`).
 */
 function resolveAskDefaults(args, swarm) {
+	const waitMs = typeof args.waitMs === "number" ? args.waitMs : swarm.defaultWaitMs;
+	if (typeof args.detach === "boolean") return {
+		waitMs,
+		detach: args.detach
+	};
+	if (typeof args.waitMs === "number") return {
+		waitMs,
+		detach: false
+	};
 	return {
-		waitMs: typeof args.waitMs === "number" ? args.waitMs : swarm.defaultWaitMs,
-		detach: typeof args.detach === "boolean" ? args.detach : swarm.defaultMode === "detach"
+		waitMs,
+		detach: swarm.defaultMode === "detach"
 	};
 }
 /**
@@ -7572,6 +8718,18 @@ function handleConfigRequest(ctx, scopedCtx, service, authToken) {
 			}
 			return;
 		}
+		if (req.method === "GET" && (pathname === "/advisor-group/corps" || pathname === "/advisor-group/corps/")) {
+			await handleCorpsGet(ctx, service, res);
+			return;
+		}
+		if (req.method === "POST" && (pathname === "/advisor-group/corps" || pathname === "/advisor-group/corps/")) {
+			await handleCorpsPost(req, res);
+			return;
+		}
+		if (req.method === "POST" && (pathname === "/advisor-group/corps/generate" || pathname === "/advisor-group/corps/generate/")) {
+			await handleCorpsGenerate(ctx, service, req, res);
+			return;
+		}
 		if (req.method === "GET" && (pathname === "/advisor-group/shadow" || pathname === "/advisor-group/shadow/")) {
 			sendJson(res, 200, {
 				ok: true,
@@ -7641,6 +8799,247 @@ function handleConfigRequest(ctx, scopedCtx, service, authToken) {
 		});
 	};
 }
+function isPlainRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/**
+* The same visibility universe as list_sessions/ask_session: workspace-
+* registered, not archived, not swarm-excluded; subagents only when enabled.
+* `undefined` means the host exposed no session controller at all.
+*/
+async function collectCorpsRoster(ctx, service) {
+	const controller = getSessionController(ctx);
+	if (controller === void 0) return void 0;
+	const listed = await controller.list({}, new AbortController().signal);
+	const swarm = service.getConfig().swarm;
+	const registered = registeredSessionIds(ctx);
+	const archived = archivedSessionIds(ctx);
+	const exclude = Array.isArray(swarm.routingExclude) ? swarm.routingExclude : [];
+	const includeSubagents = swarm.rosterIncludeSubagents === true;
+	const visible = listed.items.filter((item) => !archived.has(item.sessionId) && (registered === void 0 || registered.has(item.sessionId)) && !isSessionExcluded(exclude, {
+		sessionId: item.sessionId,
+		names: [sessionDisplayName(item)]
+	}) && (includeSubagents || item.origin !== "subagent"));
+	return {
+		rows: buildSessionRoster(visible, {
+			limit: 50,
+			hideSubagents: !includeSubagents
+		}),
+		visibleIds: new Set(visible.map((item) => item.sessionId)),
+		filtered: registered !== void 0
+	};
+}
+function corpsOrphans(cards, visibleIds) {
+	return Object.entries(cards).filter(([sessionId]) => !visibleIds.has(sessionId)).map(([sessionId, card]) => ({
+		sessionId,
+		...card
+	})).sort((a, b) => a.name.localeCompare(b.name, "zh"));
+}
+/** One panel read: the visible session roster plus every saved role card. */
+async function handleCorpsGet(ctx, service, res) {
+	const cards = loadCorpsCards();
+	try {
+		const roster = await collectCorpsRoster(ctx, service);
+		if (roster === void 0) {
+			sendJson(res, 200, {
+				ok: true,
+				filtered: false,
+				sessions: [],
+				orphans: corpsOrphans(cards, /* @__PURE__ */ new Set()),
+				note: "宿主没有提供会话列表服务，当前只能看到已保存的角色卡。"
+			});
+			return;
+		}
+		sendJson(res, 200, {
+			ok: true,
+			filtered: roster.filtered,
+			sessions: roster.rows.map((row) => ({
+				...row,
+				card: cards[row.sessionId] ?? null
+			})),
+			orphans: corpsOrphans(cards, roster.visibleIds)
+		});
+	} catch (error) {
+		console.warn("[dsh-advisor-group] corps 读取失败：", error instanceof Error ? error.message : String(error));
+		sendJson(res, 500, {
+			ok: false,
+			error: error instanceof Error ? error.message : String(error)
+		});
+	}
+}
+/** How many unassigned sessions one generation pass asks the model about. */
+const CORPS_GENERATE_LIMIT = 12;
+const CORPS_GENERATE_SYSTEM = `你是 DSH 顾问团的名册编辑。根据每个会话的标题、工作目录和活跃提示，推断它最适合承担什么任务，为它起一个简短的中文身份姓名，并写一句职责。只输出 JSON，不要解释。`;
+/** Accept a bare JSON object, a fenced block, or an array; validate against the roster. */
+function parseCorpsProposals(text, rows, cards) {
+	const fenced = text.match(/```(?:json)?\s*([\s\S]*?)```/i);
+	const raw = (fenced === null ? text : fenced[1]).trim();
+	const objectStart = raw.indexOf("{");
+	const objectEnd = raw.lastIndexOf("}");
+	const arrayStart = raw.indexOf("[");
+	const arrayEnd = raw.lastIndexOf("]");
+	const candidate = arrayStart >= 0 && (objectStart < 0 || arrayStart < objectStart) && arrayEnd > arrayStart ? raw.slice(arrayStart, arrayEnd + 1) : objectStart >= 0 && objectEnd > objectStart ? raw.slice(objectStart, objectEnd + 1) : "";
+	if (candidate.length === 0) return [];
+	let parsed;
+	try {
+		parsed = JSON.parse(candidate);
+	} catch {
+		return [];
+	}
+	const items = isPlainRecord(parsed) && Array.isArray(parsed.cards) ? parsed.cards : Array.isArray(parsed) ? parsed : [];
+	const allowed = new Set(rows.map((row) => row.sessionId));
+	const usedNames = new Set(Object.values(cards).map((card) => card.name.trim().toLowerCase()));
+	const usedIds = /* @__PURE__ */ new Set();
+	const out = [];
+	for (const item of items) {
+		if (!isPlainRecord(item)) continue;
+		const sessionId = typeof item.sessionId === "string" ? item.sessionId : "";
+		const name = typeof item.name === "string" ? item.name.trim() : "";
+		const duty = typeof item.duty === "string" ? item.duty.trim() : "";
+		if (!allowed.has(sessionId) || usedIds.has(sessionId)) continue;
+		if (name.length === 0 || name.length > 40 || duty.length > 200) continue;
+		const lower = name.toLowerCase();
+		if (usedNames.has(lower)) continue;
+		usedNames.add(lower);
+		usedIds.add(sessionId);
+		out.push({
+			sessionId,
+			name,
+			duty
+		});
+	}
+	return out;
+}
+/**
+* Ask the CURRENT conversation's main model for unassigned role cards. The
+* panel then shows the proposals as drafts; nothing is saved until the user
+* confirms each row. Existing cards are never overwritten.
+*/
+async function handleCorpsGenerate(ctx, service, req, res) {
+	let sessionId = "";
+	try {
+		const parsed = JSON.parse(await readBody(req));
+		sessionId = typeof parsed.sessionId === "string" ? parsed.sessionId : "";
+	} catch (error) {
+		sendJson(res, 400, {
+			ok: false,
+			error: `请求格式不正确：${error instanceof Error ? error.message : String(error)}`
+		});
+		return;
+	}
+	if (sessionId.length === 0) {
+		sendJson(res, 400, {
+			ok: false,
+			error: "缺少 sessionId"
+		});
+		return;
+	}
+	try {
+		const roster = await collectCorpsRoster(ctx, service);
+		if (roster === void 0) {
+			sendJson(res, 400, {
+				ok: false,
+				error: "宿主没有提供会话列表服务，无法生成。"
+			});
+			return;
+		}
+		const cards = loadCorpsCards();
+		const unassigned = roster.rows.filter((row) => cards[row.sessionId] === void 0).slice(0, CORPS_GENERATE_LIMIT);
+		if (unassigned.length === 0) {
+			sendJson(res, 200, {
+				ok: true,
+				proposals: [],
+				note: "所有可见会话都已有角色卡。"
+			});
+			return;
+		}
+		const sessions = ctx.sessions;
+		const source = resolveDriverSource(typeof sessions?.get === "function" ? sessions.get(sessionId) : void 0, service.getConfig().discussion.driverModel);
+		if (source === void 0) {
+			sendJson(res, 400, {
+				ok: false,
+				error: "当前会话没有可用的主模型配置，无法生成角色卡。"
+			});
+			return;
+		}
+		const prompt = [
+			"请为下列 DSH 会话各生成一张顾问团角色卡。",
+			"",
+			...unassigned.map((row, index) => `${index + 1}. sessionId=${row.sessionId} | 标题=${row.name} | 目录=${row.cwd ?? "未知"} | ${row.hint}`),
+			"",
+			"要求：",
+			"- 姓名简短，像同事的称呼，彼此不同，不要照抄标题；",
+			"- 职责一句话，说明最适合承担什么任务，不超过 30 个汉字；",
+			"- sessionId 必须原样照抄；",
+			"- 只输出 JSON：{\"cards\":[{\"sessionId\":\"...\",\"name\":\"...\",\"duty\":\"...\"}]}"
+		].join("\n");
+		const text = await generateWith(ctx, source, sessionId, CORPS_GENERATE_SYSTEM, prompt, AbortSignal.timeout(9e4), 9e4);
+		if (text === void 0 || text.trim().length === 0) {
+			sendJson(res, 502, {
+				ok: false,
+				error: "主模型没有返回内容。"
+			});
+			return;
+		}
+		const proposals = parseCorpsProposals(text, unassigned, cards);
+		if (proposals.length === 0) {
+			sendJson(res, 200, {
+				ok: false,
+				error: "主模型没有返回可用的角色卡，请重试。",
+				raw: text.slice(0, 500)
+			});
+			return;
+		}
+		sendJson(res, 200, {
+			ok: true,
+			proposals,
+			...proposals.length < unassigned.length ? { note: `只生成了 ${proposals.length} / ${unassigned.length} 张，可以再点一次补齐。` } : {},
+			model: {
+				provider: source.provider,
+				model: source.model
+			}
+		});
+	} catch (error) {
+		console.warn("[dsh-advisor-group] corps 生成失败：", error instanceof Error ? error.message : String(error));
+		sendJson(res, 500, {
+			ok: false,
+			error: error instanceof Error ? error.message : String(error)
+		});
+	}
+}
+/** One panel write: upsert or delete a single role card. */
+async function handleCorpsPost(req, res) {
+	try {
+		const parsed = JSON.parse(await readBody(req));
+		const result = upsertCorpsCard(loadCorpsCards(), typeof parsed.sessionId === "string" ? parsed.sessionId : "", typeof parsed.name === "string" ? parsed.name : "", typeof parsed.duty === "string" ? parsed.duty : "");
+		if (!result.ok) {
+			sendJson(res, result.code === "duplicate-name" ? 409 : 400, {
+				ok: false,
+				error: result.error,
+				code: result.code
+			});
+			return;
+		}
+		try {
+			saveCorpsCards(result.cards);
+		} catch (error) {
+			sendJson(res, 500, {
+				ok: false,
+				error: `保存角色卡失败：${error instanceof Error ? error.message : String(error)}`
+			});
+			return;
+		}
+		sendJson(res, 200, {
+			ok: true,
+			cards: result.cards
+		});
+	} catch (error) {
+		sendJson(res, 400, {
+			ok: false,
+			error: `请求格式不正确：${error instanceof Error ? error.message : String(error)}`
+		});
+	}
+}
 async function sendProviders(ctx, res) {
 	const providers = [];
 	try {
@@ -7734,7 +9133,8 @@ function buildAdvisorPrompt(config, repeatPressure) {
 		"   b) 遇到问题的具体细节（做了什么、期望什么、实际发生了什么、已尝试哪些步骤、相关报错或现象）。",
 		"   如果某项信息确实未知，明确写“该项背景未知”，不要留空 context，也不要让顾问在缺少背景的情况下猜测。",
 		"6. 拿到顾问结论后：自行判断、综合并执行，不要原样复制整段顾问回复。",
-		"7. 发起新咨询：插件会自动进行多轮深挖（默认 autoDeepen：每轮结束由驱动模型基于全部讨论生成更深入的追问，顾问按顺序 A→B→C 接力回答，直到 maxRounds 轮），并自动产出综合结论——你无需再手动 followUp；只有想追加一轮固定主题时才传 sessionId+followUp。"
+		"7. 发起新咨询：插件会自动进行多轮深挖（默认 autoDeepen：每轮结束由驱动模型基于全部讨论生成更深入的追问，顾问按顺序 A→B→C 接力回答，直到 maxRounds 轮），并自动产出综合结论——你无需再手动 followUp；只有想追加一轮固定主题时才传 sessionId+followUp。",
+		"8. 跨会话提问（ask_session）时，可以先调用 list_sessions 查看「顾问团」的姓名与职责，再直接用姓名作为 target；原来的会话标题、目录名和 sessionId 仍然可用。"
 	];
 	if (repeatPressure && repeatPressure.count >= 3) lines.push("", `【强制升级】当前会话中同一问题已被用户重复 ${repeatPressure.count} 次仍未解决。你必须立即调用 ask_advisors，把用户最新一次的问题原样作为 question 传入，并在 context 中补充项目概况与已尝试步骤；不得再让用户重复或自行空转。`);
 	else if (repeatPressure && repeatPressure.count > 1) lines.push("", `【提醒】当前会话中同一问题已出现 ${repeatPressure.count} 次。若本轮仍无法解决，必须调用 ask_advisors 升级到顾问群。`);
@@ -7783,6 +9183,22 @@ const inject = [
 	"sessions"
 ];
 /**
+* Recall candidates for the background hint, restricted to the sessions the
+* host actually shows: the registered set (workspace `sessionIds` minus
+* archived). `registered === undefined` means "this host has no workspace
+* registry" and filters nothing; a session no workspace registers must never be
+* suggested by a hint. Pure except for the bounded log-size probe inside the
+* router.
+*/
+function recallHintCandidates(input) {
+	return routeSessions(withSessionLogSizes(input.sessions.filter((session) => input.registered === void 0 || input.registered.has(session.sessionId))), input.text, {
+		topN: input.topN,
+		currentSessionId: input.currentSessionId,
+		cache: false,
+		exclude: input.exclude ?? []
+	});
+}
+/**
 * 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.
@@ -7792,10 +9208,12 @@ async function suggestCrossSession(input) {
 		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, {
+		const candidates = recallHintCandidates({
+			sessions: visibleRosterSessions((await controller.list({}, input.signal)).items, config.swarm.rosterIncludeSubagents),
+			registered: registeredSessionIds(input.ctx),
+			text: 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) => ({
@@ -7885,4 +9303,4 @@ function apply(ctx, config) {
 	}), "dsh-advisor-group: system prompt section");
 }
 //#endregion
-export { Config, apply, inject, name };
+export { Config, apply, inject, name, recallHintCandidates };