main.cpp

#include <iostream>
#include <string>
#include <vector>
#include <thread>
#include <mutex>
#include <condition_variable>
#include <atomic>
#include <chrono>
#include <cstdlib>
#include <cctype>
#include <algorithm>
#include <array>
#include <sstream>
#include <string_view>
#include <random>
#include <filesystem>
#include <optional>
#include <unordered_set>

#ifdef _WIN32
#ifndef NOMINMAX
#define NOMINMAX
#endif
#include <windows.h>
#include <io.h>
#include <direct.h>
#include <imm.h>
#pragma comment(lib, "Imm32.lib")
#else
#include <termios.h>
#include <unistd.h>
#endif

#include <ftxui/component/component.hpp>
#include <ftxui/component/screen_interactive.hpp>
#include <ftxui/dom/elements.hpp>
#include <ftxui/screen/string.hpp>
#include <ftxui/screen/terminal.hpp>

#include "version.hpp"
#include "config/config.hpp"
#include "network/proxy_resolver.hpp"
#include "remote_control/remote_control_service.hpp"
#include "provider/provider_factory.hpp"
#include "provider/copilot_provider.hpp"
#include "provider/model_context_resolver.hpp"
#include "provider/model_pool_status.hpp"
#include "provider/models_dev_registry.hpp"
#include "provider/model_resolver.hpp"
#include "provider/cwd_model_override.hpp"
#include "provider/apply_model_to_session.hpp"
#include "tool/tool_executor.hpp"
#include "tool/bash_tool.hpp"
#include "tool/builtin_tool_registry.hpp"
#include "tool/file_read_tool.hpp"
#include "tool/file_write_tool.hpp"
#include "tool/file_edit_tool.hpp"
#include "tool/grep_tool.hpp"
#include "tool/glob_tool.hpp"
#include "tool/task_complete_tool.hpp"
#include "tool/goal_tool.hpp"
#include "tool/mcp_manager.hpp"
#include "tool/mcp_startup_coordination.hpp"
#include "tool/skills_tool.hpp"
#include "tool/skill_view_tool.hpp"
#include "tool/memory_read_tool.hpp"
#include "tool/memory_write_tool.hpp"
#include "tool/ask_user_question_tool.hpp"
#include "tool/ask_overlay_input.hpp"
#include "tool/ace_browser_bridge/browser_tools.hpp"
#include "tui/confirm_question.hpp"
#include "skills/skill_init.hpp"
#include "skills/skill_registry.hpp"
#include "skills/skill_commands.hpp"
#include "skills/default_skill_seeder.hpp"
#include "hooks/hook_config.hpp"
#include "hooks/hook_manager.hpp"
#include "hooks/hook_payload.hpp"
#include "memory/memory_paths.hpp"
#include "memory/memory_registry.hpp"
#include "tool/web_search/runtime.hpp"
#include "tool/web_search/backend_router.hpp"
#include "tool/web_search/region_detector.hpp"
#include "tool/web_search/web_search_tool.hpp"
#include "utils/logger.hpp"
#include "permissions.hpp"
#include "agent_loop.hpp"
#include "commands/configure.hpp"
#include "daemon/cli.hpp"
#ifdef _WIN32
#  include "daemon/service_win.hpp"
#endif
#include "upgrade/apply.hpp"
#include "upgrade/check.hpp"
#include "upgrade/manifest.hpp"
#include "upgrade/upgrade.hpp"
#include "commands/command_registry.hpp"
#include "commands/builtin_commands.hpp"
#include "commands/compact.hpp"
#include "commands/resume_state_sync.hpp"
#include "utils/token_tracker.hpp"
#include "markdown/markdown_formatter.hpp"
#include "session/session_manager.hpp"
#include "session/session_registry.hpp"
#include "session/session_resume_restore.hpp"
#include "tui/chat_scroll.hpp"
#include "tui/chat_render_window.hpp"
#include "tui/diff_view.hpp"
#include "tui/unclipped_reflect.hpp"
#include "tui/paste_handler.hpp"
#include "tui/ask_question_overlay.hpp"
#include "tui/picker_scroll.hpp"
#include "tui/render_mode_factory.hpp"
#include "utils/terminal_capability.hpp"
#include "utils/state_file.hpp"
#include "tui/slash_dropdown.hpp"
#include "tui/text_truncation.hpp"
#include "tui/thick_vscroll_bar.hpp"
#include "tui/non_selectable.hpp"
#include "tui/tool_progress.hpp"
#include "tui/theme_palette.hpp"
#include "utils/terminal_theme_detect.hpp"
#include "tui/sidebar_model.hpp"
#include "tui/todo_checklist_view.hpp"
#include "tui/input_history_navigation.hpp"
#include "tui/ctrl_c_exit.hpp"
#include "utils/base64.hpp"
#include "utils/clipboard.hpp"
#include "utils/drag_scroll.hpp"
#include "utils/terminal_title.hpp"
#include "session/attachment_store.hpp"
#include "session/session_storage.hpp"
#include "history/input_history_store.hpp"
#include "desktop/workspace_registry.hpp"

#include <cstdio>

using namespace ftxui;
using namespace acecode;

namespace {

static const std::string EN_THINKING_PHRASES[50] = {
    "Analyzing", "Pondering", "Investigating", "Synthesizing", "Reviewing",
    "Processing", "Compiling", "Evaluating", "Formulating", "Brainstorming",
    "Searching", "Deciphering", "Gathering", "Debugging", "Inspecting",
    "Generating", "Organizing", "Mapping", "Exploring", "Tracing",
    "Validating", "Considering", "Reflecting", "Simulating", "Calculating",
    "Abstracting", "Diving", "Looking", "Troubleshooting", "Crafting",
    "Polishing", "Assembling", "Connecting", "Building", "Parsing",
    "Extracting", "Tuning", "Optimizing", "Designing", "Theorizing",
    "Hypothesizing", "Seeking", "Interpreting", "Measuring", "Weighing",
    "Reading", "Preparing", "Reasoning", "Constructing", "Finalizing"
};

static const std::string ZH_THINKING_PHRASES[50] = {
    "分析中", "思考中", "研究中", "探索中", "综合中",
    "审查中", "处理中", "编译中", "评估中", "规划中",
    "构思中", "搜索中", "解码中", "收集中", "调试中",
    "检查中", "生成中", "组织中", "映射中", "推理中",
    "验证中", "考虑中", "反思中", "模拟中", "计算中",
    "抽象中", "深挖中", "寻找中", "排查中", "打磨中",
    "完善中", "组装中", "连接中", "构建中", "解析中",
    "提取中", "微调中", "优化中", "设计中", "推论中",
    "假设中", "路线中", "解读中", "测量中", "权衡中",
    "阅读中", "准备中", "追溯中", "构造中", "总结中"
};

static bool is_user_chinese(const acecode::TuiState& state) {
    if (state.conversation.empty()) return false;
    for (auto it = state.conversation.rbegin(); it != state.conversation.rend(); ++it) {
        if (it->role == "user") {
            for (unsigned char c : it->content) {
                if (c >= 0xE0) return true;
            }
            return false;
        }
    }
    return false;
}

static std::string get_random_thinking_phrase(bool is_zh) {
    static thread_local std::random_device rd;
    static thread_local std::mt19937 gen(rd());
    std::uniform_int_distribution<> dis(0, 49);
    return is_zh ? ZH_THINKING_PHRASES[dis(gen)] : EN_THINKING_PHRASES[dis(gen)];
}

// A ToolSummary whose metrics contain `exit`, `aborted`, or `timeout` indicates
// a failure; used by the tool_result renderer to pick colour and decide whether
// to show the inline error tail.
static bool is_success_summary(const acecode::ToolSummary& s) {
    for (const auto& kv : s.metrics) {
        if (kv.first == "exit" && kv.second != "0") return false;
        if (kv.first == "aborted" && kv.second == "true") return false;
        if (kv.first == "timeout" && kv.second == "true") return false;
    }
    return true;
}

static std::string renderable_tool_summary_line(const acecode::ToolSummary& s,
                                                const std::string& metric_str,
                                                int max_visual_width) {
    const std::string prefix = s.icon + " " + s.verb + " \xC2\xB7 ";
    const std::string suffix = metric_str.empty()
        ? std::string()
        : " \xC2\xB7 " + metric_str;
    return acecode::tui::truncate_middle_segment(
        prefix, s.object, suffix, max_visual_width);
}

static std::string collapse_sidebar_title_whitespace(std::string_view text) {
    std::string out;
    bool in_space = false;
    for (unsigned char c : text) {
        if (std::isspace(c)) {
            if (!out.empty() && !in_space) {
                out.push_back(' ');
            }
            in_space = true;
        } else {
            out.push_back(static_cast<char>(c));
            in_space = false;
        }
    }
    if (!out.empty() && out.back() == ' ') {
        out.pop_back();
    }
    return out;
}

static std::string first_user_message_title(const acecode::TuiState& state) {
    std::string explicit_title =
        collapse_sidebar_title_whitespace(state.current_session_title);
    if (!explicit_title.empty()) return explicit_title;
    for (const auto& msg : state.conversation) {
        if (msg.role == "user") {
            std::string title = collapse_sidebar_title_whitespace(msg.content);
            if (!title.empty()) {
                return title;
            }
        }
    }
    return std::string("New session");
}

static void trim_ascii_space_suffix(std::string& text) {
    while (!text.empty() && text.back() == ' ') {
        text.pop_back();
    }
}

static std::string truncate_cells_prefix(std::string_view text, int max_cells) {
    if (max_cells <= 0) {
        return {};
    }
    std::string out;
    int used = 0;
    for (const auto& glyph : ftxui::Utf8ToGlyphs(std::string(text))) {
        if (glyph.empty()) {
            continue;
        }
        const int width = std::max(0, ftxui::string_width(glyph));
        if (used + width > max_cells) {
            break;
        }
        out += glyph;
        used += width;
    }
    return out;
}

static std::string truncate_cells_middle_ascii(std::string_view text, int max_cells) {
    if (max_cells <= 0) {
        return {};
    }
    const std::string input(text);
    if (ftxui::string_width(input) <= max_cells) {
        return input;
    }
    if (max_cells <= 3) {
        return truncate_cells_prefix(input, max_cells);
    }

    const int body_cells = max_cells - 3;
    const int head_cells = std::max(1, body_cells / 2);
    const int tail_cells = std::max(0, body_cells - head_cells);
    const auto glyphs = ftxui::Utf8ToGlyphs(input);

    std::string head;
    int used_head = 0;
    for (const auto& glyph : glyphs) {
        const int width = std::max(0, ftxui::string_width(glyph));
        if (used_head + width > head_cells) {
            break;
        }
        head += glyph;
        used_head += width;
    }

    std::vector<std::string> tail_glyphs;
    int used_tail = 0;
    for (std::size_t i = glyphs.size(); i > 0; --i) {
        const auto& glyph = glyphs[i - 1];
        const int width = std::max(0, ftxui::string_width(glyph));
        if (used_tail + width > tail_cells) {
            break;
        }
        tail_glyphs.push_back(glyph);
        used_tail += width;
    }
    std::reverse(tail_glyphs.begin(), tail_glyphs.end());

    std::string out = head + "...";
    for (const auto& glyph : tail_glyphs) {
        out += glyph;
    }
    return out;
}

static Element sidebar_section_header(const std::string& label, int count) {
    return hbox({
        text(label) | color(tui::theme().ui.text_muted) | dim,
        text(" " + std::to_string(count)) | color(tui::theme().ui.text_dim) | dim,
    });
}

static std::string sidebar_change_stats_text(
    const acecode::tui::SidebarFileChange& change) {
    std::string out;
    if (change.additions > 0) {
        out += "+" + std::to_string(change.additions);
    }
    if (change.deletions > 0) {
        if (!out.empty()) {
            out += " ";
        }
        out += "-" + std::to_string(change.deletions);
    }
    return out.empty() ? std::string("0") : out;
}

static Element render_sidebar_change_row(
    const acecode::tui::SidebarFileChange& change,
    int content_width) {
    const std::string stats_text = sidebar_change_stats_text(change);
    const int file_width =
        std::max(1, content_width - 2 - static_cast<int>(stats_text.size()) - 1);
    Elements stats_parts;
    if (change.additions > 0) {
        stats_parts.push_back(
            text("+" + std::to_string(change.additions)) |
            color(tui::theme().semantic.success));
    }
    if (change.deletions > 0) {
        if (!stats_parts.empty()) {
            stats_parts.push_back(text(" "));
        }
        stats_parts.push_back(
            text("-" + std::to_string(change.deletions)) |
            color(tui::theme().semantic.error));
    }
    if (stats_parts.empty()) {
        stats_parts.push_back(text("0") | color(tui::theme().ui.text_dim) | dim);
    }

    return hbox({
        text("  ") | color(tui::theme().ui.text_dim),
        text(truncate_cells_middle_ascii(
                 change.display_file.empty() ? change.file : change.display_file,
                 file_width)) |
            color(tui::theme().ui.text_muted),
        filler(),
        hbox(std::move(stats_parts)),
    });
}

static std::string mcp_state_label(McpServerState state) {
    switch (state) {
        case McpServerState::Starting:  return "starting";
        case McpServerState::Connected: return "connected";
        case McpServerState::Disabled:  return "disabled";
        case McpServerState::Failed:    return "failed";
        case McpServerState::Cancelled: return "cancelled";
        case McpServerState::TimedOut:  return "timed_out";
    }
    return "unknown";
}

static Color mcp_sidebar_state_color(const std::string& state) {
    if (state == "connected") return tui::theme().semantic.success;
    if (state == "starting") return Color::White;
    if (state == "failed" || state == "timed_out") return tui::theme().semantic.error;
    if (state == "cancelled") return tui::theme().semantic.warning;
    return tui::theme().ui.text_dim;
}

static bool mcp_sidebar_has_loading(
    const std::vector<acecode::TuiState::McpSidebarServer>& servers) {
    for (const auto& server : servers) {
        if (server.state == "starting") return true;
    }
    return false;
}

static bool mcp_sidebar_has_loading(const acecode::TuiState& state) {
    return mcp_sidebar_has_loading(state.mcp_sidebar_servers);
}

static Element render_white_shimmer_text(const std::string& label,
                                         int anim_tick,
                                         bool with_dots = true) {
    std::vector<std::string> glyphs = ftxui::Utf8ToGlyphs(label);
    const int total = static_cast<int>(glyphs.size());
    const int wave_pos = std::max(0, anim_tick) % (total > 0 ? total + 2 : 8);

    Elements parts;
    for (int i = 0; i < total; ++i) {
        int dist = i - wave_pos;
        if (dist < 0) dist = -dist;
        Color c;
        if (dist == 0) {
            c = Color::White;
        } else if (dist == 1) {
            c = Color::GrayLight;
        } else if (dist == 2) {
            c = Color::GrayDark;
        } else {
            c = tui::theme().ui.text_dim;
        }
        parts.push_back(text(glyphs[static_cast<std::size_t>(i)]) | color(c));
    }

    if (with_dots) {
        const int dot_count = (std::max(0, anim_tick) % 3) + 1;
        for (int i = 0; i < 3; ++i) {
            parts.push_back(
                text(".") |
                color(i < dot_count ? Color::White : tui::theme().ui.text_dim));
        }
    }

    return hbox(std::move(parts));
}

static std::string format_tool_count(size_t tool_count) {
    return std::to_string(tool_count) + (tool_count == 1 ? " tool" : " tools");
}

static std::string uppercase_ascii(std::string text) {
    for (char& c : text) {
        c = static_cast<char>(std::toupper(static_cast<unsigned char>(c)));
    }
    return text;
}

static std::vector<acecode::TuiState::McpSidebarServer>
build_mcp_sidebar_servers(const McpManager& manager) {
    auto server_infos = manager.list_servers();
    std::vector<acecode::TuiState::McpSidebarServer> out;
    out.reserve(server_infos.size());
    for (const auto& info : server_infos) {
        acecode::TuiState::McpSidebarServer server;
        server.name = info.name;
        server.state = mcp_state_label(info.state);
        server.transport = info.transport;
        server.error = info.error;
        server.tool_count = info.tool_count;
        out.push_back(std::move(server));
    }
    return out;
}

static void set_mcp_sidebar_servers_locked(
    acecode::TuiState& state,
    std::vector<acecode::TuiState::McpSidebarServer> servers) {
    state.mcp_sidebar_servers = std::move(servers);
}

static Element render_mcp_sidebar_section(
    const std::vector<acecode::TuiState::McpSidebarServer>& servers,
    int content_width,
    int anim_tick) {
    if (servers.empty()) {
        return emptyElement();
    }

    Elements rows;
    rows.push_back(text("MCP") | bold | color(tui::theme().ui.text_primary));

    constexpr std::size_t kMaxServers = 8;
    std::size_t shown_servers = 0;

    for (const auto& server : servers) {
        if (shown_servers >= kMaxServers) {
            break;
        }
        ++shown_servers;

        const Color state_color = mcp_sidebar_state_color(server.state);
        const bool server_loading = server.state == "starting";
        const bool server_connected = server.state == "connected";
        const bool server_failed =
            server.state == "failed" || server.state == "timed_out";
        const std::string bullet = "\xE2\x80\xA2"; // bullet

        Element status;
        if (server_loading) {
            status = render_white_shimmer_text("Loading", anim_tick);
        } else if (server_connected) {
            status = text("Connected (" + format_tool_count(server.tool_count) + ")") |
                     color(tui::theme().ui.text_muted);
        } else if (server_failed && !server.error.empty()) {
            status = hbox({
                text(uppercase_ascii(server.transport) + " error: ") |
                    color(tui::theme().semantic.error),
                paragraph(server.error) |
                    color(tui::theme().ui.text_muted) | dim | flex,
            });
        } else {
            status = text(server.state) | color(state_color) | dim;
        }

        const int name_width = std::max(1, content_width / 2);
        rows.push_back(hbox({
            text("  " + bullet + " ") | color(state_color),
            text(truncate_cells_middle_ascii(server.name, name_width)) |
                bold | color(tui::theme().ui.text_primary),
            text(" "),
            status | flex,
        }));
    }

    if (servers.size() > shown_servers) {
        rows.push_back(
            text("  +" + std::to_string(servers.size() - shown_servers) +
                 " more servers") |
            color(tui::theme().ui.text_dim) | dim);
    }

    return vbox(std::move(rows));
}

static Element queued_badge() {
    return text(" QUEUED ") | bold | color(tui::theme().ui.text_primary) |
           bgcolor(tui::theme().ui.queued_bg);
}

static std::string repeat_utf8_glyph(const char* glyph, int count) {
    std::string out;
    if (count <= 0) {
        return out;
    }
    const std::string g(glyph);
    out.reserve(g.size() * static_cast<std::size_t>(count));
    for (int i = 0; i < count; ++i) {
        out += g;
    }
    return out;
}

static Color token_progress_color(int percent) {
    const auto& s = tui::theme().semantic;
    if (percent <= 0) return tui::theme().ui.text_dim;
    if (percent > 90) return s.error;
    if (percent >= 60) return s.warning;
    return s.success;
}

// 当前活动模型的 PUB 池负载百分比(-1 = 未知/非 PUB,不渲染)。由 model-pool 监控
// 的后台轮询回调写入(atomic,UI 线程 render 读),配套 PostEvent 触发重绘。
static std::atomic<int> g_model_load_percent{-1};

// 模型池负载色阶(与 web / 后端 model_load_tier 一致):<70 绿 / 70..90 黄 / >90 红。
static Color model_load_color(int percent) {
    const auto& s = tui::theme().semantic;
    if (percent < 0) return tui::theme().ui.text_dim;
    if (percent > 90) return s.error;
    if (percent >= 70) return s.warning;
    return s.success;
}

// 底部状态栏的模型池负载 chip:递增信号格 + 百分比,按负载档染色。负载未知
// (g_model_load_percent < 0,即非 PUB 模型或监控无数据)时不渲染。
static Element render_model_load_chip() {
    const int percent = g_model_load_percent.load();
    if (percent < 0) return text("");
    const Color c = model_load_color(percent);
    return hbox({
        text("\xE2\x96\x81\xE2\x96\x83\xE2\x96\x85\xE2\x96\x87") | color(c),  // ▁▃▅▇ 递增信号格
        text(" " + std::to_string(percent) + "%  ") | color(c),
    });
}

static Color status_line_color(const std::string& status_line) {
    return status_line.find("(deleted)") != std::string::npos
        ? tui::theme().semantic.error
        : tui::theme().ui.text_primary;
}

static Element render_token_usage_chip(const acecode::TuiState& state) {
    if (state.token_status.empty()) {
        return text("");
    }

    constexpr int kBarCells = 10;
    constexpr const char* kFilled = "\xE2\x96\x88";
    constexpr const char* kEmpty = "\xE2\x96\x91";

    const int percent = std::clamp(state.token_percent, 0, 100);
    const int filled = percent <= 0 ? 0 : std::clamp((percent + 9) / 10, 1, kBarCells);
    const int empty = kBarCells - filled;
    const Color progress_color = token_progress_color(percent);

    return hbox({
        text("  " + state.token_status + " ") | dim | color(tui::theme().ui.accent_alt),
        text("[") | dim | color(tui::theme().ui.text_dim),
        text(repeat_utf8_glyph(kFilled, filled)) | color(progress_color),
        text(repeat_utf8_glyph(kEmpty, empty)) | dim | color(tui::theme().ui.text_dim),
        text("] ") | dim | color(tui::theme().ui.text_dim),
        text(std::to_string(percent) + "%  ") | dim | color(progress_color),
    });
}

static Element render_pending_queue_block(const acecode::TuiState& state,
                                          int available_width) {
    if (state.pending_queue.empty()) {
        return emptyElement();
    }

    constexpr std::size_t kMaxVisibleQueuedPrompts = 3;
    constexpr int kBadgeCells = 8;
    const int prompt_width =
        std::max(10, available_width - kBadgeCells - 5);
    const std::size_t visible =
        std::min(kMaxVisibleQueuedPrompts, state.pending_queue.size());

    Elements rows;
    const std::size_t hidden =
        state.pending_queue.size() > visible
            ? state.pending_queue.size() - visible
            : 0;
    if (hidden > 0) {
        rows.push_back(
            text("  +" + std::to_string(hidden) + " more queued") |
            color(tui::theme().ui.text_dim) | dim);
    }

    const std::size_t start = state.pending_queue.size() - visible;
    for (std::size_t i = start; i < state.pending_queue.size(); ++i) {
        const std::string preview = collapse_sidebar_title_whitespace(
            state.pending_queue[i]);
        rows.push_back(hbox({
            text(" "),
            queued_badge(),
            text(" "),
            text(truncate_cells_middle_ascii(preview, prompt_width)) |
                color(tui::theme().ui.text_primary),
        }));
    }

    return vbox(std::move(rows));
}

static Element render_pending_attachment_block(const acecode::TuiState& state,
                                               int available_width) {
    if (state.pending_attachments.empty()) {
        return emptyElement();
    }

    Elements rows;
    const int label_width = std::max(12, available_width - 18);
    for (const auto& attachment : state.pending_attachments) {
        const std::string kind = attachment.value("kind", std::string{"file"});
        const std::string name = attachment.value("name", std::string{"attachment"});
        const std::string prefix = kind == "image" ? " image " : " file ";
        rows.push_back(hbox({
            text(" "),
            text(prefix) | bold | color(tui::theme().ui.badge_fg) | bgcolor(tui::theme().ui.badge_bg),
            text(" "),
            text(truncate_cells_middle_ascii(name, label_width)) |
                color(tui::theme().ui.text_primary),
        }));
    }
    return vbox(std::move(rows));
}

static std::vector<std::string> sidebar_title_lines(const std::string& title,
                                                    int max_width) {
    max_width = std::max(1, max_width);
    const auto glyphs = ftxui::Utf8ToGlyphs(title);
    std::vector<std::string> lines;
    std::size_t index = 0;

    for (int line_index = 0; line_index < 2 && index < glyphs.size(); ++line_index) {
        std::string line;
        int width = 0;
        while (index < glyphs.size()) {
            const auto& glyph = glyphs[index];
            const int glyph_width = std::max(0, ftxui::string_width(glyph));
            if (width > 0 && width + glyph_width > max_width) {
                break;
            }
            if (width == 0 && glyph_width > max_width) {
                line += glyph;
                ++index;
                break;
            }
            line += glyph;
            width += glyph_width;
            ++index;
        }
        trim_ascii_space_suffix(line);
        lines.push_back(std::move(line));
        while (index < glyphs.size() && glyphs[index] == " ") {
            ++index;
        }
    }

    if (lines.empty()) {
        lines.push_back("New session");
    }
    if (index < glyphs.size()) {
        if (lines.size() == 1) {
            lines.push_back("");
        }
        const int body_width = std::max(0, max_width - 3);
        lines[1] = truncate_cells_prefix(lines[1], body_width);
        trim_ascii_space_suffix(lines[1]);
        lines[1] += "...";
    }
    return lines;
}

static Element render_regular_sidebar(const acecode::TuiState& state,
                                      const std::string& version_str,
                                      const std::string& cwd_display,
                                      int sidebar_width,
                                      int anim_tick) {
    const int content_width = std::max(1, sidebar_width - 2);
    Elements top_rows;
    for (const auto& line : sidebar_title_lines(first_user_message_title(state),
                                                content_width)) {
        top_rows.push_back(text(line) | bold | color(tui::theme().ui.text_primary));
    }

    Element mcp_section = render_mcp_sidebar_section(
        state.mcp_sidebar_servers, content_width, anim_tick);
    if (!state.mcp_sidebar_servers.empty()) {
        top_rows.push_back(text(""));
        top_rows.push_back(std::move(mcp_section));
    }

    const auto file_changes =
        acecode::tui::collect_sidebar_file_changes(state.conversation,
                                                   cwd_display);
    top_rows.push_back(text(""));
    top_rows.push_back(sidebar_section_header(
        "Files Changed", static_cast<int>(file_changes.size())));

    constexpr std::size_t kMaxSidebarFiles = 10;
    const std::size_t shown_files =
        std::min(kMaxSidebarFiles, file_changes.size());
    for (std::size_t i = 0; i < shown_files; ++i) {
        top_rows.push_back(
            render_sidebar_change_row(file_changes[i], content_width));
    }
    if (file_changes.size() > shown_files) {
        top_rows.push_back(
            text("  +" + std::to_string(file_changes.size() - shown_files) +
                 " more") |
            color(tui::theme().ui.text_dim) | dim);
    }

    Elements bottom_rows;
    if (!state.todos.empty()) {
        bottom_rows.push_back(
            acecode::tui::render_todo_checklist_block(state.todos,
                                                      content_width));
        bottom_rows.push_back(text(""));
    }
    const bool show_bash_task =
        state.tool_running && state.tool_progress.tool_name == "bash";
    if (show_bash_task) {
        bottom_rows.push_back(sidebar_section_header("Background Tasks", 1));
        std::string command = state.tool_progress.command_preview.empty()
            ? std::string("bash")
            : state.tool_progress.command_preview;
        bottom_rows.push_back(
            text("  " + truncate_cells_middle_ascii(command,
                                                    std::max(1, content_width - 2))) |
            color(tui::theme().ui.text_muted));
        bottom_rows.push_back(text(""));
    }
    bottom_rows.push_back(paragraph(version_str) | color(tui::theme().ui.text_muted) | dim);
    if (!state.update_notice.empty()) {
        bottom_rows.push_back(paragraph(state.update_notice) |
                              color(tui::theme().semantic.warning));
    }
    if (!state.status_line.empty()) {
        bottom_rows.push_back(paragraph(state.status_line) |
                              color(status_line_color(state.status_line)));
    }
    if (!cwd_display.empty()) {
        bottom_rows.push_back(paragraph(cwd_display) | color(tui::theme().ui.accent_alt) | dim);
    }

    const bool is_light = tui::theme().name == "light";
    Element sidebar = hbox({
        text(" "),
        vbox({
            vbox(std::move(top_rows)),
            filler(),
            vbox(std::move(bottom_rows)),
        }) | flex,
        text(" "),
    }) | size(WIDTH, EQUAL, sidebar_width) |
       bgcolor(is_light ? Color::RGB(240, 240, 242) : Color::RGB(18, 18, 20));
    return acecode::tui::non_selectable(std::move(sidebar));
}

static Element render_tool_result_lines_preserving_breaks(
    const std::string& display_content) {
    Elements lines;
    size_t pos = 0;
    while (pos <= display_content.size()) {
        const size_t nl = display_content.find('\n', pos);
        const std::string line = (nl == std::string::npos)
            ? display_content.substr(pos)
            : display_content.substr(pos, nl - pos);
        Element line_el = line.empty() ? text(" ") : paragraph(line);
        lines.push_back(line_el | color(tui::theme().ui.text_muted) | dim);
        if (nl == std::string::npos) break;
        pos = nl + 1;
    }
    return vbox(std::move(lines));
}


bool is_space_glyph(const std::string& glyph) {
    return glyph == " " || glyph == "\t";
}

bool is_narrow_glyph(const std::string& glyph) {
    return ftxui::string_width(glyph) == 1;
}

bool is_opening_cjk_punctuation(const std::string& glyph) {
    static constexpr std::array<std::string_view, 8> kOpening = {
        "（", "《", "「", "【", "‘", "“", "〈", "『"
    };
    for (const auto& candidate : kOpening) {
        if (glyph == candidate) {
            return true;
        }
    }
    return false;
}

bool is_closing_cjk_punctuation(const std::string& glyph) {
    static constexpr std::array<std::string_view, 15> kClosing = {
        "，", "。", "！", "？", "；", "：", "、", "）",
        "》", "」", "】", "’", "”", "〉", "』"
    };
    for (const auto& candidate : kClosing) {
        if (glyph == candidate) {
            return true;
        }
    }
    return false;
}

void flush_ascii_run(std::string* ascii_run,
                     std::string* pending_prefix,
                     std::vector<std::string>* output) {
    if (ascii_run->empty()) {
        return;
    }

    std::string token = std::move(*ascii_run);
    ascii_run->clear();
    if (!pending_prefix->empty()) {
        token = std::move(*pending_prefix) + token;
        pending_prefix->clear();
    }
    output->push_back(std::move(token));
}

std::vector<std::string> tokenize_wrapped_input(const std::string& text) {
    std::vector<std::string> tokens;
    std::string ascii_run;
    std::string pending_prefix;

    for (const auto& glyph : ftxui::Utf8ToGlyphs(text)) {
        if (glyph.empty()) {
            continue;
        }

        if (is_space_glyph(glyph)) {
            flush_ascii_run(&ascii_run, &pending_prefix, &tokens);
            if (!tokens.empty()) {
                tokens.back() += " ";
            }
            continue;
        }

        if (is_opening_cjk_punctuation(glyph)) {
            flush_ascii_run(&ascii_run, &pending_prefix, &tokens);
            pending_prefix += glyph;
            continue;
        }

        if (is_closing_cjk_punctuation(glyph)) {
            flush_ascii_run(&ascii_run, &pending_prefix, &tokens);
            if (!tokens.empty()) {
                tokens.back() += glyph;
            } else if (!pending_prefix.empty()) {
                pending_prefix += glyph;
            } else {
                tokens.push_back(glyph);
            }
            continue;
        }

        if (is_narrow_glyph(glyph)) {
            ascii_run += glyph;
            continue;
        }

        flush_ascii_run(&ascii_run, &pending_prefix, &tokens);
        std::string token = glyph;
        if (!pending_prefix.empty()) {
            token = std::move(pending_prefix) + token;
            pending_prefix.clear();
        }
        tokens.push_back(std::move(token));
    }

    flush_ascii_run(&ascii_run, &pending_prefix, &tokens);
    if (!pending_prefix.empty()) {
        if (!tokens.empty()) {
            tokens.back() += pending_prefix;
        } else {
            tokens.push_back(std::move(pending_prefix));
        }
    }

    return tokens;
}

Element render_wrapped_input_text(const std::string& input_value, size_t cursor_bytes) {
    if (cursor_bytes > input_value.size()) cursor_bytes = input_value.size();

    // Split input into head/cursor_glyph/tail so the caret block can be drawn
    // over the glyph under the caret (or a space when the caret sits at end).
    std::string head = input_value.substr(0, cursor_bytes);
    std::string cursor_glyph;
    std::string tail;
    if (cursor_bytes < input_value.size()) {
        size_t next = cursor_bytes + 1;
        while (next < input_value.size() &&
               (static_cast<unsigned char>(input_value[next]) & 0xC0) == 0x80) {
            next++;
        }
        cursor_glyph = input_value.substr(cursor_bytes, next - cursor_bytes);
        tail = input_value.substr(next);
    }

    auto tokens_head = tokenize_wrapped_input(head);
    auto tokens_tail = tokenize_wrapped_input(tail);

    auto cursor_elem = ftxui::text(cursor_glyph.empty() ? std::string(" ") : cursor_glyph)
                       | focusCursorBlock;

    if (tokens_head.empty() && tokens_tail.empty()) {
        return cursor_elem;
    }

    Elements parts;
    parts.reserve(tokens_head.size() + tokens_tail.size() + 1);

    // Emit all but the last head token as standalone flex items.
    for (size_t i = 0; i + 1 < tokens_head.size(); ++i) {
        parts.push_back(ftxui::text(std::move(tokens_head[i])));
    }

    // Fuse (last_head_token, cursor_elem, first_tail_token) into one hbox so
    // the caret never lands at a natural wrap boundary.
    Elements compound;
    if (!tokens_head.empty()) {
        compound.push_back(ftxui::text(std::move(tokens_head.back())));
    }
    compound.push_back(cursor_elem);
    size_t tail_start = 0;
    if (!tokens_tail.empty()) {
        compound.push_back(ftxui::text(std::move(tokens_tail[0])));
        tail_start = 1;
    }
    parts.push_back(hbox(std::move(compound)));

    for (size_t i = tail_start; i < tokens_tail.size(); ++i) {
        parts.push_back(ftxui::text(std::move(tokens_tail[i])));
    }

    static const auto config = FlexboxConfig().SetGap(0, 0);
    return flexbox(std::move(parts), config);
}

}  // namespace

