@ai-agent-forge/agent-forge 0.88.1 → 0.88.3

package/dist/modes/interactive/interactive-commands.js

@@ -1,9 +1,37 @@
 /**
- * Slash-command dispatch table for the interactive mode editor submit handler.
- * Extracted from InteractiveMode.setupEditorSubmitHandler; entry order mirrors
- * the original if-chain and each run body mirrors its branch verbatim
- * (await/no-await and editor clearing order included).
+ * Slash-command dispatch table for the interactive mode editor submit handler,
+ * plus the command-handler implementations behind it (拆分 slice 1).
+ *
+ * The dispatch table was extracted from InteractiveMode.setupEditorSubmitHandler;
+ * entry order mirrors the original if-chain and each run body mirrors its
+ * branch verbatim (await/no-await and editor clearing order included). The
+ * handler functions below were moved verbatim out of InteractiveMode (拆分
+ * slice 1, docs/plans/interactive-mode拆分计划.md); the mode keeps same-name
+ * delegate methods so prototype-level tests and the dispatch table keep
+ * working.
  */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { Container, Markdown, Spacer, Text, TuiAltScreen, visibleWidth } from "@agent-forge/tui";
+import { getDebugLogPath } from "../../config.js";
+import { SessionImportFileNotFoundError } from "../../core/agent-session-runtime.js";
+import { computeCacheWaste } from "../../core/cache-stats.js";
+import { t } from "../../core/i18n/index.js";
+import { runCleanSessions } from "../../core/session-cleanup.js";
+import { MissingSessionCwdError } from "../../core/session-cwd.js";
+import { BUILTIN_SLASH_COMMANDS } from "../../core/slash-commands.js";
+import { getUsageCostBreakdown } from "../../core/usage-totals.js";
+import { loadThemeFromPath, setRegisteredThemes, theme } from "../../theme/theme.js";
+import { getChangelogPath, normalizeChangelogLinks, parseChangelog } from "../../utils/changelog.js";
+import { copyToClipboard } from "../../utils/clipboard.js";
+import { ArminComponent } from "./components/armin.js";
+import { BashExecutionComponent } from "./components/bash-execution.js";
+import { DaxnutsComponent } from "./components/daxnuts.js";
+import { DynamicBorder } from "./components/dynamic-border.js";
+import { formatTokens } from "./components/footer.js";
+import { keyDisplayText } from "./components/keybinding-hints.js";
+import { isExpandable } from "./interactive-dialog-ui.js";
+import { formatMetricsSnapshot } from "./interactive-format.js";
 export const COMMAND_DISPATCH_ENTRIES = [
     {
         command: "/settings",
@@ -127,6 +155,13 @@ export const COMMAND_DISPATCH_ENTRIES = [
         clearEditorBeforeRun: true,
         run: (host, _text, arg) => host.handleCompactCommand(arg),
     },
+    {
+        command: "/clean-sessions",
+        argOffset: 16,
+        blankArgToUndefined: true,
+        clearEditorBeforeRun: true,
+        run: (host, _text, arg) => host.handleCleanSessionsCommand(arg),
+    },
     { command: "/reload", clearEditorBeforeRun: true, run: (host) => host.handleReloadCommand() },
     {
         command: "/debug",
@@ -213,4 +248,663 @@ export function filterCapabilityCommandsForCompletions(capabilityCommands, reser
         ...(command.argumentHint !== undefined ? { argumentHint: command.argumentHint } : {}),
     }));
 }
