@armadra/agent 0.5.0 → 0.6.0

package/dist/modes/interactive/config-ui.d.ts

@@ -0,0 +1,96 @@
+/**
+ * `/config` controller (docs/wave6-plan.md §6.3, D24-D26). [W6-S]
+ *
+ * - `open("")` shows the panel (config-panel.ts); `open("key=value")` / `open("key value")` sets one key
+ *   in the user config without the panel (same path as `ama config set`).
+ * - Every change is written at once (config/edit.ts) and then applied: keys of the "now" tier go to the
+ *   running session / view (`applySetting`), and `runtime.replaceConfig()` hands the re-merged config to
+ *   `/new`. `defaultModel`, `thinkingLevel` and `permission.mode` also switch the current session.
+ * - `permission.mode: full-auto` in the user config always asks the Bypass confirmation first.
+ * - The first change of a cache-prefix key in a conversation that already has replies shows a notice once
+ *   per panel; closing the panel posts one summary (`from → to (scope)`, plus restart / new-session lists).
+ * - `configCommand()` is the line mode `/config` (`CommandContext.extra.config`).
+ */
+import type { AgentSession } from "../../agent/types.js";
+import type { ModeContext } from "../../cli/deps.js";
+import type { Runtime } from "../../cli/runtime.js";
+import { type ConfigLayerInput } from "../../config/edit.js";
+import type { StatusLineMode } from "../../config/types.js";
+import type { CommandContext, CommandResult } from "../commands-core.js";
+import type { NoticeLevel, ThinkingDisplay } from "./message-view.js";
+import { type PickerHost } from "./pickers.js";
+/** Where "now" settings land in the running UI (every target optional). */
+export interface ConfigApplyTargets {
+    session(): AgentSession;
+    view?: {
+        setOptions(options: {
+            showThinking?: ThinkingDisplay;
+            markdown?: boolean;
+            compact?: boolean;
+        }): void;
+    };
+    loader?: {
+        setAnimation(on: boolean): void;
+    };
+    area?: {
+        setLayout(mode: StatusLineMode): void;
+    };
+    redraw?(): void;
+}
+/** Apply one "now" key to the running session / view; returns false when nothing applies. */
+export declare function applySetting(key: string, value: unknown, targets: ConfigApplyTargets): Promise<boolean>;
+/** Layer inputs of this process: user / project files, the profile and the command line flags. */
+export declare function layerInputFor(runtime: Runtime, context: ModeContext): ConfigLayerInput;
+/** `key=value` / `key value` → [key, raw]. */
+export declare function splitAssignment(args: string): [string, string] | undefined;
+export interface ConfigUiDeps extends PickerHost, ConfigApplyTargets {
+    runtime: Runtime;
+    context: ModeContext;
+    rows(): number;
+    notice(level: NoticeLevel, text: string): void;
+    render(): void;
+    /** Home directory for ~ in paths. */
+    home?: string;
+}
+export declare class ConfigUi {
+    private readonly deps;
+    private panel;
+    private handle;
+    private changes;
+    private prefixNoticeShown;
+    constructor(deps: ConfigUiDeps);
+    private input;
+    /** `/config [key=value]`. */
+    open(args: string): Promise<void>;
+    private close;
+    /** Closing summary (undefined when nothing changed). */
+    summary(): string | undefined;
+    private activate;
+    private pick;
+    private commitText;
+    /**
+     * Write one key and apply it. Errors become panel notices (or are rethrown with `rethrow`, for the
+     * inline editor). Returns the edit result, undefined when refused / cancelled.
+     */
+    private write;
+    private afterWrite;
+    /** `/config key=value`: user scope, no panel. */
+    private direct;
+}
+/** Line mode `/config`: no args lists the settings, `key=value` sets one (user scope). */
+export declare function configCommand(runtime: Runtime, context: ModeContext): (args: string, ctx: CommandContext) => Promise<CommandResult>;
+/** Wiring for interactive-mode.ts (one line there): the session follows `/new` `/resume` `/fork`. */
+export declare function configUiFor(host: PickerHost & {
+    rows(): number;
+}, parts: {
+    runtime: Runtime;
+    context: ModeContext;
+    view: NonNullable<ConfigApplyTargets["view"]>;
+    loader: NonNullable<ConfigApplyTargets["loader"]>;
+    area: NonNullable<ConfigApplyTargets["area"]>;
+    tui: {
+        forceFullRedraw(): void;
+        requestRender(): void;
+    };
+    notice(level: NoticeLevel, text: string): void;
+}): ConfigUi;

