zapmyco 0.9.0 → 0.10.0

package/dist/cli/index.mjs

@@ -1,30 +1,33 @@
 #!/usr/bin/env node
-import { D as configureLogger, H as SESSION_DIR_NAME, I as ZapmycoErrorCode, L as buildSkillSnapshot, O as logger, P as WebError, R as loadSkills, T as DEFAULT_COMPACTION_CONFIG, U as VERSION, V as APP_NAME, W as __require, h as createLlmBasedAgent, i as AgentLlmFacade, n as loadConfig, p as SubAgentManager, t as HOME_CONFIG_PATH, w as eventBus } from "../loader-Dtu0hhLu.mjs";
+import { D as configureLogger, H as SESSION_DIR_NAME, I as ZapmycoErrorCode, L as buildSkillSnapshot, O as logger, P as WebError, R as loadSkills, T as DEFAULT_COMPACTION_CONFIG, U as VERSION, V as APP_NAME, W as __require, h as createLlmBasedAgent, i as AgentLlmFacade, n as loadConfig, p as SubAgentManager, t as HOME_CONFIG_PATH, w as eventBus } from "../loader-36UrSNj8.mjs";
 import { createHash, randomBytes } from "node:crypto";
-import { appendFileSync, existsSync, mkdirSync, readFileSync, realpathSync, statSync, unlinkSync, writeFileSync } from "node:fs";
+import { appendFileSync, existsSync, mkdirSync, readFileSync, readdirSync, realpathSync, statSync, unlinkSync, writeFileSync } from "node:fs";
 import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
 import * as os from "node:os";
 import { homedir, tmpdir } from "node:os";
 import * as path from "node:path";
-import { dirname, isAbsolute, join, normalize, resolve } from "node:path";
+import { dirname, isAbsolute, join, normalize, relative, resolve } from "node:path";
 import { EventEmitter } from "node:events";
 import { getModels, getProviders } from "@mariozechner/pi-ai";
 import chalk, { Chalk } from "chalk";
 import { Command } from "commander";
-import { spawn, spawnSync } from "node:child_process";
+import { execFile, spawn, spawnSync } from "node:child_process";
 import { CombinedAutocompleteProvider, Container, Editor, Input, Key, ProcessTerminal, SelectList, TUI, getKeybindings, matchesKey, truncateToWidth, wrapTextWithAnsi } from "@mariozechner/pi-tui";
 import i18next from "i18next";
+import { AsyncLocalStorage } from "node:async_hooks";
 import TurndownService from "turndown";
 import { lookup } from "node:dns/promises";
+import { promisify } from "node:util";
 import { Client } from "@modelcontextprotocol/sdk/client";
 import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
 
 //#region src/cli/repl/command-registry.ts
