@armadra/agent 0.3.0 → 0.5.0

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

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

@@ -0,0 +1,37 @@
+/**
+ * 回滚交互流程（rewind-plan §3.5、§3.6、§4）：列表 → 确认面板 → 执行 → 结果通知。[RW-C]
+ *
+ * - `open()`（`/rewind`、空闲时双击 Esc）：运行中只提示；没有回滚点提示一行。
+ * - 执行：对话类（恢复代码和对话 / 恢复对话 / 从这里摘要）之后重画消息区并把原消息回填输入框
+ *   （文本进编辑器，图片随下一条消息发送）；结果写一条通知，错误码换成中文说明。
+ * - `afterInterrupt()`（中断即撤回）：Esc 中断后等运行结束；输入框仍为空且会话判定可撤回
+ *   （`ui.restoreOnCancel`、本回合没有任何助手文本 / 工具调用）→ 撤回并回填原消息。
+ */
+import type { AgentSession, RewindDraftText } from "../../agent/types.js";
+import type { RewindPoint } from "../../checkpoints/types.js";
+import type { NoticeLevel } from "./message-view.js";
+import { type RewindListHost } from "./rewind-list.js";
+import { type RewindChoice, type RewindPanelModel } from "./rewind-panel.js";
+export interface RewindFlowHost extends RewindListHost {
+    session(): AgentSession;
+    notice(level: NoticeLevel, text: string): void;
+    /** 底部提示行。 */
+    hint(text: string): void;
+    /** 对话变了：重画消息区。 */
+    reload(): void;
+    /** 原消息回填输入框（图片随下一条消息发送）。 */
+    setDraft(draft: RewindDraftText): void;
+    editorEmpty(): boolean;
+    /** 终端行数（面板放不下时紧凑排版）。 */
+    rows?(): number;
+}
+export declare const REFILLED = "\u539F\u6D88\u606F\u5DF2\u653E\u56DE\u8F93\u5165\u6846";
+/** 打开确认面板（底部覆盖层）；返回选择或 undefined（取消）。 */
+export declare function openRewindPanel(host: RewindFlowHost, model: RewindPanelModel): Promise<RewindChoice | undefined>;
+/** 执行面板里的选择，结果与错误都写成通知。 */
+export declare function executeRewind(host: RewindFlowHost, point: RewindPoint, choice: RewindChoice): Promise<void>;
+export interface RewindFlow {
+    open(): Promise<void>;
+    afterInterrupt(editorWasEmpty: boolean): Promise<void>;
+}
+export declare function createRewindFlow(host: RewindFlowHost): RewindFlow;

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