package/dist/modes/interactive/config-ui.js

@@ -0,0 +1,397 @@
+/**
+ * `/config` controller (docs/wave6-plan.md §6.3, D24-D26). [W6-S]
+ *
+ * - `open("")` shows the panel (config-panel.ts); `open("key=value")` / `open("key value")` sets one key
+ *   in the user config without the panel (same path as `ama config set`).
+ * - Every change is written at once (config/edit.ts) and then applied: keys of the "now" tier go to the
+ *   running session / view (`applySetting`), and `runtime.replaceConfig()` hands the re-merged config to
+ *   `/new`. `defaultModel`, `thinkingLevel` and `permission.mode` also switch the current session.
+ * - `permission.mode: full-auto` in the user config always asks the Bypass confirmation first.
+ * - The first change of a cache-prefix key in a conversation that already has replies shows a notice once
+ *   per panel; closing the panel posts one summary (`from → to (scope)`, plus restart / new-session lists).
+ * - `configCommand()` is the line mode `/config` (`CommandContext.extra.config`).
+ */
+import { AgentSessionImpl } from "../../agent/session.js";
+import { currentSession } from "../../cli/compose-session.js";
+import { hideFakeProvider } from "../../cli/fake-visibility.js";
+import { tildePath } from "../../cli/startup-screen.js";
+import { ConfigEditError, formatSettingValue, getConfigValue, parseValue, readSnapshot, setConfigValue, } from "../../config/edit.js";
+import { loadProfile } from "../../config/profile.js";
+import { settingSpec, settingsRegistry } from "../../config/settings-registry.js";
+import { msg } from "../../i18n/index.js";
+import { ConfigPanel, blockedReason } from "./config-panel.js";
+import { bypassChoiceSpec, openChoice } from "./confirm-dialog.js";
+import { modelItems, openPicker, permissionItems, thinkingItems, } from "./pickers.js";
+/** Apply one "now" key to the running session / view; returns false when nothing applies. */
+export async function applySetting(key, value, targets) {
+    const session = targets.session();
+    const impl = session instanceof AgentSessionImpl ? session : undefined;
+    switch (key) {
+        case "ui.markdown":
+            targets.view?.setOptions({ markdown: value !== false });
+            break;
+        case "ui.showThinking":
+            targets.view?.setOptions({ showThinking: (value ?? "collapsed") });
+            break;
+        case "ui.compact":
+            targets.view?.setOptions({ compact: value === true });
+            break;
+        case "ui.animation":
+            targets.loader?.setAnimation(value !== false);
+            break;
+        case "ui.statusLine":
+            targets.area?.setLayout((value ?? "full"));
+            break;
+        case "thinkingLevel":
+            session.setThinkingLevel((value ?? "medium"));
+            return true;
+        case "permission.mode":
+            session.setPermissionMode((value ?? "default"));
+            return true;
+        case "defaultModel":
+            if (typeof value !== "string")
+                return false;
+            await session.setModel(value);
+            return true;
+        case "compaction.enabled":
+            impl?.setAutoCompaction(value !== false);
+            return impl !== undefined;
+        case "retry.enabled":
+            impl?.setAutoRetry(value !== false);
+            return impl !== undefined;
+        case "cache.warming":
+            if (typeof value === "string")
+                impl?.cache.setWarming(value);
+            return impl !== undefined;
+        default:
+            return false;
+    }
+    targets.redraw?.();
+    return true;
+}
+/** Layer inputs of this process: user / project files, the profile and the command line flags. */
+export function layerInputFor(runtime, context) {
+    const { args, io } = context;
+    const cli = {};
+    if (args.thinking !== undefined)
+        cli.thinkingLevel = args.thinking;
+    if (args.permissionMode !== undefined)
+        cli.permissionMode = args.permissionMode;
+    if (args.allow.length > 0)
+        cli.allow = args.allow;
+    if (args.deny.length > 0)
+        cli.deny = args.deny;
+    if (args.quietStartup !== undefined)
+        cli.quietStartup = args.quietStartup;
+    if (args.tuiMode !== undefined)
+        cli.tuiMode = args.tuiMode;
+    if (args.toolsPreset !== undefined)
+        cli.toolsPreset = args.toolsPreset;
+    if (args.codemode !== undefined)
+        cli.codemode = args.codemode;
+    if (args.memory !== undefined)
+        cli.memory = args.memory;
+    const input = {
+        configDir: runtime.paths.configDir,
+        cwd: runtime.paths.cwd,
+        env: io.env,
+        cli,
+    };
+    if (args.profile !== undefined) {
+        input.profile = { config: loadProfile(args.profile, io.cwd).config };
+        input.hasProfile = true;
+    }
+    return input;
+}
+/** `key=value` / `key value` → [key, raw]. */
+export function splitAssignment(args) {
+    const text = args.trim();
+    const eq = text.indexOf("=");
+    const space = text.search(/\s/);
+    const at = eq !== -1 && (space === -1 || eq < space) ? eq : space;
+    if (at <= 0)
+        return undefined;
+    return [text.slice(0, at).trim(), text.slice(at + 1).trim()];
+}
+const PROJECT_FILE = ".ama/config.json";
+const labelOf = (key) => msg().settings.labels[key] ?? key;
+const hasReplies = (session) => session.messages.some((m) => m.role === "assistant");
+export class ConfigUi {
+    deps;
+    panel;
+    handle;
+    changes = new Map();
+    prefixNoticeShown = false;
+    constructor(deps) {
+        this.deps = deps;
+    }
+    input() {
+        return layerInputFor(this.deps.runtime, this.deps.context);
+    }
+    /** `/config [key=value]`. */
+    async open(args) {
+        if (args.trim() !== "")
+            return this.direct(args);
+        if (this.panel !== undefined)
+            return;
+        const snapshot = readSnapshot(this.input());
+        const home = this.deps.home;
+        this.changes = new Map();
+        this.prefixNoticeShown = false;
+        const panel = new ConfigPanel(snapshot, {
+            theme: this.deps.theme,
+            ...(this.deps.keybindings !== undefined ? { keybindings: this.deps.keybindings } : {}),
+            rows: () => this.deps.rows(),
+            // project file is always <cwd>/.ama/config.json; forward slashes on every platform
+            paths: {
+                user: tildePath(snapshot.userPath, home).replace(/\\/g, "/"),
+                project: PROJECT_FILE,
+            },
+            embedded: this.input().hasProfile === true,
+            activate: (key, scope) => this.activate(key, scope),
+            unset: (key, scope) => this.write(key, undefined, scope).then(() => undefined),
+            commit: (key, text, scope) => this.commitText(key, text, scope),
+            close: () => this.close(),
+            requestRender: () => this.deps.render(),
+        });
+        this.panel = panel;
+        this.handle = this.deps.showOverlay(panel, { anchor: "bottom" });
+        this.deps.render();
+    }
+    close() {
+        this.handle?.hide();
+        this.handle = undefined;
+        this.panel = undefined;
+        const summary = this.summary();
+        if (summary !== undefined)
+            this.deps.notice("info", summary);
+        this.deps.render();
+    }
+    /** Closing summary (undefined when nothing changed). */
+    summary() {
+        const s = msg().settings;
+        const changed = [...this.changes.values()].filter((c) => c.from !== c.to);
+        if (changed.length === 0)
+            return undefined;
+        const lines = [s.summaryTitle];
+        for (const c of changed)
+            lines.push(`  ${s.summaryLine(labelOf(c.key), c.from, c.to, s.scope[c.scope])}`);
+        const tier = (apply) => changed
+            .filter((c) => c.spec?.apply === apply)
+            .map((c) => labelOf(c.key))
+            .join(", ");
+        if (tier("restart") !== "")
+            lines.push(s.summaryRestart(tier("restart")));
+        if (tier("nextSession") !== "")
+            lines.push(s.summaryNextSession(tier("nextSession")));
+        return lines.join("\n");
+    }
+    async activate(key, scope) {
+        const panel = this.panel;
+        const spec = settingSpec(key);
+        if (panel === undefined || spec === undefined)
+            return;
+        const current = getConfigValue(readSnapshot(this.input()), key);
+        const blocked = blockedReason(spec, current, scope);
+        if (blocked !== undefined)
+            return panel.setNotice(blocked, "warning");
+        const value = current.value;
+        switch (spec.kind) {
+            case "bool":
+                await this.write(key, value !== true, scope);
+                return;
+            case "enum": {
+                const options = spec.options ?? [];
+                if (options.length <= 4) {
+                    const next = options[(options.indexOf(String(value)) + 1) % options.length];
+                    await this.write(key, next, scope);
+                    return;
+                }
+                const picked = await this.pick(spec, value);
+                if (picked !== undefined)
+                    await this.write(key, picked === "" ? undefined : picked, scope);
+                return;
+            }
+            case "model": {
+                const picked = await this.pick(spec, value);
+                if (picked !== undefined)
+                    await this.write(key, picked === "" ? undefined : picked, scope);
+                return;
+            }
+            default:
+                panel.startEdit(key, value === undefined ? "" : formatSettingValue(value));
+        }
+    }
+    async pick(spec, value) {
+        const s = msg().settings;
+        const current = typeof value === "string" ? value : undefined;
+        let items;
+        if (spec.key === "permission.mode")
+            items = permissionItems((current ?? "default"));
+        else if (spec.key.endsWith("thinkingLevel"))
+            items = thinkingItems(true);
+        else if (spec.kind === "model")
+            items = [
+                ...(await modelItems(hideFakeProvider(this.deps.runtime.providers, this.deps.context.io.env))),
+                { value: "", label: s.defaultChoice },
+            ];
+        else
+            items = (spec.options ?? []).map((o) => ({ value: o, label: o }));
+        const picked = await openPicker(this.deps, {
+            title: s.pickTitle(labelOf(spec.key)),
+            items,
+            filterable: spec.kind === "model",
+            ...(current !== undefined ? { selected: current, currentValue: current } : {}),
+            ...(spec.key === "permission.mode" ? { stacked: true } : {}),
+        });
+        return picked?.value;
+    }
+    async commitText(key, text, scope) {
+        try {
+            await this.write(key, parseValue(key, text), scope, true);
+            return undefined;
+        }
+        catch (error) {
+            return error instanceof Error ? error.message : String(error);
+        }
+    }
+    /**
+     * Write one key and apply it. Errors become panel notices (or are rethrown with `rethrow`, for the
+     * inline editor). Returns the edit result, undefined when refused / cancelled.
+     */
+    async write(key, value, scope, rethrow = false) {
+        const s = msg().settings;
+        if (key === "permission.mode" && value === "full-auto" && scope === "user") {
+            const spec = bypassChoiceSpec(this.deps.theme);
+            const body = [...spec.body, this.deps.theme.fg("warning", s.bypassPersist)];
+            if ((await openChoice(this.deps, { ...spec, body })) !== 0)
+                return undefined;
+        }
+        let result;
+        try {
+            result = setConfigValue({ ...this.input(), scope, key, value });
+        }
+        catch (error) {
+            if (rethrow)
+                throw error;
+            const text = error instanceof Error ? error.message : String(error);
+            if (this.panel !== undefined)
+                this.panel.setNotice(text, "error");
+            else
+                this.deps.notice("error", text);
+            return undefined;
+        }
+        await this.afterWrite(result);
+        return result;
+    }
+    async afterWrite(result) {
+        const s = msg().settings;
+        const spec = settingSpec(result.key);
+        const from = formatSettingValue(result.before.value);
+        const to = formatSettingValue(result.after.value);
+        const previous = this.changes.get(result.key);
+        this.changes.set(result.key, {
+            key: result.key,
+            from: previous?.from ?? from,
+            to,
+            scope: result.scope,
+            spec,
+        });
+        this.deps.runtime.replaceConfig?.(result.snapshot.config);
+        let warning;
+        if (result.apply === "now" && result.before.value !== result.after.value)
+            await applySetting(result.key, result.after.value, this.deps).catch((error) => {
+                warning = error instanceof Error ? error.message : String(error);
+            });
+        if (result.overriddenBy !== undefined)
+            warning ??= s.stillOverridden(result.key, result.after.envName ?? result.overriddenBy);
+        if (result.prefixChanged && !this.prefixNoticeShown && hasReplies(this.deps.session())) {
+            this.prefixNoticeShown = true;
+            warning ??= s.prefixNotice;
+        }
+        if (this.panel !== undefined) {
+            this.panel.refresh(result.snapshot);
+            this.panel.setNotice(warning, "warning");
+        }
+        else {
+            const line = s.setDone(result.key, to, s.scope[result.scope]);
+            this.deps.notice(warning === undefined ? "info" : "warn", warning === undefined ? line : `${line}\n${warning}`);
+        }
+        this.deps.render();
+    }
+    /** `/config key=value`: user scope, no panel. */
+    async direct(args) {
+        const s = msg().settings;
+        const parts = splitAssignment(args);
+        if (parts === undefined || parts[1] === "")
+            return this.deps.notice("warn", s.slashUsage);
+        try {
+            const value = parseValue(parts[0], parts[1]);
+            await this.write(parts[0], value, "user", true);
+        }
+        catch (error) {
+            const text = error instanceof Error ? error.message : String(error);
+            this.deps.notice(error instanceof ConfigEditError ? "warn" : "error", text);
+        }
+    }
+}
+/** Line mode `/config`: no args lists the settings, `key=value` sets one (user scope). */
+export function configCommand(runtime, context) {
+    return async (args, ctx) => {
+        const s = msg().settings;
+        const input = layerInputFor(runtime, context);
+        if (args.trim() === "") {
+            const snapshot = readSnapshot(input);
+            const lines = settingsRegistry().map((spec) => {
+                const value = getConfigValue(snapshot, spec.key);
+                return `  ${spec.key} = ${formatSettingValue(value.value)}  ${value.envName ?? value.source}`;
+            });
+            return { kind: "handled", message: [s.cli.listHeader, ...lines].join("\n") };
+        }
+        const parts = splitAssignment(args);
+        if (parts === undefined || parts[1] === "")
+            return { kind: "handled", message: s.slashUsage };
+        try {
+            const value = parseValue(parts[0], parts[1]);
+            if (parts[0] === "permission.mode" && value === "full-auto") {
+                const confirmed = ctx.confirmPermissionMode === undefined
+                    ? false
+                    : await ctx.confirmPermissionMode("full-auto");
+                if (!confirmed)
+                    return { kind: "handled", message: s.cli.needYes };
+            }
+            const result = setConfigValue({ ...input, scope: "user", key: parts[0], value });
+            runtime.replaceConfig?.(result.snapshot.config);
+            if (result.apply === "now" && result.before.value !== result.after.value)
+                await applySetting(result.key, result.after.value, { session: () => ctx.session() });
+            const lines = [s.setDone(result.key, formatSettingValue(result.after.value), s.scope.user)];
+            if (result.overriddenBy !== undefined)
+                lines.push(s.stillOverridden(result.key, result.after.envName ?? result.overriddenBy));
+            return { kind: "handled", message: lines.join("\n") };
+        }
+        catch (error) {
+            if (error instanceof ConfigEditError)
+                return { kind: "handled", message: error.message };
+            throw error;
+        }
+    };
+}
+/** Wiring for interactive-mode.ts (one line there): the session follows `/new` `/resume` `/fork`. */
+export function configUiFor(host, parts) {
+    const { runtime, context, tui } = parts;
+    const env = context.io.env;
+    const home = env["HOME"] ?? env["USERPROFILE"];
+    return new ConfigUi({
+        ...host,
+        runtime,
+        context,
+        view: parts.view,
+        loader: parts.loader,
+        area: parts.area,
+        session: () => currentSession(runtime),
+        notice: parts.notice,
+        render: () => tui.requestRender(),
+        redraw: () => tui.forceFullRedraw(),
+        ...(home !== undefined ? { home } : {}),
+    });
+}

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