+/**
+ * Rebuilds real Theme instances from the resource loader's ThemeMetaV1
+ * projection for the theme registry (B-S2b v1). Registration points
+ * (constructor, runtime session start, reload) need loadable instances —
+ * setRegisteredThemes stores what it is given and getThemeByName returns the
+ * registered instance first — while the loader surface now projects only
+ * metadata. Re-loading is synchronous and deterministic per sourcePath;
+ * theme names come from the same JSON the loader parsed, so meta.name ===
+ * Theme.name and the registry keeps its own name-filter/dedupe semantics.
+ *
+ * Contract: a meta without a sourcePath (or one whose file no longer parses)
+ * throws — themesOverride host inputs must always carry a loadable
+ * sourcePath. This adds one extra parse per theme at registration time
+ * (constructor / session start / reload, not per turn).
+ *
+ * Re-exported from ./interactive-mode.ts for existing consumers of that module.
+ */
+export function buildRegisteredThemes(themes) {
+    return themes.map((meta) => loadThemeFromPath(meta.sourcePath));
+}
+export async function handleReloadCommand(host) {
+    if (host.facade.isStreaming()) {
+        host.showWarning(t("Wait for the current response to finish before reloading."));
+        return;
+    }
+    if (host.facade.isCompacting()) {
+        host.showWarning(t("Wait for compaction to finish before reloading."));
+        return;
+    }
+    host.resetDialogUI();
+    const reloadBox = new Container();
+    const borderColor = (s) => theme.fg("border", s);
+    reloadBox.addChild(new DynamicBorder(borderColor));
+    reloadBox.addChild(new Spacer(1));
+    reloadBox.addChild(new Text(theme.fg("muted", t("Reloading keybindings, skills, prompts, themes, and context files...")), 1, 0));
+    reloadBox.addChild(new Spacer(1));
+    reloadBox.addChild(new DynamicBorder(borderColor));
+    const previousEditor = host.editor;
+    host.editorContainer.clear();
+    host.editorContainer.addChild(reloadBox);
+    host.ui.setFocus(reloadBox);
+    host.ui.requestRender(true);
+    await new Promise((resolve) => process.nextTick(resolve));
+    const dismissReloadBox = (editor) => {
+        host.editorContainer.clear();
+        host.editorContainer.addChild(editor);
+        host.ui.setFocus(editor);
+        host.ui.requestRender();
+    };
+    let chatRestoredBeforeSessionStart = false;
+    let reloadBoxDismissed = false;
+    const restoreChatBeforeSessionStart = () => {
+        if (chatRestoredBeforeSessionStart) {
+            return;
+        }
+        host.hideThinkingBlock = host.settingsManager.getHideThinkingBlock();
+        host.outputPad = host.settingsManager.getOutputPad();
+        host.rebuildChatFromMessages();
+        chatRestoredBeforeSessionStart = true;
+    };
+    try {
+        await host.facade.reload({ beforeSessionStart: restoreChatBeforeSessionStart });
+        restoreChatBeforeSessionStart();
+        host.keybindings.reload();
+        const activeHeader = host.builtInHeader;
+        if (isExpandable(activeHeader)) {
+            activeHeader.setExpanded(host.toolOutputExpanded);
+        }
+        setRegisteredThemes(buildRegisteredThemes(host.facade.getThemes().themes));
+        host.applyRuntimeSettings();
+        await host.themeController.applyFromSettings();
+        host.setupAutocompleteProvider();
+        host.showLoadedResources({
+            force: false,
+            showDiagnosticsWhenQuiet: true,
+        });
+        const modelsJsonError = host.facade.getModelsError();
+        if (modelsJsonError) {
+            host.showError(t("models.json error: {error}", { error: modelsJsonError }));
+        }
+        host.showStatus(t("Reloaded keybindings, skills, prompts, themes, and context files"));
+        dismissReloadBox(host.editor);
+        reloadBoxDismissed = true;
+    }
+    catch (error) {
+        // v8 ignore next -- reloadBoxDismissed 置位后 catch 前无可抛出点，恒走 dismiss 分支
+        if (!reloadBoxDismissed) {
+            dismissReloadBox(previousEditor);
+        }
+        host.showError(t("Reload failed: {error}", { error: error instanceof Error ? error.message : String(error) }));
+    }
+}
+export async function handleExportCommand(host, text) {
+    const outputPath = getPathCommandArgument(text, "/export");
+    try {
+        if (outputPath?.endsWith(".jsonl")) {
+            const filePath = host.facade.exportToJsonl(outputPath);
+            host.showStatus(t("Session exported to: {path}", { path: filePath }));
+        }
+        else {
+            const filePath = await host.facade.exportToHtml(outputPath, {
+                themeName: theme.name,
+            });
+            host.showStatus(t("Session exported to: {path}", { path: filePath }));
+        }
+    }
+    catch (error) {
+        host.showError(t("Failed to export session: {error}", {
+            error: error instanceof Error ? error.message : t("Unknown error"),
+        }));
+    }
+}
+export function getPathCommandArgument(text, command) {
+    if (text === command) {
+        return undefined;
+    }
+    if (!text.startsWith(`${command} `)) {
+        return undefined;
+    }
+    const argsString = text.slice(command.length + 1).trimStart();
+    if (!argsString) {
+        return undefined;
+    }
+    const firstChar = argsString[0];
+    if (firstChar === '"' || firstChar === "'") {
+        const closingQuoteIndex = argsString.indexOf(firstChar, 1);
+        if (closingQuoteIndex < 0) {
+            return undefined;
+        }
+        return argsString.slice(1, closingQuoteIndex);
+    }
+    const firstWhitespaceIndex = argsString.search(/\s/);
+    if (firstWhitespaceIndex < 0) {
+        return argsString;
+    }
+    return argsString.slice(0, firstWhitespaceIndex);
+}
+export async function handleImportCommand(host, text) {
+    const inputPath = getPathCommandArgument(text, "/import");
+    if (!inputPath) {
+        host.showError(t("Usage: /import <path.jsonl>"));
+        return;
+    }
+    const confirmed = await host.showDialogConfirm(t("Import session"), t("Replace current session with {path}?", { path: inputPath }));
+    if (!confirmed) {
+        host.showStatus(t("Import cancelled"));
+        return;
+    }
+    try {
+        host.clearStatusIndicator();
+        const result = await host.runtimeFacade.importFromJsonl(inputPath);
+        if (result.cancelled) {
+            host.showStatus(t("Import cancelled"));
+            return;
+        }
+        host.showStatus(t("Session imported from: {path}", { path: inputPath }));
+    }
+    catch (error) {
+        if (error instanceof MissingSessionCwdError) {
+            const selectedCwd = await host.promptForMissingSessionCwd(error);
+            if (!selectedCwd) {
+                host.showStatus(t("Import cancelled"));
+                return;
+            }
+            const result = await host.runtimeFacade.importFromJsonl(inputPath, selectedCwd);
+            if (result.cancelled) {
+                host.showStatus(t("Import cancelled"));
+                return;
+            }
+            host.showStatus(t("Session imported from: {path}", { path: inputPath }));
+            return;
+        }
+        if (error instanceof SessionImportFileNotFoundError) {
+            host.showError(t("Failed to import session: {error}", { error: error.message }));
+            return;
+        }
+        await host.handleFatalRuntimeError(t("Failed to import session"), error);
+    }
+}
+export async function handleCopyCommand(host, options = {}) {
+    if (options.preferSelection &&
+        host.ui instanceof TuiAltScreen &&
+        !host.ui.getCopyOnSelect() &&
+        host.ui.hasActiveSelection()) {
+        await host.ui.copyActiveSelectionToClipboard();
+        return;
+    }
+    const text = host.facade.getLastAssistantText();
+    if (!text) {
+        host.showError(t("No agent messages to copy yet."));
+        return;
+    }
+    try {
+        await copyToClipboard(text);
+        if (options.flashConfirmation && host.ui instanceof TuiAltScreen) {
+            host.ui.flash(t("Copied!"));
+        }
+        else {
+            host.showStatus(t("Copied last agent message to clipboard"));
+        }
+    }
+    catch (error) {
+        host.showError(error instanceof Error ? error.message : String(error));
+    }
+}
+export function handleNameCommand(host, text) {
+    const name = text.replace(/^\/name\s*/, "").trim();
+    if (!name) {
+        const currentName = host.facade.getSessionName();
+        if (currentName) {
+            host.chatContainer.addChild(new Spacer(1));
+            host.chatContainer.addChild(new Text(theme.fg("dim", t("Session name: {name}", { name: currentName })), 1, 0));
+        }
+        else {
+            host.showWarning(t("Usage: /name <name>"));
+        }
+        host.ui.requestRender();
+        return;
+    }
+    host.facade.setSessionName(name);
+    const sessionName = host.facade.getSessionName();
+    if (sessionName !== name) {
+        host.showWarning(t("Session name was normalized from {from} to {to}", {
+            from: JSON.stringify(name),
+            to: JSON.stringify(sessionName),
+        }));
+    }
+    host.chatContainer.addChild(new Spacer(1));
+    host.chatContainer.addChild(new Text(theme.fg("dim", t("Session name set: {name}", { name: sessionName ?? name })), 1, 0));
+    host.ui.requestRender();
+}
+/**
+ * 中断分级（设计 子代理运行时 §4.2，2026-10-02）：/stop-agents 的唯一执行
+ * 面——终止全部后台子代理（不触当前回合）。Esc 从不做这件事。
+ */
+export function handleStopAgentsCommand(host) {
+    const active = host.facade.getActiveAgentTaskCount();
+    if (active === 0) {
+        host.showStatus(t("No background subagents running"));
+        return;
+    }
+    host.facade.abortAgentTasks();
+    host.showStatus(active === 1
+        ? t("Terminated {count} background subagent", { count: active })
+        : t("Terminated {count} background subagents", { count: active }));
+}
+export function handleSessionCommand(host) {
+    const stats = host.facade.getSessionStats();
+    const sessionName = host.facade.getSessionName();
+    const entries = host.facade.getEntries();
+    const cacheWaste = computeCacheWaste(entries, host.facade.getModelPriceSource());
+    // Cost/token totals per provider/model actually used (e.g. OpenRouter `auto`
+    // resolves to a concrete responseModel). Usage without model attribution is
+    // grouped separately so the breakdown reconciles with the session total.
+    const usageBreakdown = getUsageCostBreakdown(entries);
+    let info = `${theme.bold(t("Session Info"))}\n\n`;
+    if (sessionName) {
+        info += `${theme.fg("dim", t("Name:"))} ${sessionName}\n`;
+    }
+    info += `${theme.fg("dim", t("File:"))} ${stats.sessionFile ?? t("In-memory")}\n`;
+    info += `${theme.fg("dim", t("ID:"))} ${stats.sessionId}\n\n`;
+    info += `${theme.bold(t("Messages"))}\n`;
+    info += `${theme.fg("dim", t("Total:"))} ${stats.totalMessages}\n`;
+    info += `${theme.fg("dim", t("User:"))} ${stats.userMessages}\n`;
+    info += `${theme.fg("dim", t("Assistant:"))} ${stats.assistantMessages}\n`;
+    info += `${theme.fg("dim", t("Tools:"))} ${t("{calls} calls, {results} results", {
+        calls: stats.toolCalls,
+        results: stats.toolResults,
+    })}\n\n`;
+    info += `${theme.bold(t("Tokens"))}\n`;
+    // "Input" is the full prompt volume. With cache activity, split it into
+    // cached (served from cache) vs uncached (everything else) - the only
+    // provider-independent split. Cache writes, where reported, are a detail
+    // of the uncached portion.
+    const { input, cacheRead, cacheWrite } = stats.tokens;
+    const promptTokens = input + cacheRead + cacheWrite;
+    info += `${theme.fg("dim", t("Input:"))} ${promptTokens.toLocaleString()}\n`;
+    if (promptTokens > 0 && (cacheRead > 0 || cacheWrite > 0)) {
+        const hitRate = theme.fg("dim", `(${((cacheRead / promptTokens) * 100).toFixed(1)}%)`);
+        info += `  ${theme.fg("dim", t("Cached:"))} ${cacheRead.toLocaleString()} ${hitRate}\n`;
+        const written = cacheWrite > 0
+            ? ` ${theme.fg("dim", t("({count} written to cache)", { count: cacheWrite.toLocaleString() }))}`
+            : "";
+        info += `  ${theme.fg("dim", t("Uncached:"))} ${(input + cacheWrite).toLocaleString()}${written}\n`;
+    }
+    info += `${theme.fg("dim", t("Output:"))} ${stats.tokens.output.toLocaleString()}\n`;
+    info += `${theme.fg("dim", t("Total:"))} ${stats.tokens.total.toLocaleString()}\n`;
+    // 双维度统计（用户裁决 2026-09-25）：总计之外按供应商/模型分桶——缓存读/写、
+    // 命中率、费用逐桶可见。此前该拆分门控在 cost>0 且多桶才渲染，单价为 0 的
+    // 自定义供应商（如自建代理）永远看不到。
+    if (usageBreakdown.length > 0) {
+        info += `\n${theme.bold(t("By Provider/Model"))}\n`;
+        for (const entry of usageBreakdown) {
+            const bucket = entry.totals;
+            const promptBucket = bucket.input + bucket.cacheRead + bucket.cacheWrite;
+            let line = `  ${theme.bold(entry.key)}`;
+            if (promptBucket > 0) {
+                line += `\n    ${theme.fg("dim", t("Input:"))} ${promptBucket.toLocaleString()}`;
+                if (bucket.cacheRead > 0 || bucket.cacheWrite > 0) {
+                    const rate = promptBucket > 0 ? ((bucket.cacheRead / promptBucket) * 100).toFixed(1) : "0.0";
+                    line += ` ${theme.fg("dim", t("(cache {rate}%, W {written})", { rate, written: bucket.cacheWrite.toLocaleString() }))}`;
+                }
+            }
+            if (bucket.output > 0)
+                line += `\n    ${theme.fg("dim", t("Output:"))} ${bucket.output.toLocaleString()}`;
+            if (entry.cost > 0)
+                line += ` ${theme.fg("dim", `$${entry.cost.toFixed(3)}`)}`;
+            info += `${line}\n`;
+        }
+    }
+    if (stats.cost > 0 || cacheWaste.missedTokens > 0) {
+        info += `\n${theme.bold(t("Cost"))}\n`;
+        info += `${theme.fg("dim", t("Total:"))} $${stats.cost.toFixed(3)}`;
+        if (usageBreakdown.length > 1) {
+            for (const entry of usageBreakdown) {
+                info += `\n  ${theme.fg("dim", `${entry.key}:`)} $${entry.cost.toFixed(3)} ${theme.fg("dim", t("({tokens} tokens)", { tokens: formatTokens(entry.tokens) }))}`;
+            }
+        }
+        if (cacheWaste.missedTokens > 0) {
+            const missLabel = cacheWaste.missCount === 1
+                ? t("{count} miss", { count: cacheWaste.missCount })
+                : t("{count} misses", { count: cacheWaste.missCount });
+            const detail = t("{tokens} tokens, {misses}", {
+                tokens: cacheWaste.missedTokens.toLocaleString(),
+                misses: missLabel,
+            });
+            info +=
+                cacheWaste.missedCost >= 0.0001
+                    ? `\n${theme.fg("dim", t("Cache Re-billed:"))} $${cacheWaste.missedCost.toFixed(3)} ${theme.fg("dim", `(${detail})`)}`
+                    : `\n${theme.fg("dim", t("Cache Re-billed:"))} ${detail}`;
+        }
+    }
+    host.chatContainer.addChild(new Spacer(1));
+    host.chatContainer.addChild(new Text(info, 1, 0));
+    host.ui.requestRender();
+}
+export function handleMetricsCommand(host, turnsArg) {
+    const provider = host.options.getMetrics;
+    if (!provider) {
+        host.showWarning(t("Metrics are not available: the observability plugin is not mounted in this session"));
+        return;
+    }
+    let windowTurns;
+    if (turnsArg !== undefined) {
+        const parsed = Number.parseInt(turnsArg, 10);
+        if (!Number.isSafeInteger(parsed) || parsed < 1) {
+            host.showWarning(t("Invalid turns: {turns}. Usage: /metrics [turns]", { turns: turnsArg }));
+            return;
+        }
+        windowTurns = parsed;
+    }
+    let snapshot;
+    try {
+        const result = provider({ windowTurns });
+        if (result === undefined) {
+            host.showWarning(t("Metrics are not available: the observability plugin is not mounted in this session"));
+            return;
+        }
+        snapshot = result;
+    }
+    catch (error) {
+        host.showError(error instanceof Error ? error.message : String(error));
+        return;
+    }
+    host.chatContainer.addChild(new Spacer(1));
+    host.chatContainer.addChild(new Text(formatMetricsSnapshot(snapshot), 1, 0));
+    host.ui.requestRender();
+}
+export function handleChangelogCommand(host) {
+    const changelogPath = getChangelogPath();
+    const allEntries = parseChangelog(changelogPath);
+    const changelogMarkdown = allEntries.length > 0
+        ? allEntries
+            .reverse()
+            .map((e) => normalizeChangelogLinks(e.content, e))
+            .join("\n\n")
+        : t("No changelog entries found.");
+    host.chatContainer.addChild(new Spacer(1));
+    host.chatContainer.addChild(new DynamicBorder());
+    host.chatContainer.addChild(new Text(theme.bold(theme.fg("accent", t("What's New"))), 1, 0));
+    host.chatContainer.addChild(new Spacer(1));
+    host.chatContainer.addChild(new Markdown(changelogMarkdown, 1, 1, host.getMarkdownThemeWithSettings()));
+    host.chatContainer.addChild(new DynamicBorder());
+    host.ui.requestRender();
+}
+/**
+ * Get capitalized display string for an app keybinding action.
+ */
+export function getAppKeyDisplay(action) {
+    return keyDisplayText(action);
+}
+/**
+ * Get capitalized display string for an editor keybinding action.
+ */
+export function getEditorKeyDisplay(action) {
+    return keyDisplayText(action);
+}
+export function handleHelpCommand(host) {
+    const section = (title, rows) => {
+        if (rows.length === 0)
+            return "";
+        let table = `\n**${title}**\n| ${t("Command")} | ${t("Description")} |\n|---------|-------------|\n`;
+        for (const row of rows) {
+            const command = row.hint ? `\`/${row.name} ${row.hint}\`` : `\`/${row.name}\``;
+            table += `| ${command} | ${row.description ?? ""} |\n`;
+        }
+        return table;
+    };
+    const builtinRows = BUILTIN_SLASH_COMMANDS.map((command) => ({
+        name: command.name,
+        hint: command.argumentHint,
+        description: command.description,
+    }));
+    const promptRows = host.facade.getPromptTemplates().map((template) => ({
+        name: template.name,
+        hint: template.argumentHint,
+        description: template.description,
+    }));
+    const skillRows = host.facade.getSkills().skills.map((skill) => ({
+        name: `skill:${skill.name}`,
+        description: skill.description,
+    }));
+    const help = section(t("Built-in commands"), builtinRows) +
+        section(t("Prompt templates"), promptRows) +
+        section(t("Skills"), skillRows) +
+        `\n${t("Type `/` for autocomplete. Use `/hotkeys` for keyboard shortcuts.")}`;
+    host.chatContainer.addChild(new Spacer(1));
+    host.chatContainer.addChild(new DynamicBorder());
+    host.chatContainer.addChild(new Text(theme.bold(theme.fg("accent", t("Available Commands"))), 1, 0));
+    host.chatContainer.addChild(new Markdown(help.trim(), 1, 1, host.getMarkdownThemeWithSettings()));
+    host.chatContainer.addChild(new DynamicBorder());
+    host.ui.requestRender();
+}
+export function handleHotkeysCommand(host) {
+    // Navigation keybindings
+    const cursorUp = getEditorKeyDisplay("tui.editor.cursorUp");
+    const cursorDown = getEditorKeyDisplay("tui.editor.cursorDown");
+    const cursorLeft = getEditorKeyDisplay("tui.editor.cursorLeft");
+    const cursorRight = getEditorKeyDisplay("tui.editor.cursorRight");
+    const cursorWordLeft = getEditorKeyDisplay("tui.editor.cursorWordLeft");
+    const cursorWordRight = getEditorKeyDisplay("tui.editor.cursorWordRight");
+    const cursorLineStart = getEditorKeyDisplay("tui.editor.cursorLineStart");
+    const cursorLineEnd = getEditorKeyDisplay("tui.editor.cursorLineEnd");
+    const jumpForward = getEditorKeyDisplay("tui.editor.jumpForward");
+    const jumpBackward = getEditorKeyDisplay("tui.editor.jumpBackward");
+    const pageUp = getEditorKeyDisplay("tui.editor.pageUp");
+    const pageDown = getEditorKeyDisplay("tui.editor.pageDown");
+    // Editing keybindings
+    const submit = getEditorKeyDisplay("tui.input.submit");
+    const newLine = getEditorKeyDisplay("tui.input.newLine");
+    const deleteWordBackward = getEditorKeyDisplay("tui.editor.deleteWordBackward");
+    const deleteWordForward = getEditorKeyDisplay("tui.editor.deleteWordForward");
+    const deleteToLineStart = getEditorKeyDisplay("tui.editor.deleteToLineStart");
+    const deleteToLineEnd = getEditorKeyDisplay("tui.editor.deleteToLineEnd");
+    const yank = getEditorKeyDisplay("tui.editor.yank");
+    const yankPop = getEditorKeyDisplay("tui.editor.yankPop");
+    const undo = getEditorKeyDisplay("tui.editor.undo");
+    const tab = getEditorKeyDisplay("tui.input.tab");
+    // App keybindings
+    const interrupt = getAppKeyDisplay("app.interrupt");
+    const clear = getAppKeyDisplay("app.clear");
+    const exit = getAppKeyDisplay("app.exit");
+    const suspend = getAppKeyDisplay("app.suspend");
+    const cycleThinkingLevel = getAppKeyDisplay("app.thinking.cycle");
+    const cycleModelForward = getAppKeyDisplay("app.model.cycleForward");
+    const selectModel = getAppKeyDisplay("app.model.select");
+    const expandTools = getAppKeyDisplay("app.tools.expand");
+    const toggleThinking = getAppKeyDisplay("app.thinking.toggle");
+    const externalEditor = getAppKeyDisplay("app.editor.external");
+    const cycleModelBackward = getAppKeyDisplay("app.model.cycleBackward");
+    const copyMessage = getAppKeyDisplay("app.message.copy");
+    const followUp = getAppKeyDisplay("app.message.followUp");
+    const dequeue = getAppKeyDisplay("app.message.dequeue");
+    const pasteImage = getAppKeyDisplay("app.clipboard.pasteImage");
+    // Iron law (2026-10-01): these shipped defaults were cleared in favor of
+    // the /model command; the row only appears when a user re-configures a key.
+    const selectModelRow = selectModel ? `| \`${selectModel}\` | ${t("Open model selector")} |\n` : "";
+    // Iron law (2026-10-02 复审): ctrl+g/ctrl+x stay bound only for the
+    // components without a command channel — the main editor ignores them
+    // (/editor and /copy are its single entries), so the rows say where
+    // each key actually acts.
+    const copyMessageRow = copyMessage ? `| \`${copyMessage}\` | ${t("Copy selection in /tree")} |\n` : "";
+    const externalEditorRow = externalEditor
+        ? `| \`${externalEditor}\` | ${t("External editor (inside dialog inputs)")} |\n`
+        : "";
+    // Iron law (2026-10-01): the message queue is the /queue and /dequeue
+    // commands' feature; rows only appear when a user re-configures a key.
+    const followUpRow = followUp ? `| \`${followUp}\` | ${t("Queue follow-up message")} |\n` : "";
+    const dequeueRow = dequeue ? `| \`${dequeue}\` | ${t("Restore queued messages")} |\n` : "";
+    const cycleThinkingRow = cycleThinkingLevel ? `| \`${cycleThinkingLevel}\` | ${t("Cycle thinking level")} |\n` : "";
+    const cycleModelsRow = cycleModelForward || cycleModelBackward
+        ? `| \`${cycleModelForward}\` / \`${cycleModelBackward}\` | ${t("Cycle models")} |\n`
+        : "";
+    // Suspend has no default key on native Windows; hide the row there.
+    const suspendRow = suspend ? `| \`${suspend}\` | ${t("Suspend to background")} |\n` : "";
+    const hotkeys = `
+**${t("Navigation")}**
+| ${t("Key")} | ${t("Action")} |
+|-----|--------|
+| \`${cursorUp}\` / \`${cursorDown}\` / \`${cursorLeft}\` / \`${cursorRight}\` | ${t("Move cursor / browse history")} |
+| \`${cursorWordLeft}\` / \`${cursorWordRight}\` | ${t("Move by word")} |
+| \`${cursorLineStart}\` | ${t("Start of line")} |
+| \`${cursorLineEnd}\` | ${t("End of line")} |
+| \`${jumpForward}\` | ${t("Jump forward to character")} |
+| \`${jumpBackward}\` | ${t("Jump backward to character")} |
+| \`${pageUp}\` / \`${pageDown}\` | ${t("Scroll by page")} |
+
+**${t("Editing")}**
+| ${t("Key")} | ${t("Action")} |
+|-----|--------|
+| \`${submit}\` | ${t("Send message")} |
+| \`${newLine}\` | ${process.platform === "win32" ? t("New line (Ctrl+Enter on Windows Terminal)") : t("New line")} |
+| \`${deleteWordBackward}\` | ${t("Delete word backwards")} |
+| \`${deleteWordForward}\` | ${t("Delete word forwards")} |
+| \`${deleteToLineStart}\` | ${t("Delete to start of line")} |
+| \`${deleteToLineEnd}\` | ${t("Delete to end of line")} |
+| \`${yank}\` | ${t("Paste the most-recently-deleted text")} |
+| \`${yankPop}\` | ${t("Cycle through the deleted text after pasting")} |
+| \`${undo}\` | ${t("Undo")} |
+
+**${t("Other")}**
+| ${t("Key")} | ${t("Action")} |
+|-----|--------|
+| \`${tab}\` | ${t("Path completion / accept autocomplete")} |
+| \`${interrupt}\` | ${t("Cancel autocomplete / abort streaming")} |
+| \`${clear}\` | ${t("Clear editor (first) / exit (second)")} |
+| \`${exit}\` | ${t("Exit (when editor is empty)")} |
+${suspendRow}${cycleThinkingRow}${cycleModelsRow}${selectModelRow}| \`${expandTools}\` | ${t("Toggle tool output expansion")} |
+| \`${toggleThinking}\` | ${t("Toggle thinking block visibility")} |
+${externalEditorRow}${copyMessageRow}${followUpRow}${dequeueRow}
+| \`${pasteImage}\` | ${t("Paste image or text from clipboard")} |
+| \`/\` | ${t("Slash commands")} |
+| \`!\` | ${t("Run bash command")} |
+| \`!!\` | ${t("Run bash command (excluded from context)")} |
+`;
+    host.chatContainer.addChild(new Spacer(1));
+    host.chatContainer.addChild(new DynamicBorder());
+    host.chatContainer.addChild(new Text(theme.bold(theme.fg("accent", t("Keyboard Shortcuts"))), 1, 0));
+    host.chatContainer.addChild(new Spacer(1));
+    host.chatContainer.addChild(new Markdown(hotkeys.trim(), 1, 1, host.getMarkdownThemeWithSettings()));
+    host.chatContainer.addChild(new DynamicBorder());
+    host.ui.requestRender();
+}
+export async function handleClearCommand(host) {
+    host.clearStatusIndicator();
+    try {
+        const result = await host.runtimeFacade.newSession();
+        if (result.cancelled) {
+            return;
+        }
+        host.chatContainer.addChild(new Spacer(1));
+        host.chatContainer.addChild(new Text(`${theme.fg("accent", t("✓ New session started"))}`, 1, 1));
+        host.ui.requestRender();
+    }
+    catch (error) {
+        await host.handleFatalRuntimeError("Failed to create session", error);
+    }
+}
+export function handleDebugCommand(host) {
+    const width = host.ui.terminal.columns;
+    const height = host.ui.terminal.rows;
+    const allLines = host.ui.render(width);
+    const debugLogPath = getDebugLogPath();
+    const debugData = [
+        t("Debug output at {date}", { date: new Date().toISOString() }),
+        t("Terminal: {columns}x{rows}", { columns: width, rows: height }),
+        t("Total lines: {count}", { count: allLines.length }),
+        "",
+        t("=== All rendered lines with visible widths ==="),
+        ...allLines.map((line, idx) => {
+            const vw = visibleWidth(line);
+            const escaped = JSON.stringify(line);
+            return `[${idx}] (w=${vw}) ${escaped}`;
+        }),
+        "",
+        t("=== Agent messages (JSONL) ==="),
+        ...host.facade
+            .getSessionAPI()
+            .getMessages()
+            .map((msg) => JSON.stringify(msg)),
+        "",
+    ].join("\n");
+    fs.mkdirSync(path.dirname(debugLogPath), { recursive: true });
+    fs.writeFileSync(debugLogPath, debugData);
+    host.chatContainer.addChild(new Spacer(1));
+    host.chatContainer.addChild(new Text(`${theme.fg("accent", t("✓ Debug log written"))}\n${theme.fg("muted", debugLogPath)}`, 1, 1));
+    host.ui.requestRender();
+}
+export function handleArminSaysHi(host) {
+    host.chatContainer.addChild(new Spacer(1));
+    host.chatContainer.addChild(new ArminComponent(host.ui));
+    host.ui.requestRender();
+}
+export function handleDaxnuts(host) {
+    host.chatContainer.addChild(new Spacer(1));
+    host.chatContainer.addChild(new DaxnutsComponent(host.ui));
+    host.ui.requestRender();
+}
+/** Host-visible for ./interactive-auth.ts (S5 slice 3). */
+export function checkDaxnutsEasterEgg(host, model) {
+    if (model.provider === "opencode" && model.id.toLowerCase().includes("kimi-k2.5")) {
+        host.handleDaxnuts();
+    }
+}
+export async function handleBashCommand(host, command, excludeFromContext = false) {
+    // Dispatch the user.bash lifecycle facts, then execute locally.
+    host.facade.emitUserBash(excludeFromContext);
+    // Normal execution path
+    const isDeferred = host.facade.isStreaming();
+    host.bashComponent = new BashExecutionComponent(command, host.ui, excludeFromContext);
+    if (isDeferred) {
+        // Show in pending area when agent is streaming
+        host.pendingMessagesContainer.addChild(host.bashComponent);
+        host.pendingBashComponents.push(host.bashComponent);
+    }
+    else {
+        // Show in chat immediately when agent is idle
+        host.chatContainer.addChild(host.bashComponent);
+    }
+    host.ui.requestRender();
+    try {
+        const result = await host.facade.executeBash(command, (chunk) => {
+            if (host.bashComponent) {
+                host.bashComponent.appendOutput(chunk);
+                host.ui.requestRender();
+            }
+        }, { excludeFromContext });
+        if (host.bashComponent) {
+            host.bashComponent.setComplete(result.exitCode, result.cancelled, result.truncated ? { truncated: true, content: result.output } : undefined, result.fullOutputPath);
+        }
+    }
+    catch (error) {
+        if (host.bashComponent) {
+            host.bashComponent.setComplete(undefined, false);
+        }
+        host.showError(t("Bash command failed: {error}", {
+            error: error instanceof Error ? error.message : t("Unknown error"),
+        }));
+    }
+    host.bashComponent = undefined;
+    host.ui.requestRender();
+}
+export async function handleCompactCommand(host, customInstructions) {
+    host.clearStatusIndicator();
+    try {
+        await host.facade.compact(customInstructions);
+    }
+    catch {
+        // Ignore, will be emitted as an event
+    }
+}
+/** /clean-sessions：会话清理两阶段流程；输出/确认走宿主既有机制（设计 §7）。 */
+export async function handleCleanSessionsCommand(host, arg) {
+    await runCleanSessions({
+        showMessage: (text) => host.showStatus(text),
+        showError: (text) => host.showError(text),
+        confirm: (title, message) => host.showDialogConfirm(title, message),
+    }, arg);
+}
 //# sourceMappingURL=interactive-commands.js.map