@armadra/agent 0.4.0 → 0.5.1

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

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

@@ -0,0 +1,34 @@
+/**
+ * 交互界面的计划审批编排（docs/wave5-plan.md §6.1）：把会话的计划审批交给对话框。[W5-U]
+ *
+ * - `attach(session)`：`planController(session).setAttendance("callback", …)`——计划提出后（会话空闲时）
+ *   打开审批框；同时关掉 W5-F 的文本回复审批与 `ama.plan_notice` 提示行（两者只在 `text` 时生效）。
+ *   resume 回来已有待审批的计划时只提示一行（`/plan` 打开审批框）。
+ * - 选择 → `controller.respond()`：批准（指定执行模式，编辑过则带 `editedMarkdown`）、继续修改（意见作为
+ *   普通用户消息）、放弃（4 退出 Plan 模式；Esc 留在 Plan）；「新上下文执行」先新建会话、`adopt(plan)`、
+ *   切执行模式，再发 `freshPrompt`。
+ */
+import type { AgentSession, PlanData } from "../../agent/types.js";
+import type { SwitchRequest } from "../../cli/compose-session.js";
+import type { NoticeLevel } from "./message-view.js";
+import { openPlanDialog, type PlanChoice, type PlanDialogHost } from "./plan-dialog.js";
+export interface PlanFlowDeps {
+    dialog: PlanDialogHost;
+    switchSession(request: SwitchRequest): Promise<AgentSession>;
+    notice(level: NoticeLevel, text: string): void;
+    /** 在当前会话发一条提示（新上下文执行的首条消息）。 */
+    prompt(text: string): void;
+    /** 测试注入：代替真实对话框。 */
+    open?(dialog: PlanDialogHost, input: Parameters<typeof openPlanDialog>[1]): Promise<PlanChoice>;
+}
+export declare class PlanFlow {
+    private readonly deps;
+    private opened;
+    constructor(deps: PlanFlowDeps);
+    /** 接管会话的计划审批（每次切换会话后调用）。 */
+    attach(session: AgentSession): void;
+    get isOpen(): boolean;
+    /** 打开审批框并执行选择（同一计划同时只开一个）。 */
+    ask(session: AgentSession, plan: PlanData): Promise<void>;
+    private apply;
+}

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

@@ -0,0 +1,98 @@
+/**
+ * 交互界面的计划审批编排（docs/wave5-plan.md §6.1）：把会话的计划审批交给对话框。[W5-U]
+ *
+ * - `attach(session)`：`planController(session).setAttendance("callback", …)`——计划提出后（会话空闲时）
+ *   打开审批框；同时关掉 W5-F 的文本回复审批与 `ama.plan_notice` 提示行（两者只在 `text` 时生效）。
+ *   resume 回来已有待审批的计划时只提示一行（`/plan` 打开审批框）。
+ * - 选择 → `controller.respond()`：批准（指定执行模式，编辑过则带 `editedMarkdown`）、继续修改（意见作为
+ *   普通用户消息）、放弃（4 退出 Plan 模式；Esc 留在 Plan）；「新上下文执行」先新建会话、`adopt(plan)`、
+ *   切执行模式，再发 `freshPrompt`。
+ */
+import { permissionModeLabel } from "../../permissions/modes.js";
+import { planController } from "../../plan/controller.js";
+import { executionMode } from "../../plan/store.js";
+import { approveFresh } from "./plan-command.js";
+import { openPlanDialog } from "./plan-dialog.js";
+export class PlanFlow {
+    deps;
+    opened;
+    constructor(deps) {
+        this.deps = deps;
+    }
+    /** 接管会话的计划审批（每次切换会话后调用）。 */
+    attach(session) {
+        const controller = planController(session);
+        if (controller === undefined)
+            return;
+        controller.setAttendance("callback", async (plan) => {
+            await this.ask(session, plan);
+            return undefined;
+        });
+        const pending = controller.pending();
+        if (pending !== undefined)
+            this.deps.notice("info", `计划 v${pending.version} 待审批：/plan 打开审批框`);
+    }
+    get isOpen() {
+        return this.opened !== undefined;
+    }
+    /** 打开审批框并执行选择（同一计划同时只开一个）。 */
+    async ask(session, plan) {
+        const controller = planController(session);
+        if (controller === undefined || this.opened !== undefined)
+            return;
+        this.opened = plan.id;
+        try {
+            const input = { plan, preMode: executionMode(undefined, controller.prePlanMode()) };
+            const choice = await (this.deps.open ?? openPlanDialog)(this.deps.dialog, input);
+            await this.apply(session, plan, choice);
+        }
+        catch (error) {
+            this.deps.notice("error", error instanceof Error ? error.message : String(error));
+        }
+        finally {
+            this.opened = undefined;
+        }
+    }
+    async apply(session, plan, choice) {
+        const controller = planController(session);
+        if (controller === undefined)
+            return;
+        switch (choice.decision) {
+            case "approve": {
+                const result = await controller.respond({
+                    planId: plan.id,
+                    decision: "approve",
+                    mode: choice.mode,
+                    ...(choice.editedMarkdown !== undefined ? { editedMarkdown: choice.editedMarkdown } : {}),
+                });
+                const mode = permissionModeLabel(result.mode ?? choice.mode);
+                this.deps.notice("info", `已批准计划 v${result.plan.version}，以 ${mode} 执行`);
+                return;
+            }
+            case "approve_fresh": {
+                const fresh = await approveFresh(controller, plan, choice.mode, { switchSession: (request) => this.deps.switchSession(request) }, choice.editedMarkdown);
+                this.deps.notice("info", `已批准计划 v${fresh.plan.version}，在新会话 ${fresh.session.state.sessionId.slice(0, 8)} 以 ${permissionModeLabel(choice.mode)} 执行`);
+                this.deps.prompt(fresh.prompt);
+                return;
+            }
+            case "revise":
+                await controller.respond({
+                    planId: plan.id,
+                    decision: "revise",
+                    feedback: choice.feedback,
+                });
+                return;
+            case "reject": {
+                const pre = executionMode(undefined, controller.prePlanMode());
+                await controller.respond({ planId: plan.id, decision: "reject" });
+                if (choice.exit) {
+                    session.setPermissionMode(pre);
+                    this.deps.notice("info", `已放弃计划 v${plan.version}，回到 ${permissionModeLabel(pre)}`);
+                }
+                else
+                    this.deps.notice("info", `已放弃计划 v${plan.version}（仍在 Plan 模式，/plan 查看）`);
+                return;
+            }
+        }
+    }
+}

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