@@ -0,0 +1,49 @@
+/**
+ * 通用确认框：底部覆盖层 + `Box`，选项样式与审批对话框一致（终端界面视觉设计 v1 §3.11）。
+ *
+ * - 编号选项 `› 1. 进入 Bypass   y`，选中行 `›` + `selection` 底色，右侧按键提示 `dim`；
+ * - 按键：↑↓ 移动（循环）、Enter 确认、数字直选、选项按键提示里的单个字母直选（如 `y` / `n`）；
+ *   Esc / Ctrl+C / `tui.select.cancel` 取消（返回 undefined）；
+ * - 宽 < 56 列紧凑：去掉空行、按键提示只留第一个、底部提示缩短。字形取 `theme.glyphs`（ASCII 回退）。
+ *
+ * 用途：进入 Bypass permissions 前的确认（`confirmBypass`，permissions/bypass.ts）。
+ */
+import { type Component, type Focusable, type Keybindings, type OverlayHandle, type OverlayOptions, type SemanticColor, type Theme } from "../../tui.js";
+export interface ChoiceOption {
+    label: string;
+    /** 右侧按键提示（空格分隔）；其中的单个字母同时是直选键。 */
+    keys: string;
+}
+export interface ChoiceSpec {
+    title: string;
+    /** 正文（已着色），选项之上。 */
+    body: readonly string[];
+    options: readonly ChoiceOption[];
+    /** 缺省选中的下标。 */
+    selected?: number;
+    borderColor?: SemanticColor;
+}
+export interface ChoiceHost {
+    theme: Theme;
+    keybindings?: Keybindings;
+    showOverlay(component: Component, options: OverlayOptions): OverlayHandle;
+}
+export declare class ChoiceDialog implements Component, Focusable {
+    private readonly spec;
+    private readonly host;
+    private readonly done;
+    focused: boolean;
+    private selected;
+    constructor(spec: ChoiceSpec, host: Omit<ChoiceHost, "showOverlay">, done: (index: number | undefined) => void);
+    get selectedIndex(): number;
+    handleInput(data: string): void;
+    render(width: number): string[];
+    private optionLines;
+    invalidate(): void;
+}
+/** 打开确认框（底部覆盖层）：返回选中的下标，取消返回 undefined。 */
+export declare function openChoice(host: ChoiceHost, spec: ChoiceSpec): Promise<number | undefined>;
+/** Bypass 确认框的内容（缺省选中「取消」，边框 warning）。 */
+export declare function bypassChoiceSpec(theme: Theme): ChoiceSpec;
+/** 进入 Bypass 前问一次：选「进入 Bypass」返回 true，取消 / 选「取消」返回 false。 */
+export declare function confirmBypass(host: ChoiceHost): Promise<boolean>;

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