@@ -0,0 +1,151 @@
+/**
+ * 回滚交互流程（rewind-plan §3.5、§3.6、§4）：列表 → 确认面板 → 执行 → 结果通知。[RW-C]
+ *
+ * - `open()`（`/rewind`、空闲时双击 Esc）：运行中只提示；没有回滚点提示一行。
+ * - 执行：对话类（恢复代码和对话 / 恢复对话 / 从这里摘要）之后重画消息区并把原消息回填输入框
+ *   （文本进编辑器，图片随下一条消息发送）；结果写一条通知，错误码换成中文说明。
+ * - `afterInterrupt()`（中断即撤回）：Esc 中断后等运行结束；输入框仍为空且会话判定可撤回
+ *   （`ui.restoreOnCancel`、本回合没有任何助手文本 / 工具调用）→ 撤回并回填原消息。
+ */
+import { AgentSessionImpl } from "../../agent/session.js";
+import { PreviewCache, openRewindList } from "./rewind-list.js";
+import { RewindPanel } from "./rewind-panel.js";
+import { rewindErrorText, rewindResultLines } from "./rewind-text.js";
+export const REFILLED = "原消息已放回输入框";
+/** 打开确认面板（底部覆盖层）；返回选择或 undefined（取消）。 */
+export function openRewindPanel(host, model) {
+    return new Promise((resolve) => {
+        let handle;
+        const panel = new RewindPanel(model, {
+            theme: host.theme,
+            ...(host.keybindings !== undefined ? { keybindings: host.keybindings } : {}),
+            ...(host.rows !== undefined ? { rows: host.rows } : {}),
+        }, (choice) => {
+            handle?.hide();
+            resolve(choice);
+        });
+        handle = host.showOverlay(panel, { anchor: "bottom" });
+    });
+}
+function draftNote(draft) {
+    const images = draft.images?.length ?? 0;
+    return images > 0 ? `${REFILLED}（${images} 张图片随下一条消息发送）` : REFILLED;
+}
+/** 执行面板里的选择，结果与错误都写成通知。 */
+export async function executeRewind(host, point, choice) {
+    const session = host.session();
+    try {
+        switch (choice.action) {
+            case "both":
+            case "conversation":
+            case "code": {
+                host.hint("回滚中…");
+                const result = await session.rewind({
+                    entryId: point.entryId,
+                    mode: choice.action,
+                    ...(choice.onConflict !== undefined ? { onConflict: choice.onConflict } : {}),
+                });
+                const draft = result.conversation?.draft;
+                if (draft !== undefined) {
+                    host.reload();
+                    host.setDraft(draft);
+                }
+                const shown = { ...result };
+                if (choice.action === "conversation")
+                    delete shown.gitHint;
+                const lines = rewindResultLines(shown, {
+                    overwrite: choice.onConflict === "overwrite",
+                    ...(draft !== undefined
+                        ? { conversation: `对话已回到这条消息之前，${draftNote(draft)}` }
+                        : {}),
+                });
+                const code = result.code;
+                const nothing = code !== undefined &&
+                    code.restored.length + code.deleted.length === 0 &&
+                    (choice.onConflict !== "overwrite" || code.conflicts.length === 0);
+                host.notice(nothing && choice.action === "code" ? "warn" : "info", lines.join("\n"));
+                break;
+            }
+            case "summarize-from": {
+                host.hint("正在为离开的部分写摘要…");
+                const result = await session.summarizeFrom(point.entryId, choice.instructions);
+                host.reload();
+                host.setDraft(result.draft);
+                host.notice("info", `已从这里分叉，离开的部分写成了摘要；${draftNote(result.draft)}`);
+                break;
+            }
+            case "summarize-up-to": {
+                host.hint("正在摘要…");
+                const result = await session.summarizeUpTo(point.entryId, choice.instructions);
+                const after = result.tokensAfter !== undefined ? ` → ${result.tokensAfter}` : "";
+                host.notice("info", `已摘要到这里：${result.tokensBefore}${after} token`);
+                break;
+            }
+        }
+    }
+    catch (error) {
+        host.notice("error", rewindErrorText(error));
+    }
+    finally {
+        host.hint("");
+    }
+}
+export function createRewindFlow(host) {
+    let opening = false;
+    return {
+        async open() {
+            const session = host.session();
+            if (session.state.isStreaming) {
+                host.notice("warn", "正在运行，不能回滚（先按 Esc 中断）");
+                return;
+            }
+            if (opening)
+                return;
+            opening = true;
+            try {
+                const points = session.rewindPoints();
+                if (points.length === 0) {
+                    host.notice("info", "还没有可回滚的消息");
+                    return;
+                }
+                const cache = new PreviewCache((entryId) => session.rewind({ entryId, mode: "code", dryRun: true }));
+                const point = await openRewindList(host, points, cache);
+                if (point === undefined)
+                    return;
+                const model = { point, now: host.now() };
+                if (point.hasCheckpoint) {
+                    const state = await cache.ensure(point.entryId);
+                    if (state.state === "done")
+                        model.preview = state.result;
+                    else if (state.state === "error")
+                        model.previewError = state.message;
+                }
+                const choice = await openRewindPanel(host, model);
+                if (choice !== undefined)
+                    await executeRewind(host, point, choice);
+            }
+            finally {
+                opening = false;
+            }
+        },
+        async afterInterrupt(editorWasEmpty) {
+            const session = host.session();
+            await session.waitForIdle();
+            if (!editorWasEmpty || !host.editorEmpty())
+                return;
+            if (!(session instanceof AgentSessionImpl) || !session.canUndoAbortedTurn())
+                return;
+            try {
+                const draft = await session.undoAbortedTurn();
+                if (draft === undefined)
+                    return;
+                host.reload();
+                host.setDraft(draft);
+                host.notice("info", `已撤回被中断的消息，${draftNote(draft)}`);
+            }
+            catch (error) {
+                host.notice("error", rewindErrorText(error));
+            }
+        },
+    };
+}

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