@@ -0,0 +1,31 @@
+/**
+ * `/rewind` 的带参数形式（rewind-plan §4，line 模式与交互模式共用；交互模式无参数时开列表）。[RW-C]
+ *
+ * - `/rewind`：列出回滚点，编号从旧到新（1 = 最早）。
+ * - `/rewind <n> [both|conversation|code] [overwrite]`：缺省 both（没有检查点时 conversation）；
+ *   `overwrite` 覆盖冲突文件（`onConflict: "overwrite"`）。
+ * - `/rewind <n> summarize-from|summarize-up-to [说明]`。
+ * 错误码换成中文说明后照原 code 抛出。
+ */
+import type { AgentSession, RewindDraftText } from "../../agent/types.js";
+import type { RewindPoint } from "../../checkpoints/types.js";
+import type { RewindAction } from "./rewind-panel.js";
+export declare const REWIND_USAGE = "\u7528\u6CD5\uFF1A/rewind\uFF0C/rewind <n> [both|conversation|code] [overwrite]\uFF0C/rewind <n> summarize-from|summarize-up-to [\u8BF4\u660E]";
+export interface RewindArgs {
+    /** 1 起的编号。 */
+    index: number;
+    action?: RewindAction;
+    instructions?: string;
+    overwrite?: boolean;
+}
+export declare function parseRewindArgs(args: string): RewindArgs;
+export declare function rewindListText(points: readonly RewindPoint[], now: number): string;
+export interface RewindCommandResult {
+    message: string;
+    /** 对话变了：原消息草稿（界面回填输入框）。 */
+    draft?: RewindDraftText;
+    /** 消息区要重画。 */
+    reload?: boolean;
+}
+/** 执行 `/rewind <args>`；args 为空时只列出回滚点。 */
+export declare function rewindCommand(session: AgentSession, args: string, now?: number): Promise<RewindCommandResult>;

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

