@armadra/agent 0.4.0 → 0.5.1

package/dist/modes/interactive/key-dispatch.js

@@ -3,15 +3,46 @@
  *
  * 编辑器之前的输入监听：Ctrl+C 清空输入 / 再按退出、Esc 中断（clearQueue 回填编辑器后 abort）、
  * Ctrl+D 空输入退出、Alt+Enter followUp、Alt+↑ 取回最后一条排队消息、Shift+Tab 循环权限模式、
- * Ctrl+O 展开工具输出与思考块、Ctrl+L 模型、Ctrl+T 思考级别。键位由 `keybindings.json` 覆盖。
+ * Ctrl+O 展开工具输出与思考块、Ctrl+L 模型、Ctrl+T 思考级别、Ctrl+G 底部信息行 full ↔ compact（W5-A）、
+ * Ctrl+V 粘贴剪贴板图片（`app.paste.image`，W5-U）。
+ * 键位由 `keybindings.json` 覆盖。
+ *
+ * [RW-C] 空闲时双击 Esc（`app.rewind`，double-esc.ts）：输入框为空打开回滚列表，有字则清空并存进
+ * 输入历史；运行中 Esc 仍为中断，中断后交给 `onInterrupted`（中断即撤回）。
  */
 import { ExitCode } from "../../cli/exit-codes.js";
 import { nextCycleMode, permissionModeLabel } from "../../permissions/modes.js";