@@ -0,0 +1,120 @@
+/**
+ * 通用确认框：底部覆盖层 + `Box`，选项样式与审批对话框一致（终端界面视觉设计 v1 §3.11）。
+ *
+ * - 编号选项 `› 1. 进入 Bypass   y`，选中行 `›` + `selection` 底色，右侧按键提示 `dim`；
+ * - 按键：↑↓ 移动（循环）、Enter 确认、数字直选、选项按键提示里的单个字母直选（如 `y` / `n`）；
+ *   Esc / Ctrl+C / `tui.select.cancel` 取消（返回 undefined）；
+ * - 宽 < 56 列紧凑：去掉空行、按键提示只留第一个、底部提示缩短。字形取 `theme.glyphs`（ASCII 回退）。
+ *
+ * 用途：进入 Bypass permissions 前的确认（`confirmBypass`，permissions/bypass.ts）。
+ */
+import { msg } from "../../i18n/index.js";
+import { BYPASS_DEFAULT_CHOICE, bypassChoices, bypassConfirmTitle, bypassRiskLines, } from "../../permissions/bypass.js";
+import { Box, defaultKeybindings, matchesKey, padToWidth, truncateToWidth, visibleWidth, wrapTextWithAnsi, } from "../../tui.js";
+/** 宽度低于它（Box 外宽）时用紧凑布局。 */
+const COMPACT_WIDTH = 56;
+export class ChoiceDialog {
+    spec;
+    host;
+    done;
+    focused = false;
+    selected;
+    constructor(spec, host, done) {
+        this.spec = spec;
+        this.host = host;
+        this.done = done;
+        this.selected = Math.max(0, Math.min(spec.options.length - 1, spec.selected ?? 0));
+    }
+    get selectedIndex() {
+        return this.selected;
+    }
+    handleInput(data) {
+        const keys = this.host.keybindings ?? defaultKeybindings;
+        const n = this.spec.options.length;
+        const letter = data.length === 1 ? data.toLowerCase() : "";
+        const byLetter = letter === "" || !/^[a-z]$/.test(letter)
+            ? -1
+            : this.spec.options.findIndex((o) => o.keys.split(/\s+/).includes(letter));
+        if (byLetter !== -1)
+            this.done(byLetter);
+        else if (matchesKey(data, "escape") ||
+            keys.matches(data, "app.clear") ||
+            keys.matches(data, "tui.select.cancel")) {
+            this.done(undefined);
+        }
+        else if (/^[1-9]$/.test(data) && Number(data) <= n)
+            this.done(Number(data) - 1);
+        else if (keys.matches(data, "tui.select.up"))
+            this.selected = (this.selected + n - 1) % n;
+        else if (keys.matches(data, "tui.select.down"))
+            this.selected = (this.selected + 1) % n;
+        else if (matchesKey(data, "enter"))
+            this.done(this.selected);
+    }
+    render(width) {
+        const { theme } = this.host;
+        const compact = width + 4 < COMPACT_WIDTH;
+        const lines = [];
+        for (const line of this.spec.body)
+            lines.push(...wrapTextWithAnsi(line, width));
+        if (!compact)
+            lines.push("");
+        lines.push(...this.optionLines(width, compact));
+        if (!compact)
+            lines.push("");
+        const g = theme.glyphs;
+        const arrows = g.arrowUp + g.arrowDown;
+        const n = this.spec.options.length;
+        lines.push(theme.fg("dim", compact ? `${arrows} Enter · 1-${n} · Esc` : msg().approval.choiceHint(arrows, n)));
+        return lines.map((l) => truncateToWidth(l, width));
+    }
+    optionLines(width, compact) {
+        const { theme } = this.host;
+        const g = theme.glyphs;
+        const shown = this.spec.options.map((o) => (compact ? o.keys.split(/\s+/)[0] : o.keys));
+        const keyWidth = Math.max(...shown.map((k) => visibleWidth(k)));
+        return this.spec.options.map((option, i) => {
+            const selected = i === this.selected;
+            const left = `${selected ? g.prompt : " "} ${i + 1}. ${option.label}`;
+            const right = padToWidth(shown[i], keyWidth);
+            const room = Math.max(1, width - keyWidth - 1);
+            const label = selected ? theme.fg("accent", theme.bold(left)) : left;
+            const line = padToWidth(truncateToWidth(label, room), room) + " " + theme.fg("dim", right);
+            return selected ? theme.bg("selection", line) : line;
+        });
+    }
+    invalidate() { }
+}
+/** 打开确认框（底部覆盖层）：返回选中的下标，取消返回 undefined。 */
+export function openChoice(host, spec) {
+    return new Promise((resolve) => {
+        let handle;
+        let settled = false;
+        const dialog = new ChoiceDialog(spec, host, (index) => {
+            if (settled)
+                return;
+            settled = true;
+            handle?.hide();
+            resolve(index);
+        });
+        handle = host.showOverlay(new Box(dialog, {
+            title: spec.title,
+            theme: host.theme,
+            ...(spec.borderColor !== undefined ? { borderColor: spec.borderColor } : {}),
+        }), { anchor: "bottom" });
+    });
+}
+/** Bypass 确认框的内容（缺省选中「取消」，边框 warning）。 */
+export function bypassChoiceSpec(theme) {
+    return {
+        title: bypassConfirmTitle(),
+        body: bypassRiskLines().map((line, i) => (i === 0 ? theme.fg("warning", line) : line)),
+        options: bypassChoices(),
+        selected: BYPASS_DEFAULT_CHOICE,
+        borderColor: "warning",
+    };
+}
+/** 进入 Bypass 前问一次：选「进入 Bypass」返回 true，取消 / 选「取消」返回 false。 */
+export async function confirmBypass(host) {
+    return (await openChoice(host, bypassChoiceSpec(host.theme))) === 0;
+}