// ---- Get current working directory ----
static std::string get_cwd() {
#ifdef _WIN32
    char buf[MAX_PATH];
    if (_getcwd(buf, sizeof(buf))) return std::string(buf);
#else
    char buf[4096];
    if (getcwd(buf, sizeof(buf))) return std::string(buf);
#endif
    return ".";
}

static std::string get_executable_dir_from_argv(int argc, char* argv[]) {
    if (argc <= 0 || !argv[0]) return "";
    std::error_code ec;
    std::filesystem::path exe(argv[0]);
    std::filesystem::path abs = std::filesystem::weakly_canonical(exe, ec);
    if (!ec) return abs.parent_path().string();
    return exe.parent_path().string();
}

static void seed_default_skills_if_first_initialization(const std::string& argv0_dir) {
    bool first_initialization = acecode::consume_acecode_home_created_by_process();
    auto result = acecode::install_default_global_skills_on_first_initialization(
        std::filesystem::path(acecode::get_acecode_dir()),
        argv0_dir,
        first_initialization);
    if (!result.attempted) return;

    size_t installed = 0;
    size_t skipped = 0;
    size_t errors = 0;
    for (const auto& outcome : result.outcomes) {
        if (outcome.result == "installed") ++installed;
        else if (outcome.result == "skipped") ++skipped;
        else ++errors;
    }
    if (!result.error.empty()) {
        LOG_WARN("[skills] Default skill seeding issue: " + result.error);
    }
    LOG_INFO("[skills] Default skill seeding attempted: installed=" +
             std::to_string(installed) + " skipped=" + std::to_string(skipped) +
             " errors=" + std::to_string(errors));
}

static void write_terminal_control_sequence(std::string_view seq) {
#ifdef _WIN32
    auto stdout_handle = GetStdHandle(STD_OUTPUT_HANDLE);
    DWORD out_mode = 0;
    const bool restore_mode =
        stdout_handle != INVALID_HANDLE_VALUE &&
        GetConsoleMode(stdout_handle, &out_mode);
    if (!restore_mode) {
        return;
    }
    constexpr DWORD enable_virtual_terminal_processing = 0x0004;
    constexpr DWORD disable_newline_auto_return = 0x0008;
    SetConsoleMode(stdout_handle,
                   out_mode | enable_virtual_terminal_processing |
                       disable_newline_auto_return);
#endif

    std::cout.write(seq.data(), static_cast<std::streamsize>(seq.size()));
    std::cout.flush();

#ifdef _WIN32
    SetConsoleMode(stdout_handle, out_mode);
#endif
}

static void set_ftxui_full_repaint_mode(bool enabled) {
#ifdef _WIN32
    _putenv_s("ACECODE_FTXUI_FULL_REPAINT", enabled ? "1" : "0");
#else
    if (enabled) {
        setenv("ACECODE_FTXUI_FULL_REPAINT", "1", 1);
    } else {
        unsetenv("ACECODE_FTXUI_FULL_REPAINT");
    }
#endif
}

// ---- Reset terminal cursor visibility on exit ----
static void reset_cursor() {
    // DECTCEM: show cursor (ESC [ ? 25 h)
    write_terminal_control_sequence("\033[?25h");
}

static void flush_terminal_input_buffer() {
#ifdef _WIN32
    auto stdin_handle = GetStdHandle(STD_INPUT_HANDLE);
    if (stdin_handle == INVALID_HANDLE_VALUE) {
        return;
    }
    FlushConsoleInputBuffer(stdin_handle);
#else
    if (isatty(STDIN_FILENO)) {
        tcflush(STDIN_FILENO, TCIFLUSH);
    }
#endif
}

#ifndef ACECODE_TUI_INPUT_TRACE
#define ACECODE_TUI_INPUT_TRACE 0
#endif

#if ACECODE_TUI_INPUT_TRACE
static std::string box_for_log(const Box& box) {
    return "[" + std::to_string(box.x_min) + "," +
           std::to_string(box.y_min) + "]-[" +
           std::to_string(box.x_max) + "," +
           std::to_string(box.y_max) + "]";
}

static std::string event_for_log(const Event& event) {
    if (event.is_character()) {
        return "Event::Character(bytes=" +
               std::to_string(event.character().size()) + ")";
    }
    return event.DebugString();
}

static std::string drag_phase_for_log(acecode::drag_scroll::Phase phase) {
    switch (phase) {
    case acecode::drag_scroll::Phase::Idle:
        return "Idle";
    case acecode::drag_scroll::Phase::Dragging:
        return "Dragging";
    case acecode::drag_scroll::Phase::ScrollingUp:
        return "ScrollingUp";
    case acecode::drag_scroll::Phase::ScrollingDown:
        return "ScrollingDown";
    }
    return "?";
}

static std::string scrollbar_geometry_for_log(
    const acecode::tui::ChatScrollbarThumbGeometry& geometry) {
    return "{max_top=" + std::to_string(geometry.max_top_row) +
           " range2x=" + std::to_string(geometry.scroll_range_2x) +
           " thumb_size2x=" + std::to_string(geometry.thumb_size_2x) +
           " thumb_top2x=" + std::to_string(geometry.thumb_top_2x) + "}";
}
#endif

// ---- Session finalization on exit ----
static SessionManager* g_session_manager = nullptr;

// Active FTXUI screen, used by signal / console-ctrl handlers to trigger a
// graceful Loop exit. Must be cleared before ScreenInteractive is destroyed
// so handlers can't dereference a dead object.
// App::Exit() is thread-safe (posts a task internally — see app.cpp:1063).
static std::atomic<ftxui::ScreenInteractive*> g_active_screen{nullptr};

static void finalize_session_atexit() {
    if (g_session_manager) {
        g_session_manager->finalize();
        auto sid = g_session_manager->current_session_id();
        if (!sid.empty()) {
            std::cerr << "\nacecode: session " << sid
                      << " saved. Resume with: acecode --resume " << sid << std::endl;
        }
    }
    // Best-effort: hand the window title back to the parent shell. Not
    // strictly async-signal-safe but consistent with the existing finalize
    // path which already uses iostreams.
    clear_terminal_title();
}

#ifdef _WIN32
static BOOL WINAPI console_ctrl_handler(DWORD ctrl_type) {
    // Normal Ctrl+C is handled through stdin once ENABLE_PROCESSED_INPUT is
    // cleared after FTXUI installs its terminal mode. This handler remains as
    // a fallback for hosts that still deliver CTRL_C_EVENT, and for
    // Ctrl+Break/close events where graceful shutdown is more important than
    // prompting.
    auto* s = g_active_screen.load(std::memory_order_acquire);
    if (ctrl_type == CTRL_C_EVENT) {
        if (s) {
            s->PostEvent(ftxui::Event::CtrlC);
            return TRUE;
        }
        finalize_session_atexit();
        return FALSE;
    }
    if (ctrl_type == CTRL_BREAK_EVENT || ctrl_type == CTRL_CLOSE_EVENT) {
        // Break / 关窗:明确退出意图,直接走 FTXUI 优雅退出 —— Loop 返回后
        // ScreenInteractive 析构跑 on_exit_functions,把 alt-screen /
        // mouse tracking / Windows console mode 还原回去。返回 FALSE 会让
        // 默认 handler TerminateProcess(),终端会留在 mouse-tracking 开
        // 的状态,父 shell 收到鼠标事件原样喷成乱码字节。
        if (s) {
            s->Exit();
            return TRUE;
        }
        finalize_session_atexit();
        return FALSE;
    }
    return FALSE;
}

static void prepare_windows_ctrl_c_handling_after_ftxui_install() {
    auto stdin_handle = GetStdHandle(STD_INPUT_HANDLE);
    DWORD in_mode = 0;
    if (stdin_handle != INVALID_HANDLE_VALUE &&
        GetConsoleMode(stdin_handle, &in_mode)) {
        // FTXUI preserves ENABLE_PROCESSED_INPUT from the original console
        // mode. When it stays enabled, Windows turns Ctrl+C into a console
        // control event instead of a stdin byte, and FTXUI's SIGINT handler can
        // exit before our Event::CtrlC branch can handle double-press exit.
        SetConsoleMode(stdin_handle, in_mode & ~ENABLE_PROCESSED_INPUT);
    }

    // Re-register after FTXUI's Loop/PreMain installs its own signal handling
    // so this handler gets first chance at CTRL_BREAK_EVENT / CTRL_CLOSE_EVENT
    // and any CTRL_C_EVENT fallback.
    SetConsoleCtrlHandler(console_ctrl_handler, FALSE);
    SetConsoleCtrlHandler(console_ctrl_handler, TRUE);
}
#else
#include <csignal>
static void signal_handler(int /*sig*/) {
    // FTXUI overrides SIGINT/SIGTERM during Loop() (app.cpp:575) so this only
    // fires before Loop starts or after it returns — terminal isn't in the
    // raw/alt-screen state yet, so _exit is safe.
    finalize_session_atexit();
    _exit(1);
}
#endif

#ifdef _WIN32
static int max_int(int a, int b) {
    return a > b ? a : b;
}

static std::string ptr_to_hex(const void* ptr) {
    std::ostringstream oss;
    oss << "0x" << std::hex << reinterpret_cast<uintptr_t>(ptr);
    return oss.str();
}

static std::string dword_to_hex(DWORD value) {
    std::ostringstream oss;
    oss << "0x" << std::hex << value;
    return oss.str();
}

static int clamp_int(int value, int low, int high) {
    if (value < low) {
        return low;
    }
    if (value > high) {
        return high;
    }
    return value;
}

static int display_width_utf8(const std::string& text) {
    return max_int(0, ftxui::string_width(text));
}

static HWND get_ime_target_window(HWND fallback_hwnd) {
    HWND target = GetForegroundWindow();
    if (!target) {
        LOG_DEBUG("IME: GetForegroundWindow returned null, fallback=" + ptr_to_hex(fallback_hwnd));
        return fallback_hwnd;
    }

    LOG_DEBUG("IME: foreground window=" + ptr_to_hex(target));

    GUITHREADINFO gui_thread_info{};
    gui_thread_info.cbSize = sizeof(gui_thread_info);

    DWORD thread_id = GetWindowThreadProcessId(target, nullptr);
    if (thread_id != 0 && GetGUIThreadInfo(thread_id, &gui_thread_info) && gui_thread_info.hwndFocus) {
        LOG_DEBUG("IME: GUI thread focus window=" + ptr_to_hex(gui_thread_info.hwndFocus) +
                  ", active=" + ptr_to_hex(gui_thread_info.hwndActive) +
                  ", capture=" + ptr_to_hex(gui_thread_info.hwndCapture));
        return gui_thread_info.hwndFocus;
    }

    LOG_DEBUG("IME: GetGUIThreadInfo unavailable, thread_id=" + std::to_string(thread_id) +
              ", last_error=" + dword_to_hex(GetLastError()) +
              ", using foreground window");

    return target;
}

static void update_ime_composition_window(const std::string& input_text,
                                          bool show_bottom_bar,
                                          bool confirm_pending,
                                          const std::string& confirm_tool_name) {
    HWND hwnd = GetConsoleWindow();
    if (!hwnd) {
        LOG_WARN("IME: GetConsoleWindow returned null");
        return;
    }

    HANDLE hconsole = GetStdHandle(STD_OUTPUT_HANDLE);
    if (hconsole == INVALID_HANDLE_VALUE) {
        LOG_WARN("IME: GetStdHandle(STD_OUTPUT_HANDLE) failed, last_error=" + dword_to_hex(GetLastError()));
        return;
    }

    CONSOLE_SCREEN_BUFFER_INFO csbi{};
    if (!GetConsoleScreenBufferInfo(hconsole, &csbi)) {
        LOG_WARN("IME: GetConsoleScreenBufferInfo failed, last_error=" + dword_to_hex(GetLastError()));
        return;
    }

    const int visible_cols = csbi.srWindow.Right - csbi.srWindow.Left + 1;
    const int visible_rows = csbi.srWindow.Bottom - csbi.srWindow.Top + 1;
    if (visible_cols <= 0 || visible_rows <= 0) {
        LOG_WARN("IME: invalid visible size, cols=" + std::to_string(visible_cols) +
                 ", rows=" + std::to_string(visible_rows));
        return;
    }

    // GetClientRect(GetConsoleWindow()) 在 Windows Terminal / VS 集成终端 / ConPTY 下
    // 经常拿到的是一个伪控制台窗口，client rect 可能恒为 0。
    // 这里优先使用控制台字体尺寸来计算单元格像素大小，不依赖 client rect。
    int cell_width = 0;
    int cell_height = 0;

    CONSOLE_FONT_INFOEX cfi{};
    cfi.cbSize = sizeof(cfi);
    if (GetCurrentConsoleFontEx(hconsole, FALSE, &cfi)) {
        cell_width = max_int(1, static_cast<int>(cfi.dwFontSize.X));
        cell_height = max_int(1, static_cast<int>(cfi.dwFontSize.Y));
        LOG_DEBUG("IME: font metrics width=" + std::to_string(cell_width) +
                  ", height=" + std::to_string(cell_height));
    } else {
        RECT client{};
        if (!GetClientRect(hwnd, &client)) {
            LOG_WARN("IME: GetCurrentConsoleFontEx and GetClientRect both failed, font_error=" +
                     dword_to_hex(GetLastError()));
            return;
        }

        const int client_width = client.right - client.left;
        const int client_height = client.bottom - client.top;
        if (client_width <= 0 || client_height <= 0) {
            LOG_WARN("IME: invalid client size, width=" + std::to_string(client_width) +
                     ", height=" + std::to_string(client_height));
            return;
        }

        cell_width = max_int(1, client_width / visible_cols);
        cell_height = max_int(1, client_height / visible_rows);
        LOG_DEBUG("IME: fallback client metrics width=" + std::to_string(cell_width) +
                  ", height=" + std::to_string(cell_height));
    }

    const int border_padding = 2;
    const int prefix_width = confirm_pending
        ? display_width_utf8(" [" + confirm_tool_name + "] ") + display_width_utf8("yes / always / no: ")
        : display_width_utf8(" > ");
    const int available_cols = max_int(1, visible_cols - border_padding - prefix_width);

    const int input_width = display_width_utf8(input_text);
    const int wrapped_col = input_width % available_cols;
    const int wrapped_row = input_width / available_cols;

    const int prompt_bottom_row = max_int(0, visible_rows - 2 - (show_bottom_bar ? 1 : 0));
    const int caret_col = clamp_int(1 + prefix_width + wrapped_col, 0, visible_cols - 1);
    const int caret_row = clamp_int(prompt_bottom_row + wrapped_row, 0, visible_rows - 1);

    LOG_DEBUG("IME: input='" + log_truncate(input_text, 120) +
              "', confirm_pending=" + std::string(confirm_pending ? "true" : "false") +
              ", show_bottom_bar=" + std::string(show_bottom_bar ? "true" : "false") +
              ", console_hwnd=" + ptr_to_hex(hwnd) +
              ", visible_cols=" + std::to_string(visible_cols) +
              ", visible_rows=" + std::to_string(visible_rows) +
              ", prefix_width=" + std::to_string(prefix_width) +
              ", available_cols=" + std::to_string(available_cols) +
              ", input_width=" + std::to_string(input_width) +
              ", wrapped_col=" + std::to_string(wrapped_col) +
              ", wrapped_row=" + std::to_string(wrapped_row) +
              ", caret_col=" + std::to_string(caret_col) +
              ", caret_row=" + std::to_string(caret_row) +
              ", pixel_x=" + std::to_string(caret_col * cell_width) +
              ", pixel_y=" + std::to_string(caret_row * cell_height));

    COMPOSITIONFORM composition{};
    composition.dwStyle = CFS_FORCE_POSITION;
    composition.ptCurrentPos.x = caret_col * cell_width;
    composition.ptCurrentPos.y = caret_row * cell_height;

    CANDIDATEFORM candidate{};
    candidate.dwIndex = 0;
    candidate.dwStyle = CFS_CANDIDATEPOS;
    candidate.ptCurrentPos.x = composition.ptCurrentPos.x;
    candidate.ptCurrentPos.y = composition.ptCurrentPos.y + cell_height;

    HWND ime_target = get_ime_target_window(hwnd);
    HIMC himc = ImmGetContext(ime_target);
    if (himc) {
        const BOOL composition_ok = ImmSetCompositionWindow(himc, &composition);
        const DWORD composition_error = GetLastError();
        const BOOL candidate_ok = ImmSetCandidateWindow(himc, &candidate);
        const DWORD candidate_error = GetLastError();
        LOG_DEBUG("IME: ImmGetContext success, target=" + ptr_to_hex(ime_target) +
                  ", himc=" + ptr_to_hex(himc) +
                  ", ImmSetCompositionWindow=" + std::to_string(composition_ok) +
                  ", comp_error=" + dword_to_hex(composition_error) +
                  ", ImmSetCandidateWindow=" + std::to_string(candidate_ok) +
                  ", cand_error=" + dword_to_hex(candidate_error));
        ImmReleaseContext(ime_target, himc);
        return;
    }

    LOG_WARN("IME: ImmGetContext returned null, target=" + ptr_to_hex(ime_target) +
             ", last_error=" + dword_to_hex(GetLastError()));

    HWND default_ime_window = ImmGetDefaultIMEWnd(ime_target);
    if (!default_ime_window) {
        LOG_WARN("IME: ImmGetDefaultIMEWnd returned null for target=" + ptr_to_hex(ime_target));
        return;
    }

    const LRESULT composition_result = SendMessage(default_ime_window,
                                                   WM_IME_CONTROL,
                                                   IMC_SETCOMPOSITIONWINDOW,
                                                   reinterpret_cast<LPARAM>(&composition));
    const DWORD composition_send_error = GetLastError();
    const LRESULT candidate_result = SendMessage(default_ime_window,
                                                 WM_IME_CONTROL,
                                                 IMC_SETCANDIDATEPOS,
                                                 reinterpret_cast<LPARAM>(&candidate));
    const DWORD candidate_send_error = GetLastError();
    LOG_DEBUG("IME: default IME window=" + ptr_to_hex(default_ime_window) +
              ", SendMessage(comp)=" + std::to_string(static_cast<long long>(composition_result)) +
              ", comp_error=" + dword_to_hex(composition_send_error) +
              ", SendMessage(cand)=" + std::to_string(static_cast<long long>(candidate_result)) +
              ", cand_error=" + dword_to_hex(candidate_send_error));
}
#endif

// ---- Shared TUI state ----
// TuiState is defined in src/tui_state.hpp
#include "tui_state.hpp"
using acecode::TuiState;

static void set_transient_status_line_locked(TuiState& state,
                                             const std::string& message) {
    if (state.status_line_clear_at.time_since_epoch().count() == 0) {
        state.status_line_saved = state.status_line;
    }
    state.status_line = message;
    state.status_line_clear_at =
        std::chrono::steady_clock::now() + std::chrono::milliseconds(2000);
}

static std::string clipboard_paste_status_message(
    acecode::ClipboardTextReadResult::Status status) {
    using Status = acecode::ClipboardTextReadResult::Status;
    switch (status) {
        case Status::Empty:
            return "Clipboard is empty";
        case Status::TooLarge:
            return "Clipboard text too large (max " +
                   std::to_string(acecode::kMaxClipboardTextBytes / (1024 * 1024)) +
                   " MB)";
        case Status::Unavailable:
#ifdef _WIN32
            return "Clipboard paste unavailable";
#elif defined(__APPLE__)
            return "Clipboard paste unavailable (pbpaste failed)";
#else
            return "Clipboard paste unavailable (install wl-clipboard, xclip, or xsel)";
#endif
        case Status::Success:
        default:
            return "";
    }
}

static std::string clipboard_image_status_message(
    acecode::ClipboardImageReadResult::Status status) {
    using Status = acecode::ClipboardImageReadResult::Status;
    switch (status) {
        case Status::Empty:
            return "Clipboard has no image";
        case Status::TooLarge:
            return "Clipboard image too large (max " +
                   std::to_string(acecode::kMaxClipboardImageBytes / (1024 * 1024)) +
                   " MB)";
        case Status::Unavailable:
#ifdef _WIN32
            return "Clipboard image paste unavailable";
#elif defined(__APPLE__)
            return "Clipboard image paste unavailable (install pngpaste)";
#else
            return "Clipboard image paste unavailable (install wl-clipboard or xclip)";
#endif
        case Status::Success:
        default:
            return "";
    }
}

static bool is_alt_v_event(const Event& event) {
    return event == Event::Special("\x1Bv") ||
           event == Event::Special("\x1BV");
}

static std::string attachment_name_from_json(const nlohmann::json& attachment) {
    return attachment.value("name", std::string{"attachment"});
}

static std::string display_prompt_with_attachments(
    const std::string& prompt,
    const std::vector<nlohmann::json>& attachments) {
    std::string display = prompt;
    for (const auto& attachment : attachments) {
        if (!display.empty()) display.push_back('\n');
        const std::string kind = attachment.value("kind", std::string{"file"});
        display += "[";
        display += (kind == "image") ? "Image: " : "File: ";
        display += attachment_name_from_json(attachment);
        display += "]";
    }
    return display;
}

static UserInput build_user_input_with_attachments(
    const std::string& prompt,
    const std::string& display_text,
    const std::vector<nlohmann::json>& attachments) {
    UserInput input;
    input.text = prompt;
    input.display_text = display_text;
    input.content_parts = nlohmann::json::array();
    if (!prompt.empty()) {
        input.content_parts.push_back({{"type", "text"}, {"text", prompt}});
    }
    nlohmann::json attachment_meta = nlohmann::json::array();
    for (const auto& attachment : attachments) {
        // 按 MIME + 文件名重新分类(route-attachments-by-capability 1.7),不直接信
        // 持久化的 kind:SVG 等非视觉媒体会被归为 file,避免误走图片 part。
        const std::string part_kind = attachment_kind_for_mime(
            attachment.value("mime_type", std::string{}),
            attachment.value("name", std::string{}));
        input.content_parts.push_back({
            {"type", part_kind == "image" ? "image" : "file"},
            {"attachment", attachment},
        });
        attachment_meta.push_back(attachment);
    }
    if (attachment_meta.empty()) {
        input.content_parts = nlohmann::json::array();
    } else {
        input.metadata["attachments"] = std::move(attachment_meta);
    }
    return input;
}

static std::string clipboard_copy_status_message(
    acecode::ClipboardTextWriteResult::Status status) {
    using Status = acecode::ClipboardTextWriteResult::Status;
    switch (status) {
        case Status::TooLarge:
            return "Clipboard text too large (max " +
                   std::to_string(acecode::kMaxClipboardTextBytes / (1024 * 1024)) +
                   " MB)";
        case Status::Unavailable:
#ifdef _WIN32
            return "Clipboard copy unavailable";
#elif defined(__APPLE__)
            return "Clipboard copy unavailable (pbcopy failed)";
#else
            return "Clipboard copy unavailable (install wl-clipboard, xclip, or xsel)";
#endif
        case Status::Success:
        default:
            return "";
    }
}

struct CliOptions {
    bool dangerous_mode = false;
    bool run_configure_cmd = false;
    bool validate_models_registry_cmd = false;
    bool resume_latest = false;
    bool force_alt_screen = false;
    std::string resume_session_id;
};

static int run_interactive_app(const CliOptions& cli,
                               const std::string& argv0_dir);

static void configure_process_environment() {
#ifdef _WIN32
    SetConsoleOutputCP(CP_UTF8);
    SetConsoleCP(CP_UTF8);

    // SECURITY: Prevent Windows from executing commands from current directory.
    // Without this, a malicious exe placed in cwd could hijack system commands.
    SetEnvironmentVariableA("NoDefaultCurrentDirectoryInExePath", "1");
#endif
}

static std::vector<std::string> argv_tail(int argc, char* argv[], int start) {
    std::vector<std::string> tokens;
    for (int i = start; i < argc; ++i) {
        tokens.emplace_back(argv[i]);
    }
    return tokens;
}

static std::string executable_path_from_argv(int argc, char* argv[]) {
    return (argc > 0 && argv[0]) ? std::string(argv[0]) : std::string();
}

static bool is_version_command_arg(const std::string& arg) {
    return arg == "version" || arg == "-version" || arg == "--version" ||
           arg == "/version";
}

static std::optional<int> dispatch_non_tui_command(int argc, char* argv[]) {
    const std::string exe_path = executable_path_from_argv(argc, argv);

    if (argc >= 2 && is_version_command_arg(argv[1] ? std::string(argv[1]) : std::string())) {
        std::cout << "acecode v" ACECODE_VERSION << "\n";
        return 0;
    }

    if (argc >= 2 && (std::string(argv[1]) == "upgrade" ||
                      std::string(argv[1]) == "update")) {
        bool force_update = false;
        std::optional<std::string> server_override;
        for (int i = 2; i < argc; ++i) {
            const std::string arg = argv[i] ? std::string(argv[i]) : std::string();
            if (arg == "--force") {
                force_update = true;
                continue;
            }
            constexpr const char* kServerPrefix = "--server=";
            if (arg.rfind(kServerPrefix, 0) == 0) {
                server_override = arg.substr(std::char_traits<char>::length(kServerPrefix));
                continue;
            }
            if (arg == "--server") {
                std::cerr << "acecode " << argv[1] << ": missing value for --server\n"
                          << "usage: acecode " << argv[1]
                          << " [--force] [--server=<url>]\n";
                return 64;
            }
            std::cerr << "acecode " << argv[1] << ": unknown option: " << arg << "\n"
                      << "usage: acecode " << argv[1]
                      << " [--force] [--server=<url>]\n";
            return 64;
        }
        AppConfig config = load_config();
        if (server_override.has_value()) {
            std::string server_error;
            if (!acecode::upgrade::apply_upgrade_server_override(
                    config, *server_override, &server_error)) {
                std::cerr << "acecode " << argv[1] << ": " << server_error << "\n"
                          << "usage: acecode " << argv[1]
                          << " [--force] [--server=<url>]\n";
                return 64;
            }
            try {
                save_config(config);
            } catch (const std::exception& e) {
                std::cerr << "acecode " << argv[1]
                          << ": failed to save update server: " << e.what() << "\n";
                return 1;
            }
        }
        return acecode::upgrade::run_upgrade_command(
            config, exe_path, ACECODE_VERSION, std::cout, std::cerr,
            force_update);
    }

    if (argc >= 2 && std::string(argv[1]) == "--apply-update") {
        return acecode::upgrade::run_apply_update_command(
            argv_tail(argc, argv, 2), std::cout, std::cerr,
            acecode::upgrade::current_target());
    }

    if (argc >= 2 && std::string(argv[1]) == "daemon") {
        return acecode::daemon::cli::run(argv_tail(argc, argv, 2), exe_path);
    }

    if (argc >= 2 && std::string(argv[1]) == "service") {
#ifdef _WIN32
        return acecode::daemon::service_win::run_cli(argv_tail(argc, argv, 2),
                                                     exe_path);
#else
        std::cerr << "acecode: native `service` subcommand is Windows-only;\n"
                     "         on Linux/macOS use `acecode daemon --foreground`\n"
                     "         under systemd / launchd (see README for sample units).\n";
        return 65;
#endif
    }

    for (int i = 1; i < argc; ++i) {
        if (std::string(argv[i]) == "--service-main") {
#ifdef _WIN32
            return acecode::daemon::service_win::run_service_main_dispatcher();
#else
            std::cerr << "--service-main is Windows-only\n";
            return 64;
#endif
        }
    }

#ifdef _WIN32
    if (argc == 1) {
        AppConfig cfg_probe = load_config();
        if (cfg_probe.daemon.auto_start_on_double_click) {
            DWORD procs[2] = {0, 0};
            DWORD n = ::GetConsoleProcessList(procs, 2);
            if (n == 1) {
                std::vector<std::string> tokens = {"start"};
                return acecode::daemon::cli::run(tokens, exe_path);
            }
        }
    }
#endif

    return std::nullopt;
}

static CliOptions parse_cli_options(int argc, char* argv[]) {
    CliOptions cli;
    for (int i = 1; i < argc; ++i) {
        std::string arg(argv[i]);
        if (arg == "-dangerous" || arg == "--dangerous" ||
            arg == "-yolo" || arg == "--yolo") {
            cli.dangerous_mode = true;
        } else if (arg == "configure") {
            cli.run_configure_cmd = true;
        } else if (arg == "--validate-models-registry") {
            cli.validate_models_registry_cmd = true;
        } else if (arg == "-alt-screen" || arg == "--alt-screen") {
            cli.force_alt_screen = true;
        } else if (arg == "--resume") {
            if (i + 1 < argc && argv[i + 1][0] != '-') {
                cli.resume_session_id = argv[++i];
            } else {
                cli.resume_latest = true;
            }
        }
    }
    return cli;
}

static int validate_models_registry_command(const std::string& argv0_dir) {
    AppConfig config = load_config();
    seed_default_skills_if_first_initialization(argv0_dir);
    initialize_registry(config, argv0_dir);
    const auto& src = current_registry_source();
    auto registry = current_registry();
    if (!registry || registry->empty()) {
        std::cerr << "models.dev registry not found or empty\n";
        return 1;
    }
    size_t actual_models = 0;
    for (auto it = registry->begin(); it != registry->end(); ++it) {
        if (!it->is_object()) continue;
        auto m = it->find("models");
        if (m == it->end()) continue;
        if (m->is_object()) actual_models += m->size();
        else if (m->is_array()) actual_models += m->size();
    }
    std::cout << "models.dev registry OK: " << registry->size() << " providers, "
              << actual_models << " models, source=" << src.path_or_url << "\n";
    if (src.manifest && src.manifest->is_object()) {
        const auto& m = *src.manifest;
        if (m.contains("model_count") && m["model_count"].is_number_integer()) {
            size_t expected = static_cast<size_t>(m["model_count"].get<int>());
            if (expected != actual_models) {
                std::cerr << "MANIFEST.json model_count=" << expected
                          << " disagrees with actual " << actual_models << "\n";
                return 1;
            }
        }
    }
    return 0;
}

static std::optional<int> run_pre_tui_command(const CliOptions& cli,
                                              const std::string& argv0_dir) {
    if (cli.run_configure_cmd) {
        AppConfig config = load_config();
        seed_default_skills_if_first_initialization(argv0_dir);
        initialize_registry(config, argv0_dir);
        return run_configure(config);
    }

    if (cli.validate_models_registry_cmd) {
        return validate_models_registry_command(argv0_dir);
    }

    return std::nullopt;
}

static bool ensure_interactive_terminal() {
    std::atexit(reset_cursor);

#ifdef _WIN32
    bool stdin_is_tty = _isatty(_fileno(stdin));
    bool stdout_is_tty = _isatty(_fileno(stdout));
#else
    bool stdin_is_tty = isatty(fileno(stdin));
    bool stdout_is_tty = isatty(fileno(stdout));
#endif
    if (!stdin_is_tty || !stdout_is_tty) {
        std::cerr << "Error: acecode requires an interactive terminal (stdin and stdout must be a TTY).\n"
                  << "If piping input/output, please run acecode directly in a terminal instead.\n";
        return false;
    }
    return true;
}

static void set_startup_terminal_title() {
#ifdef _WIN32
    SetConsoleTitleA("acecode v" ACECODE_VERSION);
#else
    // xterm-compatible title escape sequence
    std::cout << "\033]0;acecode v" ACECODE_VERSION "\007" << std::flush;
#endif
}

