zapmyco 0.3.0 → 0.4.0

package/dist/cli/index.mjs

@@ -1,14 +1,25 @@
 #!/usr/bin/env node
-import { D as __VERSION__, E as APP_NAME, T as eventBus, f as WebError, g as createLlmBasedAgent, m as ZapmycoErrorCode, o as logger, t as loadConfig } from "../loader-BNgN6Pz5.mjs";
+import { D as buildSkillSnapshot, E as eventBus, M as __VERSION__, N as __require, O as loadSkills, _ as createLlmBasedAgent, a as SubAgentManager, h as ZapmycoErrorCode, j as APP_NAME, p as WebError, s as logger, t as loadConfig } from "../loader-BK1Z72gI.mjs";
+import { createHash, randomBytes } from "node:crypto";
+import { mkdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
+import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import * as os from "node:os";
+import { homedir } from "node:os";
+import * as path from "node:path";
+import { dirname, isAbsolute, join, normalize, resolve } from "node:path";
+import { EventEmitter } from "node:events";
 import chalk, { Chalk } from "chalk";
 import { Command } from "commander";
 import { getModel } from "@mariozechner/pi-ai";
 import { Container, Editor, Key, ProcessTerminal, TUI, matchesKey, truncateToWidth, wrapTextWithAnsi } from "@mariozechner/pi-tui";
+import { spawn } from "node:child_process";
 import TurndownService from "turndown";
 import { lookup } from "node:dns/promises";
+import { Client } from "@modelcontextprotocol/sdk/client";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
 
 //#region src/cli/repl/command-registry.ts
-const log$1 = logger.child("repl:command-registry");
+const log$5 = logger.child("repl:command-registry");
 /**
 * 命令注册表
 */
@@ -23,7 +34,7 @@ var CommandRegistry = class {
 	*/
 	register(cmd) {
 		const canonicalName = cmd.name.toLowerCase();
-		if (this.commands.has(canonicalName)) log$1.warn(`命令 "${canonicalName}" 已存在，将被覆盖`);
+		if (this.commands.has(canonicalName)) log$5.warn(`命令 "${canonicalName}" 已存在，将被覆盖`);
 		this.commands.set(canonicalName, cmd);
 		for (const alias of cmd.aliases) {
 			const lowerAlias = alias.toLowerCase();
@@ -51,7 +62,7 @@ var CommandRegistry = class {
 	*/
 	async dispatch(parsed) {
 		if (parsed.kind !== "command") {
-			log$1.warn("dispatch 收到了非 command 类型的输入");
+			log$5.warn("dispatch 收到了非 command 类型的输入");
 			return;
 		}
 		const cmd = this.getCommand(parsed.name);
@@ -63,7 +74,7 @@ var CommandRegistry = class {
 			await cmd.handler(parsed.args, this.session);
 		} catch (error) {
 			const message = error instanceof Error ? error.message : String(error);
-			log$1.error(`命令 /${cmd.name} 执行出错`, {}, error);
+			log$5.error(`命令 /${cmd.name} 执行出错`, {}, error);
 			console.log(`\n  命令执行出错: ${message}\n`);
 		}
 	}
@@ -414,6 +425,644 @@ var ZapmycoEditor = class extends Editor {
 	}
 };
 
+//#endregion
+//#region src/cli/repl/cron/cron-parser.ts
+/** 通配符 * — 匹配所有值 */
+var WildcardMatcher = class {
+	matches(_value) {
+		return true;
+	}
+};
+/** 步进（每 N 个值匹配一次） */
+var StepMatcher = class {
+	step;
+	min;
+	constructor(step, min) {
+		this.step = step;
+		this.min = min;
+	}
+	matches(value) {
+		return (value - this.min) % this.step === 0;
+	}
+};
+/** 精确值 N */
+var ValueMatcher = class {
+	accepted;
+	constructor(values) {
+		this.accepted = new Set(values);
+	}
+	matches(value) {
+		return this.accepted.has(value);
+	}
+};
+/** 范围 N-M */
+var RangeMatcher = class {
+	start;
+	end;
+	constructor(start, end) {
+		this.start = start;
+		this.end = end;
+	}
+	matches(value) {
+		return value >= this.start && value <= this.end;
+	}
+};
+const FIELD_SPECS = [
+	{
+		name: "minute",
+		min: 0,
+		max: 59
+	},
+	{
+		name: "hour",
+		min: 0,
+		max: 23
+	},
+	{
+		name: "day-of-month",
+		min: 1,
+		max: 31
+	},
+	{
+		name: "month",
+		min: 1,
+		max: 12
+	},
+	{
+		name: "day-of-week",
+		min: 0,
+		max: 6
+	}
+];
+/**
+* 解析单个 cron 字段为 Matcher 数组
+*/
+function parseField(field, spec) {
+	const trimmed = field.trim();
+	if (trimmed.length === 0) return null;
+	const matchers = [];
+	const parts = trimmed.split(",");
+	for (const part of parts) {
+		const p = part.trim();
+		if (p.length === 0) return null;
+		const matcher = parseFieldPart(p, spec);
+		if (!matcher) return null;
+		matchers.push(matcher);
+	}
+	return matchers.length > 0 ? matchers : null;
+}
+function parseFieldPart(part, spec) {
+	if (part.startsWith("*/")) {
+		const step = parseInt(part.slice(2), 10);
+		if (isNaN(step) || step < 1) return null;
+		return new StepMatcher(step, spec.min);
+	}
+	if (part === "*") return new WildcardMatcher();
+	const rangeMatch = part.match(/^(\d+)-(\d+)$/);
+	if (rangeMatch) {
+		const start = parseInt(rangeMatch[1] ?? "", 10);
+		const end = parseInt(rangeMatch[2] ?? "", 10);
+		if (isNaN(start) || isNaN(end)) return null;
+		if (start < spec.min || end > spec.max || start > end) return null;
+		return new RangeMatcher(start, end);
+	}
+	const value = parseInt(part, 10);
+	if (!isNaN(value) && value >= spec.min && value <= spec.max) return new ValueMatcher([value]);
+	return null;
+}
+/**
+* 创建 CronSchedule
+* @param expr 5-field cron 表达式
+* @returns 解析后的 CronSchedule，无效表达式返回 null
+*/
+function createCronSchedule(expr) {
+	const fields = expr.trim().split(/\s+/);
+	if (fields.length !== 5) return null;
+	const parsedFields = [];
+	for (let i = 0; i < 5; i++) {
+		const matchers = parseField(fields[i] ?? "", FIELD_SPECS[i]);
+		if (!matchers) return null;
+		parsedFields.push(matchers);
+	}
+	return {
+		fields: parsedFields,
+		description: buildDescription(fields, parsedFields),
+		nextFrom(from) {
+			return computeNextFrom(from, parsedFields);
+		}
+	};
+}
+/**
+* 解析 cron 表达式
+* @param expr 5-field cron 表达式
+* @returns 解析后的 CronSchedule，无效表达式返回 null
+*/
+function parseCron(expr) {
+	return createCronSchedule(expr);
+}
+/**
+* 计算月份的最后一天
+*/
+function lastDayOfMonth(year, month) {
+	return new Date(year, month, 0).getDate();
+}
+/**
+* 计算下一次触发时间
+*
+* 算法：从起始时间开始逐分钟递增，直到所有字段匹配。
+* 使用月份/日期边界跳跃优化，避免过多次循环。
+*/
+function computeNextFrom(from, fields) {
+	const maxDate = new Date(from);
+	maxDate.setFullYear(maxDate.getFullYear() + 2);
+	let current = new Date(from.getTime() + 6e4);
+	current.setSeconds(0, 0);
+	let iterations = 0;
+	const MAX_ITERATIONS = 366 * 24 * 60;
+	while (current.getTime() <= maxDate.getTime()) {
+		iterations++;
+		if (iterations > MAX_ITERATIONS) return null;
+		const month = current.getMonth() + 1;
+		if (!matchersAnyMatch(month, fields[3])) {
+			current.setMonth(current.getMonth() + 1, 1);
+			current.setHours(0, 0, 0, 0);
+			continue;
+		}
+		const dom = current.getDate();
+		const maxDom = lastDayOfMonth(current.getFullYear(), month);
+		if (dom > maxDom || !matchersAnyMatch(dom <= maxDom ? dom : maxDom, fields[2])) {
+			const nextDay = new Date(current);
+			nextDay.setDate(nextDay.getDate() + 1);
+			nextDay.setHours(0, 0, 0, 0);
+			if (nextDay.getDate() === 1) current = nextDay;
+			else {
+				current.setDate(current.getDate() + 1);
+				current.setHours(0, 0, 0, 0);
+			}
+			continue;
+		}
+		if (!matchersAnyMatch(current.getDay(), fields[4])) {
+			current.setDate(current.getDate() + 1);
+			current.setHours(0, 0, 0, 0);
+			continue;
+		}
+		const hour = current.getHours();
+		if (!matchersAnyMatch(hour, fields[1])) {
+			current.setHours(hour + 1, 0, 0, 0);
+			continue;
+		}
+		const minute = current.getMinutes();
+		if (matchersAnyMatch(minute, fields[0])) return new Date(current);
+		current.setMinutes(minute + 1, 0, 0);
+	}
+	return null;
+}
+function matchersAnyMatch(value, matchers) {
+	for (const m of matchers) if (m.matches(value)) return true;
+	return false;
+}
+function buildDescription(rawFields, _parsedFields) {
+	const parts = [];
+	parts.push(describeField(rawFields[0] ?? "*", "分钟", "每", ""));
+	parts.push(describeField(rawFields[1] ?? "*", "小时", "", "点"));
+	const domStr = describeField(rawFields[2] ?? "*", "日", "每月", "号");
+	if (domStr.length > 0 && rawFields[2] !== "*") parts.push(domStr);
+	const monthStr = describeField(rawFields[3] ?? "*", "月", "", "月");
+	if (monthStr.length > 0 && rawFields[3] !== "*") parts.push(monthStr);
+	const dowStr = describeDow(rawFields[4] ?? "*");
+	if (dowStr.length > 0 && rawFields[4] !== "*") parts.push(dowStr);
+	if (parts.length === 0) return "每分钟";
+	return parts.join(" ");
+}
+function describeField(raw, unit, prefix, suffix) {
+	if (raw === "*") return "";
+	if (raw.startsWith("*/")) return `${prefix}每${raw.slice(2)}${unit}${suffix}`;
+	if (raw.includes(",")) return `${prefix}${raw}${unit}${suffix}`;
+	if (raw.includes("-")) return `${prefix}${raw.replace("-", "到")}${unit}${suffix}`;
+	return `${prefix}${raw}${unit}${suffix}`;
+}
+function describeDow(raw) {
+	const DOW_NAMES = {
+		"0": "周日",
+		"1": "周一",
+		"2": "周二",
+		"3": "周三",
+		"4": "周四",
+		"5": "周五",
+		"6": "周六"
+	};
+	if (raw === "*") return "";
+	if (raw.startsWith("*/")) return "";
+	if (raw.includes("-")) {
+		const parts = raw.split("-");
+		const start = parts[0] ?? "";
+		const end = parts[1] ?? "";
+		return `${DOW_NAMES[start] ?? start}到${DOW_NAMES[end] ?? end}`;
+	}
+	if (raw.includes(",")) return raw.split(",").map((d) => DOW_NAMES[d.trim()] ?? d.trim()).join("、");
+	return DOW_NAMES[raw] ?? raw;
+}
+/**
+* 检测启动时错过的一次性任务
+* 如果 nextFrom(createdAt) < now 且 lastFiredAt 为空，说明错过了
+*/
+function getMissedOneShotJobs(jobs, now) {
+	const missed = [];
+	for (const job of jobs) {
+		if (job.lastFiredAt) continue;
+		const schedule = parseCron(job.cron);
+		if (!schedule) continue;
+		const next = schedule.nextFrom(new Date(job.createdAt));
+		if (next && next.getTime() < now.getTime()) missed.push({
+			id: job.id,
+			createdAt: job.createdAt
+		});
+	}
+	return missed;
+}
+
+//#endregion
+//#region src/cli/repl/cron/types.ts
+const CRON_CONSTANTS = {
+	/** 最大任务数 */
+	MAX_JOBS: 50,
+	/** prompt 最大长度 */
+	MAX_PROMPT_LENGTH: 2e3,
+	/** 调度检查间隔（毫秒） */
+	CHECK_INTERVAL_MS: 1e3,
+	/** recurring 任务自动过期天数 */
+	AUTO_EXPIRE_DAYS: 7,
+	/** 最大过期天数上限 */
+	MAX_AUTO_EXPIRE_DAYS: 30,
+	/** 一次性错过任务最多补发次数 */
+	MAX_ONESHOT_MISSED_FIRE_COUNT: 5,
+	/** 补发任务间隔（毫秒） */
+	MISSED_FIRE_STAGGER_MS: 5e3
+};
+
+//#endregion
+//#region src/cli/repl/cron/cron-scheduler.ts
+/**
+* CronScheduler — 定时任务调度引擎
+*
+* 在 REPL 会话中运行，1 秒间隔检查到期任务。
+* 仅在 REPL 空闲时触发任务，使用确定性抖动分散负载。
+*
+* 设计要点:
+* - 1s setInterval 检查循环
+* - idle 门控: 仅当 REPL state === 'idle' 时触发
+* - timer.unref(): 不阻止进程退出
+* - 确定性 jitter: 基于 jobId 哈希
+* - 7 天自动过期: recurring 任务到期前触发最后一次
+* - 启动补发: 处理跨会话错过的一次性任务
+*
+* @module cli/repl/cron/cron-scheduler
+*/
+const log$4 = logger.child("cron:scheduler");
+var CronScheduler = class extends EventEmitter {
+	store;
+	jobs = [];
+	sessionJobs = [];
+	timer = null;
+	isIdle;
+	checkIntervalMs;
+	running = false;
+	missedAsked = /* @__PURE__ */ new Set();
+	constructor(store, options) {
+		super();
+		this.store = store;
+		this.isIdle = options.isIdle;
+		this.checkIntervalMs = options.checkIntervalMs ?? CRON_CONSTANTS.CHECK_INTERVAL_MS;
+	}
+	/** 启动调度器：加载 durable 任务，启动检查循环 */
+	async start() {
+		if (this.running) return;
+		const loadedJobs = await this.store.load();
+		this.jobs = loadedJobs;
+		log$4.info(`调度器启动，加载 ${loadedJobs.length} 个 durable 任务`);
+		await this.handleMissedJobs();
+		this.checkAutoExpiry();
+		this.running = true;
+		this.timer = setInterval(() => {
+			this.tick();
+		}, this.checkIntervalMs);
+		if (this.timer && typeof this.timer.unref === "function") this.timer.unref();
+	}
+	/** 停止调度器 */
+	stop() {
+		this.running = false;
+		if (this.timer) {
+			clearInterval(this.timer);
+			this.timer = null;
+		}
+		log$4.info("调度器已停止");
+	}
+	/** 添加任务 */
+	async addJob(job) {
+		if (this.jobs.length + this.sessionJobs.length >= CRON_CONSTANTS.MAX_JOBS) return `任务数已达上限（${CRON_CONSTANTS.MAX_JOBS}）`;
+		const schedule = parseCron(job.cron);
+		if (!schedule) return `无效的 cron 表达式: ${job.cron}`;
+		if (!schedule.nextFrom(/* @__PURE__ */ new Date())) return `cron 表达式在未来 365 天内无匹配: ${job.cron}`;
+		if (job.durable) {
+			this.jobs.push(job);
+			await this.store.persist(this.jobs);
+		} else this.sessionJobs.push(job);
+		log$4.info("任务已添加", {
+			id: job.id,
+			cron: job.cron,
+			durable: job.durable
+		});
+		return null;
+	}
+	/** 删除任务 */
+	async removeJob(id) {
+		const sessionIdx = this.sessionJobs.findIndex((j) => j.id === id);
+		if (sessionIdx >= 0) {
+			this.sessionJobs.splice(sessionIdx, 1);
+			return true;
+		}
+		const idx = this.jobs.findIndex((j) => j.id === id);
+		if (idx >= 0) {
+			this.jobs.splice(idx, 1);
+			await this.store.persist(this.jobs);
+			return true;
+		}
+		return false;
+	}
+	/** 更新任务 */
+	async updateJob(id, updates) {
+		const job = this.findJob(id);
+		if (!job) return `任务未找到: ${id}`;
+		if (updates.cron !== void 0) {
+			const schedule = parseCron(updates.cron);
+			if (!schedule) return `无效的 cron 表达式: ${updates.cron}`;
+			if (!schedule.nextFrom(/* @__PURE__ */ new Date())) return `cron 表达式在未来 365 天内无匹配: ${updates.cron}`;
+		}
+		Object.assign(job, updates);
+		if (job.durable) await this.store.persist(this.jobs);
+		return null;
+	}
+	/** 获取所有任务 */
+	getJobs() {
+		return [...this.jobs, ...this.sessionJobs];
+	}
+	/** 获取调度器状态 */
+	async getStatus() {
+		const allJobs = this.getJobs();
+		return {
+			running: this.running,
+			jobCount: allJobs.length,
+			enabledCount: allJobs.filter((j) => j.enabled).length,
+			durableCount: this.jobs.length,
+			sessionCount: this.sessionJobs.length
+		};
+	}
+	/** 立即触发指定任务（不改变调度） */
+	async triggerJob(id) {
+		const job = this.findJob(id);
+		if (!job) return `任务未找到: ${id}`;
+		if (!job.enabled) return `任务已暂停: ${id}`;
+		this.emit("fire", { job });
+		job.lastFiredAt = Date.now();
+		job.fireCount++;
+		if (job.durable) await this.store.persist(this.jobs);
+		return null;
+	}
+	/** 定时检查循环 */
+	async tick() {
+		if (!this.running) return;
+		if (!this.isIdle()) return;
+		const now = Date.now();
+		const dueJobs = this.getDueJobs(now);
+		if (dueJobs.length === 0) return;
+		for (const job of dueJobs) {
+			if (!this.isIdle()) break;
+			this.emit("fire", { job });
+			job.lastFiredAt = now;
+			job.fireCount++;
+			if (!job.recurring) await this.removeJob(job.id);
+			if (job.maxFires && job.fireCount >= job.maxFires) await this.removeJob(job.id);
+		}
+		if (dueJobs.some((j) => j.durable)) await this.store.persist(this.jobs);
+		this.checkAutoExpiry();
+	}
+	/** 获取到期任务（已应用 jitter） */
+	getDueJobs(nowMs) {
+		const allJobs = this.getJobs();
+		const due = [];
+		for (const job of allJobs) {
+			if (!job.enabled) continue;
+			const schedule = parseCron(job.cron);
+			if (!schedule) continue;
+			const fromMs = job.lastFiredAt ?? job.createdAt;
+			const from = new Date(fromMs);
+			const rawNext = schedule.nextFrom(from);
+			if (!rawNext) continue;
+			let nextMs = rawNext.getTime();
+			if (job.recurring) nextMs = applyRecurringJitter(job.id, nextMs, fromMs, schedule, from);
+			else nextMs = applyOneShotJitter(job.id, rawNext);
+			if (nowMs >= nextMs) due.push(job);
+		}
+		return due;
+	}
+	findJob(id) {
+		return this.jobs.find((j) => j.id === id) ?? this.sessionJobs.find((j) => j.id === id);
+	}
+	/** 处理启动时错过的一次性任务 */
+	async handleMissedJobs() {
+		const oneShotJobs = this.jobs.filter((j) => !j.recurring && !j.lastFiredAt);
+		if (oneShotJobs.length === 0) return;
+		const missed = getMissedOneShotJobs(oneShotJobs, /* @__PURE__ */ new Date());
+		if (missed.length === 0) return;
+		const toFire = missed.slice(0, CRON_CONSTANTS.MAX_ONESHOT_MISSED_FIRE_COUNT);
+		const toDelete = missed.slice(CRON_CONSTANTS.MAX_ONESHOT_MISSED_FIRE_COUNT);
+		for (const m of toDelete) {
+			this.missedAsked.add(m.id);
+			await this.removeJob(m.id);
+		}
+		for (let i = 0; i < toFire.length; i++) {
+			const m = toFire[i];
+			if (!m) continue;
+			const job = this.jobs.find((j) => j.id === m.id);
+			if (!job) continue;
+			const delay = i * CRON_CONSTANTS.MISSED_FIRE_STAGGER_MS;
+			setTimeout(() => {
+				if (!this.missedAsked.has(job.id)) {
+					this.missedAsked.add(job.id);
+					this.emit("fire", { job });
+					job.lastFiredAt = Date.now();
+					job.fireCount++;
+					this.removeJob(job.id);
+				}
+			}, delay);
+		}
+		if (toDelete.length > 0) {
+			log$4.info(`跳过 ${toDelete.length} 个错过的一次性任务（超出补发上限）`);
+			this.emit("missed-overflow", {
+				count: toDelete.length,
+				jobIds: toDelete.map((m) => m.id)
+			});
+		}
+	}
+	/** 检查 7 天自动过期 */
+	checkAutoExpiry() {
+		const now = Date.now();
+		const autoExpireMs = CRON_CONSTANTS.AUTO_EXPIRE_DAYS * 24 * 60 * 60 * 1e3;
+		for (const job of this.jobs) {
+			if (!job.recurring) continue;
+			if (job.durable && now - job.createdAt >= autoExpireMs) {
+				this.emit("fire", { job });
+				job.lastFiredAt = now;
+				job.fireCount++;
+				this.removeJob(job.id);
+				log$4.info("任务已过期并触发最后一次", { id: job.id });
+			}
+		}
+	}
+};
+/**
+* 基于 jobId 计算确定性抖动分数 [0, 1)
+* 使用 SHA256 前 8 位 hex 转换，纯数字 ID 回退到 parseInt
+*/
+function jitterFrac(jobId) {
+	if (/^[0-9a-fA-F]{8}$/.test(jobId)) {
+		const hash = createHash("sha256").update(jobId).digest("hex");
+		return parseInt(hash.slice(0, 8), 16) / 4294967295;
+	}
+	return 0;
+}
+/**
+* 循环任务抖动：正向延迟
+* 延迟 = jitterFrac * 10% * interval，上限 15 分钟
+*/
+function applyRecurringJitter(jobId, rawNextMs, _fromMs, schedule, from) {
+	if (!schedule) return rawNextMs;
+	const next1 = schedule.nextFrom(from);
+	if (!next1) return rawNextMs;
+	const next2 = schedule.nextFrom(next1);
+	if (!next2) return rawNextMs;
+	const intervalMs = next2.getTime() - next1.getTime();
+	if (intervalMs <= 0) return rawNextMs;
+	const frac = jitterFrac(jobId);
+	const delay = Math.min(frac * .1 * intervalMs, 900 * 1e3);
+	return rawNextMs + Math.floor(delay);
+}
+/**
+* 一次性任务抖动：反向（提前触发）
+* 仅对 :00 和 :30 分钟时刻生效，最多提前 90 秒
+*/
+function applyOneShotJitter(jobId, rawNext) {
+	const minutes = rawNext.getMinutes();
+	const ONE_SHOT_MINUTE_MOD = 30;
+	const ONE_SHOT_MAX_MS = 90 * 1e3;
+	const ONE_SHOT_FLOOR_MS = 0;
+	if (minutes % ONE_SHOT_MINUTE_MOD !== 0) return rawNext.getTime();
+	const early = ONE_SHOT_FLOOR_MS + jitterFrac(jobId) * (ONE_SHOT_MAX_MS - ONE_SHOT_FLOOR_MS);
+	return rawNext.getTime() - Math.floor(early);
+}
+
+//#endregion
+//#region src/cli/repl/cron/cron-store.ts
+/**
+* CronStore — 定时任务持久化存储
+*
+* 管理 ~/.zapmyco/cron/scheduled_tasks.json 文件，
+* 负责 durable 任务的跨会话恢复。
+*
+* 设计要点:
+* - 原子写入: 先写 .tmp 再 rename（防止部分写入损坏）
+* - 容错加载: JSON 损坏时降级为空列表，不阻塞启动
+* - 全局单例: 与 MemoryStore 相同的单例模式
+*
+* @module cli/repl/cron/cron-store
+*/
+const log$3 = logger.child("cron:store");
+const STORE_FILE = join(join(homedir(), ".zapmyco", "cron"), "scheduled_tasks.json");
+var CronStore = class {
+	filePath;
+	initialized = false;
+	constructor(customPath) {
+		if (customPath) this.filePath = join(customPath, "scheduled_tasks.json");
+		else this.filePath = STORE_FILE;
+	}
+	async initialize() {
+		if (this.initialized) return;
+		await mkdir(dirname(this.filePath), { recursive: true });
+		this.initialized = true;
+	}
+	/**
+	* 从文件加载 durable 任务
+	* JSON 损坏时返回空数组并记录警告，不抛异常
+	*/
+	async load() {
+		await this.initialize();
+		try {
+			const raw = await readFile(this.filePath, "utf-8");
+			const data = JSON.parse(raw);
+			if (!Array.isArray(data)) {
+				log$3.warn("存储文件格式无效（非数组），将使用空列表");
+				return [];
+			}
+			return this.validateJobs(data);
+		} catch (err) {
+			if (err.code === "ENOENT") return [];
+			log$3.warn("加载定时任务文件失败，将使用空列表", { error: err instanceof Error ? err.message : String(err) });
+			return [];
+		}
+	}
+	/**
+	* 将 durable 任务持久化到文件
+	* 原子写入：先写 .tmp 再 rename
+	*/
+	async persist(jobs) {
+		await this.initialize();
+		const durableJobs = jobs.filter((j) => j.durable);
+		const tmpPath = `${this.filePath}.tmp`;
+		await writeFile(tmpPath, JSON.stringify(durableJobs, null, 2), "utf-8");
+		await rename(tmpPath, this.filePath);
+	}
+	/** 生成唯一 jobId（8 位 hex） */
+	static generateId() {
+		return randomBytes(4).toString("hex");
+	}
+	/**
+	* 验证并清理加载的作业数据
+	* 跳过无效条目，确保必需字段存在
+	*/
+	validateJobs(raw) {
+		const valid = [];
+		for (const item of raw) {
+			if (!item || typeof item !== "object") continue;
+			const obj = item;
+			if (typeof obj.id !== "string" || obj.id.length === 0) continue;
+			if (typeof obj.cron !== "string" || obj.cron.length === 0) continue;
+			if (typeof obj.prompt !== "string") continue;
+			if (typeof obj.createdAt !== "number") continue;
+			const job = {
+				id: obj.id,
+				cron: obj.cron,
+				prompt: obj.prompt,
+				createdAt: obj.createdAt,
+				recurring: obj.recurring === true,
+				durable: obj.durable !== false,
+				enabled: obj.enabled !== false,
+				fireCount: typeof obj.fireCount === "number" ? obj.fireCount : 0
+			};
+			if (typeof obj.lastFiredAt === "number") job.lastFiredAt = obj.lastFiredAt;
+			if (typeof obj.lastError === "string") job.lastError = obj.lastError;
+			if (typeof obj.maxFires === "number") job.maxFires = obj.maxFires;
+			valid.push(job);
+		}
+		if (valid.length < raw.length) log$3.warn(`跳过 ${raw.length - valid.length} 个无效任务条目`);
+		return valid;
+	}
+};
+let globalStore$1 = null;
+function getCronStore() {
+	if (!globalStore$1) globalStore$1 = new CronStore();
+	return globalStore$1;
+}
+
 //#endregion
 //#region src/cli/repl/history-store.ts
 /** 默认最大历史条数 */
@@ -773,60 +1422,3535 @@ var OutputFormatter = class {
 };
 
 //#endregion
-//#region src/cli/repl/renderer.ts
-/**
-* 终端输出渲染器（TUI 适配版）
-*
-* 在 pi-tui 架构下，Renderer 不再直接 console.log，
-* 而是将格式化后的内容追加到 OutputArea 组件中。
-*/
+//#region src/cli/repl/renderer.ts
+/**
+* 终端输出渲染器（TUI 适配版）
+*
+* 在 pi-tui 架构下，Renderer 不再直接 console.log，
+* 而是将格式化后的内容追加到 OutputArea 组件中。
+*/
+/**
+* 渲染器实现
+*
+* 协调 OutputFormatter 和 OutputArea 之间的内容输出。
+*/
+var Renderer = class {
+	formatter;
+	constructor(opts) {
+		this.formatter = new OutputFormatter(opts.color);
+	}
+	/** 获取底层格式化器（供 OutputArea 直接使用） */
+	getFormatter() {
+		return this.formatter;
+	}
+	/** 渲染欢迎信息 → 返回格式化行 */
+	renderWelcome(version) {
+		return this.formatter.formatWelcome(version);
+	}
+	/** 渲染错误信息 → 返回格式化行 */
+	renderError(error) {
+		return this.formatter.formatError(error);
+	}
+	/** 渲染最终执行结果 → 返回格式化行 */
+	renderResult(result) {
+		return this.formatter.formatResult(result);
+	}
+	/** 渲染任务拆分概览 → 返回格式化行 */
+	renderTaskGraph(graph) {
+		return this.formatter.formatTaskGraph(graph);
+	}
+	/** 渲染 Agent 列表 → 返回格式化行 */
+	renderAgents(agents) {
+		return this.formatter.formatAgents(agents);
+	}
+	/** 渲染配置信息 → 返回格式化行 */
+	renderConfig(config) {
+		return this.formatter.formatConfig(config);
+	}
+	/** 渲染历史记录 → 返回格式化行 */
+	renderHistory(entries) {
+		return this.formatter.formatHistory(entries);
+	}
+	/** 渲染会话状态 → 返回格式化行 */
+	renderStatus(stats) {
+		return this.formatter.formatStatus(stats);
+	}
+};
+
+//#endregion
+//#region src/cli/repl/tools/cron-tool.ts
+/**
+* scheduled_task 工具实现 — 定时任务管理
+*
+* 参考 Claude Code 的 CronCreate/CronDelete/CronList 三工具设计
+* 和 OpenClaw/Hermes-Agent 的单工具 + action 模式，
+* 结合 zapmyco 现有 memory 工具的 action 路由风格。
+*
+* 设计要点:
+* - 单工具 + 8 action: create/list/update/remove/pause/resume/run/status
+* - 工厂函数 createCronTool(scheduler) 注入依赖
+* - 5-field cron 表达式，自定义解析器零外部依赖
+*
+* @module cli/repl/tools/cron-tool
+*/
+const CRON_TOOL_DESCRIPTION = `定时任务管理工具 — 创建和管理按 cron 表达式触发的自动化任务。
+
+## 何时使用
+- 用户要求"每天早上 9 点检查 XX" → create 循环任务
+- 用户要求"5 分钟后提醒我" → 计算 cron 表达式并 create
+- 用户要求"列出所有定时任务" → list
+- 用户要求"取消/暂停 XX 任务" → remove / pause
+- 用户要求"查看调度器状态" → status
+
+## 调度说明
+- 任务仅在当前 REPL 会话存活期间触发
+- durable=true 的任务会在下次启动时恢复
+- 循环任务默认 7 天后自动过期（触发最后一次后删除）
+- 调度器仅在 REPL 空闲时触发任务，不会中断正在执行的对话
+
+## Cron 表达式格式（5 字段）
+\`minute hour day-of-month month day-of-week\`
+
+| 字段 | 范围 | 说明 |
+|------|------|------|
+| minute | 0-59 | 分钟 |
+| hour | 0-23 | 小时 |
+| day-of-month | 1-31 | 每月第几天 |
+| month | 1-12 | 月份 |
+| day-of-week | 0-6 | 星期几（0=周日） |
+
+支持语法:
+- \`*\` 通配符 — 匹配所有值
+- \`*/N\` 步进 — 每隔 N 个单位
+- \`N\` 精确值
+- \`N-M\` 范围
+- \`N,M,O\` 列表（逗号分隔）
+
+示例:
+- \`0 9 * * *\` = 每天早上 9:00
+- \`*/5 * * * *\` = 每 5 分钟
+- \`0 9 * * 1-5\` = 工作日早上 9:00
+- \`30 14 28 2 *\` = 2 月 28 日下午 2:30（一次性）
+
+## 注意事项
+- 创建"5分钟后"类任务时，需要根据当前时间计算准确的 cron 表达式
+- 一次性任务（recurring=false）触发后自动删除
+- session 级任务（durable=false）在退出后不会恢复`;
+/**
+* 创建 scheduled_task 工具
+* @param scheduler CronScheduler 实例
+*/
+function createCronTool(scheduler) {
+	return {
+		id: "ScheduledTask",
+		label: "定时任务",
+		description: CRON_TOOL_DESCRIPTION,
+		parameters: {
+			type: "object",
+			properties: {
+				action: {
+					type: "string",
+					description: "操作类型: \"create\"(创建), \"list\"(列出), \"update\"(更新), \"remove\"(删除), \"pause\"(暂停), \"resume\"(恢复), \"run\"(立即执行), \"status\"(状态)。",
+					enum: [
+						"create",
+						"list",
+						"update",
+						"remove",
+						"pause",
+						"resume",
+						"run",
+						"status"
+					]
+				},
+				cron: {
+					type: "string",
+					description: "5 字段 cron 表达式（action=\"create\" 时必填，update 时可选）"
+				},
+				prompt: {
+					type: "string",
+					description: "任务触发时发送给 Agent 的 prompt 内容（action=\"create\" 时必填）"
+				},
+				recurring: {
+					type: "boolean",
+					description: "是否循环执行，默认 true。设为 false 则为一次性任务，触发后自动删除。"
+				},
+				durable: {
+					type: "boolean",
+					description: "是否持久化到文件（跨会话恢复），默认 false。仅当用户明确要求持久化时设为 true。"
+				},
+				max_fires: {
+					type: "number",
+					description: "最大执行次数，不设置则无限制。一次性任务默认为 1。"
+				},
+				job_id: {
+					type: "string",
+					description: "任务 ID（update/remove/pause/resume/run 操作需要）"
+				},
+				enabled: {
+					type: "boolean",
+					description: "是否启用（update 时使用，对应 pause/resume 操作）"
+				},
+				new_cron: {
+					type: "string",
+					description: "新的 cron 表达式（update 时使用）"
+				},
+				new_prompt: {
+					type: "string",
+					description: "新的 prompt 内容（update 时使用）"
+				}
+			},
+			required: ["action"]
+		},
+		async execute(_toolCallId, params) {
+			const action = params.action ?? "list";
+			switch (action) {
+				case "create": return buildCreateResult(scheduler, params);
+				case "list": return buildListResult$1(scheduler);
+				case "update": return buildUpdateResult$1(scheduler, params);
+				case "remove": return buildRemoveResult$1(scheduler, params);
+				case "pause": return buildPauseResult(scheduler, params);
+				case "resume": return buildResumeResult(scheduler, params);
+				case "run": return buildRunResult(scheduler, params);
+				case "status": return buildStatusResult(scheduler);
+				default: return {
+					content: [{
+						type: "text",
+						text: `不支持的操作: ${action}`
+					}],
+					details: {
+						action,
+						error: `不支持的操作: ${action}`
+					}
+				};
+			}
+		}
+	};
+}
+async function buildCreateResult(scheduler, params) {
+	const cron = params.cron?.trim();
+	const prompt = params.prompt?.trim();
+	if (!cron) return {
+		content: [{
+			type: "text",
+			text: "请提供 cron 参数（5 字段 cron 表达式）。"
+		}],
+		details: {
+			action: "create",
+			error: "cron 参数为空"
+		}
+	};
+	if (!prompt) return {
+		content: [{
+			type: "text",
+			text: "请提供 prompt 参数（任务触发时要执行的内容）。"
+		}],
+		details: {
+			action: "create",
+			error: "prompt 参数为空"
+		}
+	};
+	if (prompt.length > CRON_CONSTANTS.MAX_PROMPT_LENGTH) return {
+		content: [{
+			type: "text",
+			text: `prompt 过长（最大 ${CRON_CONSTANTS.MAX_PROMPT_LENGTH} 字符，当前 ${prompt.length} 字符）。`
+		}],
+		details: {
+			action: "create",
+			error: `prompt 过长: ${prompt.length} > ${CRON_CONSTANTS.MAX_PROMPT_LENGTH}`
+		}
+	};
+	const schedule = parseCron(cron);
+	if (!schedule) return {
+		content: [{
+			type: "text",
+			text: `无效的 cron 表达式: "${cron}"。请使用 5 字段格式。`
+		}],
+		details: {
+			action: "create",
+			error: `无效的 cron 表达式: ${cron}`
+		}
+	};
+	const now = Date.now();
+	const recurring = params.recurring !== false;
+	const maxFiresValue = params.max_fires ?? (!recurring ? 1 : void 0);
+	const job = {
+		id: CronStore.generateId(),
+		cron,
+		prompt,
+		createdAt: now,
+		recurring,
+		durable: params.durable === true,
+		enabled: true,
+		fireCount: 0
+	};
+	if (maxFiresValue !== void 0) job.maxFires = maxFiresValue;
+	const error = await scheduler.addJob(job);
+	if (error) return {
+		content: [{
+			type: "text",
+			text: `[创建失败] ${error}`
+		}],
+		details: {
+			action: "create",
+			error
+		}
+	};
+	const nextRun = schedule.nextFrom(/* @__PURE__ */ new Date());
+	const nextRunStr = nextRun ? nextRun.toISOString() : "无（表达式在未来 365 天内无匹配）";
+	const typeStr = recurring ? "循环" : "一次性";
+	const durableStr = job.durable ? "持久化" : "会话级";
+	return {
+		content: [{
+			type: "text",
+			text: [
+				`已创建${typeStr}定时任务:`,
+				`  ID: ${job.id}`,
+				`  调度: ${schedule.description}`,
+				`  Cron: ${cron}`,
+				`  类型: ${typeStr} / ${durableStr}`,
+				`  状态: 启用`,
+				`  下次触发: ${nextRunStr}`,
+				job.maxFires ? `  剩余次数: ${job.maxFires}` : ""
+			].filter(Boolean).join("\n")
+		}],
+		details: {
+			action: "create",
+			jobId: job.id,
+			cron,
+			recurring,
+			durable: job.durable,
+			nextRun: nextRunStr
+		}
+	};
+}
+async function buildListResult$1(scheduler) {
+	const jobs = scheduler.getJobs();
+	if (jobs.length === 0) return {
+		content: [{
+			type: "text",
+			text: "暂无定时任务。使用 action=\"create\" 创建一个。"
+		}],
+		details: {
+			action: "list",
+			jobs: []
+		}
+	};
+	const lines = [`共 ${jobs.length} 个定时任务:\n`];
+	let index = 0;
+	for (const job of jobs) {
+		index++;
+		const schedule = parseCron(job.cron);
+		const nextRun = schedule?.nextFrom(new Date(job.lastFiredAt ?? job.createdAt));
+		const nextStr = nextRun ? nextRun.toISOString() : "已过期";
+		const status = job.enabled ? "启用" : "暂停";
+		const type = job.recurring ? "循环" : "一次性";
+		const persist = job.durable ? "持久" : "会话";
+		lines.push(`${index}. [${status}] ${job.id}`, `   调度: ${schedule?.description ?? job.cron}`, `   类型: ${type} / ${persist} | 已触发: ${job.fireCount}次 | 下次: ${nextStr}`, `   任务: ${job.prompt.slice(0, 80)}${job.prompt.length > 80 ? "..." : ""}`, "");
+	}
+	return {
+		content: [{
+			type: "text",
+			text: lines.join("\n")
+		}],
+		details: {
+			action: "list",
+			count: jobs.length,
+			jobs: jobs.map((j) => ({
+				id: j.id,
+				cron: j.cron
+			}))
+		}
+	};
+}
+async function buildUpdateResult$1(scheduler, params) {
+	if (!params.job_id) return {
+		content: [{
+			type: "text",
+			text: "请提供 job_id 参数。"
+		}],
+		details: {
+			action: "update",
+			error: "job_id 参数为空"
+		}
+	};
+	const updates = {};
+	if (params.new_cron !== void 0) updates.cron = params.new_cron;
+	if (params.new_prompt !== void 0) updates.prompt = params.new_prompt;
+	if (params.enabled !== void 0) updates.enabled = params.enabled;
+	if (Object.keys(updates).length === 0) return {
+		content: [{
+			type: "text",
+			text: "请提供要更新的参数（new_cron / new_prompt / enabled）。"
+		}],
+		details: {
+			action: "update",
+			error: "无更新参数"
+		}
+	};
+	const error = await scheduler.updateJob(params.job_id, updates);
+	if (error) return {
+		content: [{
+			type: "text",
+			text: `[更新失败] ${error}`
+		}],
+		details: {
+			action: "update",
+			error
+		}
+	};
+	return {
+		content: [{
+			type: "text",
+			text: `任务 ${params.job_id} 已更新。`
+		}],
+		details: {
+			action: "update",
+			jobId: params.job_id,
+			updates
+		}
+	};
+}
+async function buildRemoveResult$1(scheduler, params) {
+	if (!params.job_id) return {
+		content: [{
+			type: "text",
+			text: "请提供 job_id 参数。"
+		}],
+		details: {
+			action: "remove",
+			error: "job_id 参数为空"
+		}
+	};
+	if (!await scheduler.removeJob(params.job_id)) return {
+		content: [{
+			type: "text",
+			text: `[删除失败] 任务未找到: ${params.job_id}`
+		}],
+		details: {
+			action: "remove",
+			error: `任务未找到: ${params.job_id}`
+		}
+	};
+	return {
+		content: [{
+			type: "text",
+			text: `任务 ${params.job_id} 已删除。`
+		}],
+		details: {
+			action: "remove",
+			jobId: params.job_id
+		}
+	};
+}
+async function buildPauseResult(scheduler, params) {
+	if (!params.job_id) return {
+		content: [{
+			type: "text",
+			text: "请提供 job_id 参数。"
+		}],
+		details: {
+			action: "pause",
+			error: "job_id 参数为空"
+		}
+	};
+	const error = await scheduler.updateJob(params.job_id, { enabled: false });
+	if (error) return {
+		content: [{
+			type: "text",
+			text: `[暂停失败] ${error}`
+		}],
+		details: {
+			action: "pause",
+			error
+		}
+	};
+	return {
+		content: [{
+			type: "text",
+			text: `任务 ${params.job_id} 已暂停。`
+		}],
+		details: {
+			action: "pause",
+			jobId: params.job_id
+		}
+	};
+}
+async function buildResumeResult(scheduler, params) {
+	if (!params.job_id) return {
+		content: [{
+			type: "text",
+			text: "请提供 job_id 参数。"
+		}],
+		details: {
+			action: "resume",
+			error: "job_id 参数为空"
+		}
+	};
+	const error = await scheduler.updateJob(params.job_id, { enabled: true });
+	if (error) return {
+		content: [{
+			type: "text",
+			text: `[恢复失败] ${error}`
+		}],
+		details: {
+			action: "resume",
+			error
+		}
+	};
+	return {
+		content: [{
+			type: "text",
+			text: `任务 ${params.job_id} 已恢复。`
+		}],
+		details: {
+			action: "resume",
+			jobId: params.job_id
+		}
+	};
+}
+async function buildRunResult(scheduler, params) {
+	if (!params.job_id) return {
+		content: [{
+			type: "text",
+			text: "请提供 job_id 参数。"
+		}],
+		details: {
+			action: "run",
+			error: "job_id 参数为空"
+		}
+	};
+	const error = await scheduler.triggerJob(params.job_id);
+	if (error) return {
+		content: [{
+			type: "text",
+			text: `[执行失败] ${error}`
+		}],
+		details: {
+			action: "run",
+			error
+		}
+	};
+	return {
+		content: [{
+			type: "text",
+			text: `任务 ${params.job_id} 已触发执行。`
+		}],
+		details: {
+			action: "run",
+			jobId: params.job_id
+		}
+	};
+}
+async function buildStatusResult(scheduler) {
+	const status = await scheduler.getStatus();
+	const lines = [
+		"调度器状态:",
+		`  运行中: ${status.running ? "是" : "否"}`,
+		`  总任务数: ${status.jobCount}`,
+		`  已启用: ${status.enabledCount}`,
+		`  持久化任务: ${status.durableCount}`,
+		`  会话任务: ${status.sessionCount}`
+	];
+	if (status.running && status.enabledCount > 0) {
+		const enabledJobs = scheduler.getJobs().filter((j) => j.enabled);
+		if (enabledJobs.length > 0) {
+			lines.push("\n最近到期任务:");
+			const now = /* @__PURE__ */ new Date();
+			for (const job of enabledJobs.slice(0, 5)) {
+				const nextRun = parseCron(job.cron)?.nextFrom(new Date(Math.max(job.lastFiredAt ?? job.createdAt, now.getTime())));
+				lines.push(`  ${job.id}: ${nextRun?.toISOString() ?? "无"} — ${job.prompt.slice(0, 50)}`);
+			}
+		}
+	}
+	return {
+		content: [{
+			type: "text",
+			text: lines.join("\n")
+		}],
+		details: {
+			action: "status",
+			...status
+		}
+	};
+}
+
+//#endregion
+//#region src/cli/repl/tools/file-security.ts
+/**
+* 文件工具共享安全模块
+*
+* 提供路径验证、敏感路径检查、过期检测、diff 生成等共享功能。
+* 参考 Hermes (file_safety.py) 和 Claude Code (permissions/filesystem.ts) 的设计。
+*
+* @module cli/repl/tools/file-security
+*/
+/**
+* 敏感路径模式列表
+*
+* 拒绝写入这些路径，防止破坏系统安全或泄露凭据。
+* 参考 Hermes file_safety.py 的 WRITE_DENY_LIST。
+*/
+const SENSITIVE_PATH_PATTERNS = [
+	/[/\\]\.ssh[/\\]/,
+	/[/\\]\.gnupg[/\\]/,
+	/[/\\]\.bashrc$/,
+	/[/\\]\.zshrc$/,
+	/[/\\]\.profile$/,
+	/[/\\]\.env$/,
+	/[/\\]\.env\.[a-zA-Z0-9_]+$/,
+	/[/\\]\.aws[/\\]/,
+	/[/\\]\.config[/\\]gh[/\\]/,
+	/[/\\]\.kube[/\\]/,
+	/[/\\]\.docker[/\\]config\.json$/,
+	/[/\\]\.git[/\\]config$/,
+	/[/\\]\.git[/\\]HEAD$/,
+	/[/\\]\.git[/\\]index$/,
+	/[/\\]\.git[/\\]hooks[/\\]/,
+	/[/\\]\.git[/\\]objects[/\\]/,
+	/[/\\]\.git[/\\]refs[/\\]/,
+	/^\/etc\/sudoers/,
+	/^\/etc\/passwd/,
+	/^\/etc\/shadow/,
+	/^\/etc\/hosts$/,
+	/^\/etc\/hostname$/,
+	/^\/boot[/\\]/,
+	/^\/proc[/\\]/,
+	/^\/sys[/\\]/,
+	/^\/dev[/\\]/,
+	/[/\\]\.vscode[/\\]settings\.json$/,
+	/[/\\]\.idea[/\\]/
+];
+/**
+* 系统目录前缀（不可写入）
+*/
+const SYSTEM_DIR_PREFIXES = [
+	"/etc/",
+	"/boot/",
+	"/proc/",
+	"/sys/",
+	"/dev/",
+	"/usr/lib/",
+	"/usr/share/"
+];
+/**
+* 验证并解析文件路径
+*
+* 1. 解析为绝对路径
+* 2. 检查是否需要拒绝
+* 3. 检查工作区边界
+*/
+function validateFilePath(filePath, cwd) {
+	if (!filePath || filePath.trim() === "") return {
+		valid: false,
+		resolved: "",
+		reason: "文件路径不能为空"
+	};
+	const workdir = cwd ?? process.cwd();
+	let resolved;
+	try {
+		resolved = resolve(isAbsolute(filePath) ? filePath : resolve(workdir, filePath));
+		resolved = normalize(resolved);
+	} catch {
+		return {
+			valid: false,
+			resolved: "",
+			reason: `无法解析路径: ${filePath}`
+		};
+	}
+	const sensitiveCheck = checkSensitivePath(resolved);
+	if (sensitiveCheck) return {
+		valid: false,
+		resolved,
+		reason: sensitiveCheck
+	};
+	if (!isPathWithinWorkdir(resolved, workdir)) return {
+		valid: false,
+		resolved,
+		reason: `路径超出工作区范围: ${resolved}。仅允许在工作区 ${workdir} 内写入文件。`
+	};
+	return {
+		valid: true,
+		resolved
+	};
+}
+/**
+* 检查是否为敏感路径
+* 返回拒绝原因字符串，或 null 表示安全
+*/
+function checkSensitivePath(resolvedPath) {
+	const normalized = resolvedPath.replace(/\\/g, "/");
+	for (const pattern of SENSITIVE_PATH_PATTERNS) if (pattern.test(normalized)) return `拒绝写入敏感路径: ${resolvedPath}`;
+	for (const prefix of SYSTEM_DIR_PREFIXES) if (normalized.startsWith(prefix)) return `拒绝写入系统目录: ${resolvedPath}`;
+	return null;
+}
+/**
+* 检查路径是否在工作区范围内
+*/
+function isPathWithinWorkdir(resolvedPath, workdir) {
+	const normalizedPath = normalize(resolvedPath).replace(/\\/g, "/");
+	const normalizedWorkdir = normalize(resolve(workdir)).replace(/\\/g, "/");
+	if (!normalizedPath.startsWith(normalizedWorkdir + "/") && normalizedPath !== normalizedWorkdir) return false;
+	return true;
+}
+/**
+* 读取状态跟踪器
+*
+* 记录文件读取时间戳，用于写入前检测外部修改。
+* 参考 Claude Code 的 readFileState 和 Hermes 的 stale detection。
+*/
+var ReadStateTracker = class {
+	state = /* @__PURE__ */ new Map();
+	/**
+	* 记录文件读取
+	*/
+	recordRead(filePath) {
+		try {
+			const stat = statSync(filePath);
+			this.state.set(filePath, {
+				timestamp: stat.mtimeMs,
+				size: stat.size
+			});
+		} catch {}
+	}
+	/**
+	* 记录文件写入（更新读取时间戳，避免自身写入触发过期警告）
+	*/
+	recordWrite(filePath) {
+		try {
+			const stat = statSync(filePath);
+			this.state.set(filePath, {
+				timestamp: stat.mtimeMs,
+				size: stat.size
+			});
+		} catch {
+			this.state.delete(filePath);
+		}
+	}
+	/**
+	* 检查文件是否过期（自上次读取后被修改）
+	* 返回 null 表示安全，返回警告消息表示可能过期
+	*/
+	checkStale(filePath) {
+		const lastRead = this.state.get(filePath);
+		if (!lastRead) return null;
+		try {
+			if (statSync(filePath).mtimeMs > lastRead.timestamp + 1e3) return `文件自上次读取后已被修改（警告：可能发生外部变更）`;
+		} catch {
+			return null;
+		}
+		return null;
+	}
+};
+/** 全局单例 */
+const readStateTracker = new ReadStateTracker();
+/**
+* 生成简单的 unified diff
+*
+* 用于 write/edit 工具返回时展示改动内容。
+*/
+function generateSimpleDiff(filePath, oldContent, newContent) {
+	if (oldContent === null) {
+		const lines = newContent.split("\n");
+		return `--- /dev/null\n+++ ${filePath}\n@@ -0,0 +1,${lines.length} @@\n${lines.map((l) => `+${l}`).join("\n")}`;
+	}
+	if (oldContent === newContent) return "(无变化)";
+	const oldLines = oldContent.split("\n");
+	const newLines = newContent.split("\n");
+	const diffLines = [];
+	diffLines.push(`--- ${filePath}`);
+	diffLines.push(`+++ ${filePath}`);
+	let start = 0;
+	while (start < oldLines.length && start < newLines.length && oldLines[start] === newLines[start]) start++;
+	let oldEnd = oldLines.length;
+	let newEnd = newLines.length;
+	while (oldEnd > start && newEnd > start && oldLines[oldEnd - 1] === newLines[newEnd - 1]) {
+		oldEnd--;
+		newEnd--;
+	}
+	const contextStart = Math.max(0, start - 3);
+	const oldHunkLen = oldEnd - contextStart;
+	const newHunkLen = newEnd - contextStart;
+	diffLines.push(`@@ -${contextStart + 1},${oldHunkLen} +${contextStart + 1},${newHunkLen} @@`);
+	for (let i = contextStart; i < oldEnd && i - contextStart < 50; i++) if (i < start || i >= oldEnd) diffLines.push(` ${oldLines[i]}`);
+	else if (i < oldEnd && i < 0) diffLines.push(` ${oldLines[i]}`);
+	const maxContext = 60;
+	for (let i = contextStart; i < oldEnd && i - contextStart < maxContext; i++) if (i >= start) diffLines.push(`-${oldLines[i]}`);
+	for (let i = contextStart; i < newEnd && i - contextStart < maxContext; i++) if (i >= start) diffLines.push(`+${newLines[i]}`);
+	return diffLines.join("\n");
+}
+/**
+* 写入文件内容
+*
+* 自动创建父目录，使用原子写入（先写临时文件再重命名）。
+*/
+function writeFileContent(filePath, content) {
+	const { mkdirSync, writeFileSync } = __require("node:fs");
+	const { dirname } = __require("node:path");
+	mkdirSync(dirname(filePath), { recursive: true });
+	writeFileSync(filePath, content, "utf-8");
+}
+/**
+* 读取文件内容（同步）
+* 返回文件内容字符串，或 null 表示文件不存在
+*/
+function readFileContent(filePath) {
+	try {
+		return readFileSync(filePath, "utf-8");
+	} catch {
+		return null;
+	}
+}
+
+//#endregion
+//#region src/cli/repl/tools/file-edit.ts
+/**
+* edit_file 工具实现 — 精确字符串替换
+*
+* 功能：
+* - 精确字符串查找替换
+* - replace_all 批量替换
+* - Unicode 引号归一化（花括号引号 → 直引号）
+* - 多匹配唯一性检查
+* - 同 write_file 的安全保护
+*
+* 参考 Claude Code FileEditTool 的设计。
+* 不做 Hermes 的 9 级模糊匹配（复杂度高，可后续迭代）。
+*
+* @module cli/repl/tools/file-edit
+*/
+/**
+* Unicode 字符映射：将花括号引号等归一化为 ASCII 等价字符
+* 参考 Claude Code FileEditTool/utils.ts 和 Hermes fuzzy_match.py
+*/
+const UNICODE_MAP = {
+	"“": "\"",
+	"”": "\"",
+	"‘": "'",
+	"’": "'",
+	"—": "--",
+	"–": "-",
+	"…": "...",
+	"\xA0": " "
+};
+/**
+* 归一化 Unicode 字符
+*/
+function normalizeUnicode(text) {
+	let result = text;
+	for (const [char, replacement] of Object.entries(UNICODE_MAP)) result = result.replaceAll(char, replacement);
+	return result;
+}
+/**
+* 在目标内容中查找匹配的字符串
+*
+* 先精确匹配，如果失败则尝试 Unicode 归一化后匹配。
+* 返回实际匹配到的字符串（用于替换），或 null。
+*/
+function findActualString(content, oldString) {
+	if (content.includes(oldString)) return oldString;
+	const normalizedContent = normalizeUnicode(content);
+	const normalizedOld = normalizeUnicode(oldString);
+	const idx = normalizedContent.indexOf(normalizedOld);
+	if (idx !== -1) return content.substring(idx, idx + normalizedOld.length);
+	return null;
+}
+function createEditFileTool() {
+	return {
+		id: "EditFile",
+		label: "编辑文件",
+		description: "在文件中执行精确字符串替换。参数 old_string 为要查找的文本（必须在文件中精确匹配），new_string 为替换后的文本（必须与 old_string 不同）。如果 old_string 在文件中出现多次，必须设置 replace_all=true。自动支持 Unicode 引号归一化（花括号引号 → 直引号）。",
+		parameters: {
+			type: "object",
+			properties: {
+				file_path: {
+					type: "string",
+					description: "文件绝对路径（必填）"
+				},
+				old_string: {
+					type: "string",
+					description: "要替换的文本（必填）。必须是文件中的精确内容。支持 Unicode 引号自动归一化。"
+				},
+				new_string: {
+					type: "string",
+					description: "替换后的新文本（必填）。必须与 old_string 不同。"
+				},
+				replace_all: {
+					type: "boolean",
+					description: "是否替换所有匹配项（可选，默认 false）。当 old_string 在文件中出现多次时必须设为 true。"
+				}
+			},
+			required: [
+				"file_path",
+				"old_string",
+				"new_string"
+			]
+		},
+		async execute(_toolCallId, params) {
+			const startTime = Date.now();
+			const replaceAll = params.replace_all === true;
+			if (params.old_string === params.new_string) return {
+				content: [{
+					type: "text",
+					text: "[编辑失败] old_string 和 new_string 完全相同，没有需要修改的内容。"
+				}],
+				details: {
+					filePath: params.file_path,
+					replaced: false,
+					matchCount: 0,
+					replaceAll,
+					error: "old_string 与 new_string 相同"
+				}
+			};
+			const pathResult = validateFilePath(params.file_path);
+			if (!pathResult.valid) {
+				const details = {
+					filePath: params.file_path,
+					replaced: false,
+					matchCount: 0,
+					replaceAll
+				};
+				if (pathResult.reason) details.error = pathResult.reason;
+				return {
+					content: [{
+						type: "text",
+						text: `[编辑失败] ${pathResult.reason}`
+					}],
+					details
+				};
+			}
+			const resolvedPath = pathResult.resolved;
+			const fileContent = readFileContent(resolvedPath);
+			if (fileContent === null) {
+				const details = {
+					filePath: resolvedPath,
+					replaced: false,
+					matchCount: 0,
+					replaceAll,
+					error: "文件不存在"
+				};
+				return {
+					content: [{
+						type: "text",
+						text: `[编辑失败] 文件不存在: ${resolvedPath}`
+					}],
+					details
+				};
+			}
+			let warning;
+			const staleWarning = readStateTracker.checkStale(resolvedPath);
+			if (staleWarning) warning = staleWarning;
+			const actualOldString = findActualString(fileContent, params.old_string);
+			if (actualOldString === null) {
+				const details = {
+					filePath: resolvedPath,
+					replaced: false,
+					matchCount: 0,
+					replaceAll,
+					error: "old_string 未在文件中找到"
+				};
+				return {
+					content: [{
+						type: "text",
+						text: `[编辑失败] 在文件中未找到要替换的文本。\n搜索内容: "${params.old_string}"\n请使用 ReadFile 确认文件当前内容后重试。`
+					}],
+					details
+				};
+			}
+			const matchCount = fileContent.split(actualOldString).length - 1;
+			if (matchCount > 1 && !replaceAll) {
+				const details = {
+					filePath: resolvedPath,
+					replaced: false,
+					matchCount,
+					replaceAll,
+					error: `找到 ${matchCount} 处匹配但未设置 replace_all`
+				};
+				return {
+					content: [{
+						type: "text",
+						text: `[编辑失败] 找到 ${matchCount} 处匹配，但 replace_all 为 false。\n要替换所有 ${matchCount} 处匹配，请设置 replace_all=true。\n要替换其中一处，请提供更多上下文使 old_string 唯一。\n搜索内容: "${params.old_string}"`
+					}],
+					details
+				};
+			}
+			const newContent = replaceAll ? fileContent.replaceAll(actualOldString, params.new_string) : fileContent.replace(actualOldString, params.new_string);
+			try {
+				writeFileContent(resolvedPath, newContent);
+			} catch (err) {
+				const details = {
+					filePath: resolvedPath,
+					replaced: false,
+					matchCount,
+					replaceAll,
+					error: err instanceof Error ? err.message : String(err)
+				};
+				return {
+					content: [{
+						type: "text",
+						text: `[编辑失败] ${err instanceof Error ? err.message : String(err)}`
+					}],
+					details
+				};
+			}
+			readStateTracker.recordWrite(resolvedPath);
+			const diff = generateSimpleDiff(resolvedPath, fileContent, newContent);
+			const elapsedMs = Date.now() - startTime;
+			const parts = [];
+			parts.push(`[文件已编辑] ${resolvedPath}`, `替换了 ${matchCount} 处匹配${replaceAll ? "（replace_all=true）" : ""}`);
+			if (warning) parts.push(`\n⚠ ${warning}`);
+			parts.push(`\n\`\`\`diff\n${diff}\n\`\`\``);
+			parts.push(`\n耗时: ${elapsedMs}ms`);
+			const details = {
+				filePath: resolvedPath,
+				replaced: true,
+				matchCount,
+				replaceAll,
+				elapsedMs
+			};
+			if (warning) details.warning = warning;
+			return {
+				content: [{
+					type: "text",
+					text: parts.join("\n")
+				}],
+				details
+			};
+		}
+	};
+}
+
+//#endregion
+//#region src/cli/repl/tools/file-glob.ts
+/**
+* glob 工具实现 — 文件模式匹配搜索
+*
+* 功能：
+* - 使用 glob 模式匹配文件
+* - 支持相对/绝对路径
+* - 按修改时间排序
+* - 结果数量限制
+*
+* 参考 Claude Code GlobTool 的设计。
+*
+* @module cli/repl/tools/file-glob
+*/
+/**
+* 简单的 glob 模式匹配
+*
+* 使用同步 fs.readdirSync 递归实现，避免引入额外依赖。
+* 支持 **、*、? 通配符。
+*/
+function globSync(pattern, rootPath) {
+	const { readdirSync } = __require("node:fs");
+	const { join, relative, dirname } = __require("node:path");
+	const normalizedPattern = pattern.replace(/\\/g, "/");
+	if (normalizedPattern.includes("**")) {
+		const parts = normalizedPattern.split("/");
+		const results = [];
+		const maxResults = 500;
+		let regexStr = normalizedPattern.replace(/\\/g, "\\\\").replace(/\./g, "\\.").replace(/\*\*/g, "<<<GLOBSTAR>>>").replace(/\*/g, "[^/]*").replace(/\?/g, ".").replace(/<<<GLOBSTAR>>>/g, ".*");
+		if (normalizedPattern.startsWith("**/")) regexStr = regexStr.replace(/^\.\*\//, "(.*/)?");
+		const regex = new RegExp(`^${regexStr}$`);
+		function walk(dir) {
+			if (results.length >= maxResults) return;
+			try {
+				const entries = readdirSync(dir, { withFileTypes: true });
+				for (const entry of entries) {
+					if (results.length >= maxResults) return;
+					const fullPath = join(dir, entry.name);
+					const relativePath = relative(rootPath, fullPath).replace(/\\/g, "/");
+					if (entry.isDirectory()) {
+						if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
+						walk(fullPath);
+					} else if (entry.isFile()) {
+						if (regex.test(relativePath)) results.push(fullPath);
+					}
+				}
+			} catch {}
+		}
+		const startsWithGlobstar = normalizedPattern.startsWith("**");
+		const staticPart = parts.find((p) => !p.includes("*") && !p.includes("?")) || ".";
+		walk(startsWithGlobstar ? rootPath : resolve(rootPath, staticPart === "**" ? "." : dirname(normalizedPattern)));
+		results.sort((a, b) => {
+			try {
+				return statSync(b).mtimeMs - statSync(a).mtimeMs;
+			} catch {
+				return 0;
+			}
+		});
+		return results.slice(0, maxResults);
+	} else {
+		const results = [];
+		const regexStr = normalizedPattern.replace(/\\/g, "\\\\").replace(/\./g, "\\.").replace(/\*/g, "[^/]*").replace(/\?/g, ".");
+		const regex = new RegExp(regexStr);
+		const searchDir = rootPath;
+		try {
+			const entries = readdirSync(searchDir, {
+				withFileTypes: true,
+				recursive: false
+			});
+			for (const entry of entries) if (entry.isFile() && regex.test(entry.name)) {
+				const fullPath = join(searchDir, entry.name);
+				results.push(fullPath);
+			}
+		} catch {}
+		results.sort((a, b) => {
+			try {
+				return statSync(b).mtimeMs - statSync(a).mtimeMs;
+			} catch {
+				return 0;
+			}
+		});
+		return results;
+	}
+}
+function createGlobTool() {
+	return {
+		id: "Glob",
+		label: "文件搜索",
+		description: "使用 glob 模式匹配搜索文件。支持 ** (递归)、* (任意字符)、? (单字符) 通配符。结果按修改时间倒序排列，最多返回 500 个匹配。参数 pattern 为 glob 模式（如 \"src/**/*.ts\"、\"*.js\"），path 为搜索根目录（可选）。",
+		parameters: {
+			type: "object",
+			properties: {
+				pattern: {
+					type: "string",
+					description: "glob 匹配模式（必填）。如 \"**/*.ts\"、\"src/**/*.test.ts\""
+				},
+				path: {
+					type: "string",
+					description: "搜索根目录（可选，默认当前工作目录）"
+				}
+			},
+			required: ["pattern"]
+		},
+		async execute(_toolCallId, params) {
+			const startTime = Date.now();
+			const searchPath = resolve(params.path ?? process.cwd());
+			try {
+				const matches = globSync(params.pattern, searchPath);
+				const elapsedMs = Date.now() - startTime;
+				const truncated = matches.length >= 500;
+				if (matches.length === 0) return {
+					content: [{
+						type: "text",
+						text: `[glob] 未找到匹配 "${params.pattern}" 的文件（在 ${searchPath} 中）`
+					}],
+					details: {
+						pattern: params.pattern,
+						matchCount: 0,
+						searchPath,
+						truncated: false,
+						elapsedMs
+					}
+				};
+				return {
+					content: [{
+						type: "text",
+						text: [
+							`[glob] 找到 ${matches.length} 个匹配 "${params.pattern}" 的文件${truncated ? "（结果已截断）" : ""}：`,
+							"",
+							...matches.map((m, i) => `${i + 1}. ${m}`)
+						].join("\n")
+					}],
+					details: {
+						pattern: params.pattern,
+						matchCount: matches.length,
+						searchPath,
+						truncated,
+						elapsedMs
+					}
+				};
+			} catch (err) {
+				return {
+					content: [{
+						type: "text",
+						text: `[glob] 搜索失败: ${err instanceof Error ? err.message : String(err)}`
+					}],
+					details: {
+						pattern: params.pattern,
+						matchCount: 0,
+						searchPath,
+						truncated: false,
+						error: err instanceof Error ? err.message : String(err)
+					}
+				};
+			}
+		}
+	};
+}
+
+//#endregion
+//#region src/cli/repl/tools/file-grep.ts
+/**
+* grep 工具实现 — 文件内容搜索
+*
+* 功能：
+* - 正则表达式搜索文件内容
+* - 支持 output_mode: content / files_with_matches / count
+* - 支持上下文行（-A/-B/-C）
+* - 支持 glob 文件过滤
+* - 结果数量限制
+*
+* 参考 Claude Code GrepTool 的设计。
+*
+* @module cli/repl/tools/file-grep
+*/
+/**
+* 收集搜索范围内的所有文件
+*/
+function collectFiles(searchPath, fileGlob) {
+	const { readdirSync, statSync } = __require("node:fs");
+	const { join } = __require("node:path");
+	const results = [];
+	const maxFiles = 2e3;
+	let globRegex = null;
+	if (fileGlob) {
+		const regexStr = fileGlob.replace(/\\/g, "\\\\").replace(/\./g, "\\.").replace(/\*\*/g, "<<<GLOBSTAR>>>").replace(/\*/g, "[^/]*").replace(/\?/g, ".").replace(/<<<GLOBSTAR>>>/g, ".*");
+		globRegex = new RegExp(`^${regexStr}$`);
+	}
+	function walk(dir) {
+		if (results.length >= maxFiles) return;
+		try {
+			const entries = readdirSync(dir, { withFileTypes: true });
+			for (const entry of entries) {
+				if (results.length >= maxFiles) return;
+				if (entry.name.startsWith(".") && entry.name !== ".") continue;
+				if (entry.name === "node_modules" || entry.name === ".git") continue;
+				const fullPath = join(dir, entry.name);
+				if (entry.isDirectory()) walk(fullPath);
+				else if (entry.isFile()) {
+					if (isBinaryExtension(entry.name)) continue;
+					if (globRegex) {
+						const relativePath = fullPath.replace(searchPath, "").replace(/\\/g, "/").replace(/^\//, "");
+						if (!globRegex.test(relativePath) && !globRegex.test(entry.name)) continue;
+					}
+					try {
+						if (statSync(fullPath).size > 1024 * 1024) continue;
+					} catch {
+						continue;
+					}
+					results.push(fullPath);
+				}
+			}
+		} catch {}
+	}
+	walk(searchPath);
+	return results;
+}
+/**
+* 二进制文件扩展名列表
+*/
+const BINARY_EXTENSIONS = new Set([
+	".png",
+	".jpg",
+	".jpeg",
+	".gif",
+	".webp",
+	".ico",
+	".bmp",
+	".svg",
+	".mp3",
+	".mp4",
+	".avi",
+	".mov",
+	".mkv",
+	".wav",
+	".flac",
+	".zip",
+	".tar",
+	".gz",
+	".bz2",
+	".7z",
+	".rar",
+	".exe",
+	".dll",
+	".so",
+	".dylib",
+	".pdf",
+	".doc",
+	".docx",
+	".xls",
+	".xlsx",
+	".ppt",
+	".pptx",
+	".woff",
+	".woff2",
+	".ttf",
+	".eot",
+	".otf",
+	".bin",
+	".dat",
+	".class",
+	".pyc",
+	".db",
+	".sqlite",
+	".sqlite3"
+]);
+function isBinaryExtension(filename) {
+	const ext = filename.substring(filename.lastIndexOf(".")).toLowerCase();
+	return BINARY_EXTENSIONS.has(ext);
+}
+function createGrepTool() {
+	const MAX_RESULTS = 250;
+	return {
+		id: "Grep",
+		label: "内容搜索",
+		description: "使用正则表达式搜索文件内容。支持 output_mode 控制输出格式：\"content\"（含上下文）、\"files_with_matches\"（仅文件列表）、\"count\"（匹配计数）。参数 context 可指定显示匹配行前后 N 行上下文。参数 glob 可过滤文件（如 \"*.ts\" 仅搜索 TypeScript 文件）。",
+		parameters: {
+			type: "object",
+			properties: {
+				pattern: {
+					type: "string",
+					description: "正则表达式搜索模式（必填）"
+				},
+				path: {
+					type: "string",
+					description: "搜索范围目录（可选，默认当前工作目录）"
+				},
+				glob: {
+					type: "string",
+					description: "文件过滤 glob 模式（可选，如 \"*.ts\"）"
+				},
+				output_mode: {
+					type: "string",
+					enum: [
+						"content",
+						"files_with_matches",
+						"count"
+					],
+					description: "输出模式：content（默认，含上下文）、files_with_matches（文件列表）、count（计数）"
+				},
+				"-i": {
+					type: "boolean",
+					description: "忽略大小写（默认大小写敏感）"
+				},
+				"-A": {
+					type: "number",
+					description: "匹配行之后显示的行数"
+				},
+				"-B": {
+					type: "number",
+					description: "匹配行之前显示的行数"
+				},
+				context: {
+					type: "number",
+					description: "匹配行前后显示的行数（同时设置 -A 和 -B）"
+				}
+			},
+			required: ["pattern"]
+		},
+		async execute(_toolCallId, params) {
+			const startTime = Date.now();
+			const searchPath = resolve(params.path ?? process.cwd());
+			const outputMode = params.output_mode ?? "content";
+			const ignoreCase = params["-i"] === true;
+			const contextBefore = params["-B"] ?? params.context ?? 0;
+			const contextAfter = params["-A"] ?? params.context ?? 0;
+			let regex;
+			try {
+				regex = new RegExp(params.pattern, ignoreCase ? "gi" : "g");
+			} catch {
+				const details = {
+					pattern: params.pattern,
+					matchCount: 0,
+					fileCount: 0,
+					searchPath,
+					truncated: false,
+					outputMode
+				};
+				return {
+					content: [{
+						type: "text",
+						text: `[grep] 无效的正则表达式: "${params.pattern}"`
+					}],
+					details
+				};
+			}
+			const files = collectFiles(searchPath, params.glob);
+			const results = [];
+			for (const file of files) {
+				if (results.length >= MAX_RESULTS) break;
+				try {
+					const lines = readFileSync(file, "utf-8").split("\n");
+					regex.lastIndex = 0;
+					for (let i = 0; i < lines.length; i++) {
+						if (results.length >= MAX_RESULTS) break;
+						const currentLine = lines[i];
+						if (new RegExp(params.pattern, ignoreCase ? "i" : "").test(currentLine)) {
+							const ctxBefore = [];
+							const ctxAfter = [];
+							for (let b = Math.max(0, i - contextBefore); b < i; b++) ctxBefore.push(lines[b]);
+							for (let a = i + 1; a <= Math.min(lines.length - 1, i + contextAfter); a++) ctxAfter.push(lines[a]);
+							results.push({
+								file,
+								lineNum: i + 1,
+								line: currentLine.substring(0, 500),
+								contextBefore: ctxBefore.map((l) => l.substring(0, 500)),
+								contextAfter: ctxAfter.map((l) => l.substring(0, 500))
+							});
+						}
+					}
+				} catch {}
+			}
+			const elapsedMs = Date.now() - startTime;
+			const truncated = results.length >= MAX_RESULTS;
+			if (outputMode === "files_with_matches") return buildFilesOutput([...new Set(results.map((r) => r.file))], params.pattern, searchPath, truncated, elapsedMs);
+			if (outputMode === "count") {
+				const fileCounts = /* @__PURE__ */ new Map();
+				for (const r of results) fileCounts.set(r.file, (fileCounts.get(r.file) ?? 0) + 1);
+				return buildCountOutput(fileCounts, params.pattern, searchPath, truncated, elapsedMs);
+			}
+			return buildContentOutput(results, params.pattern, searchPath, truncated, elapsedMs);
+		}
+	};
+}
+function buildContentOutput(results, pattern, searchPath, truncated, elapsedMs) {
+	if (results.length === 0) {
+		const details = {
+			pattern,
+			matchCount: 0,
+			fileCount: 0,
+			searchPath,
+			truncated: false,
+			outputMode: "content",
+			elapsedMs
+		};
+		return {
+			content: [{
+				type: "text",
+				text: `[grep] 未找到匹配 "${pattern}" 的内容（在 ${searchPath} 中）`
+			}],
+			details
+		};
+	}
+	const lines = [`[grep] 找到 ${results.length} 处匹配 "${pattern}"${truncated ? "（结果已截断）" : ""}：`, ""];
+	for (const r of results) {
+		lines.push(`${r.file}:${r.lineNum}`);
+		for (const ctxLine of r.contextBefore) lines.push(`  ${ctxLine}`);
+		lines.push(`> ${r.line}`);
+		for (const ctxLine of r.contextAfter) lines.push(`  ${ctxLine}`);
+		lines.push("");
+	}
+	const details = {
+		pattern,
+		matchCount: results.length,
+		fileCount: [...new Set(results.map((r) => r.file))].length,
+		searchPath,
+		truncated,
+		outputMode: "content",
+		elapsedMs
+	};
+	return {
+		content: [{
+			type: "text",
+			text: lines.join("\n")
+		}],
+		details
+	};
+}
+function buildFilesOutput(files, pattern, searchPath, truncated, elapsedMs) {
+	if (files.length === 0) {
+		const details = {
+			pattern,
+			matchCount: 0,
+			fileCount: 0,
+			searchPath,
+			truncated: false,
+			outputMode: "files_with_matches",
+			elapsedMs
+		};
+		return {
+			content: [{
+				type: "text",
+				text: `[grep] 未找到匹配 "${pattern}" 的文件（在 ${searchPath} 中）`
+			}],
+			details
+		};
+	}
+	const parts = [
+		`[grep] 找到 ${files.length} 个匹配 "${pattern}" 的文件${truncated ? "（结果已截断）" : ""}：`,
+		"",
+		...files.map((f, i) => `${i + 1}. ${f}`)
+	];
+	const details = {
+		pattern,
+		matchCount: files.length,
+		fileCount: files.length,
+		searchPath,
+		truncated,
+		outputMode: "files_with_matches",
+		elapsedMs
+	};
+	return {
+		content: [{
+			type: "text",
+			text: parts.join("\n")
+		}],
+		details
+	};
+}
+function buildCountOutput(fileCounts, pattern, searchPath, truncated, elapsedMs) {
+	if (fileCounts.size === 0) {
+		const details = {
+			pattern,
+			matchCount: 0,
+			fileCount: 0,
+			searchPath,
+			truncated: false,
+			outputMode: "count",
+			elapsedMs
+		};
+		return {
+			content: [{
+				type: "text",
+				text: `[grep] 未找到匹配 "${pattern}" 的内容（在 ${searchPath} 中）`
+			}],
+			details
+		};
+	}
+	const parts = [`[grep] 匹配 "${pattern}" 的计数${truncated ? "（结果已截断）" : ""}：`, ""];
+	let total = 0;
+	const sorted = [...fileCounts.entries()].sort((a, b) => b[1] - a[1]);
+	for (const [file, count] of sorted) {
+		parts.push(`${count} ${file}`);
+		total += count;
+	}
+	parts.push("", `合计: ${total} 处匹配（${fileCounts.size} 个文件）`);
+	const details = {
+		pattern,
+		matchCount: total,
+		fileCount: fileCounts.size,
+		searchPath,
+		truncated,
+		outputMode: "count",
+		elapsedMs
+	};
+	return {
+		content: [{
+			type: "text",
+			text: parts.join("\n")
+		}],
+		details
+	};
+}
+
+//#endregion
+//#region src/cli/repl/tools/file-write.ts
+/**
+* write_file 工具实现 — 文件创建与覆写
+*
+* 功能：
+* - 创建新文件 / 覆写已有文件
+* - 自动创建父目录
+* - 敏感路径检查
+* - 工作区边界保护
+* - 过期检测（软约束）
+* - 返回结构化 diff
+*
+* 参考 Claude Code FileWriteTool 和 Hermes write_file 的设计。
+*
+* @module cli/repl/tools/file-write
+*/
+function createWriteFileTool() {
+	return {
+		id: "WriteFile",
+		label: "写入文件",
+		description: "将内容写入文件，完全替换已有内容或创建新文件。使用此工具来创建或覆写文件。自动创建父目录。参数 file_path 为文件绝对路径，content 为要写入的内容。",
+		parameters: {
+			type: "object",
+			properties: {
+				file_path: {
+					type: "string",
+					description: "文件绝对路径（必填）。必须是绝对路径，不能是相对路径。"
+				},
+				content: {
+					type: "string",
+					description: "要写入文件的完整内容（必填）"
+				}
+			},
+			required: ["file_path", "content"]
+		},
+		async execute(_toolCallId, params) {
+			const startTime = Date.now();
+			const pathResult = validateFilePath(params.file_path);
+			if (!pathResult.valid) {
+				const details = {
+					type: "create",
+					filePath: params.file_path,
+					contentLength: 0
+				};
+				if (pathResult.reason) details.error = pathResult.reason;
+				return {
+					content: [{
+						type: "text",
+						text: `[写入失败] ${pathResult.reason}`
+					}],
+					details
+				};
+			}
+			const resolvedPath = pathResult.resolved;
+			let warning;
+			const staleWarning = readStateTracker.checkStale(resolvedPath);
+			if (staleWarning) warning = staleWarning;
+			const oldContent = readFileContent(resolvedPath);
+			const isNew = oldContent === null;
+			try {
+				writeFileContent(resolvedPath, params.content);
+			} catch (err) {
+				const details = {
+					type: isNew ? "create" : "update",
+					filePath: resolvedPath,
+					contentLength: 0,
+					error: err instanceof Error ? err.message : String(err)
+				};
+				return {
+					content: [{
+						type: "text",
+						text: `[写入失败] ${err instanceof Error ? err.message : String(err)}`
+					}],
+					details
+				};
+			}
+			readStateTracker.recordWrite(resolvedPath);
+			const diff = generateSimpleDiff(resolvedPath, oldContent, params.content);
+			const elapsedMs = Date.now() - startTime;
+			const type = isNew ? "create" : "update";
+			const parts = [type === "create" ? `[文件已创建] ${resolvedPath}` : `[文件已更新] ${resolvedPath}`];
+			if (warning) parts.push(`\n⚠ ${warning}`);
+			parts.push(`\n\`\`\`diff\n${diff}\n\`\`\``);
+			parts.push(`\n耗时: ${elapsedMs}ms`);
+			const details = {
+				type,
+				filePath: resolvedPath,
+				contentLength: params.content.length,
+				elapsedMs
+			};
+			if (warning) details.warning = warning;
+			return {
+				content: [{
+					type: "text",
+					text: parts.join("\n")
+				}],
+				details
+			};
+		}
+	};
+}
+
+//#endregion
+//#region src/cli/repl/tools/memory-tool.ts
+/**
+* memory 工具实现 — 持久化记忆管理
+*
+* 参考 Hermes-Agent 的 memory_tool.py（单工具 + action 模式、§ 分隔符、快照冻结）
+* 和 Claude Code 的类型分类（user/project/session 三种记忆类型）。
+*
+* 设计要点:
+* - 存储位置: ~/.zapmyco/memory/
+* - 条目分隔符: §（Section Sign，借鉴 Hermes）
+* - 快照冻结: 会话开始时冻结内容到快照，会话中写入不影响当前系统提示
+* - 原子写入: 先写临时文件，再 rename（防部分写入）
+* - 自动去重: add 时检查是否已存在相同内容
+*
+* @module cli/repl/tools/memory-tool
+*/
+const MEMORY_DIR = join(homedir(), ".zapmyco", "memory");
+const SECTION_DELIMITER = "\n§ ";
+const MAX_CONTENT_LENGTH = 2e3;
+const MEMORY_FILES = {
+	user: "user.md",
+	project: "project.md",
+	session: "session.md"
+};
+const MEMORY_LABELS = {
+	user: "用户画像",
+	project: "项目上下文",
+	session: "会话摘要"
+};
+/**
+* 持久化记忆存储
+*
+* 管理 ~/.zapmyco/memory/ 目录下的记忆文件。
+* 采用快照模式：会话开始时冻结内容到快照，会话中写入不影响快照。
+*/
+var MemoryStore = class {
+	baseDir;
+	snapshot = /* @__PURE__ */ new Map();
+	/** Promise-based 锁，防止并发 initialize() 调用产生竞态 */
+	initPromise = null;
+	constructor(homeDir) {
+		this.baseDir = homeDir ? join(homeDir, ".zapmyco", "memory") : MEMORY_DIR;
+	}
+	/** 确保目录和默认文件存在（Promise 锁防并发竞态） */
+	async initialize() {
+		if (this.initPromise) return this.initPromise;
+		this.initPromise = this.doInitialize();
+		return this.initPromise;
+	}
+	async doInitialize() {
+		await mkdir(this.baseDir, { recursive: true });
+		for (const [type, filename] of Object.entries(MEMORY_FILES)) {
+			const filepath = join(this.baseDir, filename);
+			try {
+				await readFile(filepath, "utf-8");
+			} catch {
+				await writeFile(filepath, this.buildFileHeader(type), "utf-8");
+			}
+		}
+		const indexPath = join(this.baseDir, "MEMORY.md");
+		try {
+			await readFile(indexPath, "utf-8");
+		} catch {
+			await this.updateIndex();
+		}
+	}
+	/** 冻结当前记忆内容为快照（会话开始时调用） */
+	async freezeSnapshot() {
+		await this.initialize();
+		for (const type of Object.keys(MEMORY_FILES)) {
+			const content = await this.readFileContent(type);
+			this.snapshot.set(type, content);
+		}
+	}
+	/** 获取快照内容（用于系统提示注入，不触发文件读取） */
+	getSnapshot(type) {
+		if (type) return this.snapshot.get(type) ?? "";
+		const parts = [];
+		for (const [t, content] of this.snapshot) if (content.trim()) parts.push(`### ${MEMORY_LABELS[t]}\n${content}`);
+		return parts.join("\n\n") || "(暂无记忆)";
+	}
+	/** 读取指定类型记忆 */
+	async read(type) {
+		await this.initialize();
+		return this.readFileContent(type);
+	}
+	/** 添加一条记忆条目 */
+	async add(type, content) {
+		await this.initialize();
+		if (!content?.trim()) return {
+			ok: false,
+			error: "内容不能为空"
+		};
+		if (content.length > MAX_CONTENT_LENGTH) return {
+			ok: false,
+			error: `内容过长（最大 ${MAX_CONTENT_LENGTH} 字符）`
+		};
+		const existing = await this.readFileContent(type);
+		const entries = this.parseEntries(existing);
+		const normalized = content.trim();
+		if (entries.some((e) => e.trim() === normalized)) return {
+			ok: false,
+			error: "该条目已存在"
+		};
+		entries.push(normalized);
+		await this.writeFileContent(type, entries);
+		await this.updateIndex();
+		return { ok: true };
+	}
+	/** 删除匹配的记忆条目 */
+	async remove(type, oldContent) {
+		await this.initialize();
+		if (!oldContent?.trim()) return {
+			ok: false,
+			error: "old_content 不能为空"
+		};
+		const existing = await this.readFileContent(type);
+		const entries = this.parseEntries(existing);
+		const search = oldContent.trim();
+		const matches = entries.filter((e) => e.includes(search));
+		if (matches.length === 0) return {
+			ok: false,
+			error: "未找到匹配的条目"
+		};
+		if (matches.length > 1) return {
+			ok: false,
+			error: `找到 ${matches.length} 个匹配项，请提供更精确的 old_content。匹配条目:\n${matches.map((m) => `  § ${m}`).join("\n")}`
+		};
+		const newEntries = entries.filter((e) => !e.includes(search));
+		await this.writeFileContent(type, newEntries);
+		await this.updateIndex();
+		return { ok: true };
+	}
+	/** 列出所有记忆索引 */
+	async list() {
+		await this.initialize();
+		const indexPath = join(this.baseDir, "MEMORY.md");
+		try {
+			return await readFile(indexPath, "utf-8") || "暂无记忆索引。";
+		} catch {
+			return "暂无记忆索引。";
+		}
+	}
+	buildFileHeader(type) {
+		return `# ${MEMORY_LABELS[type]}\n\n> 更新: ${(/* @__PURE__ */ new Date()).toISOString()}\n\n`;
+	}
+	parseEntries(content) {
+		const entries = [];
+		const parts = content.split(SECTION_DELIMITER);
+		for (let i = 1; i < parts.length; i++) {
+			const part = parts[i];
+			if (part) {
+				const trimmed = part.trim();
+				if (trimmed) entries.push(trimmed);
+			}
+		}
+		return entries;
+	}
+	entriesToContent(type, entries) {
+		const header = this.buildFileHeader(type);
+		if (entries.length === 0) return header;
+		return header + SECTION_DELIMITER.trimStart() + entries.join(SECTION_DELIMITER);
+	}
+	async readFileContent(type) {
+		const filepath = join(this.baseDir, MEMORY_FILES[type]);
+		try {
+			return await readFile(filepath, "utf-8");
+		} catch {
+			return this.buildFileHeader(type);
+		}
+	}
+	/** 原子写入：先写临时文件，再 rename */
+	async writeFileContent(type, entries) {
+		const filepath = join(this.baseDir, MEMORY_FILES[type]);
+		const tmpPath = `${filepath}.tmp`;
+		await writeFile(tmpPath, this.entriesToContent(type, entries), "utf-8");
+		await rename(tmpPath, filepath);
+	}
+	async updateIndex() {
+		const lines = ["# Memory Index", ""];
+		for (const [type, filename] of Object.entries(MEMORY_FILES)) {
+			const content = await this.readFileContent(type);
+			const count = this.parseEntries(content).length;
+			const label = MEMORY_LABELS[type];
+			lines.push(`- [${filename}](${filename}) — ${label}（${count} 条）`);
+		}
+		await writeFile(join(this.baseDir, "MEMORY.md"), lines.join("\n"), "utf-8");
+	}
+};
+const MEMORY_DESCRIPTION = `持久化记忆管理工具 — 跨会话保存和检索信息，让 Agent "越用越懂用户"。
+
+## 记忆类型 (type)
+- "user": 用户画像 — 偏好、习惯、知识背景、角色
+- "project": 项目上下文 — 决策、约定、目标
+- "session": 会话摘要 — 最近会话的关键结论或进展
+
+## 操作 (action)
+- "read": 读取指定类型的记忆内容
+- "add": 添加一条记忆条目（自动去重）
+- "remove": 删除匹配的记忆条目（需提供 old_content 精确匹配）
+- "list": 列出 MEMORY.md 索引摘要
+
+## 何时保存记忆
+- 用户明确告知偏好、习惯、知识背景时 → 保存到 user
+- 项目做出重要决策或约定时 → 保存到 project
+- 会话结束时有值得跨会话保留的结论 → 保存到 session
+- 用户纠正你的行为或给出反馈时 → 保存到 user
+
+## 何时不保存
+- 临时任务进度、会话状态（使用 TaskManage 管理）
+- 代码细节（可直接从代码库获取）
+- 一次性查询的内容`;
+/** 全局单例 MemoryStore（会话级生命周期） */
+let globalStore = null;
+/**
+* 获取或创建 MemoryStore 实例
+*/
+function getMemoryStore() {
+	if (!globalStore) globalStore = new MemoryStore();
+	return globalStore;
+}
+/**
+* 创建 memory 工具
+*/
+function createMemoryTool() {
+	const store = getMemoryStore();
+	return {
+		id: "Memory",
+		label: "记忆管理",
+		description: MEMORY_DESCRIPTION,
+		parameters: {
+			type: "object",
+			properties: {
+				action: {
+					type: "string",
+					description: "操作类型: \"read\"(读取), \"add\"(添加), \"remove\"(删除), \"list\"(列出索引)。",
+					enum: [
+						"read",
+						"add",
+						"remove",
+						"list"
+					]
+				},
+				type: {
+					type: "string",
+					description: "记忆类型: \"user\"(用户画像), \"project\"(项目上下文), \"session\"(会话摘要)。read/add/remove 操作需要指定。",
+					enum: [
+						"user",
+						"project",
+						"session"
+					]
+				},
+				content: {
+					type: "string",
+					description: "要添加的记忆内容（action=\"add\" 时必填）"
+				},
+				old_content: {
+					type: "string",
+					description: "要删除的记忆内容（action=\"remove\" 时必填，用于精确匹配已有条目）"
+				}
+			}
+		},
+		async execute(_toolCallId, params) {
+			const action = params.action ?? "read";
+			const type = params.type ?? "user";
+			switch (action) {
+				case "read": return buildReadResult$1(store, type);
+				case "add": return buildAddResult(store, type, params.content);
+				case "remove": return buildRemoveResult(store, type, params.old_content);
+				case "list": return buildListResult(store);
+				default: return {
+					content: [{
+						type: "text",
+						text: `不支持的操作: ${action}`
+					}],
+					details: {
+						action,
+						error: `不支持的操作: ${action}`
+					}
+				};
+			}
+		}
+	};
+}
+async function buildReadResult$1(store, type) {
+	const content = await store.read(type);
+	const label = MEMORY_LABELS[type];
+	if (!content.trim() || content.trim() === `# ${label}`) return {
+		content: [{
+			type: "text",
+			text: `${label}暂无记忆条目。使用 action="add" 添加。`
+		}],
+		details: {
+			action: "read",
+			type,
+			content: ""
+		}
+	};
+	return {
+		content: [{
+			type: "text",
+			text: content
+		}],
+		details: {
+			action: "read",
+			type,
+			content
+		}
+	};
+}
+async function buildAddResult(store, type, content) {
+	if (!content) return {
+		content: [{
+			type: "text",
+			text: "请提供 content 参数（要保存的记忆内容）。"
+		}],
+		details: {
+			action: "add",
+			type,
+			error: "content 参数为空"
+		}
+	};
+	const result = await store.add(type, content);
+	if (!result.ok) return {
+		content: [{
+			type: "text",
+			text: `[保存失败] ${result.error}`
+		}],
+		details: {
+			action: "add",
+			type,
+			error: result.error
+		}
+	};
+	return {
+		content: [{
+			type: "text",
+			text: `已保存到${MEMORY_LABELS[type]}:\n§ ${content.trim()}`
+		}],
+		details: {
+			action: "add",
+			type,
+			content: content.trim()
+		}
+	};
+}
+async function buildRemoveResult(store, type, oldContent) {
+	if (!oldContent) return {
+		content: [{
+			type: "text",
+			text: "请提供 old_content 参数（要删除的记忆内容，用于匹配已有条目）。"
+		}],
+		details: {
+			action: "remove",
+			type,
+			error: "old_content 参数为空"
+		}
+	};
+	const result = await store.remove(type, oldContent);
+	if (!result.ok) return {
+		content: [{
+			type: "text",
+			text: `[删除失败] ${result.error}`
+		}],
+		details: {
+			action: "remove",
+			type,
+			error: result.error
+		}
+	};
+	return {
+		content: [{
+			type: "text",
+			text: `已从${MEMORY_LABELS[type]}删除匹配条目。`
+		}],
+		details: {
+			action: "remove",
+			type,
+			removed: oldContent.trim()
+		}
+	};
+}
+async function buildListResult(store) {
+	const content = await store.list();
+	return {
+		content: [{
+			type: "text",
+			text: content
+		}],
+		details: {
+			action: "list",
+			content
+		}
+	};
+}
+
+//#endregion
+//#region src/cli/repl/tools/process-registry.ts
+/** 每个进程最大输出字符数 */
+const MAX_OUTPUT_CHARS$1 = 2e5;
+/** 日志预览尾部行数 */
+const LOG_TAIL_LINES = 40;
+/** 默认 TTL（30 分钟），超时自动清理 */
+const DEFAULT_TTL_MS$1 = 1800 * 1e3;
+/** 清理间隔 */
+const CLEANUP_INTERVAL_MS = 6e4;
+var ProcessRegistry = class {
+	processes = /* @__PURE__ */ new Map();
+	cleanupTimer = null;
+	/**
+	* 注册新的后台进程
+	*/
+	register(command, childProcess, options) {
+		const sessionId = `proc_${randomBytes(6).toString("hex")}`;
+		const session = {
+			sessionId,
+			command,
+			pid: childProcess.pid ?? 0,
+			status: "running",
+			startTime: Date.now()
+		};
+		if (options?.workdir !== void 0) session.workdir = options.workdir;
+		const record = {
+			session,
+			childProcess,
+			stdoutChunks: [],
+			stderrChunks: [],
+			totalOutputSize: 0
+		};
+		if (options?.onComplete !== void 0) record.onComplete = options.onComplete;
+		if (childProcess.stdout) childProcess.stdout.on("data", (data) => {
+			this.appendOutput(record, data.toString("utf-8"));
+		});
+		if (childProcess.stderr) childProcess.stderr.on("data", (data) => {
+			this.appendOutput(record, data.toString("utf-8"));
+		});
+		childProcess.on("close", (code, signal) => {
+			session.endTime = Date.now();
+			session.exitCode = code;
+			session.signal = signal;
+			if (session.status === "running") if (code === 0 || code === null) session.status = "exited";
+			else if (signal && [
+				"SIGTERM",
+				"SIGKILL",
+				"SIGINT"
+			].includes(signal)) session.status = "killed";
+			else session.status = "exited";
+			record.onComplete?.(session);
+		});
+		childProcess.on("error", (_err) => {
+			if (session.status === "running") {
+				session.status = "errored";
+				session.endTime = Date.now();
+			}
+			record.onComplete?.(session);
+		});
+		this.processes.set(sessionId, record);
+		this.ensureCleanupTimer();
+		return session;
+	}
+	/**
+	* 列出所有进程
+	*/
+	list() {
+		const sessions = [];
+		for (const record of this.processes.values()) sessions.push({ ...record.session });
+		return sessions.sort((a, b) => b.startTime - a.startTime);
+	}
+	/**
+	* 轮询进程状态（返回新输出）
+	*/
+	poll(sessionId) {
+		const record = this.processes.get(sessionId);
+		if (!record) return null;
+		const newOutput = record.stdoutChunks.join("");
+		record.stdoutChunks = [];
+		return {
+			session: { ...record.session },
+			newOutput
+		};
+	}
+	/**
+	* 获取进程完整日志
+	*/
+	getLog(sessionId, options) {
+		const record = this.processes.get(sessionId);
+		if (!record) return null;
+		const offset = options?.offset ?? 0;
+		const limit = options?.limit ?? LOG_TAIL_LINES;
+		const sliced = this.getAllOutput(record).split("\n").slice(offset, offset + limit);
+		return {
+			session: { ...record.session },
+			output: sliced.join("\n")
+		};
+	}
+	/**
+	* 等待进程完成
+	*/
+	wait(sessionId, timeoutMs) {
+		const record = this.processes.get(sessionId);
+		if (!record) return Promise.resolve(null);
+		if (record.session.status !== "running") return Promise.resolve({ ...record.session });
+		return new Promise((resolve) => {
+			const timeout = timeoutMs ? setTimeout(() => {
+				resolve({ ...record.session });
+			}, timeoutMs) : null;
+			const originalHandler = record.onComplete;
+			record.onComplete = (session) => {
+				originalHandler?.(session);
+				if (timeout) clearTimeout(timeout);
+				resolve({ ...session });
+			};
+		});
+	}
+	/**
+	* 终止进程（先 SIGTERM，2 秒后 SIGKILL）
+	*/
+	kill(sessionId) {
+		const record = this.processes.get(sessionId);
+		if (!record) return null;
+		if (record.session.status !== "running") return { ...record.session };
+		record.childProcess.kill("SIGTERM");
+		record.session.status = "killed";
+		setTimeout(() => {
+			if (record.childProcess.exitCode === null) try {
+				record.childProcess.kill("SIGKILL");
+			} catch {}
+		}, 2e3);
+		return { ...record.session };
+	}
+	/**
+	* 向进程 stdin 写入数据
+	*/
+	write(sessionId, data, newline) {
+		const record = this.processes.get(sessionId);
+		if (!record) return null;
+		if (record.session.status !== "running") return { ...record.session };
+		if (record.childProcess.stdin && !record.childProcess.stdin.destroyed) {
+			record.childProcess.stdin.write(data);
+			if (newline) record.childProcess.stdin.write("\n");
+		}
+		return { ...record.session };
+	}
+	/**
+	* 移除进程记录（清理已完成进程）
+	*/
+	remove(sessionId) {
+		return this.processes.delete(sessionId);
+	}
+	/**
+	* 获取所有已完成的进程 session ID
+	*/
+	getCompletedSessionIds() {
+		const ids = [];
+		for (const [id, record] of this.processes) if (record.session.status !== "running") ids.push(id);
+		return ids;
+	}
+	/**
+	* 获取进程数
+	*/
+	get count() {
+		return this.processes.size;
+	}
+	/**
+	* 销毁注册表（清理所有进程）
+	*/
+	destroy() {
+		if (this.cleanupTimer) {
+			clearInterval(this.cleanupTimer);
+			this.cleanupTimer = null;
+		}
+		for (const record of this.processes.values()) if (record.session.status === "running") try {
+			record.childProcess.kill("SIGKILL");
+		} catch {}
+		this.processes.clear();
+	}
+	appendOutput(record, data) {
+		if (record.totalOutputSize >= MAX_OUTPUT_CHARS$1) return;
+		const remaining = MAX_OUTPUT_CHARS$1 - record.totalOutputSize;
+		const chunk = data.length > remaining ? data.slice(0, remaining) : data;
+		record.stdoutChunks.push(chunk);
+		record.totalOutputSize += chunk.length;
+	}
+	getAllOutput(record) {
+		return record.stdoutChunks.join("");
+	}
+	ensureCleanupTimer() {
+		if (this.cleanupTimer) return;
+		this.cleanupTimer = setInterval(() => {
+			const now = Date.now();
+			for (const [id, record] of this.processes) if (record.session.status !== "running") {
+				if (now - (record.session.endTime ?? record.session.startTime) > DEFAULT_TTL_MS$1) this.processes.delete(id);
+			}
+		}, CLEANUP_INTERVAL_MS);
+		if (this.cleanupTimer.unref) this.cleanupTimer.unref();
+	}
+};
+/** 全局单例 */
+let globalRegistry = null;
+/** 获取全局 ProcessRegistry 实例 */
+function getProcessRegistry() {
+	if (!globalRegistry) globalRegistry = new ProcessRegistry();
+	return globalRegistry;
+}
+
+//#endregion
+//#region src/cli/repl/tools/shell-security.ts
+/**
+* Shell 安全检查模块
+*
+* 多层安全防护：
+* 1. 硬性阻断列表 — 危险命令无条件拒绝
+* 2. 危险命令审批 — 高风险操作需用户确认
+* 3. 环境变量清洗 — 防止敏感信息泄漏
+* 4. 工作目录验证 — 限制操作范围
+*
+* 参考 Hermes (approval.py) 和 Claude Code (bashSecurity.ts) 的设计。
+*
+* @module cli/repl/tools/shell-security
+*/
+const BLOCK_RULES = [
+	{
+		name: "rm-rf-root",
+		pattern: /\brm\s+-[a-zA-Z0-9-]*[rf][a-zA-Z0-9-]*[rf][a-zA-Z0-9-]*\s+(?:--no-preserve-root\s+)?["']?\/["']?(?:\s|$)/,
+		risk: "critical",
+		reason: "禁止递归强制删除根目录"
+	},
+	{
+		name: "dd-block-device",
+		pattern: /\bdd\s+.*\bof=\/dev\/(?:sd|nvme|hd|xvd|vd|mmcblk)/,
+		risk: "critical",
+		reason: "禁止直接写入裸块设备"
+	},
+	{
+		name: "system-shutdown",
+		pattern: /\b(?:shutdown|reboot|halt|poweroff|init\s+[06])\b/,
+		risk: "critical",
+		reason: "禁止执行系统关机/重启命令"
+	},
+	{
+		name: "fork-bomb",
+		pattern: /:\s*\(\s*\)\s*\{/,
+		risk: "critical",
+		reason: "检测到 fork bomb 模式"
+	},
+	{
+		name: "mkfs",
+		pattern: /\bmkfs\.\w+/,
+		risk: "critical",
+		reason: "禁止执行格式化命令"
+	},
+	{
+		name: "chmod-root",
+		pattern: /\bchmod\s+(?:.*\s)?-R\s+777\s+\//,
+		risk: "critical",
+		reason: "禁止递归修改根目录权限为 777"
+	},
+	{
+		name: "overwrite-system",
+		pattern: /(?:>|>>)\s*\/etc\/(?:passwd|shadow|sudoers|hosts)/,
+		risk: "critical",
+		reason: "禁止覆盖关键系统文件"
+	}
+];
+const APPROVAL_RULES = [
+	{
+		name: "rm-recursive",
+		pattern: /\brm\s+(?:-[a-zA-Z]*r[a-zA-Z]*|-rf?)\b/,
+		risk: "high",
+		message: "检测到递归删除操作，请确认要删除的文件/目录。"
+	},
+	{
+		name: "force-push-main",
+		pattern: /\bgit\s+push\s+(?:-[a-zA-Z]*f[a-zA-Z]*|--force)\s+origin\s+(?:main|master)\b/,
+		risk: "high",
+		message: "检测到强制推送到 main/master 分支，可能覆盖远程历史。"
+	},
+	{
+		name: "curl-pipe-shell",
+		pattern: /\b(?:curl|wget)\s+.*\|\s*(?:sh|bash|zsh|python|ruby|perl)\b/,
+		risk: "high",
+		message: "检测到从网络下载并直接执行脚本，请确认来源可信。"
+	},
+	{
+		name: "eval-exec",
+		pattern: /\beval\s+/,
+		risk: "medium",
+		message: "检测到 eval 命令，可能执行动态内容。"
+	},
+	{
+		name: "source-exec",
+		pattern: /\bsource\s+/,
+		risk: "medium",
+		message: "检测到 source 命令执行文件。"
+	},
+	{
+		name: "sudo",
+		pattern: /\bsudo\b/,
+		risk: "medium",
+		message: "检测到 sudo 提权操作。"
+	},
+	{
+		name: "chmod-system",
+		pattern: /\bchmod\s+.*\/(?:etc|usr|bin|sbin|opt|var|home)\b/,
+		risk: "medium",
+		message: "检测到修改系统目录权限。"
+	},
+	{
+		name: "chown-recursive",
+		pattern: /\bchown\s+(?:-[a-zA-Z]*R[a-zA-Z]*\s+)/,
+		risk: "medium",
+		message: "检测到递归修改文件所有者。"
+	}
+];
+const BLOCKED_ENV_KEYS = new Set([
+	"CI_JOB_TOKEN",
+	"CI_BUILD_TOKEN",
+	"GITLAB_TOKEN",
+	"CIRCLECI_TOKEN",
+	"TRAVIS_TOKEN",
+	"DOCKER_PASSWORD",
+	"DOCKER_AUTH",
+	"NPM_TOKEN",
+	"NPM_AUTH_TOKEN",
+	"NODE_AUTH_TOKEN",
+	"OPENAI_API_KEY",
+	"ANTHROPIC_API_KEY",
+	"COHERE_API_KEY",
+	"GOOGLE_AI_API_KEY",
+	"MISTRAL_API_KEY",
+	"DEEPSEEK_API_KEY",
+	"AZURE_OPENAI_API_KEY",
+	"HUGGINGFACE_TOKEN",
+	"REPLICATE_API_KEY",
+	"DATABASE_URL",
+	"DB_PASSWORD",
+	"PGPASSWORD",
+	"MYSQL_PWD",
+	"REDIS_URL",
+	"MONGO_URL",
+	"ELASTIC_URL",
+	"JWT_SECRET",
+	"ENCRYPTION_KEY",
+	"PRIVATE_KEY",
+	"AWS_SECRET_ACCESS_KEY",
+	"AWS_SESSION_TOKEN",
+	"LD_PRELOAD",
+	"DYLD_INSERT_LIBRARIES",
+	"DYLD_LIBRARY_PATH",
+	"LD_LIBRARY_PATH",
+	"BASH_FUNC_",
+	"NODE_OPTIONS",
+	"PYTHONPATH",
+	"PERL5LIB",
+	"RUBYLIB",
+	"CLASSPATH"
+]);
+const BLOCKED_ENV_KEY_PREFIXES = [
+	"AWS_SECRET_",
+	"AZURE_CLIENT_SECRET_",
+	"GCP_SECRET_"
+];
+const FORBIDDEN_WORKDIR_PREFIXES = ["/etc", "/root"];
+/**
+* 检查命令安全性（阻断检查 + 审批检查）
+*/
+function checkCommandSecurity(command) {
+	const normalized = stripAnsi(command).replace(/\s+/g, " ").trim();
+	if (!normalized) return {
+		allowed: false,
+		blocked: true,
+		reason: "命令为空"
+	};
+	for (const rule of BLOCK_RULES) if (rule.pattern.test(normalized)) return {
+		allowed: false,
+		blocked: true,
+		risk: rule.risk,
+		reason: rule.reason,
+		matchedRule: rule.name
+	};
+	for (const rule of APPROVAL_RULES) if (rule.pattern.test(normalized)) return {
+		allowed: true,
+		requiresApproval: true,
+		risk: rule.risk,
+		reason: rule.message,
+		matchedRule: rule.name
+	};
+	return { allowed: true };
+}
+/**
+* 清洗环境变量（返回安全的子进程环境）
+*/
+function sanitizeEnv(customEnv) {
+	const env = {};
+	for (const [key, value] of Object.entries(process.env)) {
+		if (value === void 0) continue;
+		if (BLOCKED_ENV_KEYS.has(key.toUpperCase())) continue;
+		if (BLOCKED_ENV_KEY_PREFIXES.some((prefix) => key.toUpperCase().startsWith(prefix))) continue;
+		env[key] = value;
+	}
+	if (customEnv) for (const [key, value] of Object.entries(customEnv)) {
+		if (BLOCKED_ENV_KEYS.has(key.toUpperCase())) continue;
+		if (BLOCKED_ENV_KEY_PREFIXES.some((prefix) => key.toUpperCase().startsWith(prefix))) continue;
+		env[key] = value;
+	}
+	return env;
+}
+/**
+* 验证工作目录安全性
+*/
+function validateWorkdir(workdir) {
+	const resolved = workdir ? path.resolve(workdir) : process.cwd();
+	for (const prefix of FORBIDDEN_WORKDIR_PREFIXES) if (resolved === prefix || resolved.startsWith(prefix + path.sep)) return {
+		valid: false,
+		reason: `不允许在 ${prefix} 目录下执行命令`,
+		resolved
+	};
+	return {
+		valid: true,
+		resolved
+	};
+}
+/**
+* 剥离 ANSI 转义序列（ECMA-48 CSI 序列）
+*/
+function stripAnsi(text) {
+	const esc = String.fromCharCode(27);
+	const bel = String.fromCharCode(7);
+	const patterns = [
+		new RegExp(`${esc}\\[[0-9;]*[a-zA-Z]`, "g"),
+		new RegExp(`${esc}\\][0-9;]*[^${bel}]*(${bel}|$)`, "g"),
+		new RegExp(`${esc}[PX^_][^${esc}]*${esc}\\\\`, "g"),
+		new RegExp(`${esc}\\[[?]?[0-9;]*[hl]`, "g"),
+		new RegExp(`${esc}[=>]`, "g"),
+		new RegExp(`${esc}[\\x40-\\x5f]`, "g")
+	];
+	let result = text;
+	for (const pattern of patterns) result = result.replace(pattern, "");
+	return result;
+}
+/**
+* 截断输出（头 40% + 尾 60%）
+*/
+function truncateOutput(text, maxChars = 1e5) {
+	if (text.length <= maxChars) return text;
+	const headChars = Math.floor(maxChars * .4);
+	const tailChars = Math.floor(maxChars * .6);
+	const head = text.slice(0, headChars);
+	const tail = text.slice(-tailChars);
+	return head + `\n\n... [已截断 ${text.length - headChars - tailChars} 个字符] ...\n\n` + tail;
+}
+/**
+* 脱敏输出中的敏感信息
+*/
+function redactSensitiveInfo(text) {
+	let result = text;
+	result = result.replace(/sk-[a-zA-Z0-9_-]{20,}/g, "sk-***");
+	result = result.replace(/ghp_[a-zA-Z0-9]{20,}/g, "ghp_***");
+	result = result.replace(/AKIA[0-9A-Z]{16}/g, "AKIA***");
+	result = result.replace(/eyJ[a-zA-Z0-9_-]+\.eyJ[a-zA-Z0-9_-]+\.[a-zA-Z0-9_-]+/g, "<JWT-TOKEN>");
+	result = result.replace(/([a-zA-Z0-9_-]{15,}=)([a-zA-Z0-9+/]{20,})/g, "$1***");
+	result = result.replace(/-----BEGIN (?:RSA|EC|DSA|OPENSSH) PRIVATE KEY-----[\s\S]*?-----END (?:RSA|EC|DSA|OPENSSH) PRIVATE KEY-----/g, "<PRIVATE-KEY>");
+	return result;
+}
+
+//#endregion
+//#region src/cli/repl/tools/shell-exec.ts
+/**
+* exec 工具实现 — Shell 命令执行
+*
+* 功能：
+* - 前台/后台命令执行
+* - 超时控制
+* - PTY 支持（可选）
+* - 安全检查集成
+* - 输出处理（ANSI 剥离、截断、脱敏）
+*
+* 参考 Hermes (terminal_tool.py) 和 Claude Code (BashTool.tsx) 的设计。
+*
+* @module cli/repl/tools/shell-exec
+*/
+const DEFAULT_TIMEOUT_SEC = 180;
+const MAX_FOREGROUND_TIMEOUT_SEC = 600;
+const MAX_OUTPUT_CHARS = 1e5;
+const KILL_GRACE_PERIOD_MS = 2e3;
+function createExecTool() {
+	return {
+		id: "Exec",
+		label: "执行命令",
+		description: "在本地执行 Shell 命令。支持前台/后台模式、超时控制、PTY 交互。可用于构建、测试、git 操作、文件操作、包管理等。当需要执行命令行操作时调用此工具，不要直接操作文件系统。注意：危险命令（如 rm -rf /、shutdown 等）会被自动阻断。长时间运行的任务请使用 background=true 在后台执行。",
+		parameters: {
+			type: "object",
+			properties: {
+				command: {
+					type: "string",
+					description: "要执行的 Shell 命令"
+				},
+				workdir: {
+					type: "string",
+					description: "工作目录，默认为当前项目根目录"
+				},
+				timeout: {
+					type: "number",
+					description: `超时时间（秒），默认 ${DEFAULT_TIMEOUT_SEC}，最大 ${MAX_FOREGROUND_TIMEOUT_SEC}`
+				},
+				background: {
+					type: "boolean",
+					description: "是否在后台运行。长时间任务（构建、服务启动等）应设为 true"
+				},
+				pty: {
+					type: "boolean",
+					description: "是否使用 PTY 模式（适用于交互式命令），默认 false"
+				}
+			},
+			required: ["command"]
+		},
+		async execute(_toolCallId, params, signal) {
+			const startTime = Date.now();
+			const securityResult = checkCommandSecurity(params.command);
+			if (securityResult.blocked) return {
+				content: [{
+					type: "text",
+					text: formatBlockedOutput(params.command, securityResult.reason)
+				}],
+				details: {
+					command: params.command,
+					status: "blocked",
+					exitCode: -1,
+					durationMs: Date.now() - startTime
+				}
+			};
+			const workdirResult = validateWorkdir(params.workdir);
+			if (!workdirResult.valid) return {
+				content: [{
+					type: "text",
+					text: `工作目录无效: ${workdirResult.reason}`
+				}],
+				details: {
+					command: params.command,
+					status: "error",
+					exitCode: -1,
+					durationMs: Date.now() - startTime
+				}
+			};
+			const shell = getShell();
+			const isBackground = params.background === true;
+			const timeoutSec = isBackground ? 0 : Math.min(params.timeout ?? DEFAULT_TIMEOUT_SEC, MAX_FOREGROUND_TIMEOUT_SEC);
+			const env = sanitizeEnv();
+			let childProcess;
+			try {
+				childProcess = spawn(shell, ["-c", params.command], {
+					cwd: workdirResult.resolved,
+					env,
+					stdio: [
+						"pipe",
+						"pipe",
+						"pipe"
+					],
+					...os.platform() !== "win32" ? { detached: false } : {}
+				});
+			} catch (err) {
+				return {
+					content: [{
+						type: "text",
+						text: `进程启动失败: ${err instanceof Error ? err.message : String(err)}`
+					}],
+					details: {
+						command: params.command,
+						status: "error",
+						exitCode: -1,
+						durationMs: Date.now() - startTime
+					}
+				};
+			}
+			if (isBackground) {
+				const session = getProcessRegistry().register(params.command, childProcess, { workdir: workdirResult.resolved });
+				return {
+					content: [{
+						type: "text",
+						text: `[后台进程已启动]\nSession ID: ${session.sessionId}\nPID: ${session.pid}\n命令: ${params.command}\n使用 process 工具 (action=poll) 获取状态和输出。`
+					}],
+					details: {
+						command: params.command,
+						status: "running",
+						pid: session.pid,
+						sessionId: session.sessionId,
+						durationMs: Date.now() - startTime,
+						workdir: workdirResult.resolved
+					}
+				};
+			}
+			try {
+				const result = await runForeground(childProcess, timeoutSec, signal);
+				const durationMs = Date.now() - startTime;
+				return {
+					content: [{
+						type: "text",
+						text: processOutput(result.stdout, result.stderr, result.exitCode, result.timedOut, result.killed)
+					}],
+					details: {
+						command: params.command,
+						status: result.timedOut ? "timeout" : result.killed ? "killed" : result.exitCode === 0 ? "completed" : "failed",
+						exitCode: result.exitCode,
+						signal: result.signal,
+						durationMs,
+						workdir: workdirResult.resolved
+					}
+				};
+			} catch (err) {
+				const durationMs = Date.now() - startTime;
+				return {
+					content: [{
+						type: "text",
+						text: `命令执行异常: ${err instanceof Error ? err.message : String(err)}`
+					}],
+					details: {
+						command: params.command,
+						status: "error",
+						exitCode: -1,
+						durationMs
+					}
+				};
+			}
+		}
+	};
+}
+function runForeground(childProcess, timeoutSec, signal) {
+	return new Promise((resolve) => {
+		const stdoutChunks = [];
+		const stderrChunks = [];
+		let timedOut = false;
+		let killed = false;
+		let settled = false;
+		const settle = (result) => {
+			if (settled) return;
+			settled = true;
+			if (timeoutTimer) clearTimeout(timeoutTimer);
+			if (killTimer) clearTimeout(killTimer);
+			resolve(result);
+		};
+		if (childProcess.stdout) childProcess.stdout.on("data", (data) => {
+			stdoutChunks.push(data.toString("utf-8"));
+		});
+		if (childProcess.stderr) childProcess.stderr.on("data", (data) => {
+			stderrChunks.push(data.toString("utf-8"));
+		});
+		childProcess.on("exit", (code, procSignal) => {
+			settle({
+				stdout: stdoutChunks.join(""),
+				stderr: stderrChunks.join(""),
+				exitCode: code,
+				signal: procSignal,
+				timedOut,
+				killed
+			});
+		});
+		childProcess.on("error", (err) => {
+			settle({
+				stdout: stdoutChunks.join(""),
+				stderr: stderrChunks.join("") + `\n[进程错误: ${err.message}]`,
+				exitCode: -1,
+				signal: null,
+				timedOut: false,
+				killed: false
+			});
+		});
+		let timeoutTimer;
+		let killTimer;
+		if (timeoutSec > 0) timeoutTimer = setTimeout(() => {
+			timedOut = true;
+			try {
+				if (childProcess.pid && os.platform() !== "win32") try {
+					process.kill(-childProcess.pid, "SIGTERM");
+				} catch {
+					childProcess.kill("SIGTERM");
+				}
+				else childProcess.kill("SIGTERM");
+			} catch {}
+			killTimer = setTimeout(() => {
+				killed = true;
+				try {
+					if (childProcess.pid && os.platform() !== "win32") try {
+						process.kill(-childProcess.pid, "SIGKILL");
+					} catch {
+						childProcess.kill("SIGKILL");
+					}
+					else childProcess.kill("SIGKILL");
+				} catch {}
+			}, KILL_GRACE_PERIOD_MS);
+		}, timeoutSec * 1e3);
+		if (signal) signal.addEventListener("abort", () => {
+			try {
+				if (childProcess.pid && os.platform() !== "win32") process.kill(-childProcess.pid, "SIGTERM");
+				else childProcess.kill("SIGTERM");
+			} catch {}
+		}, { once: true });
+	});
+}
+function getShell() {
+	if (os.platform() === "win32") return process.env.COMSPEC || "cmd.exe";
+	return process.env.SHELL || "/bin/bash";
+}
+function processOutput(stdout, stderr, exitCode, timedOut, killed) {
+	let output = stdout;
+	if (stderr) output += (output ? "\n" : "") + stderr;
+	output = stripAnsi(output);
+	output = redactSensitiveInfo(output);
+	output = truncateOutput(output, MAX_OUTPUT_CHARS);
+	if (timedOut) output += "\n\n[命令执行超时]";
+	else if (killed) output += "\n\n[命令已被终止]";
+	else if (exitCode !== null && exitCode !== 0) output += `\n\n(命令退出码: ${exitCode})`;
+	return output || "(无输出)";
+}
+function formatBlockedOutput(command, reason) {
+	return `[安全检查] 命令被阻断\n\n命令: ${command}\n原因: ${reason}\n\n此命令属于危险操作，已被自动拒绝执行。`;
+}
+
+//#endregion
+//#region src/cli/repl/tools/shell-process.ts
+/**
+* process 工具实现 — 后台进程管理
+*
+* 管理 exec 工具启动的后台进程：
+* - list: 列出所有后台进程
+* - poll: 检查状态 + 获取新输出
+* - log: 获取完整或部分输出
+* - wait: 等待进程完成
+* - kill: 终止进程
+* - write: 向 stdin 写入数据
+* - submit: 向 stdin 写入数据 + 换行
+*
+* 参考 Hermes (process_registry.py) 和 OpenClaw (bash-tools.process.ts) 的设计。
+*
+* @module cli/repl/tools/shell-process
+*/
+function createProcessTool() {
+	return {
+		id: "Process",
+		label: "管理进程",
+		description: "管理后台运行的进程。支持的操作：\n- list: 列出所有后台进程\n- poll: 检查进程状态并获取新输出\n- log: 获取进程完整或部分日志\n- wait: 等待进程完成\n- kill: 终止进程\n- write: 向进程 stdin 写入数据\n- submit: 向进程 stdin 写入数据并追加换行",
+		parameters: {
+			type: "object",
+			properties: {
+				action: {
+					type: "string",
+					description: "操作类型: list, poll, log, wait, kill, write, submit",
+					enum: [
+						"list",
+						"poll",
+						"log",
+						"wait",
+						"kill",
+						"write",
+						"submit"
+					]
+				},
+				sessionId: {
+					type: "string",
+					description: "进程 session ID（除 list 外必需）"
+				},
+				data: {
+					type: "string",
+					description: "write/submit 时写入的数据"
+				},
+				offset: {
+					type: "number",
+					description: "log 时的行偏移量"
+				},
+				limit: {
+					type: "number",
+					description: "log 时的最大行数（默认 40）"
+				},
+				waitTimeout: {
+					type: "number",
+					description: "wait 时的超时（毫秒），默认无超时"
+				}
+			},
+			required: ["action"]
+		},
+		async execute(_toolCallId, params) {
+			const registry = getProcessRegistry();
+			switch (params.action) {
+				case "list": return handleList(registry);
+				case "poll": return handlePoll(registry, params);
+				case "log": return handleLog(registry, params);
+				case "wait": return await handleWait(registry, params);
+				case "kill": return handleKill(registry, params);
+				case "write": return handleWrite(registry, params, false);
+				case "submit": return handleWrite(registry, params, true);
+				default: return { content: [{
+					type: "text",
+					text: `未知操作: ${params.action}。支持: list, poll, log, wait, kill, write, submit`
+				}] };
+			}
+		}
+	};
+}
+function handleList(registry) {
+	const sessions = registry.list();
+	if (sessions.length === 0) return {
+		content: [{
+			type: "text",
+			text: "(没有活动的后台进程)"
+		}],
+		details: {
+			action: "list",
+			sessions: [],
+			processCount: 0
+		}
+	};
+	const lines = [`共 ${sessions.length} 个后台进程:`, ""];
+	for (const s of sessions) {
+		const statusIcon = statusIconMap[s.status];
+		const duration = formatDuration(Date.now() - s.startTime);
+		lines.push(`${statusIcon} [${s.sessionId}] ${s.status}`);
+		lines.push(`   PID: ${s.pid} | 运行: ${duration} | 命令: ${truncateCommand(s.command)}`);
+		lines.push("");
+	}
+	return {
+		content: [{
+			type: "text",
+			text: lines.join("\n")
+		}],
+		details: {
+			action: "list",
+			sessions,
+			processCount: sessions.length
+		}
+	};
+}
+function handlePoll(registry, params) {
+	if (!params.sessionId) return { content: [{
+		type: "text",
+		text: "poll 操作需要 sessionId 参数"
+	}] };
+	const result = registry.poll(params.sessionId);
+	if (!result) return { content: [{
+		type: "text",
+		text: `进程 ${params.sessionId} 未找到`
+	}] };
+	const { session, newOutput } = result;
+	const statusIcon = statusIconMap[session.status];
+	const duration = formatDuration(Date.now() - session.startTime);
+	let text = `${statusIcon} [${session.sessionId}] ${session.status}\n`;
+	text += `PID: ${session.pid} | 运行: ${duration}\n`;
+	if (session.exitCode != null) text += `退出码: ${session.exitCode}\n`;
+	if (newOutput) text += `\n--- 新输出 ---\n${newOutput}`;
+	else if (session.status === "running") text += "\n(尚无新输出)";
+	return {
+		content: [{
+			type: "text",
+			text
+		}],
+		details: {
+			action: "poll",
+			sessionId: session.sessionId
+		}
+	};
+}
+function handleLog(registry, params) {
+	if (!params.sessionId) return { content: [{
+		type: "text",
+		text: "log 操作需要 sessionId 参数"
+	}] };
+	const logOptions = {};
+	if (params.offset !== void 0) logOptions.offset = params.offset;
+	if (params.limit !== void 0) logOptions.limit = params.limit;
+	const result = registry.getLog(params.sessionId, logOptions);
+	if (!result) return { content: [{
+		type: "text",
+		text: `进程 ${params.sessionId} 未找到`
+	}] };
+	const { session, output } = result;
+	let text = `[${session.sessionId}] ${session.status}\n`;
+	if (session.exitCode != null) text += `退出码: ${session.exitCode}\n`;
+	text += `\n${output || "(无输出)"}`;
+	return {
+		content: [{
+			type: "text",
+			text
+		}],
+		details: {
+			action: "log",
+			sessionId: session.sessionId
+		}
+	};
+}
+async function handleWait(registry, params) {
+	if (!params.sessionId) return { content: [{
+		type: "text",
+		text: "wait 操作需要 sessionId 参数"
+	}] };
+	const session = await registry.wait(params.sessionId, params.waitTimeout);
+	if (!session) return { content: [{
+		type: "text",
+		text: `进程 ${params.sessionId} 未找到`
+	}] };
+	const duration = formatDuration(Date.now() - session.startTime);
+	let text = `[${session.sessionId}] ${session.status}\n`;
+	text += `总运行时间: ${duration}\n`;
+	if (session.exitCode != null) text += `退出码: ${session.exitCode}\n`;
+	return {
+		content: [{
+			type: "text",
+			text
+		}],
+		details: {
+			action: "wait",
+			sessionId: session.sessionId
+		}
+	};
+}
+function handleKill(registry, params) {
+	if (!params.sessionId) return { content: [{
+		type: "text",
+		text: "kill 操作需要 sessionId 参数"
+	}] };
+	const session = registry.kill(params.sessionId);
+	if (!session) return { content: [{
+		type: "text",
+		text: `进程 ${params.sessionId} 未找到`
+	}] };
+	return {
+		content: [{
+			type: "text",
+			text: `[${session.sessionId}] 已发送终止信号 (SIGTERM)\nPID: ${session.pid}\n命令: ${truncateCommand(session.command)}`
+		}],
+		details: {
+			action: "kill",
+			sessionId: session.sessionId
+		}
+	};
+}
+function handleWrite(registry, params, newline) {
+	if (!params.sessionId) return { content: [{
+		type: "text",
+		text: "write/submit 操作需要 sessionId 参数"
+	}] };
+	if (!params.data) return { content: [{
+		type: "text",
+		text: "write/submit 操作需要 data 参数"
+	}] };
+	const session = registry.write(params.sessionId, params.data, newline);
+	if (!session) return { content: [{
+		type: "text",
+		text: `进程 ${params.sessionId} 未找到`
+	}] };
+	if (session.status !== "running") return { content: [{
+		type: "text",
+		text: `Cannot write to process ${params.sessionId}: status is ${session.status}`
+	}] };
+	const action = newline ? "submit" : "write";
+	return {
+		content: [{
+			type: "text",
+			text: `已向 [${session.sessionId}] ${action === "submit" ? "发送并提交" : "写入"}数据。`
+		}],
+		details: {
+			action,
+			sessionId: session.sessionId
+		}
+	};
+}
+const statusIconMap = {
+	running: "🔄",
+	exited: "✅",
+	killed: "🛑",
+	timeout: "⏰",
+	errored: "❌"
+};
+function formatDuration(ms) {
+	const seconds = Math.floor(ms / 1e3);
+	if (seconds < 60) return `${seconds}s`;
+	const minutes = Math.floor(seconds / 60);
+	const remainingSec = seconds % 60;
+	if (minutes < 60) return `${minutes}m ${remainingSec}s`;
+	return `${Math.floor(minutes / 60)}h ${minutes % 60}m`;
+}
+function truncateCommand(command, maxLen = 80) {
+	if (command.length <= maxLen) return command;
+	return command.slice(0, maxLen - 3) + "...";
+}
+
+//#endregion
+//#region src/cli/repl/tools/skill-tool.ts
+/**
+* Skill 工具实现 — 技能调用
+*
+* 将 Skill 作为 ToolRegistration 注册到 Agent，
+* 模型可主动调用此工具来执行预定义的技能工作流。
+*
+* 参考 Claude Code 的 SkillTool（inline 模式）和 Hermes-Agent 的 skill_view。
+*
+* @module cli/repl/tools/skill-tool
+*/
+const SKILL_DESCRIPTION = `调用预定义的技能（Skill）来执行特定工作流。
+
+技能是预定义的工作流模板，封装了完成特定任务所需的指令、工具调用和最佳实践。
+
+## 如何使用
+- 使用 skill 参数指定技能名称
+- 使用可选的 args 参数传递参数（如文件名、选项等）
+- 调用后技能内容会展开为当前对话的上下文，模型据此执行
+
+## 示例
+- skill: "commit" — 调用 commit 技能生成规范的 git commit
+- skill: "review-pr", args: "123" — 调用 review-pr 技能审查指定的 PR`;
+/** 已加载的 Skill 条目（由外部注入） */
+let skillEntries = [];
+/**
+* 更新已加载的 Skill 列表
+*/
+function setSkillEntries(entries) {
+	skillEntries = entries;
+}
+/**
+* 替换 Skill 内容中的模板变量
+*
+* 支持的变量：
+* - $ARGUMENTS / $ARGUMENTS[0] / $ARGUMENTS[1] — 按索引的参数
+* - $0 / $1 / $2 — 按索引的参数简写
+* - ${ZAPMYCO_SKILL_DIR} — Skill 目录绝对路径
+*/
+function substituteVariables(content, args, skillDir, skillName) {
+	let result = content;
+	result = result.replace(/\$\{ZAPMYCO_SKILL_DIR\}/g, skillDir);
+	result = result.replace(/\$\{SKILL_DIR\}/g, skillDir);
+	const parsedArgs = parseArgs(args);
+	result = result.replace(/\$ARGUMENTS\b/g, args ?? "");
+	result = result.replace(/\$ARGUMENTS\[(\d+)\]/g, (_match, idx) => {
+		return parsedArgs[parseInt(idx, 10)] ?? "";
+	});
+	result = result.replace(/\$(\d+)\b/g, (_match, idx) => {
+		return parsedArgs[parseInt(idx, 10)] ?? "";
+	});
+	result = result.replace(/\$name\b/g, skillName);
+	return result;
+}
+/**
+* 简易参数解析（支持引号和转义）
+*/
+function parseArgs(args) {
+	if (!args) return [];
+	const result = [];
+	let current = "";
+	let inSingleQuote = false;
+	let inDoubleQuote = false;
+	for (let i = 0; i < args.length; i++) {
+		const ch = args[i] ?? "";
+		if (inSingleQuote) if (ch === "'") inSingleQuote = false;
+		else current += ch;
+		else if (inDoubleQuote) if (ch === "\"") inDoubleQuote = false;
+		else if (ch === "\\" && i + 1 < args.length) {
+			i++;
+			current += args[i] ?? "";
+		} else current += ch;
+		else if (ch === "'") inSingleQuote = true;
+		else if (ch === "\"") inDoubleQuote = true;
+		else if (ch === " " || ch === "	") {
+			if (current.length > 0) {
+				result.push(current);
+				current = "";
+			}
+		} else current += ch;
+	}
+	if (current.length > 0) result.push(current);
+	return result;
+}
+/**
+* 创建 Skill 工具
+*
+* @param _config - Skill 加载配置（保留用于未来扩展）
+*/
+function createSkillTool(_config) {
+	return {
+		id: "Skill",
+		label: "技能调用",
+		description: SKILL_DESCRIPTION,
+		parameters: {
+			type: "object",
+			properties: {
+				skill: {
+					type: "string",
+					description: "要调用的技能名称（如 \"commit\"、\"review-pr\"）"
+				},
+				args: {
+					type: "string",
+					description: "传递给技能的可选参数（如文件名、选项等）"
+				}
+			},
+			required: ["skill"]
+		},
+		async execute(_toolCallId, params) {
+			const skillName = params.skill?.trim();
+			if (!skillName) return {
+				content: [{
+					type: "text",
+					text: "请提供要调用的技能名称。"
+				}],
+				details: { error: "skill 参数为空" }
+			};
+			const entry = skillEntries.find((e) => e.skill.name.toLowerCase() === skillName.toLowerCase());
+			if (!entry) {
+				const available = skillEntries.map((e) => e.skill.name).join(", ");
+				return {
+					content: [{
+						type: "text",
+						text: `未找到技能 "${skillName}"。\n\n可用技能: ${available || "(无)"}`
+					}],
+					details: {
+						error: `技能 "${skillName}" 不存在`,
+						available
+					}
+				};
+			}
+			const { skill } = entry;
+			let content;
+			try {
+				content = await readFile(skill.filePath, "utf-8");
+			} catch (err) {
+				return {
+					content: [{
+						type: "text",
+						text: `读取技能文件失败: ${err instanceof Error ? err.message : String(err)}`
+					}],
+					details: {
+						error: "读取文件失败",
+						path: skill.filePath
+					}
+				};
+			}
+			let bodyContent = content;
+			if (content.trimStart().startsWith("---")) {
+				const endIdx = content.indexOf("---", 3);
+				if (endIdx !== -1) bodyContent = content.slice(endIdx + 3).trim();
+			}
+			const substituted = substituteVariables(bodyContent, params.args, skill.baseDir, skill.name);
+			const hint = skill.frontmatter["argument-hint"] ? ` [${skill.frontmatter["argument-hint"]}]` : "";
+			const instructionParts = [
+				`# Skill: ${skill.name}${hint}`,
+				"",
+				skill.description ? `> ${skill.description}` : "",
+				"",
+				"---",
+				"",
+				substituted,
+				"",
+				"---",
+				`Base directory: ${skill.baseDir}`
+			];
+			if (!substituted.includes(params.args ?? "") && params.args) instructionParts.push("", `ARGUMENTS: ${params.args}`);
+			return {
+				content: [{
+					type: "text",
+					text: instructionParts.filter(Boolean).join("\n")
+				}],
+				details: {
+					skill: skill.name,
+					description: skill.description,
+					source: skill.source,
+					baseDir: skill.baseDir,
+					context: skill.frontmatter.context ?? "inline",
+					allowedTools: skill.frontmatter["allowed-tools"] ?? [],
+					args: params.args
+				}
+			};
+		}
+	};
+}
+/**
+* 从 Skill 条目列表获取命令规格（用于自动注册斜杠命令）
+*/
+function getSkillCommandSpecs(entries) {
+	return entries.filter((e) => e.skill.userInvocable).map((e) => ({
+		name: sanitizeSkillCommandName(e.skill.name),
+		description: e.skill.description || `调用 ${e.skill.name} 技能`,
+		isSkill: true
+	}));
+}
+/**
+* 规范化技能命令名称
+*
+* 转换为小写，非字母数字字符替换为连字符。
+*/
+function sanitizeSkillCommandName(name) {
+	return name.toLowerCase().replace(/[^a-z0-9_-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "").slice(0, 32);
+}
+
+//#endregion
+//#region src/cli/repl/tools/subagent-spawn.ts
+/**
+* 创建 spawn_subagents 工具注册
+*
+* @param manager - SubAgentManager 实例
+* @param config - Sub-Agent 系统配置
+* @returns ToolRegistration
+*/
+function createSpawnSubAgentsTool(manager, _config) {
+	return {
+		id: "SpawnSubAgents",
+		label: "派生子 Agent",
+		description: [
+			"并行启动多个子 Agent 执行独立任务，等待全部完成后汇总返回结果。",
+			"",
+			"### 何时使用此工具",
+			"1. 用户请求包含 2 个以上互不依赖的独立步骤",
+			"2. 每个步骤需要独立的搜索、分析或研究",
+			"3. 步骤之间没有顺序依赖关系，可以同时进行",
+			"",
+			"### 何时不使用此工具",
+			"- 只有 1 个任务时（直接执行即可）",
+			"- 任务之间有严格的顺序依赖（必须串行执行）",
+			"- 任务非常简单（如读取单个文件）",
+			"",
+			"### 使用流程",
+			"1. 先用 TaskManage write 规划所有子任务",
+			"2. 识别其中可并行的独立子任务",
+			"3. 调用本工具一次性派发所有并行子任务",
+			"4. 根据返回结果更新 TaskManage 状态",
+			"5. 继续处理依赖这些结果的后续任务",
+			"",
+			"### 参数说明",
+			"- agents: 子任务列表，每个包含 id（唯一标识）、description（详细指令）、allowedTools（可选工具白名单）",
+			"- context: 可选背景摘要，会注入给每个子 Agent 帮助它们理解任务背景",
+			"",
+			"### 子 Agent 的能力",
+			"默认情况下子 Agent 拥有安全的只读工具集：ReadFile, Glob, Grep, WebFetch, WebSearch。",
+			"如需子 Agent 写文件或执行命令，请在 allowedTools 中显式指定。"
+		].join("\n"),
+		parameters: {
+			type: "object",
+			properties: {
+				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 列表"
+				},
+				context: {
+					type: "string",
+					description: "可选背景摘要，注入给每个子 Agent"
+				}
+			},
+			required: ["agents"]
+		},
+		execute: async (_toolCallId, params) => {
+			const { agents, context } = params;
+			const results = await manager.spawnAndWait(agents, context);
+			return {
+				content: [{
+					type: "text",
+					text: results.summary
+				}],
+				details: results
+			};
+		}
+	};
+}
+
+//#endregion
+//#region src/cli/repl/tools/task-manage.ts
+const TASK_MANAGE_DESCRIPTION = `任务管理工具 — 对于多步骤任务，**这必须是你调用的第一个工具**。
+
+## 何时必须使用
+收到任何需要 2 个以上独立步骤的任务时，**在调用任何其他工具之前**，必须先用 action="write" 将任务分解为子任务。
+**你的第一个 tool call 必须是 TaskManage！** 不得先搜索、读取、执行任何操作！
+
+## 操作类型 (action)
+- "read": 读取当前任务列表和进度摘要
+- "write": 设置任务列表。传入 tasks 数组。用于初次规划或重新规划。merge=true 可追加/更新任务而不删除已有任务
+- "update": 更新单个任务状态。每完成一个子任务**立即**调用 update 标记状态，**不要等到所有任务做完才批量更新**
+
+## 必须遵守的规则
+1. 任何 2 个以上步骤的任务：第一个 tool call = TaskManage write，先规划再执行
+2. 每次只能有 1 个任务处于 "in_progress" 状态
+3. 完成一个子任务后**立刻** update 为 "completed"，然后再开始下一个
+4. 任务状态: "pending"(未开始), "in_progress"(进行中), "completed"(已完成), "cancelled"(已取消)
+5. 不要在一条消息中批量标记多个任务完成 — 每个任务完成时单独 update
+
+> 提示：如果项目启用了 SpawnSubAgents 工具，规划完成后识别其中互不依赖的子任务，使用 SpawnSubAgents 并行执行它们，然后根据结果更新任务状态。`;
 /**
-* 渲染器实现
+* 创建 task_manage 工具
 *
-* 协调 OutputFormatter 和 OutputArea 之间的内容输出。
+* @param store - TaskStore 实例（由 ReplSession 注入，保证会话级生命周期）
 */
-var Renderer = class {
-	formatter;
-	constructor(opts) {
-		this.formatter = new OutputFormatter(opts.color);
-	}
-	/** 获取底层格式化器（供 OutputArea 直接使用） */
-	getFormatter() {
-		return this.formatter;
-	}
-	/** 渲染欢迎信息 → 返回格式化行 */
-	renderWelcome(version) {
-		return this.formatter.formatWelcome(version);
-	}
-	/** 渲染错误信息 → 返回格式化行 */
-	renderError(error) {
-		return this.formatter.formatError(error);
-	}
-	/** 渲染最终执行结果 → 返回格式化行 */
-	renderResult(result) {
-		return this.formatter.formatResult(result);
-	}
-	/** 渲染任务拆分概览 → 返回格式化行 */
-	renderTaskGraph(graph) {
-		return this.formatter.formatTaskGraph(graph);
-	}
-	/** 渲染 Agent 列表 → 返回格式化行 */
-	renderAgents(agents) {
-		return this.formatter.formatAgents(agents);
-	}
-	/** 渲染配置信息 → 返回格式化行 */
-	renderConfig(config) {
-		return this.formatter.formatConfig(config);
+function createTaskManageTool(store) {
+	return {
+		id: "TaskManage",
+		label: "任务管理",
+		description: TASK_MANAGE_DESCRIPTION,
+		parameters: {
+			type: "object",
+			properties: {
+				action: {
+					type: "string",
+					description: "操作类型: \"read\"(读取), \"write\"(全量设置), \"update\"(更新单个任务)。默认 \"read\"。",
+					enum: [
+						"read",
+						"write",
+						"update"
+					]
+				},
+				tasks: {
+					type: "array",
+					description: "任务项数组。write 模式传入完整任务列表，update 模式只传入需要更新的任务。每项包含: id(标识), subject(标题), description(描述, 可选), status(状态)",
+					items: {
+						type: "object",
+						properties: {
+							id: {
+								type: "string",
+								description: "任务唯一标识，如 \"1\", \"2\", \"search-files\""
+							},
+							subject: {
+								type: "string",
+								description: "简短标题（祈使句），如 \"搜索相关文件\""
+							},
+							description: {
+								type: "string",
+								description: "详细描述（可选）"
+							},
+							status: {
+								type: "string",
+								description: "任务状态",
+								enum: [
+									"pending",
+									"in_progress",
+									"completed",
+									"cancelled"
+								]
+							}
+						},
+						required: [
+							"id",
+							"subject",
+							"status"
+						]
+					}
+				},
+				merge: {
+					type: "boolean",
+					description: "write 模式下是否按 ID 合并（默认 false 全量替换）。设为 true 时按 ID 新增/更新任务，不删除已有任务。"
+				}
+			}
+		},
+		async execute(_toolCallId, params) {
+			const action = params.action ?? "read";
+			switch (action) {
+				case "read": return buildReadResult(store);
+				case "write": return buildWriteResult(store, params.tasks, params.merge);
+				case "update": return buildUpdateResult(store, params.tasks);
+				default: return {
+					content: [{
+						type: "text",
+						text: `不支持的操作: ${action}`
+					}],
+					details: {
+						action,
+						tasks: [],
+						summary: {
+							total: 0,
+							pending: 0,
+							in_progress: 0,
+							completed: 0,
+							cancelled: 0
+						},
+						error: `不支持的操作: ${action}`
+					}
+				};
+			}
+		}
+	};
+}
+function buildReadResult(store) {
+	const tasks = store.read();
+	const summary = store.summary();
+	const details = {
+		action: "read",
+		tasks,
+		summary
+	};
+	if (tasks.length === 0) return {
+		content: [{
+			type: "text",
+			text: "当前没有任务。使用 action=\"write\" 创建任务列表来分解复杂工作。"
+		}],
+		details
+	};
+	const lines = [`共 ${summary.total} 个任务:`, ""];
+	for (const task of tasks) {
+		const marker = statusMarker(task.status);
+		const desc = task.description ? ` — ${task.description}` : "";
+		lines.push(`  ${marker} [${task.id}] ${task.subject}${desc}`);
 	}
-	/** 渲染历史记录 → 返回格式化行 */
-	renderHistory(entries) {
-		return this.formatter.formatHistory(entries);
+	lines.push("");
+	lines.push(`进度: ${summary.pending} 待处理 | ${summary.in_progress} 进行中 | ${summary.completed} 已完成 | ${summary.cancelled} 已取消`);
+	return {
+		content: [{
+			type: "text",
+			text: lines.join("\n")
+		}],
+		details
+	};
+}
+function buildWriteResult(store, tasks, merge) {
+	if (!tasks || tasks.length === 0) return {
+		content: [{
+			type: "text",
+			text: "请提供 tasks 参数（任务列表）。使用空数组可清空所有任务。"
+		}],
+		details: {
+			action: "write",
+			tasks: [],
+			summary: store.summary(),
+			error: "tasks 参数为空"
+		}
+	};
+	const error = store.write(tasks, merge ?? false);
+	if (error) return {
+		content: [{
+			type: "text",
+			text: `[任务更新失败] ${error}`
+		}],
+		details: {
+			action: "write",
+			tasks: store.read(),
+			summary: store.summary(),
+			error
+		}
+	};
+	const summary = store.summary();
+	return {
+		content: [{
+			type: "text",
+			text: [`任务列表已更新（${merge ? "合并模式" : "替换模式"}）`, `共 ${summary.total} 个任务: ${summary.pending} 待处理 | ${summary.in_progress} 进行中 | ${summary.completed} 已完成 | ${summary.cancelled} 已取消`].join("\n")
+		}],
+		details: {
+			action: "write",
+			tasks: store.read(),
+			summary
+		}
+	};
+}
+function buildUpdateResult(store, tasks) {
+	if (!tasks || tasks.length === 0) return {
+		content: [{
+			type: "text",
+			text: "请提供 tasks 参数，包含要更新的任务（带 id 和新的 status）。"
+		}],
+		details: {
+			action: "update",
+			tasks: store.read(),
+			summary: store.summary(),
+			error: "tasks 参数为空"
+		}
+	};
+	const results = [];
+	let hasError = false;
+	for (const item of tasks) {
+		const updates = {
+			subject: item.subject,
+			status: item.status
+		};
+		if (item.description !== void 0) updates.description = item.description;
+		const error = store.update(item.id, updates);
+		if (error) {
+			results.push(`  ❌ [${item.id}]: ${error}`);
+			hasError = true;
+		} else {
+			const task = store.read().find((t) => t.id === item.id);
+			const marker = task ? statusMarker(task.status) : "";
+			results.push(`  ✅ [${item.id}] → ${marker} ${item.status}`);
+		}
 	}
-	/** 渲染会话状态 → 返回格式化行 */
-	renderStatus(stats) {
-		return this.formatter.formatStatus(stats);
+	const summary = store.summary();
+	return {
+		content: [{
+			type: "text",
+			text: [hasError ? "部分任务更新失败:" : "任务已更新:", ...results].join("\n")
+		}],
+		details: {
+			action: "update",
+			tasks: store.read(),
+			summary,
+			error: hasError ? "部分更新失败，详见结果" : void 0
+		}
+	};
+}
+function statusMarker(status) {
+	switch (status) {
+		case "pending": return "○";
+		case "in_progress": return "▶";
+		case "completed": return "✅";
+		case "cancelled": return "❌";
+		default: return "?";
 	}
-};
+}
 
 //#endregion
 //#region src/cli/repl/tools/cache.ts
@@ -1375,7 +5499,7 @@ function createWebFetchTool(webConfig) {
 	const ssrfOptions = webConfig?.ssrf ?? {};
 	const cacheTtlMinutes = fetchOptions.cacheTtlMinutes ?? 15;
 	return {
-		id: "web_fetch",
+		id: "WebFetch",
 		label: "网页抓取",
 		description: "抓取指定 URL 的网页内容并转换为 Markdown 格式。支持 HTML 正文提取、JSON 美化、内容截断。当用户需要访问网页获取信息时调用此工具。",
 		parameters: {
@@ -1745,7 +5869,7 @@ function createWebSearchTool(webConfig) {
 	const searchOptions = webConfig?.search ?? {};
 	const cacheTtlMinutes = searchOptions.cacheTtlMinutes ?? 15;
 	return {
-		id: "web_search",
+		id: "WebSearch",
 		label: "网页搜索",
 		description: "在互联网上搜索信息。支持多种搜索引擎后端。当用户需要查找最新信息、技术文档、新闻等时调用此工具。",
 		parameters: {
@@ -1850,37 +5974,35 @@ function createWebSearchTool(webConfig) {
 //#endregion
 //#region src/cli/repl/repl-agent-tools.ts
 /**
-* REPL Agent 工具注册表
-*
-* 定义 REPL 场景下 Agent 可用的工具集合。
-* 工具按能力域分组，支持按需加载。
-*
-* @module cli/repl/repl-agent-tools
-*/
-/**
 * 创建 REPL 基础工具集
 *
-* 第一阶段工具：验证 Agent 工具调用链路的端到端连通性。
-* 后续阶段在此基础扩展：文件读写、Shell 执行、Git 操作等。
-*
-* @param webConfig - Web 工具配置（可选），传入时启用 web_fetch 和 web_search
+* @param webConfig - Web 工具配置（可选），传入时启用 WebFetch 和 WebSearch
+* @param taskStore - TaskStore 实例（可选），传入时启用 TaskManage 工具
 */
-function createReplBuiltinTools(webConfig) {
+function createReplBuiltinTools(webConfig, taskStore, skillConfig, parentAgent, subAgentConfig, cronScheduler) {
 	const tools = [
 		{
-			id: "get_current_time",
+			id: "GetCurrentTime",
 			label: "获取当前时间",
-			description: "获取当前日期和时间。当用户询问时间、需要时间戳、或需要时间相关上下文时调用此工具。",
-			execute: async () => ({
-				content: [{
-					type: "text",
-					text: (/* @__PURE__ */ new Date()).toISOString()
-				}],
-				details: { timestamp: Date.now() }
-			})
+			description: "获取当前日期和时间（含本地时间和 UTC 时间）。当用户询问时间、需要时间戳、或需要时间相关上下文时调用此工具。",
+			execute: async () => {
+				const now = /* @__PURE__ */ new Date();
+				const offset = -now.getTimezoneOffset();
+				const tz = `UTC${offset >= 0 ? "+" : ""}${Math.floor(offset / 60)}:${String(offset % 60).padStart(2, "0")}`;
+				return {
+					content: [{
+						type: "text",
+						text: `本地时间: ${now.toString()}\nISO (UTC): ${now.toISOString()}\n时区: ${tz}`
+					}],
+					details: {
+						timestamp: Date.now(),
+						timezone: tz
+					}
+				};
+			}
 		},
 		{
-			id: "get_workdir_info",
+			id: "GetWorkdirInfo",
 			label: "获取工作目录信息",
 			description: "获取当前工作目录路径和系统平台信息。当需要了解当前项目位置或运行环境时调用。",
 			execute: async () => ({
@@ -1900,29 +6022,51 @@ function createReplBuiltinTools(webConfig) {
 			})
 		},
 		{
-			id: "read_file",
+			id: "ReadFile",
 			label: "读取文件",
-			description: "读取指定路径的文本文件内容。参数 path 为文件绝对或相对路径。",
+			description: "读取指定路径的文本文件内容。参数 file_path 为文件绝对路径。支持 offset（起始行号）和 limit（最大行数）参数用于分页读取大文件。",
 			parameters: {
 				type: "object",
-				properties: { path: {
-					type: "string",
-					description: "文件路径"
-				} },
-				required: ["path"]
+				properties: {
+					file_path: {
+						type: "string",
+						description: "文件绝对路径"
+					},
+					offset: {
+						type: "number",
+						description: "起始行号（1-based，可选）"
+					},
+					limit: {
+						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 content = await fs.readFile(params.path, "utf-8");
+					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: content
+							text: pageContent + (truncated ? `\n\n[文件共 ${lines.length} 行，已显示 ${offset}-${endIdx} 行]` : "")
 						}],
 						details: {
-							path: params.path,
-							size: content.length
+							path: resolvedPath,
+							totalLines: lines.length,
+							displayedLines: endIdx - startIdx,
+							offset,
+							limit,
+							truncated
 						}
 					};
 				} catch (error) {
@@ -1932,7 +6076,7 @@ function createReplBuiltinTools(webConfig) {
 							text: `读取失败: ${error instanceof Error ? error.message : String(error)}`
 						}],
 						details: {
-							path: params.path,
+							path: resolvedPath,
 							error: true
 						}
 					};
@@ -1940,10 +6084,24 @@ function createReplBuiltinTools(webConfig) {
 			}
 		}
 	];
+	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) {
+		const manager = new SubAgentManager(subAgentConfig, parentAgent, tools);
+		tools.push(createSpawnSubAgentsTool(manager, subAgentConfig));
+	}
+	if (cronScheduler) tools.push(createCronTool(cronScheduler));
 	return tools;
 }
 
@@ -1993,6 +6151,411 @@ function createTheme(colorEnabled) {
 	};
 }
 
+//#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);
+	}
+	return servers;
+}
+
+//#endregion
+//#region src/core/mcp/mcp-client.ts
+/**
+* MCP Server 连接管理 (stdio transport)
+*
+* 封装 MCP SDK 的 Client + StdioClientTransport，
+* 提供带超时的连接和优雅关闭能力。
+*
+* @module core/mcp/client
+*/
+const log$2 = logger.child("mcp:client");
+/**
+* 连接到单个 MCP Server 并发现其工具
+*
+* 任何失败都会返回 null（优雅降级），不阻塞其他 server。
+*
+* @param config - Server 配置
+* @param signal - 可选的 AbortSignal 用于取消连接
+* @returns 连接对象，失败时返回 null
+*/
+async function connectMcpServer(config, signal) {
+	const timeoutMs = config.connectTimeoutMs ?? 15e3;
+	const serverName = config.name;
+	try {
+		const client = new Client({
+			name: "zapmyco",
+			version: "0.3.0"
+		});
+		const transportOptions = {
+			command: config.command,
+			args: config.args ?? [],
+			stderr: "pipe"
+		};
+		if (config.env) transportOptions.env = config.env;
+		if (config.cwd) transportOptions.cwd = config.cwd;
+		const transport = new StdioClientTransport(transportOptions);
+		if (signal) {
+			if (signal.aborted) return null;
+			signal.addEventListener("abort", () => {
+				transport.close().catch(() => {});
+				client.close().catch(() => {});
+			}, { once: true });
+		}
+		await withTimeout(client.connect(transport), timeoutMs);
+		const { tools: rawTools } = await withTimeout(client.listTools(), timeoutMs);
+		const tools = rawTools ?? [];
+		log$2.debug(`MCP server "${serverName}" 已连接，发现 ${tools.length} 个工具`);
+		return {
+			client,
+			transport,
+			tools,
+			serverName
+		};
+	} catch (error) {
+		log$2.warn(`MCP server "${serverName}" 连接失败: ${error instanceof Error ? error.message : String(error)}`);
+		return null;
+	}
+}
+/**
+* 安全关闭单个 MCP Server 连接
+*/
+async function closeMcpServer(conn) {
+	try {
+		await conn.transport.close();
+	} catch {}
+	try {
+		await conn.client.close();
+	} catch {}
+	log$2.debug(`MCP server "${conn.serverName}" 已断开`);
+}
+/**
+* 简单的超时工具：promise 在 ms 毫秒内未完成则 reject
+*/
+function withTimeout(promise, ms) {
+	let timer;
+	const timeout = new Promise((_resolve, reject) => {
+		timer = setTimeout(() => reject(/* @__PURE__ */ new Error(`操作超时 (${ms}ms)`)), ms);
+	});
+	return Promise.race([promise, timeout]).finally(() => {
+		if (timer) clearTimeout(timer);
+	});
+}
+
+//#endregion
+//#region src/core/mcp/mcp-tool-adapter.ts
+/**
+* 将单个 MCP Tool 转换为 zapmyco ToolRegistration
+*
+* MCP SDK 的 TextContent / ImageContent 与 pi-ai 对应类型结构兼容
+* （都是 { type, text/data, mimeType }），因此直接透传 content。
+*/
+function mcpToolToRegistration(mcpTool, serverName, client) {
+	const parameters = {
+		type: "object",
+		properties: { ...mcpTool.inputSchema?.properties ?? {} },
+		required: [...mcpTool.inputSchema?.required ?? []]
+	};
+	return {
+		id: `mcp__${serverName}__${mcpTool.name}`,
+		label: `${serverName}:${mcpTool.name}`,
+		description: mcpTool.description ?? `MCP tool: ${mcpTool.name} (from ${serverName})`,
+		parameters,
+		execute: async (_toolCallId, params) => {
+			const result = await client.callTool({
+				name: mcpTool.name,
+				arguments: params
+			});
+			return {
+				content: result.content,
+				details: {
+					isError: result.isError ?? false,
+					serverName,
+					toolName: mcpTool.name
+				}
+			};
+		}
+	};
+}
+
+//#endregion
+//#region src/core/mcp/index.ts
+const log$1 = logger.child("mcp");
+/**
+* MCP 连接生命周期管理器
+*
+* 持有所有活跃的 MCP Server 连接及其转换后的 ToolRegistration。
+* 实例化 → initialize() → 使用 tools → shutdown()
+*/
+var McpManager = class {
+	connections = [];
+	toolRegistrations = [];
+	/**
+	* 并行连接所有启用的 MCP Server 并收集工具
+	*
+	* 单个 server 连接失败不影响其他 server（Promise.allSettled）。
+	*
+	* @param servers - MCP Server 配置列表
+	* @returns 所有成功连接的 server 的工具注册列表
+	*/
+	async initialize(servers) {
+		const enabledServers = servers.filter((s) => s.enabled !== false);
+		if (enabledServers.length === 0) return [];
+		log$1.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$1.info(`MCP: ${connectedCount}/${enabledServers.length} 个 Server 已连接，共 ${this.toolRegistrations.length} 个工具`);
+		return this.toolRegistrations;
+	}
+	/**
+	* 关闭所有 MCP 连接，释放资源
+	*/
+	async shutdown() {
+		if (this.connections.length === 0) return;
+		log$1.info(`正在关闭 ${this.connections.length} 个 MCP 连接...`);
+		await Promise.allSettled(this.connections.map((conn) => closeMcpServer(conn)));
+		this.connections = [];
+		this.toolRegistrations = [];
+	}
+	/** 获取当前已注册的 MCP 工具列表（只读） */
+	getTools() {
+		return this.toolRegistrations;
+	}
+	/** 连接单个 server 并将其工具转为 ToolRegistration */
+	async connectAndCollect(config) {
+		const conn = await connectMcpServer(config);
+		if (!conn) return null;
+		this.connections.push(conn);
+		for (const tool of conn.tools) this.toolRegistrations.push(mcpToolToRegistration(tool, conn.serverName, conn.client));
+		return conn;
+	}
+};
+/**
+* 便捷工厂函数：连接所有 MCP Server 并注册工具到 Agent
+*
+* @param servers - MCP Server 配置列表
+* @param agent - 目标 LlmBasedAgent 实例
+* @returns McpManager 实例（调用方负责在退出时 shutdown）
+*/
+async function initializeMcpTools(servers, agent) {
+	const manager = new McpManager();
+	const tools = await manager.initialize(servers);
+	if (tools.length > 0) agent.registerTools(tools);
+	return manager;
+}
+
+//#endregion
+//#region src/core/task/task-store.ts
+/**
+* TaskStore — Agent 任务项持久化存储
+*
+* 内存 Map + JSON 文件双写，支持跨会话恢复。
+* 参考 Hermes-Agent 的单工具 TodoStore 设计和 Claude Code 的文件持久化方案。
+*
+* @module core/task/task-store
+*/
+/** 获取当前工作目录的短哈希（用于区分不同项目的任务列表） */
+function getCwdHash() {
+	return createHash("sha256").update(process.cwd()).digest("hex").slice(0, 12);
+}
+/** 获取任务文件存储路径 */
+function getTaskFilePath() {
+	return join(join(homedir(), ".zapmyco", "tasks"), `${getCwdHash()}.json`);
+}
+/** 确保存储目录存在 */
+function ensureTaskDir() {
+	mkdirSync(dirname(getTaskFilePath()), { recursive: true });
+}
+var TaskStore = class {
+	tasks = /* @__PURE__ */ new Map();
+	/** 读取完整任务列表 */
+	read() {
+		return Array.from(this.tasks.values());
+	}
+	/** 获取摘要统计 */
+	summary() {
+		let pending = 0;
+		let inProgress = 0;
+		let completed = 0;
+		let cancelled = 0;
+		for (const task of this.tasks.values()) switch (task.status) {
+			case "pending":
+				pending++;
+				break;
+			case "in_progress":
+				inProgress++;
+				break;
+			case "completed":
+				completed++;
+				break;
+			case "cancelled":
+				cancelled++;
+				break;
+		}
+		return {
+			total: this.tasks.size,
+			pending,
+			in_progress: inProgress,
+			completed,
+			cancelled
+		};
+	}
+	/** 获取活跃任务（pending + in_progress），用于上下文压缩后注入 */
+	getActiveTasks() {
+		const result = [];
+		for (const task of this.tasks.values()) if (task.status === "pending" || task.status === "in_progress") result.push(task);
+		return result;
+	}
+	/** 检查是否有任务 */
+	hasItems() {
+		return this.tasks.size > 0;
+	}
+	/**
+	* 全量替换任务列表
+	*
+	* @param items - 新任务列表
+	* @param merge - true=按 ID 合并，false=全量替换
+	* @returns 校验错误信息（如果有）
+	*/
+	write(items, merge = false) {
+		const now = Date.now();
+		const newTasks = /* @__PURE__ */ new Map();
+		let inProgressCount = 0;
+		if (merge) for (const [id, existing] of this.tasks) {
+			newTasks.set(id, { ...existing });
+			if (existing.status === "in_progress") inProgressCount++;
+		}
+		for (const item of items) {
+			const existing = merge ? newTasks.get(item.id) : this.tasks.get(item.id) ?? newTasks.get(item.id);
+			if (existing && (existing.status === "completed" || existing.status === "cancelled")) {
+				if (merge) continue;
+				return `任务 "${item.id}" 已处于终态 (${existing.status})，不可修改`;
+			}
+			if (item.status === "in_progress") inProgressCount++;
+			const taskItem = {
+				id: item.id,
+				subject: item.subject,
+				status: item.status,
+				createdAt: existing?.createdAt ?? now,
+				updatedAt: now
+			};
+			if (item.description !== void 0) taskItem.description = item.description;
+			newTasks.set(item.id, taskItem);
+		}
+		if (inProgressCount > 1) return `不允许同时有 ${inProgressCount} 个进行中的任务，请先将当前任务完成或取消后再开始新任务`;
+		this.tasks = newTasks;
+		this.persist();
+		return null;
+	}
+	/**
+	* 增量更新单个任务
+	*
+	* @param id - 任务 ID
+	* @param updates - 要更新的字段
+	* @returns 校验错误信息（如果有）
+	*/
+	update(id, updates) {
+		const existing = this.tasks.get(id);
+		if (!existing) return `任务 "${id}" 不存在`;
+		if (existing.status === "completed" || existing.status === "cancelled") return `任务 "${id}" 已处于终态 (${existing.status})，不可修改`;
+		if (updates.status === "in_progress") {
+			for (const task of this.tasks.values()) if (task.id !== id && task.status === "in_progress") return `已有进行中的任务 "${task.id}: ${task.subject}"，请先将它完成或取消后再开始新任务`;
+		}
+		const updated = {
+			...existing,
+			...updates.subject !== void 0 ? { subject: updates.subject } : {},
+			...updates.description !== void 0 ? { description: updates.description } : {},
+			...updates.status !== void 0 ? { status: updates.status } : {},
+			updatedAt: Date.now()
+		};
+		this.tasks.set(id, updated);
+		this.persist();
+		return null;
+	}
+	/** 清空所有任务 */
+	clear() {
+		this.tasks.clear();
+		this.persist();
+	}
+	/** 持久化到文件系统 */
+	persist() {
+		try {
+			ensureTaskDir();
+			const data = JSON.stringify(this.read(), null, 2);
+			writeFileSync(getTaskFilePath(), data, "utf-8");
+		} catch {}
+	}
+	/** 从文件系统恢复 */
+	load() {
+		try {
+			const raw = readFileSync(getTaskFilePath(), "utf-8");
+			const data = JSON.parse(raw);
+			if (!Array.isArray(data)) return false;
+			const items = data;
+			this.tasks.clear();
+			for (const item of items) if (typeof item.id === "string" && typeof item.subject === "string" && typeof item.status === "string" && [
+				"pending",
+				"in_progress",
+				"completed",
+				"cancelled"
+			].includes(item.status)) {
+				const taskItem = {
+					id: item.id,
+					subject: item.subject,
+					status: item.status,
+					createdAt: typeof item.createdAt === "number" ? item.createdAt : Date.now(),
+					updatedAt: typeof item.updatedAt === "number" ? item.updatedAt : Date.now()
+				};
+				if (typeof item.description === "string") taskItem.description = item.description;
+				this.tasks.set(item.id, taskItem);
+			}
+			return true;
+		} catch {
+			return false;
+		}
+	}
+	/**
+	* 格式化活跃任务为 LLM 注入文本
+	*
+	* 参考 Hermes-Agent 的 format_for_injection 设计，
+	* 在上下文压缩后将活跃任务重新注入给模型。
+	*/
+	formatForInjection() {
+		const active = this.getActiveTasks();
+		if (active.length === 0) return null;
+		const lines = ["## 当前任务列表"];
+		for (const task of active) {
+			const marker = task.status === "in_progress" ? "▶" : "○";
+			lines.push(`  ${marker} [${task.id}] ${task.subject}`);
+		}
+		return lines.join("\n");
+	}
+};
+
 //#endregion
 //#region src/llm/pi-ai-provider.ts
 /**
@@ -2062,10 +6625,16 @@ var ReplSession = class {
 	currentTaskAbort = null;
 	/** Agent 实例（会话级复用，替代直接 LLM 调用） */
 	agent;
+	/** MCP 连接管理器（在 registerBuiltinTools 中异步初始化） */
+	mcpManager = null;
 	/** 当前正在执行的 taskId（用于取消操作） */
 	currentTaskId = null;
 	/** 多轮对话上下文（兼容保留，Agent 内部也维护历史） */
 	conversationHistory = [];
+	/** 定时任务调度器 */
+	cronScheduler = null;
+	/** 任务管理器（会话级持久化） */
+	taskStore;
 	stats = {
 		totalRequests: 0,
 		successCount: 0,
@@ -2098,6 +6667,18 @@ var ReplSession = class {
 		this.renderer = new Renderer(this.options);
 		this.history = new HistoryStore(this.options.maxHistorySize);
 		this.agent = this.createReplAgent();
+		this.taskStore = new TaskStore();
+		this.taskStore.load();
+		this.cronScheduler = new CronScheduler(getCronStore(), { isIdle: () => this._state === "idle" });
+		this.cronScheduler.start();
+		const memoryStore = getMemoryStore();
+		memoryStore.freezeSnapshot().then(() => {
+			this.agent.memorySnapshot = memoryStore.getSnapshot();
+		}).catch((err) => {
+			log.warn("记忆快照冻结失败，将使用空快照", { error: err instanceof Error ? err.message : String(err) });
+			this.agent.memorySnapshot = "";
+		});
+		if (this.config.skill?.enabled !== false) this.initSkills();
 		this.registerBuiltinCommands();
 		this.registerBuiltinTools();
 		this.setupEditorHandlers();
@@ -2125,6 +6706,14 @@ var ReplSession = class {
 		log.info("REPL 关闭", { reason: reason ?? "未知" });
 		this.cancelCurrentTask();
 		eventBus.emit("system:shutdown", { reason });
+		if (this.cronScheduler) {
+			this.cronScheduler.stop();
+			this.cronScheduler = null;
+		}
+		if (this.mcpManager) {
+			await this.mcpManager.shutdown();
+			this.mcpManager = null;
+		}
 		this.tui.stop();
 	}
 	/** 获取渲染器引用 */
@@ -2184,8 +6773,15 @@ var ReplSession = class {
 			const errorHandler = (event) => {
 				if (event.taskId === taskId) log.error("Agent 执行中收到 error 事件", { error: event.error.message });
 			};
+			const progressHandler = (event) => {
+				if (event.taskId === taskId && event.percent === 0) {
+					this.outputArea.append([`  → ${event.message}`]);
+					this.tui.requestRender();
+				}
+			};
 			this.agent.on(this.agent.EVENT_OUTPUT, outputHandler);
 			this.agent.on(this.agent.EVENT_ERROR, errorHandler);
+			this.agent.on(this.agent.EVENT_PROGRESS, progressHandler);
 			this.currentTaskId = taskId;
 			log.debug("开始通过 Agent 执行目标", {
 				taskId,
@@ -2202,6 +6798,7 @@ var ReplSession = class {
 			});
 			this.agent.off(this.agent.EVENT_OUTPUT, outputHandler);
 			this.agent.off(this.agent.EVENT_ERROR, errorHandler);
+			this.agent.off(this.agent.EVENT_PROGRESS, progressHandler);
 			log.debug("Agent 执行完成", {
 				taskId,
 				status: taskResult.status,
@@ -2379,9 +6976,73 @@ var ReplSession = class {
 	}
 	/**
 	* 注册 REPL 场景下的基础工具
+	*
+	* 在注册内置工具后，异步初始化 MCP 工具。
+	* MCP 连接不阻塞内置工具注册——Agent 立即可用内置工具，
+	* MCP 工具在连接完成后自动追加。
 	*/
 	registerBuiltinTools() {
-		this.agent.registerTools(createReplBuiltinTools(this.config.web));
+		this.agent.registerTools(createReplBuiltinTools(this.config.web, this.taskStore, this.config.skill, this.agent, this.config.subAgent, this.cronScheduler ?? void 0));
+		const mcpServers = this.config.mcp ? normalizeMcpConfig(this.config.mcp) : [];
+		if (mcpServers.length > 0) initializeMcpTools(mcpServers, this.agent).then((manager) => {
+			this.mcpManager = manager;
+		}).catch((err) => {
+			log.error("MCP 初始化失败", { error: err instanceof Error ? err.message : String(err) });
+		});
+	}
+	/**
+	* 初始化 Skill 系统
+	*
+	* 从 bundled/user/project/workspace 四个来源加载技能，
+	* 构建快照注入到 Agent 系统提示。
+	*/
+	initSkills() {
+		const skillConfig = this.config.skill;
+		if (!skillConfig?.enabled) return;
+		loadSkills({
+			enabled: true,
+			extraDirs: skillConfig.loadDirs,
+			maxSkillsInPrompt: skillConfig.maxSkillsInPrompt,
+			maxSkillFileBytes: skillConfig.maxSkillFileBytes
+		}, process.cwd()).then((entries) => {
+			setSkillEntries(entries);
+			this.agent.skillEntries = entries;
+			const snapshot = buildSkillSnapshot(entries, skillConfig.maxSkillsInPrompt);
+			this.agent.skillPrompt = snapshot.prompt;
+			this._registerSkillCommands(entries);
+			log.info("Skill 系统初始化完成", {
+				count: snapshot.count,
+				names: snapshot.names
+			});
+		}).catch((err) => {
+			log.error("Skill 加载失败", { error: err instanceof Error ? err.message : String(err) });
+		});
+	}
+	/**
+	* 为 user-invocable 技能注册斜杠命令
+	*
+	* 将每个用户可调用的技能注册为 /skill-name 格式的 CLI 命令。
+	* 命令执行时，将技能名称和用户参数作为 goal 发送给 Agent 处理。
+	*/
+	_registerSkillCommands(entries) {
+		const specs = getSkillCommandSpecs(entries);
+		for (const spec of specs) {
+			if (this.registry.getCommand(spec.name)) {
+				log.debug(`跳过 skill 命令 "${spec.name}"：与内置命令冲突`);
+				continue;
+			}
+			this.registry.register({
+				name: spec.name,
+				description: spec.description,
+				aliases: [],
+				usage: spec.name,
+				handler: async (args) => {
+					const argsStr = args.join(" ");
+					const goalInput = argsStr ? `请使用 /${spec.name} 技能，参数: ${argsStr}` : `请使用 /${spec.name} 技能`;
+					await this.executeGoal(goalInput);
+				}
+			});
+		}
 	}
 	/** 设置编辑器事件绑定 */
 	setupEditorHandlers() {