+import { DOUBLE_ESC_HINT_MS, DoubleEscape } from "./double-esc.js";
+import { statusLineText } from "./status-area.js";
 const DOUBLE_CTRL_C_MS = 1500;
 /** 返回输入监听器：已处理返回 true，交给编辑器返回 false。 */
 export function createKeyDispatch(deps) {
     const { keys, editor, tools, status } = deps;
     let ctrlCArmedAt = Number.NEGATIVE_INFINITY;
+    const esc = new DoubleEscape(deps.doubleEscMs);
+    const doubleEscape = () => {
+        switch (esc.press(deps.now(), editor.isEmpty())) {
+            case "arm-rewind":
+                deps.showHint("再按 Esc 回滚", DOUBLE_ESC_HINT_MS);
+                return;
+            case "arm-clear":
+                deps.showHint("再按 Esc 清空", DOUBLE_ESC_HINT_MS);
+                return;
+            case "rewind":
+                deps.showHint("");
+                deps.runCommand("/rewind");
+                return;
+            case "clear": {
+                // 记进输入历史再清空：↑ 可取回
+                const text = editor.getExpandedText();
+                if (text.trim() !== "")
+                    editor.addToHistory(text);
+                editor.clear();
+                deps.showHint("已清空输入 · ↑ 取回");
+                return;
+            }
+        }
+    };
     const interrupt = () => {
         const session = deps.session();
         const queued = session.clearQueue();
@@ -37,17 +68,28 @@ export function createKeyDispatch(deps) {
         const current = editor.getText();
         editor.setText(current.trim() === "" ? last : `${last}\n${current}`);
     };
-    const cyclePermission = () => {
-        const session = deps.session();
-        const next = nextCycleMode(session.state.permissionMode);
-        session.setPermissionMode(next);
+    const applyMode = (mode, skipped) => {
+        deps.session().setPermissionMode(mode);
         status.refresh();
-        deps.showHint(`权限模式：${permissionModeLabel(next)}`);
+        const label = `权限模式：${permissionModeLabel(mode)}`;
+        deps.showHint(skipped ? `未进入 Bypass · ${label}` : label);
+    };
+    const cyclePermission = () => {
+        const next = nextCycleMode(deps.session().state.permissionMode);
+        // 取消进入 Bypass：跳过它继续循环（回到起点 Manual），而不是停在原模式——否则不进 Bypass 就绕不回去
+        const settle = (ok) => ok ? applyMode(next, false) : applyMode(nextCycleMode(next), true);
+        const answer = deps.confirmMode?.(next) ?? true;
+        if (typeof answer === "boolean")
+            settle(answer);
+        else
+            void answer.then(settle);
     };
     return (data) => {
         if (deps.inactive())
             return false;
         const is = (action) => keys.matches(data, action);
+        if (!is("app.rewind"))
+            esc.reset();
         if (is("app.clear")) {
             if (!editor.isEmpty()) {
                 editor.clear();
@@ -65,8 +107,14 @@ export function createKeyDispatch(deps) {
         }
         ctrlCArmedAt = Number.NEGATIVE_INFINITY;
         if (is("app.interrupt") && !editor.isCompletionOpen && deps.busy()) {
+            esc.reset();
             interrupt();
             deps.showHint("已中断");
+            deps.onInterrupted?.(editor.isEmpty());
+            return true;
+        }
+        if (is("app.rewind") && !editor.isCompletionOpen && !deps.busy()) {
+            doubleEscape();
             return true;
         }
         if (is("app.exit") && editor.isEmpty()) {
@@ -83,7 +131,9 @@ export function createKeyDispatch(deps) {
             dequeue();
             return true;
         }
-        if (is("app.permission.cycle")) {
+        // 与补全共用的键（缺省 Tab）只在输入为空、补全未打开时切换模式；有输入时照常交给编辑器补全
+        if (is("app.permission.cycle") &&
+            (!is("tui.editor.complete") || (editor.isEmpty() && !editor.isCompletionOpen))) {
             cyclePermission();
             return true;
         }
@@ -101,6 +151,15 @@ export function createKeyDispatch(deps) {
             deps.runCommand("/thinking");
             return true;
         }
+        if (is("app.paste.image") && deps.onPasteImage !== undefined) {
+            deps.onPasteImage();
+            return true;
+        }
+        if (is("app.statusLine.toggle") && deps.onStatusLineToggle !== undefined) {
+            const mode = deps.onStatusLineToggle();
+            deps.showHint(statusLineText(mode));
+            return true;
+        }
         return false;
     };
 }

package/dist/modes/interactive/line/line-mode.d.ts

@@ -6,7 +6,10 @@
  *   问句之前逐行打印执行前预览（`request.preview`，W3-B9a-2）。
  * - 否则（管道）：逐行读 stdin，每行依次执行（等上一条运行结束）；没有审批 UI，ask → deny。
  *   模型错误在运行结束时只打印一次（重试中只显示 ↻）；有运行最终失败时退出码 1。
- * - 斜杠命令走 commands-core（与 B7 同一语义），`pick` 退化为列出候选。
+ * - raw 终端里 `/permission full-auto` 进入 Bypass 前文本确认（`确认进入 Bypass？[y/N]`，本次运行确认过
+ *   一次后不再问；启动时已是 Bypass 视为已确认）。
+ * - 斜杠命令走 commands-core（与 B7 同一语义），`pick` 退化为列出候选；`/rewind` 列编号、
+ *   `/rewind <n> …` 执行，回到的单行原消息放回编辑行。
  */
 import type { ModeContext } from "../../../cli/deps.js";
 import type { Runtime } from "../../../cli/runtime.js";

package/dist/modes/interactive/line/line-mode.js

@@ -6,11 +6,16 @@
  *   问句之前逐行打印执行前预览（`request.preview`，W3-B9a-2）。
  * - 否则（管道）：逐行读 stdin，每行依次执行（等上一条运行结束）；没有审批 UI，ask → deny。
  *   模型错误在运行结束时只打印一次（重试中只显示 ↻）；有运行最终失败时退出码 1。
- * - 斜杠命令走 commands-core（与 B7 同一语义），`pick` 退化为列出候选。
+ * - raw 终端里 `/permission full-auto` 进入 Bypass 前文本确认（`确认进入 Bypass？[y/N]`，本次运行确认过
+ *   一次后不再问；启动时已是 Bypass 视为已确认）。
+ * - 斜杠命令走 commands-core（与 B7 同一语义），`pick` 退化为列出候选；`/rewind` 列编号、
+ *   `/rewind <n> …` 执行，回到的单行原消息放回编辑行。
  */
 import { promptImages, sessionModel } from "../../image-input.js";
+import { taskRegistryView } from "../../../agent/subagent-registry.js";
 import { currentSession, switchSession } from "../../../cli/compose-session.js";
 import { ExitCode } from "../../../cli/exit-codes.js";
+import { BYPASS_LINE_QUESTION, BYPASS_MODE, BYPASS_RISK_LINES, createBypassGate, } from "../../../permissions/bypass.js";
 import { previewDisplayLines } from "../../../permissions/preview.js";
 import { AMA_VERSION } from "../../../version.js";
 import { runSlashCommand } from "../../commands-core.js";
@@ -64,8 +69,21 @@ export async function runLineMode(runtime, context, options = {}) {
                 await prompt(session, result.text);
             else if (result.kind === "pick")
                 out(`${await pickHint(result.what, runtime, session)}\n`);
-            else if (result.message !== undefined)
-                out(`${result.message}\n`);
+            else {
+                if (result.message !== undefined)
+                    out(`${result.message}\n`);
+                // /rewind 回到某条消息之前：单行原消息放回编辑行（多行只在输出里给出）
+                const draft = result.draft?.text;
+                if (editor !== undefined && draft !== undefined && !draft.includes("\n")) {
+                    editor.buffer = draft;
+                    editor.cursor = draft.length;
+                }
+                // /plan approve 开了新回合：跑完再收下一行（与直接发提示一致）
+                if (result.wait === true) {
+                    await session.waitForIdle();
+                    printer.endLine();
+                }
+            }
         }
         catch (error) {
             printer.endLine();
@@ -75,7 +93,8 @@ export async function runLineMode(runtime, context, options = {}) {
         return undefined;
     };
     const prompt = async (target, text) => {
-        const images = await promptImages(text, [], target.state.cwd, sessionModel(runtime.providers, target));
+        const resize = runtime.config.images?.resize;
+        const images = await promptImages(text, [], target.state.cwd, sessionModel(runtime.providers, target), resize !== undefined ? { resize } : {});
         await target.prompt(text, images.length > 0 ? { images } : {});
         printer.endLine();
     };
@@ -89,13 +108,20 @@ export async function runLineMode(runtime, context, options = {}) {
         const model = session.state.model;
         io.stdout(`ama ${AMA_VERSION} · ${model?.provider}/${model?.id} · /help 查看命令，Ctrl+D 退出\n`);
     }
+    // /permission full-auto：进入 Bypass 前文本确认一次（管道里没有这一步，命令本身就是显式选择）
+    commands.confirmPermissionMode = createBypassGate(() => {
+        ed.hide();
+        io.stdout(`\n${BYPASS_RISK_LINES.map((l) => `  ${l}\n`).join("")}`);
+        return ed.ask(BYPASS_LINE_QUESTION, "n").then((answer) => answer === "y");
+    }, session.state.permissionMode === BYPASS_MODE);
     runtime.approvals.setUiBroker({
         ask: (request, signal) => new Promise((resolve) => {
             if (signal.aborted)
                 return resolve(undefined);
             signal.addEventListener("abort", () => resolve(undefined), { once: true });
             const preview = previewDisplayLines(request.preview).map((l) => `  ${l}\n`);
-            void ed.ask(`\n${preview.join("")}${approvalQuestion(request)}`, "n").then((answer) => {
+            const question = approvalQuestion(request, (taskId) => taskRegistryView(session.state.sessionId)?.get(taskId)?.agent);
+            void ed.ask(`\n${preview.join("")}${question}`, "n").then((answer) => {
                 resolve(answer === "y" ? "allow" : answer === "a" ? "allow_session" : "deny");
                 if (!busy)
                     ed.render();

package/dist/modes/interactive/line/line-render.d.ts

@@ -6,9 +6,10 @@ import type { AgentSession, SessionEvent } from "../../../agent/types.js";
 import type { Runtime } from "../../../cli/runtime.js";
 import type { ApprovalRequest } from "../../../permissions/types.js";
 import type { CommandResult } from "../../commands-core.js";
+import { type TaskAgentLookup } from "../approval-dialog.js";
 /** 工具参数的一行摘要（第一个常见字段，折叠换行、截到 80 字符）。 */
 export declare function argsSummary(args: unknown): string;
-export declare function approvalQuestion(request: ApprovalRequest): string;
+export declare function approvalQuestion(request: ApprovalRequest, taskAgent?: TaskAgentLookup): string;
 /** [W3-C2] 缓存提示的开关（line 模式由 runLineMode 传入）。 */
 export interface EventPrinterOptions {
     /** `cache.missNotices`（每次现取，切换会话后跟随新会话）；缺省 true。 */

package/dist/modes/interactive/line/line-render.js

@@ -6,6 +6,9 @@ import { THINKING_LEVELS } from "../../../ai/thinking.js";
 import { listSessions } from "../../../cli/compose-store.js";
 import { AUTO_LAYER_TEXT, permissionModeLines } from "../../../permissions/modes.js";
 import { cacheEventNotice, warmSentNotice } from "../../session-report.js";
+import { isFirstRunRequest, sourceLabel } from "../approval-dialog.js";
+import { LIMIT_WARNING, backgroundJobText, limitReachedText, modelFallbackText, } from "../event-notices.js";
+import { taskStatusText } from "../tasks-report.js";
 const SUMMARY_KEYS = ["command", "path", "pattern", "file_path", "url", "description", "name"];
 /** 工具参数的一行摘要（第一个常见字段，折叠换行、截到 80 字符）。 */
 export function argsSummary(args) {
@@ -21,8 +24,18 @@ export function argsSummary(args) {
     }
     return "";
 }
-export function approvalQuestion(request) {
-    const task = (request.context?.depth ?? 0) > 0 ? "[task] " : "";
+export function approvalQuestion(request, taskAgent) {
+    const label = sourceLabel(request, taskAgent);
+    const task = label === undefined ? "" : `${label} `;
+    const origin = request.context?.origin;
+    if (origin !== undefined) {
+        const where = origin.toolCall.locations?.[0];
+        return `${task}允许 ${origin.toolCall.title}${where !== undefined ? ` ${where}` : ""}？[y 允许 / a 本会话都允许 / N 拒绝] `;
+    }
+    if (isFirstRunRequest(request)) {
+        const input = request.input;
+        return `${task}${String(input["note"])} 允许？[y 允许 / N 拒绝] `;
+    }
     const summary = argsSummary(request.input);
     const auto = request.autoDecision;
     const why = request.reason === "dangerous"
@@ -131,11 +144,34 @@ export class EventPrinter {
                     this.failures++;
                     this.line(`ama: 错误：${error}`, true);
                 }
-                // 失败时 warning 就是同一条错误文本，不再重复打印
-                if (event.warning !== undefined && event.warning !== error)
+                // 失败时 warning 就是同一条错误文本，不再重复打印；预算到限已由 limit_reached 说明
+                if (event.warning !== undefined &&
+                    event.warning !== error &&
+                    event.warning !== LIMIT_WARNING)
                     this.line(`ama: ${event.warning}`, true);
                 return;
             }
+            // [W5-U] 第五波事件
+            case "plan_proposed": {
+                const file = event.filePath !== undefined ? `（${event.filePath}）` : "";
+                this.line(`◇ 计划 v${event.version} 待审批${file}：/plan approve [模式|fresh] 批准 · /plan reject 放弃 · 直接输入修改意见`);
+                return;
+            }
+            case "subagent_start":
+                this.line(`  ↳ ${event.taskId} ${event.agent}${event.background ? "（后台）" : ""} 开始`);
+                return;
+            case "subagent_end":
+                this.line(`  ↳ ${event.taskId} ${taskStatusText(event.status)}`);
+                return;
+            case "limit_reached":
+                this.line(`ama: ${limitReachedText(event)}`, true);
+                return;
+            case "model_fallback":
+                this.line(`ama: ${modelFallbackText(event)}`, true);
+                return;
+            case "background_job":
+                this.line(`ama: ${backgroundJobText(event)}`, true);
+                return;
             default:
                 return;
         }

package/dist/modes/interactive/message-view.d.ts

@@ -47,7 +47,7 @@ export declare class PrefixedText implements Component {
     render(width: number): string[];
     invalidate(): void;
 }
-/** 粗估 token（4 字符 ≈ 1 token），只用于思考块的流式计数。 */
+export declare function displayText(text: string): string;
 export declare function estimateTokens(text: string): number;
 export declare function contentText(content: string | readonly ContentBlock[]): string;
 /** 一条助手消息：按内容块（思考 / 文本）同步子组件；工具调用块由 tool-view 单独显示。 */

package/dist/modes/interactive/message-view.js

@@ -16,6 +16,8 @@
  */
 import { Card, Container, Markdown, Spacer, Text, visibleWidth, wrapTextWithAnsi, } from "../../tui.js";
 import { formatCost, formatTokens } from "./status-bar.js";
+import { notificationSummary } from "./subagent-view.js";
+import { PLAN_APPROVED_PROMPT } from "../../plan/prompts.js";
 /** 退出摘要的时长：不足 1 分钟按秒，否则按分钟。 */
 function sessionDuration(ms) {
     const seconds = Math.max(0, Math.round(ms / 1000));
@@ -60,7 +62,11 @@ export const ORIGIN_LABELS = {
     steer: "插话",
     followUp: "之后",
     host: "宿主",
+    task: "子 Agent 通知",
+    plan: "计划",
 };
+/** [W5-U] origin 为 plan 的交接消息（给模型的英文开场）在消息区的说法。 */
+const PLAN_HANDOFF_TEXT = "按批准的计划开始执行";
 /** 首行带前缀、续行按 `indent` 缩进的文本（用户消息、排队消息）。 */
 export class PrefixedText {
     prefix;
@@ -155,6 +161,11 @@ class ThinkingView {
     }
 }
 /** 粗估 token（4 字符 ≈ 1 token），只用于思考块的流式计数。 */
+/** [W5-U] 计划块的开闭标签（独占一行）只给模型与提取用，消息区不显示（计划正文照常渲染）。 */
+const PLAN_TAG_LINE = /^[ \t]*<\/?proposed_plan>[ \t]*$/gm;
+export function displayText(text) {
+    return text.includes("proposed_plan>") ? text.replace(PLAN_TAG_LINE, "") : text;
+}
 export function estimateTokens(text) {
     return Math.ceil(text.length / 4);
 }
@@ -214,8 +225,9 @@ export class AssistantView extends Container {
             if (block.text.trim() === "")
                 return;
             const view = this.part(index, () => this.options.markdown === false ? new Text("") : new Markdown("", { theme }));
-            if (view.getText() !== block.text)
-                view.setText(block.text);
+            const text = displayText(block.text);
+            if (view.getText() !== text)
+                view.setText(text);
             order.push(view);
         });
         const gap = this.options.compact !== true;
@@ -339,6 +351,16 @@ export class MessageView extends Container {
             return;
         }
         const label = ORIGIN_LABELS[origin] ?? origin;
+        // [W5-U] 后台子 Agent 的 <task-notification> 是给模型的全文，消息区只留一行
+        const summary = origin === "task"
+            ? notificationSummary(text)
+            : origin === "plan" && text === PLAN_APPROVED_PROMPT
+                ? PLAN_HANDOFF_TEXT
+                : undefined;
+        if (summary !== undefined) {
+            this.add(new PrefixedText(t.fg("dim", t.glyphs.queued) + " " + t.fg("muted", `${label}  `), t.fg("muted", summary)));
+            return;
+        }
         this.add(new PrefixedText(t.fg("dim", t.glyphs.queued) + " " + t.fg("muted", `${label}  `), t.fg("muted", text)));
     }
     newAssistant() {

package/dist/modes/interactive/panels.d.ts

@@ -4,12 +4,29 @@
  *
  * - `/session`：标题 `会话 <id 前 8 位> · <文件>`；模型 / 消息 / 用量 / 上下文（余量表，阈值着色），
  *   空一行后「缓存」段（与 `/cache` 共用 `cacheRows`）；
+ * - [W5-U] `/session` 多「子 Agent」行（任务汇总）与「外部 Agent」段（按 Agent 的运行次数与用量，单位不换算）；
  * - `/permissions`：权限模式、判定顺序（折行对齐值列）、规则（allow success、deny error、来源 dim）、
  *   最近的 auto 判定。
  */
 import type { AgentSession } from "../../agent/types.js";
 import type { Runtime } from "../../cli/runtime.js";
-import { type Component, type Theme } from "../../tui.js";
+import { KeyValue, type Component, type KeyValueRow, type Theme } from "../../tui.js";
+/** 多段内容按顺序拼起来（段之间不加空行，由调用方放空串）。 */
+export declare class Stack implements Component {
+    private readonly parts;
+    constructor(parts: readonly (Component | string)[]);
+    render(width: number): string[];
+    invalidate(): void;
+}
+/** 缩进若干列的子组件。 */
+export declare class Indent implements Component {
+    private readonly child;
+    private readonly columns;
+    constructor(child: Component, columns: number);
+    render(width: number): string[];
+    invalidate(): void;
+}
+export declare function keyValue(rows: readonly KeyValueRow[], theme: Theme, wrap?: boolean): KeyValue;
 export declare function sessionPanel(session: AgentSession, theme: Theme, options?: {
     now?: number;
     home?: string;

package/dist/modes/interactive/panels.js

@@ -4,15 +4,16 @@
  *
  * - `/session`：标题 `会话 <id 前 8 位> · <文件>`；模型 / 消息 / 用量 / 上下文（余量表，阈值着色），
  *   空一行后「缓存」段（与 `/cache` 共用 `cacheRows`）；
+ * - [W5-U] `/session` 多「子 Agent」行（任务汇总）与「外部 Agent」段（按 Agent 的运行次数与用量，单位不换算）；
  * - `/permissions`：权限模式、判定顺序（折行对齐值列）、规则（allow success、deny error、来源 dim）、
  *   最近的 auto 判定。
  */
 import { AUTO_LAYER_TEXT, permissionModeLabel } from "../../permissions/modes.js";
 import { Card, KeyValue, Meter, } from "../../tui.js";
-import { cacheRows, formatTokenCount, formatUsd } from "../session-report.js";
+import { cacheRows, externalRows, formatTokenCount, formatUsd, taskStatsText, } from "../session-report.js";
 import { tildePath } from "../../cli/startup-screen.js";
 /** 多段内容按顺序拼起来（段之间不加空行，由调用方放空串）。 */
-class Stack {
+export class Stack {
     parts;
     constructor(parts) {
         this.parts = parts;
@@ -27,7 +28,7 @@ class Stack {
     }
 }
 /** 缩进若干列的子组件。 */
-class Indent {
+export class Indent {
     child;
     columns;
     constructor(child, columns) {
@@ -44,7 +45,7 @@ class Indent {
         this.child.invalidate();
     }
 }
-function keyValue(rows, theme, wrap = false) {
+export function keyValue(rows, theme, wrap = false) {
     return new KeyValue(rows, { theme, maxKeyRatio: 0.3, ...(wrap ? { wrap: true } : {}) });
 }
 function cacheSection(session, theme, now) {
@@ -93,8 +94,21 @@ export function sessionPanel(session, theme, options = {}) {
         },
         { key: "上下文", value: meter + window },
     ];
+    const tasks = taskStatsText(session);
+    if (tasks !== undefined)
+        rows.push({ key: "子 Agent", value: tasks });
+    const external = externalRows(session);
+    const externalSection = external.length > 0
+        ? ["", theme.bold("外部 Agent"), new Indent(keyValue(external, theme), 2)]
+        : [];
     const file = state.sessionFile === undefined ? "未落盘" : tildePath(state.sessionFile, options.home);
-    return new Card(new Stack([keyValue(rows, theme), "", ...cacheSection(session, theme, now)]), {
+    const parts = [
+        keyValue(rows, theme),
+        "",
+        ...cacheSection(session, theme, now),
+        ...externalSection,
+    ];
+    return new Card(new Stack(parts), {
         theme,
         title: `会话 ${state.sessionId.slice(0, 8)}`,
         subtitle: file,

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 };
+}