-const log$16 = logger.child("repl:command-registry");
+const log$21 = logger.child("repl:command-registry");
 /**
 * 命令注册表
 */
 var CommandRegistry = class {
+	session;
 	commands = /* @__PURE__ */ new Map();
 	aliasMap = /* @__PURE__ */ new Map();
 	constructor(session) {
@@ -35,7 +38,7 @@ var CommandRegistry = class {
 	*/
 	register(cmd) {
 		const canonicalName = cmd.name.toLowerCase();
-		if (this.commands.has(canonicalName)) log$16.warn(`命令 "${canonicalName}" 已存在，将被覆盖`);
+		if (this.commands.has(canonicalName)) log$21.warn(`命令 "${canonicalName}" 已存在，将被覆盖`);
 		this.commands.set(canonicalName, cmd);
 		for (const alias of cmd.aliases) {
 			const lowerAlias = alias.toLowerCase();
@@ -63,7 +66,7 @@ var CommandRegistry = class {
 	*/
 	async dispatch(parsed) {
 		if (parsed.kind !== "command") {
-			log$16.warn("dispatch 收到了非 command 类型的输入");
+			log$21.warn("dispatch 收到了非 command 类型的输入");
 			return;
 		}
 		const cmd = this.getCommand(parsed.name);
@@ -75,7 +78,7 @@ var CommandRegistry = class {
 			await cmd.handler(parsed.args, this.session);
 		} catch (error) {
 			const message = error instanceof Error ? error.message : String(error);
-			log$16.error(`命令 /${cmd.name} 执行出错`, {}, error);
+			log$21.error(`命令 /${cmd.name} 执行出错`, {}, error);
 			console.log(`\n  命令执行出错: ${message}\n`);
 		}
 	}
@@ -444,7 +447,7 @@ const noColor = {
 
 //#endregion
 //#region src/core/agent-team/agent-instance-manager.ts
-const log$15 = logger.child("agent-instance-manager");
+const log$20 = logger.child("agent-instance-manager");
 /**
 * Agent 实例状态转换表
 *
@@ -508,7 +511,7 @@ var AgentInstanceManager = class {
 			const parent = this.instances.get(parentInstanceId);
 			if (parent) parent.childInstanceIds.push(instance.instanceId);
 		}
-		log$15.debug("注册 Agent 实例", {
+		log$20.debug("注册 Agent 实例", {
 			instanceId: instance.instanceId,
 			typeId: definition.typeId,
 			depth,
@@ -526,12 +529,12 @@ var AgentInstanceManager = class {
 	transition(instanceId, newStatus) {
 		const instance = this.instances.get(instanceId);
 		if (!instance) {
-			log$15.warn("状态转换失败：实例不存在", { instanceId });
+			log$20.warn("状态转换失败：实例不存在", { instanceId });
 			return false;
 		}
 		const allowed = VALID_TRANSITIONS[instance.status];
 		if (!allowed.includes(newStatus)) {
-			log$15.warn("状态转换拒绝", {
+			log$20.warn("状态转换拒绝", {
 				instanceId,
 				from: instance.status,
 				to: newStatus,
@@ -540,7 +543,7 @@ var AgentInstanceManager = class {
 			return false;
 		}
 		instance.status = newStatus;
-		log$15.debug("Agent 实例状态转换", {
+		log$20.debug("Agent 实例状态转换", {
 			instanceId,
 			typeId: instance.typeId,
 			from: instance.status,
@@ -641,7 +644,7 @@ var AgentInstanceManager = class {
 		instance.agent.removeAllListeners();
 		instance.agent.systemPromptOverride = null;
 		this.instances.delete(instanceId);
-		log$15.debug("Agent 实例已清理", { instanceId });
+		log$20.debug("Agent 实例已清理", { instanceId });
 	}
 	/**
 	* 清理所有终态的实例
@@ -923,6 +926,7 @@ const plannerType = {
 			"- **务实优先**：选择最简单可行的方案，避免过度设计",
 			"- **分阶段交付**：将方案拆解为增量可交付的阶段",
 			"- **可派生子 Agent**：需要调研时 spawn researcher 并行搜索",
+			"- **交互式确认**：遇到需要用户决策的方向性问题时，使用 AskUserQuestion 工具获取用户偏好。不要自行假设用户的需求",
 			"",
 			`## 工作目录\n${ctx.workdir}`
 		];
@@ -1083,7 +1087,7 @@ const BUILTIN_AGENT_TYPES = [
 *
 * @module core/agent-team
 */
-const log$14 = logger.child("agent-type-registry");
+const log$19 = logger.child("agent-type-registry");
 /**
 * Agent 类型注册中心
 *
@@ -1107,14 +1111,14 @@ var AgentTypeRegistry = class {
 	*/
 	register(definition) {
 		const existing = this.types.get(definition.typeId);
-		if (existing) log$14.info("覆盖已注册的 Agent 类型", {
+		if (existing) log$19.info("覆盖已注册的 Agent 类型", {
 			typeId: definition.typeId,
 			oldSource: existing.source,
 			newSource: definition.source
 		});
 		this.types.set(definition.typeId, definition);
 		this.refreshCache();
-		log$14.debug("注册 Agent 类型", {
+		log$19.debug("注册 Agent 类型", {
 			typeId: definition.typeId,
 			source: definition.source
 		});
@@ -1127,7 +1131,7 @@ var AgentTypeRegistry = class {
 	registerAll(definitions) {
 		for (const def of definitions) this.types.set(def.typeId, def);
 		this.refreshCache();
-		log$14.info("批量注册 Agent 类型", { count: definitions.length });
+		log$19.info("批量注册 Agent 类型", { count: definitions.length });
 	}
 	/**
 	* 注销 Agent 类型
@@ -1139,7 +1143,7 @@ var AgentTypeRegistry = class {
 		const result = this.types.delete(typeId);
 		if (result) {
 			this.refreshCache();
-			log$14.debug("注销 Agent 类型", { typeId });
+			log$19.debug("注销 Agent 类型", { typeId });
 		}
 		return result;
 	}
@@ -1226,7 +1230,7 @@ var AgentTypeRegistry = class {
 	loadBuiltinTypes() {
 		for (const def of BUILTIN_AGENT_TYPES) this.types.set(def.typeId, def);
 		this.refreshCache();
-		log$14.info("加载内置 Agent 类型", { count: BUILTIN_AGENT_TYPES.length });
+		log$19.info("加载内置 Agent 类型", { count: BUILTIN_AGENT_TYPES.length });
 	}
 	/**
 	* 刷新可见类型缓存
@@ -2028,7 +2032,7 @@ function setLocale(locale) {
 * Provides SelectList and TextInput overlay dialogs.
 */
 /** Overlay layout options for menus */
-const OVERLAY_OPTIONS = {
+const OVERLAY_OPTIONS$1 = {
 	width: "100%",
 	anchor: "top-left",
 	margin: {
@@ -2166,7 +2170,7 @@ function showSelectList(tui, items, options) {
 			handle?.hide();
 			resolve(null);
 		};
-		handle = tui.showOverlay(list, OVERLAY_OPTIONS);
+		handle = tui.showOverlay(list, OVERLAY_OPTIONS$1);
 	});
 }
 var TextInputComponent = class {
@@ -3430,7 +3434,7 @@ const CRON_CONSTANTS = {
 *
 * @module cli/repl/cron/cron-scheduler
 */
-const log$13 = logger.child("cron:scheduler");
+const log$18 = logger.child("cron:scheduler");
 var CronScheduler = class extends EventEmitter {
 	store;
 	jobs = [];
@@ -3451,7 +3455,7 @@ var CronScheduler = class extends EventEmitter {
 		if (this.running) return;
 		const loadedJobs = await this.store.load();
 		this.jobs = loadedJobs;
-		log$13.info(`调度器启动，加载 ${loadedJobs.length} 个 durable 任务`);
+		log$18.info(`调度器启动，加载 ${loadedJobs.length} 个 durable 任务`);
 		await this.handleMissedJobs();
 		this.checkAutoExpiry();
 		this.running = true;
@@ -3467,7 +3471,7 @@ var CronScheduler = class extends EventEmitter {
 			clearInterval(this.timer);
 			this.timer = null;
 		}
-		log$13.info("调度器已停止");
+		log$18.info("调度器已停止");
 	}
 	/** 添加任务 */
 	async addJob(job) {
@@ -3479,7 +3483,7 @@ var CronScheduler = class extends EventEmitter {
 			this.jobs.push(job);
 			await this.store.persist(this.jobs);
 		} else this.sessionJobs.push(job);
-		log$13.info("任务已添加", {
+		log$18.info("任务已添加", {
 			id: job.id,
 			cron: job.cron,
 			durable: job.durable
@@ -3609,7 +3613,7 @@ var CronScheduler = class extends EventEmitter {
 			}, delay);
 		}
 		if (toDelete.length > 0) {
-			log$13.info(`跳过 ${toDelete.length} 个错过的一次性任务（超出补发上限）`);
+			log$18.info(`跳过 ${toDelete.length} 个错过的一次性任务（超出补发上限）`);
 			this.emit("missed-overflow", {
 				count: toDelete.length,
 				jobIds: toDelete.map((m) => m.id)
@@ -3627,7 +3631,7 @@ var CronScheduler = class extends EventEmitter {
 				job.lastFiredAt = now;
 				job.fireCount++;
 				this.removeJob(job.id);
-				log$13.info("任务已过期并触发最后一次", { id: job.id });
+				log$18.info("任务已过期并触发最后一次", { id: job.id });
 			}
 		}
 	}
@@ -3688,7 +3692,7 @@ function applyOneShotJitter(jobId, rawNext) {
 *
 * @module cli/repl/cron/cron-store
 */
-const log$12 = logger.child("cron:store");
+const log$17 = logger.child("cron:store");
 const STORE_FILE = join(join(homedir(), ".zapmyco", "cron"), "scheduled_tasks.json");
 var CronStore = class {
 	filePath;
@@ -3712,13 +3716,13 @@ var CronStore = class {
 			const raw = await readFile(this.filePath, "utf-8");
 			const data = JSON.parse(raw);
 			if (!Array.isArray(data)) {
-				log$12.warn("存储文件格式无效（非数组），将使用空列表");
+				log$17.warn("存储文件格式无效（非数组），将使用空列表");
 				return [];
 			}
 			return this.validateJobs(data);
 		} catch (err) {
 			if (err.code === "ENOENT") return [];
-			log$12.warn("加载定时任务文件失败，将使用空列表", { error: err instanceof Error ? err.message : String(err) });
+			log$17.warn("加载定时任务文件失败，将使用空列表", { error: err instanceof Error ? err.message : String(err) });
 			return [];
 		}
 	}
@@ -3765,7 +3769,7 @@ var CronStore = class {
 			if (typeof obj.maxFires === "number") job.maxFires = obj.maxFires;
 			valid.push(job);
 		}
-		if (valid.length < raw.length) log$12.warn(`跳过 ${raw.length - valid.length} 个无效任务条目`);
+		if (valid.length < raw.length) log$17.warn(`跳过 ${raw.length - valid.length} 个无效任务条目`);
 		return valid;
 	}
 };
@@ -3783,7 +3787,7 @@ function getCronStore() {
 * 基于内存的环形缓冲区，记录 REPL 会话中的用户输入和执行结果。
 * 支持文件持久化到 ~/.zapmyco/history.json，跨会话恢复。
 */
-const log$11 = logger.child("history:store");
+const log$16 = logger.child("history:store");
 /** 默认最大历史条数 */
 const DEFAULT_MAX_SIZE = 100;
 /** 历史文件存储路径 */
@@ -3842,13 +3846,13 @@ var HistoryStore = class {
 			if (Array.isArray(data.entries)) {
 				this.entries = data.entries.slice(-this.maxSize);
 				this.nextId = typeof data.nextId === "number" ? data.nextId : 1;
-				log$11.debug("历史记录已加载", {
+				log$16.debug("历史记录已加载", {
 					count: this.entries.length,
 					nextId: this.nextId
 				});
 			}
 		} catch {
-			log$11.debug("无历史文件或加载失败，使用空历史");
+			log$16.debug("无历史文件或加载失败，使用空历史");
 		}
 	}
 	/** 持久化历史记录到文件 */
@@ -3861,7 +3865,7 @@ var HistoryStore = class {
 			}, null, 2);
 			writeFileSync(this.filePath, data, "utf-8");
 		} catch (err) {
-			log$11.warn("历史记录保存失败", { error: err instanceof Error ? err.message : String(err) });
+			log$16.warn("历史记录保存失败", { error: err instanceof Error ? err.message : String(err) });
 		}
 	}
 };
@@ -3961,6 +3965,432 @@ var InputParser = class {
 	}
 };
 
+//#endregion
+//#region src/cli/repl/components/ask-user-question.ts
+const OVERLAY_OPTIONS = {
+	width: "100%",
+	anchor: "top-left",
+	margin: {
+		top: 1,
+		bottom: 1
+	}
+};
+/** 截断文本到指定宽度 */
+function truncate(text, maxLen) {
+	if (text.length <= maxLen) return text;
+	return text.slice(0, maxLen - 1) + "…";
+}
+var AskUserQuestionComponent = class {
+	tui;
+	questions;
+	onResolve;
+	onCancel;
+	phase = "answering";
+	currentQuestionIndex = 0;
+	questionStates;
+	selectedOptionIndex = 0;
+	otherInputValue = "";
+	showPreview = false;
+	constructor(tui, params, onResolve, onCancel) {
+		this.tui = tui;
+		this.questions = params.questions;
+		this.onResolve = onResolve;
+		this.onCancel = onCancel;
+		this.questionStates = this.questions.map(() => ({
+			selectedLabels: [],
+			otherText: ""
+		}));
+		const hasPreview = this.questions.some((q) => q.options.some((o) => o.preview));
+		this.showPreview = hasPreview;
+	}
+	/** 安全获取当前问题 */
+	getCurrentQuestion() {
+		return this.questions[this.currentQuestionIndex];
+	}
+	/** 安全获取当前问题的状态 */
+	getCurrentState() {
+		return this.questionStates[this.currentQuestionIndex];
+	}
+	handleInput(data) {
+		if (data === "escape" || data === "q") {
+			if (this.phase === "other_input") {
+				this.phase = "answering";
+				return;
+			}
+			if (this.phase === "reviewing") {
+				this.phase = "answering";
+				return;
+			}
+			this.onCancel?.();
+			return;
+		}
+		switch (this.phase) {
+			case "answering":
+				this.handleAnsweringInput(data);
+				break;
+			case "other_input":
+				this.handleOtherInput(data);
+				break;
+			case "reviewing":
+				this.handleReviewingInput(data);
+				break;
+		}
+	}
+	handleAnsweringInput(data) {
+		const q = this.getCurrentQuestion();
+		const state = this.getCurrentState();
+		const optionCount = q.options.length;
+		if (data >= "1" && data <= "9") {
+			const idx = Number.parseInt(data, 10) - 1;
+			if (idx < optionCount) {
+				this.selectOption(idx);
+				return;
+			}
+			if (idx === optionCount) {
+				this.enterOtherInput();
+				return;
+			}
+			return;
+		}
+		switch (data) {
+			case "up":
+			case "k":
+				if (this.selectedOptionIndex > 0) this.selectedOptionIndex--;
+				return;
+			case "down":
+			case "j":
+				if (this.selectedOptionIndex < optionCount) this.selectedOptionIndex++;
+				return;
+			case " ":
+				if (q.multiSelect && this.selectedOptionIndex < optionCount) this.toggleOption(this.selectedOptionIndex);
+				return;
+			case "tab":
+				this.advanceQuestion();
+				return;
+			case "shift+tab":
+				if (this.currentQuestionIndex > 0) {
+					this.currentQuestionIndex--;
+					this.selectedOptionIndex = 0;
+				}
+				return;
+			case "enter":
+				if (q.multiSelect) {
+					if (state.selectedLabels.length > 0) this.advanceQuestion();
+				} else if (this.selectedOptionIndex < optionCount) {
+					this.selectOption(this.selectedOptionIndex);
+					this.advanceQuestion();
+				} else if (this.selectedOptionIndex === optionCount) this.enterOtherInput();
+				return;
+			case "o":
+				this.enterOtherInput();
+				return;
+			case "p":
+				this.showPreview = !this.showPreview;
+				return;
+			case "h":
+			case "backspace":
+				if (this.currentQuestionIndex > 0) {
+					this.currentQuestionIndex--;
+					this.selectedOptionIndex = 0;
+				}
+				return;
+			default: break;
+		}
+	}
+	handleOtherInput(data) {
+		if (data === "enter") {
+			const trimmed = this.otherInputValue.trim();
+			if (trimmed) {
+				const state = this.getCurrentState();
+				state.selectedLabels = [trimmed];
+				state.otherText = trimmed;
+			}
+			this.otherInputValue = "";
+			this.phase = "answering";
+			this.advanceQuestion();
+			return;
+		}
+		if (data === "escape") {
+			this.otherInputValue = "";
+			this.phase = "answering";
+			return;
+		}
+		if (data === "backspace" || data === "" || data === "\b") {
+			this.otherInputValue = this.otherInputValue.slice(0, -1);
+			return;
+		}
+		if (data.length === 1 && data >= " " && data <= "~") this.otherInputValue += data;
+	}
+	handleReviewingInput(data) {
+		if (data === "enter") {
+			this.submitAnswers();
+			return;
+		}
+		if (data === "escape") {
+			this.phase = "answering";
+			this.currentQuestionIndex = this.questions.length - 1;
+			this.selectedOptionIndex = 0;
+			return;
+		}
+	}
+	selectOption(index) {
+		const state = this.getCurrentState();
+		const option = this.getCurrentQuestion().options[index];
+		if (this.getCurrentQuestion().multiSelect) this.toggleOption(index);
+		else state.selectedLabels = [option.label];
+	}
+	toggleOption(index) {
+		const state = this.getCurrentState();
+		const option = this.getCurrentQuestion().options[index];
+		const idx = state.selectedLabels.indexOf(option.label);
+		if (idx >= 0) state.selectedLabels.splice(idx, 1);
+		else state.selectedLabels.push(option.label);
+	}
+	enterOtherInput() {
+		this.otherInputValue = this.getCurrentState().otherText;
+		this.phase = "other_input";
+	}
+	advanceQuestion() {
+		if (this.currentQuestionIndex < this.questions.length - 1) {
+			this.currentQuestionIndex++;
+			this.selectedOptionIndex = 0;
+		} else this.phase = "reviewing";
+	}
+	submitAnswers() {
+		const answers = {};
+		const annotations = {};
+		for (let i = 0; i < this.questions.length; i++) {
+			const q = this.questions[i];
+			const state = this.questionStates[i];
+			if (q.multiSelect) answers[q.question] = [...state.selectedLabels];
+			else answers[q.question] = state.selectedLabels[0] ?? "";
+			if (state.otherText) annotations[q.question] = { notes: `自定义: ${state.otherText}` };
+		}
+		this.onResolve?.({
+			questions: this.questions,
+			answers,
+			annotations: Object.keys(annotations).length > 0 ? annotations : void 0
+		});
+	}
+	invalidate() {}
+	render(width) {
+		switch (this.phase) {
+			case "reviewing": return this.renderReview(width);
+			case "other_input": return this.renderOtherInput(width);
+			default: return this.renderQuestion(width);
+		}
+	}
+	renderQuestion(fullWidth) {
+		const c = chalk;
+		const showPreviewPanel = this.showPreview && this.questions.some((q) => q.options.some((o) => o.preview));
+		const mainWidth = showPreviewPanel ? Math.floor(fullWidth * .58) : fullWidth;
+		const previewWidth = showPreviewPanel ? fullWidth - mainWidth - 1 : 0;
+		const mainLines = this.renderMainPanel(mainWidth);
+		let previewLines = [];
+		if (showPreviewPanel) previewLines = this.renderPreviewPanel(previewWidth);
+		const maxLines = Math.max(mainLines.length, previewLines.length);
+		const result = [];
+		for (let i = 0; i < maxLines; i++) {
+			const left = i < mainLines.length ? mainLines[i] : " ".repeat(mainWidth);
+			const right = i < previewLines.length ? previewLines[i] : "";
+			const separator = showPreviewPanel ? c.gray("│") : "";
+			result.push(`${left}${separator}${right}`);
+		}
+		return result;
+	}
+	renderMainPanel(width) {
+		const c = chalk;
+		const lines = [];
+		lines.push("");
+		lines.push(this.renderTabs(width));
+		lines.push(c.gray(`  ${"─".repeat(Math.max(0, width - 4))}`));
+		lines.push("");
+		const q = this.getCurrentQuestion();
+		const wrappedQuestion = this.wrapText(q.question, width - 4);
+		for (const line of wrappedQuestion) lines.push(c.bold(`  ${line}`));
+		lines.push("");
+		const state = this.getCurrentState();
+		for (let i = 0; i < q.options.length; i++) {
+			const opt = q.options[i];
+			const isSelected = q.multiSelect ? state.selectedLabels.includes(opt.label) : state.selectedLabels[0] === opt.label;
+			const isFocused = this.selectedOptionIndex === i;
+			const prefix = `${i + 1}`;
+			const checkbox = isSelected ? c.green("●") : "○";
+			const label = isFocused ? c.cyan.bold(opt.label) : c.bold(opt.label);
+			const desc = c.gray(`  ${opt.description}`);
+			const line = `  ${c.gray(prefix)} ${checkbox} ${label}`;
+			lines.push(line);
+			if (isFocused && opt.description) lines.push(`    ${desc}`);
+		}
+		const otherIdx = q.options.length;
+		const isOtherFocused = this.selectedOptionIndex === otherIdx;
+		const otherLabel = isOtherFocused ? c.cyan.bold("其他 (自定义)") : c.gray("其他 (自定义)");
+		const otherPrefix = `${otherIdx + 1}`;
+		lines.push(`  ${c.gray(otherPrefix)} ${otherLabel}`);
+		if (isOtherFocused) lines.push(`    ${c.gray("输入自定义答案")}`);
+		lines.push("");
+		lines.push(c.gray(`  ${"─".repeat(Math.max(0, width - 4))}`));
+		const termHeight = this.tui.terminal.rows;
+		const padding = Math.max(0, termHeight - 1 - lines.length - 3);
+		for (let i = 0; i < padding; i++) lines.push("");
+		if (q.multiSelect) lines.push(c.gray(`  ${this.buildMultiFooter()}`));
+		else lines.push(c.gray(`  ${this.buildSingleFooter()}`));
+		lines.push("");
+		return lines;
+	}
+	renderTabs(width) {
+		const c = chalk;
+		const parts = [];
+		for (let i = 0; i < this.questions.length; i++) {
+			const q = this.questions[i];
+			const isAnswered = this.questionStates[i].selectedLabels.length > 0;
+			const isCurrent = i === this.currentQuestionIndex;
+			const header = truncate(q.header, 10);
+			const indicator = isAnswered ? c.green("✓") : c.gray("○");
+			let tab;
+			if (isCurrent) tab = c.bgCyan.black(` ${indicator} ${header} `);
+			else if (isAnswered) tab = c.green(` ${indicator} ${header} `);
+			else tab = c.gray(` ${indicator} ${header} `);
+			parts.push(tab);
+		}
+		const submitTab = this.phase === "reviewing" ? c.bgGreen.black(" 提交 ") : c.gray(" 提交 ");
+		parts.push(submitTab);
+		return `  ${parts.join(" ")}`;
+	}
+	renderPreviewPanel(width) {
+		const c = chalk;
+		const lines = [];
+		if (width < 15) return lines;
+		lines.push(c.bold(" 预览"));
+		lines.push(c.gray("─".repeat(Math.max(0, width - 2))));
+		const q = this.getCurrentQuestion();
+		if (this.selectedOptionIndex < q.options.length) {
+			const opt = q.options[this.selectedOptionIndex];
+			if (opt.preview) {
+				const previewLines = opt.preview.split("\n");
+				const maxPreviewLines = 20;
+				for (const line of previewLines.slice(0, maxPreviewLines)) lines.push(` ${c.gray(truncate(line, width - 2))}`);
+				if (previewLines.length > maxPreviewLines) lines.push(c.gray(` ... 还有 ${previewLines.length - maxPreviewLines} 行`));
+			} else lines.push(c.gray(" (无预览)"));
+		} else lines.push(c.gray(" (无预览)"));
+		const maxLines = 22;
+		while (lines.length < maxLines) lines.push("");
+		return lines;
+	}
+	renderOtherInput(width) {
+		const c = chalk;
+		const q = this.getCurrentQuestion();
+		const lines = [];
+		lines.push("");
+		lines.push(this.renderTabs(width));
+		lines.push(c.gray(`  ${"─".repeat(Math.max(0, width - 4))}`));
+		lines.push("");
+		lines.push(c.bold(`  ${q.question}`));
+		lines.push("");
+		lines.push(`  输入自定义答案:`);
+		lines.push("");
+		lines.push(c.yellow(`  > ${this.otherInputValue}█`));
+		lines.push("");
+		lines.push(c.gray(`  ${"─".repeat(Math.max(0, width - 4))}`));
+		lines.push(c.gray("  Enter 确认  ·  Esc 返回  ·  输入自定义文本"));
+		lines.push("");
+		return lines;
+	}
+	renderReview(width) {
+		const c = chalk;
+		const lines = [];
+		lines.push("");
+		lines.push(c.bold("  确认你的答案"));
+		lines.push(c.gray(`  ${"─".repeat(Math.max(0, width - 4))}`));
+		lines.push("");
+		for (let i = 0; i < this.questions.length; i++) {
+			const q = this.questions[i];
+			const state = this.questionStates[i];
+			const answer = q.multiSelect ? state.selectedLabels.join(", ") : state.selectedLabels[0] ?? c.gray("(未回答)");
+			const header = truncate(q.header, 15);
+			lines.push(`  ${c.bold(header)}:  ${answer}`);
+		}
+		lines.push("");
+		lines.push(c.gray(`  ${"─".repeat(Math.max(0, width - 4))}`));
+		lines.push(c.gray("  Enter 提交答案  ·  Esc 返回修改"));
+		lines.push("");
+		return lines;
+	}
+	buildSingleFooter() {
+		const parts = [];
+		const q = this.getCurrentQuestion();
+		parts.push(`1-${q.options.length} 选择`);
+		parts.push("k/j ↑↓ 导航");
+		if (q.options.some((o) => o.preview)) parts.push("p 切换预览");
+		if (this.questions.length > 1) parts.push("Tab 下一题");
+		parts.push("Enter 确认");
+		parts.push("o 自定义");
+		parts.push("Esc 取消");
+		return parts.join("  ·  ");
+	}
+	buildMultiFooter() {
+		const parts = [];
+		const q = this.getCurrentQuestion();
+		parts.push(`1-${q.options.length} 切换`);
+		parts.push("Space 选择");
+		parts.push("k/j ↑↓ 导航");
+		if (q.options.some((o) => o.preview)) parts.push("p 切换预览");
+		if (this.questions.length > 1) parts.push("Tab 下一题");
+		parts.push("Enter 确认选择");
+		parts.push("o 自定义");
+		parts.push("Esc 取消");
+		return parts.join("  ·  ");
+	}
+	wrapText(text, maxWidth) {
+		if (text.length <= maxWidth) return [text];
+		const lines = [];
+		let remaining = text;
+		while (remaining.length > maxWidth) {
+			let breakAt = maxWidth;
+			const lastSpace = remaining.lastIndexOf(" ", maxWidth);
+			if (lastSpace > maxWidth / 2) breakAt = lastSpace;
+			lines.push(remaining.slice(0, breakAt));
+			remaining = remaining.slice(breakAt).trim();
+		}
+		if (remaining) lines.push(remaining);
+		return lines;
+	}
+};
+/**
+* 显示 AskUserQuestion 对话框
+*
+* @param tui - TUI 实例
+* @param params - 问题参数
+* @returns 用户回答结果，取消时 reject
+*/
+function showAskUserQuestionDialog(tui, params) {
+	return new Promise((resolve, reject) => {
+		let handle = null;
+		const component = new AskUserQuestionComponent(tui, params, (result) => {
+			handle?.hide();
+			resolve(result);
+		}, () => {
+			handle?.hide();
+			reject(/* @__PURE__ */ new Error("用户取消了提问"));
+		});
+		handle = tui.showOverlay(component, OVERLAY_OPTIONS);
+	});
+}
+
+//#endregion
+//#region src/cli/repl/question-provider.ts
+/**
+* 创建基于 TUI 的问题提供者
+*
+* @param tui - TUI 实例
+* @returns QuestionProvider 实现
+*/
+function createTuiQuestionProvider(tui) {
+	return { async showQuestions(params) {
+		return showAskUserQuestionDialog(tui, params);
+	} };
+}
+
 //#endregion
 //#region src/cli/repl/components/output-area.ts
 /**
@@ -3975,6 +4405,7 @@ var InputParser = class {
 * 从原 Renderer 中提取的纯格式化逻辑，不依赖 console.log。
 */
 var OutputFormatter = class {
+	color;
 	c;
 	cDisabled;
 	constructor(color) {
@@ -4292,133 +4723,1186 @@ var Renderer = class {
 };
 
 //#endregion
-//#region src/cli/repl/tools/agent-tool.ts
+//#region src/security/tool-guard.ts
 /**
-* 创建 AgentTool 工具注册
+* 工具守卫 — 代理模式包装 ToolRegistration
 *
-* @param orchestrator - AgentOrchestrator 实例
-* @returns ToolRegistration
+* 为每个 ToolRegistration 的 execute 函数添加安全管道：
+*   1. PermissionEngine.evaluate() → 获取安全决策
+*   2. DENY → 抛出 SecurityBlockedError
+*   3. ASK → ApprovalManager.requestApproval()
+*   4. ALLOW → 执行原 execute()
+*
+* 代理模式：保留原 ToolRegistration 所有属性，
+* 仅替换 execute 函数为带安全检查的版本。
+*
+* ## ToolGuardContext
+*
+* 通过 AsyncLocalStorage 传递运行时上下文，控制特殊场景下的行为：
+* - isBackgroundAgent: 后台 Agent 遇 ASK 自动降级为 DENY（无用户可交互）
+* - planMode: Plan Mode 下限制工具可用性
+* - worktreePath: 工作树上下文
+*
+* @module security/tool-guard
 */
-function createAgentTool(orchestrator) {
-	const registry = getAgentTypeRegistry();
-	return {
-		id: "AgentTool",
-		label: "创建 Agent",
-		defaultRisk: "high",
-		description: [
-			"创建特定类型的子 Agent 来执行独立任务。支持按 Agent 类型创建（推荐）或批量匿名创建（兼容旧版）。",
-			"",
-			"### 何时使用此工具",
-			"1. 需要分解复杂任务为多个独立子任务时",
-			"2. 需要特定类型的 Agent（研究员/编码助手/审查员/规划师）时",
-			"3. 多个子任务之间没有顺序依赖关系时可以并行创建",
-			"",
-			"### 何时不使用此工具",
-			"- 只有 1 个简单任务时（直接执行即可）",
-			"- 任务之间有严格的顺序依赖（必须串行执行）",
-			"- 任务非常简单（如读取单个文件）",
-			"",
-			"### 可用的 Agent 类型",
-			registry.list().map((t) => `- **${t.typeId}**: ${t.whenToUse}`).join("\n"),
-			"",
-			"### 参数说明",
-			"- **subagent_type**（推荐）: Agent 类型 ID，如 researcher/coder/reviewer/planner/general-purpose",
-			"- **description**: 发给子 Agent 的详细任务指令",
-			"- **run_in_background**: 是否后台运行（暂不支持，默认 false）",
-			"- **inherit_context**: 是否继承父级上下文",
-			"- **agents**（已废弃，兼容旧版）: 批量匿名子 Agent 列表",
-			"- **context**: 可选背景摘要",
-			"",
-			"### 使用流程",
-			"1. 分析任务，确定需要的 Agent 类型",
-			"2. 为每个 Agent 编写详细的任务指令",
-			"3. 调用本工具创建 Agent（可多次调用创建多个不同类型的 Agent）",
-			"4. 等待结果返回后整合汇总"
-		].join("\n"),
-		parameters: {
-			type: "object",
-			properties: {
-				subagent_type: {
-					type: "string",
-					description: `Agent 类型 ID。可用类型: ${registry.list().map((t) => t.typeId).join(", ")}`
-				},
-				description: {
-					type: "string",
-					description: "发给子 Agent 的详细任务指令"
-				},
-				run_in_background: {
-					type: "boolean",
-					description: "是否后台运行（暂不支持，默认 false）",
-					default: false
-				},
-				inherit_context: {
-					type: "boolean",
-					description: "是否继承父级上下文",
-					default: false
-				},
-				agents: {
-					type: "array",
-					items: {
-						type: "object",
-						properties: {
-							id: {
-								type: "string",
-								description: "子任务唯一标识"
-							},
-							description: {
-								type: "string",
-								description: "发给子 Agent 的详细任务指令"
-							},
-							allowedTools: {
-								type: "array",
-								items: { type: "string" },
-								description: "可选工具白名单"
-							}
-						},
-						required: ["id", "description"]
-					},
-					description: "[已废弃] 批量匿名子 Agent 列表，请使用 subagent_type 参数"
-				},
-				context: {
-					type: "string",
-					description: "可选背景摘要，注入给每个子 Agent"
-				}
-			},
-			required: ["description"]
-		},
-		execute: async (_toolCallId, params) => {
-			const p = params;
-			if (p.run_in_background) return { content: [{
-				type: "text",
-				text: "错误: run_in_background（异步模式）将在后续版本中支持。当前请使用同步模式（run_in_background=false）。"
-			}] };
-			if (p.subagent_type && !p.agents) {
-				const result = await orchestrator.spawnWorker(p.subagent_type, p.description, {
-					...p.context != null ? { context: p.context } : {},
-					...p.inherit_context != null ? { inheritContext: p.inherit_context } : {}
-				});
-				return {
-					content: [{
-						type: "text",
-						text: result.status === "success" ? `✅ **${result.typeId}** 执行成功 (${(result.duration / 1e3).toFixed(1)}s)\n\n${result.output ?? "（无输出）"}` : `❌ **${result.typeId}** 执行失败: ${result.error?.message ?? "未知错误"}`
-					}],
-					details: result
-				};
-			}
-			if (p.agents && p.agents.length > 0) {
-				const results = await orchestrator.spawnFlat(p.agents, p.context);
-				return {
-					content: [{
-						type: "text",
-						text: results.summary
+const log$15 = logger.child("tool-guard");
+const toolGuardCtxStore = new AsyncLocalStorage();
+/**
+* 获取当前 ToolGuard 上下文
+*/
+function getToolGuardContext() {
+	return toolGuardCtxStore.getStore();
+}
+/**
+* 在指定上下文中执行回调
+*
+* 用于在后台 Agent / Plan Mode 等场景下包装工具执行。
+*/
+async function runWithToolGuardContext(context, fn) {
+	return toolGuardCtxStore.run(context, fn);
+}
+/**
+* 安全阻止错误
+*
+* 当工具调用被权限引擎拒绝时抛出。
+* 调用方（agent-adapter / session）应捕获此错误
+* 并转换为 LLM 友好的错误反馈。
+*/
+var SecurityBlockedError = class extends Error {
+	toolId;
+	risk;
+	reason;
+	constructor(message, toolId, risk, reason) {
+		super(message);
+		this.name = "SecurityBlockedError";
+		this.toolId = toolId;
+		this.risk = risk;
+		this.reason = reason;
+	}
+};
+var ToolGuard = class {
+	engine;
+	approvalManager;
+	store;
+	sessionId;
+	auditLogger;
+	constructor(engine, approvalManager, store, sessionId, auditLogger) {
+		this.engine = engine;
+		this.approvalManager = approvalManager;
+		this.store = store;
+		this.sessionId = sessionId ?? `session-${Date.now()}`;
+		this.auditLogger = auditLogger;
+	}
+	/**
+	* 包装单个 ToolRegistration
+	*
+	* 返回新 ToolRegistration，原对象不变。
+	* execute 被替换为带安全检查的版本。
+	*/
+	wrap(registration) {
+		const originalExecute = registration.execute;
+		const toolId = registration.id;
+		const toolLabel = registration.label;
+		const guardedExecute = async (toolCallId, params, signal, onUpdate) => {
+			const decision = this.engine.evaluate(toolId, params);
+			if (decision.action === "deny") {
+				const reason = decision.reason ?? `工具 ${toolId} 已被安全策略阻止`;
+				log$15.warn("工具调用被阻止", {
+					toolId,
+					risk: decision.risk,
+					reason
+				});
+				eventBus.emit("security:blocked", {
+					toolId,
+					risk: decision.risk,
+					reason,
+					params
+				});
+				this.auditLogger?.log({
+					action: "BLOCK",
+					toolId,
+					risk: decision.risk,
+					reason,
+					params,
+					...decision.matchedRule ? { matchedRule: decision.matchedRule } : {}
+				});
+				throw new SecurityBlockedError(reason, toolId, decision.risk, reason);
+			}
+			if (decision.action === "ask") {
+				if (getToolGuardContext()?.isBackgroundAgent) {
+					const reason = `后台 Agent 不允许交互式审批，工具 ${toolId} 被自动拒绝`;
+					log$15.info("后台 Agent ASK 降级为 DENY", {
+						toolId,
+						risk: decision.risk
+					});
+					eventBus.emit("security:blocked", {
+						toolId,
+						risk: decision.risk,
+						reason,
+						params
+					});
+					this.auditLogger?.log({
+						action: "BLOCK",
+						toolId,
+						risk: decision.risk,
+						reason,
+						params
+					});
+					throw new SecurityBlockedError(reason, toolId, decision.risk, reason);
+				}
+				this.auditLogger?.log({
+					action: "APPROVAL_REQUESTED",
+					toolId,
+					risk: decision.risk,
+					params,
+					...decision.reason ? { reason: decision.reason } : {}
+				});
+				const approvalResponse = await this.approvalManager.requestApproval({
+					toolId,
+					toolLabel,
+					params,
+					risk: decision.risk,
+					reason: decision.reason ?? `工具 ${toolId} 需要审批`,
+					sessionId: this.sessionId
+				});
+				if (!approvalResponse.approved) {
+					const reason = `用户拒绝了工具 ${toolId} 的执行请求`;
+					log$15.info("用户拒绝工具执行", { toolId });
+					this.auditLogger?.log({
+						action: "APPROVAL_DENIED",
+						toolId,
+						risk: decision.risk,
+						reason
+					});
+					throw new SecurityBlockedError(reason, toolId, decision.risk, reason);
+				}
+				if (approvalResponse.scope === "session") this.store.addSessionApproval(toolId);
+				else if (approvalResponse.scope === "always") this.store.addPersistentApproval(toolId);
+				this.auditLogger?.log({
+					action: "APPROVAL_GRANTED",
+					toolId,
+					risk: decision.risk,
+					...approvalResponse.scope ? { scope: approvalResponse.scope } : {},
+					...decision.reason ? { reason: decision.reason } : {}
+				});
+				log$15.debug("审批通过，执行工具", {
+					toolId,
+					scope: approvalResponse.scope
+				});
+			} else this.auditLogger?.log({
+				action: "ALLOW",
+				toolId,
+				risk: decision.risk,
+				params,
+				...decision.matchedRule ? { matchedRule: decision.matchedRule } : {}
+			});
+			return originalExecute(toolCallId, params, signal, onUpdate);
+		};
+		return {
+			...registration,
+			execute: guardedExecute
+		};
+	}
+	/**
+	* 批量包装所有工具
+	*/
+	wrapAll(registrations) {
+		return registrations.map((reg) => this.wrap(reg));
+	}
+};
+/**
+* 从 ToolRegistration 数组构建 ToolInfoResolver
+*
+* 供 PermissionEngine 使用，将 toolId 映射到其安全信息。
+*/
+function createToolInfoResolver(registrations) {
+	const map = /* @__PURE__ */ new Map();
+	for (const reg of registrations) map.set(reg.id, reg);
+	return (toolId) => {
+		const reg = map.get(toolId);
+		if (!reg) return void 0;
+		return {
+			checkPermission: reg.checkPermission,
+			defaultRisk: reg.defaultRisk
+		};
+	};
+}
+
+//#endregion
+//#region src/core/agent-team/agent-background-store.ts
+/**
+* 后台任务持久化存储
+*
+* 复用 TaskStore 的内存+JSON 双写模式。
+* 存储路径：~/.zapmyco/background-tasks/<cwd-hash>.json
+*
+* @module core/agent-team
+*/
+const log$14 = logger.child("background-store");
+/**
+* 后台任务持久化存储
+*
+* 提供跨会话的后台任务状态持久化。
+* 内存 Map + JSON 文件双写，每次变更自动同步到磁盘。
+*/
+var BackgroundTaskStore = class {
+	tasks = /* @__PURE__ */ new Map();
+	filePath;
+	constructor(cwd) {
+		const dir = join(homedir(), ".zapmyco", "background-tasks");
+		if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+		const hash = createHash("md5").update(cwd ?? process.cwd()).digest("hex").slice(0, 16);
+		this.filePath = join(dir, `${hash}.json`);
+	}
+	/** 获取存储文件路径 */
+	get storagePath() {
+		return this.filePath;
+	}
+	/**
+	* 从磁盘加载（覆盖内存）
+	*/
+	load() {
+		try {
+			if (existsSync(this.filePath)) {
+				const raw = readFileSync(this.filePath, "utf-8");
+				const entries = JSON.parse(raw);
+				this.tasks.clear();
+				for (const entry of entries) this.tasks.set(entry.taskId, entry);
+				log$14.debug("后台任务已加载", {
+					count: entries.length,
+					path: this.filePath
+				});
+				return entries;
+			}
+		} catch (err) {
+			log$14.warn("后台任务加载失败", {
+				error: String(err),
+				path: this.filePath
+			});
+		}
+		return [];
+	}
+	/**
+	* 获取指定任务
+	*/
+	get(taskId) {
+		return this.tasks.get(taskId);
+	}
+	/**
+	* 获取所有任务
+	*/
+	listAll() {
+		return Array.from(this.tasks.values());
+	}
+	/**
+	* 获取活跃（未完结）的任务
+	*/
+	listActive() {
+		return this.listAll().filter((t) => t.status === "pending" || t.status === "running");
+	}
+	/**
+	* 保存或更新任务
+	*/
+	save(entry) {
+		this.tasks.set(entry.taskId, entry);
+		this.persist();
+	}
+	/**
+	* 更新任务状态
+	*/
+	updateStatus(taskId, status, extra) {
+		const entry = this.tasks.get(taskId);
+		if (!entry) return false;
+		Object.assign(entry, {
+			status,
+			...extra
+		});
+		this.persist();
+		return true;
+	}
+	/**
+	* 删除任务
+	*/
+	remove(taskId) {
+		const deleted = this.tasks.delete(taskId);
+		if (deleted) this.persist();
+		return deleted;
+	}
+	/** 同步到磁盘 */
+	persist() {
+		try {
+			const entries = Array.from(this.tasks.values());
+			writeFileSync(this.filePath, JSON.stringify(entries, null, 2), "utf-8");
+		} catch (err) {
+			log$14.error("后台任务持久化失败", {
+				error: String(err),
+				path: this.filePath
+			});
+		}
+	}
+	/** 恢复时清理卡死的 running 任务 */
+	cleanStale(maxRunningMs = 7200 * 1e3) {
+		let cleaned = 0;
+		const now = Date.now();
+		const stale = [];
+		for (const [id, entry] of this.tasks) {
+			if (entry.status === "running" && now - entry.createdAt > maxRunningMs) stale.push(id);
+			if (entry.status === "pending" && now - entry.createdAt > maxRunningMs) stale.push(id);
+		}
+		for (const id of stale) {
+			const entry = this.tasks.get(id);
+			if (entry) {
+				entry.status = entry.status === "running" ? "failed" : "cancelled";
+				entry.error = entry.status === "failed" ? "任务超时丢失（跨会话恢复）" : "任务在 pending 状态超时，无法恢复";
+				entry.completedAt = now;
+				cleaned++;
+			}
+		}
+		if (cleaned > 0) {
+			this.persist();
+			log$14.info("清理过期后台任务", { cleaned });
+		}
+		return cleaned;
+	}
+};
+
+//#endregion
+//#region src/core/agent-team/agent-message-bus.ts
+/**
+* Agent 消息总线
+*
+* 内存中的 Agent 间消息路由系统。
+* 基于 EventEmitter 实现 publish/subscribe 模式，
+* 消息同时投递到目标 AgentInstance 的 inbox。
+*
+* @module core/agent-team
+*/
+const log$13 = logger.child("agent-message-bus");
+/**
+* Agent 消息总线（单例）
+*
+* 负责 Agent 间消息的路由和投递：
+* - publish(): 将消息投递到目标 inbox + 触发订阅回调
+* - subscribe(): 注册消息监听器
+* - drainInbox(): 取出并清空 Agent 收件箱
+*/
+var AgentMessageBus = class {
+	emitter = new EventEmitter();
+	messageCounter = 0;
+	/**
+	* 发布消息
+	*
+	* 1. 生成 messageId（若未提供）
+	* 2. 将消息推入目标 AgentInstance.inbox（通过 AgentInstanceManager）
+	* 3. 触发目标 Agent 的订阅回调
+	*
+	* @param fromAgentId - 发送方实例 ID
+	* @param toAgentId - 接收方实例 ID
+	* @param message - 消息内容（不含 messageId/fromAgentId/timestamp）
+	* @returns 完整的 AgentMessage（含生成的 messageId 和 timestamp）
+	*/
+	publish(fromAgentId, toAgentId, message) {
+		const fullMessage = {
+			...message,
+			messageId: this.generateMessageId(),
+			fromAgentId,
+			toAgentId,
+			timestamp: Date.now()
+		};
+		const targetInstance = getAgentInstanceManager().get(toAgentId);
+		if (targetInstance) targetInstance.inbox.push(fullMessage);
+		else log$13.warn("目标 Agent 实例不存在，消息丢弃", {
+			toAgentId,
+			messageId: fullMessage.messageId
+		});
+		this.emitter.emit(`msg:${toAgentId}`, fullMessage);
+		log$13.debug("消息已投递", {
+			from: fromAgentId,
+			to: toAgentId,
+			type: fullMessage.type,
+			messageId: fullMessage.messageId
+		});
+		return fullMessage;
+	}
+	/**
+	* 订阅指定 Agent 的消息
+	*
+	* 当有新消息投递到该 Agent 时，回调被触发。
+	*
+	* @param agentId - 要监听的 Agent 实例 ID
+	* @param callback - 消息到达时的回调
+	*/
+	subscribe(agentId, callback) {
+		this.emitter.on(`msg:${agentId}`, callback);
+	}
+	/**
+	* 取消订阅
+	*
+	* @param agentId - Agent 实例 ID
+	* @param callback - 要移除的回调
+	*/
+	unsubscribe(agentId, callback) {
+		this.emitter.off(`msg:${agentId}`, callback);
+	}
+	/**
+	* 取出并清空指定 Agent 的收件箱
+	*
+	* @param agentId - Agent 实例 ID
+	* @returns 收件箱中的所有消息（按投递时间排序）
+	*/
+	drainInbox(agentId) {
+		const instance = getAgentInstanceManager().get(agentId);
+		if (!instance || instance.inbox.length === 0) return [];
+		const messages = [...instance.inbox];
+		instance.inbox = [];
+		return messages;
+	}
+	/**
+	* 获取收件箱中的消息数量（不清空）
+	*
+	* @param agentId - Agent 实例 ID
+	*/
+	inboxCount(agentId) {
+		return getAgentInstanceManager().get(agentId)?.inbox.length ?? 0;
+	}
+	/** 获取当前活跃的订阅数量 */
+	get subscriptionCount() {
+		return this.emitter.listenerCount("msg:");
+	}
+	/** 生成唯一消息 ID */
+	generateMessageId() {
+		this.messageCounter++;
+		return `msg-${Date.now()}-${this.messageCounter}`;
+	}
+};
+/** 全局单例引用 */
+let _messageBus = null;
+/**
+* 获取 AgentMessageBus 单例
+*/
+function getAgentMessageBus() {
+	if (!_messageBus) _messageBus = new AgentMessageBus();
+	return _messageBus;
+}
+
+//#endregion
+//#region src/core/agent-team/agent-background-manager.ts
+/**
+* 后台 Agent 管理器
+*
+* 管理后台异步 Agent 的完整生命周期：
+* - fire-and-forget 启动（立即返回 taskId，Agent 在后台执行）
+* - 进度跟踪
+* - 结果收集
+* - 完成后通过 AgentMessageBus 通知父 Agent
+* - 超时自动取消
+*
+* @module core/agent-team
+*/
+const log$12 = logger.child("background-agent-manager");
+/**
+* 后台 Agent 管理器（单例）
+*/
+var BackgroundAgentManager = class {
+	runtime = /* @__PURE__ */ new Map();
+	store;
+	orchestrator = null;
+	defaultTimeoutMs = 1800 * 1e3;
+	constructor() {
+		this.store = new BackgroundTaskStore();
+	}
+	/** 注入 AgentOrchestrator（用于创建 Agent） */
+	setOrchestrator(orchestrator) {
+		this.orchestrator = orchestrator;
+	}
+	/** 获取持久化存储（供外部查询） */
+	getStore() {
+		return this.store;
+	}
+	/**
+	* 异步启动一个 Agent
+	*
+	* fire-and-forget 模式：
+	* 1. 立即返回 { taskId, instanceId }
+	* 2. Agent 在后台执行
+	* 3. 完成后自动通过 AgentMessageBus 通知父 Agent
+	*
+	* @param params - 异步 Agent 参数
+	* @returns 任务标识
+	*/
+	async executeAsync(params) {
+		if (!this.orchestrator) throw new Error("BackgroundAgentManager 未注入 AgentOrchestrator");
+		const taskId = `bg-${params.typeId}-${Date.now()}`;
+		const abortController = new AbortController();
+		const timeoutMs = params.timeoutMs ?? this.defaultTimeoutMs;
+		const runtime = {
+			taskId,
+			instanceId: "",
+			typeId: params.typeId,
+			description: params.description,
+			status: "pending",
+			createdAt: Date.now(),
+			abortController,
+			parentInstanceId: params.parentInstanceId
+		};
+		this.runtime.set(taskId, runtime);
+		this.store.save({
+			taskId,
+			instanceId: "",
+			typeId: params.typeId,
+			description: params.description,
+			status: "pending",
+			createdAt: runtime.createdAt,
+			parentAgentId: params.parentInstanceId
+		});
+		this.runAsync(taskId, params, abortController, timeoutMs).catch((err) => {
+			log$12.error("后台 Agent 意外崩溃", {
+				taskId,
+				error: String(err)
+			});
+			this.failTask(taskId, `意外错误: ${err instanceof Error ? err.message : String(err)}`);
+		});
+		return {
+			taskId,
+			instanceId: runtime.instanceId || "pending"
+		};
+	}
+	/**
+	* 实际执行后台 Agent 的逻辑
+	*/
+	async runAsync(taskId, params, abortController, timeoutMs) {
+		const runtime = this.runtime.get(taskId);
+		if (!runtime) return;
+		const orchestrator = this.orchestrator;
+		const messageBus = getAgentMessageBus();
+		const timeoutHandle = setTimeout(() => {
+			log$12.warn("后台 Agent 超时，自动取消", {
+				taskId,
+				timeoutMs
+			});
+			abortController.abort();
+		}, timeoutMs);
+		try {
+			const workerOptions = {
+				taskId,
+				timeoutMs,
+				inheritContext: params.inheritContext ?? false,
+				context: params.context,
+				parentInstanceId: params.parentInstanceId,
+				isolation: params.isolation,
+				wrapExecute: (execute) => runWithToolGuardContext({ isBackgroundAgent: true }, () => execute())
+			};
+			const result = await orchestrator.spawnWorker(params.typeId, params.description, workerOptions);
+			runtime.instanceId = result.instanceId;
+			runtime.status = result.status === "success" ? "completed" : "failed";
+			runtime.completedAt = Date.now();
+			if (result.error) runtime.error = result.error.message;
+			this.store.updateStatus(taskId, runtime.status, {
+				instanceId: result.instanceId,
+				completedAt: runtime.completedAt,
+				result: result.output ?? void 0,
+				error: runtime.error
+			});
+			if (params.parentInstanceId) {
+				const payload = JSON.stringify({
+					taskId,
+					instanceId: result.instanceId,
+					typeId: params.typeId,
+					status: result.status,
+					summary: result.output,
+					duration: result.duration,
+					tokenUsage: result.tokenUsage,
+					error: result.error
+				});
+				messageBus.publish(result.instanceId, params.parentInstanceId, {
+					type: "task_result",
+					payload,
+					taskId,
+					requiresResponse: false
+				});
+				log$12.info("后台 Agent 完成通知已发送", {
+					taskId,
+					instanceId: result.instanceId,
+					parentId: params.parentInstanceId,
+					status: result.status
+				});
+			}
+		} catch (err) {
+			const message = err instanceof Error ? err.message : String(err);
+			if (abortController.signal.aborted) this.failTask(taskId, `任务超时（${timeoutMs / 1e3}秒）`);
+			else this.failTask(taskId, message);
+		} finally {
+			clearTimeout(timeoutHandle);
+		}
+	}
+	/** 标记任务失败 */
+	failTask(taskId, error) {
+		const runtime = this.runtime.get(taskId);
+		if (runtime) {
+			runtime.status = "failed";
+			runtime.error = error;
+			runtime.completedAt = Date.now();
+		}
+		this.store.updateStatus(taskId, "failed", {
+			completedAt: Date.now(),
+			error
+		});
+		log$12.warn("后台 Agent 失败", {
+			taskId,
+			error
+		});
+	}
+	/**
+	* 获取后台任务状态
+	*/
+	getTask(taskId) {
+		return this.runtime.get(taskId);
+	}
+	/**
+	* 列出所有活跃（未完结）的后台任务
+	*/
+	listActive() {
+		return Array.from(this.runtime.values()).filter((t) => t.status === "pending" || t.status === "running");
+	}
+	/**
+	* 列出所有后台任务
+	*/
+	listAll() {
+		return Array.from(this.runtime.values());
+	}
+	/**
+	* 取消后台任务
+	*/
+	async cancel(taskId) {
+		const runtime = this.runtime.get(taskId);
+		if (!runtime) return false;
+		if (runtime.status === "completed" || runtime.status === "failed" || runtime.status === "cancelled") return false;
+		runtime.abortController.abort();
+		runtime.status = "cancelled";
+		runtime.completedAt = Date.now();
+		this.store.updateStatus(taskId, "cancelled", { completedAt: runtime.completedAt });
+		if (runtime.instanceId) try {
+			await getAgentInstanceManager().cancel(runtime.instanceId);
+		} catch {}
+		log$12.info("后台 Agent 已取消", { taskId });
+		return true;
+	}
+	/**
+	* 从持久化存储恢复（跨会话）
+	*/
+	restore() {
+		this.store.load();
+		const stale = this.store.cleanStale();
+		if (stale > 0) log$12.info("跨会话恢复：清理了过期后台任务", { count: stale });
+		const active = this.store.listActive();
+		for (const entry of active) this.store.updateStatus(entry.taskId, "failed", {
+			completedAt: Date.now(),
+			error: "会话终止导致任务丢失"
+		});
+		if (active.length > 0) log$12.info("跨会话恢复：标记活跃任务为 failed", { count: active.length });
+	}
+};
+/** 全局单例 */
+let globalBackgroundManager = null;
+/** 获取 BackgroundAgentManager 单例 */
+function getBackgroundAgentManager() {
+	if (!globalBackgroundManager) globalBackgroundManager = new BackgroundAgentManager();
+	return globalBackgroundManager;
+}
+
+//#endregion
+//#region src/cli/repl/tools/agent-tool.ts
+/**
+* 创建 AgentTool 工具注册
+*
+* @param orchestrator - AgentOrchestrator 实例
+* @returns ToolRegistration
+*/
+function createAgentTool(orchestrator) {
+	const registry = getAgentTypeRegistry();
+	return {
+		id: "AgentTool",
+		label: "创建 Agent",
+		defaultRisk: "high",
+		description: [
+			"创建特定类型的子 Agent 来执行独立任务。支持按 Agent 类型创建（推荐）或批量匿名创建（兼容旧版）。",
+			"",
+			"### 何时使用此工具",
+			"1. 需要分解复杂任务为多个独立子任务时",
+			"2. 需要特定类型的 Agent（研究员/编码助手/审查员/规划师）时",
+			"3. 多个子任务之间没有顺序依赖关系时可以并行创建",
+			"",
+			"### 何时不使用此工具",
+			"- 只有 1 个简单任务时（直接执行即可）",
+			"- 任务之间有严格的顺序依赖（必须串行执行）",
+			"- 任务非常简单（如读取单个文件）",
+			"",
+			"### 可用的 Agent 类型",
+			registry.list().map((t) => `- **${t.typeId}**: ${t.whenToUse}`).join("\n"),
+			"",
+			"### 参数说明",
+			"- **subagent_type**（推荐）: Agent 类型 ID，如 researcher/coder/reviewer/planner/general-purpose",
+			"- **description**: 发给子 Agent 的详细任务指令",
+			"- **run_in_background**: 是否后台运行（默认 false）。设为 true 时立即返回 taskId，Agent 在后台执行，完成后自动通知",
+			"- **inherit_context**: 是否继承父级上下文",
+			"- **agents**（已废弃，兼容旧版）: 批量匿名子 Agent 列表",
+			"- **context**: 可选背景摘要",
+			"",
+			"### 使用流程",
+			"1. 分析任务，确定需要的 Agent 类型",
+			"2. 为每个 Agent 编写详细的任务指令",
+			"3. 调用本工具创建 Agent（可多次调用创建多个不同类型的 Agent）",
+			"4. 同步模式：等待结果返回后整合汇总",
+			"5. 异步模式：立即返回 taskId，完成后通过收件箱接收通知"
+		].join("\n"),
+		parameters: {
+			type: "object",
+			properties: {
+				subagent_type: {
+					type: "string",
+					description: `Agent 类型 ID。可用类型: ${registry.list().map((t) => t.typeId).join(", ")}`
+				},
+				description: {
+					type: "string",
+					description: "发给子 Agent 的详细任务指令"
+				},
+				run_in_background: {
+					type: "boolean",
+					description: "是否后台运行（默认 false）。设为 true 时 fire-and-forget，Agent 后台执行完成后自动通知父 Agent",
+					default: false
+				},
+				inherit_context: {
+					type: "boolean",
+					description: "是否继承父级上下文",
+					default: false
+				},
+				agents: {
+					type: "array",
+					items: {
+						type: "object",
+						properties: {
+							id: {
+								type: "string",
+								description: "子任务唯一标识"
+							},
+							description: {
+								type: "string",
+								description: "发给子 Agent 的详细任务指令"
+							},
+							allowedTools: {
+								type: "array",
+								items: { type: "string" },
+								description: "可选工具白名单"
+							}
+						},
+						required: ["id", "description"]
+					},
+					description: "[已废弃] 批量匿名子 Agent 列表，请使用 subagent_type 参数"
+				},
+				context: {
+					type: "string",
+					description: "可选背景摘要，注入给每个子 Agent"
+				},
+				isolation: {
+					type: "string",
+					enum: ["worktree"],
+					description: "隔离模式。设为 \"worktree\" 时 Agent 在独立 git worktree 中运行，修改不影响主工作区"
+				}
+			},
+			required: ["description"]
+		},
+		execute: async (_toolCallId, params) => {
+			const p = params;
+			if (p.run_in_background && p.subagent_type && !p.agents) {
+				const { taskId, instanceId } = await getBackgroundAgentManager().executeAsync({
+					typeId: p.subagent_type,
+					description: p.description,
+					context: p.context,
+					inheritContext: p.inherit_context,
+					...p.isolation ? { isolation: p.isolation } : {}
+				});
+				return {
+					content: [{
+						type: "text",
+						text: [
+							`🚀 **${p.subagent_type}** 已作为后台任务启动`,
+							"",
+							`- 任务 ID: \`${taskId}\``,
+							`- 实例 ID: \`${instanceId}\``,
+							`- 状态: 后台运行中`,
+							"",
+							"Agent 完成后将自动通知。可使用 BackgroundTask 工具查询状态。"
+						].join("\n")
+					}],
+					details: {
+						taskId,
+						instanceId,
+						status: "async_launched"
+					}
+				};
+			}
+			if (p.run_in_background && !p.subagent_type) return { content: [{
+				type: "text",
+				text: "后台运行模式需要指定 subagent_type 参数。请选择一种 Agent 类型。"
+			}] };
+			if (p.subagent_type && !p.agents) {
+				const result = await orchestrator.spawnWorker(p.subagent_type, p.description, {
+					...p.context != null ? { context: p.context } : {},
+					...p.inherit_context != null ? { inheritContext: p.inherit_context } : {},
+					...p.isolation ? { isolation: p.isolation } : {}
+				});
+				return {
+					content: [{
+						type: "text",
+						text: result.status === "success" ? `✅ **${result.typeId}** 执行成功 (${(result.duration / 1e3).toFixed(1)}s)\n\n${result.output ?? "（无输出）"}` : `❌ **${result.typeId}** 执行失败: ${result.error?.message ?? "未知错误"}`
+					}],
+					details: result
+				};
+			}
+			if (p.agents && p.agents.length > 0) {
+				const results = await orchestrator.spawnFlat(p.agents, p.context);
+				return {
+					content: [{
+						type: "text",
+						text: results.summary
+					}],
+					details: results
+				};
+			}
+			return { content: [{
+				type: "text",
+				text: "请指定 subagent_type（推荐的 Agent 类型）或 agents（已废弃的批量参数）。"
+			}] };
+		}
+	};
+}
+
+//#endregion
+//#region src/core/question/types.ts
+/** 创建 Deferred */
+function createDeferred() {
+	let resolve;
+	let reject;
+	let isSettled = false;
+	return {
+		promise: new Promise((res, rej) => {
+			resolve = (value) => {
+				if (!isSettled) {
+					isSettled = true;
+					res(value);
+				}
+			};
+			reject = (error) => {
+				if (!isSettled) {
+					isSettled = true;
+					rej(error);
+				}
+			};
+		}),
+		resolve,
+		reject,
+		isSettled
+	};
+}
+
+//#endregion
+//#region src/core/question/question-manager.ts
+/**
+* 问题管理器
+*
+* 基于 Provider 模式实现异步阻塞提问。
+* TUI 层通过 setProvider() 注入提问 UI 实现，
+* Agent 工具执行流通过 ask() 被阻塞等待用户回答。
+*
+* 在 headless 模式（无 provider）下自动报错。
+*
+* @module core/question/question-manager
+*/
+const log$11 = logger.child("question-manager");
+/** 问题超时时间（5 分钟） */
+const QUESTION_TIMEOUT_MS = 300 * 1e3;
+var QuestionManager = class {
+	provider = null;
+	pending = /* @__PURE__ */ new Map();
+	constructor(provider) {
+		if (provider) this.provider = provider;
+	}
+	/**
+	* 设置问题提供者（由 TUI 层注入）
+	*/
+	setProvider(provider) {
+		this.provider = provider;
+	}
+	/**
+	* 检查是否有问题提供者
+	*/
+	hasProvider() {
+		return this.provider !== null;
+	}
+	/**
+	* 向用户提问并等待回答
+	*
+	* 阻塞当前执行流，等待用户通过 TUI 做出回答。
+	* 如果无 provider（headless 模式），抛出错误。
+	*
+	* @param params - 问题参数
+	* @returns 用户回答结果
+	*/
+	async ask(params) {
+		if (!this.provider) throw new Error("当前环境不支持交互式提问（headless 模式）");
+		const requestId = `q-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+		const deferred = createDeferred();
+		deferred.promise.catch(() => {});
+		const entry = {
+			requestId,
+			questions: params.questions,
+			deferred,
+			createdAt: Date.now()
+		};
+		this.pending.set(requestId, entry);
+		eventBus.emit("question:asked", {
+			requestId,
+			questionCount: params.questions.length
+		});
+		log$11.debug("提问已发出", {
+			requestId,
+			questionCount: params.questions.length
+		});
+		const timeout = setTimeout(() => {
+			if (!deferred.isSettled) {
+				log$11.warn("提问超时，自动取消", { requestId });
+				deferred.reject(/* @__PURE__ */ new Error("提问超时，用户未在 5 分钟内回答"));
+				this.pending.delete(requestId);
+				eventBus.emit("question:timeout", { requestId });
+			}
+		}, QUESTION_TIMEOUT_MS);
+		try {
+			const result = await this.provider.showQuestions(params);
+			clearTimeout(timeout);
+			deferred.resolve(result);
+			eventBus.emit("question:answered", {
+				requestId,
+				answerCount: Object.keys(result.answers).length
+			});
+			log$11.debug("提问已回答", { requestId });
+			return result;
+		} catch (err) {
+			clearTimeout(timeout);
+			if (!deferred.isSettled) deferred.reject(err instanceof Error ? err : new Error(String(err)));
+			eventBus.emit("question:cancelled", {
+				requestId,
+				reason: err instanceof Error ? err.message : String(err)
+			});
+			log$11.debug("提问已取消", {
+				requestId,
+				error: err instanceof Error ? err.message : String(err)
+			});
+			throw err;
+		} finally {
+			this.pending.delete(requestId);
+		}
+	}
+	/**
+	* 获取待处理的问题请求
+	*/
+	getPending(requestId) {
+		return this.pending.get(requestId);
+	}
+	/**
+	* 拒绝所有待处理的问题（用于 session 关闭时清理）
+	*/
+	rejectAll(error) {
+		const count = this.pending.size;
+		for (const [, entry] of this.pending) if (!entry.deferred.isSettled) entry.deferred.reject(error);
+		this.pending.clear();
+		if (count > 0) log$11.debug("已清理所有待处理问题", { count });
+	}
+};
+let globalQuestionManager = null;
+/**
+* 获取全局 QuestionManager 单例
+*/
+function getQuestionManager() {
+	if (!globalQuestionManager) globalQuestionManager = new QuestionManager();
+	return globalQuestionManager;
+}
+
+//#endregion
+//#region src/cli/repl/tools/ask-user-question.ts
+/**
+* 创建 AskUserQuestion 工具注册
+*/
+function createAskUserQuestionTool() {
+	return {
+		id: "AskUserQuestion",
+		label: "向用户提问",
+		defaultRisk: "medium",
+		checkPermission: () => ({
+			risk: "medium",
+			requiresApproval: false,
+			reason: "AskUserQuestion 使用独立的交互式 UI，不走 ToolGuard 审批路径"
+		}),
+		description: [
+			"向用户提问以获取决策指导。当需要在多个可行方案之间选择、进行技术选型、",
+			"或需要用户偏好时使用此工具。",
+			"",
+			"### 何时使用",
+			"- 需要在多个可行方案之间做出选择时",
+			"- 需要技术选型、架构决策等需要用户判断的问题",
+			"- Plan Mode 中分析完方案后需要用户指定方向时",
+			"- 需要明确用户偏好以实现个性化功能时",
+			"",
+			"### 何时不使用",
+			"- 可以通过代码分析直接确定的结论",
+			"- 简单确认（直接回复文本询问即可）",
+			"- 已有明确最佳实践的问题",
+			"",
+			"### 提问原则",
+			"- 每个问题提供 2-4 个具体、互斥的选项",
+			"- header 字段控制在 12 个字符以内",
+			"- 使用 multiSelect: true 表示多选",
+			"- 推荐选项放在第一位并加 \"(Recommended)\" 后缀",
+			"- 如果选项有代码示例/配置对比，可在 preview 字段中提供（markdown 格式）",
+			"- 用户始终可以选择 \"Other\" 输入自定义答案"
+		].join("\n"),
+		parameters: {
+			type: "object",
+			properties: { questions: {
+				type: "array",
+				items: {
+					type: "object",
+					properties: {
+						question: {
+							type: "string",
+							description: "完整问题文本，以问号结尾"
+						},
+						header: {
+							type: "string",
+							description: "短标签，用于 Tab 导航（最多 12 个字符）"
+						},
+						options: {
+							type: "array",
+							items: {
+								type: "object",
+								properties: {
+									label: {
+										type: "string",
+										description: "选项显示文本（1-5 个词）"
+									},
+									description: {
+										type: "string",
+										description: "选项说明"
+									},
+									preview: {
+										type: "string",
+										description: "可选的预览内容（markdown 格式）。当任一选项有 preview 时，UI 切换为左右分栏布局"
+									}
+								},
+								required: ["label", "description"]
+							},
+							minItems: 2,
+							maxItems: 4,
+							description: "2-4 个选项"
+						},
+						multiSelect: {
+							type: "boolean",
+							description: "是否允许多选",
+							default: false
+						}
+					},
+					required: [
+						"question",
+						"header",
+						"options",
+						"multiSelect"
+					]
+				},
+				minItems: 1,
+				maxItems: 4,
+				description: "1-4 个问题"
+			} },
+			required: ["questions"]
+		},
+		execute: async (_toolCallId, params) => {
+			const p = params;
+			if (getToolGuardContext()?.isBackgroundAgent) throw new SecurityBlockedError("后台 Agent 不支持交互式提问（AskUserQuestion）", "AskUserQuestion", "medium", "后台 Agent 无用户交互界面");
+			if (!p.questions || p.questions.length === 0) return {
+				content: [{
+					type: "text",
+					text: "错误: 至少需要 1 个问题"
+				}],
+				details: {
+					error: true,
+					message: "questions 数组不能为空"
+				}
+			};
+			for (let i = 0; i < p.questions.length; i++) {
+				const q = p.questions[i];
+				if (q.options.length < 2) return {
+					content: [{
+						type: "text",
+						text: `错误: 问题 "${q.header}" 至少需要 2 个选项`
+					}],
+					details: {
+						error: true,
+						message: "选项数量不足",
+						questionIndex: i
+					}
+				};
+				if (q.header.length > 12) return {
+					content: [{
+						type: "text",
+						text: `错误: 问题 "${q.header}" 的 header 超过 12 个字符限制`
 					}],
-					details: results
+					details: {
+						error: true,
+						message: "header 过长",
+						questionIndex: i
+					}
+				};
+			}
+			try {
+				const questionManager = getQuestionManager();
+				if (!questionManager.hasProvider()) return {
+					content: [{
+						type: "text",
+						text: "错误: 当前环境不支持交互式提问（headless 模式或未初始化 UI）"
+					}],
+					details: {
+						error: true,
+						message: "无 QuestionProvider"
+					}
+				};
+				const result = await questionManager.ask(p);
+				return {
+					content: [{
+						type: "text",
+						text: `用户已回答你的问题：\n${result.questions.map((q) => {
+							const answer = result.answers[q.question];
+							const answerStr = Array.isArray(answer) ? answer.join(", ") : answer ?? "(未回答)";
+							return `"${q.question}" → "${answerStr}"`;
+						}).join("\n")}\n\n你可以根据这些答案继续执行。`
+					}],
+					details: {
+						questions: result.questions,
+						answers: result.answers,
+						annotations: result.annotations
+					}
+				};
+			} catch (err) {
+				const message = err instanceof Error ? err.message : String(err);
+				return {
+					content: [{
+						type: "text",
+						text: `提问被取消: ${message}`
+					}],
+					details: {
+						error: true,
+						message,
+						cancelled: true
+					}
 				};
 			}
-			return { content: [{
-				type: "text",
-				text: "请指定 subagent_type（推荐的 Agent 类型）或 agents（已废弃的批量参数）。"
-			}] };
 		}
 	};
 }
@@ -4920,6 +6404,257 @@ async function buildStatusResult(scheduler) {
 	};
 }
 
+//#endregion
+//#region src/cli/repl/tools/enter-worktree.ts
+/**
+* 创建 EnterWorktree 工具注册
+*/
+function createEnterWorktreeTool(worktreeManager) {
+	return {
+		id: "EnterWorktree",
+		label: "进入工作树",
+		description: [
+			"创建 git worktree 并切换当前会话的工作目录到隔离环境。",
+			"",
+			"### 何时使用此工具",
+			"- 需要在独立的工作区中进行代码修改时",
+			"- 不希望当前修改影响主工作区时",
+			"- Agent 需要隔离的文件系统环境时",
+			"",
+			"### 参数",
+			"- **name**（可选）: worktree 名称，用于标识和后续管理",
+			"",
+			"### 注意事项",
+			"- 进入 worktree 后所有文件操作和 Shell 命令都在 worktree 中执行",
+			"- 使用 ExitWorktree 工具退出 worktree"
+		].join("\n"),
+		defaultRisk: "high",
+		parameters: {
+			type: "object",
+			properties: { name: {
+				type: "string",
+				description: "worktree 名称（可选，用于标识）"
+			} },
+			required: []
+		},
+		execute: async (_toolCallId, params) => {
+			const name = params.name;
+			try {
+				const slug = name ?? `manual-${Date.now()}`;
+				const info = await worktreeManager.create({
+					slug,
+					createdBy: "user"
+				});
+				process.chdir(info.worktreePath);
+				return {
+					content: [{
+						type: "text",
+						text: [
+							"**已进入 worktree 隔离环境**",
+							"",
+							`- ID: \`${info.id}\``,
+							`- 路径: \`${info.worktreePath}\``,
+							`- 分支: \`${info.branchName}\``,
+							"",
+							"后续文件操作和 Shell 命令都将在 worktree 中执行。",
+							"使用 ExitWorktree 工具退出。"
+						].join("\n")
+					}],
+					details: {
+						worktreeId: info.id,
+						worktreePath: info.worktreePath,
+						branchName: info.branchName
+					}
+				};
+			} catch (err) {
+				const message = err instanceof Error ? err.message : String(err);
+				return {
+					content: [{
+						type: "text",
+						text: `创建 worktree 失败: ${message}`
+					}],
+					details: { error: message }
+				};
+			}
+		}
+	};
+}
+
+//#endregion
+//#region src/core/worktree/worktree-context.ts
+/**
+* Worktree 运行时上下文
+*
+* 基于 AsyncLocalStorage 在整个工具调用链中传递 worktree 上下文。
+* 文件操作和 Shell 工具通过 resolveWorktreePath() 自动映射路径到 worktree。
+*
+* @module core/worktree
+*/
+const worktreeStorage = new AsyncLocalStorage();
+/** 获取当前 worktree 上下文 */
+function getWorktreeContext() {
+	return worktreeStorage.getStore();
+}
+/** 在 worktree 上下文中执行回调 */
+async function runInWorktree(context, fn) {
+	return worktreeStorage.run(context, fn);
+}
+/**
+* 将路径解析到当前 worktree
+*
+* 解析规则：
+* - 无 worktree 上下文 → 直接 resolve 返回
+* - 相对路径 → 在 worktree 根目录下解析
+* - 绝对路径（属于原项目目录） → 映射到 worktree 对应路径
+* - 绝对路径（不在项目目录内） → 保持原样
+*/
+function resolveWorktreePath(originalPath) {
+	const ctx = worktreeStorage.getStore();
+	if (!ctx) return resolve(originalPath);
+	if (!isAbsolute(originalPath)) return resolve(ctx.worktreePath, originalPath);
+	const normalizedOriginal = resolve(originalPath);
+	const normalizedProjectRoot = resolve(ctx.originalPath);
+	if (normalizedOriginal.startsWith(normalizedProjectRoot)) {
+		const relPath = relative(normalizedProjectRoot, normalizedOriginal);
+		return resolve(ctx.worktreePath, relPath);
+	}
+	return normalizedOriginal;
+}
+/**
+* 获取当前有效的工作目录
+*
+* 在 worktree 上下文中返回 worktree 路径，否则返回 process.cwd()
+*/
+function resolveWorkdir() {
+	return worktreeStorage.getStore()?.worktreePath ?? process.cwd();
+}
+
+//#endregion
+//#region src/cli/repl/tools/exit-worktree.ts
+/**
+* ExitWorktree 工具
+*
+* 退出当前 worktree 隔离环境。
+* 支持 keep（保留 worktree）和 remove（删除 worktree）两种模式。
+*
+* @module cli/repl/tools
+*/
+/**
+* 创建 ExitWorktree 工具注册
+*/
+function createExitWorktreeTool(worktreeManager) {
+	return {
+		id: "ExitWorktree",
+		label: "退出工作树",
+		description: [
+			"退出当前 worktree 隔离环境。",
+			"",
+			"### 参数",
+			"- **action**: \"keep\" 保留 worktree，\"remove\" 删除 worktree",
+			"- **discard_changes**: remove 时是否强制丢弃未提交变更（默认 false）",
+			"",
+			"### 安全门控",
+			"- remove 模式：如果 worktree 有未提交变更且 discard_changes=false，操作将被拒绝",
+			"- keep 模式：直接退出 worktree，worktree 保留在磁盘上"
+		].join("\n"),
+		defaultRisk: "high",
+		parameters: {
+			type: "object",
+			properties: {
+				action: {
+					type: "string",
+					enum: ["keep", "remove"],
+					description: "keep=保留 worktree 并退出，remove=删除 worktree 并退出"
+				},
+				discard_changes: {
+					type: "boolean",
+					description: "remove 时是否强制丢弃未提交变更（默认 false）。设为 true 会强制删除 worktree"
+				}
+			},
+			required: ["action"]
+		},
+		execute: async (_toolCallId, params) => {
+			const p = params;
+			const ctx = getWorktreeContext();
+			if (!ctx) return { content: [{
+				type: "text",
+				text: "当前不处于 worktree 隔离环境。无需退出。"
+			}] };
+			try {
+				if (p.action === "keep") {
+					if (existsSync(ctx.originalPath)) process.chdir(ctx.originalPath);
+					return {
+						content: [{
+							type: "text",
+							text: [
+								"**已退出 worktree 隔离环境（保留 worktree）**",
+								"",
+								`- Worktree ID: \`${ctx.worktreeId}\``,
+								`- Worktree 路径: \`${ctx.worktreePath}\``,
+								`- 已切换回: \`${ctx.originalPath}\``
+							].join("\n")
+						}],
+						details: {
+							action: "keep",
+							worktreeId: ctx.worktreeId
+						}
+					};
+				}
+				try {
+					await worktreeManager.remove(ctx.worktreeId, p.discard_changes);
+				} catch (err) {
+					const message = err instanceof Error ? err.message : String(err);
+					if (!p.discard_changes && message.includes("changes")) return {
+						content: [{
+							type: "text",
+							text: [
+								"**无法删除 worktree：存在未提交的变更**",
+								"",
+								`错误: ${message}`,
+								"",
+								"请选择:",
+								"- 设置 `discard_changes: true` 强制删除",
+								"- 或使用 `action: \"keep\"` 保留 worktree"
+							].join("\n")
+						}],
+						details: {
+							action: "remove",
+							error: "has_changes",
+							worktreeId: ctx.worktreeId
+						}
+					};
+					throw err;
+				}
+				if (existsSync(ctx.originalPath)) process.chdir(ctx.originalPath);
+				return {
+					content: [{
+						type: "text",
+						text: [
+							"**已退出 worktree 隔离环境（已删除 worktree）**",
+							"",
+							`- Worktree ID: \`${ctx.worktreeId}\``,
+							`- 已切换回: \`${ctx.originalPath}\``
+						].join("\n")
+					}],
+					details: {
+						action: "remove",
+						worktreeId: ctx.worktreeId
+					}
+				};
+			} catch (err) {
+				const message = err instanceof Error ? err.message : String(err);
+				return {
+					content: [{
+						type: "text",
+						text: `退出 worktree 失败: ${message}`
+					}],
+					details: { error: message }
+				};
+			}
+		}
+	};
+}
+
 //#endregion
 //#region src/cli/repl/tools/file-security.ts
 /**
@@ -5308,7 +7043,7 @@ function createEditFileTool() {
 					error: "old_string 与 new_string 相同"
 				}
 			};
-			const pathResult = validateFilePath(params.file_path);
+			const pathResult = validateFilePath(resolveWorktreePath(params.file_path));
 			if (!pathResult.valid) {
 				const details = {
 					filePath: params.file_path,
@@ -5532,7 +7267,7 @@ function createGlobTool() {
 		},
 		async execute(_toolCallId, params) {
 			const startTime = Date.now();
-			const searchPath = resolve(params.path ?? process.cwd());
+			const searchPath = resolveWorktreePath(params.path ?? process.cwd());
 			try {
 				const matches = globSync(params.pattern, searchPath);
 				const elapsedMs = Date.now() - startTime;
@@ -5748,7 +7483,7 @@ function createGrepTool() {
 		},
 		async execute(_toolCallId, params) {
 			const startTime = Date.now();
-			const searchPath = resolve(params.path ?? process.cwd());
+			const searchPath = resolveWorktreePath(params.path ?? process.cwd());
 			const outputMode = params.output_mode ?? "content";
 			const ignoreCase = params["-i"] === true;
 			const contextBefore = params["-B"] ?? params.context ?? 0;
@@ -5980,7 +7715,7 @@ function createWriteFileTool() {
 		checkPermission: checkFilePermission,
 		async execute(_toolCallId, params) {
 			const startTime = Date.now();
-			const pathResult = validateFilePath(params.file_path);
+			const pathResult = validateFilePath(resolveWorktreePath(params.file_path));
 			if (!pathResult.valid) {
 				const details = {
 					type: "create",
@@ -7085,7 +8820,7 @@ function createExecTool() {
 					durationMs: Date.now() - startTime
 				}
 			};
-			const workdirResult = validateWorkdir(params.workdir);
+			const workdirResult = validateWorkdir(params.workdir ?? resolveWorkdir());
 			if (!workdirResult.valid) return {
 				content: [{
 					type: "text",
@@ -9073,36 +10808,399 @@ function createWebSearchTool(webConfig) {
 			}
 			let results;
 			try {
-				results = await provider.search(query, {
-					maxResults: numResults,
-					language
-				}, providerConfig, signal);
+				results = await provider.search(query, {
+					maxResults: numResults,
+					language
+				}, providerConfig, signal);
+			} catch (err) {
+				if (err instanceof Error && err.message.includes("quota")) throw new WebError("WEB_SEARCH_QUOTA_EXCEEDED", err.message, { provider: providerName });
+				throw new WebError("WEB_SEARCH_FAILED", `搜索失败: ${err instanceof Error ? err.message : String(err)}`, {
+					provider: providerName,
+					query
+				});
+			}
+			const text = formatResults(results, query, provider.label);
+			cache.set(cacheKey, text);
+			const details = {
+				query,
+				provider: providerName,
+				resultCount: results.length,
+				cached: false,
+				elapsedMs: Date.now() - startTime
+			};
+			return {
+				content: [{
+					type: "text",
+					text
+				}],
+				details
+			};
+		}
+	};
+}
+
+//#endregion
+//#region src/core/worktree/types.ts
+/** Worktree 操作错误 */
+var WorktreeError = class extends Error {
+	code;
+	constructor(message, code) {
+		super(message);
+		this.name = "WorktreeError";
+		this.code = code;
+	}
+};
+
+//#endregion
+//#region src/core/worktree/worktree-store.ts
+/**
+* Worktree 持久化存储
+*
+* 将 worktree 记录持久化到磁盘（~/.zapmyco/worktrees/ 目录），
+* 支持跨会话恢复和过期清理。
+*
+* @module core/worktree
+*/
+/** 获取默认存储目录 */
+function getDefaultBaseDir() {
+	return join(__require("node:os").homedir(), ".zapmyco", "worktrees");
+}
+/**
+* Worktree 持久化存储
+*/
+var WorktreeStore = class {
+	baseDir;
+	cache = /* @__PURE__ */ new Map();
+	loaded = false;
+	constructor(baseDir) {
+		this.baseDir = baseDir ?? getDefaultBaseDir();
+	}
+	/** 获取存储目录 */
+	getBaseDir() {
+		return this.baseDir;
+	}
+	/** 保存记录到磁盘 */
+	save(record) {
+		this.ensureDir();
+		this.cache.set(record.id, record);
+		writeFileSync(this.getFilePath(record.id), JSON.stringify(record, null, 2), "utf-8");
+	}
+	/** 更新记录状态 */
+	updateStatus(id, status) {
+		const record = this.cache.get(id);
+		if (record) {
+			record.status = status;
+			this.cache.set(id, record);
+			this.save(record);
+		}
+	}
+	/** 删除记录（从缓存和磁盘） */
+	delete(id) {
+		this.cache.delete(id);
+		const filePath = this.getFilePath(id);
+		try {
+			if (existsSync(filePath)) unlinkSync(filePath);
+		} catch {}
+	}
+	/** 获取单个记录 */
+	get(id) {
+		this.ensureLoaded();
+		return this.cache.get(id);
+	}
+	/** 列出所有活跃记录 */
+	listActive() {
+		this.ensureLoaded();
+		return Array.from(this.cache.values()).filter((r) => r.status === "active");
+	}
+	/** 列出所有记录 */
+	listAll() {
+		this.ensureLoaded();
+		return Array.from(this.cache.values());
+	}
+	/** 从磁盘加载所有记录 */
+	load() {
+		this.ensureDir();
+		this.cache.clear();
+		try {
+			const files = readdirSync(this.baseDir).filter((f) => f.endsWith(".json"));
+			for (const file of files) try {
+				const content = readFileSync(join(this.baseDir, file), "utf-8");
+				const record = JSON.parse(content);
+				if (record.id && record.worktreePath) this.cache.set(record.id, record);
+			} catch {}
+		} catch {}
+		this.loaded = true;
+		return Array.from(this.cache.values());
+	}
+	/** 清理过期记录文件 */
+	cleanExpired(expireAfterMs) {
+		this.ensureLoaded();
+		let cleaned = 0;
+		const now = Date.now();
+		for (const [id, record] of this.cache) if (record.status === "expired") {
+			this.delete(id);
+			cleaned++;
+		} else if (record.status === "active" && now - record.createdAt > expireAfterMs) {
+			record.status = "expired";
+			this.save(record);
+			cleaned++;
+		}
+		return cleaned;
+	}
+	/** 确保目录存在 */
+	ensureDir() {
+		if (!existsSync(this.baseDir)) mkdirSync(this.baseDir, { recursive: true });
+	}
+	/** 确保已加载 */
+	ensureLoaded() {
+		if (!this.loaded) this.load();
+	}
+	/** 获取记录文件路径 */
+	getFilePath(id) {
+		const safeId = id.replace(/[^a-zA-Z0-9_-]/g, "_");
+		return join(this.baseDir, `${safeId}.json`);
+	}
+};
+
+//#endregion
+//#region src/core/worktree/worktree-manager.ts
+/**
+* Worktree 管理器
+*
+* 负责 git worktree 的完整生命周期管理：
+* - 创建隔离 worktree
+* - 执行后自动清理（无变更）或保留（有变更）
+* - 过期 worktree 清理
+*
+* 通过 child_process.execFile 调用 git 命令，不引入额外依赖。
+*
+* @module core/worktree
+*/
+const execFileAsync = promisify(execFile);
+const log$10 = logger.child("worktree-manager");
+let globalWorktreeManager = null;
+/** 获取全局 WorktreeManager 实例 */
+function getWorktreeManager() {
+	return globalWorktreeManager ?? void 0;
+}
+/** 设置全局 WorktreeManager 实例 */
+function setWorktreeManager(manager) {
+	globalWorktreeManager = manager;
+}
+var WorktreeManager = class {
+	config;
+	store;
+	activeWorktrees = /* @__PURE__ */ new Map();
+	constructor(config) {
+		this.config = config;
+		this.store = new WorktreeStore(config.baseDir);
+		this.store.load();
+	}
+	/**
+	* 创建新的 git worktree
+	*/
+	async create(options) {
+		if (!this.config.enabled) throw new WorktreeError("Worktree 功能未启用", "DISABLED");
+		const timestamp = Date.now();
+		const branchName = `zapmyco-${options.slug}-${timestamp}`;
+		const dirName = `${options.slug}-${timestamp}`;
+		const worktreePath = join(this.config.baseDir, dirName);
+		let gitRoot;
+		try {
+			const { stdout } = await execFileAsync("git", ["rev-parse", "--show-toplevel"], { timeout: 5e3 });
+			gitRoot = stdout.trim();
+		} catch {
+			throw new WorktreeError("无法确定 git 仓库根目录，请确保在 git 仓库中运行", "NOT_GIT_REPO");
+		}
+		try {
+			log$10.info("创建 worktree", {
+				branchName,
+				worktreePath,
+				gitRoot
+			});
+			await execFileAsync("git", [
+				"worktree",
+				"add",
+				"--detach",
+				worktreePath
+			], {
+				cwd: gitRoot,
+				timeout: 3e4
+			});
+		} catch (err) {
+			throw new WorktreeError(`创建 worktree 失败: ${err instanceof Error ? err.message : String(err)}`, "CREATE_FAILED");
+		}
+		try {
+			await execFileAsync("git", [
+				"checkout",
+				"-b",
+				branchName
+			], {
+				cwd: worktreePath,
+				timeout: 1e4
+			});
+		} catch (err) {
+			const msg = err instanceof Error ? err.message : String(err);
+			log$10.warn("创建分支失败，清理 worktree", {
+				branchName,
+				error: msg
+			});
+			try {
+				await this.removeByPath(worktreePath, branchName, true);
+			} catch {}
+			throw new WorktreeError(`在 worktree 中创建分支失败: ${msg}`, "BRANCH_FAILED");
+		}
+		const info = {
+			id: `${options.slug}-${timestamp}`,
+			worktreePath,
+			branchName,
+			originalPath: gitRoot,
+			createdAt: timestamp,
+			createdBy: options.createdBy
+		};
+		this.activeWorktrees.set(info.id, info);
+		this.store.save({
+			id: info.id,
+			worktreePath: info.worktreePath,
+			branchName: info.branchName,
+			originalPath: info.originalPath,
+			createdAt: info.createdAt,
+			createdBy: info.createdBy,
+			status: "active"
+		});
+		log$10.info("Worktree 创建成功", {
+			id: info.id,
+			path: worktreePath
+		});
+		return info;
+	}
+	/**
+	* 删除指定 worktree
+	*/
+	async remove(id, discardChanges) {
+		const info = this.activeWorktrees.get(id);
+		if (!info) {
+			log$10.warn("尝试删除不存在的 worktree", { id });
+			return;
+		}
+		await this.removeByPath(info.worktreePath, info.branchName, discardChanges);
+		this.activeWorktrees.delete(id);
+		this.store.delete(id);
+		log$10.info("Worktree 已删除", { id });
+	}
+	/**
+	* 通过路径删除 worktree（内部方法）
+	*/
+	async removeByPath(worktreePath, branchName, discardChanges) {
+		if (!existsSync(worktreePath)) {
+			try {
+				await execFileAsync("git", ["worktree", "prune"], { timeout: 1e4 });
+			} catch {}
+			return;
+		}
+		const args = ["worktree", "remove"];
+		if (discardChanges) args.push("--force");
+		args.push(worktreePath);
+		try {
+			await execFileAsync("git", args, { timeout: 15e3 });
+		} catch (err) {
+			const msg = err instanceof Error ? err.message : String(err);
+			log$10.warn("git worktree remove 失败", {
+				worktreePath,
+				error: msg
+			});
+		}
+		try {
+			await execFileAsync("git", [
+				"branch",
+				"-D",
+				branchName
+			], { timeout: 1e4 });
+		} catch {}
+		try {
+			await execFileAsync("git", ["worktree", "prune"], { timeout: 1e4 });
+		} catch {}
+	}
+	/**
+	* 检查 worktree 是否有变更，无变更则自动清理
+	*/
+	async autoCleanIfNoChanges(id) {
+		const info = this.activeWorktrees.get(id);
+		if (!info) return { cleaned: true };
+		if (!this.config.autoCleanNoChanges) return {
+			cleaned: false,
+			worktreePath: info.worktreePath
+		};
+		if (!existsSync(info.worktreePath)) {
+			this.activeWorktrees.delete(id);
+			this.store.delete(id);
+			return { cleaned: true };
+		}
+		if (!await this.checkHasChanges(info.worktreePath)) {
+			await this.remove(id, true);
+			return { cleaned: true };
+		}
+		log$10.info("Worktree 有变更，保留", {
+			id,
+			path: info.worktreePath
+		});
+		return {
+			cleaned: false,
+			worktreePath: info.worktreePath
+		};
+	}
+	/**
+	* 检查 worktree 中是否有未提交变更
+	*/
+	async checkHasChanges(worktreePath) {
+		try {
+			const { stdout } = await execFileAsync("git", ["status", "--porcelain"], {
+				cwd: worktreePath,
+				timeout: 5e3
+			});
+			return stdout.trim().length > 0;
+		} catch {
+			return true;
+		}
+	}
+	/**
+	* 清理过期的 worktree
+	*/
+	async cleanExpired() {
+		const now = Date.now();
+		let cleaned = 0;
+		this.store.cleanExpired(this.config.expireAfterMs);
+		const allRecords = this.store.listAll();
+		for (const record of allRecords) if (record.status === "expired" || now - record.createdAt > this.config.expireAfterMs) {
+			if (existsSync(record.worktreePath)) try {
+				await this.removeByPath(record.worktreePath, record.branchName, true);
+				cleaned++;
 			} catch (err) {
-				if (err instanceof Error && err.message.includes("quota")) throw new WebError("WEB_SEARCH_QUOTA_EXCEEDED", err.message, { provider: providerName });
-				throw new WebError("WEB_SEARCH_FAILED", `搜索失败: ${err instanceof Error ? err.message : String(err)}`, {
-					provider: providerName,
-					query
+				log$10.warn("过期 worktree 清理失败", {
+					id: record.id,
+					path: record.worktreePath,
+					error: err instanceof Error ? err.message : String(err)
 				});
 			}
-			const text = formatResults(results, query, provider.label);
-			cache.set(cacheKey, text);
-			const details = {
-				query,
-				provider: providerName,
-				resultCount: results.length,
-				cached: false,
-				elapsedMs: Date.now() - startTime
-			};
-			return {
-				content: [{
-					type: "text",
-					text
-				}],
-				details
-			};
+			this.activeWorktrees.delete(record.id);
+			this.store.delete(record.id);
 		}
-	};
-}
+		if (cleaned > 0) log$10.info("过期 worktree 清理完成", { cleaned });
+		return cleaned;
+	}
+	listActive() {
+		return Array.from(this.activeWorktrees.values());
+	}
+	getWorktree(id) {
+		return this.activeWorktrees.get(id);
+	}
+	getConfig() {
+		return { ...this.config };
+	}
+	getStore() {
+		return this.store;
+	}
+};
 
 //#endregion
 //#region src/core/agent-team/types.ts
@@ -9146,7 +11244,7 @@ const AGENT_STANDARD_TOOLS = [
 *
 * @module core/agent-team
 */
-const log$10 = logger.child("agent-factory");
+const log$9 = logger.child("agent-factory");
 /**
 * 创建 Agent 实例
 *
@@ -9178,7 +11276,7 @@ function createAgentFromType(definition, instance, parentAgent, availableTools,
 	const tools = resolveTools(definition, availableTools, instance.depth, config);
 	agent.registerTools(tools);
 	agent.systemPromptOverride = buildSystemPrompt(definition, instance.task.description, config);
-	log$10.debug("创建 Agent 实例", {
+	log$9.debug("创建 Agent 实例", {
 		typeId: definition.typeId,
 		instanceId: instance.instanceId,
 		depth: instance.depth,
@@ -9262,7 +11360,7 @@ function shareParentResources(subAgent, parentAgent) {
 
 //#endregion
 //#region src/core/agent-team/agent-result-aggregator.ts
-const log$9 = logger.child("agent-result-aggregator");
+const log$8 = logger.child("agent-result-aggregator");
 /** 零值 TokenUsage */
 const ZERO_TOKEN = {
 	inputTokens: 0,
@@ -9288,7 +11386,7 @@ function aggregateResults(teamId, workerResults) {
 		estimatedCostUsd: sum.estimatedCostUsd + (r.tokenUsage?.estimatedCostUsd ?? 0)
 	}), { ...ZERO_TOKEN });
 	const summary = buildTeamSummary(workerResults);
-	log$9.debug("Team 结果聚合完成", {
+	log$8.debug("Team 结果聚合完成", {
 		teamId,
 		total: workerResults.length,
 		succeeded,
@@ -9366,7 +11464,7 @@ function escapeMarkdownTable(text) {
 
 //#endregion
 //#region src/core/agent-team/agent-orchestrator.ts
-const log$8 = logger.child("agent-orchestrator");
+const log$7 = logger.child("agent-orchestrator");
 /**
 * Agent 编排器
 *
@@ -9399,7 +11497,7 @@ var AgentOrchestrator = class {
 		const startTime = Date.now();
 		const defaultType = getAgentTypeRegistry().getDefault();
 		if (!defaultType) throw new Error("无法获取默认 Agent 类型（general-purpose）");
-		log$8.info("开始扁平并行执行", {
+		log$7.info("开始扁平并行执行", {
 			count: specs.length,
 			maxConcurrent: this.flatConfig.maxConcurrent,
 			hasContext: context != null
@@ -9407,7 +11505,7 @@ var AgentOrchestrator = class {
 		const allResults = [];
 		for (let i = 0; i < specs.length; i += this.flatConfig.maxConcurrent) {
 			const batch = specs.slice(i, i + this.flatConfig.maxConcurrent);
-			log$8.debug("执行扁平批次", {
+			log$7.debug("执行扁平批次", {
 				batchStart: i,
 				batchSize: batch.length,
 				totalSpecs: specs.length
@@ -9417,7 +11515,7 @@ var AgentOrchestrator = class {
 		}
 		const succeeded = allResults.filter((r) => r.status === "success").length;
 		const totalDuration = Date.now() - startTime;
-		log$8.info("扁平并行执行完成", {
+		log$7.info("扁平并行执行完成", {
 			total: allResults.length,
 			succeeded,
 			failed: allResults.length - succeeded,
@@ -9489,7 +11587,7 @@ var AgentOrchestrator = class {
 		} catch (error) {
 			const duration = Date.now() - startTime;
 			const message = error instanceof Error ? error.message : String(error);
-			log$8.warn("扁平子任务执行失败", {
+			log$7.warn("扁平子任务执行失败", {
 				specId: spec.id,
 				error: message,
 				duration
@@ -9541,7 +11639,7 @@ var AgentOrchestrator = class {
 		const parentInstanceId = options?.parentInstanceId ?? "";
 		const depth = (parentInstanceId && instanceManager.get(parentInstanceId) ? instanceManager.get(parentInstanceId)?.depth ?? 0 : 0) + 1;
 		if (depth > this.teamConfig.maxGlobalDepth) {
-			log$8.warn("Worker 创建被拒绝：超过全局最大深度", {
+			log$7.warn("Worker 创建被拒绝：超过全局最大深度", {
 				typeId,
 				depth,
 				maxGlobalDepth: this.teamConfig.maxGlobalDepth
@@ -9570,6 +11668,7 @@ var AgentOrchestrator = class {
 		const taskId = options?.taskId ?? `worker-${typeId}-${Date.now()}`;
 		const instanceId = `agent-${typeId}-${Date.now()}`;
 		const timeoutMs = options?.timeoutMs ?? this.flatConfig.taskTimeoutMs;
+		let worktreeInfo;
 		try {
 			const agent = createAgentFromType(definition, {
 				instanceId,
@@ -9596,16 +11695,36 @@ var AgentOrchestrator = class {
 			if (options?.context) promptCtx.context = options.context;
 			const systemPrompt = definition.getSystemPrompt(promptCtx);
 			agent.systemPromptOverride = this.enrichSystemPrompt(systemPrompt, instanceId, parentInstanceId || null);
+			let effectiveOptions = options;
+			if (options?.isolation === "worktree" && getWorktreeManager()) {
+				worktreeInfo = await getWorktreeManager().create({
+					slug: `${typeId}-${instanceId}`,
+					createdBy: instanceId
+				});
+				const innerWrapExecute = options.wrapExecute;
+				effectiveOptions = { ...options };
+				effectiveOptions.wrapExecute = (execute) => {
+					const inner = innerWrapExecute ? () => innerWrapExecute(execute) : execute;
+					return runInWorktree({
+						worktreeId: worktreeInfo.id,
+						worktreePath: worktreeInfo.worktreePath,
+						originalPath: worktreeInfo.originalPath
+					}, inner);
+				};
+			}
 			instanceManager.transition(instanceId, "running");
-			const result = await Promise.race([agent.execute({
+			const workdir = worktreeInfo?.worktreePath ?? process.cwd();
+			const executeFn = () => agent.execute({
 				taskId,
 				taskDescription,
-				workdir: process.cwd(),
+				workdir,
 				options: {
 					timeout: timeoutMs,
 					verbose: false
 				}
-			}), this.createTimeoutPromise(taskId, timeoutMs)]);
+			});
+			const executePromise = effectiveOptions?.wrapExecute ? effectiveOptions.wrapExecute(executeFn) : executeFn();
+			const result = await Promise.race([executePromise, this.createTimeoutPromise(taskId, timeoutMs)]);
 			const duration = Date.now() - startTime;
 			const taskResult = result;
 			const outputText = this.extractOutputText(result);
@@ -9636,7 +11755,7 @@ var AgentOrchestrator = class {
 		} catch (error) {
 			const duration = Date.now() - startTime;
 			const message = error instanceof Error ? error.message : String(error);
-			log$8.warn("Worker 执行失败", {
+			log$7.warn("Worker 执行失败", {
 				typeId,
 				instanceId,
 				error: message,
@@ -9670,6 +11789,21 @@ var AgentOrchestrator = class {
 				const instance = instanceManager.get(instanceId);
 				if (instance) instance.agent.systemPromptOverride = null;
 			} catch {}
+			if (worktreeInfo) {
+				const wm = getWorktreeManager();
+				if (wm) try {
+					const cleanResult = await wm.autoCleanIfNoChanges(worktreeInfo.id);
+					if (!cleanResult.cleaned) log$7.info("Worktree 有变更，保留", {
+						id: worktreeInfo.id,
+						path: cleanResult.worktreePath
+					});
+				} catch (err) {
+					log$7.warn("Worktree 清理失败", {
+						id: worktreeInfo.id,
+						error: err instanceof Error ? err.message : String(err)
+					});
+				}
+			}
 		}
 	}
 	/**
@@ -9684,7 +11818,7 @@ var AgentOrchestrator = class {
 	*/
 	async spawnTeam(taskDescription, workerSpecs) {
 		const teamId = `team-${Date.now()}-${++this.teamCounter}`;
-		log$8.info("创建 Team", {
+		log$7.info("创建 Team", {
 			teamId,
 			workerCount: workerSpecs.length,
 			taskDescription
@@ -9845,6 +11979,8 @@ const TOOL_RISK_MAP = {
 	Skill: "medium",
 	TaskManage: "medium",
 	ScheduledTask: "medium",
+	LSP: "low",
+	AskUserQuestion: "medium",
 	SpawnSubAgents: "high"
 };
 
@@ -9856,7 +11992,7 @@ const TOOL_RISK_MAP = {
 * @param webConfig - Web 工具配置（可选），传入时启用 WebFetch 和 WebSearch
 * @param taskStore - TaskStore 实例（可选），传入时启用 TaskManage 工具
 */
-function createReplBuiltinTools(webConfig, taskStore, skillConfig, parentAgent, subAgentConfig, cronScheduler, agentTeamConfig) {
+function createReplBuiltinTools(webConfig, taskStore, skillConfig, parentAgent, subAgentConfig, cronScheduler, agentTeamConfig, worktreeManager) {
 	const tools = [
 		{
 			id: "GetCurrentTime",
@@ -9920,154 +12056,1353 @@ function createReplBuiltinTools(webConfig, taskStore, skillConfig, parentAgent,
 						type: "number",
 						description: "最大读取行数（可选，默认 2000）"
 					}
-				},
-				required: ["file_path"]
-			},
-			execute: async (_toolCallId, params) => {
-				const fs = await import("node:fs/promises");
-				const resolvedPath = (await import("node:path")).resolve(params.file_path);
-				try {
-					const lines = (await fs.readFile(resolvedPath, "utf-8")).split("\n");
-					const offset = params.offset ? Math.max(1, params.offset) : 1;
-					const limit = params.limit ?? 2e3;
-					const startIdx = offset - 1;
-					const endIdx = Math.min(startIdx + limit, lines.length);
-					const pageContent = lines.slice(startIdx, endIdx).map((l, i) => `${startIdx + i + 1}\t${l}`).join("\n");
-					const truncated = endIdx < lines.length;
-					readStateTracker.recordRead(resolvedPath);
-					return {
+				},
+				required: ["file_path"]
+			},
+			execute: async (_toolCallId, params) => {
+				const fs = await import("node:fs/promises");
+				const resolvedPath = resolveWorktreePath(params.file_path);
+				try {
+					const lines = (await fs.readFile(resolvedPath, "utf-8")).split("\n");
+					const offset = params.offset ? Math.max(1, params.offset) : 1;
+					const limit = params.limit ?? 2e3;
+					const startIdx = offset - 1;
+					const endIdx = Math.min(startIdx + limit, lines.length);
+					const pageContent = lines.slice(startIdx, endIdx).map((l, i) => `${startIdx + i + 1}\t${l}`).join("\n");
+					const truncated = endIdx < lines.length;
+					readStateTracker.recordRead(resolvedPath);
+					return {
+						content: [{
+							type: "text",
+							text: pageContent + (truncated ? `\n\n[文件共 ${lines.length} 行，已显示 ${offset}-${endIdx} 行]` : "")
+						}],
+						details: {
+							path: resolvedPath,
+							totalLines: lines.length,
+							displayedLines: endIdx - startIdx,
+							offset,
+							limit,
+							truncated
+						}
+					};
+				} catch (error) {
+					return {
+						content: [{
+							type: "text",
+							text: `读取失败: ${error instanceof Error ? error.message : String(error)}`
+						}],
+						details: {
+							path: resolvedPath,
+							error: true
+						}
+					};
+				}
+			}
+		}
+	];
+	tools.push(createWriteFileTool());
+	tools.push(createEditFileTool());
+	tools.push(createGlobTool());
+	tools.push(createGrepTool());
+	tools.push(createExecTool());
+	tools.push(createProcessTool());
+	if (webConfig?.enabled !== false) {
+		tools.push(createWebFetchTool(webConfig));
+		tools.push(createWebSearchTool(webConfig));
+	}
+	if (taskStore) tools.push(createTaskManageTool(taskStore));
+	tools.push(createMemoryTool());
+	if (skillConfig?.enabled !== false) tools.push(createSkillTool(skillConfig));
+	if (parentAgent && subAgentConfig?.enabled !== false && subAgentConfig) {
+		let orchestrator;
+		if (agentTeamConfig?.enabled) {
+			orchestrator = new AgentOrchestrator(agentTeamConfig, subAgentConfig, parentAgent, tools);
+			tools.push(createAgentTool(orchestrator));
+			const bgManager = getBackgroundAgentManager();
+			bgManager.setOrchestrator(orchestrator);
+			bgManager.restore();
+		}
+		const manager = new SubAgentManager(subAgentConfig, parentAgent, tools, orchestrator);
+		if (!agentTeamConfig?.enabled) tools.push(createSpawnSubAgentsTool(manager, subAgentConfig));
+	}
+	if (worktreeManager) {
+		tools.push(createEnterWorktreeTool(worktreeManager));
+		tools.push(createExitWorktreeTool(worktreeManager));
+	}
+	if (cronScheduler) tools.push(createCronTool(cronScheduler));
+	tools.push(createAskUserQuestionTool());
+	for (const tool of tools) if (!tool.defaultRisk) tool.defaultRisk = TOOL_RISK_MAP[tool.id] ?? "medium";
+	return tools;
+}
+
+//#endregion
+//#region src/cli/repl/theme.ts
+/** 根据颜色开关获取 chalk 实例 */
+function makeColor(colorEnabled) {
+	return colorEnabled ? chalk : new Chalk({ level: 0 });
+}
+/**
+* 创建 zapmyco pi-tui 主题
+*/
+function createTheme(colorEnabled) {
+	const c = makeColor(colorEnabled);
+	/** 基础 selectList 主题 */
+	const baseSelectListTheme = {
+		selectedPrefix: (text) => c.cyan(text),
+		selectedText: (text) => c.bold(c.cyan(text)),
+		description: (text) => c.gray(text),
+		scrollInfo: (text) => c.gray(text),
+		noMatch: (text) => c.gray(text)
+	};
+	return {
+		/** 主文本色 */
+		text: (s) => s,
+		/** 加粗 */
+		bold: (s) => c.bold(s),
+		/** 灰色/弱化文本 */
+		dim: (s) => c.gray(s),
+		/** 强调色 - 青色 */
+		accent: (s) => c.cyan(s),
+		/** 成功 - 绿色 */
+		success: (s) => c.green(s),
+		/** 错误 - 红色 */
+		error: (s) => c.red(s),
+		/** 警告 - 黄色 */
+		warning: (s) => c.yellow(s),
+		/** 边框色 - 灰色 */
+		border: (s) => c.gray(s),
+		/** Header 文本 */
+		heading: (s) => c.bold(s),
+		editorTheme: {
+			borderColor: (text) => c.gray(text),
+			selectList: baseSelectListTheme
+		},
+		selectListTheme: baseSelectListTheme
+	};
+}
+
+//#endregion
+//#region src/core/lsp/types.ts
+/** SymbolKind 名称映射 */
+const SYMBOL_KIND_NAMES = {
+	[1]: "File",
+	[2]: "Module",
+	[3]: "Namespace",
+	[4]: "Package",
+	[5]: "Class",
+	[6]: "Method",
+	[7]: "Property",
+	[8]: "Field",
+	[9]: "Constructor",
+	[10]: "Enum",
+	[11]: "Interface",
+	[12]: "Function",
+	[13]: "Variable",
+	[14]: "Constant",
+	[15]: "String",
+	[16]: "Number",
+	[17]: "Boolean",
+	[18]: "Array",
+	[19]: "Object",
+	[20]: "Key",
+	[21]: "Null",
+	[22]: "EnumMember",
+	[23]: "Struct",
+	[24]: "Event",
+	[25]: "Operator",
+	[26]: "TypeParameter"
+};
+/** LSP 操作错误 */
+var LspError = class extends Error {
+	code;
+	constructor(message, code) {
+		super(message);
+		this.name = "LspError";
+		this.code = code;
+	}
+};
+
+//#endregion
+//#region src/cli/repl/tools/lsp-tool.ts
+/** 操作 → LSP 方法 */
+const METHOD_MAP = {
+	goToDefinition: "textDocument/definition",
+	findReferences: "textDocument/references",
+	hover: "textDocument/hover",
+	documentSymbol: "textDocument/documentSymbol",
+	workspaceSymbol: "workspace/symbol",
+	goToImplementation: "textDocument/implementation",
+	prepareCallHierarchy: "textDocument/prepareCallHierarchy",
+	incomingCalls: "callHierarchy/incomingCalls",
+	outgoingCalls: "callHierarchy/outgoingCalls"
+};
+/**
+* 需要两步调用（先 prepareCallHierarchy）的操作
+*/
+const TWO_STEP_OPS = new Set(["incomingCalls", "outgoingCalls"]);
+/**
+* 需要位置参数的操作
+*/
+const POSITION_REQUIRED_OPS = new Set([
+	"goToDefinition",
+	"findReferences",
+	"hover",
+	"goToImplementation",
+	"prepareCallHierarchy",
+	"incomingCalls",
+	"outgoingCalls"
+]);
+/**
+* 不需要 filePath 的操作
+*/
+const NO_FILEPATH_OPS = new Set(["workspaceSymbol"]);
+function formatLocation(loc) {
+	if ("targetUri" in loc) return `${loc.targetUri.replace(/^file:\/\//, "")}:${loc.targetRange.start.line + 1}:${loc.targetRange.start.character + 1}`;
+	return `${loc.uri.replace(/^file:\/\//, "")}:${loc.range.start.line + 1}:${loc.range.start.character + 1}`;
+}
+function formatHoverContent(contents) {
+	if (typeof contents === "string") return contents;
+	if (Array.isArray(contents)) return contents.map((c) => typeof c === "string" ? c : `\`\`\`${c.language}\n${c.value}\n\`\`\``).join("\n");
+	if (typeof contents === "object" && "kind" in contents) return contents.value;
+	return JSON.stringify(contents, null, 2);
+}
+function formatDocumentSymbol(symbols, indent = 0) {
+	const prefix = "  ".repeat(indent);
+	const lines = [];
+	for (const sym of symbols) {
+		const kind = SYMBOL_KIND_NAMES[sym.kind] ?? `Kind(${sym.kind})`;
+		const detail = sym.detail ? `: ${sym.detail}` : "";
+		const line = sym.selectionRange.start.line + 1;
+		const char = sym.selectionRange.start.character + 1;
+		const deprecated = sym.deprecated ? " [deprecated]" : "";
+		lines.push(`${prefix}${kind} ${sym.name}${detail} @ ${line}:${char}${deprecated}`);
+		if (sym.children && sym.children.length > 0) lines.push(...formatDocumentSymbol(sym.children, indent + 1));
+	}
+	return lines.join("\n");
+}
+function formatWorkspaceSymbol(symbols) {
+	const lines = [];
+	for (const sym of symbols) {
+		const kind = SYMBOL_KIND_NAMES[sym.kind] ?? `Kind(${sym.kind})`;
+		const path = sym.location.uri.replace(/^file:\/\//, "");
+		const line = sym.location.range.start.line + 1;
+		const char = sym.location.range.start.character + 1;
+		const container = sym.containerName ? ` (in ${sym.containerName})` : "";
+		lines.push(`${kind} ${sym.name}${container} — ${path}:${line}:${char}`);
+	}
+	return lines.join("\n");
+}
+function formatCallHierarchyItem(item) {
+	const kind = SYMBOL_KIND_NAMES[item.kind] ?? `Kind(${item.kind})`;
+	const path = item.uri.replace(/^file:\/\//, "");
+	const line = item.selectionRange.start.line + 1;
+	const char = item.selectionRange.start.character + 1;
+	const detail = item.detail ? `: ${item.detail}` : "";
+	return `${kind} ${item.name}${detail} — ${path}:${line}:${char}`;
+}
+function createLspTool(lspManager) {
+	return {
+		id: "LSP",
+		label: "LSP 代码智能",
+		description: "使用 Language Server Protocol 进行代码智能操作。支持：goToDefinition(跳转到定义)、findReferences(查找引用)、hover(悬停信息)、documentSymbol(文档符号)、workspaceSymbol(工作区符号)、goToImplementation(跳转到实现)、prepareCallHierarchy(准备调用层次)、incomingCalls(传入调用)、outgoingCalls(传出调用)。所有操作都需要 filePath(绝对路径)、line(1-based)、character(1-based) 参数。LSP 服务器必须已配置才能使用此工具。",
+		parameters: {
+			type: "object",
+			properties: {
+				operation: {
+					type: "string",
+					enum: [
+						"goToDefinition",
+						"findReferences",
+						"hover",
+						"documentSymbol",
+						"workspaceSymbol",
+						"goToImplementation",
+						"prepareCallHierarchy",
+						"incomingCalls",
+						"outgoingCalls"
+					],
+					description: "要执行的 LSP 操作"
+				},
+				filePath: {
+					type: "string",
+					description: "文件绝对路径或相对路径（workspaceSymbol 操作不需要）"
+				},
+				line: {
+					type: "number",
+					description: "行号（1-based，与编辑器一致。位置相关操作需要）"
+				},
+				character: {
+					type: "number",
+					description: "字符偏移（1-based，与编辑器一致。位置相关操作需要）"
+				}
+			},
+			required: [
+				"operation",
+				"filePath",
+				"line",
+				"character"
+			]
+		},
+		defaultRisk: "low",
+		execute: async (_toolCallId, rawParams) => {
+			const startTime = Date.now();
+			const { operation, filePath, line, character } = rawParams;
+			if (!NO_FILEPATH_OPS.has(operation) && !filePath) return {
+				content: [{
+					type: "text",
+					text: "错误：需要 filePath 参数"
+				}],
+				details: {
+					error: true,
+					message: "filePath required"
+				}
+			};
+			if (POSITION_REQUIRED_OPS.has(operation)) {
+				if (line == null || character == null) return {
+					content: [{
+						type: "text",
+						text: `错误：${operation} 需要 line 和 character 参数`
+					}],
+					details: {
+						error: true,
+						message: "position required"
+					}
+				};
+			}
+			try {
+				const resolvedPath = NO_FILEPATH_OPS.has(operation) ? process.cwd() : resolveWorktreePath(filePath);
+				const lspMethod = METHOD_MAP[operation];
+				if (TWO_STEP_OPS.has(operation)) {
+					const items = await lspManager.request(resolvedPath, "textDocument/prepareCallHierarchy", {
+						textDocument: { uri: `file://${resolvedPath}` },
+						position: {
+							line: (line ?? 1) - 1,
+							character: (character ?? 1) - 1
+						}
+					});
+					const firstItem = items?.[0];
+					if (!items || items.length === 0 || !firstItem) return {
 						content: [{
 							type: "text",
-							text: pageContent + (truncated ? `\n\n[文件共 ${lines.length} 行，已显示 ${offset}-${endIdx} 行]` : "")
+							text: "未找到调用层次项"
 						}],
 						details: {
-							path: resolvedPath,
-							totalLines: lines.length,
-							displayedLines: endIdx - startIdx,
-							offset,
-							limit,
-							truncated
+							operation,
+							filePath: resolvedPath,
+							resultCount: 0,
+							elapsedMs: Date.now() - startTime
 						}
 					};
-				} catch (error) {
+					const results = await lspManager.request(resolvedPath, lspMethod, { item: firstItem });
+					const elapsedMs = Date.now() - startTime;
+					const callResults = results ?? [];
+					if (operation === "incomingCalls") {
+						const calls = callResults;
+						const formatted = calls.map((c) => `← ${formatCallHierarchyItem(c.from)} (${c.fromRanges.length} 处调用)`).join("\n");
+						return {
+							content: [{
+								type: "text",
+								text: `传入调用 — ${formatCallHierarchyItem(firstItem)}\n\n${formatted || "无传入调用"}`
+							}],
+							details: {
+								operation,
+								filePath: resolvedPath,
+								resultCount: calls.length,
+								elapsedMs
+							}
+						};
+					}
+					const calls = callResults;
+					const formatted = calls.map((c) => `→ ${formatCallHierarchyItem(c.to)} (${c.fromRanges.length} 处调用)`).join("\n");
 					return {
 						content: [{
 							type: "text",
-							text: `读取失败: ${error instanceof Error ? error.message : String(error)}`
+							text: `传出调用 — ${formatCallHierarchyItem(firstItem)}\n\n${formatted || "无传出调用"}`
 						}],
 						details: {
-							path: resolvedPath,
-							error: true
+							operation,
+							filePath: resolvedPath,
+							resultCount: calls.length,
+							elapsedMs
+						}
+					};
+				}
+				const methodParams = {};
+				if (operation === "workspaceSymbol") methodParams.query = rawParams.query ?? "";
+				else if (operation === "documentSymbol") methodParams.textDocument = { uri: `file://${resolvedPath}` };
+				else if (operation === "findReferences") {
+					methodParams.textDocument = { uri: `file://${resolvedPath}` };
+					methodParams.position = {
+						line: (line ?? 1) - 1,
+						character: (character ?? 1) - 1
+					};
+					methodParams.context = { includeDeclaration: true };
+				} else {
+					methodParams.textDocument = { uri: `file://${resolvedPath}` };
+					methodParams.position = {
+						line: (line ?? 1) - 1,
+						character: (character ?? 1) - 1
+					};
+				}
+				const result = await lspManager.request(resolvedPath, lspMethod, methodParams);
+				const elapsedMs = Date.now() - startTime;
+				switch (operation) {
+					case "goToDefinition":
+					case "goToImplementation": {
+						const locations = result ?? [];
+						const formatted = locations.map(formatLocation).join("\n");
+						return {
+							content: [{
+								type: "text",
+								text: `${operation === "goToDefinition" ? "定义" : "实现"} (${locations.length} 处)\n\n${formatted || "无结果"}`
+							}],
+							details: {
+								operation,
+								filePath: resolvedPath,
+								resultCount: locations.length,
+								elapsedMs
+							}
+						};
+					}
+					case "findReferences": {
+						const refs = result ?? [];
+						const formatted = refs.map(formatLocation).join("\n");
+						return {
+							content: [{
+								type: "text",
+								text: `引用 (${refs.length} 处)\n\n${formatted || "无引用"}`
+							}],
+							details: {
+								operation,
+								filePath: resolvedPath,
+								resultCount: refs.length,
+								elapsedMs
+							}
+						};
+					}
+					case "hover": {
+						const hover = result;
+						if (!hover?.contents) return {
+							content: [{
+								type: "text",
+								text: "无悬停信息"
+							}],
+							details: {
+								operation,
+								filePath: resolvedPath,
+								resultCount: 0,
+								elapsedMs
+							}
+						};
+						return {
+							content: [{
+								type: "text",
+								text: formatHoverContent(hover.contents)
+							}],
+							details: {
+								operation,
+								filePath: resolvedPath,
+								resultCount: 1,
+								elapsedMs
+							}
+						};
+					}
+					case "documentSymbol": {
+						const symbols = result ?? [];
+						if (symbols.length === 0) return {
+							content: [{
+								type: "text",
+								text: "无文档符号"
+							}],
+							details: {
+								operation,
+								filePath: resolvedPath,
+								resultCount: 0,
+								elapsedMs
+							}
+						};
+						const formatted = formatDocumentSymbol(symbols);
+						return {
+							content: [{
+								type: "text",
+								text: `文档符号 (${symbols.length} 个顶层)\n\n${formatted}`
+							}],
+							details: {
+								operation,
+								filePath: resolvedPath,
+								resultCount: symbols.length,
+								elapsedMs
+							}
+						};
+					}
+					case "workspaceSymbol": {
+						const symbols = result ?? [];
+						if (symbols.length === 0) return {
+							content: [{
+								type: "text",
+								text: "未找到工作区符号"
+							}],
+							details: {
+								operation,
+								resultCount: 0,
+								elapsedMs
+							}
+						};
+						const formatted = formatWorkspaceSymbol(symbols);
+						return {
+							content: [{
+								type: "text",
+								text: `工作区符号 (${symbols.length} 个)\n\n${formatted}`
+							}],
+							details: {
+								operation,
+								resultCount: symbols.length,
+								elapsedMs
+							}
+						};
+					}
+					case "prepareCallHierarchy": {
+						const items = result ?? [];
+						if (items.length === 0) return {
+							content: [{
+								type: "text",
+								text: "未找到调用层次项"
+							}],
+							details: {
+								operation,
+								filePath: resolvedPath,
+								resultCount: 0,
+								elapsedMs
+							}
+						};
+						const formatted = items.map(formatCallHierarchyItem).join("\n");
+						return {
+							content: [{
+								type: "text",
+								text: `调用层次 (${items.length} 项)\n\n${formatted}`
+							}],
+							details: {
+								operation,
+								filePath: resolvedPath,
+								resultCount: items.length,
+								elapsedMs
+							}
+						};
+					}
+					default: return {
+						content: [{
+							type: "text",
+							text: JSON.stringify(result, null, 2)
+						}],
+						details: {
+							operation,
+							filePath: resolvedPath,
+							elapsedMs
 						}
 					};
 				}
+			} catch (err) {
+				const errorMsg = err instanceof Error ? err.message : String(err);
+				return {
+					content: [{
+						type: "text",
+						text: `LSP 操作失败: ${errorMsg}`
+					}],
+					details: {
+						error: true,
+						operation,
+						filePath,
+						message: errorMsg
+					}
+				};
 			}
 		}
-	];
-	tools.push(createWriteFileTool());
-	tools.push(createEditFileTool());
-	tools.push(createGlobTool());
-	tools.push(createGrepTool());
-	tools.push(createExecTool());
-	tools.push(createProcessTool());
-	if (webConfig?.enabled !== false) {
-		tools.push(createWebFetchTool(webConfig));
-		tools.push(createWebSearchTool(webConfig));
+	};
+}
+
+//#endregion
+//#region src/config/types.ts
+/**
+* 将用户配置的 MCP 格式标准化为 McpServerConfig 数组
+*
+* 支持两种输入格式自动检测：
+* - `{ servers: [...] }` → 直接返回数组
+* - `{ "server-a": {...}, "server-b": {...} }` → 以 key 作为 name 转换为数组
+*/
+function normalizeMcpConfig(raw) {
+	if (raw.servers && Array.isArray(raw.servers) && raw.servers.length > 0) return raw.servers;
+	const servers = [];
+	for (const [key, value] of Object.entries(raw)) {
+		if (key === "servers") continue;
+		if (value === null || value === void 0 || typeof value !== "object") continue;
+		if (Array.isArray(value)) continue;
+		const config = value;
+		if (typeof config.command !== "string") continue;
+		const server = {
+			name: key,
+			transport: "stdio",
+			command: config.command
+		};
+		if (Array.isArray(config.args)) server.args = config.args;
+		if (config.env && typeof config.env === "object") server.env = config.env;
+		if (typeof config.cwd === "string") server.cwd = config.cwd;
+		if (typeof config.enabled === "boolean") server.enabled = config.enabled;
+		if (typeof config.connectTimeoutMs === "number") server.connectTimeoutMs = config.connectTimeoutMs;
+		servers.push(server);
 	}
-	if (taskStore) tools.push(createTaskManageTool(taskStore));
-	tools.push(createMemoryTool());
-	if (skillConfig?.enabled !== false) tools.push(createSkillTool(skillConfig));
-	if (parentAgent && subAgentConfig?.enabled !== false && subAgentConfig) {
-		let orchestrator;
-		if (agentTeamConfig?.enabled) {
-			orchestrator = new AgentOrchestrator(agentTeamConfig, subAgentConfig, parentAgent, tools);
-			tools.push(createAgentTool(orchestrator));
+	return servers;
+}
+
+//#endregion
+//#region src/core/lsp/diagnostics.ts
+function createDiagnosticCollector() {
+	const diagnosticsByFile = /* @__PURE__ */ new Map();
+	function init(_manager) {}
+	function getForFile(filePath) {
+		const diags = diagnosticsByFile.get(filePath);
+		if (!diags) return [];
+		return [...diags];
+	}
+	function clearForFile(filePath) {
+		diagnosticsByFile.delete(filePath);
+	}
+	function clear() {
+		diagnosticsByFile.clear();
+	}
+	return {
+		init,
+		getForFile,
+		clearForFile,
+		clear
+	};
+}
+
+//#endregion
+//#region src/core/lsp/lsp-config.ts
+/** 内置 TypeScript/JavaScript LSP 服务器配置 */
+const BUILTIN_LSP_SERVERS = [{
+	name: "typescript",
+	command: "typescript-language-server",
+	args: ["--stdio"],
+	languageIds: [
+		"typescript",
+		"javascript",
+		"typescriptreact",
+		"javascriptreact"
+	],
+	extensions: [
+		".ts",
+		".tsx",
+		".js",
+		".jsx",
+		".mjs",
+		".cjs",
+		".mts",
+		".cts"
+	],
+	connectTimeoutMs: 3e4,
+	requestTimeoutMs: 15e3
+}];
+/**
+* 解析并合并 LSP 配置
+*
+* 规则：
+* 1. 加载内置 server 配置
+* 2. 用户 servers 中同名项覆盖内置，不同名追加
+* 3. enabled=false 的 server 移除
+* 4. userConfig.enabled=false 全局禁用，返回空数组
+*
+* @param userConfig - 用户配置（可选）
+* @returns 生效的 server 配置列表
+*/
+function resolveLspConfig(userConfig) {
+	if (userConfig?.enabled === false) return [];
+	const serverMap = /* @__PURE__ */ new Map();
+	for (const builtin of BUILTIN_LSP_SERVERS) serverMap.set(builtin.name, { ...builtin });
+	if (userConfig?.servers) for (const userServer of userConfig.servers) {
+		if (userServer.enabled === false) {
+			serverMap.delete(userServer.name);
+			continue;
 		}
-		const manager = new SubAgentManager(subAgentConfig, parentAgent, tools, orchestrator);
-		if (!agentTeamConfig?.enabled) tools.push(createSpawnSubAgentsTool(manager, subAgentConfig));
+		const existing = serverMap.get(userServer.name);
+		if (existing) serverMap.set(userServer.name, {
+			...existing,
+			...userServer
+		});
+		else serverMap.set(userServer.name, { ...userServer });
 	}
-	if (cronScheduler) tools.push(createCronTool(cronScheduler));
-	for (const tool of tools) if (!tool.defaultRisk) tool.defaultRisk = TOOL_RISK_MAP[tool.id] ?? "medium";
-	return tools;
+	return Array.from(serverMap.values()).filter((s) => s.enabled !== false);
 }
 
 //#endregion
-//#region src/cli/repl/theme.ts
-/** 根据颜色开关获取 chalk 实例 */
-function makeColor(colorEnabled) {
-	return colorEnabled ? chalk : new Chalk({ level: 0 });
+//#region src/core/lsp/json-rpc.ts
+const HEADER_CONTENT_LENGTH = "Content-Length";
+const HEADER_CONTENT_TYPE = "Content-Type";
+const DEFAULT_CONTENT_TYPE = "application/vscode-jsonrpc; charset=utf-8";
+const CRLF = "\r\n";
+const DOUBLE_CRLF = "\r\n\r\n";
+/**
+* 从 Readable 流（子进程 stdout）读取 JSON-RPC 消息。
+*
+* 处理 TCP 流特性：
+* - 消息可能分多个 chunk 到达
+* - 一个 chunk 可能包含多个消息
+* - Content-Length 头可能跨 chunk 边界
+*/
+function createMessageReader(onMessage, onError, _onClose, trace) {
+	let buffer = "";
+	let contentLength = -1;
+	let headerEnd = -1;
+	function parseHeaders(rawHeaders) {
+		const headers = {};
+		for (const line of rawHeaders.split(CRLF)) {
+			const colon = line.indexOf(":");
+			if (colon > 0) {
+				const key = line.slice(0, colon).trim();
+				headers[key] = line.slice(colon + 1).trim();
+			}
+		}
+		return headers;
+	}
+	function processBuffer() {
+		while (buffer.length > 0) {
+			if (contentLength < 0) {
+				headerEnd = buffer.indexOf(DOUBLE_CRLF);
+				if (headerEnd < 0) return;
+				const lengthStr = parseHeaders(buffer.slice(0, headerEnd))[HEADER_CONTENT_LENGTH];
+				if (!lengthStr) {
+					onError(/* @__PURE__ */ new Error(`Missing ${HEADER_CONTENT_LENGTH} header in LSP message`));
+					buffer = buffer.slice(headerEnd + 4);
+					continue;
+				}
+				contentLength = parseInt(lengthStr, 10);
+				if (Number.isNaN(contentLength) || contentLength < 0) {
+					onError(/* @__PURE__ */ new Error(`Invalid ${HEADER_CONTENT_LENGTH}: ${lengthStr}`));
+					buffer = buffer.slice(headerEnd + 4);
+					contentLength = -1;
+					continue;
+				}
+			}
+			const bodyStart = headerEnd + 4;
+			const bodyEnd = bodyStart + contentLength;
+			if (buffer.length < bodyEnd) return;
+			const body = buffer.slice(bodyStart, bodyEnd);
+			buffer = buffer.slice(bodyEnd);
+			contentLength = -1;
+			headerEnd = -1;
+			if (body.length === 0) continue;
+			try {
+				trace?.(`LSP ← ${body.slice(0, 500)}${body.length > 500 ? "..." : ""}`);
+				onMessage(JSON.parse(body));
+			} catch (err) {
+				onError(/* @__PURE__ */ new Error(`JSON parse error: ${err instanceof Error ? err.message : String(err)}`));
+			}
+		}
+	}
+	return {
+		feed(chunk) {
+			buffer += chunk.toString("utf-8");
+			processBuffer();
+		},
+		reset() {
+			buffer = "";
+			contentLength = -1;
+			headerEnd = -1;
+		}
+	};
 }
 /**
-* 创建 zapmyco pi-tui 主题
-*/
-function createTheme(colorEnabled) {
-	const c = makeColor(colorEnabled);
-	/** 基础 selectList 主题 */
-	const baseSelectListTheme = {
-		selectedPrefix: (text) => c.cyan(text),
-		selectedText: (text) => c.bold(c.cyan(text)),
-		description: (text) => c.gray(text),
-		scrollInfo: (text) => c.gray(text),
-		noMatch: (text) => c.gray(text)
+* 向 Writable 流（子进程 stdin）写入 JSON-RPC 消息。
+* 自动添加 Content-Length 和 Content-Type 头。
+*/
+function createMessageWriter(writable, trace) {
+	const encoder = new TextEncoder();
+	async function write(message) {
+		const body = JSON.stringify(message);
+		const bodyBytes = encoder.encode(body);
+		const header = `${HEADER_CONTENT_LENGTH}: ${bodyBytes.length}${CRLF}${HEADER_CONTENT_TYPE}: ${DEFAULT_CONTENT_TYPE}${CRLF}${CRLF}`;
+		const headerBytes = encoder.encode(header);
+		const fullMessage = Buffer.concat([headerBytes, bodyBytes]);
+		trace?.(`LSP → ${body.slice(0, 500)}${body.length > 500 ? "..." : ""}`);
+		return new Promise((resolve, reject) => {
+			if (!writable.writable) {
+				reject(/* @__PURE__ */ new Error("Stream is not writable"));
+				return;
+			}
+			writable.write(fullMessage, (err) => {
+				if (err) reject(err);
+				else resolve();
+			});
+		});
+	}
+	return { write };
+}
+
+//#endregion
+//#region src/core/lsp/lsp-client.ts
+/**
+* LSP 客户端 — Layer 1
+*
+* 启动 LSP 语言服务器子进程，通过 stdio 进行 JSON-RPC 2.0 通信。
+*
+* @module core/lsp
+*/
+function createLspClient(config) {
+	const requestTimeoutMs = config.requestTimeoutMs ?? 3e4;
+	let childProcess = null;
+	let nextId = 1;
+	let isStopping = false;
+	let capabilities = null;
+	const pendingRequests = /* @__PURE__ */ new Map();
+	const notificationHandlers = /* @__PURE__ */ new Map();
+	let messageWriter = null;
+	function trace(dir, msg) {
+		if (process.env.ZAPMYCO_LSP_TRACE) process.stderr.write(`[lsp-client] ${dir} ${msg}\n`);
+	}
+	function rejectAllPending(error) {
+		for (const [, pending] of pendingRequests) {
+			clearTimeout(pending.timer);
+			pending.reject(error);
+		}
+		pendingRequests.clear();
+	}
+	function handleMessage(message) {
+		if ("id" in message && !("method" in message)) {
+			const response = message;
+			const pending = pendingRequests.get(response.id);
+			if (pending) {
+				clearTimeout(pending.timer);
+				pendingRequests.delete(response.id);
+				if (response.error) pending.reject(new LspError(`LSP error ${response.error.code}: ${response.error.message}`, `LSP_ERROR_${response.error.code}`));
+				else pending.resolve(response.result);
+			}
+			return;
+		}
+		if ("method" in message && !("id" in message)) {
+			const notification = message;
+			const handlers = notificationHandlers.get(notification.method);
+			if (handlers) for (const handler of handlers) try {
+				handler(notification.params);
+			} catch {}
+		}
+	}
+	function spawnProcess() {
+		const child = spawn(config.command, config.args ?? [], {
+			env: {
+				...process.env,
+				...config.env
+			},
+			stdio: [
+				"pipe",
+				"pipe",
+				"pipe"
+			]
+		});
+		child.on("error", (err) => {
+			rejectAllPending(new LspError(`LSP process error: ${err.message}`, "PROCESS_ERROR"));
+		});
+		child.on("exit", (code, signal) => {
+			if (!isStopping) rejectAllPending(new LspError(`LSP process exited unexpectedly (${signal ? `signal ${signal}` : `exit code ${code}`})`, "PROCESS_EXIT"));
+		});
+		if (child.stderr) child.stderr.on("data", (chunk) => {
+			if (process.env.ZAPMYCO_LSP_TRACE) process.stderr.write(`[lsp-stderr] ${chunk.toString("utf-8")}`);
+		});
+		return child;
+	}
+	function ensureStarted() {
+		if (childProcess) return;
+		childProcess = spawnProcess();
+		const reader = createMessageReader(handleMessage, (err) => trace("←", `Reader error: ${err.message}`), () => {
+			if (!isStopping) rejectAllPending(new LspError("LSP stdout closed", "STDOUT_CLOSED"));
+		}, (msg) => trace("←", msg));
+		childProcess.stdout.on("data", (chunk) => {
+			reader.feed(chunk);
+		});
+		childProcess.stdout.on("end", () => {
+			if (!isStopping) rejectAllPending(new LspError("LSP stdout closed unexpectedly", "STDOUT_CLOSED"));
+		});
+		messageWriter = createMessageWriter(childProcess.stdin, (msg) => trace("→", msg));
+	}
+	async function initialize(rootUri, initializationOptions) {
+		ensureStarted();
+		const result = await sendRequest("initialize", {
+			processId: process.pid,
+			rootUri,
+			rootPath: rootUri.replace(/^file:\/\//, ""),
+			workspaceFolders: [{
+				uri: rootUri,
+				name: "workspace"
+			}],
+			capabilities: {
+				textDocument: {
+					synchronization: { didSave: true },
+					definition: { linkSupport: true },
+					references: {},
+					hover: { contentFormat: ["markdown", "plaintext"] },
+					documentSymbol: { hierarchicalDocumentSymbolSupport: true },
+					implementation: { linkSupport: true },
+					callHierarchy: {}
+				},
+				workspace: { symbol: {} }
+			},
+			initializationOptions
+		});
+		capabilities = result.capabilities;
+		await sendNotification("initialized", {});
+		return result;
+	}
+	async function sendRequest(method, params) {
+		if (!childProcess || !messageWriter) throw new LspError("LSP client not started", "NOT_STARTED");
+		if (isStopping) throw new LspError("LSP client is shutting down", "SHUTTING_DOWN");
+		const id = nextId++;
+		const request = {
+			jsonrpc: "2.0",
+			id,
+			method,
+			params
+		};
+		return new Promise((resolve, reject) => {
+			const timer = setTimeout(() => {
+				pendingRequests.delete(id);
+				reject(new LspError(`LSP request timeout: ${method}`, "REQUEST_TIMEOUT"));
+			}, requestTimeoutMs);
+			pendingRequests.set(id, {
+				resolve,
+				reject,
+				timer,
+				method
+			});
+			messageWriter.write(request).catch((err) => {
+				clearTimeout(timer);
+				pendingRequests.delete(id);
+				reject(err);
+			});
+		});
+	}
+	async function sendNotification(method, params) {
+		if (!childProcess || !messageWriter) throw new LspError("LSP client not started", "NOT_STARTED");
+		if (isStopping) return;
+		const notification = {
+			jsonrpc: "2.0",
+			method,
+			params
+		};
+		await messageWriter.write(notification);
+	}
+	function onNotification(method, handler) {
+		let handlers = notificationHandlers.get(method);
+		if (!handlers) {
+			handlers = /* @__PURE__ */ new Set();
+			notificationHandlers.set(method, handlers);
+		}
+		handlers.add(handler);
+	}
+	function offNotification(method, handler) {
+		const handlers = notificationHandlers.get(method);
+		if (handlers) {
+			handlers.delete(handler);
+			if (handlers.size === 0) notificationHandlers.delete(method);
+		}
+	}
+	function getCapabilities() {
+		return capabilities;
+	}
+	function isAlive() {
+		return childProcess !== null && !childProcess.killed && childProcess.exitCode === null;
+	}
+	async function shutdown() {
+		if (!childProcess || isStopping) return;
+		isStopping = true;
+		try {
+			await sendRequest("shutdown");
+		} catch {}
+		try {
+			await sendNotification("exit");
+		} catch {}
+		await new Promise((resolve) => {
+			const timer = setTimeout(() => {
+				if (childProcess && !childProcess.killed) childProcess.kill("SIGKILL");
+				resolve();
+			}, 2e3);
+			childProcess.once("exit", () => {
+				clearTimeout(timer);
+				resolve();
+			});
+		});
+		childProcess = null;
+		capabilities = null;
+		messageWriter = null;
+		pendingRequests.clear();
+		notificationHandlers.clear();
+	}
+	return {
+		sendRequest,
+		sendNotification,
+		onNotification,
+		offNotification,
+		initialize,
+		getCapabilities,
+		isAlive,
+		shutdown
 	};
+}
+
+//#endregion
+//#region src/core/lsp/lsp-server-instance.ts
+/**
+* LSP 服务器实例 — Layer 2
+*
+* 封装单个 LSP 服务器的完整生命周期：
+* - 状态机（stopped → starting → running → stopping → stopped + error）
+* - initialize 握手（capabilities 提取）
+* - 文档同步跟踪（didOpen/didChange/didClose）
+* - 重试逻辑（指数退避，最大 maxRetries 次）
+* - 能力查询
+*
+* @module core/lsp
+*/
+function createLspServerInstance(config) {
+	const { serverId, languageIds, extensions, initializationOptions } = config;
+	const maxRetries = config.maxRetries ?? 3;
+	const retryBaseDelayMs = config.retryBaseDelayMs ?? 1e3;
+	let client = null;
+	let capabilities = null;
+	let state = "stopped";
+	let retryCount = 0;
+	let requestCount = 0;
+	let errorCount = 0;
+	const openedDocuments = /* @__PURE__ */ new Map();
+	function transition(newState) {
+		state = newState;
+	}
+	function calculateDelay() {
+		return Math.min(retryBaseDelayMs * 2 ** retryCount, 3e4);
+	}
+	async function ensureDocumentOpened(uri, languageId, text) {
+		if (openedDocuments.get(uri)) return;
+		await ensureRunning();
+		try {
+			await client.sendNotification("textDocument/didOpen", { textDocument: {
+				uri,
+				languageId,
+				version: 1,
+				text
+			} });
+			openedDocuments.set(uri, { version: 1 });
+		} catch (err) {
+			if (process.env.ZAPMYCO_LSP_TRACE) process.stderr.write(`[lsp-instance] didOpen failed: ${err instanceof Error ? err.message : String(err)}\n`);
+		}
+	}
+	async function notifyDocumentChanged(uri, text) {
+		const existing = openedDocuments.get(uri);
+		if (!existing) return;
+		existing.version++;
+		const version = existing.version;
+		if (state !== "running" || !client?.isAlive()) return;
+		try {
+			await client.sendNotification("textDocument/didChange", {
+				textDocument: {
+					uri,
+					version
+				},
+				contentChanges: [{ text }]
+			});
+		} catch {}
+	}
+	async function notifyDocumentClosed(uri) {
+		openedDocuments.delete(uri);
+		if (state !== "running" || !client?.isAlive()) return;
+		try {
+			await client.sendNotification("textDocument/didClose", { textDocument: { uri } });
+		} catch {}
+	}
+	async function ensureRunning() {
+		if (state === "running" && client?.isAlive()) return;
+		if (state === "stopped" || state === "error") await doInitialize();
+	}
+	async function doInitialize(rootUri) {
+		if (state === "starting") return;
+		transition("starting");
+		try {
+			if (client) try {
+				await client.shutdown();
+			} catch {}
+			client = createLspClient(config.clientConfig);
+			const uri = rootUri ?? `file://${process.cwd()}`;
+			capabilities = (await client.initialize(uri, initializationOptions)).capabilities;
+			retryCount = 0;
+			transition("running");
+		} catch (err) {
+			errorCount++;
+			const error = err instanceof Error ? err : new Error(String(err));
+			if (retryCount < maxRetries) {
+				retryCount++;
+				const delay = calculateDelay();
+				if (process.env.ZAPMYCO_LSP_TRACE) process.stderr.write(`[lsp-instance] ${serverId} init failed, retry ${retryCount}/${maxRetries} in ${delay}ms\n`);
+				await new Promise((resolve) => setTimeout(resolve, delay));
+				retryCount--;
+				transition("error");
+				return doInitialize(rootUri);
+			}
+			transition("error");
+			throw new LspError(`Failed to initialize LSP server ${serverId}: ${error.message}`, "INIT_FAILED");
+		}
+	}
+	async function initialize(rootUri) {
+		await doInitialize(rootUri);
+	}
+	async function request(method, params) {
+		await ensureRunning();
+		requestCount++;
+		try {
+			return await client.sendRequest(method, params);
+		} catch (err) {
+			errorCount++;
+			if (err instanceof LspError && err.code === "PROCESS_EXIT") transition("error");
+			throw err;
+		}
+	}
+	async function sendNotification(method, params) {
+		if (state !== "running" || !client?.isAlive()) return;
+		try {
+			await client.sendNotification(method, params);
+		} catch {}
+	}
+	function onNotification(method, handler) {
+		if (client) client.onNotification(method, handler);
+	}
+	function supportsCapability(capability) {
+		if (!capabilities) return false;
+		return capabilities[capability] === true;
+	}
+	function getHealth() {
+		return {
+			state,
+			requestCount,
+			errorCount
+		};
+	}
+	function getState() {
+		return state;
+	}
+	function getServerId() {
+		return serverId;
+	}
+	function getExtensions() {
+		return extensions;
+	}
+	function getLanguageIds() {
+		return languageIds;
+	}
+	async function shutdown() {
+		if (state === "stopped" || state === "stopping") return;
+		transition("stopping");
+		for (const [uri] of openedDocuments) try {
+			await client?.sendNotification("textDocument/didClose", { textDocument: { uri } });
+		} catch {}
+		openedDocuments.clear();
+		if (client) try {
+			await client.shutdown();
+		} catch {}
+		client = null;
+		capabilities = null;
+		transition("stopped");
+	}
 	return {
-		/** 主文本色 */
-		text: (s) => s,
-		/** 加粗 */
-		bold: (s) => c.bold(s),
-		/** 灰色/弱化文本 */
-		dim: (s) => c.gray(s),
-		/** 强调色 - 青色 */
-		accent: (s) => c.cyan(s),
-		/** 成功 - 绿色 */
-		success: (s) => c.green(s),
-		/** 错误 - 红色 */
-		error: (s) => c.red(s),
-		/** 警告 - 黄色 */
-		warning: (s) => c.yellow(s),
-		/** 边框色 - 灰色 */
-		border: (s) => c.gray(s),
-		/** Header 文本 */
-		heading: (s) => c.bold(s),
-		editorTheme: {
-			borderColor: (text) => c.gray(text),
-			selectList: baseSelectListTheme
-		},
-		selectListTheme: baseSelectListTheme
+		initialize,
+		shutdown,
+		ensureDocumentOpened,
+		notifyDocumentChanged,
+		notifyDocumentClosed,
+		request,
+		sendNotification,
+		onNotification,
+		getHealth,
+		supportsCapability,
+		getState,
+		getServerId,
+		getExtensions,
+		getLanguageIds
 	};
 }
 
 //#endregion
-//#region src/config/types.ts
+//#region src/core/lsp/lsp-server-manager.ts
 /**
-* 将用户配置的 MCP 格式标准化为 McpServerConfig 数组
+* LSP 服务器管理器 — Layer 3
 *
-* 支持两种输入格式自动检测：
-* - `{ servers: [...] }` → 直接返回数组
-* - `{ "server-a": {...}, "server-b": {...} }` → 以 key 作为 name 转换为数组
+* 管理多个 LSP 服务器实例：
+* - 根据文件扩展名路由请求
+* - 协调文档同步（didOpen/didChange/didClose）
+* - 追踪 broken server
+* - 懒启动（首次请求时才启动 server）
+*
+* @module core/lsp
 */
-function normalizeMcpConfig(raw) {
-	if (raw.servers && Array.isArray(raw.servers) && raw.servers.length > 0) return raw.servers;
+function createLspServerManager() {
+	/** 扩展名 → server 实例 */
+	const extensionMap = /* @__PURE__ */ new Map();
+	/** 所有 server 实例 */
 	const servers = [];
-	for (const [key, value] of Object.entries(raw)) {
-		if (key === "servers") continue;
-		if (value === null || value === void 0 || typeof value !== "object") continue;
-		if (Array.isArray(value)) continue;
-		const config = value;
-		if (typeof config.command !== "string") continue;
-		const server = {
-			name: key,
-			transport: "stdio",
-			command: config.command
+	/** 已打开文档追踪：uri → { serverId, languageId, version } */
+	const openedFiles = /* @__PURE__ */ new Map();
+	/** 永久失败的 server ID 集合 */
+	const brokenServers = /* @__PURE__ */ new Set();
+	/** 初始化状态 */
+	let initialized = false;
+	/** 工作区根路径 */
+	let workspaceRoot = "";
+	function findLanguageId(extension, server) {
+		const languageIds = server.getLanguageIds();
+		if (languageIds.length === 0) return void 0;
+		return {
+			".ts": "typescript",
+			".tsx": "typescriptreact",
+			".js": "javascript",
+			".jsx": "javascriptreact",
+			".mjs": "javascript",
+			".cjs": "javascript",
+			".mts": "typescript",
+			".cts": "typescript"
+		}[extension] ?? languageIds[0];
+	}
+	function getServerForFile(filePath) {
+		const ext = filePath.slice(filePath.lastIndexOf(".")).toLowerCase();
+		const server = extensionMap.get(ext);
+		if (server && !brokenServers.has(server.getServerId())) return server;
+	}
+	function getLanguageForFile(filePath, server) {
+		return findLanguageId(filePath.slice(filePath.lastIndexOf(".")).toLowerCase(), server) ?? "plaintext";
+	}
+	async function ensureFileOpened(filePath, server, content) {
+		const uri = `file://${filePath}`;
+		if (openedFiles.has(uri)) return;
+		const languageId = getLanguageForFile(filePath, server);
+		try {
+			await server.ensureDocumentOpened(uri, languageId, content ?? "");
+			openedFiles.set(uri, {
+				serverId: server.getServerId(),
+				languageId,
+				version: 1
+			});
+		} catch (err) {
+			if (process.env.ZAPMYCO_LSP_TRACE) process.stderr.write(`[lsp-manager] ensureFileOpened failed: ${err instanceof Error ? err.message : String(err)}\n`);
+		}
+	}
+	async function init(serverConfigs, root) {
+		workspaceRoot = root;
+		extensionMap.clear();
+		servers.length = 0;
+		brokenServers.clear();
+		for (const config of serverConfigs) {
+			const extensions = config.extensions ?? [];
+			const languageIds = config.languageIds ?? [];
+			const instance = createLspServerInstance({
+				serverId: config.name,
+				clientConfig: {
+					command: config.command,
+					args: config.args ?? void 0,
+					env: config.env ?? void 0,
+					connectTimeoutMs: config.connectTimeoutMs ?? void 0,
+					requestTimeoutMs: config.requestTimeoutMs ?? void 0
+				},
+				languageIds,
+				extensions,
+				initializationOptions: config.initializationOptions
+			});
+			servers.push(instance);
+			for (const ext of extensions) {
+				const normalized = ext.toLowerCase();
+				if (!extensionMap.has(normalized)) extensionMap.set(normalized, instance);
+			}
+		}
+		initialized = true;
+	}
+	async function onFileOpened(filePath, content) {
+		if (!initialized) return;
+		const server = getServerForFile(filePath);
+		if (!server) return;
+		if (server.getState() === "stopped" || server.getState() === "error") try {
+			await server.initialize(`file://${workspaceRoot}`);
+		} catch {
+			brokenServers.add(server.getServerId());
+			return;
+		}
+		await ensureFileOpened(filePath, server, content);
+	}
+	async function onFileChanged(filePath, content) {
+		const uri = `file://${filePath}`;
+		const opened = openedFiles.get(uri);
+		if (!opened) {
+			await onFileOpened(filePath, content);
+			return;
+		}
+		const server = servers.find((s) => s.getServerId() === opened.serverId);
+		if (server && server.getState() === "running") await server.notifyDocumentChanged(uri, content);
+	}
+	async function onFileClosed(filePath) {
+		const uri = `file://${filePath}`;
+		const opened = openedFiles.get(uri);
+		if (opened) {
+			const server = servers.find((s) => s.getServerId() === opened.serverId);
+			if (server) await server.notifyDocumentClosed(uri);
+			openedFiles.delete(uri);
+		}
+	}
+	async function request(filePath, method, params) {
+		if (!initialized) throw new LspError("LSP manager not initialized", "NOT_INITIALIZED");
+		const server = getServerForFile(filePath);
+		if (!server) throw new LspError(`No LSP server available for file: ${filePath}`, "NO_SERVER");
+		if (server.getState() === "stopped" || server.getState() === "error") try {
+			await server.initialize(`file://${workspaceRoot}`);
+		} catch (err) {
+			brokenServers.add(server.getServerId());
+			throw new LspError(`Failed to start LSP server for ${filePath}: ${err instanceof Error ? err.message : String(err)}`, "SERVER_START_FAILED");
+		}
+		await ensureFileOpened(filePath, server);
+		return server.request(method, params);
+	}
+	function getStatus() {
+		return {
+			serverCount: servers.length,
+			runningCount: servers.filter((s) => s.getState() === "running").length,
+			errorCount: brokenServers.size,
+			servers: servers.map((s) => ({
+				serverId: s.getServerId(),
+				state: s.getState(),
+				extensions: s.getExtensions()
+			}))
 		};
-		if (Array.isArray(config.args)) server.args = config.args;
-		if (config.env && typeof config.env === "object") server.env = config.env;
-		if (typeof config.cwd === "string") server.cwd = config.cwd;
-		if (typeof config.enabled === "boolean") server.enabled = config.enabled;
-		if (typeof config.connectTimeoutMs === "number") server.connectTimeoutMs = config.connectTimeoutMs;
-		servers.push(server);
 	}
-	return servers;
+	async function shutdown() {
+		for (const [uri] of openedFiles) {
+			const opened = openedFiles.get(uri);
+			if (opened) {
+				const server = servers.find((s) => s.getServerId() === opened.serverId);
+				if (server) try {
+					await server.notifyDocumentClosed(uri);
+				} catch {}
+			}
+		}
+		openedFiles.clear();
+		for (const server of servers) try {
+			await server.shutdown();
+		} catch {}
+		servers.length = 0;
+		extensionMap.clear();
+		brokenServers.clear();
+		initialized = false;
+	}
+	return {
+		init,
+		onFileOpened,
+		onFileChanged,
+		onFileClosed,
+		request,
+		getServerForFile,
+		getStatus,
+		shutdown
+	};
 }
 
 //#endregion
@@ -10080,7 +13415,7 @@ function normalizeMcpConfig(raw) {
 *
 * @module core/mcp/client
 */
-const log$7 = logger.child("mcp:client");
+const log$6 = logger.child("mcp:client");
 /**
 * 连接到单个 MCP Server 并发现其工具
 *
@@ -10116,7 +13451,7 @@ async function connectMcpServer(config, signal) {
 		await withTimeout(client.connect(transport), timeoutMs);
 		const { tools: rawTools } = await withTimeout(client.listTools(), timeoutMs);
 		const tools = rawTools ?? [];
-		log$7.debug(`MCP server "${serverName}" 已连接，发现 ${tools.length} 个工具`);
+		log$6.debug(`MCP server "${serverName}" 已连接，发现 ${tools.length} 个工具`);
 		return {
 			client,
 			transport,
@@ -10124,7 +13459,7 @@ async function connectMcpServer(config, signal) {
 			serverName
 		};
 	} catch (error) {
-		log$7.warn(`MCP server "${serverName}" 连接失败: ${error instanceof Error ? error.message : String(error)}`);
+		log$6.warn(`MCP server "${serverName}" 连接失败: ${error instanceof Error ? error.message : String(error)}`);
 		return null;
 	}
 }
@@ -10138,7 +13473,7 @@ async function closeMcpServer(conn) {
 	try {
 		await conn.client.close();
 	} catch {}
-	log$7.debug(`MCP server "${conn.serverName}" 已断开`);
+	log$6.debug(`MCP server "${conn.serverName}" 已断开`);
 }
 /**
 * 简单的超时工具：promise 在 ms 毫秒内未完成则 reject
@@ -10191,7 +13526,7 @@ function mcpToolToRegistration(mcpTool, serverName, client) {
 
 //#endregion
 //#region src/core/mcp/index.ts
-const log$6 = logger.child("mcp");
+const log$5 = logger.child("mcp");
 /**
 * MCP 连接生命周期管理器
 *
@@ -10212,9 +13547,9 @@ var McpManager = class {
 	async initialize(servers) {
 		const enabledServers = servers.filter((s) => s.enabled !== false);
 		if (enabledServers.length === 0) return [];
-		log$6.info(`正在连接 ${enabledServers.length} 个 MCP Server...`);
+		log$5.info(`正在连接 ${enabledServers.length} 个 MCP Server...`);
 		const connectedCount = (await Promise.allSettled(enabledServers.map((config) => this.connectAndCollect(config)))).filter((r) => r.status === "fulfilled" && r.value !== null).length;
-		log$6.info(`MCP: ${connectedCount}/${enabledServers.length} 个 Server 已连接，共 ${this.toolRegistrations.length} 个工具`);
+		log$5.info(`MCP: ${connectedCount}/${enabledServers.length} 个 Server 已连接，共 ${this.toolRegistrations.length} 个工具`);
 		return this.toolRegistrations;
 	}
 	/**
@@ -10222,7 +13557,7 @@ var McpManager = class {
 	*/
 	async shutdown() {
 		if (this.connections.length === 0) return;
-		log$6.info(`正在关闭 ${this.connections.length} 个 MCP 连接...`);
+		log$5.info(`正在关闭 ${this.connections.length} 个 MCP 连接...`);
 		await Promise.allSettled(this.connections.map((conn) => closeMcpServer(conn)));
 		this.connections = [];
 		this.toolRegistrations = [];
@@ -10455,7 +13790,7 @@ var TaskStore = class {
 *
 * @module security/approval-manager
 */
-const log$5 = logger.child("approval-manager");
+const log$4 = logger.child("approval-manager");
 var ApprovalManager = class {
 	provider = null;
 	constructor(provider) {
@@ -10484,7 +13819,7 @@ var ApprovalManager = class {
 	*/
 	async requestApproval(request) {
 		if (!this.provider) {
-			log$5.warn("无审批提供者，自动拒绝审批请求", {
+			log$4.warn("无审批提供者，自动拒绝审批请求", {
 				toolId: request.toolId,
 				risk: request.risk
 			});
@@ -10507,7 +13842,7 @@ var ApprovalManager = class {
 					toolId: request.toolId,
 					scope: response.scope ?? "once"
 				});
-				log$5.debug("审批通过", {
+				log$4.debug("审批通过", {
 					toolId: request.toolId,
 					scope: response.scope
 				});
@@ -10516,11 +13851,11 @@ var ApprovalManager = class {
 					toolId: request.toolId,
 					reason: "用户拒绝"
 				});
-				log$5.debug("审批被拒绝", { toolId: request.toolId });
+				log$4.debug("审批被拒绝", { toolId: request.toolId });
 			}
 			return response;
 		} catch (err) {
-			log$5.error("审批提供者异常，自动拒绝", {
+			log$4.error("审批提供者异常，自动拒绝", {
 				toolId: request.toolId,
 				error: err instanceof Error ? err.message : String(err)
 			});
@@ -10543,7 +13878,7 @@ var ApprovalManager = class {
 *
 * @module security/audit-logger
 */
-const log$4 = logger.child("audit-logger");
+const log$3 = logger.child("audit-logger");
 /** 默认审计日志目录 */
 const AUDIT_DIR = join(homedir(), ".zapmyco", "logs");
 /** 审计日志文件名 */
@@ -10583,7 +13918,7 @@ var AuditLogger = class {
 			});
 		};
 		eventBus.on("security:violation", this.violationListener);
-		log$4.debug("审计日志初始化", {
+		log$3.debug("审计日志初始化", {
 			path: this.filePath,
 			level: this.level
 		});
@@ -10638,7 +13973,7 @@ var AuditLogger = class {
 			if (!existsSync(this.filePath)) return [];
 			return readFileSync(this.filePath, "utf-8").trim().split("\n").filter(Boolean).map((line) => JSON.parse(line));
 		} catch {
-			log$4.warn("读取审计日志失败");
+			log$3.warn("读取审计日志失败");
 			return [];
 		}
 	}
@@ -10657,7 +13992,7 @@ var AuditLogger = class {
 			this.violationListener = null;
 		}
 		this.flush();
-		log$4.debug("审计日志已关闭");
+		log$3.debug("审计日志已关闭");
 	}
 	/**
 	* 将缓冲写入文件
@@ -10670,7 +14005,7 @@ var AuditLogger = class {
 			const lines = entries.map((e) => JSON.stringify(e)).join("\n") + "\n";
 			appendFileSync(this.filePath, lines, "utf-8");
 		} catch (err) {
-			log$4.error("审计日志写入失败", { error: err instanceof Error ? err.message : String(err) });
+			log$3.error("审计日志写入失败", { error: err instanceof Error ? err.message : String(err) });
 			if (this.buffer.length < 1e3) this.buffer = [...entries, ...this.buffer];
 		}
 	}
@@ -10789,7 +14124,7 @@ function matchParamPatterns(paramPatterns, actualParams) {
 
 //#endregion
 //#region src/security/permission-engine.ts
-const log$3 = logger.child("permission-engine");
+const log$2 = logger.child("permission-engine");
 var PermissionEngine = class {
 	config;
 	store;
@@ -10814,7 +14149,7 @@ var PermissionEngine = class {
 		};
 		const toolInfo = this.resolveToolInfo(toolId);
 		for (const rule of BUILTIN_DENY_RULES) if (matchToolPattern(rule.toolPattern, toolId)) {
-			log$3.debug("命中内置拒绝规则", {
+			log$2.debug("命中内置拒绝规则", {
 				toolId,
 				rule: rule.toolPattern
 			});
@@ -10827,7 +14162,7 @@ var PermissionEngine = class {
 			};
 		}
 		for (const rule of this.config.denyRules) if (matchToolPattern(rule.toolPattern, toolId) && matchParamPatterns(rule.paramPatterns, params)) {
-			log$3.debug("命中用户拒绝规则", {
+			log$2.debug("命中用户拒绝规则", {
 				toolId,
 				ruleId: rule.id ?? rule.toolPattern
 			});
@@ -10856,7 +14191,7 @@ var PermissionEngine = class {
 			};
 		}
 		for (const rule of this.config.allowRules) if (matchToolPattern(rule.toolPattern, toolId) && matchParamPatterns(rule.paramPatterns, params)) {
-			log$3.debug("命中用户允许规则", {
+			log$2.debug("命中用户允许规则", {
 				toolId,
 				ruleId: rule.id ?? rule.toolPattern
 			});
@@ -10869,7 +14204,7 @@ var PermissionEngine = class {
 			};
 		}
 		if (this.store.hasSessionApproval(toolId)) {
-			log$3.debug("命中会话级审批", { toolId });
+			log$2.debug("命中会话级审批", { toolId });
 			return {
 				action: "allow",
 				risk: "low",
@@ -10877,7 +14212,7 @@ var PermissionEngine = class {
 			};
 		}
 		if (this.store.hasPersistentApproval(toolId)) {
-			log$3.debug("命中持久化审批", { toolId });
+			log$2.debug("命中持久化审批", { toolId });
 			return {
 				action: "allow",
 				risk: "low",
@@ -10923,7 +14258,7 @@ var PermissionEngine = class {
 		try {
 			return toolInfo.checkPermission(params);
 		} catch (err) {
-			log$3.warn("工具 checkPermission 执行异常", {
+			log$2.warn("工具 checkPermission 执行异常", {
 				toolId,
 				error: err instanceof Error ? err.message : String(err)
 			});
@@ -11011,7 +14346,7 @@ var PermissionEngine = class {
 *
 * @module security/permission-store
 */
-const log$2 = logger.child("permission-store");
+const log$1 = logger.child("permission-store");
 function getStoragePath() {
 	return join(homedir(), ".zapmyco", "permissions.json");
 }
@@ -11082,7 +14417,7 @@ var PermissionStore = class {
 		const before = this.persistentApprovals.length;
 		this.persistentApprovals = this.persistentApprovals.filter((a) => a.expiresAt === 0 || a.expiresAt > now);
 		if (this.persistentApprovals.length < before) {
-			log$2.debug("清理过期审批条目", { removed: before - this.persistentApprovals.length });
+			log$1.debug("清理过期审批条目", { removed: before - this.persistentApprovals.length });
 			this.saveToFile();
 		}
 	}
@@ -11113,7 +14448,7 @@ var PermissionStore = class {
 			const raw = readFileSync(getStoragePath(), "utf-8");
 			const data = JSON.parse(raw);
 			this.persistentApprovals = Array.isArray(data.approvals) ? data.approvals : [];
-			log$2.debug("已加载持久化审批记录", { count: this.persistentApprovals.length });
+			log$1.debug("已加载持久化审批记录", { count: this.persistentApprovals.length });
 		} catch {
 			this.persistentApprovals = [];
 		}
@@ -11129,7 +14464,7 @@ var PermissionStore = class {
 			const data = { approvals: this.persistentApprovals };
 			writeFileSync(getStoragePath(), JSON.stringify(data, null, 2), "utf-8");
 		} catch (err) {
-			log$2.warn("保存权限持久化文件失败", { error: err instanceof Error ? err.message : String(err) });
+			log$1.warn("保存权限持久化文件失败", { error: err instanceof Error ? err.message : String(err) });
 		}
 	}
 };
@@ -11427,155 +14762,6 @@ function threatSeverity(level) {
 	}
 }
 
-//#endregion
-//#region src/security/tool-guard.ts
-const log$1 = logger.child("tool-guard");
-/**
-* 安全阻止错误
-*
-* 当工具调用被权限引擎拒绝时抛出。
-* 调用方（agent-adapter / session）应捕获此错误
-* 并转换为 LLM 友好的错误反馈。
-*/
-var SecurityBlockedError = class extends Error {
-	toolId;
-	risk;
-	reason;
-	constructor(message, toolId, risk, reason) {
-		super(message);
-		this.name = "SecurityBlockedError";
-		this.toolId = toolId;
-		this.risk = risk;
-		this.reason = reason;
-	}
-};
-var ToolGuard = class {
-	engine;
-	approvalManager;
-	store;
-	sessionId;
-	auditLogger;
-	constructor(engine, approvalManager, store, sessionId, auditLogger) {
-		this.engine = engine;
-		this.approvalManager = approvalManager;
-		this.store = store;
-		this.sessionId = sessionId ?? `session-${Date.now()}`;
-		this.auditLogger = auditLogger;
-	}
-	/**
-	* 包装单个 ToolRegistration
-	*
-	* 返回新 ToolRegistration，原对象不变。
-	* execute 被替换为带安全检查的版本。
-	*/
-	wrap(registration) {
-		const originalExecute = registration.execute;
-		const toolId = registration.id;
-		const toolLabel = registration.label;
-		const guardedExecute = async (toolCallId, params, signal, onUpdate) => {
-			const decision = this.engine.evaluate(toolId, params);
-			if (decision.action === "deny") {
-				const reason = decision.reason ?? `工具 ${toolId} 已被安全策略阻止`;
-				log$1.warn("工具调用被阻止", {
-					toolId,
-					risk: decision.risk,
-					reason
-				});
-				eventBus.emit("security:blocked", {
-					toolId,
-					risk: decision.risk,
-					reason,
-					params
-				});
-				this.auditLogger?.log({
-					action: "BLOCK",
-					toolId,
-					risk: decision.risk,
-					reason,
-					params,
-					...decision.matchedRule ? { matchedRule: decision.matchedRule } : {}
-				});
-				throw new SecurityBlockedError(reason, toolId, decision.risk, reason);
-			}
-			if (decision.action === "ask") {
-				this.auditLogger?.log({
-					action: "APPROVAL_REQUESTED",
-					toolId,
-					risk: decision.risk,
-					params,
-					...decision.reason ? { reason: decision.reason } : {}
-				});
-				const approvalResponse = await this.approvalManager.requestApproval({
-					toolId,
-					toolLabel,
-					params,
-					risk: decision.risk,
-					reason: decision.reason ?? `工具 ${toolId} 需要审批`,
-					sessionId: this.sessionId
-				});
-				if (!approvalResponse.approved) {
-					const reason = `用户拒绝了工具 ${toolId} 的执行请求`;
-					log$1.info("用户拒绝工具执行", { toolId });
-					this.auditLogger?.log({
-						action: "APPROVAL_DENIED",
-						toolId,
-						risk: decision.risk,
-						reason
-					});
-					throw new SecurityBlockedError(reason, toolId, decision.risk, reason);
-				}
-				if (approvalResponse.scope === "session") this.store.addSessionApproval(toolId);
-				else if (approvalResponse.scope === "always") this.store.addPersistentApproval(toolId);
-				this.auditLogger?.log({
-					action: "APPROVAL_GRANTED",
-					toolId,
-					risk: decision.risk,
-					...approvalResponse.scope ? { scope: approvalResponse.scope } : {},
-					...decision.reason ? { reason: decision.reason } : {}
-				});
-				log$1.debug("审批通过，执行工具", {
-					toolId,
-					scope: approvalResponse.scope
-				});
-			} else this.auditLogger?.log({
-				action: "ALLOW",
-				toolId,
-				risk: decision.risk,
-				params,
-				...decision.matchedRule ? { matchedRule: decision.matchedRule } : {}
-			});
-			return originalExecute(toolCallId, params, signal, onUpdate);
-		};
-		return {
-			...registration,
-			execute: guardedExecute
-		};
-	}
-	/**
-	* 批量包装所有工具
-	*/
-	wrapAll(registrations) {
-		return registrations.map((reg) => this.wrap(reg));
-	}
-};
-/**
-* 从 ToolRegistration 数组构建 ToolInfoResolver
-*
-* 供 PermissionEngine 使用，将 toolId 映射到其安全信息。
-*/
-function createToolInfoResolver(registrations) {
-	const map = /* @__PURE__ */ new Map();
-	for (const reg of registrations) map.set(reg.id, reg);
-	return (toolId) => {
-		const reg = map.get(toolId);
-		if (!reg) return void 0;
-		return {
-			checkPermission: reg.checkPermission,
-			defaultRisk: reg.defaultRisk
-		};
-	};
-}
-
 //#endregion
 //#region src/cli/repl/session.ts
 /**
@@ -11645,6 +14831,7 @@ const DEFAULT_CONTINUATION_PROMPT = "... ";
 * REPL 会话实现
 */
 var ReplSession = class {
+	config;
 	tui;
 	editor;
 	outputArea;
@@ -11659,6 +14846,10 @@ var ReplSession = class {
 	agent;
 	/** MCP 连接管理器（在 registerBuiltinTools 中异步初始化） */
 	mcpManager = null;
+	/** LSP 服务器管理器（在 registerBuiltinTools 中异步初始化） */
+	lspManager = null;
+	/** LSP 诊断收集器 */
+	diagnosticCollector = null;
 	/** 当前正在执行的 taskId（用于取消操作） */
 	currentTaskId = null;
 	/** 多轮对话上下文（兼容保留，Agent 内部也维护历史） */
@@ -11667,6 +14858,8 @@ var ReplSession = class {
 	cronScheduler = null;
 	/** 任务管理器（会话级持久化） */
 	taskStore;
+	/** Worktree 隔离管理器 */
+	worktreeManager;
 	/** 安全框架组件 */
 	permissionStore;
 	permissionEngine;
@@ -11675,6 +14868,8 @@ var ReplSession = class {
 	auditLogger;
 	secretRedactor;
 	skillGuard;
+	/** 交互式提问管理器 */
+	questionManager;
 	stats = {
 		totalRequests: 0,
 		successCount: 0,
@@ -11718,6 +14913,7 @@ var ReplSession = class {
 		this.taskStore.load();
 		this.cronScheduler = new CronScheduler(getCronStore(), { isIdle: () => this._state === "idle" });
 		this.cronScheduler.start();
+		this.initWorktreeManager();
 		const memoryStore = getMemoryStore();
 		memoryStore.freezeSnapshot().then(() => {
 			this.agent.memorySnapshot = memoryStore.getSnapshot();
@@ -11727,6 +14923,8 @@ var ReplSession = class {
 		});
 		if (this.config.skill?.enabled !== false) this.initSkills();
 		this.initSecurity();
+		this.questionManager = getQuestionManager();
+		this.questionManager.setProvider(createTuiQuestionProvider(this.tui));
 		this.registerBuiltinCommands();
 		this.registerBuiltinTools();
 		this.setupEditorHandlers();
@@ -11754,6 +14952,7 @@ var ReplSession = class {
 		this.updateStatsState();
 		log.info("REPL 关闭", { reason: reason ?? "未知" });
 		this.cancelCurrentTask();
+		if (this.questionManager) this.questionManager.rejectAll(/* @__PURE__ */ new Error("会话已关闭"));
 		this.editor.setExecuting(false);
 		eventBus.emit("system:shutdown", { reason });
 		if (this.cronScheduler) {
@@ -11765,6 +14964,14 @@ var ReplSession = class {
 			await this.mcpManager.shutdown();
 			this.mcpManager = null;
 		}
+		if (this.lspManager) {
+			await this.lspManager.shutdown();
+			this.lspManager = null;
+		}
+		if (this.diagnosticCollector) {
+			this.diagnosticCollector.clear();
+			this.diagnosticCollector = null;
+		}
 		this.tui.stop();
 		process.exit(0);
 	}
@@ -12201,6 +15408,28 @@ var ReplSession = class {
 	/**
 	* 初始化安全框架
 	*
+	/**
+	* 初始化 WorktreeManager
+	*
+	* 创建 git worktree 隔离管理器，注册为全局实例，
+	* 并启动过期 worktree 清理。
+	*/
+	initWorktreeManager() {
+		const rawConfig = this.config.worktree ?? {};
+		const worktreeConfig = {
+			enabled: true,
+			autoCleanNoChanges: true,
+			expireAfterMs: 1440 * 60 * 1e3,
+			baseDir: join(homedir(), ".zapmyco", "worktrees"),
+			...rawConfig
+		};
+		this.worktreeManager = new WorktreeManager(worktreeConfig);
+		setWorktreeManager(this.worktreeManager);
+		this.worktreeManager.cleanExpired().catch((err) => {
+			log.warn("过期 worktree 清理失败", { error: err instanceof Error ? err.message : String(err) });
+		});
+	}
+	/**
 	* 创建 PermissionEngine → ApprovalManager → ToolGuard 管道。
 	* 必须在 registerBuiltinTools() 之前调用。
 	*/
@@ -12318,7 +15547,7 @@ var ReplSession = class {
 	* MCP 工具在连接完成后自动追加。
 	*/
 	registerBuiltinTools() {
-		const rawTools = createReplBuiltinTools(this.config.web, this.taskStore, this.config.skill, this.agent, this.config.subAgent, this.cronScheduler ?? void 0, this.config.agentTeam);
+		const rawTools = createReplBuiltinTools(this.config.web, this.taskStore, this.config.skill, this.agent, this.config.subAgent, this.cronScheduler ?? void 0, this.config.agentTeam, this.worktreeManager);
 		this.permissionEngine.setToolInfoResolver(createToolInfoResolver(rawTools));
 		const guardedTools = this.toolGuard.wrapAll(rawTools);
 		this.agent.registerTools(guardedTools);
@@ -12328,6 +15557,29 @@ var ReplSession = class {
 		}).catch((err) => {
 			log.error("MCP 初始化失败", { error: err instanceof Error ? err.message : String(err) });
 		});
+		if (this.config.lsp?.enabled !== false) {
+			const lspServers = resolveLspConfig(this.config.lsp);
+			if (lspServers.length > 0) {
+				this.lspManager = createLspServerManager();
+				this.lspManager.init(lspServers, process.cwd()).catch((err) => {
+					log.error("LSP 初始化失败", { error: err instanceof Error ? err.message : String(err) });
+				});
+				rawTools.push(createLspTool(this.lspManager));
+				this.diagnosticCollector = createDiagnosticCollector();
+				this.diagnosticCollector.init(this.lspManager);
+				const readFileTool = rawTools.find((t) => t.id === "ReadFile");
+				if (readFileTool && this.lspManager) {
+					const lspManagerRef = this.lspManager;
+					const originalExecute = readFileTool.execute;
+					readFileTool.execute = async (toolCallId, params, signal, onUpdate) => {
+						const result = await originalExecute(toolCallId, params, signal, onUpdate);
+						const filePath = params?.file_path;
+						if (filePath && typeof filePath === "string" && !result.details?.error) lspManagerRef.onFileOpened(filePath, "").catch(() => {});
+						return result;
+					};
+				}
+			}
+		}
 	}
 	/**
 	* 初始化 Skill 系统