@@ -0,0 +1,36 @@
+/**
+ * 回滚列表（rewind-plan §4）：居中覆盖层 + `SelectList`。[RW-C]
+ *
+ * - 活动路径上的回滚点，最旧在上、最近在下，缺省选中最后一条；标签是消息首行，说明是相对时间。
+ * - 右侧徽标：没有检查点的行一律「仅对话」；有检查点的只给高亮行算——对它做一次代码 dry-run，
+ *   结果按 entryId 缓存，算好后异步刷新：`N 文件 +x −y` / `无代码改动`，计算中 `…`，失败 `—`。
+ */
+import type { RewindPoint, RewindResult } from "../../checkpoints/types.js";
+import { type SelectItem } from "../../tui.js";
+import { type PickerHost } from "./pickers.js";
+export type PreviewState = {
+    state: "pending";
+} | {
+    state: "done";
+    result: RewindResult;
+} | {
+    state: "error";
+    message: string;
+};
+/** 代码 dry-run 的缓存：每个回滚点最多算一次。 */
+export declare class PreviewCache {
+    private readonly load;
+    private readonly states;
+    private readonly running;
+    constructor(load: (entryId: string) => Promise<RewindResult>);
+    get(entryId: string): PreviewState | undefined;
+    ensure(entryId: string): Promise<PreviewState>;
+}
+/** 列表项：value = 用户消息条目 id。 */
+export declare function rewindListItems(points: readonly RewindPoint[], cache: PreviewCache, highlighted: string | undefined, now: number, ascii?: boolean): SelectItem[];
+export interface RewindListHost extends PickerHost {
+    render(): void;
+    now(): number;
+}
+/** 打开回滚列表；Enter 返回选中的回滚点，Esc 返回 undefined。 */
+export declare function openRewindList(host: RewindListHost, points: readonly RewindPoint[], cache: PreviewCache): Promise<RewindPoint | undefined>;

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

