@armadra/agent 0.3.0 → 0.5.0

package/dist/modes/interactive/pickers.js

@@ -4,14 +4,17 @@
  * - 模型：按供应商分组并标 key 状态（`modelItems`，与启动期共用），当前模型预选；
  * - 会话：名字或首条提示、相对时间、消息数（`sessionItems`）；
  * - 树：会话文件里全部用户消息，按分叉缩进，`●` 标出当前分支；选中项回填编辑器（由 commands.ts 处理）；
- * - 权限模式（从严到宽）与思考级别。
+ * - 权限模式（标题「权限模式」，界面顺序 1–6，当前模式 ✓ / Default dim / Recommended accent，底部按键提示，
+ *   上下留白，见 permissionItems）与思考级别；
+ * - 所有选择器底部一行按键提示（dim），模型选择器带 (i/n) 并给当前模型打 ✓。
  */
 import { THINKING_LEVELS } from "../../ai/thinking.js";
-import { PERMISSION_MODES_STRICT_FIRST } from "../../permissions/types.js";
+import { PERMISSION_MODE_INFO, PERMISSION_MODE_ORDER, RECOMMENDED_PERMISSION_MODE, } from "../../permissions/modes.js";
 import { Box, SelectList, } from "../../tui.js";
 import { contentText } from "./message-view.js";
 import { relativeTime } from "./startup-ui.js";
 export { modelItems, sessionItems } from "./startup-ui.js";
