@ia-ccun/code-agent-cli 0.0.51-beta.1 → 0.0.51-beta.10

package/config/agent/extensions/aicode-plan.ts

@@ -0,0 +1,897 @@
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { Box, Spacer, Text, Editor, type EditorTheme, Key, matchesKey, truncateToWidth } from "@earendil-works/pi-tui";
+
+const STATUS_KEY = "aicode-plan";
+const TODO_WIDGET_KEY = "aicode-plan-todos";
+const CUSTOM_TYPE = "aicode-plan-event";
+
+type PlanNextAction = "approve" | "continue" | "regenerate" | "exit";
+
+interface PlanNextActionResult {
+	cancelled: boolean;
+	action?: PlanNextAction;
+	continueNote?: string;
+}
+
+interface TodoItem {
+	step: number;
+	text: string;
+	completed: boolean;
+}
+
+const PLAN_TOOL_CANDIDATES = [
+	"read",
+	"bash",
+	"grep",
+	"find",
+	"ls",
+	"lsp",
+	"ast_search",
+	"web_search",
+	"fetch_content",
+	"get_search_content",
+] as const;
+
+const WRITE_LIKE_TOOLS = new Set(["edit", "write", "ast_rewrite"]);
+
+const PLAN_MODE_SYSTEM_PROMPT = `
+[计划模式已激活 - 仅限只读]
+你当前处于计划模式。
+
+硬性规则：
+- 允许的操作：仅限检查、分析和创建计划
+- 绝不执行任何写入/变更操作
+- 绝不使用 edit/write 或变更性 shell 命令
+
+强制工作流程：
+1) 首先收集上下文
+   - 在提出计划前检查相关文件/路径/符号/配置/测试
+   - 如果涉及外部依赖行为，收集官方文档/参考证据
+   - 不允许无证据的规划
+2) 需求澄清
+   - 明确列出不确定性/假设
+   - 如果有阻塞性模糊点，在最终确定前提出简洁的澄清问题
+3) 计划设计
+   - 基于收集的证据构建具体的执行计划
+
+输出规范（使用此结构）：
+1) 目标理解（简洁）
+2) 收集的证据
+   - 检查过的文件/路径/符号/文档
+3) 不确定性 / 假设
+4) 计划：
+   1. 步骤目标
+   2. 目标文件/组件
+   3. 验证方法
+5) 风险和回滚说明
+6) 结尾："准备就绪，等待批准后执行。"
+`.trim();
+
+const YOLO_MODE_SYSTEM_PROMPT = `
+[默认模式：直接执行]
+- 直接执行任务，除非用户明确要求规划
+- 在正常模式下不要强制执行计划/批准流程
+- 只读计划/批准流程仅在 /plan 模式启用时激活
+`.trim();
+
+const EXECUTION_TRIGGER_PROMPT =
+	"计划已批准。现在切换到执行模式并实施最新计划。";
+
+// ============== 工具函数 ==============
+
+function isSafeReadOnlyCommand(command: string): boolean {
+	const DESTRUCTIVE_PATTERNS = [
+		/\brm\b/i,
+		/\brmdir\b/i,
+		/\bmv\b/i,
+		/\bcp\b/i,
+		/\bmkdir\b/i,
+		/\btouch\b/i,
+		/\bchmod\b/i,
+		/\bchown\b/i,
+		/\bchgrp\b/i,
+		/\bln\b/i,
+		/\btee\b/i,
+		/\btruncate\b/i,
+		/\bdd\b/i,
+		/\bshred\b/i,
+		/(^|[^<])>(?!>)/,
+		/>>/,
+		/\bnpm\s+(install|uninstall|update|ci|link|publish)\b/i,
+		/\byarn\s+(add|remove|install|publish)\b/i,
+		/\bpnpm\s+(add|remove|install|publish)\b/i,
+		/\bpip\s+(install|uninstall)\b/i,
+		/\bapt(-get)?\s+(install|remove|purge|update|upgrade)\b/i,
+		/\bbrew\s+(install|uninstall|upgrade)\b/i,
+		/\bgit\s+(add|commit|push|pull|merge|rebase|reset|checkout|branch\s+-[dD]|stash|cherry-pick|revert|tag|init|clone)\b/i,
+		/\bsudo\b/i,
+		/\bsu\b/i,
+		/\bkill\b/i,
+		/\bpkill\b/i,
+		/\bkillall\b/i,
+		/\breboot\b/i,
+		/\bshutdown\b/i,
+		/\bsystemctl\s+(start|stop|restart|enable|disable)\b/i,
+		/\bservice\s+\S+\s+(start|stop|restart)\b/i,
+		/\b(vim?|nano|emacs|code|subl)\b/i,
+	];
+
+	const SAFE_PATTERNS = [
+		/^\s*cat\b/,
+		/^\s*head\b/,
+		/^\s*tail\b/,
+		/^\s*less\b/,
+		/^\s*more\b/,
+		/^\s*grep\b/,
+		/^\s*find\b/,
+		/^\s*ls\b/,
+		/^\s*pwd\b/,
+		/^\s*echo\b/,
+		/^\s*printf\b/,
+		/^\s*wc\b/,
+		/^\s*sort\b/,
+		/^\s*uniq\b/,
+		/^\s*diff\b/,
+		/^\s*file\b/,
+		/^\s*stat\b/,
+		/^\s*du\b/,
+		/^\s*df\b/,
+		/^\s*tree\b/,
+		/^\s*which\b/,
+		/^\s*whereis\b/,
+		/^\s*type\b/,
+		/^\s*env\b/,
+		/^\s*printenv\b/,
+		/^\s*uname\b/,
+		/^\s*whoami\b/,
+		/^\s*id\b/,
+		/^\s*date\b/,
+		/^\s*cal\b/,
+		/^\s*uptime\b/,
+		/^\s*ps\b/,
+		/^\s*top\b/,
+		/^\s*htop\b/,
+		/^\s*free\b/,
+		/^\s*git\s+(status|log|diff|show|branch|remote|config\s+--get)\b/i,
+		/^\s*git\s+ls-/i,
+		/^\s*npm\s+(list|ls|view|info|search|outdated|audit)\b/i,
+		/^\s*yarn\s+(list|info|why|audit)\b/i,
+		/^\s*node\s+--version\b/i,
+		/^\s*python\s+--version\b/i,
+		/^\s*jq\b/,
+		/^\s*sed\s+-n\b/i,
+		/^\s*awk\b/,
+		/^\s*rg\b/,
+		/^\s*fd\b/,
+	];
+
+	const isDestructive = DESTRUCTIVE_PATTERNS.some((pattern) => pattern.test(command));
+	if (isDestructive) return false;
+	return SAFE_PATTERNS.some((pattern) => pattern.test(command));
+}
+
+function normalizeArg(input: string): string {
+	return input.trim().toLowerCase();
+}
+
+function cleanStepText(text: string): string {
+	let cleaned = text
+		.replace(/\*{1,2}([^*]+)\*{1,2}/g, "$1")
+		.replace(/`([^`]+)`/g, "$1")
+		.replace(
+			/^(Use|Run|Execute|Create|Write|Read|Check|Verify|Update|Modify|Add|Remove|Delete|Install|使用 | 运行 | 执行 | 创建 | 写入 | 读取 | 检查 | 验证 | 更新 | 修改 | 添加 | 删除 | 安装)\s+(the\s+)?/i,
+			"",
+		)
+		.replace(/\s+/g, " ")
+		.trim();
+
+	if (cleaned.length > 0) {
+		cleaned = cleaned.charAt(0).toUpperCase() + cleaned.slice(1);
+	}
+	if (cleaned.length > 80) {
+		cleaned = `${cleaned.slice(0, 77)}...`;
+	}
+	return cleaned;
+}
+
+function extractTodoItems(message: string): TodoItem[] {
+	const items: TodoItem[] = [];
+	const headerMatch = message.match(/\*{0,2}(?:Plan|计划):\*{0,2}\s*\n/i);
+	if (!headerMatch) return items;
+
+	const planSection = message.slice(
+		message.indexOf(headerMatch[0]) + headerMatch[0].length,
+	);
+	const numberedPattern = /^\s*(\d+)[.)]\s+\*{0,2}([^*\n]+)/gm;
+
+	for (const match of planSection.matchAll(numberedPattern)) {
+		const text = match[2]
+			.trim()
+			.replace(/\*{1,2}$/, "")
+			.trim();
+		if (
+			text.length > 5 &&
+			!text.startsWith("`") &&
+			!text.startsWith("/") &&
+			!text.startsWith("-")
+		) {
+			const cleaned = cleanStepText(text);
+			if (cleaned.length > 3) {
+				items.push({
+					step: items.length + 1,
+					text: cleaned,
+					completed: false,
+				});
+			}
+		}
+	}
+	return items;
+}
+
+function extractDoneSteps(message: string): number[] {
+	const steps: number[] = [];
+	for (const match of message.matchAll(/\[DONE:(\d+)\]/gi)) {
+		const step = Number(match[1]);
+		if (Number.isFinite(step)) {
+			steps.push(step);
+		}
+	}
+	return steps;
+}
+
+function markCompletedSteps(text: string, items: TodoItem[]): number {
+	const doneSteps = extractDoneSteps(text);
+	for (const step of doneSteps) {
+		const item = items.find((candidate) => candidate.step === step);
+		if (item) {
+			item.completed = true;
+		}
+	}
+	return doneSteps.length;
+}
+
+function getAssistantTextFromMessage(message: unknown): string {
+	const candidate = message as {
+		role?: unknown;
+		content?: unknown;
+	};
+
+	if (candidate.role !== "assistant") {
+		return "";
+	}
+
+	if (typeof candidate.content === "string") {
+		return candidate.content;
+	}
+
+	if (!Array.isArray(candidate.content)) {
+		return "";
+	}
+
+	return candidate.content
+		.filter(
+			(block): block is { type?: string; text?: string } =>
+				typeof block === "object" &&
+				block !== null &&
+				(block as { type?: string }).type === "text" &&
+				typeof (block as { text?: string }).text === "string",
+		)
+		.map((block) => block.text ?? "")
+		.join("\n");
+}
+
+// ============== UI 组件 ==============
+
+const ACTION_OPTIONS: ReadonlyArray<{ label: string; value: PlanNextAction }> = [
+	{ label: "批准并立即执行", value: "approve" },
+	{ label: "从当前计划继续", value: "continue" },
+	{ label: "重新生成计划", value: "regenerate" },
+	{ label: "退出计划模式", value: "exit" },
+];
+
+const CONTINUE_OPTION_INDEX = ACTION_OPTIONS.findIndex((option) => option.value === "continue");
+
+function normalizeContinueNote(input: string): string {
+	return input.replace(/\s+/g, " ").trim();
+}
+
+function buildContinueOptionLabel(
+	baseLabel: string,
+	note: string,
+	isEditing: boolean,
+	maxLength: number,
+): string {
+	const normalized = normalizeContinueNote(note);
+	if (normalized.length === 0 && !isEditing) {
+		return baseLabel;
+	}
+
+	const suffix = isEditing ? `${normalized}▍` : normalized;
+	const inline = `${baseLabel} — 备注：${suffix}`;
+	if (inline.length <= maxLength) {
+		return inline;
+	}
+
+	if (maxLength <= 1) {
+		return "…";
+	}
+	return `${inline.slice(0, maxLength - 1)}…`;
+}
+
+async function selectPlanNextActionWithInlineNote(
+	ui: ExtensionContext["ui"],
+): Promise<PlanNextActionResult> {
+	return ui.custom<PlanNextActionResult>((tui, theme, _keybindings, done) => {
+		let cursorIndex = 0;
+		let isContinueNoteEditorOpen = false;
+		let continueNote = "";
+		let cachedRenderedLines: string[] | undefined;
+
+		const editorTheme: EditorTheme = {
+			borderColor: (text) => theme.fg("accent", text),
+			selectList: {
+				selectedPrefix: (text) => theme.fg("accent", text),
+				selectedText: (text) => theme.fg("accent", text),
+				description: (text) => theme.fg("muted", text),
+				scrollInfo: (text) => theme.fg("dim", text),
+				noMatch: (text) => theme.fg("warning", text),
+			},
+		};
+		const noteEditor = new Editor(tui, editorTheme);
+
+		const requestUiRerender = () => {
+			cachedRenderedLines = undefined;
+			tui.requestRender();
+		};
+
+		const getNormalizedContinueNote = (): string => normalizeContinueNote(continueNote);
+
+		const openContinueEditor = () => {
+			if (cursorIndex !== CONTINUE_OPTION_INDEX) {
+				return;
+			}
+			isContinueNoteEditorOpen = true;
+			noteEditor.setText(continueNote);
+			requestUiRerender();
+		};
+
+		noteEditor.onChange = (value) => {
+			continueNote = value;
+			requestUiRerender();
+		};
+
+		noteEditor.onSubmit = (value) => {
+			continueNote = value;
+			const normalized = getNormalizedContinueNote();
+			if (normalized.length === 0) {
+				isContinueNoteEditorOpen = false;
+				requestUiRerender();
+				return;
+			}
+
+			done({
+				cancelled: false,
+				action: "continue",
+				continueNote: normalized,
+			});
+		};
+
+		const render = (width: number): string[] => {
+			if (cachedRenderedLines) {
+				return cachedRenderedLines;
+			}
+
+			const renderedLines: string[] = [];
+			const addLine = (line: string) => renderedLines.push(truncateToWidth(line, width));
+
+			addLine(theme.fg("accent", "─".repeat(width)));
+			addLine(theme.fg("text", " 计划模式：下一步操作"));
+			renderedLines.push("");
+
+			const maxInlineLabelLength = Math.max(20, width - 8);
+			for (let optionIndex = 0; optionIndex < ACTION_OPTIONS.length; optionIndex++) {
+				const option = ACTION_OPTIONS[optionIndex];
+				const isCursorOption = optionIndex === cursorIndex;
+				const isContinueOption = optionIndex === CONTINUE_OPTION_INDEX;
+				const optionLabel = isContinueOption
+					? buildContinueOptionLabel(
+							option.label,
+							continueNote,
+							isContinueNoteEditorOpen && isCursorOption,
+							maxInlineLabelLength,
+						)
+					: option.label;
+				const cursorPrefix = isCursorOption ? theme.fg("accent", "→ ") : "  ";
+				const bullet = isCursorOption ? "●" : "○";
+				const optionColor = isCursorOption ? "accent" : "text";
+				addLine(`${cursorPrefix}${theme.fg(optionColor, `${bullet} ${optionLabel}`)}`);
+			}
+
+			renderedLines.push("");
+			if (isContinueNoteEditorOpen) {
+				addLine(theme.fg("dim", " 正在输入备注 • Enter 继续 • Tab/Esc 停止编辑"));
+			} else if (cursorIndex === CONTINUE_OPTION_INDEX) {
+				if (getNormalizedContinueNote().length > 0) {
+					addLine(theme.fg("dim", " ↑↓ 移动 • Enter 继续 • Tab 编辑备注 • Esc 取消"));
+				} else {
+					addLine(theme.fg("dim", " ↑↓ 移动 • Enter 继续 • Tab 添加备注 • Esc 取消"));
+				}
+			} else {
+				addLine(theme.fg("dim", " ↑↓ 移动 • Enter 选择 • Esc 取消"));
+			}
+
+			addLine(theme.fg("accent", "─".repeat(width)));
+			cachedRenderedLines = renderedLines;
+			return renderedLines;
+		};
+
+		const handleInput = (data: string) => {
+			if (isContinueNoteEditorOpen) {
+				if (matchesKey(data, Key.tab) || matchesKey(data, Key.escape)) {
+					isContinueNoteEditorOpen = false;
+					requestUiRerender();
+					return;
+				}
+				noteEditor.handleInput(data);
+				requestUiRerender();
+				return;
+			}
+
+			if (matchesKey(data, Key.up)) {
+				cursorIndex = Math.max(0, cursorIndex - 1);
+				requestUiRerender();
+				return;
+			}
+
+			if (matchesKey(data, Key.down)) {
+				cursorIndex = Math.min(ACTION_OPTIONS.length - 1, cursorIndex + 1);
+				requestUiRerender();
+				return;
+			}
+
+			if (matchesKey(data, Key.tab)) {
+				if (cursorIndex === CONTINUE_OPTION_INDEX) {
+					openContinueEditor();
+				}
+				return;
+			}
+
+			if (matchesKey(data, Key.enter)) {
+				const selected = ACTION_OPTIONS[cursorIndex];
+				if (selected.value === "continue") {
+					const normalized = getNormalizedContinueNote();
+					done({
+						cancelled: false,
+						action: "continue",
+						continueNote: normalized.length > 0 ? normalized : undefined,
+					});
+					return;
+				}
+
+				done({ cancelled: false, action: selected.value });
+				return;
+			}
+
+			if (matchesKey(data, Key.escape)) {
+				done({ cancelled: true });
+			}
+		};
+
+		return {
+			render,
+			invalidate: () => {
+				cachedRenderedLines = undefined;
+			},
+			handleInput,
+		};
+	});
+}
+
+// ============== 扩展主函数 ==============
+
+export default function aicodePlan(pi: ExtensionAPI) {
+	let planModeEnabled = false;
+	let executionMode = false;
+	let restoreTools: string[] | null = null;
+	let todoItems: TodoItem[] = [];
+
+	const getAllToolNames = (): string[] => pi.getAllTools().map((tool) => tool.name);
+
+	const getPlanTools = (): string[] => {
+		const available = new Set(getAllToolNames());
+		const planTools = PLAN_TOOL_CANDIDATES.filter((tool) => available.has(tool));
+		if (planTools.length > 0) {
+			return [...planTools];
+		}
+
+		const fallback = pi.getActiveTools().filter((tool) => !WRITE_LIKE_TOOLS.has(tool));
+		return [...new Set(fallback)];
+	};
+
+	const restoreNormalTools = (): void => {
+		const toolsToRestore =
+			restoreTools && restoreTools.length > 0
+				? [...restoreTools]
+				: [...getAllToolNames()];
+		if (toolsToRestore.length > 0) {
+			pi.setActiveTools(toolsToRestore);
+		}
+		restoreTools = null;
+	};
+
+	const updateTodoWidget = (ctx: ExtensionContext): void => {
+		if (!ctx.hasUI) {
+			return;
+		}
+
+		if (!executionMode || todoItems.length === 0) {
+			ctx.ui.setWidget(TODO_WIDGET_KEY, undefined);
+			return;
+		}
+
+		const lines = todoItems.map((item) => {
+			if (item.completed) {
+				return (
+					ctx.ui.theme.fg("success", "✓ ") +
+					ctx.ui.theme.fg("muted", ctx.ui.theme.strikethrough(item.text))
+				);
+			}
+			return `${ctx.ui.theme.fg("muted", "○ ")}${item.text}`;
+		});
+
+		ctx.ui.setWidget(TODO_WIDGET_KEY, lines);
+	};
+
+	const setStatus = (ctx: ExtensionContext): void => {
+		if (!ctx.hasUI) {
+			return;
+		}
+
+		if (executionMode && todoItems.length > 0) {
+			const completed = todoItems.filter((item) => item.completed).length;
+			ctx.ui.setStatus(
+				STATUS_KEY,
+				ctx.ui.theme.fg("accent", `📋 ${completed}/${todoItems.length}`),
+			);
+			updateTodoWidget(ctx);
+			return;
+		}
+
+		const statusText = planModeEnabled
+			? ctx.ui.theme.fg("warning", "⏸ 计划") + ctx.ui.theme.fg("dim", " | plan (Ctrl+Alt+P)")
+			: undefined;
+		ctx.ui.setStatus(STATUS_KEY, statusText);
+		updateTodoWidget(ctx);
+	};
+
+	const enterPlanMode = (ctx: ExtensionContext): void => {
+		if (planModeEnabled) {
+			ctx.ui.notify("计划模式已启用。", "info");
+			return;
+		}
+
+		const currentTools = pi.getActiveTools();
+		restoreTools = currentTools.length > 0 ? [...currentTools] : null;
+
+		const planTools = getPlanTools();
+		if (planTools.length === 0) {
+			ctx.ui.notify("无法解析只读工具集。", "error");
+			return;
+		}
+
+		todoItems = [];
+		executionMode = false;
+		pi.setActiveTools(planTools);
+		planModeEnabled = true;
+		pi.events.emit("aicode-plan:mode-changed", { enabled: true });
+		setStatus(ctx);
+		ctx.ui.notify(`计划模式已启用（只读）: ${planTools.join(", ")}`, "info");
+	};
+
+	const exitPlanMode = (
+		ctx: ExtensionContext,
+		reason?: string,
+		options: { resetProgress?: boolean } = {},
+	): void => {
+		if (!planModeEnabled) {
+			if (reason) {
+				ctx.ui.notify(reason);
+			}
+			if (options.resetProgress) {
+				executionMode = false;
+				todoItems = [];
+				setStatus(ctx);
+			}
+			return;
+		}
+
+		planModeEnabled = false;
+		pi.events.emit("aicode-plan:mode-changed", { enabled: false });
+		restoreNormalTools();
+		if (options.resetProgress) {
+			executionMode = false;
+			todoItems = [];
+		}
+		setStatus(ctx);
+		if (reason) {
+			ctx.ui.notify(reason);
+		}
+	};
+
+	// 注册命令
+	pi.registerCommand("plan", {
+		description: "启用只读计划模式。用法：/plan, /plan on, /plan off, /plan status, /plan <任务>",
+		handler: async (args, ctx) => {
+			const raw = args.trim();
+
+			if (raw.length === 0) {
+				if (planModeEnabled) {
+					exitPlanMode(ctx, "计划模式已禁用。返回直接执行模式。", {
+						resetProgress: true,
+					});
+				} else {
+					enterPlanMode(ctx);
+				}
+				return;
+			}
+
+			const command = normalizeArg(raw);
+			if (["on", "enable", "start", "启用", "开启"].includes(command)) {
+				enterPlanMode(ctx);
+				return;
+			}
+
+			if (["off", "disable", "stop", "exit", "禁用", "关闭"].includes(command)) {
+				exitPlanMode(ctx, "计划模式已禁用。返回直接执行模式。", {
+					resetProgress: true,
+				});
+				return;
+			}
+
+			if (["status", "state", "状态"].includes(command)) {
+				const statusLines = [
+					planModeEnabled
+						? "计划模式：开启（只读规划）"
+						: executionMode
+							? "计划模式：关闭（正在执行已批准的计划）"
+							: "计划模式：关闭（默认直接执行模式）",
+				];
+				if (!planModeEnabled && !executionMode) {
+					statusLines.push("");
+					statusLines.push("快捷键：Alt+Shift+P 快速切换计划模式");
+				}
+				ctx.ui.notify(statusLines.join("\n"), "info");
+				return;
+			}
+
+			if (!planModeEnabled) {
+				enterPlanMode(ctx);
+			}
+
+			pi.sendUserMessage(raw);
+		},
+	});
+
+	pi.registerCommand("todos", {
+		description: "显示当前计划执行进度",
+		handler: async (_args, ctx) => {
+			if (todoItems.length === 0) {
+				ctx.ui.notify("没有跟踪的计划步骤。先在 /plan 模式中创建计划。", "info");
+				return;
+			}
+
+			const completed = todoItems.filter((item) => item.completed).length;
+			const progress = `${completed}/${todoItems.length}`;
+			const list = todoItems
+				.map((item) => `${item.step}. ${item.completed ? "✓" : "○"} ${item.text}`)
+				.join("\n");
+			ctx.ui.notify(`计划进度 ${progress}\n${list}`, "info");
+		},
+	});
+
+	// 注册快捷键
+	pi.registerShortcut("ctrl+alt+p", {
+		description: "切换计划模式",
+		handler: async (ctx) => {
+			const wasEnabled = planModeEnabled;  // 保存当前状态
+			if (planModeEnabled) {
+				exitPlanMode(ctx, "计划模式已禁用。返回直接执行模式。", {
+					resetProgress: true,
+				});
+			} else {
+				enterPlanMode(ctx);
+			}
+			// 显示切换后的状态
+			ctx.ui.notify(wasEnabled ? "计划模式已禁用 ✓" : "计划模式已启用 ✓");
+		},
+	});
+
+	// 注册消息渲染器
+	pi.registerMessageRenderer(CUSTOM_TYPE, (message, { expanded }, theme) => {
+		const details = message.details as { kind?: string; message?: string } | undefined;
+		const kind = details?.kind ?? "status";
+		const msg = details?.message ?? "";
+		const box = new Box(1, 1, (value) => theme.bg("customMessageBg", value));
+		box.addChild(new Text(theme.fg("customMessageLabel", theme.bold("📋 计划")), 0, 0));
+		box.addChild(new Spacer(1));
+		if (!expanded) {
+			box.addChild(new Text(`${theme.fg("customMessageText", msg)} ${theme.fg("dim", "(ctrl+o 展开)")}`, 0, 0));
+			return box;
+		}
+		const lines = [
+			`${theme.fg("dim", "状态：")}${theme.fg("customMessageText", kind)}`,
+		];
+		if (msg) {
+			lines.push(`${theme.fg("dim", "消息：")}${theme.fg("customMessageText", msg)}`);
+		}
+		box.addChild(new Text(lines.join("\n"), 0, 0));
+		return box;
+	});
+
+	// 工具调用拦截
+	pi.on("tool_call", async (event) => {
+		if (!planModeEnabled) {
+			return;
+		}
+
+		if (WRITE_LIKE_TOOLS.has(event.toolName)) {
+			return {
+				block: true,
+				reason: "计划模式是只读的。请先批准执行（选择'批准并立即执行'）。",
+			};
+		}
+
+		if (event.toolName === "bash") {
+			const input = event.input as { command?: unknown };
+			const command = typeof input.command === "string" ? input.command : "";
+			if (!isSafeReadOnlyCommand(command)) {
+				return {
+					block: true,
+					reason: `计划模式拦截了潜在的变更命令：${command}`,
+				};
+			}
+		}
+	});
+
+	// agent 启动前注入系统提示词
+	pi.on("before_agent_start", async (event) => {
+		if (planModeEnabled) {
+			return {
+				systemPrompt: `${event.systemPrompt}\n\n${PLAN_MODE_SYSTEM_PROMPT}`,
+			};
+		}
+
+		if (executionMode && todoItems.length > 0) {
+			const remaining = todoItems
+				.filter((item) => !item.completed)
+				.map((item) => `${item.step}. ${item.text}`)
+				.join("\n");
+			const executionPrompt = remaining
+				? `[已批准计划执行]\n按顺序完成剩余步骤：\n${remaining}\n\n每完成一步后添加 [DONE:n] 标记。`
+				: "[已批准计划执行]\n完成实现并验证结果。";
+
+			return {
+				systemPrompt: `${event.systemPrompt}\n\n${YOLO_MODE_SYSTEM_PROMPT}\n\n${executionPrompt}`,
+			};
+		}
+
+		return {
+			systemPrompt: `${event.systemPrompt}\n\n${YOLO_MODE_SYSTEM_PROMPT}`,
+		};
+	});
+
+	// turn 结束时标记完成的步骤
+	pi.on("turn_end", async (event, ctx) => {
+		if (!executionMode || todoItems.length === 0) {
+			return;
+		}
+
+		const text = getAssistantTextFromMessage(event.message);
+		if (!text) {
+			return;
+		}
+
+		const completedCount = markCompletedSteps(text, todoItems);
+		if (completedCount > 0) {
+			setStatus(ctx);
+		}
+
+		if (todoItems.every((item) => item.completed)) {
+			executionMode = false;
+			setStatus(ctx);
+			ctx.ui.notify("所有跟踪的计划步骤已完成。", "info");
+		}
+	});
+
+	// agent 结束时显示操作菜单
+	pi.on("agent_end", async (event, ctx) => {
+		if (!planModeEnabled || !ctx.hasUI) {
+			return;
+		}
+
+		const lastAssistantText = [...event.messages]
+			.reverse()
+			.map(getAssistantTextFromMessage)
+			.find((text) => text.length > 0);
+
+		if (lastAssistantText) {
+			const extracted = extractTodoItems(lastAssistantText);
+			if (extracted.length > 0) {
+				todoItems = extracted;
+			}
+		}
+		setStatus(ctx);
+
+		const selection = await selectPlanNextActionWithInlineNote(ctx.ui);
+		if (selection.cancelled || !selection.action) {
+			return;
+		}
+
+		if (selection.action === "approve") {
+			executionMode = todoItems.length > 0;
+			exitPlanMode(ctx, "计划已批准。进入直接执行模式进行实施。");
+
+			const firstOpenStep = todoItems.find((item) => !item.completed);
+			if (firstOpenStep) {
+				pi.sendUserMessage(
+					`${EXECUTION_TRIGGER_PROMPT} 从步骤 ${firstOpenStep.step} 开始：${firstOpenStep.text}`,
+				);
+			} else {
+				pi.sendUserMessage(EXECUTION_TRIGGER_PROMPT);
+			}
+			return;
+		}
+
+		if (selection.action === "regenerate") {
+			todoItems = [];
+			setStatus(ctx);
+			pi.sendUserMessage(
+				"从头重新生成计划。重新检查上下文并提供刷新后的 Plan: 部分。",
+			);
+			return;
+		}
+
+		if (selection.action === "continue") {
+			const continueNote = selection.continueNote?.trim() ?? "";
+			if (continueNote.length === 0) {
+				ctx.ui.notify(
+					"请输入请求的修改内容，然后发送消息继续规划。等待你的输入。",
+					"info",
+				);
+				return;
+			}
+
+			const firstOpenStep = todoItems.find((item) => !item.completed);
+			if (firstOpenStep) {
+				pi.sendUserMessage(
+					`从提议的计划继续。用户备注：${continueNote}。聚焦步骤 ${firstOpenStep.step}: ${firstOpenStep.text}。优化文件、验证和风险分析。`,
+				);
+			} else {
+				pi.sendUserMessage(
+					`从提议的计划继续。用户备注：${continueNote}。无需重新生成完整计划，优化实现细节。`,
+				);
+			}
+			return;
+		}
+
+		if (selection.action === "exit") {
+			exitPlanMode(ctx, "未执行就退出了计划模式。", {
+				resetProgress: true,
+			});
+		}
+	});
+
+	// session 启动时恢复状态
+	pi.on("session_start", async (_event, ctx) => {
+		setStatus(ctx);
+	});
+
+	// session 关闭时清理
+	pi.on("session_shutdown", async (_event, ctx) => {
+		executionMode = false;
+		if (ctx.hasUI) {
+			ctx.ui.setStatus(STATUS_KEY, undefined);
+			ctx.ui.setWidget(TODO_WIDGET_KEY, undefined);
+		}
+	});
+}