@@ -0,0 +1,106 @@
+/**
+ * `/rewind` 的带参数形式（rewind-plan §4，line 模式与交互模式共用；交互模式无参数时开列表）。[RW-C]
+ *
+ * - `/rewind`：列出回滚点，编号从旧到新（1 = 最早）。
+ * - `/rewind <n> [both|conversation|code] [overwrite]`：缺省 both（没有检查点时 conversation）；
+ *   `overwrite` 覆盖冲突文件（`onConflict: "overwrite"`）。
+ * - `/rewind <n> summarize-from|summarize-up-to [说明]`。
+ * 错误码换成中文说明后照原 code 抛出。
+ */
+import { AmaError } from "../../errors.js";
+import { oneLine, rewindErrorText, rewindResultLines } from "./rewind-text.js";
+import { relativeTime } from "./startup-ui.js";
+const FORMS = "/rewind <n> [both|conversation|code] [overwrite]，/rewind <n> summarize-from|summarize-up-to [说明]";
+export const REWIND_USAGE = `用法：/rewind，${FORMS}`;
+const ACTIONS = [
+    "both",
+    "conversation",
+    "code",
+    "summarize-from",
+    "summarize-up-to",
+];
+export function parseRewindArgs(args) {
+    const m = /^(\d+)(?:\s+(\S+))?(?:\s+([\s\S]*))?$/.exec(args.trim());
+    const index = m === null ? NaN : Number(m[1]);
+    if (m === null || !Number.isInteger(index) || index < 1) {
+        throw new AmaError("invalid_arguments", REWIND_USAGE);
+    }
+    const out = { index };
+    const action = m[2];
+    const rest = (m[3] ?? "").trim();
+    if (action === undefined)
+        return out;
+    if (!ACTIONS.includes(action)) {
+        throw new AmaError("invalid_arguments", REWIND_USAGE);
+    }
+    out.action = action;
+    if (action === "summarize-from" || action === "summarize-up-to") {
+        if (rest !== "")
+            out.instructions = rest;
+    }
+    else if (rest === "overwrite" && action !== "conversation")
+        out.overwrite = true;
+    else if (rest !== "")
+        throw new AmaError("invalid_arguments", REWIND_USAGE);
+    return out;
+}
+export function rewindListText(points, now) {
+    if (points.length === 0)
+        return "还没有可回滚的消息";
+    const lines = points.map((point, i) => {
+        const time = relativeTime(new Date(point.timestamp).toISOString(), now);
+        const only = point.hasCheckpoint ? "" : "  [仅对话]";
+        return `  ${i + 1}. ${time}  ${oneLine(point.text, 60) || "（空）"}${only}`;
+    });
+    return [`回滚点（${FORMS}）：`, ...lines].join("\n");
+}
+/** 执行 `/rewind <args>`；args 为空时只列出回滚点。 */
+export async function rewindCommand(session, args, now = Date.now()) {
+    const points = session.rewindPoints();
+    if (args.trim() === "")
+        return { message: rewindListText(points, now) };
+    const parsed = parseRewindArgs(args);
+    const point = points[parsed.index - 1];
+    if (point === undefined) {
+        throw new AmaError("invalid_arguments", `没有第 ${parsed.index} 个回滚点（共 ${points.length} 个，/rewind 查看）`);
+    }
+    const action = parsed.action ?? (point.hasCheckpoint ? "both" : "conversation");
+    try {
+        if (action === "summarize-from") {
+            const result = await session.summarizeFrom(point.entryId, parsed.instructions);
+            return {
+                message: `已从这里分叉，离开的部分写成了摘要；原消息：${oneLine(result.draft.text, 80)}`,
+                draft: result.draft,
+                reload: true,
+            };
+        }
+        if (action === "summarize-up-to") {
+            const result = await session.summarizeUpTo(point.entryId, parsed.instructions);
+            const after = result.tokensAfter !== undefined ? ` → ${result.tokensAfter}` : "";
+            return { message: `已摘要到这里：${result.tokensBefore}${after} token` };
+        }
+        const result = await session.rewind({
+            entryId: point.entryId,
+            mode: action,
+            ...(parsed.overwrite === true ? { onConflict: "overwrite" } : {}),
+        });
+        if (action === "conversation")
+            delete result.gitHint;
+        const draft = result.conversation?.draft;
+        const lines = rewindResultLines(result, {
+            overwrite: parsed.overwrite === true,
+            ...(draft !== undefined
+                ? { conversation: `对话已回到这条消息之前；原消息：${oneLine(draft.text, 80)}` }
+                : {}),
+        });
+        return draft !== undefined
+            ? { message: lines.join("\n"), draft, reload: true }
+            : { message: lines.join("\n") };
+    }
+    catch (error) {
+        if (error instanceof AmaError) {
+            throw new AmaError(error.code, rewindErrorText(error), { cause: error });
+        }
+        throw error;
+    }
+}