static void initialize_logger_for_working_dir(const std::string& working_dir) {
    Logger::instance().init(working_dir + "/acecode.log");
    Logger::instance().set_level(LogLevel::Dbg);
    LOG_INFO("=== acecode started, cwd=" + working_dir + " ===");
}

static void initialize_proxy_runtime(const AppConfig& config) {
    // 必须在任何 cpr 调用之前完成(下面 initialize_registry 可能触发 models.dev
    // 拉取)。失败也不应阻塞启动 —— ProxyResolver 内部所有探测都是 soft-fail。
    network::proxy_resolver().init(config.network);
    // openspec/changes/proxy-fallback-on-unreachable:启动 TCP probe 检测代理
    // 是否真的在监听,失败时进程级回退直连;所有 cpr 调用站点零变更。
    network::proxy_resolver().probe_and_maybe_fallback();
    auto resolved = network::proxy_resolver().effective("https://example.com");
    std::string banner;
    if (resolved.source == "auto-fallback") {
        auto fb = network::proxy_resolver().fallback_info_snapshot();
        banner = "Proxy: direct (auto-fallback: " + fb.original_url +
                 " from " + fb.original_source + " unreachable)";
    } else {
        std::string url_disp = resolved.url.empty()
                                  ? std::string("direct")
                                  : network::redact_credentials(resolved.url);
        banner = "Proxy: " + url_disp + " (" + resolved.source + ")";
    }
    if (config.network.proxy_insecure_skip_verify) {
        // ANSI red bold — TUI 还没起来,直接打 stderr 让用户立刻看见。
        banner += "  \x1b[1;31m[INSECURE: TLS verification disabled]\x1b[0m";
        LOG_WARN("[proxy] insecure_skip_verify is enabled — TLS chain validation off");
    }
    std::cerr << banner << std::endl;
    LOG_INFO(std::string("[proxy] effective=") +
             (resolved.url.empty() ? "direct" : network::redact_credentials(resolved.url)) +
             " source=" + resolved.source +
             " mode=" + config.network.proxy_mode);
}

static void initialize_models_registry_runtime(const AppConfig& config,
                                               const std::string& argv0_dir) {
    initialize_registry(config, argv0_dir);
    if (config.models_dev.allow_network && !config.models_dev.refresh_on_command_only) {
        std::thread([] {
            refresh_registry_from_network();
        }).detach();
    }
}

static void initialize_web_search_runtime(const AppConfig& config) {
    // Backend router + region detector 单例,异步探测一次后写缓存。失败 / 已有
    // 缓存都不阻塞启动。enabled=false 时仍 init,但下面 register 阶段不挂工具。
    web_search::init(config.web_search);
    web_search::register_default_backends(web_search::runtime().router(),
                                           config.web_search);

    // 启动时先用缓存 region(若有)即时 resolve;无缓存先按 Unknown 走悲观,
    // 再起 detached 线程做实际 HEAD 探测,完成后再 resolve 一次。
    web_search::Region cached = web_search::runtime().detector().cached_region();
    web_search::runtime().router().resolve_active(cached);
    if (cached == web_search::Region::Unknown) {
        std::thread([]{
            auto r = web_search::runtime().detector().detect_now();
            web_search::runtime().router().resolve_active(r);
        }).detach();
    }
}

static std::thread start_tui_update_check(const AppConfig& config,
                                          TuiState& state,
                                          ScreenInteractive& screen) {
    return std::thread([config, &state, &screen] {
        try {
            auto result = acecode::upgrade::check_for_update(config, ACECODE_VERSION);
            if (result.update_available()) {
                std::lock_guard<std::mutex> lk(state.mu);
                state.update_notice = "Update available: v" + result.latest_version +
                                      ". Run acecode update.";
                screen.PostEvent(Event::Custom);
            } else if (result.status != acecode::upgrade::UpdateCheckStatus::UpToDate) {
                LOG_DEBUG(std::string("[upgrade] startup check skipped: ") +
                          acecode::upgrade::update_check_status_name(result.status) +
                          (result.error.empty() ? "" : " (" + result.error + ")"));
            }
        } catch (const std::exception& e) {
            LOG_DEBUG(std::string("[upgrade] startup check failed: ") + e.what());
        } catch (...) {
            LOG_DEBUG("[upgrade] startup check failed with unknown exception");
        }
    });
}

// 实现已抽到 src/skills/skill_init.{hpp,cpp},供 TUI 与 daemon(src/daemon/worker.cpp)
// 共用。下方所有 `initialize_skill_registry(...)` 调用站点经 `using namespace acecode`
// 解析到 `acecode::initialize_skill_registry`。

static MemoryConfig initialize_memory_registry(MemoryRegistry& memory_registry,
                                               const AppConfig& config) {
    // Auto-create ~/.acecode/memory/ if missing; failure disables the memory
    // system for this session without rewriting the user's config.json.
    MemoryConfig runtime_memory_cfg = config.memory;
    std::error_code mkec;
    std::filesystem::create_directories(get_memory_dir(), mkec);
    if (mkec) {
        LOG_ERROR("[memory] failed to create " + get_memory_dir().generic_string() +
                  ": " + mkec.message() + " — memory will be disabled this session");
        runtime_memory_cfg.enabled = false;
    } else if (runtime_memory_cfg.enabled) {
        memory_registry.scan();
    }
    return runtime_memory_cfg;
}

static void initialize_mcp_servers(McpManager& mcp_manager,
                                   const AppConfig& config) {
    const size_t configured = config.mcp_servers.size();
    if (configured == 0) {
        return;
    }

    mcp_manager.connect_all(config);
    LOG_INFO("[mcp] Configured " + std::to_string(configured) +
             " server(s); startup will run in the background");
}

static void restore_input_history(TuiState& state,
                                  const AppConfig& config,
                                  const std::string& working_dir) {
    // Restore per-working-directory input history. Independent of session files so
    // /clear, resume, or deleting a session never blows away the Up/Down queue.
    // 关闭开关时退化为纯内存历史（旧行为）。
    if (!config.input_history.enabled) {
        return;
    }

    std::string ih_path = InputHistoryStore::file_path(
        SessionStorage::get_project_dir(working_dir));
    state.input_history = InputHistoryStore::load(ih_path);
    // 若历史文件条数超过当前上限（用户把 max_entries 调小），保留最近 N 条。
    int cap = config.input_history.max_entries;
    if (cap > 0 && static_cast<int>(state.input_history.size()) > cap) {
        state.input_history.erase(
            state.input_history.begin(),
            state.input_history.begin() +
                (state.input_history.size() - static_cast<size_t>(cap)));
    }
}

static void add_startup_messages(TuiState& state,
                                 bool dangerous_mode,
                                 const McpManager& mcp_manager) {
    // If YOLO mode is forced from CLI, show startup warning. Note: this skips permission
    // confirmations but does NOT suppress AskUserQuestion overlays (those are a
    // legitimate LLM-driven request for input).
    if (dangerous_mode) {
        state.conversation.push_back({"system",
            "[YOLO MODE] All permission checks are bypassed. Use with caution. "
            "(AskUserQuestion overlays are still shown when the model needs input.)",
            false});
    }

    const size_t configured = mcp_manager.configured_server_count();
    if (configured > 0) {
        state.conversation.push_back({"system",
            acecode::mcp_background_start_message(configured),
            false});
    }
}

static void start_mcp_servers_async(McpManager& mcp_manager,
                                    ToolExecutor& tools,
                                    TuiState& state,
                                    ftxui::ScreenInteractive& screen) {
    if (mcp_manager.configured_server_count() == 0) {
        return;
    }

    mcp_manager.set_status_callback([&mcp_manager, &state, &screen](const McpServerInfo& info) {
        auto sidebar_servers = build_mcp_sidebar_servers(mcp_manager);
        auto message = acecode::mcp_status_message(info);
        {
            std::lock_guard<std::mutex> lk(state.mu);
            set_mcp_sidebar_servers_locked(state, std::move(sidebar_servers));
            if (message.has_value()) {
                state.conversation.push_back({"system", *message, false});
            }
        }
        screen.PostEvent(ftxui::Event::Custom);
    });
    mcp_manager.start_async(tools);
}

static void maybe_add_legacy_terminal_hint(
    TuiState& state,
    const AppConfig& config,
    const acecode::TerminalCapabilities& term_caps,
    acecode::tui::ScreenRenderMode render_mode,
    bool force_alt_screen) {
    // 一次性提示:仅在自动探测命中并切换到 alt-screen 时显示一次。
    // CLI 强制 / config "always" / config "never" / 现代终端都不触发。
    bool show_legacy_hint =
        render_mode == acecode::tui::ScreenRenderMode::AltScreen &&
        !force_alt_screen &&
        config.tui.alt_screen_mode == "auto" &&
        !term_caps.source_label.empty() &&
        !acecode::read_state_flag("legacy_terminal_hint_shown");
    if (show_legacy_hint) {
        std::string hint = "提示: 检测到 " + term_caps.source_label +
            ",已启用全屏渲染避免画面跳动。可在 ~/.acecode/config.json 设置 "
            "\"tui\": {\"alt_screen_mode\": \"never\"} 关闭。";
        state.conversation.push_back({"system", hint, false});
        acecode::write_state_flag("legacy_terminal_hint_shown", true);
    }
}

static PermissionMode permission_mode_from_meta_name(std::string mode) {
    if (mode == "acceptEdits") mode = "accept-edits";
    if (mode == "accept-edits") return PermissionMode::AcceptEdits;
    if (mode == "yolo") return PermissionMode::Yolo;
    if (mode == "plan") return PermissionMode::Plan;
    return PermissionMode::Default;
}

static void configure_permissions(PermissionManager& permissions,
                                  bool dangerous_mode,
                                  const std::string& default_permission_mode) {
    permissions.set_mode(permission_mode_from_meta_name(default_permission_mode));
    if (dangerous_mode) {
        permissions.set_dangerous(true);
        permissions.set_mode(PermissionMode::Yolo);
    }

    // Register built-in safety rules (deny writes to sensitive files/dirs)
    permissions.add_rule({"file_write", "*.env", "", RuleAction::Deny, 100});
    permissions.add_rule({"file_edit", "*.env", "", RuleAction::Deny, 100});
    permissions.add_rule({"file_write", ".git/**", "", RuleAction::Deny, 100});
    permissions.add_rule({"file_edit", ".git/**", "", RuleAction::Deny, 100});
    permissions.add_rule({"bash", "", "rm -rf /", RuleAction::Deny, 100});
}

static void register_slash_commands(CommandRegistry& cmd_registry,
                                    SkillRegistry& skill_registry) {
    register_builtin_commands(cmd_registry);
    auto keys = register_skill_commands_tracked(cmd_registry, skill_registry);
    if (!keys.empty()) {
        LOG_INFO("[skills] Registered " + std::to_string(keys.size()) +
                 " skill slash command(s)");
    }
}

static void run_tui_loop(ftxui::ScreenInteractive& screen,
                         const ftxui::Component& renderer) {
#ifdef _WIN32
    // FTXUI applies its console mode inside Loop()/PreMain, so queue this
    // adjustment as the first loop task. From then on Ctrl+C arrives as
    // Event::CtrlC instead of being consumed by the Windows console layer.
    screen.Post(prepare_windows_ctrl_c_handling_after_ftxui_install);
#endif
    // Enable bracketed paste so the terminal frames pasted text with
    // ESC[200~ … ESC[201~. FTXUI exposes those markers as Event::Special, and
    // the paste accumulator in the CatchEvent body intercepts them before
    // normal Return / character handlers run — preventing pasted newlines
    // from accidentally submitting partial prompts.
    flush_terminal_input_buffer();
    write_terminal_control_sequence(acecode::tui::kBracketedPasteEnableSeq);
    screen.Loop(renderer);
    write_terminal_control_sequence(acecode::tui::kBracketedPasteDisableSeq);
    flush_terminal_input_buffer();
}

static void shutdown_after_tui_loop(TuiState& state,
                                    AgentLoop& agent_loop,
                                    McpManager& mcp_manager,
                                    std::atomic<bool>& running,
                                    std::atomic<bool>& agent_aborting,
                                    std::thread& anim_thread,
                                    std::thread& auth_thread,
                                    std::thread& update_check_thread,
                                    SessionManager& session_manager,
                                    const AppConfig& config) {
    g_active_screen.store(nullptr, std::memory_order_release);
#ifdef _WIN32
    SetConsoleCtrlHandler(console_ctrl_handler, FALSE);
#endif

    running = false;

    // 先停 remote-control listener:teardown 期间不再接受 IM 入站,也避免
    // 静态析构阶段才停 Crow/asio 的顺序问题。
    acecode::rc::remote_control_service().stop();

    // Graceful shutdown: abort agent, unblock confirm_cv / ask_cv, then join worker
    agent_aborting = true;
    agent_loop.abort();
    {
        std::lock_guard<std::mutex> lk(state.mu);
        if (state.confirm_pending) {
            state.confirm_pending = false;
            state.confirm_result = PermissionResult::Deny;
            state.confirm_cv.notify_one();
        }
        if (state.ask_pending) {
            // AskUserQuestion 工具线程也在 wait,通知它醒来走拒绝分支。
            // agent_loop.abort() 已经置 abort_flag,工具的 wait 谓词因此成立。
            state.ask_pending = false;
            state.ask_result_ok = false;
            state.ask_scroll_offset = 0;
            state.ask_scroll_total_rows = 0;
            state.ask_scroll_visible_rows = 0;
            state.ask_scrollbar_dragging = false;
            state.ask_scroll_to_focus_requested = false;
            state.ask_cv.notify_one();
        }
    }
    agent_loop.shutdown();

    // Tear down MCP child processes after the agent worker has stopped, so no
    // in-flight tool calls can race with the clients being destroyed.
    mcp_manager.shutdown();

    // Abort and join any in-progress compact thread
    state.compact_abort_requested.store(true);
    if (state.compact_thread.joinable()) {
        state.compact_thread.join();
    }

    if (anim_thread.joinable()) {
        anim_thread.join();
    }

    if (auth_thread.joinable()) {
        auth_thread.join();
    }

    if (update_check_thread.joinable()) {
        update_check_thread.join();
    }

    // Finalize session before exit
    session_manager.finalize();
    session_manager.cleanup_old_sessions(config.max_sessions);

    // Print session ID so user knows how to resume
    auto exit_sid = session_manager.current_session_id();
    g_session_manager = nullptr;
    if (!exit_sid.empty()) {
        std::cerr << "\nacecode: session " << exit_sid
                  << " saved. Resume with: acecode --resume " << exit_sid << std::endl;
    }
}

int main(int argc, char* argv[]) {
    configure_process_environment();

    if (auto exit_code = dispatch_non_tui_command(argc, argv)) {
        return *exit_code;
    }

    std::string argv0_dir = get_executable_dir_from_argv(argc, argv);
    CliOptions cli = parse_cli_options(argc, argv);

    if (auto exit_code = run_pre_tui_command(cli, argv0_dir)) {
        return *exit_code;
    }

    return run_interactive_app(cli, argv0_dir);
}