+export const PICKER_FOOTER = "↑↓ 选择 · Enter 确认 · Esc 取消";
 /** 打开一个居中选择器；Enter 返回选中项，Esc / Ctrl+C 返回 undefined。 */
 export function openPicker(host, spec) {
     return new Promise((resolve) => {
@@ -26,30 +29,60 @@ export function openPicker(host, spec) {
             filterable: spec.filterable ?? spec.items.length > 8,
             ...(host.keybindings !== undefined ? { keybindings: host.keybindings } : {}),
             ...(spec.emptyText !== undefined ? { emptyText: spec.emptyText } : {}),
+            ...(spec.numberKeys === true ? { numberKeys: true } : {}),
+            ...(spec.stacked === true ? { stacked: true } : {}),
+            ...(spec.currentValue !== undefined ? { currentValue: spec.currentValue } : {}),
+            ...(spec.showCount === true ? { showCount: true } : {}),
+            footer: spec.footer ?? PICKER_FOOTER,
             onSelect: (item) => close(item),
             onCancel: () => close(undefined),
         });
         if (spec.selected !== undefined)
             list.selectValue(spec.selected);
         const width = Math.max(20, Math.min(host.columns() - 2, 72));
-        handle = host.showOverlay(new Box(list, { title: spec.title, theme: host.theme }), {
+        const box = new Box(list, {
+            title: spec.title,
+            theme: host.theme,
+            ...(spec.paddingY !== undefined ? { paddingY: spec.paddingY } : {}),
+        });
+        handle = host.showOverlay(box, {
             anchor: "center",
             width,
         });
     });
 }
-const PERMISSION_TEXT = {
-    plan: "只读，不改文件不跑命令",
-    default: "写入与命令逐次确认",
-    "auto-edit": "文件编辑自动放行，命令确认",
-    "full-auto": "全部放行（危险命令仍确认）",
-};
-export function permissionItems() {
-    return PERMISSION_MODES_STRICT_FIRST.map((mode) => ({
-        value: mode,
-        label: mode,
-        description: PERMISSION_TEXT[mode],
-    }));
+/**
+ * 模式选择器（标题「权限模式」）：界面顺序、当前模式打勾（`currentValue`）、配置里的缺省模式标
+ * `Default`、Auto 标 `Recommended`，右侧数字快捷键 1–6，说明在下一行。
+ */
+export function permissionItems(_current, configDefault = "default") {
+    return PERMISSION_MODE_ORDER.map((mode) => {
+        const info = PERMISSION_MODE_INFO[mode];
+        const item = { value: mode, label: info.label, description: info.description };
+        const badges = [
+            ...(mode === configDefault ? ["Default"] : []),
+            ...(mode === RECOMMENDED_PERMISSION_MODE ? ["Recommended"] : []),
+        ];
+        if (badges.length > 0) {
+            item.badge = badges.join(" · ");
+            if (mode !== RECOMMENDED_PERMISSION_MODE)
+                item.badgeColor = "dim";
+        }
+        return item;
+    });
+}
+export function permissionPickerSpec(current, configDefault = "default") {
+    return {
+        title: "权限模式",
+        items: permissionItems(current, configDefault),
+        selected: current,
+        currentValue: current,
+        filterable: false,
+        numberKeys: true,
+        stacked: true,
+        footer: "↑↓ 选择 · 1-6 直接选 · Enter 确认 · Esc 取消",
+        paddingY: 1,
+    };
 }
 export function thinkingItems(reasoning) {
     return THINKING_LEVELS.map((level) => {

package/dist/modes/interactive/plan-command.d.ts

@@ -0,0 +1,40 @@
+/**
+ * `/plan` 的语义（line 模式与交互模式共用，经 commands-core）。[W5-U]
+ *
+ * - `/plan`：当前计划与状态（版本、状态、文件、步骤、待办进度、所处模式）；
+ * - `/plan approve [模式|fresh]`：批准待审批的计划（没有计划块时把上一条回复当作计划，docs/wave5-plan.md
+ *   §6.3）；模式缺省回到进入 plan 前的模式，`fresh` 在新会话里执行（新建会话 → `adopt(plan)` → 发计划
+ *   全文）；
+ * - `/plan reject`：放弃待审批的计划（留在 Plan 模式）；
+ * - `/plan <目标>`：进入 Plan 模式并把目标作为提示发出。
+ */
+import type { AgentSession, PlanData } from "../../agent/types.js";
+import type { SwitchRequest } from "../../cli/compose-session.js";
+import type { PermissionMode } from "../../permissions/types.js";
+import { type PlanController } from "../../plan/controller.js";
+export declare const PLAN_USAGE = "\u7528\u6CD5\uFF1A/plan [\u76EE\u6807] | /plan approve [\u6A21\u5F0F|fresh] | /plan reject";
+export declare function planStatusText(status: PlanData["status"]): string;
+/** 计划的标题：第一个 `#` 标题，没有时取第一行非空文本。 */
+export declare function planTitle(plan: Pick<PlanData, "markdown">): string;
+/** 批准后的执行模式（缺省回到进入 plan 前的模式；进入前就是 plan 则 default）。 */
+export declare function defaultExecutionMode(controller: PlanController): PermissionMode;
+/** `/plan` 的纯文本说明。 */
+export declare function describePlan(controller: PlanController, session: AgentSession): string;
+export interface PlanCommandContext {
+    switchSession(request: SwitchRequest): Promise<AgentSession>;
+}
+export type PlanCommandResult = {
+    kind: "handled";
+    message: string;
+    wait?: boolean;
+} | {
+    kind: "prompt";
+    text: string;
+};
+/** 「新上下文执行」：新建会话、记下计划与 todo、切到执行模式，返回首条消息。 */
+export declare function approveFresh(controller: PlanController, plan: PlanData, mode: PermissionMode, ctx: PlanCommandContext, editedMarkdown?: string): Promise<{
+    session: AgentSession;
+    prompt: string;
+    plan: PlanData;
+}>;
+export declare function planCommand(session: AgentSession, args: string, ctx: PlanCommandContext): Promise<PlanCommandResult>;

package/dist/modes/interactive/plan-command.js

@@ -0,0 +1,129 @@
+/**
+ * `/plan` 的语义（line 模式与交互模式共用，经 commands-core）。[W5-U]
+ *
+ * - `/plan`：当前计划与状态（版本、状态、文件、步骤、待办进度、所处模式）；
+ * - `/plan approve [模式|fresh]`：批准待审批的计划（没有计划块时把上一条回复当作计划，docs/wave5-plan.md
+ *   §6.3）；模式缺省回到进入 plan 前的模式，`fresh` 在新会话里执行（新建会话 → `adopt(plan)` → 发计划
+ *   全文）；
+ * - `/plan reject`：放弃待审批的计划（留在 Plan 模式）；
+ * - `/plan <目标>`：进入 Plan 模式并把目标作为提示发出。
+ */
+import { AmaError } from "../../errors.js";
+import { parsePermissionMode, permissionModeLabel } from "../../permissions/modes.js";
+import { planController } from "../../plan/controller.js";
+import { executionMode } from "../../plan/store.js";
+export const PLAN_USAGE = "用法：/plan [目标] | /plan approve [模式|fresh] | /plan reject";
+const STATUS_TEXT = {
+    proposed: "待审批",
+    approved: "已批准",
+    rejected: "已放弃",
+    superseded: "已被新版本取代",
+};
+export function planStatusText(status) {
+    return STATUS_TEXT[status];
+}
+/** 计划的标题：第一个 `#` 标题，没有时取第一行非空文本。 */
+export function planTitle(plan) {
+    const lines = plan.markdown.split(/\r?\n/).map((l) => l.trim());
+    const heading = lines.find((l) => /^#{1,6}\s+\S/.test(l));
+    if (heading !== undefined)
+        return heading.replace(/^#{1,6}\s+/, "");
+    return lines.find((l) => l !== "" && !/^<\/?proposed_plan>$/.test(l)) ?? "（无标题）";
+}
+/** 批准后的执行模式（缺省回到进入 plan 前的模式；进入前就是 plan 则 default）。 */
+export function defaultExecutionMode(controller) {
+    return executionMode(undefined, controller.prePlanMode());
+}
+/** `/plan` 的纯文本说明。 */
+export function describePlan(controller, session) {
+    const plan = controller.current();
+    const mode = session.state.permissionMode;
+    const pre = controller.prePlanMode();
+    const modeLine = mode === "plan"
+        ? `模式：Plan（批准后回到 ${permissionModeLabel(executionMode(undefined, pre))}）`
+        : `模式：${permissionModeLabel(mode)}`;
+    if (plan === null) {
+        return mode === "plan"
+            ? [modeLine, "还没有计划：模型给出 <proposed_plan> 后在这里审批"].join("\n")
+            : "没有计划。/plan <目标> 进入 Plan 模式";
+    }
+    const lines = [
+        `计划 v${plan.version} · ${planStatusText(plan.status)} · ${planTitle(plan)}`,
+        ...(plan.filePath !== undefined ? [`文件：${plan.filePath}`] : []),
+        modeLine,
+    ];
+    if (plan.steps.length > 0) {
+        lines.push(`步骤（${plan.steps.length}）：`);
+        for (const step of plan.steps)
+            lines.push(`  ${step.id} ${step.text}`);
+    }
+    const todos = controller.todos();
+    if (todos.length > 0) {
+        const done = todos.filter((t) => t.status === "done").length;
+        const current = todos.find((t) => t.status === "in_progress");
+        lines.push(`待办：${done}/${todos.length} 完成${current !== undefined ? ` · 进行中 ${current.text}` : ""}`);
+    }
+    if (plan.status === "proposed")
+        lines.push("/plan approve [模式|fresh] 批准 · /plan reject 放弃 · 直接输入修改意见");
+    return lines.join("\n");
+}
+/** 「新上下文执行」：新建会话、记下计划与 todo、切到执行模式，返回首条消息。 */
+export async function approveFresh(controller, plan, mode, ctx, editedMarkdown) {
+    const result = await controller.respond({
+        planId: plan.id,
+        decision: "approve_fresh",
+        mode,
+        ...(editedMarkdown !== undefined ? { editedMarkdown } : {}),
+    });
+    const next = await ctx.switchSession({ kind: "new" });
+    planController(next)?.adopt(result.plan);
+    next.setPermissionMode(result.mode ?? mode);
+    return { session: next, prompt: result.freshPrompt ?? result.plan.markdown, plan: result.plan };
+}
+function pendingOrLastReply(controller) {
+    const plan = controller.pending() ?? controller.proposeFromLastReply();
+    if (plan === undefined)
+        throw new AmaError("plan_not_found", "没有待审批的计划");
+    return plan;
+}
+export async function planCommand(session, args, ctx) {
+    const controller = planController(session);
+    const [verb = "", ...rest] = args.split(/\s+/).filter((s) => s !== "");
+    if (controller === undefined) {
+        if (args === "")
+            return { kind: "handled", message: "当前会话没有 Plan 能力" };
+        throw new AmaError("invalid_arguments", "当前会话没有 Plan 能力");
+    }
+    if (verb === "")
+        return { kind: "handled", message: describePlan(controller, session) };
+    if (verb === "approve") {
+        if (rest.length > 1)
+            throw new AmaError("invalid_arguments", PLAN_USAGE);
+        const plan = pendingOrLastReply(controller);
+        const arg = rest[0];
+        if (arg === "fresh") {
+            const fresh = await approveFresh(controller, plan, defaultExecutionMode(controller), ctx);
+            return { kind: "prompt", text: fresh.prompt };
+        }
+        const mode = arg === undefined ? defaultExecutionMode(controller) : parsePermissionMode(arg);
+        if (mode === undefined || mode === "plan")
+            throw new AmaError("invalid_arguments", `执行模式无效：${arg ?? ""}（${PLAN_USAGE}）`);
+        const result = await controller.respond({ planId: plan.id, decision: "approve", mode });
+        return {
+            kind: "handled",
+            message: `已批准计划 v${result.plan.version}，以 ${permissionModeLabel(result.mode ?? mode)} 执行`,
+            wait: true,
+        };
+    }
+    if (verb === "reject" && rest.length === 0) {
+        const plan = controller.pending();
+        if (plan === undefined)
+            throw new AmaError("plan_not_found", "没有待审批的计划");
+        await controller.respond({ planId: plan.id, decision: "reject" });
+        return { kind: "handled", message: `已放弃计划 v${plan.version}（仍在 Plan 模式）` };
+    }
+    // 其余：目标文本
+    if (session.state.permissionMode !== "plan")
+        session.setPermissionMode("plan");
+    return { kind: "prompt", text: args };
+}

package/dist/modes/interactive/plan-dialog.d.ts

@@ -0,0 +1,98 @@
+/**
+ * 计划审批对话框（docs/wave5-plan.md §6.1、§6.3）：底部覆盖层，与权限审批框同一手法。[W5-U]
+ *
+ * ```
+ * ╭─ 计划待审批 ──────────────────────────────────────────────╮
+ * │ 计划 v1 · 3 步 · ~/.local/share/ama/plans/3f2a9c1e-v1.md  │
+ * │ 给 status-bar 加回退模型显示                              │
+ * │   S1 读 status-bar.ts 与 status-area.ts                   │
+ * │   …                                                       │
+ * │                                                           │
+ * │ › 1. 批准并执行                                           │
+ * │   2. 批准，在新上下文执行                                 │
+ * │   3. 继续修改…                                            │
+ * │   4. 放弃，退出 Plan 模式                                 │
+ * │                                                           │
+ * │ ↑↓ 选择 · Enter 确认 · e 编辑计划 · Esc 留在 Plan         │
+ * ╰───────────────────────────────────────────────────────────╯
+ * ```
+ *
+ * - 1 / 2 之后选执行模式：回到进入前的模式（缺省）/ Accept edits / Auto；Esc 回到上一步。
+ * - 3「继续修改」：行内写意见（Enter 发送，`Ctrl+E` 改用外部编辑器写），意见作为普通用户消息、留在 plan；
+ *   Esc 回到上一步。
+ * - `e`：在外部编辑器（`$VISUAL` / `$EDITOR`，TUI 挂起）里改计划全文；批准时以改后的版本（version + 1）
+ *   交接。
+ * - 4「放弃」：计划标 rejected 并退出 Plan 模式（回到进入前的模式）；Esc：计划标 rejected、留在 Plan 模式
+ *   （§6.1）。
+ * - 宽 < 56 时紧凑：去掉空行、按键提示缩短。ASCII 字形走 theme.glyphs。
+ */
+import type { PlanData } from "../../agent/types.js";
+import type { PermissionMode } from "../../permissions/types.js";
+import { type Component, type Focusable, type Keybindings, type OverlayHandle, type Theme } from "../../tui.js";
+/** 对话框里最多列出的步骤数。 */
+export declare const PLAN_DIALOG_STEPS = 6;
+export type PlanChoice = {
+    decision: "approve" | "approve_fresh";
+    mode: PermissionMode;
+    editedMarkdown?: string;
+} | {
+    decision: "revise";
+    feedback: string;
+}
+/** `exit`：放弃并退出 Plan 模式（选项 4）；Esc 为 false。 */
+ | {
+    decision: "reject";
+    exit: boolean;
+};
+export interface PlanDialogHost {
+    theme: Theme;
+    keybindings?: Keybindings;
+    showOverlay(component: Component): OverlayHandle;
+    /** 外部编辑器：返回改后的文本，取消或失败返回 undefined。 */
+    editExternal?(text: string, kind: "plan" | "feedback"): Promise<string | undefined>;
+    /** 计划文件路径的显示（缩写家目录）。 */
+    displayPath?(path: string): string;
+    /** 重画（外部编辑器回来之后）。 */
+    render?(): void;
+    onOpen?(): void;
+    onClose?(): void;
+}
+export interface PlanDialogInput {
+    plan: PlanData;
+    /** 「回到进入前的模式」对应的执行模式。 */
+    preMode: PermissionMode;
+}
+export declare class PlanDialog implements Component, Focusable {
+    private readonly input;
+    private readonly host;
+    private readonly done;
+    focused: boolean;
+    private stage;
+    private selected;
+    private modeSelected;
+    /** 选执行模式时记下的是 1 还是 2。 */
+    private fresh;
+    private feedback;
+    private edited;
+    constructor(input: PlanDialogInput, host: PlanDialogHost, done: (choice: PlanChoice) => void);
+    private modes;
+    handleInput(data: string): void;
+    private keys;
+    private cancelKey;
+    private mainInput;
+    private choose;
+    private modeInput;
+    private approve;
+    private reviseInput;
+    private editPlan;
+    private editFeedback;
+    render(width: number): string[];
+    /** 版本、步数、文件、标题与前几步。 */
+    private summary;
+    private optionLines;
+    private reviseLines;
+    private hint;
+    invalidate(): void;
+}
+/** 打开对话框，等用户选择。 */
+export declare function openPlanDialog(host: PlanDialogHost, input: PlanDialogInput): Promise<PlanChoice>;

package/dist/modes/interactive/plan-dialog.js

@@ -0,0 +1,290 @@
+/**
+ * 计划审批对话框（docs/wave5-plan.md §6.1、§6.3）：底部覆盖层，与权限审批框同一手法。[W5-U]
+ *
+ * ```
+ * ╭─ 计划待审批 ──────────────────────────────────────────────╮
+ * │ 计划 v1 · 3 步 · ~/.local/share/ama/plans/3f2a9c1e-v1.md  │
+ * │ 给 status-bar 加回退模型显示                              │
+ * │   S1 读 status-bar.ts 与 status-area.ts                   │
+ * │   …                                                       │
+ * │                                                           │
+ * │ › 1. 批准并执行                                           │
+ * │   2. 批准，在新上下文执行                                 │
+ * │   3. 继续修改…                                            │
+ * │   4. 放弃，退出 Plan 模式                                 │
+ * │                                                           │
+ * │ ↑↓ 选择 · Enter 确认 · e 编辑计划 · Esc 留在 Plan         │
+ * ╰───────────────────────────────────────────────────────────╯
+ * ```
+ *
+ * - 1 / 2 之后选执行模式：回到进入前的模式（缺省）/ Accept edits / Auto；Esc 回到上一步。
+ * - 3「继续修改」：行内写意见（Enter 发送，`Ctrl+E` 改用外部编辑器写），意见作为普通用户消息、留在 plan；
+ *   Esc 回到上一步。
+ * - `e`：在外部编辑器（`$VISUAL` / `$EDITOR`，TUI 挂起）里改计划全文；批准时以改后的版本（version + 1）
+ *   交接。
+ * - 4「放弃」：计划标 rejected 并退出 Plan 模式（回到进入前的模式）；Esc：计划标 rejected、留在 Plan 模式
+ *   （§6.1）。
+ * - 宽 < 56 时紧凑：去掉空行、按键提示缩短。ASCII 字形走 theme.glyphs。
+ */
+import { permissionModeLabel } from "../../permissions/modes.js";
+import { Box, defaultKeybindings, isPasteData, isPrintableText, matchesKey, padToWidth, truncateToWidth, unwrapPaste, wrapTextWithAnsi, } from "../../tui.js";
+import { planTitle } from "./plan-command.js";
+/** 对话框里最多列出的步骤数。 */
+export const PLAN_DIALOG_STEPS = 6;
+const COMPACT_WIDTH = 56;
+function mainOptions(ellipsis) {
+    return ["批准并执行", "批准，在新上下文执行", `继续修改${ellipsis}`, "放弃，退出 Plan 模式"];
+}
+const MAIN_COUNT = 4;
+export class PlanDialog {
+    input;
+    host;
+    done;
+    focused = false;
+    stage = "main";
+    selected = 0;
+    modeSelected = 0;
+    /** 选执行模式时记下的是 1 还是 2。 */
+    fresh = false;
+    feedback = "";
+    edited;
+    constructor(input, host, done) {
+        this.input = input;
+        this.host = host;
+        this.done = done;
+    }
+    modes() {
+        const pre = this.input.preMode;
+        return [
+            { mode: pre, label: `回到进入前的模式（${permissionModeLabel(pre)}）` },
+            { mode: "auto-edit", label: permissionModeLabel("auto-edit") },
+            { mode: "auto", label: permissionModeLabel("auto") },
+        ];
+    }
+    handleInput(data) {
+        switch (this.stage) {
+            case "main":
+                return this.mainInput(data);
+            case "mode":
+                return this.modeInput(data);
+            case "revise":
+                return this.reviseInput(data);
+            case "editing":
+                return;
+        }
+    }
+    keys() {
+        return this.host.keybindings ?? defaultKeybindings;
+    }
+    cancelKey(data) {
+        const keys = this.keys();
+        return (matchesKey(data, "escape") ||
+            keys.matches(data, "app.clear") ||
+            keys.matches(data, "tui.select.cancel"));
+    }
+    mainInput(data) {
+        const keys = this.keys();
+        if (this.cancelKey(data))
+            return this.done({ decision: "reject", exit: false });
+        if (/^[1-4]$/.test(data))
+            return this.choose(Number(data) - 1);
+        if (keys.matches(data, "tui.select.up"))
+            this.selected = (this.selected + MAIN_COUNT - 1) % MAIN_COUNT;
+        else if (keys.matches(data, "tui.select.down"))
+            this.selected = (this.selected + 1) % MAIN_COUNT;
+        else if (matchesKey(data, "enter"))
+            this.choose(this.selected);
+        else if (data === "e" || data === "E")
+            void this.editPlan();
+    }
+    choose(index) {
+        this.selected = index;
+        if (index === 0 || index === 1) {
+            this.fresh = index === 1;
+            this.modeSelected = 0;
+            this.stage = "mode";
+        }
+        else if (index === 2) {
+            this.stage = "revise";
+        }
+        else
+            this.done({ decision: "reject", exit: true });
+    }
+    modeInput(data) {
+        const keys = this.keys();
+        const modes = this.modes();
+        if (this.cancelKey(data)) {
+            this.stage = "main";
+            return;
+        }
+        if (/^[1-3]$/.test(data))
+            return this.approve(modes[Number(data) - 1].mode);
+        if (keys.matches(data, "tui.select.up"))
+            this.modeSelected = (this.modeSelected + modes.length - 1) % modes.length;
+        else if (keys.matches(data, "tui.select.down"))
+            this.modeSelected = (this.modeSelected + 1) % modes.length;
+        else if (matchesKey(data, "enter"))
+            this.approve(modes[this.modeSelected].mode);
+    }
+    approve(mode) {
+        this.done({
+            decision: this.fresh ? "approve_fresh" : "approve",
+            mode,
+            ...(this.edited !== undefined ? { editedMarkdown: this.edited } : {}),
+        });
+    }
+    reviseInput(data) {
+        if (this.cancelKey(data)) {
+            this.stage = "main";
+            return;
+        }
+        if (matchesKey(data, "enter")) {
+            if (this.feedback.trim() !== "")
+                this.done({ decision: "revise", feedback: this.feedback });
+            return;
+        }
+        if (matchesKey(data, "ctrl+e"))
+            return void this.editFeedback();
+        if (matchesKey(data, "backspace")) {
+            this.feedback = [...this.feedback].slice(0, -1).join("");
+            return;
+        }
+        if (isPasteData(data)) {
+            this.feedback += unwrapPaste(data).replace(/\r\n?/g, "\n");
+            return;
+        }
+        if (isPrintableText(data))
+            this.feedback += data;
+    }
+    async editPlan() {
+        if (this.host.editExternal === undefined)
+            return;
+        this.stage = "editing";
+        const before = this.edited ?? this.input.plan.markdown;
+        const after = await this.host.editExternal(before, "plan").catch(() => undefined);
+        if (after !== undefined && after.trim() !== "" && after !== this.input.plan.markdown)
+            this.edited = after;
+        this.stage = "main";
+        this.host.render?.();
+    }
+    async editFeedback() {
+        if (this.host.editExternal === undefined)
+            return;
+        this.stage = "editing";
+        const after = await this.host.editExternal(this.feedback, "feedback").catch(() => undefined);
+        this.stage = "revise";
+        if (after !== undefined && after.trim() !== "") {
+            this.done({ decision: "revise", feedback: after.trim() });
+            return;
+        }
+        this.host.render?.();
+    }
+    render(width) {
+        const compact = width + 4 < COMPACT_WIDTH;
+        const lines = [];
+        const push = (line) => void lines.push(...wrapTextWithAnsi(line, width));
+        const blank = () => {
+            if (!compact)
+                lines.push("");
+        };
+        // 摘要（版本、标题、步骤）窄屏截断不折行：续行顶格会和步骤编号对不齐
+        lines.push(...this.summary());
+        blank();
+        switch (this.stage) {
+            case "main":
+                lines.push(...this.optionLines(mainOptions(this.host.theme.glyphs.ellipsis), this.selected, width));
+                break;
+            case "mode":
+                push(this.host.theme.bold(this.fresh ? "在新上下文执行，执行模式" : "执行模式"));
+                lines.push(...this.optionLines(this.modes().map((m) => m.label), this.modeSelected, width));
+                break;
+            case "revise":
+                lines.push(...this.reviseLines(width, compact));
+                break;
+            case "editing":
+                push(this.host.theme.fg("dim", `正在外部编辑器里编辑${this.host.theme.glyphs.ellipsis}`));
+                break;
+        }
+        blank();
+        lines.push(this.host.theme.fg("dim", this.hint(compact)));
+        return lines.map((line) => truncateToWidth(line, width));
+    }
+    /** 版本、步数、文件、标题与前几步。 */
+    summary() {
+        const { theme } = this.host;
+        const plan = this.input.plan;
+        const sep = theme.fg("dim", " · ");
+        const head = [`计划 v${plan.version}`, `${plan.steps.length} 步`];
+        if (plan.filePath !== undefined)
+            head.push(this.host.displayPath?.(plan.filePath) ?? plan.filePath);
+        const out = [theme.fg("muted", head.join(sep))];
+        out.push(theme.bold(planTitle({ markdown: this.edited ?? plan.markdown })));
+        if (this.edited !== undefined) {
+            out.push(theme.fg("warning", "已在编辑器里修改：批准时以修改后的计划执行"));
+            return out;
+        }
+        for (const step of plan.steps.slice(0, PLAN_DIALOG_STEPS))
+            out.push(`  ${theme.fg("dim", step.id)} ${step.text}`);
+        const hidden = plan.steps.length - PLAN_DIALOG_STEPS;
+        if (hidden > 0)
+            out.push(theme.fg("dim", `  ${theme.glyphs.ellipsis} 另 ${hidden} 步（/plan 查看全部）`));
+        return out;
+    }
+    optionLines(labels, selected, width) {
+        const { theme } = this.host;
+        const g = theme.glyphs;
+        return labels.map((label, i) => {
+            const on = i === selected;
+            const text = `${on ? g.prompt : " "} ${i + 1}. ${label}`;
+            const line = padToWidth(truncateToWidth(on ? theme.fg("accent", theme.bold(text)) : text, width), width);
+            return on ? theme.bg("selection", line) : line;
+        });
+    }
+    reviseLines(width, compact) {
+        const { theme } = this.host;
+        const g = theme.glyphs;
+        const out = [theme.bold(compact ? "修改意见" : "修改意见（留在 Plan 模式，模型据此重写计划）")];
+        const cursor = "\x1b[7m \x1b[27m";
+        const text = this.feedback.replace(/\n/g, " ⏎ ");
+        const body = `${theme.fg("user", g.prompt)} ${text}${cursor}`;
+        out.push(...wrapTextWithAnsi(body, width));
+        return out;
+    }
+    hint(compact) {
+        const g = this.host.theme.glyphs;
+        const arrows = g.arrowUp + g.arrowDown;
+        const edit = this.host.editExternal !== undefined;
+        switch (this.stage) {
+            case "main":
+                return compact
+                    ? `${arrows} Enter${edit ? " · e 编辑" : ""} · Esc 留在 Plan`
+                    : `${arrows} 选择 · Enter 确认${edit ? " · e 编辑计划" : ""} · Esc 留在 Plan`;
+            case "mode":
+                return compact ? `${arrows} Enter · Esc 返回` : `${arrows} 选择 · Enter 确认 · Esc 返回`;
+            case "revise":
+                return compact
+                    ? `Enter 发送${edit ? " · Ctrl+E 编辑器" : ""} · Esc 返回`
+                    : `Enter 发送${edit ? " · Ctrl+E 外部编辑器" : ""} · Esc 返回`;
+            case "editing":
+                return "保存并关闭编辑器后回到这里";
+        }
+    }
+    invalidate() { }
+}
+/** 打开对话框，等用户选择。 */
+export function openPlanDialog(host, input) {
+    return new Promise((resolve) => {
+        let handle;
+        let settled = false;
+        const dialog = new PlanDialog(input, host, (choice) => {
+            if (settled)
+                return;
+            settled = true;
+            handle?.hide();
+            host.onClose?.();
+            resolve(choice);
+        });
+        host.onOpen?.();
+        handle = host.showOverlay(new Box(dialog, { title: "计划待审批", theme: host.theme }));
+    });
+}