@@ -0,0 +1,123 @@
+/**
+ * 回滚列表（rewind-plan §4）：居中覆盖层 + `SelectList`。[RW-C]
+ *
+ * - 活动路径上的回滚点，最旧在上、最近在下，缺省选中最后一条；标签是消息首行，说明是相对时间。
+ * - 右侧徽标：没有检查点的行一律「仅对话」；有检查点的只给高亮行算——对它做一次代码 dry-run，
+ *   结果按 entryId 缓存，算好后异步刷新：`N 文件 +x −y` / `无代码改动`，计算中 `…`，失败 `—`。
+ */
+import { Box, SelectList } from "../../tui.js";
+import { PICKER_FOOTER } from "./pickers.js";
+import { badgeText, hasCodeChanges, oneLine, rewindErrorText } from "./rewind-text.js";
+import { relativeTime } from "./startup-ui.js";
+/** 代码 dry-run 的缓存：每个回滚点最多算一次。 */
+export class PreviewCache {
+    load;
+    states = new Map();
+    running = new Map();
+    constructor(load) {
+        this.load = load;
+    }
+    get(entryId) {
+        return this.states.get(entryId);
+    }
+    ensure(entryId) {
+        const known = this.states.get(entryId);
+        if (known !== undefined && known.state !== "pending")
+            return Promise.resolve(known);
+        const running = this.running.get(entryId);
+        if (running !== undefined)
+            return running;
+        this.states.set(entryId, { state: "pending" });
+        const promise = this.load(entryId).then((result) => ({ state: "done", result }), (error) => ({ state: "error", message: rewindErrorText(error) }));
+        const settled = promise.then((state) => {
+            this.states.set(entryId, state);
+            this.running.delete(entryId);
+            return state;
+        });
+        this.running.set(entryId, settled);
+        return settled;
+    }
+}
+/** 列表项：value = 用户消息条目 id。 */
+export function rewindListItems(points, cache, highlighted, now, ascii = false) {
+    return points.map((point) => {
+        const text = oneLine(point.text, 60, ascii ? "..." : "…");
+        const item = {
+            value: point.entryId,
+            label: text === "" ? "（空）" : text,
+            description: relativeTime(new Date(point.timestamp).toISOString(), now),
+        };
+        if (!point.hasCheckpoint) {
+            item.badge = "仅对话";
+            item.badgeColor = "dim";
+        }
+        else if (point.entryId === highlighted) {
+            const state = cache.get(point.entryId);
+            if (state === undefined || state.state === "pending") {
+                item.badge = ascii ? "..." : "…";
+                item.badgeColor = "dim";
+            }
+            else if (state.state === "error") {
+                item.badge = ascii ? "-" : "—";
+                item.badgeColor = "dim";
+            }
+            else {
+                const code = state.result.code;
+                item.badge = code === undefined ? "无代码改动" : badgeText(code, ascii);
+                item.badgeColor = hasCodeChanges(code) ? "accent" : "dim";
+            }
+        }
+        return item;
+    });
+}
+/** 打开回滚列表；Enter 返回选中的回滚点，Esc 返回 undefined。 */
+export function openRewindList(host, points, cache) {
+    return new Promise((resolve) => {
+        const ascii = host.theme.glyphs.ascii;
+        let highlighted = points.at(-1)?.entryId;
+        let refreshing = false;
+        let closed = false;
+        const items = () => rewindListItems(points, cache, highlighted, host.now(), ascii);
+        const refresh = () => {
+            if (refreshing || closed)
+                return;
+            refreshing = true;
+            list.setItems(items());
+            refreshing = false;
+            host.render();
+        };
+        const close = (point) => {
+            closed = true;
+            handle.hide();
+            resolve(point);
+        };
+        const highlight = (entryId) => {
+            highlighted = entryId;
+            const point = points.find((p) => p.entryId === entryId);
+            if (point?.hasCheckpoint === true)
+                void cache.ensure(point.entryId).then(refresh);
+            refresh();
+        };
+        const list = new SelectList(items(), {
+            theme: host.theme,
+            maxVisible: 10,
+            filterable: points.length > 8,
+            ...(host.keybindings !== undefined ? { keybindings: host.keybindings } : {}),
+            footer: PICKER_FOOTER.replace("↑↓", host.theme.glyphs.arrowUp + host.theme.glyphs.arrowDown),
+            onSelect: (item) => close(points.find((p) => p.entryId === item.value)),
+            onCancel: () => close(undefined),
+            onSelectionChange: (item) => {
+                if (!refreshing && item?.value !== highlighted)
+                    highlight(item?.value);
+            },
+        });
+        if (highlighted !== undefined)
+            list.selectValue(highlighted);
+        const width = Math.max(20, Math.min(host.columns() - 2, 72));
+        const handle = host.showOverlay(new Box(list, { title: "回滚到哪条消息之前", theme: host.theme }), {
+            anchor: "center",
+            width,
+        });
+        highlight(highlighted);
+    });
+}