static int run_interactive_app(const CliOptions& cli,
                               const std::string& argv0_dir) {
    const bool dangerous_mode = cli.dangerous_mode;
    const bool resume_latest = cli.resume_latest;
    const bool force_alt_screen = cli.force_alt_screen;
    const std::string resume_session_id = cli.resume_session_id;

    if (!ensure_interactive_terminal()) {
        return 1;
    }

    set_startup_terminal_title();

    // ---- Record working directory ----
    std::string working_dir = get_cwd();

    // ---- Init logger ----
    initialize_logger_for_working_dir(working_dir);

    acecode::desktop::ensure_workspace_metadata(
        (std::filesystem::path(get_acecode_dir()) / "projects").string(),
        working_dir);

    std::string hook_config_error;
    HookConfig hook_config = load_hook_config(&hook_config_error);
    if (!hook_config_error.empty()) {
        LOG_WARN("[hooks] " + hook_config_error);
    }
    HookManager hook_manager(std::move(hook_config));
    {
        auto payload = build_startup_before_model_load_payload(working_dir);
        hook_manager.dispatch(kHookEventStartupBeforeModelLoad, payload, working_dir);
    }

    // ---- Load config ----
    AppConfig config = load_config();
    {
        std::string trust_error;
        HookTrustStore trust_store =
            load_hook_trust_store_from_path(default_hook_trust_state_path(), &trust_error);
        if (!trust_error.empty()) {
            LOG_WARN("[hooks] " + trust_error);
        }
        HookLoadOptions hook_load;
        hook_load.feature_enabled = config.features.hooks;
        hook_load.cwd = working_dir;
        hook_load.project_trusted = true;
        hook_manager.refresh_registry(load_hook_registry(hook_load, &trust_store));
    }
    seed_default_skills_if_first_initialization(argv0_dir);

    // ---- Init proxy resolver ----
    initialize_proxy_runtime(config);

    // ---- Load bundled models.dev registry (offline-first) ----
    initialize_models_registry_runtime(config, argv0_dir);

    // ---- Resolve effective model + create provider ----
    // 三级回退:default → cwd override → session meta(resume 路径在后面单独应用)。
    // 启动时这里只看前两级;resume 的 meta 应用延到下面读到 meta 之后。
    auto cwd_override = load_cwd_model_override(working_dir);
    ModelProfile effective_entry = resolve_effective_model(config, cwd_override, std::nullopt);
    // ProviderSlot 把 shared_ptr<LlmProvider> 与保护它的 mutex 打包成一个
    // 整体(design D4 / 任务 5)。CommandContext 拿 &provider_slot,/model 走
    // apply_model_to_session 替换 .provider 字段。
    SessionEntry::ProviderSlot provider_slot;
    {
        std::lock_guard<std::mutex> lk(provider_slot.mu);
        provider_slot.provider = create_provider_from_entry(effective_entry, &config);
    }
    auto provider_accessor = [&provider_slot]() -> std::shared_ptr<LlmProvider> {
        std::lock_guard<std::mutex> lk(provider_slot.mu);
        return provider_slot.provider;
    };
    {
        auto p = provider_accessor();
        if (p) {
            config.context_window = resolve_model_context_window(
                config,
                p->name(),
                p->model(),
                config.context_window
            );
        } else {
            LOG_WARN("[main] no configured model provider; starting without an active model");
        }
    }
    {
        auto p = provider_accessor();
        auto payload = build_startup_models_loaded_payload(working_dir, effective_entry, p);
        hook_manager.dispatch(kHookEventStartupModelsLoaded, payload, working_dir);
    }

    // ---- Init web search runtime ----
    initialize_web_search_runtime(config);

    // ---- Setup tools ----
    ToolExecutor tools;
    register_session_builtin_tools(tools, config);

    // ---- Skill registry ----
    SkillRegistry skill_registry;
    initialize_skill_registry(skill_registry, config, working_dir);
    tools.register_tool(create_skills_list_tool(skill_registry, &config));
    tools.register_tool(create_skill_view_tool(skill_registry, &config));

    // ---- Memory registry ----
    MemoryRegistry memory_registry;
    MemoryConfig runtime_memory_cfg = initialize_memory_registry(memory_registry, config);
    tools.register_tool(create_memory_read_tool(memory_registry,
                                                runtime_memory_cfg.max_index_bytes));
    tools.register_tool(create_memory_write_tool(memory_registry));

    // ---- MCP servers ----
    McpManager mcp_manager;
    initialize_mcp_servers(mcp_manager, config);

    // ---- TUI state ----
    TuiState state;
    set_mcp_sidebar_servers_locked(state, build_mcp_sidebar_servers(mcp_manager));
    {
        auto p = provider_accessor();
        state.status_line = p
            ? "[" + p->name() + "] model: " + p->model()
            : "No model configured";
    }

    restore_input_history(state, config, working_dir);

    // Version and working directory strings for TUI header
    std::string version_str = "acecode v" ACECODE_VERSION;
    std::string cwd_display = working_dir;

    add_startup_messages(state, dangerous_mode, mcp_manager);

    // Animation tick for Thinking... indicator
    std::atomic<int> anim_tick{0};
    Box chat_box;
    // draggable-thick-scrollbar: track box for the thick scroll indicator —
    // populated by acecode::tui::thick_vscroll_bar each Render so the mouse
    // handler can hit-test "click on scrollbar" vs "click in chat content".
    Box scrollbar_box;
    // AskUserQuestion overlay owns a separate scrollbar track while active.
    // It must not share hit-testing state with the chat transcript scrollbar.
    Box ask_scrollbar_box;
    Box ask_overlay_box;

    // drag-autoscroll: 每帧渲染时由 reflect 回填每条消息的屏幕 box,
    // 下一帧 (事件线程 / anim_thread) 读这里算每条消息的行数,供
    // scroll_chat_by_lines 做按行粒度的平滑滚动. Renderer 重新构建 element
    // 树时先把上一帧的高度同步到 message_line_counts, 再把 boxes 清零.
    // 读写发生在 (a) 事件线程 Renderer callback (b) anim_thread 通过
    // state.mu 保护下的 scroll_chat_by_lines, 不显式加锁 — 与现有 state
    // 读取路径保持一致的 "PostEvent happens-before" 模型.
    std::vector<Box> message_boxes;
    std::vector<Box> message_layout_boxes;
    std::vector<int> message_line_counts;
    int message_line_count_width = 0;

    // 主题初始化 — 必须在 FTXUI 接管 stdin 之前完成 OSC 11 探测。
    {
        std::string theme_name = config.tui.theme;
        if (theme_name == "auto") {
            auto detected = acecode::detect_terminal_theme();
            theme_name = (detected == acecode::DetectedTheme::light) ? "light" : "dark";
        }
        acecode::tui::init_theme_palette(theme_name);
    }

    // 终端能力探测 + render mode 决策。默认 auto 走 Fullscreen,让 TUI
    // 启动时直接撑满终端;config "never" 可回到 TerminalOutput。
    // CLI --alt-screen / -alt-screen 把 effective alt_screen_mode 临时强制为
    // "always",优先级高于 config.json,只影响本次启动,不写回。
    auto term_caps = acecode::detect_terminal_capabilities();
    if (force_alt_screen) {
        config.tui.alt_screen_mode = "always";
    }
    auto render_mode = acecode::tui::decide_render_mode(config.tui, term_caps);
    const bool conhost_compat_layout =
        acecode::should_use_conhost_compat_layout(term_caps);
    set_ftxui_full_repaint_mode(conhost_compat_layout);
    if (conhost_compat_layout) {
        render_mode = acecode::tui::ScreenRenderMode::AltScreen;
    }

    maybe_add_legacy_terminal_hint(state, config, term_caps, render_mode,
                                   force_alt_screen);

    auto screen = acecode::tui::make_screen_interactive(render_mode);
    // Publish for the Windows console-ctrl handler so Ctrl+C can trigger a
    // graceful Loop exit instead of letting the default handler kill us.
    g_active_screen.store(&screen, std::memory_order_release);
    screen.ForceHandleCtrlC(false);
    // mouse-selection-copy: register a no-op SelectionChange callback so
    // FTXUI enables live selection tracking. The right-click branch in the
    // CatchEvent handler reads screen.GetSelection() on demand; we don't
    // need per-change work here yet. Future: hook "auto-clear on new drag".
    screen.SelectionChange([]{});
    std::thread update_check_thread = start_tui_update_check(config, state, screen);

    // AskUserQuestion 依赖 TuiState + ScreenInteractive 才能发起阻塞 overlay,
    // 所以和其它无依赖的内置工具分开、等 `state` / `screen` 就绪之后再注册。
    tools.register_tool(create_ask_user_question_tool(state, screen));
    start_mcp_servers_async(mcp_manager, tools, state, screen);

    std::atomic<bool> mcp_first_turn_wait_done{false};
    auto coordinate_mcp_before_first_turn = [&]() {
        auto result = acecode::coordinate_mcp_before_first_turn(
            mcp_manager,
            mcp_first_turn_wait_done,
            std::chrono::milliseconds(1500));
        if (result.should_warn) {
            std::lock_guard<std::mutex> lk(state.mu);
            state.conversation.push_back({"system",
                acecode::mcp_first_turn_still_starting_warning(),
                false});
            screen.PostEvent(Event::Custom);
        }
    };

    auto chat_viewport_rows = [&chat_box]() -> int {
        return chat_box.y_max >= chat_box.y_min
            ? chat_box.y_max - chat_box.y_min + 1
            : 0;
    };

    // Sync row counts from the most recent completed FTXUI layout. Render()
    // writes message_layout_boxes after the renderer lambda returns, so a
    // wheel/PgUp event can arrive with fresh boxes but stale line counts.
    auto sync_chat_line_counts_from_layout =
        [&state, &chat_box, &message_layout_boxes, &message_line_counts,
         &message_line_count_width]() {
            const size_t n_msgs = state.conversation.size();
            const int current_message_width = chat_box.x_max >= chat_box.x_min
                ? chat_box.x_max - chat_box.x_min + 1
                : 0;
            const bool line_count_width_changed =
                current_message_width > 0 &&
                current_message_width != message_line_count_width;
            if (line_count_width_changed) {
                message_line_counts.assign(n_msgs, 0);
                message_line_count_width = current_message_width;
            }
            message_line_counts.resize(n_msgs);
            for (size_t i = 0; i < n_msgs; ++i) {
                if (!line_count_width_changed && i < message_layout_boxes.size()) {
                    int h = message_layout_boxes[i].y_max -
                            message_layout_boxes[i].y_min + 1;
                    message_line_counts[i] =
                        acecode::tui::update_chat_line_count_estimate(
                            message_line_counts[i], h);
                } else if (message_line_counts[i] <= 0) {
                    message_line_counts[i] = 1;
                }
            }
        };

    auto clamp_chat_focus = [&state, &message_line_counts, &chat_viewport_rows]() {
        if (state.conversation.empty()) {
            state.chat_focus_index = -1;
            state.chat_line_offset = 0;
            state.chat_scroll_top_row = 0;
            state.chat_follow_tail = true;
            return;
        }

        int message_count = static_cast<int>(state.conversation.size());
        int last = message_count - 1;
        const int viewport_rows = chat_viewport_rows();
        const int max_scroll_top =
            acecode::tui::chat_max_scroll_top_row(message_line_counts,
                                                  message_count,
                                                  viewport_rows);
        if (state.chat_follow_tail) {
            state.chat_focus_index = last;
            state.chat_line_offset =
                acecode::tui::chat_tail_line_offset(message_line_counts, last);
            state.chat_scroll_top_row = max_scroll_top;
            return;
        }

        state.chat_scroll_top_row =
            acecode::tui::clamp_chat_scroll_top_row(state.chat_scroll_top_row,
                                                    message_line_counts,
                                                    message_count,
                                                    viewport_rows);
        auto [idx, off] = acecode::tui::chat_focus_from_display_row(
            message_line_counts, message_count, state.chat_scroll_top_row);
        state.chat_focus_index = idx;
        state.chat_line_offset = off;
        state.chat_follow_tail = state.chat_scroll_top_row >= max_scroll_top;
    };

    // 按行粒度滚动: 鼠标滚轮 / PgUp / PgDn / 拖到边界 auto-scroll 全部走它.
    // 实现:以 chat_scroll_top_row 维护 transcript 视口顶部的绝对显示行,
    // 再从顶部行反推当前 focus message. 返回实际滚了几行, 供调用方调用
    // screen.ShiftSelection(0, -actual) 补偿 FTXUI 屏幕坐标选区.
    // 注意: 本 lambda 必须在持有 state.mu 的上下文中调用.
    auto scroll_chat_by_lines = [&state, &message_line_counts, &chat_viewport_rows](int delta_lines) -> int {
        if (state.conversation.empty()) return 0;
        const int message_count = static_cast<int>(state.conversation.size());
        int last_msg = message_count - 1;
        const int viewport_rows = chat_viewport_rows();
        const int max_scroll_top =
            acecode::tui::chat_max_scroll_top_row(message_line_counts,
                                                  message_count,
                                                  viewport_rows);
        if (state.chat_follow_tail) {
            state.chat_focus_index = last_msg;
            state.chat_line_offset =
                acecode::tui::chat_tail_line_offset(message_line_counts,
                                                    last_msg);
            state.chat_scroll_top_row = max_scroll_top;
        }

        const int before = acecode::tui::clamp_chat_scroll_top_row(
            state.chat_scroll_top_row, message_line_counts, message_count,
            viewport_rows);
        const int after = acecode::tui::clamp_chat_scroll_top_row(
            before + delta_lines, message_line_counts, message_count,
            viewport_rows);
        state.chat_scroll_top_row = after;
        const int actual = after - before;

        if (after >= max_scroll_top) {
            state.chat_focus_index = last_msg;
            state.chat_line_offset =
                acecode::tui::chat_tail_line_offset(message_line_counts,
                                                    last_msg);
            state.chat_follow_tail = true;
        } else {
            auto [idx, off] = acecode::tui::chat_focus_from_display_row(
                message_line_counts, message_count, after);
            state.chat_focus_index = idx;
            state.chat_line_offset = off;
            state.chat_follow_tail = false;
        }
        // 到达最后一条消息的最末行就重新 follow_tail —— 适用于鼠标滚轮 / PgDn /
        // 拖到底三种场景:用户主动滚到底就期望新内容自动跟进。其他位置保持手动锁定。
        return actual;
    };

    // ---- Copilot auth flow (background thread) ----
    std::atomic<bool> auth_done{false};
    std::thread auth_thread;
    bool auth_thread_started = false;

    {
        auto provider_snapshot = provider_accessor();
        auto* copilot = dynamic_cast<CopilotProvider*>(provider_snapshot.get());
        if (copilot && !copilot->is_authenticated()) {
            const std::string copilot_model = copilot->model();
            {
                std::lock_guard<std::mutex> lk(state.mu);
                state.current_thinking_phrase = get_random_thinking_phrase(is_user_chinese(state));
                // 新一轮等待：计时/计数字段必须和 is_waiting 一起重置，否则
                // on_busy_changed 的 `busy && !is_waiting` 护栏会把这段跳过，
                // thinking_start_time 会停在 time_point{} 原点，底部秒数会巨大。
                state.thinking_start_time = std::chrono::steady_clock::now();
                state.streaming_output_chars = 0;
                state.last_completion_tokens_authoritative = 0;
                state.is_waiting = true;
                state.conversation.push_back({"system", "Authenticating with GitHub Copilot...", false});
            }
            screen.PostEvent(Event::Custom);

            auth_thread_started = true;
            auth_thread = std::thread([copilot, &state, &screen, &auth_done, copilot_model] {
                // Try silent auth first (saved token)
                if (copilot->try_silent_auth()) {
                    {
                        std::lock_guard<std::mutex> lk(state.mu);
                        state.conversation.push_back({"system", "Authenticated (saved token).", false});
                        state.is_waiting = false;
                    }
                    auth_done = true;
                    screen.PostEvent(Event::Custom);
                    return;
                }

                // Need interactive device flow
                auto dc = request_device_code();
                {
                    std::lock_guard<std::mutex> lk(state.mu);
                    state.conversation.push_back({"system",
                        "Open " + dc.verification_uri + " and enter code: " + dc.user_code, false});
                }
                screen.PostEvent(Event::Custom);

                copilot->run_device_flow([&state, &screen](const std::string& status) {
                    std::lock_guard<std::mutex> lk(state.mu);
                    state.status_line = status;
                    screen.PostEvent(Event::Custom);
                });

                if (copilot->is_authenticated()) {
                    {
                        std::lock_guard<std::mutex> lk(state.mu);
                        state.conversation.push_back({"system", "GitHub Copilot authenticated!", false});
                        state.is_waiting = false;
                        state.status_line = "[copilot] model: " + copilot_model;
                    }
                } else {
                    std::lock_guard<std::mutex> lk(state.mu);
                    state.conversation.push_back({"system", "[Error] Authentication failed.", false});
                    state.is_waiting = false;
                }
                auth_done = true;
                screen.PostEvent(Event::Custom);
            });
        }
    }
    if (!auth_thread_started) auth_done = true;

    // ---- Token tracking ----
    TokenTracker token_tracker;
    state.token_status = token_tracker.format_status(config.context_window);
    state.token_percent = token_tracker.context_percent(config.context_window);

    // ---- Agent callbacks ----
    std::atomic<bool> agent_aborting{false};  // shared abort flag for confirm_cv
    AgentCallbacks callbacks;
    callbacks.on_message = [&state, &clamp_chat_focus, &screen](const std::string& role, const std::string& content, bool is_tool) {
        std::lock_guard<std::mutex> lk(state.mu);
        if (!is_tool && role == "assistant" &&
            !state.conversation.empty() &&
            state.conversation.back().role == "assistant" &&
            !state.conversation.back().is_tool) {
            state.conversation.back().content = content;
        } else {
            state.conversation.push_back({role, content, is_tool});
        }
        clamp_chat_focus();
        screen.PostEvent(Event::Custom);
    };
    callbacks.on_busy_changed = [&state, &screen](bool busy) {
        std::lock_guard<std::mutex> lk(state.mu);
        if (busy && !state.is_waiting) {
            state.current_thinking_phrase = get_random_thinking_phrase(is_user_chinese(state));
            state.thinking_start_time = std::chrono::steady_clock::now();
            state.streaming_output_chars = 0;
            state.last_completion_tokens_authoritative = 0;
        }
        state.is_waiting = busy;
        screen.PostEvent(Event::Custom);
    };
    callbacks.on_tool_confirm = [&state, &screen, &agent_aborting](const std::string& tool_name, const std::string& args) -> PermissionResult {
        {
            std::lock_guard<std::mutex> lk(state.mu);
            state.confirm_pending = true;
            state.confirm_tool_name = tool_name;
            state.confirm_tool_args = args;
            // 每次新确认都把焦点复位到 "No",避免上一次留下的焦点泄漏到下一次,
            // 同时安全的默认是 Deny —— 用户随手 Enter 不会误授权。
            state.confirm_focus = 2;
        }
        screen.PostEvent(Event::Custom);

        // Block the agent thread until the user responds in the TUI (or abort)
        std::unique_lock<std::mutex> lk(state.mu);
        state.confirm_cv.wait(lk, [&state, &agent_aborting] {
            return !state.confirm_pending || agent_aborting.load();
        });
        if (agent_aborting.load()) return PermissionResult::Deny;
        return state.confirm_result;
    };
    callbacks.on_delta = [&state, &clamp_chat_focus, &screen](const std::string& token) {
        std::lock_guard<std::mutex> lk(state.mu);
        // Find or create the streaming assistant message
        if (state.conversation.empty() ||
            state.conversation.back().role != "assistant" ||
            state.conversation.back().is_tool) {
            state.conversation.push_back({"assistant", "", false});
        }
        state.conversation.back().content += token;
        state.streaming_output_chars += token.size();
        clamp_chat_focus();
        screen.PostEvent(Event::Custom);
    };
    // Attach summary/display_override to the two most-recent TUI messages
    // (the trailing tool_call row and tool_result row that on_message just
    // appended) so the renderer can switch to the single-line summary mode.
    callbacks.on_tool_result = [&state, &screen](const ChatMessage& call_msg,
                                                 const std::string& /*tool_name*/,
                                                 const ToolResult& result) {
        std::lock_guard<std::mutex> lk(state.mu);
        // Walk the tail backwards: most recent tool_result gets `summary` +
        // `hunks`, the nearest preceding tool_call gets `display_override`.
        // Both were just pushed by `on_message` on the agent worker thread.
        for (auto it = state.conversation.rbegin(); it != state.conversation.rend(); ++it) {
            if (it->role == "tool_result" && !it->summary.has_value()) {
                it->summary = result.summary;
                it->hunks = result.hunks;
                break;
            }
        }
        if (!call_msg.display_override.empty()) {
            for (auto it = state.conversation.rbegin(); it != state.conversation.rend(); ++it) {
                if (it->role == "tool_call" && it->display_override.empty()) {
                    it->display_override = call_msg.display_override;
                    break;
                }
            }
        }
        screen.PostEvent(Event::Custom);
    };
    callbacks.on_usage = [&token_tracker, &state, &config, &screen](const TokenUsage& usage) {
        token_tracker.record(usage);
        std::lock_guard<std::mutex> lk(state.mu);
        state.token_status = token_tracker.format_status(config.context_window);
        state.token_percent = token_tracker.context_percent(config.context_window);
        state.last_completion_tokens_authoritative = usage.completion_tokens;
        screen.PostEvent(Event::Custom);
    };
    callbacks.on_goal_status = [&state, &screen](const std::string& status) {
        std::lock_guard<std::mutex> lk(state.mu);
        state.goal_status = status;
        screen.PostEvent(Event::Custom);
    };
    callbacks.on_todo_updated = [&state, &screen](const nlohmann::json& payload) {
        std::lock_guard<std::mutex> lk(state.mu);
        if (payload.is_object() && payload.contains("todos")) {
            state.todos = todo_items_from_json(payload["todos"]);
        } else {
            state.todos.clear();
        }
        screen.PostEvent(Event::Custom);
    };
    callbacks.on_transcript_replace = [&state, &clamp_chat_focus, &screen](
        const std::vector<ChatMessage>& /*messages*/,
        const CompactResult& result) {
        if (!result.performed || result.summary_text.empty()) {
            return;
        }
        std::lock_guard<std::mutex> lk(state.mu);
        int tui_keep = 0;
        int tui_turns = 0;
        for (int i = static_cast<int>(state.conversation.size()) - 1; i >= 0; --i) {
            if (state.conversation[i].role == "user") {
                tui_turns++;
                if (tui_turns >= 4) {
                    tui_keep = i;
                    break;
                }
            }
        }
        std::vector<TuiState::Message> new_conv;
        new_conv.reserve(state.conversation.size() - tui_keep + 2);
        new_conv.push_back({"system", "--- [Compact Boundary] ---", false});
        new_conv.push_back({"system", "[Conversation summary]\n" + result.summary_text, false});
        new_conv.insert(new_conv.end(),
                        state.conversation.begin() + tui_keep,
                        state.conversation.end());
        state.conversation = std::move(new_conv);
        state.chat_follow_tail = true;
        clamp_chat_focus();
        screen.PostEvent(Event::Custom);
    };
    callbacks.on_stream_retry_reset = [&state, &clamp_chat_focus, &screen]() {
        std::lock_guard<std::mutex> lk(state.mu);
        if (!state.conversation.empty() &&
            state.conversation.back().role == "assistant" &&
            !state.conversation.back().is_tool) {
            state.conversation.pop_back();
        }
        state.streaming_output_chars = 0;
        clamp_chat_focus();
        screen.PostEvent(Event::Custom);
    };

    PermissionManager permissions;
    configure_permissions(permissions, dangerous_mode, config.default_permission_mode);

    AgentLoop agent_loop(provider_accessor, tools, callbacks, working_dir, permissions);
    agent_loop.set_context_window(config.context_window);
    agent_loop.set_no_model_config_prompt(
        u8"请先配置大模型服务。TUI 可运行 acecode configure 或使用 /model add 添加模型。");
    agent_loop.set_agent_loop_config(config.agent_loop);
    agent_loop.set_hook_manager(&hook_manager);
    agent_loop.set_skill_registry(&skill_registry);
    agent_loop.set_memory_registry(&memory_registry);
    agent_loop.set_memory_config(&runtime_memory_cfg);
    agent_loop.set_project_instructions_config(&config.project_instructions);

    agent_loop.set_callbacks(callbacks);

    // ---- Model-pool load monitor (PUB 模型) ----
    // 仅当配置里有 PUB 池模型时才起 30s 轮询(避免在没有这些模型的机器上无谓打外网)。
    // 负载实时写 g_model_load_percent 供底栏 chip 展示;maxWindowTokens 稳定,故只需在
    // 每次成功轮询时把 0.8x 有效窗口回灌到 config + agent_loop(UI 线程 Post,改的是 int,
    // 安全),token% 下个回合自然重算。service 在 run_tui_loop 返回后 stop(),保证回调
    // 不晚于这些局部变量析构。
    {
        bool has_pub = false;
        for (const auto& m : config.saved_models) {
            if (acecode::is_pub_model(m.model)) { has_pub = true; break; }
        }
        if (has_pub) {
            auto on_pool_update = [&provider_slot, &config, &agent_loop]() {
                std::string model_id;
                {
                    std::lock_guard<std::mutex> lk(provider_slot.mu);
                    if (provider_slot.provider) model_id = provider_slot.provider->model();
                }
                int pct = -1;
                int eff = 0;
                if (acecode::is_pub_model(model_id)) {
                    if (auto st = acecode::model_pool_status_service().get(model_id)) {
                        pct = st->usage_rate;
                        eff = acecode::effective_context_window(st->max_window_tokens);
                    }
                }
                g_model_load_percent.store(pct);
                auto* scr = g_active_screen.load(std::memory_order_acquire);
                if (!scr) return;
                if (eff > 0) {
                    scr->Post([&config, &agent_loop, eff]() {
                        if (config.context_window != eff) {
                            config.context_window = eff;
                            agent_loop.set_context_window(eff);
                        }
                    });
                }
                scr->PostEvent(ftxui::Event::Custom);
            };
            acecode::model_pool_status_service().start(on_pool_update);
        }
    }

    // ---- Session manager ----
    SessionManager session_manager;
    {
        auto p = provider_accessor();
        const std::string provider_name = p ? p->name() : std::string{};
        const std::string provider_model = p ? p->model() : std::string{};
        session_manager.start_session(working_dir, provider_name, provider_model);
        session_manager.set_permission_mode(
            PermissionManager::mode_name(permissions.mode()),
            /*persist_immediately=*/false);
        if (permissions.mode() == PermissionMode::Plan) {
            session_manager.set_pre_plan_permission_mode(
                PermissionManager::mode_name(permissions.pre_plan_mode()),
                /*persist_immediately=*/false);
        }
    }
    agent_loop.set_session_manager(&session_manager);

    // Register session finalization for clean shutdown
    g_session_manager = &session_manager;
    std::atexit(finalize_session_atexit);
#ifdef _WIN32
    SetConsoleCtrlHandler(console_ctrl_handler, TRUE);
#else
    std::signal(SIGINT, signal_handler);
    std::signal(SIGTERM, signal_handler);
#endif

    // ---- Handle --resume ----
    bool resumed_session_success = false;
    if (resume_latest || !resume_session_id.empty()) {
        std::string target_id = resume_session_id;
        std::string resumed_title;
        if (resume_latest) {
            auto sessions = session_manager.list_sessions();
            if (!sessions.empty()) {
                target_id = sessions.front().id;
                resumed_title = sessions.front().title;
            }
        } else if (!target_id.empty()) {
            // 通过 SessionManager 读取 canonical meta,避免在 TUI 启动路径里
            // 直接拼存储路径。
            auto meta = session_manager.load_session_meta(target_id);
            resumed_title = meta.title;
        }
        if (!target_id.empty()) {
            const bool canonical_exists = session_manager.has_session_file(target_id);
            // 把 session meta 喂给 resolver,让 resume 真正还原 provider+model。
            // resolve_effective_model 会优先用 (meta.provider, meta.model) 从
            // saved_models 找匹配 entry;找不到则构造 ad-hoc entry,name 以
            // "(session:..." 开头,触发我们后面的系统消息提示。
            SessionMeta resumed_meta = session_manager.load_session_meta(target_id);
            std::optional<SessionModelState> resumed_model_state;
            if (auto deleted_state = deleted_model_state_from_meta(config, resumed_meta)) {
                resumed_model_state = deleted_state;
            } else if (!resumed_meta.provider.empty() && !resumed_meta.model.empty()) {
                ModelProfile resumed_entry = resolve_effective_model(
                    config, cwd_override, std::optional<SessionMeta>{resumed_meta});
                ApplyModelDeps deps;
                deps.provider_slot = &provider_slot;
                deps.sm = &session_manager;
                deps.loop = &agent_loop;
                deps.cfg = &config;
                try {
                    auto result = apply_model_to_session(resumed_entry, deps);
                    config.context_window = result.state.context_window;
                    resumed_model_state = result.state;
                } catch (const std::exception& e) {
                    state.conversation.push_back({"system",
                        std::string("⚠ Resume model switch failed: ") + e.what(), false});
                }
                if (resumed_entry.name.rfind("(session:", 0) == 0) {
                    state.conversation.push_back({"system",
                        "⚠ Resumed with ad-hoc model entry (session recorded " +
                        resumed_meta.provider + "/" + resumed_meta.model +
                        ", not in saved_models). Use /model --default <name> to pick a permanent one.",
                        false});
                }
            }

            auto messages = session_manager.resume_session(target_id);
            const std::string resume_error = session_manager.last_error();
            if (!resume_error.empty()) {
                state.conversation.push_back({"system", resume_error, false});
            } else if (!canonical_exists && session_manager.has_incompatible_session_data(target_id)) {
                state.conversation.push_back({"system",
                    "Session " + target_id + " uses an old PID-suffixed data format that is no longer supported. Delete the old project session data under ~/.acecode/projects and start a new session.", false});
            } else if (!canonical_exists) {
                state.conversation.push_back({"system", "Session " + target_id + " not found.", false});
            } else {
                acecode::append_resumed_session_messages(messages, state, agent_loop, tools);
                state.todos = session_manager.current_todos();
                const PermissionMode resumed_mode =
                    permission_mode_from_meta_name(resumed_meta.permission_mode);
                if (resumed_mode == PermissionMode::Plan) {
                    permissions.set_mode(permission_mode_from_meta_name(
                        resumed_meta.pre_plan_permission_mode.empty()
                            ? std::string{"default"}
                            : resumed_meta.pre_plan_permission_mode));
                    permissions.set_mode(PermissionMode::Plan);
                } else {
                    permissions.set_mode(resumed_mode);
                }
                permissions.clear_session_allows();
                session_manager.set_permission_mode(
                    PermissionManager::mode_name(permissions.mode()),
                    /*persist_immediately=*/false);
                if (permissions.mode() == PermissionMode::Plan) {
                    session_manager.set_pre_plan_permission_mode(
                        PermissionManager::mode_name(permissions.pre_plan_mode()),
                        /*persist_immediately=*/false);
                }
                token_tracker.restore(resumed_meta.last_token_usage,
                                      resumed_meta.session_token_usage);
                sync_tui_resume_runtime_state(state, config, token_tracker,
                                              resumed_model_state);
                state.conversation.push_back({"system",
                    "Resumed session " + target_id + " (" + std::to_string(messages.size()) + " messages)", false});
                resumed_session_success = true;
                agent_loop.publish_current_goal_state();
                agent_loop.maybe_continue_goal();
                if (!resumed_title.empty()) {
                    set_terminal_title(resumed_title);
                    state.current_session_title = resumed_title;
                }
            }
        } else {
            if (session_manager.has_incompatible_session_data()) {
                state.conversation.push_back({"system",
                    "No canonical sessions found. Old PID-suffixed session data in this project is no longer supported; delete the old project session data under ~/.acecode/projects and start a new session.", false});
            } else {
                state.conversation.push_back({"system", "No previous sessions found to resume.", false});
            }
        }
    }
    agent_loop.dispatch_session_start_hook(
        resumed_session_success ? std::string{"resume"} : std::string{"startup"});

    // Slash command registry
    CommandRegistry cmd_registry;
    register_slash_commands(cmd_registry, skill_registry);

    // --- Tool progress callbacks (streaming-tool-progress change) ---
    callbacks.on_tool_progress_start = [&state, &screen](
        const std::string& tool_name, const std::string& cmd_preview) {
        {
            std::lock_guard<std::mutex> lk(state.mu);
            state.tool_running = true;
            state.tool_progress = {};
            state.tool_progress.tool_name = tool_name;
            state.tool_progress.command_preview = cmd_preview;
            state.tool_progress.start_time = std::chrono::steady_clock::now();
            state.last_tool_post_event_time = std::chrono::steady_clock::now();
        }
        screen.PostEvent(Event::Custom);
    };

    callbacks.on_tool_progress_update = [&state, &screen](
        const std::vector<std::string>& tail_snapshot,
        const std::string& current_partial,
        size_t total_bytes, int total_lines) {
        bool should_post = false;
        {
            std::lock_guard<std::mutex> lk(state.mu);
            state.tool_progress.tail_lines = tail_snapshot;
            state.tool_progress.current_partial = current_partial;
            state.tool_progress.total_bytes = total_bytes;
            state.tool_progress.total_lines = total_lines;
            auto now = std::chrono::steady_clock::now();
            if (now - state.last_tool_post_event_time > std::chrono::milliseconds(150)) {
                state.last_tool_post_event_time = now;
                should_post = true;
            }
        }
        if (should_post) screen.PostEvent(Event::Custom);
    };

    callbacks.on_tool_progress_end = [&state, &screen]() {
        {
            std::lock_guard<std::mutex> lk(state.mu);
            state.tool_running = false;
            state.tool_progress = {};
        }
        // Unconditional PostEvent so the live element disappears immediately.
        screen.PostEvent(Event::Custom);
    };

    // Now that agent_loop exists, update on_busy_changed to drain pending queue
    callbacks.on_busy_changed = [&state, &clamp_chat_focus, &agent_loop, &screen,
                                 &coordinate_mcp_before_first_turn](bool busy) {
        std::unique_lock<std::mutex> lk(state.mu);
        if (busy && !state.is_waiting) {
            state.current_thinking_phrase = get_random_thinking_phrase(is_user_chinese(state));
            state.thinking_start_time = std::chrono::steady_clock::now();
            state.streaming_output_chars = 0;
            state.last_completion_tokens_authoritative = 0;
        }
        state.is_waiting = busy;
        // remote-control 出站:回合结束时把游标之后新增的 assistant 文本逐条
        // 转发给 IM 桥。挂在回合结束而不是 on_message:流式期间 assistant 气泡
        // 原地增量更新,逐 delta 转发会把半截文本刷给 IM。游标语义见 hub 注释。
        if (!busy) {
            auto& rc_hub = acecode::rc::remote_control_service().hub();
            if (rc_hub.enabled()) {
                std::size_t cursor = rc_hub.forward_cursor();
                // /clear 会缩短 conversation,游标越界时收口,避免越界读。
                if (cursor > state.conversation.size()) {
                    cursor = state.conversation.size();
                }
                for (std::size_t i = cursor; i < state.conversation.size(); ++i) {
                    const auto& m = state.conversation[i];
                    if (m.role == "assistant" && !m.is_tool) {
                        rc_hub.notify_assistant_text(m.content);
                    }
                }
                rc_hub.set_forward_cursor(state.conversation.size());
            }
        }
        if (!busy && !state.pending_queue.empty()) {
            std::string next_prompt = state.pending_queue.front();
            state.pending_queue.erase(state.pending_queue.begin());
            UserInput next_input;
            bool has_structured_input = false;
            if (!state.pending_structured_queue.empty() &&
                state.pending_structured_queue.front().display_text == next_prompt) {
                next_input = state.pending_structured_queue.front();
                state.pending_structured_queue.pop_front();
                has_structured_input = true;
            }
            state.conversation.push_back({"user", next_prompt, false});
            // draggable-thick-scrollbar: 用户主动拖滚动条时不要被 worker 线程
            // 强行拽回尾巴 —— 让用户看着自己挑的位置,直到他自己释放鼠标。
            // 拖到底的情况由 clamp_chat_focus 内部 (idx == last) 分支自然恢复。
            if (state.drag_scrollbar_phase ==
                TuiState::DragScrollbarPhase::Idle) {
                state.chat_follow_tail = true;
            }
            clamp_chat_focus();
            state.current_thinking_phrase = get_random_thinking_phrase(is_user_chinese(state));
            state.thinking_start_time = std::chrono::steady_clock::now();
            state.streaming_output_chars = 0;
            state.last_completion_tokens_authoritative = 0;
            state.is_waiting = true;
            lk.unlock();
            coordinate_mcp_before_first_turn();
            lk.lock();
            if (has_structured_input) {
                agent_loop.submit(next_input);
            } else {
                agent_loop.submit(next_prompt);
            }
        }
        screen.PostEvent(Event::Custom);
    };
    agent_loop.set_callbacks(callbacks);

    // remote-control 入站:IM 桥经 loopback HTTP 送来的文本走输入框同款提交
    // 路径(busy 排队 / 空闲直接 submit),气泡渲染与会话持久化与手输完全一致。
    // 该回调由 RC listener 的 Crow worker 线程调用,锁内逻辑与 Enter 提交分支
    // 保持一字不差。
    acecode::rc::remote_control_service().hub().set_inbound_submit(
        [&state, &agent_loop, &screen, &clamp_chat_focus,
         &coordinate_mcp_before_first_turn](const std::string& text) {
            std::unique_lock<std::mutex> lk(state.mu);
            if (state.is_waiting) {
                state.pending_queue.push_back(text);
            } else {
                state.conversation.push_back({"user", text, false});
                state.chat_follow_tail = true;
                clamp_chat_focus();
                state.current_thinking_phrase =
                    get_random_thinking_phrase(is_user_chinese(state));
                state.thinking_start_time = std::chrono::steady_clock::now();
                state.streaming_output_chars = 0;
                state.last_completion_tokens_authoritative = 0;
                state.is_waiting = true;
                lk.unlock();
                coordinate_mcp_before_first_turn();
                lk.lock();
                agent_loop.submit(text);
            }
            screen.PostEvent(Event::Custom);
        });

    // ---- Animation ticker thread ----
    std::atomic<bool> running{true};
    std::thread anim_thread([&running, &anim_tick, &state, &screen, &scroll_chat_by_lines, conhost_compat_layout] {
        while (running) {
            // drag-autoscroll: 拖动到边界期间提速到 50ms 唤醒, 其他时间保持 300ms.
            // 每次唤醒前读最新 phase, 避免拖动开始后还得等一个完整的 300ms.
            bool fast_tick = false;
            {
                std::lock_guard<std::mutex> lk(state.mu);
                fast_tick = (state.drag_phase == drag_scroll::Phase::ScrollingUp ||
                             state.drag_phase == drag_scroll::Phase::ScrollingDown);
            }
            const int idle_tick_ms = conhost_compat_layout ? 1000 : 300;
            std::this_thread::sleep_for(
                std::chrono::milliseconds(fast_tick ? 50 : idle_tick_ms));
            anim_tick++;
            // mouse-selection-copy: clear the "Copied N bytes" confirmation
            // ~2 s after the copy fired. Run before the post-event gate so we
            // always get a final render when the deadline passes.
            bool needs_post = false;
            {
                std::lock_guard<std::mutex> lk(state.mu);
                const auto now = std::chrono::steady_clock::now();
                if (state.status_line_clear_at.time_since_epoch().count() != 0 &&
                    now >= state.status_line_clear_at) {
                    state.status_line = state.status_line_saved;
                    state.status_line_saved.clear();
                    state.status_line_clear_at = {};
                    needs_post = true;
                }
                if (acecode::tui::expire_ctrl_c_exit_state(
                        state.ctrl_c_armed, state.last_ctrl_c_time, now)) {
                    needs_post = true;
                }
                if (mcp_sidebar_has_loading(state)) {
                    needs_post = true;
                }

                // drag-autoscroll: 时间门到点就滚一行, 把 ShiftSelection 的补偿请求
                // 累加到 pending_shift_dy, 由事件线程 CatchEvent 的入口消费 — 避免
                // anim_thread 直接改 FTXUI selection_data_ 与 HandleSelection 撞车.
                if (state.drag_phase == drag_scroll::Phase::ScrollingUp ||
                    state.drag_phase == drag_scroll::Phase::ScrollingDown) {
                    if (drag_scroll::should_tick(now, state.last_drag_scroll_at,
                                                  std::chrono::milliseconds(60))) {
                        int dy = (state.drag_phase == drag_scroll::Phase::ScrollingUp) ? -1 : 1;
                        int actual = scroll_chat_by_lines(dy);
                        if (actual != 0) {
                            // scroll_chat_by_lines(+1) 让视口顶部下移一行 → 屏幕
                            // 内容相对上移 actual 行 → 原 anchor 文本屏幕坐标应
                            // -actual.
                            state.pending_shift_dy += -actual;
#if ACECODE_TUI_INPUT_TRACE
                            LOG_DEBUG("[drag-select] autoscroll tick phase=" +
                                      drag_phase_for_log(state.drag_phase) +
                                      " requested_dy=" + std::to_string(dy) +
                                      " actual=" + std::to_string(actual) +
                                      " pending_shift_dy=" +
                                      std::to_string(state.pending_shift_dy) +
                                      " focus=" +
                                      std::to_string(state.chat_focus_index) +
                                      " offset=" +
                                      std::to_string(state.chat_line_offset) +
                                      " mouse=(" +
                                      std::to_string(state.last_mouse_x) +
                                      "," +
                                      std::to_string(state.last_mouse_y) +
                                      ")");
#endif
                            needs_post = true;
                        }
                    }
                }
            }
            // Drive re-render while waiting on LLM OR while a tool is running
            // (so the tool-timer chip in the status bar updates every second),
            // or when we just cleared a pending status confirmation.
            if (needs_post || state.is_waiting || state.tool_running) {
                screen.PostEvent(Event::Custom);
            }
        }
    });

    // ---- Input handling ----
    // Custom input component using paragraph-like flexbox for auto-wrapping.
    // Uses FTXUI's focusCursorBlock so the terminal cursor tracks the caret,
    // which lets the terminal emulator position the IME composition window.
    // NOTE: Renderer must take (bool) to be Focusable. This ensures
    // component_active=true on the element, so the input's cursor always
    // wins focus priority over message_view's | focus (which has
    // component_active=false and cursor_shape=Hidden).
    auto input_renderer = Renderer([&state](bool) {
        std::string display_text = state.input_text;
        size_t cursor = state.input_cursor;
        if (cursor > display_text.size()) cursor = display_text.size();
        if (display_text.empty()) {
            return hbox({
                text(" ") | focusCursorBar,
                text("Type your prompt here...") | dim | color(tui::theme().ui.text_dim),
            });
        }
        return render_wrapped_input_text(display_text, cursor);
    });

    // Must be called with state.mu held.
    auto cancel_ctrl_c_exit_locked = [&state]() {
        acecode::tui::clear_ctrl_c_exit_state(
            state.ctrl_c_armed, state.last_ctrl_c_time);
    };

    // 把已归一化的 paste 文本插入到 state.input_cursor。短文本 inline，超阈值
    // 或多行折叠为 [Pasted text #N (+M lines)] 并把原文存到 pasted_texts。
    // 调用前必须持有 state.mu。
    auto insert_pasted_text_at_cursor = [
        &state,
        &cancel_ctrl_c_exit_locked
    ](const std::string& normalized) {
        cancel_ctrl_c_exit_locked();
        if (state.input_cursor > state.input_text.size()) {
            state.input_cursor = state.input_text.size();
        }
        std::string to_insert;
        if (acecode::tui::should_fold_to_placeholder(normalized)) {
            const int id = state.next_paste_id++;
            state.pasted_texts[id] = normalized;
            const int n = acecode::tui::count_newlines(normalized);
            to_insert = acecode::tui::format_placeholder(id, n);
        } else {
            to_insert = normalized;
        }
        state.input_text.insert(state.input_cursor, to_insert);
        state.input_cursor += to_insert.size();
        state.history_index = -1;
    };

    auto can_accept_clipboard_paste_locked = [&state]() {
        return !state.ask_pending &&
               !state.confirm_pending &&
               !state.rewind_picker_active &&
               !state.resume_picker_active &&
               !state.model_picker_open;
    };

    auto paste_system_clipboard_text = [
        &state,
        &screen,
        &cmd_registry,
        &insert_pasted_text_at_cursor,
        &can_accept_clipboard_paste_locked
    ]() {
        {
            std::lock_guard<std::mutex> lk(state.mu);
            if (!can_accept_clipboard_paste_locked()) {
                return true;
            }
        }

        auto clipboard = acecode::read_system_clipboard_text();

        {
            std::lock_guard<std::mutex> lk(state.mu);
            if (!can_accept_clipboard_paste_locked()) {
                return true;
            }
            if (!clipboard) {
                set_transient_status_line_locked(
                    state, clipboard_paste_status_message(clipboard.status));
                screen.PostEvent(Event::Custom);
                return true;
            }

            std::string normalized =
                acecode::tui::normalize_pasted_text(clipboard.text);
            if (normalized.empty()) {
                set_transient_status_line_locked(
                    state,
                    clipboard_paste_status_message(
                        acecode::ClipboardTextReadResult::Status::Empty));
                screen.PostEvent(Event::Custom);
                return true;
            }

            insert_pasted_text_at_cursor(normalized);
            refresh_slash_dropdown(state, cmd_registry);
        }
        screen.PostEvent(Event::Custom);
        return true;
    };

    auto paste_system_clipboard_image = [
        &state,
        &screen,
        &session_manager,
        &working_dir,
        &can_accept_clipboard_paste_locked,
        &cancel_ctrl_c_exit_locked
    ]() {
        {
            std::lock_guard<std::mutex> lk(state.mu);
            if (!can_accept_clipboard_paste_locked() ||
                state.input_mode != InputMode::Normal) {
                return true;
            }
        }

        auto clipboard = acecode::read_system_clipboard_image();

        {
            std::lock_guard<std::mutex> lk(state.mu);
            if (!can_accept_clipboard_paste_locked()) {
                return true;
            }
            if (!clipboard) {
                set_transient_status_line_locked(
                    state, clipboard_image_status_message(clipboard.status));
                screen.PostEvent(Event::Custom);
                return true;
            }
        }

        const std::string session_id = session_manager.ensure_active_session_id();
        const std::string project_dir = SessionStorage::get_project_dir(working_dir);
        std::string error;
        auto record = save_attachment(
            project_dir,
            session_id,
            "clipboard.png",
            clipboard.mime_type.empty() ? "image/png" : clipboard.mime_type,
            clipboard.bytes,
            &error);

        {
            std::lock_guard<std::mutex> lk(state.mu);
            if (!record.has_value()) {
                set_transient_status_line_locked(
                    state,
                    error.empty() ? "Clipboard image save failed" : error);
                screen.PostEvent(Event::Custom);
                return true;
            }
            cancel_ctrl_c_exit_locked();
            state.pending_attachments.push_back(attachment_to_json(*record));
            set_transient_status_line_locked(
                state,
                "Attached image: " + record->name);
        }
        screen.PostEvent(Event::Custom);
        return true;
    };

    // Wrap with CatchEvent to handle all keyboard input
    auto input_with_esc = CatchEvent(input_renderer, [&state, &screen, &clamp_chat_focus, &chat_viewport_rows, &sync_chat_line_counts_from_layout, &auth_done, &cmd_registry, &agent_loop, &provider_slot, &provider_accessor, &config, &token_tracker, &permissions, &session_manager, &scroll_chat_by_lines, &chat_box, &scrollbar_box, &ask_scrollbar_box, &ask_overlay_box, &message_line_counts, &mcp_manager, &tools, &skill_registry, &memory_registry, &working_dir, &insert_pasted_text_at_cursor, &paste_system_clipboard_text, &paste_system_clipboard_image, &cancel_ctrl_c_exit_locked, &coordinate_mcp_before_first_turn](Event event) {
#if ACECODE_TUI_INPUT_TRACE
        if (event != Event::Custom &&
            !event.is_cursor_position() &&
            !event.is_cursor_shape()) {
            std::string state_snapshot;
            {
                std::lock_guard<std::mutex> lk(state.mu);
                state_snapshot =
                    " ask=" + std::string(state.ask_pending ? "1" : "0") +
                    " confirm=" + std::string(state.confirm_pending ? "1" : "0") +
                    " ctrl_c_armed=" + std::string(state.ctrl_c_armed ? "1" : "0") +
                    " resume=" + std::string(state.resume_picker_active ? "1" : "0") +
                    " model=" + std::string(state.model_picker_open ? "1" : "0") +
                    " waiting=" + std::string(state.is_waiting ? "1" : "0") +
                    " tool=" + std::string(state.tool_running ? "1" : "0") +
                    " focus=" + std::to_string(state.chat_focus_index) +
                    " line_offset=" + std::to_string(state.chat_line_offset) +
                    " follow_tail=" + std::string(state.chat_follow_tail ? "1" : "0");
            }
            LOG_DEBUG("[input] received " + event_for_log(event) +
                      " chat_box=" + box_for_log(chat_box) +
                      " scrollbar_box=" + box_for_log(scrollbar_box) +
                      " ask_scrollbar_box=" + box_for_log(ask_scrollbar_box) +
                      " ask_overlay_box=" + box_for_log(ask_overlay_box) +
                      state_snapshot);
        }
#endif

        // drag-autoscroll: 事件线程入口处消费 anim_thread 攒下的 selection 偏移
        // 补偿. 所有对 FTXUI selection_data_ 的写都发生在这条路径上, 跟
        // HandleSelection 串行 — 避免跨线程数据竞争. 不 return, 让事件继续正常处理.
        {
            int dy = 0;
            {
                std::lock_guard<std::mutex> lk(state.mu);
                dy = state.pending_shift_dy;
                state.pending_shift_dy = 0;
            }
            if (dy != 0) {
#if ACECODE_TUI_INPUT_TRACE
                LOG_DEBUG("[drag-select] consuming pending ShiftSelection dy=" +
                          std::to_string(dy));
#endif
                screen.ShiftSelection(0, dy);
            }
        }
        if (event != Event::CtrlC &&
            event != Event::Custom &&
            !event.is_mouse() &&
            !event.is_cursor_position() &&
            !event.is_cursor_shape()) {
            std::lock_guard<std::mutex> lk(state.mu);
            cancel_ctrl_c_exit_locked();
        }
        // 多行粘贴折叠（fix-multiline-paste-input change）：把所有事件先喂进
        // bracketed paste 状态机。begin marker 进入 in-paste，期间所有事件
        // （含 Return / Tab / 字符 / 内嵌 CSI bytes）都聚合到 buffer 而不下发到
        // 正常 Return / 字符 / 删除 / 方向键 handler；end marker 触发 normalize
        // 后或 inline 插入或折叠成 [Pasted text #N +M lines]。空 paste 直接返回。
        {
            std::unique_lock<std::mutex> lk(state.mu);
            acecode::tui::PasteFeedResult pr = event.is_character()
                ? state.paste_accumulator.feed_character(event.character())
                : state.paste_accumulator.feed_special(event.input());
            if (pr.just_completed && !pr.completed_text.empty()) {
                insert_pasted_text_at_cursor(pr.completed_text);
                refresh_slash_dropdown(state, cmd_registry);
                lk.unlock();
                screen.PostEvent(Event::Custom);
            }
            if (pr.consume) {
                return true;
            }
        }
        if (event == Event::CtrlV) {
            return paste_system_clipboard_text();
        }
        if (is_alt_v_event(event)) {
            return paste_system_clipboard_image();
        }
        if (event == Event::CtrlC) {
            // If an operation is active, Ctrl+C behaves like Escape: cancel the
            // current work instead of arming the double-press exit shortcut.
            bool should_exit = false;
            {
                std::lock_guard<std::mutex> lk(state.mu);
                if (state.is_compacting) {
                    cancel_ctrl_c_exit_locked();
                    state.compact_abort_requested.store(true);
                    state.conversation.push_back({"system", "Cancelling compaction...", false});
                    state.chat_follow_tail = true;
                    clamp_chat_focus();
                    screen.PostEvent(Event::Custom);
                    return true;
                }
                if (state.ask_pending || state.confirm_pending ||
                    state.is_waiting || state.tool_running) {
                    cancel_ctrl_c_exit_locked();
                    screen.PostEvent(Event::Escape);
                    return true;
                }
                const auto action = acecode::tui::record_ctrl_c_exit_press(
                    state.ctrl_c_armed,
                    state.last_ctrl_c_time,
                    std::chrono::steady_clock::now());
                if (action == acecode::tui::CtrlCExitAction::Exit) {
                    should_exit = true;
                } else {
                    if (acecode::tui::clear_current_input_for_history_restore(state)) {
                        refresh_slash_dropdown(state, cmd_registry);
                    }
                }
            }
            if (should_exit) {
                screen.Exit();
            } else {
                screen.PostEvent(Event::Custom);
            }
            return true;
        }

        // AskUserQuestion overlay guard:active 时抢占键盘,所有非导航键被吞掉,
        // 不透传到输入框。优先级高于 confirm、slash-dropdown、Return/Esc 等分支。
        // "Other" 自定义文本态下让字符输入 / Backspace 继续走默认路径,只拦截
        // Return / Escape / 方向键。
        {
            std::unique_lock<std::mutex> lk(state.mu);
            if (state.ask_pending) {
                // Redraw/timer events must not be reported as "handled" while a
                // question is open. FTXUI clears the active text selection when
                // a component handles any event; the thinking animation posts
                // Event::Custom frequently, which otherwise erases drag
                // selection before it can stay visible.
                if (event == Event::Custom || event.is_cursor_position()) {
                    return false;
                }

                auto& q = state.ask_questions[state.ask_current_question];
                const int option_count = static_cast<int>(q.options.size());
                const int total_rows = option_count + 1; // + "Other..."

                auto reset_ask_scroll_state = [&]() {
                    state.ask_scroll_offset = 0;
                    state.ask_scroll_total_rows = 0;
                    state.ask_scroll_visible_rows = 0;
                    state.ask_scrollbar_dragging = false;
                    state.ask_scroll_to_focus_requested = false;
                };

                auto clamp_ask_scroll = [&]() {
                    state.ask_scroll_offset = acecode::tui::clamp_scroll_offset(
                        state.ask_scroll_offset,
                        state.ask_scroll_total_rows,
                        state.ask_scroll_visible_rows);
                };

                auto scroll_ask_by_lines = [&](int delta) {
                    const int before = state.ask_scroll_offset;
                    state.ask_scroll_offset = acecode::tui::scroll_offset_by_lines(
                        state.ask_scroll_offset, delta,
                        state.ask_scroll_total_rows,
                        state.ask_scroll_visible_rows);
                    return state.ask_scroll_offset != before;
                };

                auto scroll_ask_to_mouse_y = [&](int mouse_y) {
                    const int track_height =
                        ask_scrollbar_box.y_max - ask_scrollbar_box.y_min + 1;
                    state.ask_scroll_offset = acecode::tui::scroll_offset_for_track_y(
                        mouse_y, ask_scrollbar_box.y_min, track_height,
                        state.ask_scroll_total_rows,
                        state.ask_scroll_visible_rows);
                };

                auto advance_or_finish_question = [&]() {
                    state.ask_current_question++;
                    if (state.ask_current_question >=
                        static_cast<int>(state.ask_questions.size())) {
                        state.ask_result_ok = true;
                        state.ask_pending = false;
                        reset_ask_scroll_state();
                        state.ask_cv.notify_one();
                    } else {
                        state.ask_option_focus = 0;
                        state.ask_multi_selected.assign(
                            state.ask_questions[state.ask_current_question]
                                .options.size(), false);
                        state.ask_other_input_active = false;
                        state.ask_scroll_offset = 0;
                        state.ask_scrollbar_dragging = false;
                        state.ask_scroll_to_focus_requested = true;
                        clamp_ask_scroll();
                    }
                };

                if (event == Event::PageUp || event == Event::PageDown) {
                    const int page_step =
                        std::max(1, state.ask_scroll_visible_rows - 1);
                    const int delta =
                        (event == Event::PageUp) ? -page_step : page_step;
                    if (scroll_ask_by_lines(delta)) {
                        screen.PostEvent(Event::Custom);
                        return true;
                    }

                    const int chat_step = config.tui.page_keys_single_line
                        ? 1
                        : std::max(1, chat_viewport_rows() - 2);
                    const int chat_delta =
                        (event == Event::PageUp) ? -chat_step : chat_step;
                    sync_chat_line_counts_from_layout();
                    if (scroll_chat_by_lines(chat_delta) != 0) {
                        screen.PostEvent(Event::Custom);
                    }
                    return true;
                }

                if (event == Event::Special("\x1B[1;3A") ||
                    event == Event::Special("\x1B[1;3B")) {
                    const int delta =
                        (event == Event::Special("\x1B[1;3A")) ? -1 : 1;
                    sync_chat_line_counts_from_layout();
                    if (scroll_chat_by_lines(delta) != 0) {
                        screen.PostEvent(Event::Custom);
                    }
                    return true;
                }

                if (event.is_mouse()) {
                    auto& mouse = event.mouse();
                    constexpr int WHEEL_LINES = 3;
                    auto contains_box = [](const Box& box, int x, int y) {
                        return box.x_min <= box.x_max &&
                               box.y_min <= box.y_max &&
                               box.Contain(x, y);
                    };
                    auto scroll_chat_from_ask = [&](int delta) {
                        sync_chat_line_counts_from_layout();
                        const int actual = scroll_chat_by_lines(delta);
                        if (actual != 0) {
                            screen.PostEvent(Event::Custom);
                        }
                        return actual;
                    };
                    auto begin_chat_scrollbar_drag = [&]() {
                        sync_chat_line_counts_from_layout();
                        state.drag_scrollbar_snapshot = message_line_counts;
                        state.drag_scrollbar_phase =
                            TuiState::DragScrollbarPhase::Dragging;
                        const bool was_follow_tail = state.chat_follow_tail;
                        state.chat_follow_tail = false;
                        const int track_height =
                            scrollbar_box.y_max - scrollbar_box.y_min + 1;
                        const int snapshot_count = static_cast<int>(
                            state.drag_scrollbar_snapshot.size());
                        const int viewport_rows = chat_viewport_rows();
                        const int max_top = acecode::tui::chat_max_scroll_top_row(
                            state.drag_scrollbar_snapshot, snapshot_count,
                            viewport_rows);
                        const int current_top = was_follow_tail
                            ? max_top
                            : state.chat_scroll_top_row;
                        const auto geometry =
                            acecode::tui::chat_scrollbar_thumb_geometry(
                                scrollbar_box.y_min, track_height,
                                state.drag_scrollbar_snapshot, snapshot_count,
                                viewport_rows, current_top);
                        state.drag_scrollbar_grab_offset_2x =
                            acecode::tui::chat_scrollbar_grab_offset_2x(
                                mouse.y, geometry);
                        state.chat_scroll_top_row =
                            acecode::tui::chat_scrollbar_y_to_top_row_with_grab(
                                mouse.y, scrollbar_box.y_min, geometry,
                                state.drag_scrollbar_grab_offset_2x);
                        auto [idx, off] = acecode::tui::chat_focus_from_display_row(
                            state.drag_scrollbar_snapshot, snapshot_count,
                            state.chat_scroll_top_row);
                        if (idx >= 0) {
                            state.chat_focus_index = idx;
                            state.chat_line_offset = off;
                            state.chat_follow_tail =
                                state.chat_scroll_top_row >= max_top;
                        }
                        screen.PostEvent(Event::Custom);
                    };
                    auto move_chat_scrollbar_drag = [&]() {
                        const int track_height =
                            scrollbar_box.y_max - scrollbar_box.y_min + 1;
                        const int snapshot_count = static_cast<int>(
                            state.drag_scrollbar_snapshot.size());
                        const int viewport_rows = chat_viewport_rows();
                        const auto geometry =
                            acecode::tui::chat_scrollbar_thumb_geometry(
                                scrollbar_box.y_min, track_height,
                                state.drag_scrollbar_snapshot, snapshot_count,
                                viewport_rows, state.chat_scroll_top_row);
                        state.chat_scroll_top_row =
                            acecode::tui::chat_scrollbar_y_to_top_row_with_grab(
                                mouse.y, scrollbar_box.y_min, geometry,
                                state.drag_scrollbar_grab_offset_2x);
                        auto [idx, off] = acecode::tui::chat_focus_from_display_row(
                            state.drag_scrollbar_snapshot, snapshot_count,
                            state.chat_scroll_top_row);
                        if (idx >= 0) {
                            state.chat_focus_index = idx;
                            state.chat_line_offset = off;
                            state.chat_follow_tail =
                                state.chat_scroll_top_row >= geometry.max_top_row;
                        }
                        screen.PostEvent(Event::Custom);
                    };
                    auto end_chat_drag_state = [&]() {
                        state.drag_left_pressed = false;
                        state.drag_phase = drag_scroll::Phase::Idle;
                        state.last_drag_scroll_at = {};
                    };
                    auto end_chat_scrollbar_drag = [&]() {
                        state.drag_scrollbar_phase =
                            TuiState::DragScrollbarPhase::Idle;
                        state.drag_scrollbar_snapshot.clear();
                        state.drag_scrollbar_grab_offset_2x = 0;
                    };
#if ACECODE_TUI_INPUT_TRACE
                    LOG_DEBUG("[input] ask overlay mouse path " +
                              event_for_log(event) +
                              " ask_scroll_offset=" +
                              std::to_string(state.ask_scroll_offset) +
                              " ask_rows=" +
                              std::to_string(state.ask_scroll_total_rows) +
                              "/" +
                              std::to_string(state.ask_scroll_visible_rows) +
                              " ask_scrollbar=" +
                              box_for_log(ask_scrollbar_box) +
                              " ask_overlay=" + box_for_log(ask_overlay_box) +
                              " chat_box=" + box_for_log(chat_box) +
                              " scrollbar_box=" + box_for_log(scrollbar_box));
#endif

                    if (mouse.button == Mouse::Right &&
                        mouse.motion == Mouse::Pressed) {
                        std::string sel = screen.GetSelection();
                        if (!sel.empty()) {
                            lk.unlock();
                            auto clipboard_write =
                                acecode::write_system_clipboard_text(sel);
                            std::string status_msg;
                            if (clipboard_write) {
                                status_msg = "Copied " +
                                             std::to_string(sel.size()) +
                                             " bytes to clipboard";
                            } else if (
                                clipboard_write.status !=
                                ClipboardTextWriteResult::Status::TooLarge) {
                                std::string seq = "\x1b]52;c;" +
                                                  base64_encode(sel) + "\x1b\\";
                                std::fwrite(seq.data(), 1, seq.size(), stdout);
                                std::fflush(stdout);
                                status_msg = "Sent OSC 52 copy request";
                            } else {
                                status_msg = clipboard_copy_status_message(
                                    clipboard_write.status);
                            }
                            lk.lock();
                            set_transient_status_line_locked(state, status_msg);
                            screen.PostEvent(Event::Custom);
                        }
                        return true;
                    }

                    if (state.ask_scrollbar_dragging) {
                        if (mouse.motion == Mouse::Released) {
                            state.ask_scrollbar_dragging = false;
                            screen.PostEvent(Event::Custom);
                            return true;
                        }
                        if (mouse.motion == Mouse::Moved) {
                            scroll_ask_to_mouse_y(mouse.y);
                            screen.PostEvent(Event::Custom);
                            return true;
                        }
                    }

                    if (state.drag_scrollbar_phase ==
                        TuiState::DragScrollbarPhase::Dragging) {
                        if (mouse.motion == Mouse::Released) {
                            end_chat_scrollbar_drag();
                            screen.PostEvent(Event::Custom);
                            return true;
                        }
                        if (mouse.motion == Mouse::Moved) {
                            move_chat_scrollbar_drag();
                            return true;
                        }
                    }

                    if (mouse.button == Mouse::Left &&
                        mouse.motion == Mouse::Pressed &&
                        state.ask_scroll_total_rows >
                            state.ask_scroll_visible_rows &&
                        contains_box(ask_scrollbar_box, mouse.x, mouse.y)) {
                        state.ask_scrollbar_dragging = true;
                        scroll_ask_to_mouse_y(mouse.y);
                        screen.PostEvent(Event::Custom);
                        return true;
                    }

                    if (mouse.button == Mouse::Left &&
                        mouse.motion == Mouse::Pressed &&
                        contains_box(scrollbar_box, mouse.x, mouse.y)) {
                        begin_chat_scrollbar_drag();
                        return true;
                    }

                    if (mouse.button == Mouse::Left &&
                        mouse.motion == Mouse::Pressed &&
                        contains_box(chat_box, mouse.x, mouse.y) &&
                        !contains_box(scrollbar_box, mouse.x, mouse.y)) {
                        state.drag_left_pressed = true;
                        state.last_mouse_x = mouse.x;
                        state.last_mouse_y = mouse.y;
                        state.drag_phase = drag_scroll::Phase::Dragging;
                        state.last_drag_scroll_at = {};
                        return false;
                    }

                    if (mouse.button == Mouse::Left &&
                        mouse.motion == Mouse::Pressed) {
                        // Everything except explicit scrollbar hits remains
                        // selectable while a question is pending. Returning
                        // false is important: App::HandleSelection only keeps
                        // the drag selection alive when the component did not
                        // consume the mouse event.
                        return false;
                    }

                    if (mouse.motion == Mouse::Moved &&
                        state.drag_left_pressed) {
                        state.last_mouse_x = mouse.x;
                        state.last_mouse_y = mouse.y;
                        auto new_phase = drag_scroll::classify(
                            mouse.y, chat_box.y_min, chat_box.y_max, true,
                            drag_scroll::Config{});
                        const bool phase_changed =
                            new_phase != state.drag_phase;
                        state.drag_phase = new_phase;
                        if (phase_changed &&
                            (new_phase == drag_scroll::Phase::ScrollingUp ||
                             new_phase == drag_scroll::Phase::ScrollingDown)) {
                            screen.PostEvent(Event::Custom);
                        }
                        return false;
                    }

                    if (mouse.button == Mouse::Left &&
                        mouse.motion == Mouse::Released &&
                        state.drag_left_pressed) {
                        end_chat_drag_state();
                        return false;
                    }

                    if (mouse.button == Mouse::Left &&
                        (mouse.motion == Mouse::Moved ||
                         mouse.motion == Mouse::Released)) {
                        return false;
                    }

                    if (mouse.motion == Mouse::Moved ||
                        mouse.motion == Mouse::Released) {
                        return false;
                    }

                    const bool is_wheel_event =
                        mouse.button == Mouse::WheelUp ||
                        mouse.button == Mouse::WheelDown;
                    const bool ask_mouse_target =
                        contains_box(ask_overlay_box, mouse.x, mouse.y) ||
                        contains_box(ask_scrollbar_box, mouse.x, mouse.y);
                    const bool chat_mouse_target =
                        acecode::tui::is_chat_mouse_target(
                            mouse.x, mouse.y, chat_box.x_min, chat_box.y_min,
                            chat_box.x_max, chat_box.y_max, is_wheel_event);

                    if (mouse.button == Mouse::WheelUp && ask_mouse_target) {
#if ACECODE_TUI_INPUT_TRACE
                        const int before = state.ask_scroll_offset;
#endif
                        const bool changed = scroll_ask_by_lines(-WHEEL_LINES);
#if ACECODE_TUI_INPUT_TRACE
                        LOG_DEBUG("[input] ask wheel up delta=-" +
                                  std::to_string(WHEEL_LINES) +
                                  " before=" + std::to_string(before) +
                                  " after=" +
                                  std::to_string(state.ask_scroll_offset) +
                                  " changed=" +
                                  std::string(changed ? "1" : "0"));
#endif
                        if (changed) {
                            screen.PostEvent(Event::Custom);
                        }
                        return true;
                    }
                    if (mouse.button == Mouse::WheelDown && ask_mouse_target) {
#if ACECODE_TUI_INPUT_TRACE
                        const int before = state.ask_scroll_offset;
#endif
                        const bool changed = scroll_ask_by_lines(WHEEL_LINES);
#if ACECODE_TUI_INPUT_TRACE
                        LOG_DEBUG("[input] ask wheel down delta=" +
                                  std::to_string(WHEEL_LINES) +
                                  " before=" + std::to_string(before) +
                                  " after=" +
                                  std::to_string(state.ask_scroll_offset) +
                                  " changed=" +
                                  std::string(changed ? "1" : "0"));
#endif
                        if (changed) {
                            screen.PostEvent(Event::Custom);
                        }
                        return true;
                    }

                    if (mouse.button == Mouse::WheelUp && chat_mouse_target) {
                        scroll_chat_from_ask(-WHEEL_LINES);
                        return true;
                    }
                    if (mouse.button == Mouse::WheelDown && chat_mouse_target) {
                        scroll_chat_from_ask(WHEEL_LINES);
                        return true;
                    }

                    if (mouse.button == Mouse::Left &&
                        mouse.motion == Mouse::Released) {
                        end_chat_drag_state();
                        end_chat_scrollbar_drag();
                    }
                    return true;
                }

                // Esc —— 整体拒绝。
                if (event == Event::Escape) {
                    if (state.ask_other_input_active) {
                        // 先退出 Other 文本模式,保留用户之前的选择。
                        state.ask_other_input_active = false;
                        state.input_text.clear(); state.pasted_texts.clear();
                        state.input_cursor = 0;
                    } else {
                        state.ask_result_ok = false;
                        state.ask_pending = false;
                        reset_ask_scroll_state();
                        state.ask_cv.notify_one();
                    }
                    screen.PostEvent(Event::Custom);
                    return true;
                }

                if (state.ask_other_input_active) {
                    if (event == Event::Return) {
                        std::string answer = state.input_text;
                        state.input_text.clear(); state.pasted_texts.clear();
                        state.input_cursor = 0;
                        state.ask_other_input_active = false;
                        state.ask_result_answers[q.question] = answer;

                        // 推进到下一题或提交。
                        advance_or_finish_question();
                        screen.PostEvent(Event::Custom);
                        return true;
                    }
                    // Other 输入态:委托 try_handle_ask_other_input 内联处理字符 /
                    // Backspace / Delete / 方向键 / Home / End。helper 返回 true
                    // 表示真的改了 state,我们才 PostEvent 请求重绘 —— Custom /
                    // Mouse 等未识别事件返回 false,**不能** PostEvent,否则
                    // "Custom → swallow → PostEvent(Custom)" 会形成事件自回环
                    // 把事件循环打爆(表现为 TUI 卡死)。无论哪种情况都 return
                    // true 消耗事件,防止透传到下游 shell-mode / slash-dropdown
                    // / Ctrl+E tool_result-expand 等 handler。
                    if (acecode::try_handle_ask_other_input(state, event)) {
                        screen.PostEvent(Event::Custom);
                    }
                    return true;
                }

                // 方向键 / j k 上下移动焦点。
                if (event == Event::ArrowUp ||
                    event == Event::Character('k')) {
                    state.ask_option_focus =
                        (state.ask_option_focus - 1 + total_rows) % total_rows;
                    state.ask_scroll_to_focus_requested = true;
                    screen.PostEvent(Event::Custom);
                    return true;
                }
                if (event == Event::ArrowDown ||
                    event == Event::Character('j')) {
                    state.ask_option_focus =
                        (state.ask_option_focus + 1) % total_rows;
                    state.ask_scroll_to_focus_requested = true;
                    screen.PostEvent(Event::Custom);
                    return true;
                }

                // Space —— 仅 multi-select 下对当前焦点项切换勾选;焦点落在
                // "Other..." 行时 Space 不作响应(Other 需要 Enter 进入文本态)。
                if (event == Event::Character(' ')) {
                    if (q.multi_select && state.ask_option_focus < option_count) {
                        if (static_cast<int>(state.ask_multi_selected.size()) <=
                            state.ask_option_focus) {
                            state.ask_multi_selected.resize(option_count, false);
                        }
                        state.ask_multi_selected[state.ask_option_focus] =
                            !state.ask_multi_selected[state.ask_option_focus];
                        screen.PostEvent(Event::Custom);
                    }
                    return true;
                }

                // Enter —— 提交当前题目。
                if (event == Event::Return) {
                    // 焦点在 "Other..." 行:进入自定义文本输入态。
                    if (state.ask_option_focus == option_count) {
                        state.ask_other_input_active = true;
                        state.input_text.clear(); state.pasted_texts.clear();
                        state.input_cursor = 0;
                        state.ask_scroll_to_focus_requested = true;
                        screen.PostEvent(Event::Custom);
                        return true;
                    }

                    std::string answer;
                    if (q.multi_select) {
                        for (int i = 0; i < option_count; ++i) {
                            if (i < static_cast<int>(state.ask_multi_selected.size()) &&
                                state.ask_multi_selected[i]) {
                                if (!answer.empty()) answer += ", ";
                                answer += q.options[i].label;
                            }
                        }
                        // 允许空选 —— 上游 schema 没强制,把空字符串交回给模型。
                    } else {
                        answer = q.options[state.ask_option_focus].label;
                    }
                    state.ask_result_answers[q.question] = answer;

                    // 推进或提交。
                    advance_or_finish_question();
                    screen.PostEvent(Event::Custom);
                    return true;
                }

                // 其它键一律吞掉 —— 不让字符进入 input_text(避免破坏下一次
                // "Other" 文本模式的初始状态)。
                return true;
            }
        }

        // Tool-confirmation overlay guard。confirm_pending=true 时键盘归 overlay
        // 所有 —— 上下方向移焦点 / 1-3 数字直选 / Enter 提交 / Shift+Tab 直选
        // option2 / Esc → Deny。其他键(字符 / Backspace / Tab 等)一律吞掉,
        // 防止误打字符串去到 input_text。优先级仅次于 ask_pending(二者互斥)。
        {
            std::unique_lock<std::mutex> lk(state.mu);
            if (state.confirm_pending) {
                auto submit = [&](PermissionResult r) {
                    state.input_text.clear(); state.pasted_texts.clear();
                    state.input_cursor = 0;
                    state.confirm_result = r;
                    state.confirm_pending = false;
                    state.confirm_cv.notify_one();
                    screen.PostEvent(Event::Custom);
                };

                if (event == Event::Escape) {
                    submit(PermissionResult::Deny);
                    return true;
                }
                if (event == Event::ArrowUp) {
                    state.confirm_focus = (state.confirm_focus + 2) % 3;
                    screen.PostEvent(Event::Custom);
                    return true;
                }
                if (event == Event::ArrowDown) {
                    state.confirm_focus = (state.confirm_focus + 1) % 3;
                    screen.PostEvent(Event::Custom);
                    return true;
                }
                if (event == Event::TabReverse) {
                    // Shift+Tab 直选 option2(AlwaysAllow),与 overlay 文案中
                    // "(shift+tab)" 提示一致。
                    submit(PermissionResult::AlwaysAllow);
                    return true;
                }
                if (event == Event::Return) {
                    int f = std::clamp(state.confirm_focus, 0, 2);
                    PermissionResult r = (f == 0) ? PermissionResult::Allow
                                       : (f == 1) ? PermissionResult::AlwaysAllow
                                                  : PermissionResult::Deny;
                    submit(r);
                    return true;
                }
                if (event.is_character()) {
                    const std::string& c = event.character();
                    if (c == "1") { submit(PermissionResult::Allow);       return true; }
                    if (c == "2") { submit(PermissionResult::AlwaysAllow); return true; }
                    if (c == "3") { submit(PermissionResult::Deny);        return true; }
                    // y/n 兼容老用户的肌肉记忆;也保留 'a' = always。
                    if (c == "y" || c == "Y") { submit(PermissionResult::Allow);       return true; }
                    if (c == "n" || c == "N") { submit(PermissionResult::Deny);        return true; }
                    if (c == "a" || c == "A") { submit(PermissionResult::AlwaysAllow); return true; }
                    // 其它字符吞掉,不让进入 input_text。
                    return true;
                }
                // 鼠标 / resize / custom 事件不拦截,让默认 handler 处理。
            }
        }

        // Rewind picker guard: target selection first, optional restore-mode
        // selection second. This owns navigation while active.
        {
            std::unique_lock<std::mutex> lk(state.mu);
            if (state.rewind_picker_active) {
                auto clear_picker = [&]() {
                    state.rewind_picker_active = false;
                    state.rewind_mode_active = false;
                    state.rewind_items.clear();
                    state.rewind_selected = 0;
                    state.rewind_view_offset = 0;
                    state.rewind_modes.clear();
                    state.rewind_mode_selected = 0;
                    state.rewind_callback = nullptr;
                };
                auto populate_modes = [&](const TuiState::RewindItem& item) {
                    state.rewind_modes.clear();
                    if (item.can_restore_code) {
                        state.rewind_modes.push_back({
                            TuiState::RewindRestoreMode::CodeAndConversation,
                            "Code and conversation",
                            "Restore tracked files, fork the conversation, and prefill the selected prompt."
                        });
                        state.rewind_modes.push_back({
                            TuiState::RewindRestoreMode::ConversationOnly,
                            "Conversation only",
                            "Fork the conversation and prefill the selected prompt."
                        });
                        state.rewind_modes.push_back({
                            TuiState::RewindRestoreMode::CodeOnly,
                            "Code only",
                            "Restore tracked files without changing the conversation."
                        });
                    } else {
                        state.rewind_modes.push_back({
                            TuiState::RewindRestoreMode::ConversationOnly,
                            "Conversation only",
                            "Fork the conversation and prefill the selected prompt."
                        });
                    }
                    state.rewind_modes.push_back({
                        TuiState::RewindRestoreMode::NeverMind,
                        "Never mind",
                        "Cancel rewind."
                    });
                    state.rewind_mode_selected = 0;
                };
                auto commit_mode = [&](TuiState::RewindRestoreMode mode) {
                    if (state.rewind_selected < 0 ||
                        state.rewind_selected >= static_cast<int>(state.rewind_items.size())) {
                        clear_picker();
                        screen.PostEvent(Event::Custom);
                        return;
                    }
                    auto item = state.rewind_items[state.rewind_selected];
                    auto cb = state.rewind_callback;
                    state.rewind_picker_active = false;
                    state.rewind_mode_active = false;
                    state.rewind_items.clear();
                    state.rewind_selected = 0;
                    state.rewind_view_offset = 0;
                    state.rewind_modes.clear();
                    state.rewind_mode_selected = 0;
                    state.rewind_callback = nullptr;
                    state.input_text.clear(); state.pasted_texts.clear();
                    state.input_cursor = 0;
                    if (cb) cb(std::move(item), mode);
                    clamp_chat_focus();
                    screen.PostEvent(Event::Custom);
                };

                if (event == Event::Escape) {
                    if (state.rewind_mode_active) {
                        state.rewind_mode_active = false;
                        state.rewind_modes.clear();
                        state.rewind_mode_selected = 0;
                    } else {
                        clear_picker();
                        state.conversation.push_back({"system", "Rewind cancelled.", false});
                        state.chat_follow_tail = true;
                        clamp_chat_focus();
                    }
                    screen.PostEvent(Event::Custom);
                    return true;
                }

                const bool move_up =
                    event == Event::ArrowUp || event == Event::Character('k');
                const bool move_down =
                    event == Event::ArrowDown || event == Event::Character('j');
                if (move_up || move_down) {
                    int* selected = state.rewind_mode_active
                        ? &state.rewind_mode_selected
                        : &state.rewind_selected;
                    int count = state.rewind_mode_active
                        ? static_cast<int>(state.rewind_modes.size())
                        : static_cast<int>(state.rewind_items.size());
                    if (count > 0) {
                        if (move_up) {
                            *selected = (*selected - 1 + count) % count;
                        } else {
                            *selected = (*selected + 1) % count;
                        }
                    }
                    if (!state.rewind_mode_active) {
                        state.rewind_view_offset = acecode::tui::scroll_to_keep_visible(
                            state.rewind_selected, state.rewind_view_offset,
                            acecode::tui::kRewindPickerVisibleRows,
                            static_cast<int>(state.rewind_items.size()));
                    }
                    screen.PostEvent(Event::Custom);
                    return true;
                }

                // PgUp/PgDn/Home/End: only the items list (not the 4-row mode
                // list) needs viewport navigation.
                if (!state.rewind_mode_active &&
                    (event == Event::PageUp || event == Event::PageDown ||
                     event == Event::Home || event == Event::End)) {
                    const int total = static_cast<int>(state.rewind_items.size());
                    if (total > 0) {
                        const int step = acecode::tui::kRewindPickerVisibleRows;
                        if (event == Event::PageUp) {
                            state.rewind_selected = std::max(0, state.rewind_selected - step);
                        } else if (event == Event::PageDown) {
                            state.rewind_selected = std::min(total - 1, state.rewind_selected + step);
                        } else if (event == Event::Home) {
                            state.rewind_selected = 0;
                        } else {  // End
                            state.rewind_selected = total - 1;
                        }
                        state.rewind_view_offset = acecode::tui::scroll_to_keep_visible(
                            state.rewind_selected, state.rewind_view_offset, step, total);
                        screen.PostEvent(Event::Custom);
                    }
                    return true;
                }

                auto activate_current_target = [&]() {
                    if (state.rewind_selected < 0 ||
                        state.rewind_selected >= static_cast<int>(state.rewind_items.size())) {
                        return;
                    }
                    const auto& item = state.rewind_items[state.rewind_selected];
                    if (item.can_restore_code) {
                        populate_modes(item);
                        state.rewind_mode_active = true;
                    } else {
                        commit_mode(TuiState::RewindRestoreMode::ConversationOnly);
                    }
                };

                if (event == Event::Return) {
                    if (state.rewind_mode_active) {
                        if (state.rewind_mode_selected >= 0 &&
                            state.rewind_mode_selected < static_cast<int>(state.rewind_modes.size())) {
                            auto mode = state.rewind_modes[state.rewind_mode_selected].mode;
                            commit_mode(mode);
                        }
                    } else {
                        activate_current_target();
                    }
                    screen.PostEvent(Event::Custom);
                    return true;
                }

                if (event.is_character()) {
                    std::string ch = event.character();
                    if (!ch.empty() && ch[0] >= '1' && ch[0] <= '9') {
                        int idx = ch[0] - '1';
                        if (state.rewind_mode_active) {
                            if (idx < static_cast<int>(state.rewind_modes.size())) {
                                state.rewind_mode_selected = idx;
                                auto mode = state.rewind_modes[idx].mode;
                                commit_mode(mode);
                            }
                        } else if (idx < static_cast<int>(state.rewind_items.size())) {
                            state.rewind_selected = idx;
                            activate_current_target();
                        }
                        screen.PostEvent(Event::Custom);
                    }
                    return true;
                }

                return true;
            }
        }

        // Slash-command dropdown guard: when the dropdown is open, intercept
        // the navigation/commit keys before any other overlay or input-history
        // handler gets them.
        {
            std::unique_lock<std::mutex> lk(state.mu);
            if (state.slash_dropdown_active && !state.slash_dropdown_items.empty()) {
                auto commit_selection = [&]() {
                    const auto& item = state.slash_dropdown_items[state.slash_dropdown_selected];
                    state.input_text = "/" + item.name + " ";
                    state.input_cursor = state.input_text.size();
                    state.slash_dropdown_active = false;
                    state.slash_dropdown_items.clear();
                    state.slash_dropdown_selected = 0;
                    state.slash_dropdown_view_offset = 0;
                    state.slash_dropdown_total_matches = 0;
                    state.slash_dropdown_dismissed_for_input = false;
                };
                const int n = static_cast<int>(state.slash_dropdown_items.size());
                auto follow_view = [&]() {
                    state.slash_dropdown_view_offset =
                        acecode::tui::scroll_to_keep_visible(
                            state.slash_dropdown_selected,
                            state.slash_dropdown_view_offset,
                            acecode::tui::kSlashDropdownVisibleRows, n);
                };
                if (event == Event::ArrowUp ||
                    event == Event::Special(std::string(1, '\x10'))) { // Ctrl+P
                    state.slash_dropdown_selected =
                        (state.slash_dropdown_selected - 1 + n) % n;
                    follow_view();
                    screen.PostEvent(Event::Custom);
                    return true;
                }
                if (event == Event::ArrowDown ||
                    event == Event::Special(std::string(1, '\x0E'))) { // Ctrl+N
                    state.slash_dropdown_selected =
                        (state.slash_dropdown_selected + 1) % n;
                    follow_view();
                    screen.PostEvent(Event::Custom);
                    return true;
                }
                if (event == Event::PageUp || event == Event::PageDown ||
                    event == Event::Home || event == Event::End) {
                    const int step = acecode::tui::kSlashDropdownVisibleRows;
                    if (event == Event::PageUp) {
                        state.slash_dropdown_selected =
                            std::max(0, state.slash_dropdown_selected - step);
                    } else if (event == Event::PageDown) {
                        state.slash_dropdown_selected =
                            std::min(n - 1, state.slash_dropdown_selected + step);
                    } else if (event == Event::Home) {
                        state.slash_dropdown_selected = 0;
                    } else {  // End
                        state.slash_dropdown_selected = n - 1;
                    }
                    follow_view();
                    screen.PostEvent(Event::Custom);
                    return true;
                }
                if (event == Event::Tab) {
                    commit_selection();
                    screen.PostEvent(Event::Custom);
                    return true;
                }
                if (event == Event::Return) {
                    commit_selection();
                    // Let the ordinary Enter handler below submit/dispatch the
                    // completed slash command.
                } else if (event == Event::Escape) {
                    state.slash_dropdown_active = false;
                    state.slash_dropdown_items.clear();
                    state.slash_dropdown_selected = 0;
                    state.slash_dropdown_view_offset = 0;
                    state.slash_dropdown_total_matches = 0;
                    state.slash_dropdown_dismissed_for_input = true;
                    screen.PostEvent(Event::Custom);
                    return true;
                }
            }
        }

        // Enter → submit message
        if (event == Event::Return) {
            std::unique_lock<std::mutex> lk(state.mu);

            // Handle resume picker: Enter confirms selection
            if (state.resume_picker_active) {
                if (state.resume_selected >= 0 &&
                    state.resume_selected < static_cast<int>(state.resume_items.size())) {
                    auto sid = state.resume_items[state.resume_selected].id;
                    auto cb = state.resume_callback;
                    state.resume_picker_active = false;
                    state.resume_items.clear();
                    state.resume_view_offset = 0;
                    state.resume_callback = nullptr;
                    state.input_text.clear(); state.pasted_texts.clear();
                    state.input_cursor = 0;
                    if (cb) cb(sid);
                    clamp_chat_focus();
                }
                screen.PostEvent(Event::Custom);
                return true;
            }

            // /model picker: Enter confirms,callback 在持 state.mu 的同
            // 一锁内跑(和 /resume 同款约定),完成后清状态 + post 一帧。
            if (state.model_picker_open) {
                if (state.model_picker_selected >= 0 &&
                    state.model_picker_selected <
                        static_cast<int>(state.model_picker_options.size())) {
                    auto name = state.model_picker_options[state.model_picker_selected].name;
                    auto cb = state.model_picker_callback;
                    state.model_picker_open = false;
                    state.model_picker_options.clear();
                    state.model_picker_selected = 0;
                    state.model_picker_view_offset = 0;
                    state.model_picker_callback = nullptr;
                    if (cb) cb(name);
                    clamp_chat_focus();
                }
                screen.PostEvent(Event::Custom);
                return true;
            }

            // confirm_pending 现在由上面的 confirm overlay handler 单独拦截
            // (Enter 直接走那条路径),这里不会再被 confirm 触发。

            if (state.input_text.empty() && state.pending_attachments.empty()) return true;
            if (!auth_done) return true;

            // Block message submission during compaction
            if (state.is_compacting) return true;

            // 多行粘贴折叠（fix-multiline-paste-input change）：把已知 [Pasted text #N]
            // 占位符替换回 pasted_texts 中存的全文，得到 expanded_prompt 喂给 agent_loop
            // / 斜杠命令 / pending 队列 / input_history / 对话气泡。提交后清空 input_text
            // 与 pasted_texts；next_paste_id 不复位（display 用计数，跨提交单调递增
            // 即可，避免极端情况下与 input_history 中残留占位符同号撞 ID）。
            //
            // 用户反馈：提交后对话气泡也显示展开版原文，而非紧凑占位符——所以这里
            // 没有保留单独的 `visible_prompt`，提交即一并展开上屏。
            const std::string expanded_prompt = acecode::tui::expand_placeholders(
                state.input_text, state.pasted_texts);
            const std::vector<nlohmann::json> attachments = state.pending_attachments;
            const std::string display_prompt =
                display_prompt_with_attachments(expanded_prompt, attachments);
            state.input_text.clear(); state.pasted_texts.clear();
            state.pending_attachments.clear();
            state.input_cursor = 0;
            refresh_slash_dropdown(state, cmd_registry);

            // 统一入口：内存 push + 磁盘 append。空白 / 相邻重复被抑制，保持磁盘与内存
            // 行为一致；磁盘持久化受 config.input_history.enabled 控制。
            auto record_history = [&state, &config, &working_dir](const std::string& entry) {
                auto is_all_space = [](const std::string& s) {
                    for (unsigned char c : s) {
                        if (!std::isspace(c)) return false;
                    }
                    return true;
                };
                if (entry.empty() || is_all_space(entry)) return;
                if (!state.input_history.empty() && state.input_history.back() == entry) return;
                state.input_history.push_back(entry);
                if (config.input_history.enabled) {
                    std::string path = InputHistoryStore::file_path(
                        SessionStorage::get_project_dir(working_dir));
                    InputHistoryStore::append(path, entry, config.input_history.max_entries);
                }
            };

            // Shell input mode: dispatch directly to BashTool via agent worker.
            // Skips slash-command parsing and LLM round-trip.
            if (state.input_mode == InputMode::Shell) {
                if (!attachments.empty()) {
                    set_transient_status_line_locked(
                        state,
                        "Image attachments are only supported in normal prompt mode");
                    state.input_text = expanded_prompt;
                    state.input_cursor = state.input_text.size();
                    state.pending_attachments = attachments;
                    screen.PostEvent(Event::Custom);
                    return true;
                }
                const std::string shell_cmd = expanded_prompt;
                record_history(prepend_mode_prefix(shell_cmd, InputMode::Shell));
                state.history_index = -1;
                state.input_mode = InputMode::Normal;

                // 提交后对话气泡显示展开后的原文（用户反馈：上屏不要看到 [] 占位符）。
                state.conversation.push_back({"user", "!" + shell_cmd, false});
                state.chat_follow_tail = true;
                clamp_chat_focus();
                state.current_thinking_phrase = "Running shell";
                state.thinking_start_time = std::chrono::steady_clock::now();
                state.streaming_output_chars = 0;
                state.last_completion_tokens_authoritative = 0;
                state.is_waiting = true;
                agent_loop.submit_shell(shell_cmd);
                return true;
            }

            // Record history（用 expanded_prompt：上箭头取回原文，再次提交不会发出
            // 字面 [Pasted text #N] —— 因为本会话提交后 store 已经清空，未展开的
            // 字面占位符在下次 submit 时也会按 unknown id 保留，丢失原文。）
            record_history(expanded_prompt);
            state.history_index = -1;

            // Slash command interception（用 expanded_prompt 派发：spec 4.3）。
            if (attachments.empty() && !expanded_prompt.empty() && expanded_prompt[0] == '/') {
                CommandContext cmd_ctx{
                    state, agent_loop, &provider_slot,
                    config, token_tracker,
                    permissions,
                    [&screen]() { screen.Exit(); },
                    &session_manager,
                    [&screen]() { screen.PostEvent(Event::Custom); },
                    &mcp_manager,
                    &tools,
                    &skill_registry,
                    &memory_registry,
                    &cmd_registry,
                    working_dir
                };
                lk.unlock();
                bool handled = cmd_registry.dispatch(expanded_prompt, cmd_ctx);
                if (handled) {
                    lk.lock();
                    clamp_chat_focus();
                    screen.PostEvent(Event::Custom);
                    return true;
                }
                lk.lock();
                // If not a known command, fall through to send as normal prompt
            }

            if (state.is_waiting) {
                // 队列保存展开版（spec 4.5）；提交后气泡显示展开版（用户反馈：
                // 上屏不要看到 [] 占位符）。
                state.pending_queue.push_back(display_prompt);
                if (!attachments.empty()) {
                    state.pending_structured_queue.push_back(
                        build_user_input_with_attachments(
                            expanded_prompt, display_prompt, attachments));
                }
            } else {
                lk.unlock();
                coordinate_mcp_before_first_turn();
                lk.lock();
                state.conversation.push_back({"user", display_prompt, false});
                state.chat_follow_tail = true;
                clamp_chat_focus();
                state.current_thinking_phrase = get_random_thinking_phrase(is_user_chinese(state));
                state.thinking_start_time = std::chrono::steady_clock::now();
                state.streaming_output_chars = 0;
                state.last_completion_tokens_authoritative = 0;
                state.is_waiting = true;
                if (attachments.empty()) {
                    agent_loop.submit(expanded_prompt);
                } else {
                    agent_loop.submit(build_user_input_with_attachments(
                        expanded_prompt, display_prompt, attachments));
                }
            }
            return true;
        }
        // /resume picker viewport navigation: PgUp/PgDn jump a full window,
        // Home/End jump to first/last item. Must short-circuit before chat
        // scroll handlers so the picker absorbs these keys exclusively.
        if (event == Event::PageUp || event == Event::PageDown ||
            event == Event::Home || event == Event::End) {
            std::lock_guard<std::mutex> lk(state.mu);
            if (state.resume_picker_active) {
                const int total = static_cast<int>(state.resume_items.size());
                if (total > 0) {
                    const int step = acecode::tui::kResumePickerVisibleRows;
                    if (event == Event::PageUp) {
                        state.resume_selected = std::max(0, state.resume_selected - step);
                    } else if (event == Event::PageDown) {
                        state.resume_selected = std::min(total - 1, state.resume_selected + step);
                    } else if (event == Event::Home) {
                        state.resume_selected = 0;
                    } else {  // End
                        state.resume_selected = total - 1;
                    }
                    state.resume_view_offset = acecode::tui::scroll_to_keep_visible(
                        state.resume_selected, state.resume_view_offset, step, total);
                    screen.PostEvent(Event::Custom);
                }
                return true;
            }
            if (state.model_picker_open) {
                const int total = static_cast<int>(state.model_picker_options.size());
                if (total > 0) {
                    const int step = acecode::tui::kResumePickerVisibleRows;
                    if (event == Event::PageUp) {
                        state.model_picker_selected =
                            std::max(0, state.model_picker_selected - step);
                    } else if (event == Event::PageDown) {
                        state.model_picker_selected =
                            std::min(total - 1, state.model_picker_selected + step);
                    } else if (event == Event::Home) {
                        state.model_picker_selected = 0;
                    } else {  // End
                        state.model_picker_selected = total - 1;
                    }
                    state.model_picker_view_offset = acecode::tui::scroll_to_keep_visible(
                        state.model_picker_selected, state.model_picker_view_offset,
                        step, total);
                    screen.PostEvent(Event::Custom);
                }
                return true;
            }
        }
        if (event == Event::PageUp) {
            std::lock_guard<std::mutex> lk(state.mu);
            sync_chat_line_counts_from_layout();
            // page_keys_single_line 默认开启:把 PgUp 当作单行滚动,等同 Alt+↑.
            // 适用于吞掉 Alt+方向键序列的终端 (老 conhost / Cmder / 部分 SSH 客户端).
            int step = config.tui.page_keys_single_line
                ? 1
                : std::max(1, (chat_box.y_max - chat_box.y_min + 1) - 2);  // 视口高度 -2 留重叠
            const int before_top = state.chat_scroll_top_row;
            const int before_focus = state.chat_focus_index;
            const int before_offset = state.chat_line_offset;
            const bool before_follow_tail = state.chat_follow_tail;
            const int actual = scroll_chat_by_lines(-step);
#if ACECODE_TUI_INPUT_TRACE
            const int max_top = acecode::tui::chat_max_scroll_top_row(
                message_line_counts,
                static_cast<int>(state.conversation.size()),
                chat_viewport_rows());
            LOG_DEBUG("[input] chat page up step=" + std::to_string(step) +
                      " actual=" + std::to_string(actual) +
                      " top=" + std::to_string(before_top) + "->" +
                      std::to_string(state.chat_scroll_top_row) +
                      " max_top=" + std::to_string(max_top) +
                      " focus=" + std::to_string(before_focus) + "->" +
                      std::to_string(state.chat_focus_index) +
                      " offset=" + std::to_string(before_offset) + "->" +
                      std::to_string(state.chat_line_offset) +
                      " follow_tail=" +
                      std::string(before_follow_tail ? "1" : "0") + "->" +
                      std::string(state.chat_follow_tail ? "1" : "0"));
#endif
            if (actual != 0) {
                screen.PostEvent(Event::Custom);
            }
            return true;
        }
        if (event == Event::PageDown) {
            std::lock_guard<std::mutex> lk(state.mu);
            sync_chat_line_counts_from_layout();
            int step = config.tui.page_keys_single_line
                ? 1
                : std::max(1, (chat_box.y_max - chat_box.y_min + 1) - 2);
            const int before_top = state.chat_scroll_top_row;
            const int before_focus = state.chat_focus_index;
            const int before_offset = state.chat_line_offset;
            const bool before_follow_tail = state.chat_follow_tail;
            const int actual = scroll_chat_by_lines(step);
#if ACECODE_TUI_INPUT_TRACE
            const int max_top = acecode::tui::chat_max_scroll_top_row(
                message_line_counts,
                static_cast<int>(state.conversation.size()),
                chat_viewport_rows());
            LOG_DEBUG("[input] chat page down step=" + std::to_string(step) +
                      " actual=" + std::to_string(actual) +
                      " top=" + std::to_string(before_top) + "->" +
                      std::to_string(state.chat_scroll_top_row) +
                      " max_top=" + std::to_string(max_top) +
                      " focus=" + std::to_string(before_focus) + "->" +
                      std::to_string(state.chat_focus_index) +
                      " offset=" + std::to_string(before_offset) + "->" +
                      std::to_string(state.chat_line_offset) +
                      " follow_tail=" +
                      std::string(before_follow_tail ? "1" : "0") + "->" +
                      std::string(state.chat_follow_tail ? "1" : "0"));
#endif
            if (actual != 0) {
                screen.PostEvent(Event::Custom);
            }
            return true;
        }
        // Alt+Up / Alt+Down: 按单行滚动聊天视图. 与 ArrowUp/Down 的"按消息历史
        // 导航"区分开 —— 这里走 scroll_chat_by_lines(±1), 跨消息边界时由 lambda
        // 自行进位 chat_focus_index + chat_line_offset. 序列 `\x1B[1;3A`/`B` 是
        // xterm modifyOtherKeys 标准, Windows Terminal / Alacritty / iTerm2 /
        // kitty / Konsole / GNOME Terminal 都走这一编码. 上面 overlay 守卫会
        // 提前 return, 这里不再重复 ask/confirm/rewind/slash 检查; 仅 resume
        // picker 没有"全局吞键"逻辑, 单独让位.
        if (event == Event::Special("\x1B[1;3A")) {
            std::lock_guard<std::mutex> lk(state.mu);
            if (state.resume_picker_active) return true;
            if (state.model_picker_open) return true;
            sync_chat_line_counts_from_layout();
            if (scroll_chat_by_lines(-1) != 0) {
                screen.PostEvent(Event::Custom);
            }
            return true;
        }
        if (event == Event::Special("\x1B[1;3B")) {
            std::lock_guard<std::mutex> lk(state.mu);
            if (state.resume_picker_active) return true;
            if (state.model_picker_open) return true;
            sync_chat_line_counts_from_layout();
            if (scroll_chat_by_lines(1) != 0) {
                screen.PostEvent(Event::Custom);
            }
            return true;
        }
        if (event == Event::Home) {
            std::lock_guard<std::mutex> lk(state.mu);
            if (!state.conversation.empty()) {
                state.chat_scroll_top_row = 0;
                state.chat_focus_index = 0;
                state.chat_line_offset = 0;
                state.chat_follow_tail = false;
                screen.PostEvent(Event::Custom);
            }
            return true;
        }
        if (event == Event::End) {
            std::lock_guard<std::mutex> lk(state.mu);
            if (!state.conversation.empty()) {
                state.chat_follow_tail = true;
                clamp_chat_focus();
                screen.PostEvent(Event::Custom);
            }
            return true;
        }
        if (event == Event::Escape) {
            std::lock_guard<std::mutex> lk(state.mu);
            // drag-autoscroll: Esc 中止任何进行中的拖动自动滚动. 选区本身由
            // 下游 FTXUI 通过 `handled=true` 情况下的 HandleSelection 清空
            // (如果之前有选择). 我们只负责把自己的状态机拉回 Idle.
            if (state.drag_left_pressed ||
                state.drag_phase != drag_scroll::Phase::Idle) {
                state.drag_left_pressed = false;
                state.drag_phase = drag_scroll::Phase::Idle;
                state.last_drag_scroll_at = {};
            }
            // Escape during resume picker → cancel
            if (state.resume_picker_active) {
                state.resume_picker_active = false;
                state.resume_items.clear();
                state.resume_view_offset = 0;
                state.resume_callback = nullptr;
                state.input_text.clear(); state.pasted_texts.clear();
                state.input_cursor = 0;
                state.conversation.push_back({"system", "Resume cancelled.", false});
                state.chat_follow_tail = true;
                clamp_chat_focus();
                screen.PostEvent(Event::Custom);
                return true;
            }
            // Escape during /model picker → cancel(不写气泡 —— 保持安静,
            // 用户大概率只是看了一眼当前模型就关掉)。
            if (state.model_picker_open) {
                state.model_picker_open = false;
                state.model_picker_options.clear();
                state.model_picker_selected = 0;
                state.model_picker_view_offset = 0;
                state.model_picker_callback = nullptr;
                clamp_chat_focus();
                screen.PostEvent(Event::Custom);
                return true;
            }
            // confirm_pending 的 Esc → Deny 已由上面的 confirm overlay handler
            // 拦截,这里不再重复处理。

            // Shell mode: Escape exits and clears the buffer. Takes precedence
            // over `is_waiting` abort so typing Esc in shell mode never fires
            // an unintended cancel on a pending agent turn.
            if (state.input_mode == InputMode::Shell) {
                cancel_ctrl_c_exit_locked();
                state.input_mode = InputMode::Normal;
                state.input_text.clear(); state.pasted_texts.clear();
                state.input_cursor = 0;
                return true;
            }
            if (!state.pending_attachments.empty() && state.input_text.empty()) {
                cancel_ctrl_c_exit_locked();
                state.pending_attachments.clear();
                set_transient_status_line_locked(state, "Cleared pending attachments");
                screen.PostEvent(Event::Custom);
                return true;
            }
            if (state.is_waiting || state.tool_running) {
                agent_loop.cancel();
                return true;
            }
        }
        // Ctrl+P: cycle permission mode
        if (event == Event::Special(std::string(1, '\x10'))) {
            std::lock_guard<std::mutex> lk(state.mu);
            if (!state.is_waiting && !state.confirm_pending) {
                const PermissionMode before = permissions.mode();
                auto new_mode = permissions.cycle_mode();
                session_manager.set_permission_mode(PermissionManager::mode_name(new_mode));
                if (new_mode == PermissionMode::Plan) {
                    session_manager.set_pre_plan_permission_mode(
                        PermissionManager::mode_name(
                            before == PermissionMode::Plan
                                ? permissions.pre_plan_mode()
                                : before));
                    session_manager.ensure_plan_file_path();
                }
                state.conversation.push_back({"system",
                    std::string("Permission mode: ") + PermissionManager::mode_name(new_mode) +
                    " - " + PermissionManager::mode_description(new_mode), false});
                clamp_chat_focus();
                screen.PostEvent(Event::Custom);
            }
            return true;
        }
        if (event.is_mouse()) {
            auto& mouse = event.mouse();

            // mouse-selection-copy / clipboard-paste: right-click copies the
            // current FTXUI selection to the system clipboard. With no
            // selection, terminal mouse tracking prevents the host context menu
            // on many Linux terminals, so use the click as an explicit
            // clipboard paste.
            if (mouse.button == Mouse::Right && mouse.motion == Mouse::Pressed) {
                std::string sel = screen.GetSelection();
                if (sel.empty()) {
                    return paste_system_clipboard_text();
                }
                auto clipboard_write = acecode::write_system_clipboard_text(sel);
                std::string status_msg;
                if (clipboard_write) {
                    status_msg = "Copied " + std::to_string(sel.size()) +
                                 " bytes to clipboard";
                    LOG_INFO("Copied " + std::to_string(sel.size()) +
                             " bytes to clipboard via system clipboard");
                } else if (
                    clipboard_write.status != ClipboardTextWriteResult::Status::TooLarge) {
                    std::string seq = "\x1b]52;c;" + base64_encode(sel) + "\x1b\\";
                    std::fwrite(seq.data(), 1, seq.size(), stdout);
                    std::fflush(stdout);
                    status_msg = "Sent OSC 52 copy request";
                    LOG_INFO("Sent OSC 52 copy request for " +
                             std::to_string(sel.size()) + " bytes");
                } else {
                    status_msg = clipboard_copy_status_message(clipboard_write.status);
                    LOG_WARN(status_msg);
                }
                {
                    std::lock_guard<std::mutex> lk(state.mu);
                    set_transient_status_line_locked(state, status_msg);
                }
                screen.PostEvent(Event::Custom);
                return true;
            }

            // draggable-thick-scrollbar: 左键 Pressed 落在滚动条列时,优先
            // 进入"拖滚动条"分支,跳过下面的 drag-select 启动。两态互斥 ——
            // 一次按下不会同时开始选区拖拽和滚动条拖拽。
            if (mouse.button == Mouse::Left && mouse.motion == Mouse::Pressed &&
                scrollbar_box.Contain(mouse.x, mouse.y)) {
                std::lock_guard<std::mutex> lk(state.mu);
                sync_chat_line_counts_from_layout();
                // 快照 message_line_counts —— 流式输出追加新行时,拖动期间的
                // y → line 映射继续按按下瞬间的几何走,不被指针下扯走。
                state.drag_scrollbar_snapshot = message_line_counts;
                state.drag_scrollbar_phase = TuiState::DragScrollbarPhase::Dragging;
                const bool was_follow_tail = state.chat_follow_tail;
                // 一旦用户主动操纵滚动条,就视为离开尾巴跟随;松手时不自动恢复。
                state.chat_follow_tail = false;
                int track_height = scrollbar_box.y_max - scrollbar_box.y_min + 1;
                const int snapshot_count =
                    static_cast<int>(state.drag_scrollbar_snapshot.size());
                const int viewport_rows = chat_viewport_rows();
                const int max_top = acecode::tui::chat_max_scroll_top_row(
                    state.drag_scrollbar_snapshot, snapshot_count,
                    viewport_rows);
                const int current_top = was_follow_tail
                    ? max_top
                    : state.chat_scroll_top_row;
                const auto geometry =
                    acecode::tui::chat_scrollbar_thumb_geometry(
                        scrollbar_box.y_min, track_height,
                        state.drag_scrollbar_snapshot, snapshot_count,
                        viewport_rows, current_top);
                state.drag_scrollbar_grab_offset_2x =
                    acecode::tui::chat_scrollbar_grab_offset_2x(mouse.y,
                                                                geometry);
                const int previous_top = state.chat_scroll_top_row;
                state.chat_scroll_top_row =
                    acecode::tui::chat_scrollbar_y_to_top_row_with_grab(
                        mouse.y, scrollbar_box.y_min, geometry,
                        state.drag_scrollbar_grab_offset_2x);
                auto [idx, off] = acecode::tui::chat_focus_from_display_row(
                    state.drag_scrollbar_snapshot, snapshot_count,
                    state.chat_scroll_top_row);
                if (idx >= 0) {
                    state.chat_focus_index = idx;
                    state.chat_line_offset = off;
                    // 拖到底自然恢复 follow_tail;中间位置保持手动滚动。
                    state.chat_follow_tail = state.chat_scroll_top_row >= max_top;
                }
#if ACECODE_TUI_INPUT_TRACE
                LOG_DEBUG("[scrollbar] pressed mouse=(" +
                          std::to_string(mouse.x) + "," +
                          std::to_string(mouse.y) + ") track=" +
                          box_for_log(scrollbar_box) +
                          " track_height=" + std::to_string(track_height) +
                          " viewport_rows=" + std::to_string(viewport_rows) +
                          " messages=" + std::to_string(snapshot_count) +
                          " was_follow_tail=" +
                          std::string(was_follow_tail ? "1" : "0") +
                          " current_top=" + std::to_string(current_top) +
                          " previous_top=" + std::to_string(previous_top) +
                          " new_top=" +
                          std::to_string(state.chat_scroll_top_row) +
                          " max_top=" + std::to_string(max_top) +
                          " grab2x=" +
                          std::to_string(
                              state.drag_scrollbar_grab_offset_2x) +
                          " geometry=" +
                          scrollbar_geometry_for_log(geometry) +
                          " focus=" + std::to_string(state.chat_focus_index) +
                          " offset=" +
                          std::to_string(state.chat_line_offset) +
                          " follow_tail=" +
                          std::string(state.chat_follow_tail ? "1" : "0"));
#endif
                screen.PostEvent(Event::Custom);
                return true;
            }

            // drag-autoscroll: 跟踪左键按下/拖动/释放, 驱动 anim_thread 在用户
            // 把鼠标拖到 chat_box 顶部/底部时自动滚动并补偿 selection 坐标.
            // 不 return true, 让事件继续流向 FTXUI 的 HandleSelection 走原本的
            // 选区更新. Release/Moved 不做 chat_box.Contain 限制, 因为用户常常
            // 会把鼠标拖到窗口外松开, 此时我们仍要把状态机拉回 Idle.
            if (mouse.button == Mouse::Left) {
                if (mouse.motion == Mouse::Pressed) {
                    // draggable-thick-scrollbar: 落在滚动条列上的 Pressed 已经
                    // 在上一个分支被吞掉,这里只剩内容区的左键按下 → 启动选区拖拽。
                    if (chat_box.Contain(mouse.x, mouse.y) &&
                        !scrollbar_box.Contain(mouse.x, mouse.y)) {
                        std::lock_guard<std::mutex> lk(state.mu);
#if ACECODE_TUI_INPUT_TRACE
                        LOG_DEBUG("[drag-select] pressed start mouse=(" +
                                  std::to_string(mouse.x) + "," +
                                  std::to_string(mouse.y) + ") chat_box=" +
                                  box_for_log(chat_box) + " scrollbar_box=" +
                                  box_for_log(scrollbar_box) + " focus=" +
                                  std::to_string(state.chat_focus_index) +
                                  " offset=" +
                                  std::to_string(state.chat_line_offset) +
                                  " previous_phase=" +
                                  drag_phase_for_log(state.drag_phase));
#endif
                        state.drag_left_pressed = true;
                        state.last_mouse_x = mouse.x;
                        state.last_mouse_y = mouse.y;
                        state.drag_phase = drag_scroll::Phase::Dragging;
                        state.last_drag_scroll_at = {};
                    }
                } else if (mouse.motion == Mouse::Released) {
                    std::lock_guard<std::mutex> lk(state.mu);
#if ACECODE_TUI_INPUT_TRACE
                    if (state.drag_scrollbar_phase ==
                        TuiState::DragScrollbarPhase::Dragging) {
                        LOG_DEBUG("[scrollbar] released mouse=(" +
                                  std::to_string(mouse.x) + "," +
                                  std::to_string(mouse.y) + ") track=" +
                                  box_for_log(scrollbar_box) + " top=" +
                                  std::to_string(state.chat_scroll_top_row) +
                                  " grab2x=" +
                                  std::to_string(
                                      state.drag_scrollbar_grab_offset_2x) +
                                  " focus=" +
                                  std::to_string(state.chat_focus_index) +
                                  " offset=" +
                                  std::to_string(state.chat_line_offset) +
                                  " follow_tail=" +
                                  std::string(state.chat_follow_tail ? "1"
                                                                      : "0"));
                    }
                    LOG_DEBUG("[drag-select] released mouse=(" +
                              std::to_string(mouse.x) + "," +
                              std::to_string(mouse.y) + ") phase=" +
                              drag_phase_for_log(state.drag_phase) +
                              " left_pressed=" +
                              std::to_string(state.drag_left_pressed ? 1 : 0) +
                              " focus=" +
                              std::to_string(state.chat_focus_index) +
                              " offset=" +
                              std::to_string(state.chat_line_offset));
#endif
                    state.drag_left_pressed = false;
                    state.drag_phase = drag_scroll::Phase::Idle;
                    state.last_drag_scroll_at = {};
                    // draggable-thick-scrollbar: 任何左键 Released 都把滚动条
                    // 拖拽态拉回 Idle,即使释放点已经离开滚动条列(用户经常
                    // 拖出窗口外松开)。chat_follow_tail 不在这里恢复 —— 用户
                    // 显式滚到了非尾位置,只在拖到底时由 Pressed 分支重新开启。
                    state.drag_scrollbar_phase = TuiState::DragScrollbarPhase::Idle;
                    state.drag_scrollbar_snapshot.clear();
                    state.drag_scrollbar_grab_offset_2x = 0;
                }
            }
            // 终端在拖动期间发 Moved 事件, button 字段通常是 None 而不是 Left.
            // 我们靠自己维护的 drag_left_pressed 判断是否处于拖动中.
            if (mouse.motion == Mouse::Moved) {
                std::lock_guard<std::mutex> lk(state.mu);
                // draggable-thick-scrollbar: 滚动条拖拽优先级高于 drag-select
                // —— 两态互斥,Pressed 分支保证只可能进一态。直接 early return,
                // 不让下面的 drag-autoscroll 分类运行,避免拖滚动条时选区被误激活。
                if (state.drag_scrollbar_phase ==
                    TuiState::DragScrollbarPhase::Dragging) {
                    int track_height =
                        scrollbar_box.y_max - scrollbar_box.y_min + 1;
                    const int snapshot_count =
                        static_cast<int>(state.drag_scrollbar_snapshot.size());
                    const int viewport_rows = chat_viewport_rows();
                    const int previous_top = state.chat_scroll_top_row;
                    const auto geometry =
                        acecode::tui::chat_scrollbar_thumb_geometry(
                            scrollbar_box.y_min, track_height,
                            state.drag_scrollbar_snapshot, snapshot_count,
                            viewport_rows, state.chat_scroll_top_row);
                    state.chat_scroll_top_row =
                        acecode::tui::chat_scrollbar_y_to_top_row_with_grab(
                            mouse.y, scrollbar_box.y_min, geometry,
                            state.drag_scrollbar_grab_offset_2x);
                    auto [idx, off] = acecode::tui::chat_focus_from_display_row(
                        state.drag_scrollbar_snapshot, snapshot_count,
                        state.chat_scroll_top_row);
                    if (idx >= 0) {
                        state.chat_focus_index = idx;
                        state.chat_line_offset = off;
                        state.chat_follow_tail =
                            state.chat_scroll_top_row >= geometry.max_top_row;
                    }
#if ACECODE_TUI_INPUT_TRACE
                    LOG_DEBUG("[scrollbar] moved mouse=(" +
                              std::to_string(mouse.x) + "," +
                              std::to_string(mouse.y) + ") track=" +
                              box_for_log(scrollbar_box) +
                              " track_height=" +
                              std::to_string(track_height) +
                              " viewport_rows=" +
                              std::to_string(viewport_rows) +
                              " messages=" +
                              std::to_string(snapshot_count) +
                              " top=" + std::to_string(previous_top) +
                              "->" +
                              std::to_string(state.chat_scroll_top_row) +
                              " max_top=" +
                              std::to_string(geometry.max_top_row) +
                              " grab2x=" +
                              std::to_string(
                                  state.drag_scrollbar_grab_offset_2x) +
                              " geometry=" +
                              scrollbar_geometry_for_log(geometry) +
                              " focus=" +
                              std::to_string(state.chat_focus_index) +
                              " offset=" +
                              std::to_string(state.chat_line_offset) +
                              " follow_tail=" +
                              std::string(state.chat_follow_tail ? "1" : "0"));
#endif
                    screen.PostEvent(Event::Custom);
                    return true;
                }
                if (state.drag_left_pressed) {
#if ACECODE_TUI_INPUT_TRACE
                    const auto previous_phase = state.drag_phase;
#endif
                    state.last_mouse_x = mouse.x;
                    state.last_mouse_y = mouse.y;
                    auto new_phase = drag_scroll::classify(
                        mouse.y, chat_box.y_min, chat_box.y_max, true,
                        drag_scroll::Config{});
                    bool phase_changed = (new_phase != state.drag_phase);
                    state.drag_phase = new_phase;
#if ACECODE_TUI_INPUT_TRACE
                    LOG_DEBUG("[drag-select] moved mouse=(" +
                              std::to_string(mouse.x) + "," +
                              std::to_string(mouse.y) + ") chat_box=" +
                              box_for_log(chat_box) + " phase=" +
                              drag_phase_for_log(previous_phase) + "->" +
                              drag_phase_for_log(new_phase) +
                              " changed=" +
                              std::to_string(phase_changed ? 1 : 0) +
                              " focus=" +
                              std::to_string(state.chat_focus_index) +
                              " offset=" +
                              std::to_string(state.chat_line_offset));
#endif
                    // 进入滚动阶段时立即 PostEvent, 让 anim_thread 尽快转到
                    // 50ms 间隔 + 跑第一次 tick. 不 PostEvent 也会在下个 300ms
                    // 唤醒读到新 phase, 但那个延迟体感很差.
                    if (phase_changed &&
                        (new_phase == drag_scroll::Phase::ScrollingUp ||
                         new_phase == drag_scroll::Phase::ScrollingDown)) {
                        screen.PostEvent(Event::Custom);
                    }
                }
            }

            std::lock_guard<std::mutex> lk(state.mu);
            const bool is_wheel_event = mouse.button == Mouse::WheelUp ||
                                        mouse.button == Mouse::WheelDown;
            const bool chat_mouse_target = acecode::tui::is_chat_mouse_target(
                mouse.x, mouse.y, chat_box.x_min, chat_box.y_min,
                chat_box.x_max, chat_box.y_max, is_wheel_event);
            if (!chat_mouse_target) {
#if ACECODE_TUI_INPUT_TRACE
                if (is_wheel_event) {
                    LOG_DEBUG("[input] chat wheel ignored outside chat_box " +
                              event_for_log(event) +
                              " chat_box=" + box_for_log(chat_box));
                }
#endif
                return false;
            }
#if ACECODE_TUI_INPUT_TRACE
            if (is_wheel_event && !chat_box.Contain(mouse.x, mouse.y)) {
                LOG_DEBUG("[input] chat wheel accepted above chat_box for "
                          "terminal origin mismatch " +
                          event_for_log(event) +
                          " chat_box=" + box_for_log(chat_box));
            }
#endif

            // 鼠标滚轮按行滚动 (3 行/notch, Win 默认值), 长消息不再被一格掠过。
            constexpr int WHEEL_LINES = 3;
            if (mouse.button == Mouse::WheelUp) {
                sync_chat_line_counts_from_layout();
#if ACECODE_TUI_INPUT_TRACE
                const int before_focus = state.chat_focus_index;
                const int before_offset = state.chat_line_offset;
                const bool before_tail = state.chat_follow_tail;
#endif
                const int actual = scroll_chat_by_lines(-WHEEL_LINES);
#if ACECODE_TUI_INPUT_TRACE
                LOG_DEBUG("[input] chat wheel up delta=-" +
                          std::to_string(WHEEL_LINES) +
                          " actual=" + std::to_string(actual) +
                          " focus=" + std::to_string(before_focus) +
                          "->" + std::to_string(state.chat_focus_index) +
                          " offset=" + std::to_string(before_offset) +
                          "->" + std::to_string(state.chat_line_offset) +
                          " follow_tail=" +
                          std::string(before_tail ? "1" : "0") +
                          "->" +
                          std::string(state.chat_follow_tail ? "1" : "0"));
#endif
                if (actual != 0) {
                    screen.PostEvent(Event::Custom);
                }
                return true;
            }
            if (mouse.button == Mouse::WheelDown) {
                sync_chat_line_counts_from_layout();
#if ACECODE_TUI_INPUT_TRACE
                const int before_focus = state.chat_focus_index;
                const int before_offset = state.chat_line_offset;
                const bool before_tail = state.chat_follow_tail;
#endif
                const int actual = scroll_chat_by_lines(WHEEL_LINES);
#if ACECODE_TUI_INPUT_TRACE
                LOG_DEBUG("[input] chat wheel down delta=" +
                          std::to_string(WHEEL_LINES) +
                          " actual=" + std::to_string(actual) +
                          " focus=" + std::to_string(before_focus) +
                          "->" + std::to_string(state.chat_focus_index) +
                          " offset=" + std::to_string(before_offset) +
                          "->" + std::to_string(state.chat_line_offset) +
                          " follow_tail=" +
                          std::string(before_tail ? "1" : "0") +
                          "->" +
                          std::string(state.chat_follow_tail ? "1" : "0"));
#endif
                if (actual != 0) {
                    screen.PostEvent(Event::Custom);
                }
                return true;
            }
        }
        if (event == Event::ArrowUp) {
            std::lock_guard<std::mutex> lk(state.mu);
            if (state.resume_picker_active) {
                if (state.resume_selected > 0) state.resume_selected--;
                state.resume_view_offset = acecode::tui::scroll_to_keep_visible(
                    state.resume_selected, state.resume_view_offset,
                    acecode::tui::kResumePickerVisibleRows,
                    static_cast<int>(state.resume_items.size()));
                screen.PostEvent(Event::Custom);
                return true;
            }
            if (state.model_picker_open) {
                if (state.model_picker_selected > 0) state.model_picker_selected--;
                state.model_picker_view_offset = acecode::tui::scroll_to_keep_visible(
                    state.model_picker_selected, state.model_picker_view_offset,
                    acecode::tui::kResumePickerVisibleRows,
                    static_cast<int>(state.model_picker_options.size()));
                screen.PostEvent(Event::Custom);
                return true;
            }
            if (acecode::tui::navigate_input_history_up(state)) {
                // 历史覆盖输入：清掉本会话旧粘贴留下的孤儿 pasted_texts（spec 3.7）。
                acecode::tui::prune_unreferenced(state.pasted_texts, state.input_text);
                refresh_slash_dropdown(state, cmd_registry);
            }
            return true;
        }
        if (event == Event::ArrowDown) {
            std::lock_guard<std::mutex> lk(state.mu);
            if (state.resume_picker_active) {
                if (state.resume_selected < static_cast<int>(state.resume_items.size()) - 1)
                    state.resume_selected++;
                state.resume_view_offset = acecode::tui::scroll_to_keep_visible(
                    state.resume_selected, state.resume_view_offset,
                    acecode::tui::kResumePickerVisibleRows,
                    static_cast<int>(state.resume_items.size()));
                screen.PostEvent(Event::Custom);
                return true;
            }
            if (state.model_picker_open) {
                if (state.model_picker_selected <
                    static_cast<int>(state.model_picker_options.size()) - 1)
                    state.model_picker_selected++;
                state.model_picker_view_offset = acecode::tui::scroll_to_keep_visible(
                    state.model_picker_selected, state.model_picker_view_offset,
                    acecode::tui::kResumePickerVisibleRows,
                    static_cast<int>(state.model_picker_options.size()));
                screen.PostEvent(Event::Custom);
                return true;
            }
            if (acecode::tui::navigate_input_history_down(state)) {
                // 历史覆盖输入：清掉本会话旧粘贴留下的孤儿 pasted_texts（spec 3.7）。
                acecode::tui::prune_unreferenced(state.pasted_texts, state.input_text);
                refresh_slash_dropdown(state, cmd_registry);
            }
            return true;
        }
        // ArrowLeft / ArrowRight: move caret one UTF-8 glyph.
        if (event == Event::ArrowLeft) {
            std::lock_guard<std::mutex> lk(state.mu);
            if (state.resume_picker_active) return true;
            if (state.model_picker_open) return true;
            if (state.input_cursor > state.input_text.size()) {
                state.input_cursor = state.input_text.size();
            }
            if (state.input_cursor == 0) return true;
            // 已知 [Pasted text #N] 占位符整体跨越（atomic span）。
            if (auto span = acecode::tui::placeholder_ending_at(
                    state.input_text, state.pasted_texts, state.input_cursor)) {
                state.input_cursor = span->begin;
                return true;
            }
            size_t pos = state.input_cursor - 1;
            while (pos > 0 && (static_cast<unsigned char>(state.input_text[pos]) & 0xC0) == 0x80) {
                pos--;
            }
            state.input_cursor = pos;
            return true;
        }
        if (event == Event::ArrowRight) {
            std::lock_guard<std::mutex> lk(state.mu);
            if (state.resume_picker_active) return true;
            if (state.model_picker_open) return true;
            if (state.input_cursor >= state.input_text.size()) {
                state.input_cursor = state.input_text.size();
                return true;
            }
            // 已知 [Pasted text #N] 占位符整体跨越（atomic span）。
            if (auto span = acecode::tui::placeholder_starting_at(
                    state.input_text, state.pasted_texts, state.input_cursor)) {
                state.input_cursor = span->end;
                return true;
            }
            size_t pos = state.input_cursor + 1;
            while (pos < state.input_text.size() &&
                   (static_cast<unsigned char>(state.input_text[pos]) & 0xC0) == 0x80) {
                pos++;
            }
            state.input_cursor = pos;
            return true;
        }
        // Home / End: jump caret to start/end of the input buffer.
        // FTXUI only maps `ESC [ H` and `ESC [ F` (plus the `ESC O H/F` DECCKM
        // variants) to Event::Home / Event::End. Several terminals emit VT220-
        // style `ESC [ 1 ~` / `ESC [ 4 ~` or rxvt-style `ESC [ 7 ~` / `ESC [ 8 ~`
        // instead — those arrive as raw Special events, so match them here.
        // Ctrl+A / Ctrl+E are also honoured as the readline-style fallback.
        auto is_home_event = [](const Event& e) {
            return e == Event::Home
                || e == Event::Special("\x1B[1~")
                || e == Event::Special("\x1B[7~")
                || e == Event::Special(std::string(1, '\x01')); // Ctrl+A
        };
        auto is_end_event = [](const Event& e) {
            return e == Event::End
                || e == Event::Special("\x1B[4~")
                || e == Event::Special("\x1B[8~")
                || e == Event::Special(std::string(1, '\x05')); // Ctrl+E
        };
        if (is_home_event(event)) {
            std::lock_guard<std::mutex> lk(state.mu);
            if (state.resume_picker_active) return true;
            state.input_cursor = 0;
            return true;
        }
        // Ctrl+E contextual expand: when a summarized tool_result is focused
        // in the chat view, toggle its expanded state. Falls through to the
        // readline-style "move to end of line" when no chat message is focused.
        if (event == Event::Special(std::string(1, '\x05'))) {
            std::lock_guard<std::mutex> lk(state.mu);
            if (state.chat_focus_index >= 0 &&
                state.chat_focus_index < static_cast<int>(state.conversation.size())) {
                auto& msg = state.conversation[state.chat_focus_index];
                if (msg.role == "tool_result" &&
                    (msg.summary.has_value() || msg.hunks.has_value())) {
                    msg.expanded = !msg.expanded;
                    if (state.chat_focus_index <
                        static_cast<int>(message_line_counts.size())) {
                        message_line_counts[state.chat_focus_index] = 0;
                    }
                    screen.PostEvent(Event::Custom);
                    return true;
                }
            }
            // Fall through to end-of-line if nothing to toggle.
        }
        if (is_end_event(event)) {
            std::lock_guard<std::mutex> lk(state.mu);
            if (state.resume_picker_active) return true;
            state.input_cursor = state.input_text.size();
            return true;
        }
        // Delete: remove UTF-8 glyph at the caret (to the right)
        if (event == Event::Delete) {
            std::lock_guard<std::mutex> lk(state.mu);
            if (state.input_cursor > state.input_text.size()) {
                state.input_cursor = state.input_text.size();
            }
            if (state.input_cursor >= state.input_text.size()) return true;
            // 已知 [Pasted text #N] 占位符整体删除：连同 store 条目一起回收。
            if (auto span = acecode::tui::placeholder_starting_at(
                    state.input_text, state.pasted_texts, state.input_cursor)) {
                state.pasted_texts.erase(span->paste_id);
                state.input_text.erase(span->begin, span->end - span->begin);
                // input_cursor 保持在 span->begin（即 input_cursor 不变）
                refresh_slash_dropdown(state, cmd_registry);
                return true;
            }
            size_t next = state.input_cursor + 1;
            while (next < state.input_text.size() &&
                   (static_cast<unsigned char>(state.input_text[next]) & 0xC0) == 0x80) {
                next++;
            }
            state.input_text.erase(state.input_cursor, next - state.input_cursor);
            refresh_slash_dropdown(state, cmd_registry);
            return true;
        }
        // Backspace: remove UTF-8 glyph preceding the caret
        if (event == Event::Backspace) {
            std::lock_guard<std::mutex> lk(state.mu);
            if (state.input_cursor > state.input_text.size()) {
                state.input_cursor = state.input_text.size();
            }
            if (state.input_text.empty()) {
                // On empty buffer, Backspace exits Shell mode back to Normal.
                if (state.input_mode == InputMode::Shell) {
                    state.input_mode = InputMode::Normal;
                }
                state.input_cursor = 0;
                refresh_slash_dropdown(state, cmd_registry);
                return true;
            }
            if (state.input_cursor == 0) {
                return true;
            }
            // 已知 [Pasted text #N] 占位符整体删除：连同 store 条目一起回收。
            if (auto span = acecode::tui::placeholder_ending_at(
                    state.input_text, state.pasted_texts, state.input_cursor)) {
                state.pasted_texts.erase(span->paste_id);
                state.input_text.erase(span->begin, span->end - span->begin);
                state.input_cursor = span->begin;
                refresh_slash_dropdown(state, cmd_registry);
                return true;
            }
            size_t pos = state.input_cursor - 1;
            // Walk back over UTF-8 continuation bytes (10xxxxxx)
            while (pos > 0 && (static_cast<unsigned char>(state.input_text[pos]) & 0xC0) == 0x80) {
                pos--;
            }
            state.input_text.erase(pos, state.input_cursor - pos);
            state.input_cursor = pos;
            refresh_slash_dropdown(state, cmd_registry);
            return true;
        }
        // Printable character input
        if (event.is_character()) {
            std::lock_guard<std::mutex> lk(state.mu);
            // During resume picker, digit keys select directly
            if (state.resume_picker_active) {
                std::string ch = event.character();
                if (!ch.empty() && ch[0] >= '1' && ch[0] <= '9') {
                    int idx = ch[0] - '1';
                    if (idx < static_cast<int>(state.resume_items.size())) {
                        auto sid = state.resume_items[idx].id;
                        auto cb = state.resume_callback;
                        state.resume_picker_active = false;
                        state.resume_items.clear();
                        state.resume_view_offset = 0;
                        state.resume_callback = nullptr;
                        state.input_text.clear(); state.pasted_texts.clear();
                        state.input_cursor = 0;
                        if (cb) cb(sid);
                        clamp_chat_focus();
                        screen.PostEvent(Event::Custom);
                    }
                }
                return true;
            }
            // /model picker:数字键 1-9 直接跳到对应行(选中,不立即提交 ——
            // 和 /resume 不同,模型切换是有副作用的操作,留 Enter 确认)。
            // 其它字符 absorb,不写进 input_text。
            if (state.model_picker_open) {
                std::string ch = event.character();
                if (!ch.empty() && ch[0] >= '1' && ch[0] <= '9') {
                    int idx = ch[0] - '1';
                    if (idx < static_cast<int>(state.model_picker_options.size())) {
                        state.model_picker_selected = idx;
                        state.model_picker_view_offset = acecode::tui::scroll_to_keep_visible(
                            state.model_picker_selected, state.model_picker_view_offset,
                            acecode::tui::kResumePickerVisibleRows,
                            static_cast<int>(state.model_picker_options.size()));
                        screen.PostEvent(Event::Custom);
                    }
                }
                return true;
            }
            const std::string ch = event.character();
            // Shell-mode trigger on an empty Normal buffer switches mode
            // without being inserted. Subsequent trigger characters are literal.
            if (state.input_mode == InputMode::Normal &&
                state.input_text.empty() &&
                is_shell_mode_trigger_character(ch)) {
                state.input_mode = InputMode::Shell;
                state.history_index = -1;
                return true;
            }
            if (state.input_cursor > state.input_text.size()) {
                state.input_cursor = state.input_text.size();
            }
            state.input_text.insert(state.input_cursor, ch);
            state.input_cursor += ch.size();
            // Reset history browsing on new input
            state.history_index = -1;
            refresh_slash_dropdown(state, cmd_registry);
            return true;
        }
        return false;
    });

    auto renderer = Renderer(input_with_esc, [&state, &screen, &version_str, &cwd_display, &chat_box, &scrollbar_box, &ask_scrollbar_box, &ask_overlay_box, &message_boxes, &message_layout_boxes, &message_line_counts, &anim_tick, &input_with_esc, &permissions, dangerous_mode, conhost_compat_layout, &clamp_chat_focus, &chat_viewport_rows, &sync_chat_line_counts_from_layout] {
        std::lock_guard<std::mutex> lk(state.mu);
        auto compat_horizontal_line = [] {
            const int cols = Terminal::Size().dimx;
            const int safe_cols = std::max(1, cols > 4 ? cols - 4 : cols);
            const std::string glyph = "\xE2\x94\x80";
            std::string line;
            line.reserve(glyph.size() * static_cast<size_t>(safe_cols));
            for (int i = 0; i < safe_cols; ++i) {
                line += glyph;
            }
            return text(line);
        };
        constexpr int kRegularSidebarThresholdCols = 120;
        constexpr int kRegularSidebarWidthCols = 43;
        const int terminal_width =
            std::max(Terminal::Size().dimx, screen.dimx());
        const bool show_regular_sidebar =
            !conhost_compat_layout &&
            terminal_width > kRegularSidebarThresholdCols;
        const bool hide_regular_sidebar_banner =
            show_regular_sidebar && !state.conversation.empty();

        // drag-autoscroll: 把上一帧布局分配的未裁剪 box 高度同步到行数表,
        // 供 scroll_chat_by_lines 做按行滚动. 普通 ftxui::reflect 会在 Render
        // 阶段和 screen.stencil 取交集,只能拿到可见高度;这里必须用未裁剪高度,
        // 否则长消息会被误判为只剩当前可见的几行,导致底部滚动范围过短.
        size_t n_msgs = state.conversation.size();
        const int current_message_width = chat_box.x_max >= chat_box.x_min
            ? chat_box.x_max - chat_box.x_min + 1
            : 0;
        sync_chat_line_counts_from_layout();
        clamp_chat_focus();

        // selection-anchor-compensation: 在清空 boxes 之前,先用上一帧 reflect 的
        // box.y_min 检测 anchor 漂移。focus_index 和 line_offset 都没变(用户没动
        // 滚轮 / PgUp / 拖滚动条)而 y_min 变了 —— 这种纯 layout 漂移期间如果用户
        // 在拖选,FTXUI 的 selection_data_ 钉在物理屏幕坐标会错位,这里调
        // ShiftSelection 把锚点跟随移到新位置。ShiftSelection 内部会在没有 active
        // selection 时 early return,这里无条件调用是安全的。
        {
            int cur_focus = state.chat_focus_index;
            int cur_offset = state.chat_line_offset;
            int cur_y = (cur_focus >= 0 && cur_focus < (int)message_boxes.size())
                ? message_boxes[cur_focus].y_min : 0;
            bool focus_unchanged = (cur_focus == state.last_focus_index &&
                                     cur_offset == state.last_chat_line_offset);
            // last_focus_box_y 的 sentinel 是 -999999 (从未拍过),用 > -1000000
            // 判断"已有有效快照"。cur_y 在 reflect 没回填时是 0(default Box),
            // 也跳过补偿——避免被裁出 viewport 的 anchor 触发假阳性 dy。
            if (focus_unchanged && cur_y > 0 &&
                state.last_focus_box_y > -1000000 &&
                cur_y != state.last_focus_box_y) {
                int dy = cur_y - state.last_focus_box_y;
#if ACECODE_TUI_INPUT_TRACE
                LOG_DEBUG("[drag-select] anchor compensation dy=" +
                          std::to_string(dy) + " focus=" +
                          std::to_string(cur_focus) + " offset=" +
                          std::to_string(cur_offset) + " y=" +
                          std::to_string(state.last_focus_box_y) + "->" +
                          std::to_string(cur_y));
#endif
                screen.ShiftSelection(0, dy);
            }
            // 仅在拿到有效 reflect 数据时更新快照,否则保留上次的;这样 anchor
            // 短暂被裁出 viewport 再回到可见区时,差值仍是相对最近一次可见位置。
            if (cur_y > 0) {
                state.last_focus_box_y = cur_y;
            }
            state.last_focus_index = cur_focus;
            state.last_chat_line_offset = cur_offset;
        }

        message_boxes.assign(n_msgs, Box{});
        message_layout_boxes.assign(n_msgs, Box{});

        const bool is_light = acecode::tui::theme().name == "light";
        Element header;
        if (conhost_compat_layout) {
            header = vbox({
                text(version_str) | color(tui::theme().ui.text_muted) | dim,
                state.update_notice.empty()
                    ? emptyElement()
                    : paragraph(state.update_notice) | color(tui::theme().semantic.warning),
                text(state.status_line) | color(status_line_color(state.status_line)),
                text(cwd_display) | color(tui::theme().ui.accent_alt) | dim,
            }) | bgcolor(is_light ? Color::RGB(225, 235, 245) : Color::RGB(0, 30, 45));
        } else {
            // -- Logo --
            auto logo = vbox({
                text("\xE2\x96\x91\xE2\x96\x88\xE2\x96\x80\xE2\x96\x88\xE2\x96\x91\xE2\x96\x88\xE2\x96\x80\xE2\x96\x80\xE2\x96\x91\xE2\x96\x88\xE2\x96\x80\xE2\x96\x80\xE2"),
                text("\xE2\x96\x91\xE2\x96\x88\xE2\x96\x80\xE2\x96\x88\xE2\x96\x91\xE2\x96\x88\xE2\x96\x91\xE2\x96\x91\xE2\x96\x91\xE2\x96\x88\xE2\x96\x80\xE2\x96\x80\xE2"),
                text("\xE2\x96\x91\xE2\x96\x80\xE2\x96\x91\xE2\x96\x80\xE2\x96\x91\xE2\x96\x80\xE2\x96\x80\xE2\x96\x80\xE2\x96\x91\xE2\x96\x80\xE2\x96\x80\xE2\x96\x80\xE2"),
            }) | color(tui::theme().ui.border) | bold;

            if (show_regular_sidebar && hide_regular_sidebar_banner) {
                header = emptyElement();
            } else if (show_regular_sidebar) {
                header = hbox({
                    text("    "),
                    logo,
                    filler(),
                    text("  "),
                }) | bgcolor(is_light ? Color::RGB(225, 235, 245) : Color::RGB(0, 30, 45));
            } else {
                header = hbox({
                    text("    "),
                    logo,
                    filler(),
                    vbox({
                        text(version_str) | color(tui::theme().ui.text_muted) | dim,
                        state.update_notice.empty()
                            ? emptyElement()
                            : paragraph(state.update_notice) | color(tui::theme().semantic.warning),
                        text(state.status_line) | color(status_line_color(state.status_line)),
                        text(cwd_display) | color(tui::theme().ui.accent_alt) | dim,
                    }),
                    text("  "),
                }) | bgcolor(is_light ? Color::RGB(225, 235, 245) : Color::RGB(0, 30, 45));
            }
        }

        // -- Messages --
        // Bottom-anchor short transcripts while following the tail. FTXUI's
        // yframe only scrolls when the child is taller than the viewport, so a
        // short chat at tail otherwise remains pinned to the top.
        Elements message_elements;
        auto push_spacer_rows = [&message_elements](int rows) {
            if (rows > 0) {
                message_elements.push_back(
                    emptyElement() | size(HEIGHT, EQUAL, rows));
            }
        };
        const int chat_viewport_height = chat_box.y_max >= chat_box.y_min
            ? chat_box.y_max - chat_box.y_min + 1
            : 0;
        const int tail_top_padding =
            acecode::tui::chat_bottom_anchor_top_padding_rows(
            message_line_counts,
            static_cast<int>(state.conversation.size()),
            chat_viewport_height);
        push_spacer_rows(tail_top_padding);
        const auto render_window = acecode::tui::chat_render_window(
            message_line_counts,
            static_cast<int>(state.conversation.size()),
            state.chat_scroll_top_row,
            chat_viewport_height,
            acecode::tui::default_chat_render_overscan_rows(
                chat_viewport_height));
        push_spacer_rows(render_window.top_spacer_rows);

        // drag-autoscroll: 每条消息同时记录两个 box:
        //   - message_layout_boxes: 未裁剪高度,用于滚动数学;
        //   - message_boxes: 裁剪后屏幕位置,用于选区锚点补偿。
        auto tracked_message = [&](size_t index, Element element) -> Element {
            return std::move(element)
                | acecode::tui::reflect_unclipped(message_layout_boxes[index])
                | reflect(message_boxes[index]);
        };
        const size_t render_first =
            static_cast<size_t>(std::max(0, render_window.first_message));
        const size_t render_last = std::min(
            state.conversation.size(),
            static_cast<size_t>(std::max(0,
                render_window.last_message_exclusive)));
        for (size_t i = render_first; i < render_last; ++i) {
            const auto& msg = state.conversation[i];
            bool focused_message = static_cast<int>(i) == state.chat_focus_index;
            Decorator focus_decorator = nothing;

            if (msg.role == "user") {
                auto line = hbox({
                    text(" > ") | bold | color(tui::theme().markdown.link),
                    paragraph(msg.content) | color(tui::theme().ui.text_primary) | flex,
                });
                if (focused_message) {
                    line = line | focus;
                }
                message_elements.push_back(
                    tracked_message(i, line | focus_decorator));
            } else if (msg.role == "assistant") {
                // Render with Markdown formatting
                Element md_content;
                try {
                    acecode::markdown::FormatOptions md_opts;
                    const int fallback_width = terminal_width -
                        (show_regular_sidebar ? kRegularSidebarWidthCols + 9 : 6);
                    md_opts.terminal_width =
                        std::max(20, (current_message_width > 0
                            ? current_message_width
                            : fallback_width) - 6);
                    md_opts.syntax_highlight = true;
                    md_opts.hyperlinks = true;
                    md_opts.strip_xml = true;
                    md_content = acecode::markdown::format_markdown(msg.content, md_opts);
                } catch (...) {
                    // Fallback: raw paragraph if markdown parsing fails
                    md_content = paragraph(msg.content) | color(tui::theme().semantic.success);
                }
                auto line = hbox({
                    text(" * ") | bold | color(tui::theme().semantic.success),
                    md_content | flex,
                });
                if (focused_message) {
                    line = line | focus;
                }
                message_elements.push_back(
                    tracked_message(i, line | focus_decorator));
            } else if (msg.role == "tool_call") {
                // Prefer the compact one-line preview (→ bash  npm install) when
                // agent_loop supplied one; fall back to the legacy full-JSON row.
                std::string display_text;
                if (!msg.display_override.empty()) {
                    display_text = "\xE2\x86\x92 " + msg.display_override; // "→ "
                } else {
                    display_text = msg.content;
                }
                auto line = hbox({
                    text("   -> ") | color(tui::theme().syntax.preproc),
                    paragraph(display_text) | color(tui::theme().syntax.preproc) | flex,
                });
                if (focused_message) {
                    line = line | focus;
                }
                message_elements.push_back(
                    tracked_message(i, line | focus_decorator));
            } else if (msg.role == "user_shell_output") {
                // 用户主动 `!cmd` 的输出 —— 全量显示,无截断、无摘要、无 fold。
                // 用户自己输入的命令就是想看完整输出,任何折叠都不符合预期。
                // 这与 LLM 工具结果(role="tool_result")形成对照:LLM 调用的
                // 工具结果走摘要/diff/fold 三优先级,有 Ctrl+E 展开机制。
                auto line = hbox({
                    text("   <- ") | color(tui::theme().ui.text_dim),
                    render_tool_result_lines_preserving_breaks(msg.content) | flex,
                });
                if (focused_message) {
                    line = line | focus;
                }
                message_elements.push_back(
                    tracked_message(i, line | focus_decorator));
            } else if (msg.role == "tool_result") {
                // 新优先级:有结构化 hunks → 走彩色 diff 视图(summary + 色带);
                // 其次 summary(无 hunks)→ 单行摘要;都没有 → 灰色 fold。
                const bool use_diff = msg.hunks.has_value();
                const bool use_summary = msg.summary.has_value() && !msg.expanded && !use_diff;
                if (use_diff) {
                    // ---- Diff 视图:summary 行 + 彩色 diff 块 ----
                    Elements rows;
                    if (msg.summary.has_value()) {
                        const auto& s = *msg.summary;
                        Color row_color = msg.content.find("[Error]") == 0 || !is_success_summary(s)
                            ? tui::theme().semantic.error
                            : tui::theme().semantic.success;
                        std::string metric_str;
                        for (const auto& kv : s.metrics) {
                            std::string seg;
                            if (kv.first == "+") seg = "+" + kv.second;
                            else if (kv.first == "-") seg = "-" + kv.second;
                            else seg = kv.first + "=" + kv.second;
                            if (!metric_str.empty()) metric_str += " \xC2\xB7 ";
                            metric_str += seg;
                        }
                        const int summary_width = std::max(
                            20, chat_box.x_max - chat_box.x_min - 6);
                        std::string summary_line = renderable_tool_summary_line(
                            s, metric_str, summary_width);
                        rows.push_back(hbox({
                            text("   <- ") | color(tui::theme().ui.text_dim),
                            text(summary_line) | color(row_color) | flex,
                        }));
                    } else {
                        rows.push_back(hbox({
                            text("   <- ") | color(tui::theme().ui.text_dim),
                            text("diff") | color(tui::theme().ui.text_muted) | flex,
                        }));
                    }

                    // 失败态:把前 3 行 stderr dim 显示在 summary 之下(保留既有行为)。
                    if (msg.summary.has_value() && !is_success_summary(*msg.summary) &&
                        !msg.content.empty()) {
                        int shown = 0;
                        size_t pos = 0;
                        while (pos < msg.content.size() && shown < 3) {
                            size_t nl = msg.content.find('\n', pos);
                            std::string line = (nl == std::string::npos)
                                ? msg.content.substr(pos)
                                : msg.content.substr(pos, nl - pos);
                            rows.push_back(hbox({
                                text("      ") | color(tui::theme().ui.text_dim),
                                paragraph(line) | color(tui::theme().ui.text_muted) | dim | flex,
                            }));
                            if (nl == std::string::npos) break;
                            pos = nl + 1;
                            ++shown;
                        }
                    }

                    // Diff 视图:缩进 6 列,宽度由 chat_box 推导。
                    DiffViewOptions opts;
                    opts.width = std::max(20, chat_box.x_max - chat_box.x_min - 6);
                    opts.expanded = msg.expanded;
                    opts.max_hunks = 3;
                    opts.max_lines_per_hunk = 20;
                    Element diff_el = render_diff_view(*msg.hunks, opts);
                    rows.push_back(hbox({
                        text("      ") | color(tui::theme().ui.text_dim),
                        diff_el | flex,
                    }));

                    auto block = vbox(std::move(rows));
                    if (focused_message) {
                        block = block | focus;
                    }
                    message_elements.push_back(
                        tracked_message(i, block | focus_decorator));
                } else if (use_summary) {
                    // ---- Summary row: single line, icon + verb + object + metrics ----
                    const auto& s = *msg.summary;
                    Color row_color = msg.content.find("[Error]") == 0 || !is_success_summary(s)
                        ? tui::theme().semantic.error
                        : tui::theme().semantic.success;

                    // Build metric tail: " · k=v · k=v" but drop k for
                    // "time"/"bytes"/"lines"/"size" since the value is self-describing.
                    std::string metric_str;
                    for (const auto& kv : s.metrics) {
                        std::string seg;
                        if (kv.first == "time" || kv.first == "bytes" ||
                            kv.first == "size" || kv.first == "lines") {
                            seg = kv.second + (kv.first == "lines" ? " lines" : "");
                        } else if (kv.first == "+") {
                            seg = "+" + kv.second;
                        } else if (kv.first == "-") {
                            seg = "-" + kv.second;
                        } else if (kv.first == "exit") {
                            seg = "exit " + kv.second;
                        } else if (kv.first == "truncated" && kv.second == "true") {
                            seg = "truncated";
                        } else if (kv.first == "aborted" && kv.second == "true") {
                            seg = "aborted";
                        } else if (kv.first == "timeout" && kv.second == "true") {
                            seg = "timeout";
                        } else if (kv.first == "hint") {
                            seg = "hint:" + kv.second;
                        } else {
                            seg = kv.first + "=" + kv.second;
                        }
                        if (!metric_str.empty()) metric_str += " \xC2\xB7 "; // " · "
                        metric_str += seg;
                    }

                    const int summary_width = std::max(
                        20, chat_box.x_max - chat_box.x_min - 6);
                    std::string summary_line = renderable_tool_summary_line(
                        s, metric_str, summary_width);

                    Elements rows;
                    rows.push_back(hbox({
                        text("   <- ") | color(tui::theme().ui.text_dim),
                        text(summary_line) | color(row_color) | flex,
                    }));

                    // Failed tool: render the first 3 lines of output dimmed
                    // below the summary so the error is visible without expand.
                    if (!is_success_summary(s) && !msg.content.empty()) {
                        int shown = 0;
                        size_t pos = 0;
                        while (pos < msg.content.size() && shown < 3) {
                            size_t nl = msg.content.find('\n', pos);
                            std::string line = (nl == std::string::npos)
                                ? msg.content.substr(pos)
                                : msg.content.substr(pos, nl - pos);
                            rows.push_back(hbox({
                                text("      ") | color(tui::theme().ui.text_dim),
                                paragraph(line) | color(tui::theme().ui.text_muted) | dim | flex,
                            }));
                            if (nl == std::string::npos) break;
                            pos = nl + 1;
                            ++shown;
                        }
                    }

                    auto block = vbox(std::move(rows));
                    if (focused_message) {
                        block = block | focus;
                    }
                    message_elements.push_back(
                        tracked_message(i, block | focus_decorator));
                } else {
                    // ---- Legacy fold path (also used when user pressed Ctrl+E
                    // to expand, and the 10-line cap acts as a secondary safety) ----
                    const int MAX_TOOL_LINES = 10;
                    std::string display_content = msg.content;
                    int line_count = 0;
                    for (char c : msg.content) if (c == '\n') line_count++;
                    if (msg.content.empty() || msg.content.back() != '\n') line_count++;

                    if (line_count > MAX_TOOL_LINES) {
                        size_t cut = 0;
                        int seen = 0;
                        while (cut < msg.content.size() && seen < MAX_TOOL_LINES) {
                            if (msg.content[cut] == '\n') seen++;
                            cut++;
                        }
                        display_content = msg.content.substr(0, cut);
                        if (!display_content.empty() && display_content.back() == '\n') {
                            display_content.pop_back();
                        }
                        int hidden = line_count - MAX_TOOL_LINES;
                        display_content += "\n... (" + std::to_string(hidden) + " more lines)";
                    }

                    auto line = hbox({
                        text("   <- ") | color(tui::theme().ui.text_dim),
                        render_tool_result_lines_preserving_breaks(display_content) | flex,
                    });
                    if (focused_message) {
                        line = line | focus;
                    }
                    message_elements.push_back(
                        tracked_message(i, line | focus_decorator));
                }
            } else if (msg.role == "system") {
                auto line = hbox({
                    text(" i ") | bold | color(tui::theme().ui.accent),
                    paragraph(msg.content) | color(tui::theme().ui.accent) | flex,
                });
                if (focused_message) {
                    line = line | focus;
                }
                message_elements.push_back(
                    tracked_message(i, line | focus_decorator));
            } else if (msg.role == "error") {
                auto line = hbox({
                    text(" ! ") | bold | color(tui::theme().semantic.error),
                    paragraph(msg.content) | color(tui::theme().semantic.error) | flex,
                });
                if (focused_message) {
                    line = line | focus;
                }
                message_elements.push_back(
                    tracked_message(i, line | focus_decorator));
            }
            message_elements.push_back(text(""));
        }
        push_spacer_rows(render_window.bottom_spacer_rows);

        Element message_body = vbox(std::move(message_elements));
        if (state.chat_follow_tail) {
            // /resume replaces the transcript before the next render has
            // measured the new paragraph heights. Use FTXUI's rendered bottom
            // anchor while tail-follow is active so the first restored frame
            // lands at the true tail instead of an underestimated absolute row.
            message_body = message_body | focusPositionRelative(0.0f, 1.0f);
        } else {
            const int frame_focus_y =
                acecode::tui::chat_frame_focus_y_for_scroll_top(
                    state.chat_scroll_top_row, chat_viewport_rows());
            message_body = message_body | focusPosition(0, frame_focus_y);
        }

        // draggable-thick-scrollbar: thumb glyph identical to upstream
        // vscroll_indicator (┃╹╻),painted only in the rightmost reserved
        // column. We reserve 3 columns total so the *invisible* hit zone
        // is wider than 1 cell — the leftmost 2 reserved columns render
        // as whitespace but scrollbar_box.Contain() still matches them,
        // making mouse aim much easier without changing the visual rail
        // position. The decorator also enforces a minimum thumb height
        // (3 cells) so long sessions don't shrink the click target to a
        // single half-block.
        auto message_view = acecode::tui::thick_vscroll_bar(
                                std::move(message_body),
                                /*width=*/3,
                                scrollbar_box,
                                conhost_compat_layout)
            | yframe | reflect(chat_box) | flex
            // mouse-selection-copy: visual feedback for drag-selection. The
            // decorator lives on the message_view so selection can span
            // multiple messages.
            | selectionBackgroundColor(tui::theme().ui.selection_bg)
            | selectionForegroundColor(tui::theme().ui.selection_fg);

        // -- Thinking indicator / tool progress --
        // Priority: if a tool is streaming output, show the live tool-progress
        // element instead of the thinking animation (the tool is the more
        // specific "in-progress" signal).
        Element thinking_element = emptyElement();
        if (!conhost_compat_layout && state.tool_running) {
            thinking_element = render_tool_progress(state);
        } else if (!conhost_compat_layout && state.is_waiting) {
            int tick = anim_tick.load();
            int dot_count = (tick % 3) + 1; // 1, 2, 3 dots cycling

            std::string base = state.current_thinking_phrase;
            std::vector<std::string> utf8_chars;
            for (size_t i = 0; i < base.size();) {
                unsigned char c = base[i];
                size_t len = 1;
                if ((c & 0xE0) == 0xC0) len = 2;
                else if ((c & 0xF0) == 0xE0) len = 3;
                else if ((c & 0xF8) == 0xF0) len = 4;
                if (i + len > base.size()) len = base.size() - i;
                utf8_chars.push_back(base.substr(i, len));
                i += len;
            }

            int total_chars = static_cast<int>(utf8_chars.size());
            int wave_pos = tick % (total_chars > 0 ? total_chars + 2 : 8);

            Elements chars;
            for (int i = 0; i < total_chars; i++) {
                int dist = (i - wave_pos);
                if (dist < 0) dist = -dist;
                Color c;
                if (dist == 0)
                    c = tui::theme().ui.accent;
                else if (dist == 1)
                    c = is_light ? Color::RGB(130, 90, 0) : Color::RGB(180, 180, 60);
                else if (dist == 2)
                    c = is_light ? Color::RGB(160, 130, 60) : Color::RGB(120, 120, 40);
                else
                    c = tui::theme().ui.text_dim;
                chars.push_back(text(utf8_chars[i]) | color(c));
            }

            // Dots also animate
            for (int i = 0; i < 3; i++) {
                if (i < dot_count)
                    chars.push_back(text(".") | color(tui::theme().ui.accent));
                else
                    chars.push_back(text(".") | color(tui::theme().ui.text_dim));
            }

            thinking_element = hbox({
                text(" \xE2\x97\x8F ") | color(tui::theme().ui.accent),
                hbox(std::move(chars)),
            });
        }

        Element mcp_loading_element = emptyElement();
        if (!show_regular_sidebar && mcp_sidebar_has_loading(state)) {
            mcp_loading_element = hbox({
                text(" i ") | bold | color(Color::White),
                render_white_shimmer_text("MCP loading", anim_tick.load()),
            });
        }

        // -- Prompt line --
        Element prompt_line;
        // Resume picker overlay above the prompt
        Element resume_picker_element = emptyElement();
        if (state.resume_picker_active && !state.resume_items.empty()) {
            Elements picker_rows;
            picker_rows.push_back(
                text(" Resume a session (Up/Down/PgUp/PgDn/Home/End to navigate, Enter to confirm, Esc to cancel, 1-9 jump):")
                | bold | color(tui::theme().ui.border));
            picker_rows.push_back(text(""));

            const int total = static_cast<int>(state.resume_items.size());
            const int visible = std::min(acecode::tui::kResumePickerVisibleRows, total);
            int offset = std::clamp(state.resume_view_offset, 0,
                                    std::max(0, total - visible));
            const int items_above = offset;
            const int items_below = std::max(0, total - offset - visible);

            // Top overflow indicator (always reserves a row to keep height stable).
            if (items_above > 0) {
                picker_rows.push_back(
                    text("  \xE2\x86\x91 " + std::to_string(items_above) + " more above")
                    | dim | color(tui::theme().ui.text_muted));
            } else {
                picker_rows.push_back(text(""));
            }

            for (int i = offset; i < offset + visible; ++i) {
                bool selected = (i == state.resume_selected);
                auto row = text("  " + state.resume_items[i].display);
                if (selected) {
                    row = row | bold | color(tui::theme().ui.selection_fg) | bgcolor(tui::theme().ui.selection_bg);
                } else {
                    row = row | color(tui::theme().ui.text_muted);
                }
                picker_rows.push_back(row);
            }

            // Bottom overflow indicator (also reserves a row).
            if (items_below > 0) {
                picker_rows.push_back(
                    text("  \xE2\x86\x93 " + std::to_string(items_below) + " more below")
                    | dim | color(tui::theme().ui.text_muted));
            } else {
                picker_rows.push_back(text(""));
            }

            picker_rows.push_back(text(""));
            resume_picker_element = vbox(std::move(picker_rows)) | border | color(tui::theme().ui.border);
        }
        Element rewind_picker_element = emptyElement();
        if (state.rewind_picker_active && !state.rewind_items.empty()) {
            Elements picker_rows;
            if (state.rewind_mode_active) {
                const int selected =
                    std::clamp(state.rewind_selected, 0,
                               static_cast<int>(state.rewind_items.size()) - 1);
                const auto& item = state.rewind_items[selected];
                picker_rows.push_back(
                    text(" Rewind mode (Up/Down to select, Enter to confirm, Esc to go back, or type 1-9):")
                    | bold | color(tui::theme().ui.border));
                picker_rows.push_back(text(" Target: " + item.preview) | color(tui::theme().ui.text_muted));
                picker_rows.push_back(text(" Code rewind only covers ACECode file_edit/file_write changes; manual edits, shell commands, MCP tools, git operations, and external side effects are not tracked.")
                                      | color(tui::theme().ui.accent));
                picker_rows.push_back(text(""));
                for (int i = 0; i < static_cast<int>(state.rewind_modes.size()); ++i) {
                    bool selected_mode = (i == state.rewind_mode_selected);
                    const auto& mode = state.rewind_modes[i];
                    auto row = hbox({
                        text("  [" + std::to_string(i + 1) + "] " + mode.label + "  "),
                        text(mode.description) | color(tui::theme().ui.text_muted),
                    });
                    if (selected_mode) {
                        row = row | bold | color(tui::theme().ui.selection_fg) | bgcolor(tui::theme().ui.selection_bg);
                    } else {
                        row = row | color(tui::theme().ui.text_muted);
                    }
                    picker_rows.push_back(row);
                }
            } else {
                picker_rows.push_back(
                    text(" Rewind to a user turn (Up/Down/PgUp/PgDn/Home/End to navigate, Enter to confirm, Esc to cancel, 1-9 jump):")
                    | bold | color(tui::theme().ui.border));
                picker_rows.push_back(text(""));

                const int total = static_cast<int>(state.rewind_items.size());
                const int visible = std::min(acecode::tui::kRewindPickerVisibleRows, total);
                int offset = std::clamp(state.rewind_view_offset, 0,
                                        std::max(0, total - visible));
                const int items_above = offset;
                const int items_below = std::max(0, total - offset - visible);

                if (items_above > 0) {
                    picker_rows.push_back(
                        text("  \xE2\x86\x91 " + std::to_string(items_above) + " more above")
                        | dim | color(tui::theme().ui.text_muted));
                } else {
                    picker_rows.push_back(text(""));
                }

                for (int i = offset; i < offset + visible; ++i) {
                    bool selected = (i == state.rewind_selected);
                    auto row = text("  " + state.rewind_items[i].display);
                    if (selected) {
                        row = row | bold | color(tui::theme().ui.selection_fg) | bgcolor(tui::theme().ui.selection_bg);
                    } else {
                        row = row | color(tui::theme().ui.text_muted);
                    }
                    picker_rows.push_back(row);
                }

                if (items_below > 0) {
                    picker_rows.push_back(
                        text("  \xE2\x86\x93 " + std::to_string(items_below) + " more below")
                        | dim | color(tui::theme().ui.text_muted));
                } else {
                    picker_rows.push_back(text(""));
                }
            }
            picker_rows.push_back(text(""));
            rewind_picker_element = vbox(std::move(picker_rows)) | border | color(tui::theme().ui.border);
        }
        // /model picker overlay。同 resume_picker_element 的视觉风格(青边、
        // 滚动指示、选中行高亮)—— 单纯多一列前缀 "*" 标记当前 effective entry。
        Element model_picker_element = emptyElement();
        if (state.model_picker_open && !state.model_picker_options.empty()) {
            Elements picker_rows;
            picker_rows.push_back(
                text(" Select a model (Up/Down/PgUp/PgDn/Home/End to navigate, Enter to confirm, Esc to cancel):")
                | bold | color(tui::theme().ui.border));
            picker_rows.push_back(text(""));

            const int total = static_cast<int>(state.model_picker_options.size());
            // 复用 /resume 的视口高度常量 —— picker 行为口径一致,行少时
            // scroll_to_keep_visible 直接返回 0,不会留空行。
            const int visible = std::min(acecode::tui::kResumePickerVisibleRows, total);
            int offset = std::clamp(state.model_picker_view_offset, 0,
                                    std::max(0, total - visible));
            const int items_above = offset;
            const int items_below = std::max(0, total - offset - visible);

            if (items_above > 0) {
                picker_rows.push_back(
                    text("  \xE2\x86\x91 " + std::to_string(items_above) + " more above")
                    | dim | color(tui::theme().ui.text_muted));
            } else {
                picker_rows.push_back(text(""));
            }

            for (int i = offset; i < offset + visible; ++i) {
                bool selected = (i == state.model_picker_selected);
                const auto& opt = state.model_picker_options[i];
                std::string marker = opt.is_current ? "* " : "  ";
                std::string body =
                    "  " + marker + opt.name + "  (" + opt.provider + "/" + opt.model + ")";
                auto row = text(body);
                if (selected) {
                    row = row | bold | color(tui::theme().ui.selection_fg) | bgcolor(tui::theme().ui.selection_bg);
                } else if (opt.is_current) {
                    row = row | color(tui::theme().ui.accent);
                } else {
                    row = row | color(tui::theme().ui.text_muted);
                }
                picker_rows.push_back(row);
            }

            if (items_below > 0) {
                picker_rows.push_back(
                    text("  \xE2\x86\x93 " + std::to_string(items_below) + " more below")
                    | dim | color(tui::theme().ui.text_muted));
            } else {
                picker_rows.push_back(text(""));
            }

            picker_rows.push_back(text(""));
            model_picker_element = vbox(std::move(picker_rows)) | border | color(tui::theme().ui.border);
        }

        Element slash_dropdown_element =
            render_slash_dropdown(state, conhost_compat_layout);

        // AskUserQuestion overlay —— 和 confirm_pending 互斥,在渲染层面
        // 显式让 ask 优先(事件层在 confirm 分支之前也已经拦截,这里只是
        // 作为显式护栏)。
        Element ask_overlay_element = emptyElement();
        ask_scrollbar_box = Box{};
        ask_overlay_box = Box{};
        if (state.ask_pending && !state.ask_questions.empty() &&
            state.ask_current_question >= 0 &&
            state.ask_current_question <
                static_cast<int>(state.ask_questions.size())) {
            const auto& q = state.ask_questions[state.ask_current_question];
            const auto terminal_size = Terminal::Size();
            const int content_width = std::max(20, terminal_size.dimx - 10);
            const int max_visible_rows =
                std::max(4, std::min(14, terminal_size.dimy - 12));

            acecode::tui::AskOverlayLayoutInput layout_input;
            layout_input.question = &q;
            layout_input.current_question_index = state.ask_current_question;
            layout_input.total_questions =
                static_cast<int>(state.ask_questions.size());
            layout_input.option_focus = state.ask_option_focus;
            layout_input.multi_selected = state.ask_multi_selected;
            layout_input.other_input_active = state.ask_other_input_active;
            layout_input.content_width = content_width;

            auto layout = acecode::tui::build_ask_overlay_layout(layout_input);
            const int total = static_cast<int>(layout.rows.size());
            const int visible = total > 0 ? std::min(total, max_visible_rows) : 0;

            if (state.ask_scroll_to_focus_requested &&
                layout.focused_row_begin >= 0) {
                state.ask_scroll_offset = acecode::tui::ensure_row_range_visible(
                    state.ask_scroll_offset,
                    visible,
                    total,
                    layout.focused_row_begin,
                    layout.focused_row_end);
                state.ask_scroll_to_focus_requested = false;
            }
            state.ask_scroll_offset = acecode::tui::clamp_scroll_offset(
                state.ask_scroll_offset, total, visible);
            state.ask_scroll_total_rows = total;
            state.ask_scroll_visible_rows = visible;

            Elements rows;
            const int begin = state.ask_scroll_offset;
            const int end = std::min(total, begin + visible);
            for (int i = begin; i < end; ++i) {
                const auto& row = layout.rows[i];
                Element el = row.text.empty() ? text("") : text(row.text);
                switch (row.kind) {
                    case acecode::tui::AskOverlayRowKind::Header:
                        el = el | bold | color(tui::theme().ui.border);
                        break;
                    case acecode::tui::AskOverlayRowKind::Body:
                        el = el | color(tui::theme().ui.text_primary);
                        break;
                    case acecode::tui::AskOverlayRowKind::Option:
                        if (row.focused) {
                            el = el | bold | color(tui::theme().ui.text_primary) |
                                bgcolor(tui::theme().ui.selection_bg);
                        } else {
                            el = el | color(tui::theme().ui.text_muted);
                        }
                        break;
                    case acecode::tui::AskOverlayRowKind::Hint:
                        el = el | dim | color(tui::theme().ui.text_dim);
                        break;
                    case acecode::tui::AskOverlayRowKind::CustomPrompt:
                        el = el | color(tui::theme().ui.accent);
                        break;
                    case acecode::tui::AskOverlayRowKind::Blank:
                        break;
                }
                rows.push_back(el);
            }

            Elements bar_rows;
            const bool overflow = visible > 0 && total > visible;
            int thumb_start = 0;
            int thumb_size = visible;
            if (overflow) {
                thumb_size = std::max(1, visible * visible / total);
                thumb_size = std::min(visible, thumb_size);
                const int max_offset = total - visible;
                const int max_thumb_start = visible - thumb_size;
                thumb_start = max_offset > 0
                    ? state.ask_scroll_offset * max_thumb_start / max_offset
                    : 0;
            }
            for (int i = 0; i < visible; ++i) {
                const bool in_thumb =
                    overflow && i >= thumb_start && i < thumb_start + thumb_size;
                auto bar = text(in_thumb
                    ? (conhost_compat_layout ? " | " : " \xE2\x94\x83 ")
                    : "   ");
                bar_rows.push_back(bar | color(in_thumb ? tui::theme().ui.border : tui::theme().ui.text_dim));
            }

            Element body = hbox({
                vbox(std::move(rows)) | flex,
                vbox(std::move(bar_rows)) | reflect(ask_scrollbar_box),
            });
            if (conhost_compat_layout) {
                ask_overlay_element = vbox({
                    compat_horizontal_line(),
                    body,
                    compat_horizontal_line(),
                }) | color(tui::theme().ui.border);
            } else {
                ask_overlay_element = body | border | color(tui::theme().ui.border);
            }
            ask_overlay_element = ask_overlay_element | reflect(ask_overlay_box);
        }

        // Tool confirmation overlay —— 取代旧的单行 "y/a/n" 提示。
        // 三个固定选项:
        //   0  Yes
        //   1  Yes, allow all edits during this session (shift+tab)
        //   2  No
        // ↑↓ 移焦点,Enter 提交焦点项,1/2/3 数字键直选,Shift+Tab 直接选第二项,
        // Esc → Deny。事件分支在 CatchEvent 中,渲染层只是把状态画出来。
        Element confirm_overlay_element = emptyElement();
        if (state.confirm_pending) {
            Elements rows;
            std::string title = acecode::tui::build_confirm_question(
                state.confirm_tool_name, state.confirm_tool_args);
            // build_confirm_question 可能返回多行(bash 把 command 附在第二行),
            // 按 \n 拆开逐行 push,首行加粗。
            bool first = true;
            size_t pos = 0;
            while (pos <= title.size()) {
                size_t nl = title.find('\n', pos);
                std::string line = (nl == std::string::npos)
                    ? title.substr(pos)
                    : title.substr(pos, nl - pos);
                if (first) {
                    rows.push_back(text(" " + line) | bold | color(tui::theme().ui.accent));
                    first = false;
                } else {
                    rows.push_back(text(line) | color(tui::theme().ui.text_muted));
                }
                if (nl == std::string::npos) break;
                pos = nl + 1;
            }
            rows.push_back(text(""));

            const std::array<std::string, 3> labels = {
                "1. Yes",
                "2. Yes, allow all edits during this session (shift+tab)",
                "3. No",
            };
            const int focus = std::clamp(state.confirm_focus, 0, 2);
            for (int i = 0; i < 3; ++i) {
                bool focused = (i == focus);
                std::string prefix = focused ? " \xE2\x9D\xAF " : "   ";
                auto row = text(prefix + labels[i]);
                if (focused) {
                    row = row | bold | color(tui::theme().ui.text_primary) | bgcolor(tui::theme().ui.selection_bg);
                } else {
                    row = row | color(tui::theme().ui.text_muted);
                }
                rows.push_back(row);
            }
            rows.push_back(text(""));
            rows.push_back(
                text(" \xE2\x86\x91\xE2\x86\x93 move   Enter select   1/2/3 jump   Esc deny")
                | dim | color(tui::theme().ui.text_dim));
            confirm_overlay_element = vbox(std::move(rows)) | border | color(tui::theme().ui.accent);
        }

        if (state.ask_pending) {
            // ask active 时:把输入框留给 Other 自定义文本态使用;其它状态下
            // 显示静态提示,吞掉字符输入(CatchEvent 不透传非导航键)。
            if (state.ask_other_input_active) {
                prompt_line = hbox({
                    text(" ? ") | bold | color(tui::theme().ui.accent),
                    input_with_esc->Render() | flex,
                });
            } else {
                prompt_line = hbox({
                    text(" ? answering: ") | bold | color(tui::theme().ui.accent),
                    text("use arrows + Enter (Esc to cancel)") | dim | color(tui::theme().ui.text_dim),
                });
            }
        } else if (state.confirm_pending) {
            // overlay 已经把选项画在 message_view 之上,prompt_line 仅作静态
            // 提示并吞掉字符输入(CatchEvent 中 confirm overlay handler 拦截非
            // 导航键,这里的 hbox 不渲染 input_with_esc 是为了让光标不在输入
            // 框里闪、误导用户去打字)。
            prompt_line = hbox({
                text(" [" + state.confirm_tool_name + "] ") | bold | color(tui::theme().syntax.preproc),
                text("awaiting confirmation \xE2\x80\x94 use \xE2\x86\x91\xE2\x86\x93 + Enter (Esc to deny)")
                    | dim | color(tui::theme().ui.text_dim),
            });
        } else {
            Elements prompt_parts;
            if (state.input_mode == InputMode::Shell) {
                prompt_parts.push_back(text(" ! ") | bold | color(tui::theme().semantic.error));
            } else {
                prompt_parts.push_back(text(" > ") | bold | color(tui::theme().ui.border));
            }
            prompt_parts.push_back(input_with_esc->Render() | flex);
            if (!state.pending_queue.empty()) {
                prompt_parts.push_back(
                    text(" QUEUED " + std::to_string(state.pending_queue.size()) + " ") |
                    bold | color(tui::theme().ui.text_primary) | bgcolor(tui::theme().ui.queued_bg));
            }
            prompt_line = hbox(std::move(prompt_parts));
        }

        // -- Bottom status bar --
        std::string perm_mode_str = std::string("mode: ") + PermissionManager::mode_name(permissions.mode());
        Element token_el = render_token_usage_chip(state);
        Element load_el = render_model_load_chip();
        Element goal_el = state.goal_status.empty()
            ? text("")
            : text("  " + state.goal_status + "  ") | dim | color(tui::theme().semantic.success);
        // Tool timer chip — persistent even when the main progress element is
        // obscured by overlays or scrolled out of view. Thinking-timer chip
        // shows elapsed time + live output-token estimate while the agent is
        // waiting on the LLM. The two are mutually exclusive (thinking chip
        // returns empty when tool_running is true), so they occupy the same
        // slot in the bottom bar.
        Element tool_timer_el = render_tool_timer_chip(state);
        Element thinking_timer_el = render_thinking_timer_chip(state);
        Element bottom_bar;
        if (conhost_compat_layout) {
            auto elapsed_secs = [](std::chrono::steady_clock::time_point start) -> long long {
                if (start.time_since_epoch().count() == 0) return 0;
                return static_cast<long long>(std::chrono::duration_cast<std::chrono::seconds>(
                    std::chrono::steady_clock::now() - start).count());
            };

            Elements status_parts;
            const bool show_ctrl_c_exit_hint =
                state.ctrl_c_armed && !state.is_waiting && !state.tool_running;
            if (show_ctrl_c_exit_hint) {
                status_parts.push_back(
                    text("  Press ctrl+c again to exit  ") | dim |
                    color(tui::theme().ui.text_dim));
            } else if (dangerous_mode) {
                status_parts.push_back(
                    text("  [YOLO]  ") | bold | color(tui::theme().ui.accent));
            } else if (state.is_waiting || state.tool_running) {
                status_parts.push_back(
                    text("  esc / ctrl+c to interrupt  ") | dim |
                    color(tui::theme().ui.text_dim));
            } else {
                status_parts.push_back(
                    text("  ctrl+p: cycle permission mode  ") | dim |
                    color(tui::theme().ui.text_dim));
            }
            if (state.tool_running) {
                const long secs = elapsed_secs(state.tool_progress.start_time);
                status_parts.push_back(
                    text("Tool: " + state.tool_progress.tool_name + " " +
                         std::to_string(secs) + "s  ") |
                    bold | color(tui::theme().ui.accent));
            } else if (state.is_waiting) {
                const long secs = elapsed_secs(state.thinking_start_time);
                std::string wait = "Thinking " + std::to_string(secs) + "s";
                if (state.last_completion_tokens_authoritative > 0) {
                    wait += " " +
                        std::to_string(state.last_completion_tokens_authoritative) +
                        " tok";
                } else if (state.streaming_output_chars >= 4) {
                    wait += " ~" +
                        std::to_string(state.streaming_output_chars / 4) +
                        " tok";
                }
                wait += "  ";
                status_parts.push_back(text(wait) | bold | color(tui::theme().ui.accent));
            }
            status_parts.push_back(goal_el);
            status_parts.push_back(token_el);
            status_parts.push_back(load_el);
            status_parts.push_back(text(perm_mode_str) | dim | color(tui::theme().ui.text_dim));
            bottom_bar = hbox(std::move(status_parts));
        } else if (state.ctrl_c_armed && !state.is_waiting && !state.tool_running) {
            bottom_bar = hbox({
                text("  Press ctrl+c again to exit") | dim | color(tui::theme().ui.text_dim),
                filler(),
                tool_timer_el,
                goal_el,
                token_el,
                load_el,
                text(perm_mode_str + "  ") | dim | color(tui::theme().ui.text_dim),
            });
        } else if (dangerous_mode) {
            bottom_bar = hbox({
                text("  [YOLO]") | bold | color(tui::theme().ui.accent),
                filler(),
                thinking_timer_el,
                tool_timer_el,
                goal_el,
                token_el,
                load_el,
                text(perm_mode_str + "  ") | dim | color(tui::theme().ui.text_dim),
            });
        } else if (state.is_waiting || state.tool_running) {
            bottom_bar = hbox({
                text("  esc / ctrl+c to interrupt") | dim | color(tui::theme().ui.text_dim),
                filler(),
                thinking_timer_el,
                tool_timer_el,
                goal_el,
                token_el,
                load_el,
                text(perm_mode_str + "  ") | dim | color(tui::theme().ui.text_dim),
            });
        } else {
            bottom_bar = hbox({
                text("  ctrl+p: cycle permission mode") | dim | color(tui::theme().ui.text_dim),
                filler(),
                tool_timer_el,
                goal_el,
                token_el,
                load_el,
                text(perm_mode_str + "  ") | dim | color(tui::theme().ui.text_dim),
            });
        }

        // IME composition window positioning is handled by FTXUI's cursor
        // system (focusCursorBlock) which emits ANSI sequences to place the
        // terminal cursor at the caret. Windows Terminal/ConPTY uses this
        // to position the IME window. The Win32 IME APIs (ImmSetComposition
        // Window) don't work under ConPTY.

        Color outer_border_color = (state.input_mode == InputMode::Shell)
            ? acecode::tui::theme().semantic.error
            : acecode::tui::theme().ui.text_muted;

        Element header_separator = hide_regular_sidebar_banner
            ? emptyElement()
            : (conhost_compat_layout ? compat_horizontal_line() : separatorHeavy());
        Element prompt_separator = conhost_compat_layout
            ? compat_horizontal_line()
            : separatorLight();
        const int pending_queue_width = current_message_width > 0
            ? current_message_width
            : std::max(20, terminal_width -
                (show_regular_sidebar ? kRegularSidebarWidthCols + 6 : 4));
        Element pending_queue_element =
            render_pending_queue_block(state, pending_queue_width);
        Element pending_attachment_element =
            render_pending_attachment_block(state, pending_queue_width);
        Element todo_checklist_element =
            acecode::tui::todo_checklist_uses_sidebar(show_regular_sidebar)
                ? emptyElement()
                : acecode::tui::render_todo_checklist_block(
                    state.todos, pending_queue_width);

        Element main_root = vbox({
            header,
            header_separator | color(acecode::tui::theme().ui.text_dim),
            message_view,
            mcp_loading_element,
            resume_picker_element,
            rewind_picker_element,
            model_picker_element,
            ask_overlay_element,
            confirm_overlay_element,
            slash_dropdown_element,
            thinking_element,
            todo_checklist_element,
            pending_queue_element,
            prompt_separator | color(acecode::tui::theme().ui.text_dim),
            pending_attachment_element,
            prompt_line,
            bottom_bar,
        });

        if (conhost_compat_layout) {
            return vbox({
                compat_horizontal_line() | color(outer_border_color),
                main_root | flex,
                compat_horizontal_line() | color(outer_border_color),
            }) | flex;
        }

        if (show_regular_sidebar) {
            Element sidebar = render_regular_sidebar(
                state,
                version_str,
                cwd_display,
                kRegularSidebarWidthCols,
                anim_tick.load());
            return hbox({
                main_root | flex,
                separator() | color(outer_border_color),
                sidebar,
            }) | borderRounded | color(outer_border_color) | flex;
        }

        return main_root | borderRounded | color(outer_border_color) | flex;
    });

    run_tui_loop(screen, renderer);
    // 先停 model-pool 轮询线程:它的回调按引用捕获 provider_slot/config/agent_loop,
    // 必须在这些局部变量析构前 join。g_active_screen 此时已被 run_tui_loop 清空,
    // 回调不会再 Post 到屏幕。stop() 幂等,未 start 也安全。
    acecode::model_pool_status_service().stop();
    shutdown_after_tui_loop(state, agent_loop, mcp_manager, running,
                            agent_aborting, anim_thread, auth_thread,
                            update_check_thread,
                            session_manager, config);

    return 0;
}