main.cpp

#define NOMINMAX

#include <windows.h>
#include <commctrl.h>
#include <commdlg.h>
#include <richedit.h>
#include <shlobj.h>
#include <shobjidl.h>
#include <shellapi.h>

#include <algorithm>
#include <chrono>
#include <climits>
#include <cmath>
#include <cmath>
#include <cstdio>
#include <filesystem>
#include <fstream>
#include <iomanip>
#include <initializer_list>
#include <iomanip>
#include <initializer_list>
#include <iostream>
#include <map>
#include <memory>
#include <optional>
#include <regex>
#include <set>
#include <sstream>
#include <string>
#include <thread>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>

using std::optional;
namespace fs = std::filesystem;

#include "build_info.inc"
#include "nc_lexer.h"
#include "nc_modal_state.h"
#include "nc_events.h"

using nc::MachineModalState;
using nc::parseGcodeLine;
using nc::parseXY;
using nc::normalizeTokens;
using nc::normalizeTokensForWcs;
#include "nc_lexer.h"
#include "nc_modal_state.h"
#include "nc_events.h"

using nc::MachineModalState;
using nc::parseGcodeLine;
using nc::parseXY;
using nc::normalizeTokens;
using nc::normalizeTokensForWcs;

static constexpr COLORREF C_BG = RGB(240, 240, 240);
static constexpr COLORREF C_CARD = C_BG;
static constexpr COLORREF C_PRIMARY_DARK = RGB(0, 0, 0);
static constexpr COLORREF C_TEXT = RGB(0, 0, 0);
static constexpr COLORREF C_MUTED = RGB(96, 96, 96);
static constexpr COLORREF C_ERR = RGB(160, 0, 0);
static constexpr UINT_PTR TOOLTIP_TIMER_ID = 7001;
static constexpr UINT_PTR HOVER_POLL_TIMER_ID = 7002;
static constexpr UINT WM_APP_JOB_DONE = WM_APP + 101;
static constexpr UINT WM_APP_SHOW_TOOLTIP = WM_APP + 102;
static constexpr UINT WM_APP_JOB_PROGRESS = WM_APP + 103;

enum ControlId {
    ID_BTN_NORMAL = 1001,
    ID_BTN_MERGE,
    ID_BTN_PREVIEW,
    ID_BTN_TOPMOST,
    ID_BTN_ADD_FILES,
    ID_BTN_ADD_FOLDER,
    ID_BTN_UP,
    ID_BTN_DOWN,
    ID_BTN_REMOVE,
    ID_BTN_CLEAR,
    ID_LIST_FILES,
    ID_ALLOW_HH,
    ID_FILTER_TRY,
    ID_STRIP,
    ID_OPEN_G28,
    ID_END_DUAL,
    ID_HH_STRIP,
    ID_H_FORCE,
    ID_CROSS_G43,
    ID_SORT_H,
    ID_SORT_FILE,
    ID_SORT_Z_GLOBAL,
    ID_SORT_Z_CLUSTER,
    ID_SORT_SMART,
    ID_APPEND_TRY,
    ID_G54G56_MODE,
    ID_G56_H_PLUS10,
    ID_G54G56_LIFT_OFF,
    ID_G54G56_LIFT_50,
    ID_G54G56_LIFT_100,
    ID_MULTI_WCS_CONFIG,
    ID_EXP_COMP_ENABLE,
    ID_EXP_COMP_CONFIG,
    ID_SIDE_COMP_ENABLE,
    ID_PRE_LEGACY,

    ID_M00_WAIT_OFF,
    ID_M00_WAIT_ALL,
    ID_M00_WAIT_DRILL,
    ID_G41_RISK_TEXT,
    ID_PRE_LEGACY,
    ID_PRE_OFF,
    ID_PRE_NEXT,
    ID_PRE_RING,
    ID_TRAILING,
    ID_TMAP,
    ID_SILENT,
    ID_NOVICE,
    ID_LABEL_TRAILING,
    ID_LABEL_TMAP,
    ID_GROUP_HEAD,
    ID_GROUP_SORT,
    ID_GROUP_TOOL,
    ID_GROUP_PARAMS,
    ID_TABS,
    ID_TEXT_NORMAL,
    ID_TEXT_H,
    ID_TEXT_HH,
    ID_TEXT_LOG,
    ID_G54G56_SECOND_AUTO,
    ID_G54G56_SECOND_TOGGLE,
    ID_G54G56_SECOND_G54,
    ID_G54G56_SECOND_G56,
    ID_SAFETY_AUDIT_ENABLE,
    ID_SAFETY_AUDIT_STRICT,
    ID_COMP_LIMIT_ENABLE,
    ID_COMP_LIMIT_VALUE,
    ID_BTN_SAFETY_REPORT,
    ID_GROUP_SAFETY,
    ID_SHOP_PRECHECK_INPUT,
    ID_SHOP_KEYWORD_PREVIEW,
    ID_SHOP_COORD_DRY_RUN,
    ID_SHOP_G41_ENVELOPE,
    ID_SHOP_AUTO_BACKUP,
    ID_SHOP_CONFIG_SNAPSHOT,
    ID_GROUP_TEMPLATE,
    ID_TEMPLATE_COMBO,
    ID_BTN_TEMPLATE_APPLY,
};

static std::wstring widen(const std::string& s) {
    if (s.empty()) return {};
    int n = MultiByteToWideChar(CP_UTF8, 0, s.data(), (int)s.size(), nullptr, 0);
    if (n <= 0) return L"";
    std::wstring w(n, L'\0');
    MultiByteToWideChar(CP_UTF8, 0, s.data(), (int)s.size(), w.data(), n);
    return w;
}

static std::string narrowUtf8(const std::wstring& w) {
    if (w.empty()) return {};
    int n = WideCharToMultiByte(CP_UTF8, 0, w.data(), (int)w.size(), nullptr, 0, nullptr, nullptr);
    std::string s(n, '\0');
    WideCharToMultiByte(CP_UTF8, 0, w.data(), (int)w.size(), s.data(), n, nullptr, nullptr);
    return s;
}

static std::string bytesToUtf8(const std::string& bytes, UINT cp, DWORD flags = 0) {
    if (bytes.empty()) return {};
    int wn = MultiByteToWideChar(cp, flags, bytes.data(), (int)bytes.size(), nullptr, 0);
    if (wn <= 0) return {};
    std::wstring w(wn, L'\0');
    if (!MultiByteToWideChar(cp, flags, bytes.data(), (int)bytes.size(), w.data(), wn)) return {};
    return narrowUtf8(w);
}

static std::string readFileBytes(const fs::path& path) {
    std::ifstream in(path, std::ios::binary | std::ios::ate);
    if (!in) throw std::runtime_error("open failed: " + narrowUtf8(path.wstring()));
    std::streamoff n = in.tellg();
    if (n < 0) throw std::runtime_error("read size failed: " + narrowUtf8(path.wstring()));
    std::string bytes((size_t)n, '\0');
    in.seekg(0, std::ios::beg);
    if (!bytes.empty()) {
        in.read(bytes.data(), (std::streamsize)bytes.size());
        if (!in || in.gcount() != (std::streamsize)bytes.size()) {
            throw std::runtime_error("read failed: " + narrowUtf8(path.wstring()));
        }
    }
    return bytes;
}

static std::vector<std::string> splitLines(const std::string& text) {
    std::vector<std::string> out;
    out.reserve((size_t)std::count(text.begin(), text.end(), '\n') + 1);
    size_t start = 0;
    while (start <= text.size()) {
        size_t pos = text.find('\n', start);
        std::string line = text.substr(start, pos == std::string::npos ? std::string::npos : pos - start);
        if (!line.empty() && line.back() == '\r') line.pop_back();
        out.push_back(line);
        if (pos == std::string::npos) break;
        start = pos + 1;
    }
    if (!out.empty() && out.back().empty() && !text.empty() && text.back() == '\n') out.pop_back();
    return out;
}

static std::vector<std::string> splitLinesKeepEnds(const std::string& text) {
    std::vector<std::string> out;
    out.reserve((size_t)std::count(text.begin(), text.end(), '\n') + 1);
    size_t start = 0;
    while (start < text.size()) {
        size_t pos = text.find('\n', start);
        if (pos == std::string::npos) {
            out.push_back(text.substr(start));
            break;
        }
        out.push_back(text.substr(start, pos - start + 1));
        start = pos + 1;
    }
    return out;
}

static std::string utf8IgnoreInvalid(const std::string& bytes) {
    std::string out;
    for (size_t i = 0; i < bytes.size();) {
        unsigned char c = (unsigned char)bytes[i];
        size_t len = 0;
        if (c < 0x80) len = 1;
        else if ((c & 0xE0) == 0xC0 && c >= 0xC2) len = 2;
        else if ((c & 0xF0) == 0xE0) len = 3;
        else if ((c & 0xF8) == 0xF0 && c <= 0xF4) len = 4;
        else { ++i; continue; }
        if (i + len > bytes.size()) break;
        bool ok = true;
        for (size_t j = 1; j < len; ++j) {
            if (((unsigned char)bytes[i + j] & 0xC0) != 0x80) { ok = false; break; }
        }
        if (!ok) { ++i; continue; }
        out.append(bytes, i, len);
        i += len;
    }
    return out;
}

static std::vector<std::string> readTextLines(const fs::path& path) {
    const std::string bytes = readFileBytes(path);
    std::string text = bytesToUtf8(bytes, CP_UTF8, MB_ERR_INVALID_CHARS);
    if (text.empty() && !bytes.empty()) text = bytesToUtf8(bytes, CP_ACP, 0);
    if (text.empty() && !bytes.empty()) text = bytes;
    return splitLines(text);
}

static std::vector<std::string> readNormalLines(const fs::path& path) {
    return splitLinesKeepEnds(utf8IgnoreInvalid(readFileBytes(path)));
}

static void writeUtf8File(const fs::path& path, const std::string& text) {
    std::ofstream out(path, std::ios::binary);
    if (!out) throw std::runtime_error("write failed");
    out.write(text.data(), (std::streamsize)text.size());
}

static std::string trim(const std::string& s) {
    size_t a = 0, b = s.size();
    while (a < b && std::isspace((unsigned char)s[a])) ++a;
    while (b > a && std::isspace((unsigned char)s[b - 1])) --b;
    return s.substr(a, b - a);
}

static std::string upperAscii(std::string s) {
    for (char& c : s) c = (char)std::toupper((unsigned char)c);
    return s;
}

static bool startsWith(const std::string& s, const std::string& prefix) {
    return s.size() >= prefix.size() && std::equal(prefix.begin(), prefix.end(), s.begin());
}

static bool endsWithLower(const std::wstring& s, const std::wstring& suffix) {
    if (s.size() < suffix.size()) return false;
    for (size_t i = 0; i < suffix.size(); ++i) {
        wchar_t a = towlower(s[s.size() - suffix.size() + i]);
        wchar_t b = towlower(suffix[i]);
        if (a != b) return false;
    }
    return true;
}

static std::string baseNameUtf8(const fs::path& p) {
    return narrowUtf8(p.filename().wstring());
}

static std::string formatGcodeVal(double val) {
    if (std::abs(val - std::round(val)) < 1e-9) {
        return std::to_string((long long)std::llround(val)) + ".";
    }
    std::ostringstream ss;
    ss << std::setprecision(12) << val;
    std::string s = ss.str();
    while (s.find('.') != std::string::npos && !s.empty() && s.back() == '0') s.pop_back();
    return s;
}
struct Segment {
    std::string src_fn;
    fs::path src_path;
    optional<std::string> tool_comment;
    optional<std::string> dia_comment;
    optional<std::string> date_comment;
    optional<std::string> wcs;
    optional<std::string> g0_no_wcs_etc;
    optional<std::string> g0_xy_etc;
    optional<std::string> g43_line;
    optional<int> h_num;
    std::vector<std::string> cutting_body;
    optional<double> first_cut_z;
    optional<std::string> machine_time;
    optional<std::string> cutting_time;
    std::pair<optional<double>, optional<double>> g0_xy;
    bool has_drill_cycle = false;  // 是否包含G81/G83/G84钻孔循环
};
    bool has_drill_cycle = false;  // 是否包含G81/G83/G84钻孔循环
};

static constexpr const char* SORT_H_ASC = "H_ASC";
static constexpr const char* SORT_FILE = "FILE";
static constexpr const char* SORT_Z_GLOBAL = "Z_GLOBAL";
static constexpr const char* SORT_Z_CLUSTER = "Z_CLUSTER";
static constexpr const char* SORT_SMART_AUTO = "SMART_AUTO";

static constexpr const char* PRESELECT_OFF = "OFF";
static constexpr const char* PRESELECT_LEGACY = "LEGACY";
static constexpr const char* PRESELECT_NEXT = "NEXT";
static constexpr const char* PRESELECT_RING = "RING";

// M00 wait mode
static constexpr const char* M00_WAIT_OFF = "OFF";
static constexpr const char* M00_WAIT_ALL_TOOLS = "ALL_TOOLS";
static constexpr const char* M00_WAIT_DRILL_ONLY = "DRILL_ONLY";

// G41 刀损补偿速度/安全策略：0 最危险最快，4 最安全。
static constexpr const char* G41_RISK_EXTREME = "EXTREME";      // 极限速度: 自动开 G41 后不自动关 G40
static constexpr const char* G41_RISK_FAST = "FAST";            // 偏快: 旧版兼容，段末才 G40
static constexpr const char* G41_RISK_BALANCED = "BALANCED";    // 平衡: G0/固定循环/停机前 G40
static constexpr const char* G41_RISK_SAFE = "SAFE";            // 偏安全: 再加纯 Z 前 G40
static constexpr const char* G41_RISK_SAFEST = "SAFEST";        // 安全: 当前保守策略，G0/纯Z/固定循环/G2G3前 G40
static constexpr const char* G41_CLOSE_SEGMENT = G41_RISK_FAST;      // 兼容旧 CLI
static constexpr const char* G41_CLOSE_ADAPTIVE = G41_RISK_SAFEST;   // 兼容旧 CLI

static constexpr const char* SECOND_WCS_AUTO = "AUTO";
static constexpr const char* SECOND_WCS_TOGGLE = "TOGGLE";
static constexpr const char* SECOND_WCS_G54 = "G54";
static constexpr const char* SECOND_WCS_G56 = "G56";

struct TipDef {
    int id;
    const char* key;
    const char* text;
};

static const std::vector<TipDef>& tooltipDefs() {
    static const std::vector<TipDef> defs = {
#include "py_tooltips.inc"
    };
    return defs;
}

static const char* tooltipUtf8ForId(int id) {
    for (const auto& def : tooltipDefs()) {
        if (def.id == id) return def.text;
    }
    return nullptr;
}

static void dumpTooltipsFile(const fs::path& path) {
    auto esc = [](const char* s) {
        std::string out;
        for (const char* p = s; *p; ++p) {
            if (*p == '\\') out += "\\\\";
            else if (*p == '\n') out += "\\n";
            else if (*p == '\t') out += "\\t";
            else out.push_back(*p);
        }
        return out;
    };
    std::ostringstream ss;
    for (const auto& def : tooltipDefs()) {
        ss << def.id << "\t" << def.key << "\t" << esc(def.text) << "\n";
    }
    writeUtf8File(path, ss.str());
}

struct WorkOffsetConfig {
    std::string wcs;
    int h_offset = 0;
};

struct ExperimentalCompensation {
    std::string wcs;
    double x = 0.0;
    double y = 0.0;
    double z = 0.0;
};

struct MergeOptions {
    std::string version = "H";
    bool strip_header_g49g80 = true;
    bool open_g28 = true;
    bool end_dual_axis = true;
    bool hh_strip_f4000 = true;
    bool h_force_f4000 = true;
    bool g54g56_mode = false;
    bool end_zero_zero = false;
    int g54g56_lift_z = 0;
    std::vector<WorkOffsetConfig> work_offsets = {{"G54", 0}, {"G56", 10}};
    bool experimental_compensation = false;
    std::vector<ExperimentalCompensation> compensations;
    bool side_compensation_g41 = false;
    std::string preselect_mode = PRESELECT_LEGACY;

    std::string m00_wait_mode = M00_WAIT_OFF;  // M00暂停模式
    std::string g41_close_strategy = G41_RISK_BALANCED;  // G41刀损补偿策略，默认平衡速度和风险
    std::string preselect_mode = PRESELECT_LEGACY;
    std::string sort_strategy = SORT_H_ASC;
    bool append_try_knife_at_end = false;
    bool safety_audit_report = false;
    bool safety_audit_strict = false;
    bool compensation_limit_check = false;
    double compensation_limit_abs = 0.10;
    bool shop_precheck_input = false;
    bool shop_keyword_preview = false;
    bool shop_coord_dry_run = false;
    bool shop_g41_envelope = false;
    bool shop_auto_backup = false;
    bool shop_config_snapshot = false;
    std::string config_template_name;
    int trailing_blank_lines = 1;
    std::map<std::string, int> tool_t_map;
};

enum class JobKind { Normal, Merge, Preview, Load, Safety };

struct JobResult {
    JobKind kind = JobKind::Normal;
    bool ok = false;
    std::wstring status;
    std::wstring logMessage;
    std::wstring outDir;
    std::wstring errorTitle;
    std::wstring errorMessage;
    std::string normalText;
    std::string hText;
    std::string hhText;
    std::string safetyText;
    std::vector<fs::path> loadedFiles;
    int added = 0;
    int skippedHh = 0;
    int skippedTry = 0;
    int skippedOther = 0;
};

static bool isTryKnifeName(const std::string& fn) {
    std::string low = upperAscii(fn);
    return low.size() >= 7 && low.rfind("-11.PTP") == low.size() - 7;
}

static bool isFlyingKnifeSeg(const Segment& seg) {
    return isTryKnifeName(seg.src_fn) && seg.h_num && *seg.h_num == 1;
}

static Segment parseSegment(const std::vector<std::string>& lines, const std::string& srcFn, const fs::path& path) {
    static const std::regex g0Any(R"(^G0(?=[\sA-Z])\s*(.+)$)");
    static const std::regex g43(R"(^G43\s*Z[\d\.\-]+\s*H(\d+)(\s*.*)?$)");
    static const std::regex zInline(R"(^G[01](?:\s|G\d+|X[\d\.\-]+|Y[\d\.\-]+)*\s*Z([\d\.\-]+))");
    static const std::regex zLead(R"(^Z([\d\.\-]+))");

    Segment seg;
    seg.src_fn = srcFn;
    seg.src_path = path;
    for (size_t j = 0; j < lines.size(); ++j) {
        std::string s = trim(lines[j]);
        if (s.empty()) continue;
        if (s[0] == '(') {
            if (!seg.tool_comment && startsWith(s, "(Tool")) seg.tool_comment = s;
            else if (!seg.dia_comment && startsWith(s, "(===") && s.find("DIA") != std::string::npos) seg.dia_comment = s;
            else if (!seg.date_comment && startsWith(s, "(Date")) seg.date_comment = s;
            else if (s.find("MACHINE-TIME") != std::string::npos) seg.machine_time = s;
            else if (s.find("CUTTING-TIME") != std::string::npos) seg.cutting_time = s;
            continue;
        }
        if (!seg.g0_xy_etc) {
            std::smatch m;
            if (std::regex_match(s, m, g0Any)) {
                std::vector<std::string> kept;
                std::vector<std::string> noWcs;
                for (const auto& t : normalizeTokens(m[1].str())) {
                    if (t == "G54" || t == "G55" || t == "G56" || t == "G57" || t == "G58" || t == "G59") {
                        if (!seg.wcs) seg.wcs = t;
                        if (t != "G54") kept.push_back(t);
                        continue;
                    } else {
                        if (t != "G90") kept.push_back(t);
                        if (t != "G90") noWcs.push_back(t);
                    }
                }
                if (!seg.wcs || noWcs.empty()) {
                    noWcs.clear();
                    for (const auto& t : normalizeTokensForWcs(m[1].str())) {
                        if (t == "G54" || t == "G55" || t == "G56" || t == "G57" || t == "G58" || t == "G59") {
                            if (!seg.wcs) seg.wcs = t;
                            continue;
                        }
                        if (t != "G90") noWcs.push_back(t);
                    }
                }
                std::ostringstream ss;
                for (size_t i = 0; i < kept.size(); ++i) {
                    if (i) ss << ' ';
                    ss << kept[i];
                }
                seg.g0_xy_etc = ss.str();
                std::ostringstream nw;
                for (size_t i = 0; i < noWcs.size(); ++i) {
                    if (i) nw << ' ';
                    nw << noWcs[i];
                }
                seg.g0_no_wcs_etc = nw.str();
                seg.g0_xy = parseXY(*seg.g0_xy_etc);
            }
        }
        if (!seg.g43_line) {
            std::smatch m;
            if (std::regex_match(s, m, g43)) {
                seg.g43_line = s;
                try { seg.h_num = std::stoi(m[1].str()); } catch (...) { seg.h_num.reset(); }
                for (size_t k = j + 1; k < lines.size(); ++k) {
                    if (startsWith(trim(lines[k]), "M05")) break;
                    seg.cutting_body.push_back(lines[k]);
                }
                // 修复 #25: 钻孔检测与首切 Z 提取分离，钻孔检测必须遍历整个 body
                for (const auto& bl : seg.cutting_body) {
                    std::string bs = trim(bl);
                    // 检测钻孔/镗孔固定循环 G81-G89
                    for (const auto& t : parseGcodeLine(bs)) {
                        if (t.ch == 'G' && t.val >= 81.0 && t.val <= 89.0) {
                            seg.has_drill_cycle = true;
                            break;
                        }
                    }
                    if (seg.has_drill_cycle) break;  // 已找到钻孔，可提前退出
                }
                // 提取第一个 Z 坐标（独立循环，不受钻孔检测影响）
                }
                // 修复 #25: 钻孔检测与首切 Z 提取分离，钻孔检测必须遍历整个 body
                for (const auto& bl : seg.cutting_body) {
                    std::string bs = trim(bl);
                    // 检测钻孔/镗孔固定循环 G81-G89
                    for (const auto& t : parseGcodeLine(bs)) {
                        if (t.ch == 'G' && t.val >= 81.0 && t.val <= 89.0) {
                            seg.has_drill_cycle = true;
                            break;
                        }
                    }
                    if (seg.has_drill_cycle) break;  // 已找到钻孔，可提前退出
                }
                // 提取第一个 Z 坐标（独立循环，不受钻孔检测影响）
                for (const auto& bl : seg.cutting_body) {
                    std::string bs = trim(bl);
                    std::smatch zm;
                    if (std::regex_search(bs, zm, zInline) || std::regex_search(bs, zm, zLead)) {
                        try { seg.first_cut_z = std::stod(zm[1].str()); } catch (...) {}
                        break;  // 只需首个 Z
                    }
                }
            }
    }
    return seg;
}

static std::string g0PayloadForWcs(const Segment& seg, const std::string& wcs) {
    (void)wcs;
    return seg.g0_no_wcs_etc.value_or(seg.g0_xy_etc.value_or(""));
}

static std::string extractToolName(const std::string& toolComment) {
    static const std::regex re(R"(\(Tool\s*=\s*([^\)]+)\))");
    std::smatch m;
    return std::regex_match(toolComment, m, re) ? trim(m[1].str()) : "";
}

static bool isAxisBoundaryBefore(const std::string& line, size_t pos) {
    if (pos == 0) return true;
    unsigned char prev = (unsigned char)line[pos - 1];
    return std::isspace(prev) || line[pos - 1] == ',' || line[pos - 1] == ';';
}

static std::string replaceHNumber(std::string line, int hNum) {
    std::ostringstream h;
    h << "H" << std::setw(2) << std::setfill('0') << hNum;
    static const std::regex hRe(R"(H\s*\d+)");
    return std::regex_replace(line, hRe, h.str(), std::regex_constants::format_first_only);
}

static std::string dTokenText(int dNum) {
    std::ostringstream d;
    d << "D" << std::setw(2) << std::setfill('0') << dNum;
    return d.str();
}

static std::string replaceDNumber(std::string line, int dNum) {
    if (dNum <= 0) return line;
    std::string d = dTokenText(dNum);
    bool inComment = false;
    for (size_t i = 0; i < line.size(); ++i) {
        if (line[i] == '(') { inComment = true; continue; }
        if (inComment) { if (line[i] == ')') inComment = false; continue; }
        if ((line[i] == 'D' || line[i] == 'd') && isAxisBoundaryBefore(line, i)) {
            size_t start = i + 1;
            while (start < line.size() && std::isspace((unsigned char)line[start])) ++start;
            size_t end = start;
            while (end < line.size() && std::isdigit((unsigned char)line[end])) ++end;
            if (end > start) { line.replace(i, end - i, d); return line; }
        }
    }
    return line;
}

static std::string ensureG41DNumber(std::string line, int dNum) {
    if (dNum <= 0) return line;
    bool inComment = false;
    optional<size_t> g41End;
    for (size_t i = 0; i < line.size(); ++i) {
        if (line[i] == '(') { inComment = true; continue; }
        if (inComment) { if (line[i] == ')') inComment = false; continue; }
        if ((line[i] == 'D' || line[i] == 'd') && isAxisBoundaryBefore(line, i)) return replaceDNumber(std::move(line), dNum);
        if ((line[i] == 'G' || line[i] == 'g') && isAxisBoundaryBefore(line, i)) {
            size_t j = i + 1;
            while (j < line.size() && line[j] == '0') ++j;
            if (j + 1 < line.size() && line[j] == '4' && line[j + 1] == '1') {
                size_t k = j + 2;
                if (k >= line.size() || !std::isdigit((unsigned char)line[k])) g41End = k;
            }
        }
    }
    if (g41End) line.insert(*g41End, " " + dTokenText(dNum));
    return line;
}

static std::string toolGroupKey(const Segment& seg) {
    std::string name = upperAscii(extractToolName(seg.tool_comment.value_or("")));
    if (name.size() > 1 && name.back() == 'X') name.pop_back();
    if (name.empty()) return "H" + std::to_string(seg.h_num.value_or(0));
    return name;
}

static bool shouldUsePairedCoordinates(const Segment& a, const Segment& b) {
    std::string ta = upperAscii(extractToolName(a.tool_comment.value_or("")));
    std::string tb = upperAscii(extractToolName(b.tool_comment.value_or("")));
    return (!ta.empty() && !tb.empty() && ta != tb && toolGroupKey(a) == toolGroupKey(b));
}

static std::string formatLiftZLikeOriginal(const std::string& original, bool hasG0, int liftZ, bool hasG40) {
    std::ostringstream ss;
    if (hasG0) ss << "G0 ";
    ss << "Z" << liftZ;
    static const std::regex zRe(R"(Z[-+]?\d+(\.\d*)?)");
    std::smatch m;
    if (std::regex_search(original, m, zRe) && m[1].matched) ss << m[1].str();
    if (hasG40) ss << "G40";
    return ss.str();
}

static std::vector<std::string> cuttingBodyForG54G56(const Segment& seg, int liftZ) {
    std::vector<std::string> body = seg.cutting_body;
    if (liftZ <= 0) return body;
    for (auto it = body.rbegin(); it != body.rend(); ++it) {
        std::string s = trim(*it);
        if (s.empty()) continue;
        std::smatch m;
        static const std::regex zOnlyRe(R"(^(G0\s*)?Z[-+]?\d+(?:\.\d*)?(G40)?$)");
        if (std::regex_match(s, m, zOnlyRe)) {
            bool hasG0 = m[1].matched;
            bool hasG40 = m[2].matched;
            *it = formatLiftZLikeOriginal(s, hasG0, liftZ, hasG40);
        }
        break;
    }
    return body;
}

static std::string adjustG0ForG54G56(std::string line, const Segment& seg, const MergeOptions& opts) {
    (void)seg;
    (void)opts;
    return line;
}

static std::string upperWcs(std::string s) {
    s = upperAscii(trim(s));
    static const std::regex basic("^G5[4-9]$");
    std::smatch m;
    static const std::regex ext(R"(^G54\.1\s*P\s*([1-9]|[1-3][0-9]|4[0-8])$)");
    if (std::regex_match(s, basic)) return s;
    if (std::regex_match(s, m, ext)) return "G54.1 P" + m[1].str();
    throw std::runtime_error("坐标系格式错(仅支持 G54-G59 / G54.1 P1-P48): " + s);
}

static std::vector<WorkOffsetConfig> parseWorkOffsetConfigText(const std::string& raw) {
    std::vector<WorkOffsetConfig> out;
    std::set<std::string> seen;
    std::stringstream ss(raw);
    for (std::string piece; std::getline(ss, piece, ',');) {
        piece = trim(piece);
        if (piece.empty()) continue;
        auto pos = piece.find(':');
        if (pos == std::string::npos) throw std::runtime_error("多坐标配置格式错: " + piece);
        std::string wcs = upperWcs(piece.substr(0, pos));
        // 修复 #31: stoi 必须完整消费，拒绝 "10.5"/"10abc"/"0x10"
        std::string numStr = trim(piece.substr(pos + 1));
        size_t consumed = 0;
        int offset = 0;
        try {
            offset = std::stoi(numStr, &consumed);
        } catch (const std::exception&) {
            throw std::runtime_error("多坐标 offset 非法: " + piece);
        }
        if (consumed != numStr.size()) {
            throw std::runtime_error("多坐标 offset 含非法字符(必须为纯整数): " + piece);
        }
        if (offset < -199 || offset > 199) throw std::runtime_error("多坐标 offset 超范围(-199..199): " + piece);
        if (!seen.insert(wcs).second) throw std::runtime_error("多坐标配置重复: " + wcs);
        out.push_back({wcs, offset});
        if (out.size() > 48) throw std::runtime_error("多坐标配置最多支持 48 项");
    }
    if (out.empty()) throw std::runtime_error("多坐标配置不能为空");
    return out;
}

static std::string formatWorkOffsetConfigText(const std::vector<WorkOffsetConfig>& cfg) {
    std::ostringstream ss;
    for (size_t i = 0; i < cfg.size(); ++i) {
        if (i) ss << ',';
        ss << cfg[i].wcs << ':' << cfg[i].h_offset;
    }
    return ss.str();
}

static double parseStrictDouble(const std::string& raw, const std::string& label);
static void enforceExperimentalCompensationHardCap(const ExperimentalCompensation& comp);

static std::vector<ExperimentalCompensation> parseCompensationConfigText(const std::string& raw) {
    std::vector<ExperimentalCompensation> out;
    std::set<std::string> seenWcs;
    std::stringstream ss(raw);
    for (std::string piece; std::getline(ss, piece, ';');) {
        piece = trim(piece);
        if (piece.empty()) throw std::runtime_error("坐标补偿配置存在空项");
        std::stringstream fields(piece);
        std::string wcsPart;
        if (!std::getline(fields, wcsPart, ':')) throw std::runtime_error("实验性补偿格式错: " + piece);
        ExperimentalCompensation comp;
        comp.wcs = upperWcs(wcsPart);
        if (!seenWcs.insert(comp.wcs).second) throw std::runtime_error("坐标补偿配置重复: " + comp.wcs);
        std::set<char> seenAxis;
        bool sawAxis = false;
        for (std::string field; std::getline(fields, field, ':');) {
            field = trim(field);
            if (field.size() < 2) throw std::runtime_error("实验性补偿字段格式错: " + piece);
            char axis = (char)std::toupper((unsigned char)field[0]);
            if (axis != 'X' && axis != 'Y' && axis != 'Z') throw std::runtime_error("实验性补偿轴错误: " + field);
            if (!seenAxis.insert(axis).second) throw std::runtime_error("坐标补偿配置重复轴: " + comp.wcs + " " + axis);
            double value = parseStrictDouble(field.substr(1), "坐标补偿数值");
            if (axis == 'X') comp.x = value;
            else if (axis == 'Y') comp.y = value;
            else comp.z = value;
            sawAxis = true;
        }
        if (!sawAxis) throw std::runtime_error("坐标补偿配置缺少轴: " + piece);
        out.push_back(comp);
    }
    return out;
}

static std::string formatCompensationConfigText(const std::vector<ExperimentalCompensation>& cfg) {
    std::ostringstream ss;
    for (size_t i = 0; i < cfg.size(); ++i) {
        if (i) ss << ';';
        ss << cfg[i].wcs << ":X" << cfg[i].x << ":Y" << cfg[i].y << ":Z" << cfg[i].z;
    }
    return ss.str();
}

static std::string normalizeTemplateKey(std::string name) {
    name = upperAscii(trim(name));
    for (char& c : name) if (c == ' ' || c == '-' || c == '/') c = '_';
    return name;
}

static void applyConfigTemplate(MergeOptions& opts, const std::string& rawName) {
    std::string key = normalizeTemplateKey(rawName);
    if (key.empty() || key == "NONE" || key == "OFF") return;
    opts.config_template_name = rawName;
    if (key == "M70_SAFE" || rawName == "M70默认安全") {
        opts.g41_close_strategy = G41_CLOSE_ADAPTIVE;
        opts.side_compensation_g41 = true;
        opts.safety_audit_report = true;
        opts.compensation_limit_check = true;
        opts.compensation_limit_abs = 0.10;
        opts.shop_precheck_input = true;
        opts.shop_keyword_preview = true;
        opts.shop_coord_dry_run = true;
        opts.shop_g41_envelope = true;
        return;
    }
    if (key == "G54G56_H10" || key == "G54_G56_H10" || rawName == "G54/G56 H+10") {
        opts.g54g56_mode = true;
        opts.work_offsets = {{"G54", 0}, {"G56", 10}};
        opts.g54g56_lift_z = 100;
        opts.shop_keyword_preview = true;
        opts.shop_coord_dry_run = true;
        return;
    }
    if (key == "MULTI_WCS" || rawName == "多工位 G54/G56/G55") {
        opts.g54g56_mode = true;
        opts.work_offsets = {{"G54", 0}, {"G56", 10}, {"G55", 20}};
        opts.g54g56_lift_z = 100;
        opts.shop_keyword_preview = true;
        opts.shop_coord_dry_run = true;
        return;
    }
    if (key == "DRILL_PAUSE" || rawName == "钻孔刀暂停") {
        opts.m00_wait_mode = M00_WAIT_DRILL_ONLY;
        opts.preselect_mode = PRESELECT_NEXT;
        opts.safety_audit_report = true;
        opts.shop_keyword_preview = true;
        opts.shop_precheck_input = true;
        return;
    }
    if (key == "MASTER_COMPAT" || rawName == "老师傅兼容") {
        opts.g54g56_mode = false;
        opts.side_compensation_g41 = false;
        opts.g41_close_strategy = G41_CLOSE_SEGMENT;
        opts.m00_wait_mode = M00_WAIT_OFF;
        opts.preselect_mode = PRESELECT_LEGACY;
        opts.shop_precheck_input = true;
        opts.shop_keyword_preview = true;
        return;
    }
    throw std::runtime_error("未知配置模板: " + rawName);
}

struct CompensationLimitIssue {
    std::string severity;
    std::string text;
};

static std::vector<CompensationLimitIssue> scanCompensationLimitIssues(const MergeOptions& opts) {
    std::vector<CompensationLimitIssue> issues;
    if (!opts.compensation_limit_check) return issues;
    if (!std::isfinite(opts.compensation_limit_abs) || opts.compensation_limit_abs < 0.0) {
        issues.push_back({"ERROR", "坐标补偿限值配置无效，最大允许绝对值必须为非负数"});
        return issues;
    }
    auto checkAxis = [&](const std::string& wcs, char axis, double value) {
        if (std::abs(value) > opts.compensation_limit_abs + 1e-12) {
            std::ostringstream ss;
            ss << "坐标补偿超限: " << wcs << ' ' << axis << formatGcodeVal(value)
               << "，允许 |delta| <= " << formatGcodeVal(opts.compensation_limit_abs);
            issues.push_back({opts.safety_audit_strict ? "ERROR" : "WARN", ss.str()});
        }
    };
    for (const auto& comp : opts.compensations) {
        checkAxis(comp.wcs, 'X', comp.x);
        checkAxis(comp.wcs, 'Y', comp.y);
        checkAxis(comp.wcs, 'Z', comp.z);
    }
    return issues;
}

static double parseStrictDouble(const std::string& raw, const std::string& label) {
    std::string s = trim(raw);
    if (s.empty()) throw std::runtime_error(label + "不能为空");
    try {
        size_t consumed = 0;
        double v = std::stod(s, &consumed);
        if (consumed != s.size() || !std::isfinite(v)) throw std::runtime_error("");
        return v;
    } catch (...) {
        throw std::runtime_error(label + "填写无效，请输入纯数字");
    }
}

static int parseStrictInt(const std::string& raw, const std::string& label, int lo, int hi) {
    std::string s = trim(raw);
    if (s.empty()) throw std::runtime_error(label + "不能为空");
    try {
        size_t consumed = 0;
        long v = std::stol(s, &consumed);
        if (consumed != s.size() || v < lo || v > hi) throw std::runtime_error("");
        return (int)v;
    } catch (...) {
        throw std::runtime_error(label + "必须是 " + std::to_string(lo) + "-" + std::to_string(hi) + " 的整数");
    }
}

static void writeCliWarning(const std::string& message);
static void writeCliWarning(const std::string& message);

static void enforceCompensationLimitForOutput(const MergeOptions& opts, bool writeWarnings) {
    auto issues = scanCompensationLimitIssues(opts);
    for (const auto& issue : issues) {
        if (writeWarnings) writeCliWarning(issue.severity + ": " + issue.text + "\n");
        if (issue.severity == "ERROR" || issue.severity == "FATAL") {
            throw std::runtime_error(issue.text);
        }
    }
}

static void enforceExperimentalCompensationHardCap(const ExperimentalCompensation& comp) {
    constexpr double kExperimentalCompHardCap = 5.0;
    auto check = [&](char axis, double value) {
        if (std::abs(value) > kExperimentalCompHardCap + 1e-12) {
            std::ostringstream ss;
            ss << "实验性坐标补偿幅值超硬上限: " << comp.wcs << ' ' << axis << formatGcodeVal(value)
               << "，硬上限 |delta| <= " << formatGcodeVal(kExperimentalCompHardCap);
            throw std::runtime_error(ss.str());
        }
    };
    check('X', comp.x); check('Y', comp.y); check('Z', comp.z);
}

static std::string applyAxisDelta(std::string line, char axis, double delta) {
    if (std::abs(delta) < 1e-12) return line;
    bool inComment = false;
    for (size_t i = 0; i < line.size(); ++i) {
        if (line[i] == '(') { inComment = true; continue; }
        if (inComment) {
            if (line[i] == ')') inComment = false;
            continue;
        }
        if ((char)std::toupper((unsigned char)line[i]) != axis) continue;
        if (!isAxisBoundaryBefore(line, i)) continue;
        size_t start = i + 1;
        while (start < line.size() && std::isspace((unsigned char)line[start])) ++start;
        size_t end = start;
        if (end < line.size() && (line[end] == '+' || line[end] == '-')) ++end;
        bool hasDigit = false;
        while (end < line.size() && (std::isdigit((unsigned char)line[end]) || line[end] == '.')) {
            if (std::isdigit((unsigned char)line[end])) hasDigit = true;
            ++end;
        }
        if (!hasDigit) continue;
        std::string tok = line.substr(start, end - start);
        double v = 0.0;
        try {
            size_t consumed = 0;
            v = std::stod(tok, &consumed);
            if (consumed != tok.size()) continue;
        } catch (...) {
            continue;
        }
        line.replace(start, end - start, formatGcodeVal(v + delta));
        return line;
    }
    return line;
}

static void applyExperimentalCompensation(std::string& line, const std::string& wcs, const MergeOptions& opts, bool forceSkipZ = false) {
    if (!opts.experimental_compensation) return;
    bool skipZ = forceSkipZ;
    for (const auto& t : parseGcodeLine(line)) {
        if (t.ch != 'G') continue;
        if (std::abs(t.val - 0.0) < 1e-9 || std::abs(t.val - 43.0) < 1e-9 || (t.val >= 81.0 && t.val <= 89.0)) {
            skipZ = true;
        }
    }
    for (const auto& comp : opts.compensations) {
        if (comp.wcs != wcs) continue;
        line = applyAxisDelta(line, 'X', comp.x);
        line = applyAxisDelta(line, 'Y', comp.y);
        if (!skipZ) line = applyAxisDelta(line, 'Z', comp.z);
        return;
    }
}

static void applyExperimentalCompensation(std::vector<std::string>& lines, const std::string& wcs, const MergeOptions& opts) {
    if (!opts.experimental_compensation) return;
    int motion = -1;
    for (auto& line : lines) {
        for (const auto& t : parseGcodeLine(line)) {
            if (t.ch == 'G' && std::abs(t.val - 0.0) < 1e-9) motion = 0;
            else if (t.ch == 'G' && std::abs(t.val - 1.0) < 1e-9) motion = 1;
        }
        applyExperimentalCompensation(line, wcs, opts, motion == 0);
    }
}

static std::string upperWcs(std::string s) {
    s = upperAscii(trim(s));
    // 修复 #30: 白名单校验，只接受 G54-G59 和 G54.1 P1-P48
    static const std::regex basic("^G5[4-9]$");
    static const std::regex ext("^G54\\.1(\\s*P([1-9]|[1-3][0-9]|4[0-8]))?$");
    if (std::regex_match(s, basic) || std::regex_match(s, ext)) return s;
    throw std::runtime_error("坐标系格式错(仅支持 G54-G59 / G54.1 P1-P48): " + s);
}

static std::vector<WorkOffsetConfig> parseWorkOffsetConfigText(const std::string& raw) {
    std::vector<WorkOffsetConfig> out;
    std::set<std::string> seen;
    std::stringstream ss(raw);
    for (std::string piece; std::getline(ss, piece, ',');) {
        piece = trim(piece);
        if (piece.empty()) continue;
        auto pos = piece.find(':');
        if (pos == std::string::npos) throw std::runtime_error("多坐标配置格式错: " + piece);
        std::string wcs = upperWcs(piece.substr(0, pos));
        // 修复 #31: stoi 必须完整消费，拒绝 "10.5"/"10abc"/"0x10"
        std::string numStr = trim(piece.substr(pos + 1));
        size_t consumed = 0;
        int offset = 0;
        try {
            offset = std::stoi(numStr, &consumed);
        } catch (const std::exception&) {
            throw std::runtime_error("多坐标 offset 非法: " + piece);
        }
        if (consumed != numStr.size()) {
            throw std::runtime_error("多坐标 offset 含非法字符(必须为纯整数): " + piece);
        }
        if (!seen.insert(wcs).second) throw std::runtime_error("多坐标配置重复: " + wcs);
        out.push_back({wcs, offset});
    }
    if (out.empty()) throw std::runtime_error("多坐标配置不能为空");
    return out;
}

static std::string formatWorkOffsetConfigText(const std::vector<WorkOffsetConfig>& cfg) {
    std::ostringstream ss;
    for (size_t i = 0; i < cfg.size(); ++i) {
        if (i) ss << ',';
        ss << cfg[i].wcs << ':' << cfg[i].h_offset;
    }
    return ss.str();
}

static std::vector<ExperimentalCompensation> parseCompensationConfigText(const std::string& raw) {
    std::vector<ExperimentalCompensation> out;
    std::stringstream ss(raw);
    for (std::string piece; std::getline(ss, piece, ';');) {
        piece = trim(piece);
        if (piece.empty()) continue;
        std::stringstream fields(piece);
        std::string wcsPart;
        if (!std::getline(fields, wcsPart, ':')) throw std::runtime_error("实验性补偿格式错: " + piece);
        ExperimentalCompensation comp;
        comp.wcs = upperWcs(wcsPart);
        for (std::string field; std::getline(fields, field, ':');) {
            field = trim(field);
            if (field.size() < 2) continue;
            char axis = (char)std::toupper((unsigned char)field[0]);
            double value = parseStrictDouble(field.substr(1), "坐标补偿数值");
            if (axis == 'X') comp.x = value;
            else if (axis == 'Y') comp.y = value;
            else if (axis == 'Z') comp.z = value;
            else throw std::runtime_error("实验性补偿轴错误: " + field);
        }
        out.push_back(comp);
    }
    return out;
}

static std::string formatCompensationConfigText(const std::vector<ExperimentalCompensation>& cfg) {
    std::ostringstream ss;
    for (size_t i = 0; i < cfg.size(); ++i) {
        if (i) ss << ';';
        ss << cfg[i].wcs << ":X" << cfg[i].x << ":Y" << cfg[i].y << ":Z" << cfg[i].z;
    }
    return ss.str();
}

static std::string applyAxisDelta(std::string line, char axis, double delta) {
    if (std::abs(delta) < 1e-12) return line;
    for (size_t i = 0; i < line.size(); ++i) {
        // 修复 #5: 不补偿括号注释中的伪坐标，例如 (SAFE X0 START)
        if (line[i] == '(') {
            while (i < line.size() && line[i] != ')') ++i;
            continue;
        }
        if ((char)std::toupper((unsigned char)line[i]) != axis) continue;
        size_t start = i + 1;
        while (start < line.size() && std::isspace((unsigned char)line[start])) ++start;
        size_t end = start;
        if (end < line.size() && (line[end] == '+' || line[end] == '-')) ++end;
        bool hasDigit = false;
        while (end < line.size() && (std::isdigit((unsigned char)line[end]) || line[end] == '.')) {
            if (std::isdigit((unsigned char)line[end])) hasDigit = true;
            ++end;
        }
        if (!hasDigit) continue;
        std::string tok = line.substr(start, end - start);
        double v = 0.0;
        try {
            size_t consumed = 0;
            v = std::stod(tok, &consumed);
            if (consumed != tok.size()) continue;
        } catch (...) {
            continue;  // 修复 #7: 畸形坐标 token 保持原样，不中止整批处理
        }
        std::string repl = formatGcodeVal(v + delta);
        line.replace(start, end - start, repl);
        i = start + repl.size();
    }
    return line;
}

static void applyExperimentalCompensation(std::string& line, const std::string& wcs, const MergeOptions& opts) {
    if (!opts.experimental_compensation) return;
    for (const auto& comp : opts.compensations) {
        if (comp.wcs != wcs) continue;
        line = applyAxisDelta(line, 'X', comp.x);
        line = applyAxisDelta(line, 'Y', comp.y);
        line = applyAxisDelta(line, 'Z', comp.z);
        return;
    }
}

static void applyExperimentalCompensation(std::vector<std::string>& lines, const std::string& wcs, const MergeOptions& opts) {
    if (!opts.experimental_compensation) return;
    for (auto& line : lines) applyExperimentalCompensation(line, wcs, opts);
}

static std::string formatG43ForVersion(std::string g43, const MergeOptions& opts) {
    static const std::regex g1FeedTailRe(R"(\s*G1\s*F\d+\s*$)");
    if (opts.version == "HH" && opts.hh_strip_f4000) {
        g43 = std::regex_replace(g43, g1FeedTailRe, "") + " ";
    } else if (opts.version == "H" && opts.h_force_f4000) {
        if (!std::regex_search(g43, g1FeedTailRe)) g43 = trim(g43) + " G1 F4000";
    }
    return g43;
}

static std::string otherWcs(const std::string& wcs);

struct WorkOffsetHMap {
    bool g56Plus10 = false;

    int offsetFor(const std::string& wcs) const {
        if (g56Plus10 && wcs == "G56") return 10;
        return 0;
    }

    int hFor(const Segment& seg, const std::string& effectiveWcs) const {
        return seg.h_num.value_or(0) + offsetFor(effectiveWcs);
    }
};

struct ModalSemanticState {

    std::string wcs = "G54";

    std::string effectiveWcs(const std::string& explicitWcs) const {
        return explicitWcs.empty() ? wcs : explicitWcs;
    }

    void observeWcs(const std::string& explicitWcs) {
        if (!explicitWcs.empty()) wcs = explicitWcs;
    }
};

struct WorkOffsetHMap {
    bool g56Plus10 = false;

    int offsetFor(const std::string& wcs) const {
        if (g56Plus10 && wcs == "G56") return 10;
        return 0;
    }

    int hFor(const Segment& seg, const std::string& effectiveWcs) const {
        return seg.h_num.value_or(0) + offsetFor(effectiveWcs);
    }
};

struct G54G56Pass {
    const Segment* seg = nullptr;
    const Segment* coordSource = nullptr;
    std::string wcs;
    std::string effectiveWcs;
    bool firstRun = false;
    optional<int> hOverride;
    bool repeatComments = false;
    int liftZ = 0;
};


static bool lineHasCannedCycle(const std::string& line) {
    for (const auto& t : parseGcodeLine(line)) if (t.ch == 'G' && t.val >= 81.0 && t.val <= 89.0) return true;
    return false;
}

static bool lineHasArcMotion(const std::string& line) {
    for (const auto& t : parseGcodeLine(line)) if (t.ch == 'G' && (std::abs(t.val - 2.0) < 1e-9 || std::abs(t.val - 3.0) < 1e-9)) return true;
    return false;
}

static bool isSideCompStopLine(const std::string& trimmed) {
    return startsWith(trimmed, "M05") || startsWith(trimmed, "M09") || startsWith(trimmed, "G28") || startsWith(trimmed, "M30");
}

static bool shouldCloseSideCompBeforeLine(const std::string& strategy, const std::string& line, int motion, bool banned, bool hasXy, bool hasZ) {
    std::string trimmed = trim(line);
    // 提前计算所有条件，避免 FAST 分支无法访问 arc/banned
    bool stopLine = isSideCompStopLine(trimmed);
    bool g0 = motion == 0;
    bool canned = lineHasCannedCycle(line);
    bool pureZ = hasZ && !hasXy;
    bool arc = lineHasArcMotion(line);

    // EXTREME 仍保留跨 G0/纯Z 的高速语义，但圆弧/固定循环/G28/M30 等禁用动作前必须关 G40
    if (strategy == G41_RISK_EXTREME) return stopLine || canned || arc || banned;
    // FAST: stopLine + 圆弧 + 固定循环 前必须关 G40
    if (strategy == G41_RISK_FAST) return stopLine || arc || canned;
    // BALANCED（默认档）: 加上 G0
    if (strategy == G41_RISK_BALANCED) return stopLine || g0 || canned || arc;
    // SAFE: 再加 pureZ
    if (strategy == G41_RISK_SAFE) return stopLine || g0 || canned || pureZ || arc;
    // SAFEST（最保守档）: 加上 banned（包含 G2/G3/G28/M30 等）
    return stopLine || g0 || canned || pureZ || banned || arc;
}

static bool lineHasXy(const std::string& line) {
    for (const auto& t : parseGcodeLine(line)) if (t.ch == 'X' || t.ch == 'Y') return true;
    return false;
}

static bool lineHasXy(const std::string& line) {
    for (const auto& t : parseGcodeLine(line)) if (t.ch == 'X' || t.ch == 'Y') return true;
    return false;
}

static bool lineHasZ(const std::string& line) {
    for (const auto& t : parseGcodeLine(line)) if (t.ch == 'Z') return true;
    return false;
}

static bool updateMotionStateForSideComp(const std::string& line, int& motion) {
    bool banned = false;
    for (const auto& t : parseGcodeLine(line)) {
        if (t.ch != 'G') continue;
        if (std::abs(t.val - 0.0) < 1e-9) motion = 0;
        else if (std::abs(t.val - 1.0) < 1e-9) motion = 1;
        else if (std::abs(t.val - 2.0) < 1e-9) { motion = 2; banned = true; }
        else if (std::abs(t.val - 3.0) < 1e-9) { motion = 3; banned = true; }
        else if (std::abs(t.val - 28.0) < 1e-9) banned = true;
        else if (std::abs(t.val - 80.0) < 1e-9) { inCannedCycle = false; banned = true; }
        else if (t.val >= 81.0 && t.val <= 89.0) { inCannedCycle = true; banned = true; motion = -1; }
    }
    return banned || inCannedCycle;
}

static std::string insertG41D(std::string line, int dNum) {
    // 修复 #17: H00/D00 无效，拒绝输出
    if (dNum <= 0) return line;
    std::ostringstream d;
    d << "G41 D" << std::setw(2) << std::setfill('0') << dNum;
    static const std::regex g1Re(R"(\bG0*1\b)", std::regex::icase);
    if (std::regex_search(line, g1Re)) return std::regex_replace(line, g1Re, "G1 " + d.str(), std::regex_constants::format_first_only);
    return d.str() + " " + trim(line);
}

static std::string removeG40Token(std::string line) {
    static const std::regex g40Re(R"(\s*\bG0*40\b\s*)", std::regex::icase);
    line = std::regex_replace(line, g40Re, " ");
    return trim(line);
}

struct SideCompLineState {
    bool hasG40 = false;
    bool hasG41 = false;
    bool finalActive = false;
};

static SideCompLineState sideCompStateAfterLine(const std::string& line, bool previousActive) {
    SideCompLineState st;
    st.finalActive = previousActive;
    for (const auto& t : parseGcodeLine(line)) {
        if (t.ch != 'G') continue;
        if (std::abs(t.val - 40.0) < 1e-9) { st.hasG40 = true; st.finalActive = false; }
        else if (std::abs(t.val - 41.0) < 1e-9) { st.hasG41 = true; st.finalActive = true; }
    }
    return st;
}

static std::vector<std::string> applySideCompensationToProgram(std::vector<std::string> lines, bool enabled, const std::string& strategy = G41_RISK_BALANCED) {
    if (!enabled) return lines;
    optional<int> currentH;
    bool active = false;
    int motion = -1;
    bool inCannedCycle = false;
    bool inCuttingSegment = false;
    std::vector<std::string> out;
    out.reserve(lines.size() + 8);
    for (auto line : lines) {
        auto tokens = parseGcodeLine(line);
        for (const auto& t : tokens) if (t.ch == 'H') currentH = (int)std::llround(t.val);
        bool wasActive = active;
        SideCompLineState compState = sideCompStateAfterLine(line, active);
        bool hasExistingG40 = compState.hasG40;
        bool hasExistingG41 = compState.hasG41;
        bool keepNewline = !line.empty() && line.back() == '\n';
        bool banned = updateMotionStateForSideComp(line, motion, inCannedCycle);
        bool hasXy = lineHasXy(line);
        bool hasZ = lineHasZ(line);
        if (hasExistingG40 || hasExistingG41) {
            if (wasActive && hasExistingG40 && shouldCloseSideCompBeforeLine(strategy, line, motion, banned, hasXy, hasZ)) {
                out.push_back("G40\n");
                std::string withoutG40 = removeG40Token(line);
                if (!withoutG40.empty()) out.push_back(withoutG40 + (keepNewline ? "\n" : ""));
            } else {
                if (hasExistingG41 && currentH) line = ensureG41DNumber(line, *currentH);
                out.push_back(line);
            }
            active = compState.finalActive;
            continue;
        }
        bool shouldClose = active && shouldCloseSideCompBeforeLine(strategy, line, motion, banned, hasXy, hasZ);
        if (shouldClose) { out.push_back("G40\n"); active = false; }
        // 修复 #13(G28重插)、#12(固定循环重插): 增加 !banned 条件，防止在 G2/G3/G28/M30/固定循环上建立 G41
        if (!active && !banned && currentH && !lineHasCannedCycle(line) && motion == 1 && hasXy) {
            while (!line.empty() && (line.back() == '\n' || line.back() == '\r')) line.pop_back();
            line = insertG41D(line, *currentH);
            if (keepNewline) line += "\n";
            active = true;
        }
        }
        out.push_back(line);
    }
    if (inCuttingSegment) out.push_back("G40");
    return out;
}

static std::vector<std::string> applySideCompensationAdaptive(std::vector<std::string> body, int dNum, const std::string& strategy = G41_RISK_SAFEST) {
    std::vector<std::string> out;
    out.reserve(body.size() + 10);
    int motion = -1;
    bool inCannedCycle = false;
    bool inCuttingSegment = false;

    for (size_t i = 0; i < body.size(); ++i) {
        std::string line = body[i];
        bool wasInCuttingSegment = inCuttingSegment;
        SideCompLineState compState = sideCompStateAfterLine(line, inCuttingSegment);
        bool hasExistingG40 = compState.hasG40;
        bool hasExistingG41 = compState.hasG41;
        bool banned = updateMotionStateForSideComp(line, motion, inCannedCycle);
        bool hasXy = lineHasXy(line);
        bool hasZ = lineHasZ(line);
        // 修复 #22(多坐标圆弧重插): 增加 !banned && !lineHasArcMotion 条件
        bool isG1XyCut = (motion == 1 && hasXy && !lineHasCannedCycle(line) && !banned && !lineHasArcMotion(line));

        // 输入里已有 G40/G41 时，尊重原始刀补指令并同步内部状态，避免重复插入或状态失步。
        if (hasExistingG40 || hasExistingG41) {
            if (wasInCuttingSegment && hasExistingG40 && !hasExistingG41 && shouldCloseSideCompBeforeLine(strategy, line, motion, banned, hasXy, hasZ)) {
                std::string withoutG40 = removeG40Token(line);
                out.push_back("G40");
                if (!withoutG40.empty()) out.push_back(withoutG40);
                inCuttingSegment = false;
            } else {
                if (hasExistingG41) line = ensureG41DNumber(line, dNum);
                out.push_back(line);
                inCuttingSegment = compState.finalActive;
            }
            continue;
        }

        bool shouldClose = inCuttingSegment && shouldCloseSideCompBeforeLine(strategy, line, motion, banned, hasXy, hasZ);
        if (shouldClose) { out.push_back("G40"); inCuttingSegment = false; }

        if (!inCuttingSegment && isG1XyCut) {
            out.push_back(insertG41D(line, dNum));
            inCuttingSegment = true;
        } else {
            out.push_back(line);
        }
    }

    if (inCuttingSegment) out.push_back("G40");
    return out;
}

static std::vector<std::string> applySideCompensationToProgram(std::vector<std::string> lines, bool enabled, const std::string& strategy = G41_CLOSE_ADAPTIVE) {
    if (!enabled) return lines;
    optional<int> currentH;
    bool active = false;
    int motion = -1;
    bool inCannedCycle = false;
    std::vector<std::string> out;
    out.reserve(lines.size() + 8);
    for (auto line : lines) {
        auto tokens = parseGcodeLine(line);
        bool hasExistingG40 = false;
        bool hasExistingG41 = false;
        for (const auto& t : tokens) {
            if (t.ch == 'H') currentH = (int)std::llround(t.val);
            if (t.ch == 'G' && std::abs(t.val - 40.0) < 1e-9) {
                active = false;
                hasExistingG40 = true;
            }
            if (t.ch == 'G' && std::abs(t.val - 41.0) < 1e-9) {
                active = true;
                hasExistingG41 = true;
            }
        }
        std::string trimmed = trim(line);
        bool keepNewline = !line.empty() && line.back() == '\n';
        bool banned = updateMotionStateForSideComp(line, motion, inCannedCycle);
        bool hasXy = lineHasXy(line);
        bool hasZ = lineHasZ(line);
        // 修复 #22(多坐标圆弧重插): 增加 !banned && !lineHasArcMotion 条件
        bool isG1XyCut = (motion == 1 && hasXy && !lineHasCannedCycle(line) && !banned && !lineHasArcMotion(line));
            if (active && hasExistingG40 && unsafeLineForOpenSideComp(motion, banned, hasXy, hasZ)) {
                out.push_back("G40\n");
                std::string withoutG40 = removeG40Token(line);
                if (!withoutG40.empty()) out.push_back(withoutG40 + (keepNewline ? "\n" : ""));
            } else {
                out.push_back(line);
            }
            active = hasExistingG41 && !hasExistingG40;
            continue;
        }
        bool isStopLine = startsWith(trimmed, "M05") || startsWith(trimmed, "M09") || startsWith(trimmed, "G28") || startsWith(trimmed, "M30");
        bool shouldClose = active && (isStopLine || (strategy == G41_CLOSE_ADAPTIVE && (motion == 0 || banned || (hasZ && !hasXy))));
        if (shouldClose) {
            out.push_back("G40\n");
            active = false;
        }
        if (!active && currentH && !banned && motion == 1 && hasXy) {
            while (!line.empty() && (line.back() == '\n' || line.back() == '\r')) line.pop_back();
            line = insertG41D(line, *currentH);
            if (keepNewline) line += "\n";
            active = true;
        }
        out.push_back(line);
    }
    if (active) out.push_back("G40\n");
    return out;
}

static std::vector<std::string> applySideCompensationToBody(std::vector<std::string> body, const MergeOptions& opts, int dNum) {
    if (!opts.side_compensation_g41) return body;
    if (dNum <= 0) return body;
    return applySideCompensationAdaptive(std::move(body), dNum, opts.g41_close_strategy);
}

static bool lineHasXy(const std::string& line) {
    for (const auto& t : parseGcodeLine(line)) if (t.ch == 'X' || t.ch == 'Y') return true;
    return false;
}

static bool isSideCompBoundaryLine(const std::string& line) {
    auto tokens = parseGcodeLine(line);
    for (const auto& t : tokens) {
        if (t.ch == 'G') {
            if (std::abs(t.val - 0.0) < 1e-9) return true;
            if (std::abs(t.val - 80.0) < 1e-9 || (t.val >= 81.0 && t.val <= 89.0)) return true;
        }
        if (t.ch == 'M' && (std::abs(t.val - 5.0) < 1e-9 || std::abs(t.val - 9.0) < 1e-9)) return true;
    }
    return false;
}

static bool updateMotionStateForSideComp(const std::string& line, int& motion, bool& inCannedCycle) {
    bool banned = false;
    for (const auto& t : parseGcodeLine(line)) {
        if (t.ch != 'G') continue;
        if (std::abs(t.val - 0.0) < 1e-9) motion = 0;
        else if (std::abs(t.val - 1.0) < 1e-9) motion = 1;
        else if (std::abs(t.val - 2.0) < 1e-9) { motion = 2; banned = true; }
        else if (std::abs(t.val - 3.0) < 1e-9) { motion = 3; banned = true; }
        else if (std::abs(t.val - 28.0) < 1e-9) banned = true;
        else if (std::abs(t.val - 80.0) < 1e-9) { inCannedCycle = false; banned = true; }
        else if (t.val >= 81.0 && t.val <= 89.0) { inCannedCycle = true; banned = true; motion = -1; }
    }
    return banned || inCannedCycle;
}

static std::string insertG41D(std::string line, int dNum) {
    // 修复 #17: H00/D00 无效，拒绝输出
    if (dNum <= 0) return line;
    std::ostringstream d;
    d << "G41 D" << std::setw(2) << std::setfill('0') << dNum;
    static const std::regex g1Re(R"(\bG0*1\b)", std::regex::icase);
    if (std::regex_search(line, g1Re)) return std::regex_replace(line, g1Re, "G1 " + d.str(), std::regex_constants::format_first_only);
    return d.str() + " " + trim(line);
}

static std::string removeG40Token(std::string line) {
    bool keepNewline = !line.empty() && (line.back() == '\n' || line.back() == '\r');
    static const std::regex g40Re(R"((^|\s)G0*40\b)", std::regex::icase);
    line = std::regex_replace(line, g40Re, " ");
    line = std::regex_replace(line, std::regex(R"(\s+)") , " ");
    std::string s = trim(line);
    if (keepNewline && !s.empty()) s += "\n";
    return s;
}

static std::string removeG40Token(std::string line) {
    static const std::regex g40Re(R"((^|\s)G0*40\b)", std::regex::icase);
    line = std::regex_replace(line, g40Re, " ");
    line = std::regex_replace(line, std::regex(R"(\s+)") , " ");
    std::string s = trim(line);
    bool keepNewline = !line.empty() && (line.back() == '\n' || line.back() == '\r');
    if (keepNewline && !s.empty()) s += "\n";
    return s;
}

static bool isSideCompBoundaryLine(const std::string& line) {
    auto tokens = parseGcodeLine(line);
    bool hasG0 = false, hasXy = false;
    for (const auto& t : tokens) {
        if (t.ch == 'X' || t.ch == 'Y') hasXy = true;
        if (t.ch != 'G') continue;
        if (std::abs(t.val - 0.0) < 1e-9) hasG0 = true;
        if (t.val >= 80.0 && t.val <= 89.0) return true;
    }
    return hasG0 && hasXy;
}

static std::vector<std::string> applySideCompensationToBody(std::vector<std::string> body, const MergeOptions& opts, int dNum) {
    if (!opts.side_compensation_g41) return body;
    bool active = false;
    int motion = -1;
    std::vector<std::string> out;
    out.reserve(body.size() + 4);
    for (auto line : body) {
        if (active && isSideCompBoundaryLine(line)) {
            out.push_back("G40");
            active = false;
        }
        bool banned = updateMotionStateForSideComp(line, motion);
        if (!active && !banned && motion == 1 && lineHasXy(line)) {
            line = insertG41D(line, dNum);
            active = true;
        }
        out.push_back(line);
    }
    if (active) out.push_back("G40");
    return out;
}

static std::string g0PrefixForPass(const G54G56Pass& pass) {
    std::ostringstream ss;
    ss << "G0";
    if (!pass.wcs.empty()) ss << ' ' << pass.wcs;
    if (pass.firstRun) ss << " G90";
    ss << ' ';
    return ss.str();
}
static std::string g0PrefixForPass(const G54G56Pass& pass) {
    std::ostringstream ss;
    ss << "G0";
    if (!pass.wcs.empty()) ss << ' ' << pass.wcs;
    if (pass.firstRun) ss << " G90";
    ss << ' ';
    return ss.str();
}

static void appendRun(std::vector<std::string>& out, const G54G56Pass& pass, const MergeOptions& opts) {
    const Segment& seg = *pass.seg;
    const Segment& coordSource = pass.coordSource ? *pass.coordSource : seg;
    if (pass.repeatComments) {
        out.push_back(seg.tool_comment.value_or(""));
        out.push_back(seg.dia_comment.value_or(""));
        out.push_back(seg.date_comment.value_or(""));
    }
    std::string g0 = adjustG0ForG54G56(g0PrefixForPass(pass) + g0PayloadForWcs(coordSource, pass.wcs), seg, opts);
    applyExperimentalCompensation(g0, pass.wcs, opts);
    out.push_back(g0);

    applyExperimentalCompensation(g0, pass.wcs, opts);
    out.push_back(g0);
    std::string g43 = seg.g43_line.value_or("");
    if (pass.hOverride) g43 = replaceHNumber(g43, *pass.hOverride);
    out.push_back(formatG43ForVersion(g43, opts));
    auto body = cuttingBodyForG54G56(seg, pass.liftZ);
    auto body = cuttingBodyForG54G56(seg, pass.liftZ);
    applyExperimentalCompensation(body, pass.wcs, opts);
    body = applySideCompensationToBody(std::move(body), opts, pass.hOverride.value_or(seg.h_num.value_or(0)));
    out.insert(out.end(), body.begin(), body.end());
}

static void updateModalWcs(MachineModalState& state, const G54G56Pass& pass) {
    state.observeExplicitWcs(pass.wcs);
}

static bool shouldUseFinalSafeLift(const Segment& seg, const MergeOptions& opts) {
    static const std::regex edToolRe(R"(ED\d+)");
    return opts.g54g56_lift_z > 0 &&
           std::regex_search(upperAscii(extractToolName(seg.tool_comment.value_or(""))), edToolRe);
}

static std::vector<G54G56Pass> buildG54G56Passes(const Segment& base, const optional<Segment>& paired,
                                                size_t idx, const MergeOptions& opts,
                                                const MachineModalState&, bool isLastGroup = false) {
    (void)idx;
    std::vector<G54G56Pass> passes;
    const int switchLiftZ = opts.g54g56_lift_z;
    const Segment* coordSource = &base;
    if (paired) coordSource = shouldUsePairedCoordinates(base, *paired) ? &*paired : &base;
    for (size_t i = 0; i < opts.work_offsets.size(); ++i) {
        const auto& cfg = opts.work_offsets[i];
        // 修复 #4、#28、#29: 校验最终 H/D 号合法性（下界 1，上界 200）
        int finalH = base.h_num.value_or(0) + cfg.h_offset;
        if (finalH < 1 || finalH > 200) {
            throw std::runtime_error(
                "多坐标最终 H/D 号越界(必须 1-200): 基础 H" +
                std::to_string(base.h_num.value_or(0)) +
                " + " + cfg.wcs + " offset " + std::to_string(cfg.h_offset) +
                " = " + std::to_string(finalH)
            );
        }
        int liftZ = 0;
        if (i + 1 < opts.work_offsets.size()) liftZ = switchLiftZ;
        else if (isLastGroup && shouldUseFinalSafeLift(base, opts)) liftZ = switchLiftZ;
        passes.push_back(G54G56Pass{&base, coordSource, cfg.wcs, cfg.wcs, i == 0,
                                    finalH, i > 0, liftZ});
    }
    return passes;
}

static int resolveTNumber(const Segment& seg, const MergeOptions& opts) {
    std::string tool = extractToolName(seg.tool_comment.value_or(""));
    auto it = opts.tool_t_map.find(tool);
    if (it != opts.tool_t_map.end()) return it->second;
    return seg.h_num.value_or(0);
}

static optional<int> preselectTool(const std::vector<int>& tNums, size_t currentIdx, const std::string& mode) {
    if (tNums.size() <= 1 || mode == PRESELECT_OFF || currentIdx >= tNums.size()) return std::nullopt;
    if (!(mode == PRESELECT_LEGACY || mode == PRESELECT_NEXT || mode == PRESELECT_RING)) return std::nullopt;
    int current = tNums[currentIdx];
    int next = tNums[(currentIdx + 1) % tNums.size()];
    return next == current ? std::nullopt : optional<int>(next);
}

static std::vector<Segment> sortHAsc(std::vector<Segment> segs) {
    std::stable_sort(segs.begin(), segs.end(), [](const Segment& a, const Segment& b) {
        return a.h_num.value_or(9999) < b.h_num.value_or(9999);
    });
    return segs;
}

static std::vector<Segment> sortZGlobal(std::vector<Segment> segs) {
    std::stable_sort(segs.begin(), segs.end(), [](const Segment& a, const Segment& b) {
        double za = a.first_cut_z.value_or(-9999.0);
        double zb = b.first_cut_z.value_or(-9999.0);
        if (za != zb) return -za < -zb;
        return a.h_num.value_or(9999) < b.h_num.value_or(9999);
    });
    return segs;
}

static bool sameXY(const Segment& a, const Segment& b) {
    return a.g0_xy.first == b.g0_xy.first && a.g0_xy.second == b.g0_xy.second &&
           (a.g0_xy.first || a.g0_xy.second);
}

static std::vector<Segment> sortZCluster(const std::vector<Segment>& segs) {
    std::vector<Segment> out;
    std::vector<bool> used(segs.size(), false);
    for (size_t i = 0; i < segs.size(); ++i) {
        if (used[i]) continue;
        std::vector<Segment> cluster{segs[i]};
        used[i] = true;
        for (size_t j = i + 1; j < segs.size(); ++j) {
            if (!used[j] && sameXY(segs[i], segs[j])) {
                cluster.push_back(segs[j]);
                used[j] = true;
            }
        }
        std::stable_sort(cluster.begin(), cluster.end(), [](const Segment& a, const Segment& b) {
            return -a.first_cut_z.value_or(-9999.0) < -b.first_cut_z.value_or(-9999.0);
        });
        out.insert(out.end(), cluster.begin(), cluster.end());
    }
    return out;
}

static optional<std::chrono::system_clock::time_point> parseDate(const optional<std::string>& comment) {
    if (!comment) return std::nullopt;
    static const std::regex re(R"(Date:\s*\w+\s+(\w+)\s+(\d+)\s+(\d+):(\d+):(\d+)\s+(\d+))");
    static const std::vector<std::string> months = {"Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"};
    std::smatch m;
    if (!std::regex_search(*comment, m, re)) return std::nullopt;
    auto it = std::find(months.begin(), months.end(), m[1].str());
    if (it == months.end()) return std::nullopt;
    std::tm tm{};
    try {
        tm.tm_year = std::stoi(m[6].str()) - 1900;
        tm.tm_mon = (int)(it - months.begin());
        tm.tm_mday = std::stoi(m[2].str());
        tm.tm_hour = std::stoi(m[3].str());
        tm.tm_min = std::stoi(m[4].str());
        tm.tm_sec = std::stoi(m[5].str());
    } catch (...) {
        return std::nullopt;
    }
    std::time_t tt = std::mktime(&tm);
    if (tt == -1) return std::nullopt;
    return std::chrono::system_clock::from_time_t(tt);
}

static std::vector<Segment> sortSmartAuto(const std::vector<Segment>& segs) {
    if (segs.empty()) return {};
    std::map<int, std::vector<Segment>> byH;
    std::vector<Segment> noneH;
    for (const auto& s : segs) {
        if (s.h_num) byH[*s.h_num].push_back(s);
        else noneH.push_back(s);
    }
    std::vector<Segment> deduped = noneH;
    for (auto& [_, group] : byH) {
        auto best = std::max_element(group.begin(), group.end(), [](const Segment& a, const Segment& b) {
            return parseDate(a.date_comment).value_or(std::chrono::system_clock::time_point::min()) <
                   parseDate(b.date_comment).value_or(std::chrono::system_clock::time_point::min());
        });
        deduped.push_back(*best);
    }
    std::vector<std::pair<Segment, std::chrono::system_clock::time_point>> dated;
    std::vector<Segment> undated;
    for (auto& s : deduped) {
        auto d = parseDate(s.date_comment);
        if (d) dated.push_back({s, *d});
        else undated.push_back(s);
    }
    if (dated.empty()) return sortHAsc(deduped);
    std::sort(dated.begin(), dated.end(), [](auto& a, auto& b) { return a.second < b.second; });
    std::vector<std::vector<std::pair<Segment, std::chrono::system_clock::time_point>>> clusters{{dated[0]}};
    for (size_t i = 1; i < dated.size(); ++i) {
        auto gap = std::chrono::duration_cast<std::chrono::hours>(dated[i].second - clusters.back().back().second);
        if (gap <= std::chrono::hours(24)) clusters.back().push_back(dated[i]);
        else clusters.push_back({dated[i]});
    }
    auto mainIt = std::max_element(clusters.begin(), clusters.end(), [](auto& a, auto& b) {
        auto amax = std::max_element(a.begin(), a.end(), [](auto& x, auto& y) { return x.second < y.second; })->second;
        auto bmax = std::max_element(b.begin(), b.end(), [](auto& x, auto& y) { return x.second < y.second; })->second;
        return std::make_pair(a.size(), amax) < std::make_pair(b.size(), bmax);
    });
    std::vector<Segment> mainSegs;
    for (auto& p : *mainIt) mainSegs.push_back(p.first);
    if (clusters.size() == 1) mainSegs.insert(mainSegs.end(), undated.begin(), undated.end());
    return sortHAsc(mainSegs);
}

static void splitMainAndTrySegments(const std::vector<Segment>& segs, const MergeOptions& opts,
                                    std::vector<Segment>& mainSegs, std::vector<Segment>& trySegs) {
    if (opts.append_try_knife_at_end) {
        for (const auto& s : segs) (isTryKnifeName(s.src_fn) ? trySegs : mainSegs).push_back(s);
    } else {
        mainSegs = segs;
    }
}

static void sortMergeSegments(std::vector<Segment>& mainSegs, std::vector<Segment>& trySegs, const MergeOptions& opts) {
    if (opts.sort_strategy == SORT_FILE) {}
    else if (opts.sort_strategy == SORT_Z_GLOBAL) mainSegs = sortZGlobal(mainSegs);
    else if (opts.sort_strategy == SORT_Z_CLUSTER) mainSegs = sortZCluster(mainSegs);
    else if (opts.sort_strategy == SORT_SMART_AUTO) mainSegs = sortSmartAuto(mainSegs);
    else mainSegs = sortHAsc(mainSegs);
    trySegs = sortHAsc(trySegs);
    mainSegs.insert(mainSegs.end(), trySegs.begin(), trySegs.end());
}

static std::string joinOutputLines(const std::vector<std::string>& out) {
    std::ostringstream ss;
    for (const auto& line : out) ss << line << "\n";
    return ss.str();
}
static bool cliOptionTakesValue(const std::wstring& arg) {
    return arg == L"--g54g56-lift-z" || arg == L"--g54g56-second-wcs" ||
           arg == L"--multi-wcs" || arg == L"--experimental-compensation-config" || arg == L"--compensation-limit" ||
           arg == L"--config-template";
}
           arg == L"--g41-risk";
}

static bool isCliOption(const std::wstring& arg) {
    return startsWith(narrowUtf8(arg), "--");
}

static bool cliOptionTakesValue(const std::wstring& arg) {
    return arg == L"--g54g56-lift-z" || arg == L"--g54g56-second-wcs" ||
           arg == L"--multi-wcs" || arg == L"--experimental-compensation-config";
}

static bool isCliOption(const std::wstring& arg) {
    return startsWith(narrowUtf8(arg), "--");
}

static std::string describeSegmentDecision(const Segment& seg) {
    std::ostringstream ss;
    ss << seg.src_fn;
    if (seg.h_num) ss << " H=" << *seg.h_num;
    if (seg.wcs) ss << " WCS=" << *seg.wcs;
    if (seg.g0_xy_etc) ss << " G0=" << *seg.g0_xy_etc;
    if (seg.first_cut_z) ss << " Z=" << formatGcodeVal(*seg.first_cut_z);
    if (seg.tool_comment) ss << " TOOL=" << extractToolName(*seg.tool_comment);
    return ss.str();
}

static std::string describeMergeDecisionTrace(std::vector<Segment> segs, const MergeOptions& opts) {
    std::ostringstream ss;
    ss << "mode: " << (opts.g54g56_mode ? "MULTI_WCS" : "standard") << "\n";
    ss << "sort: " << opts.sort_strategy << "\n";
    ss << "preselect: " << opts.preselect_mode << "\n";
    ss << "work_offsets: " << formatWorkOffsetConfigText(opts.work_offsets) << "\n";
    ss << "lift_z: " << opts.g54g56_lift_z << "\n";
    ss << "experimental_compensation: " << (opts.experimental_compensation ? "on" : "off") << "\n";
    ss << "side_compensation_g41: " << (opts.side_compensation_g41 ? "on" : "off") << "\n";
    if (!opts.compensations.empty()) ss << "experimental_compensation_config: " << formatCompensationConfigText(opts.compensations) << "\n";
    ss << "\n";

    segs.erase(std::remove_if(segs.begin(), segs.end(), isFlyingKnifeSeg), segs.end());
    ss << "after_flying_knife_filter: " << segs.size() << " segment(s)\n";
    std::vector<Segment> mainSegs, trySegs;
    splitMainAndTrySegments(segs, opts, mainSegs, trySegs);
    sortMergeSegments(mainSegs, trySegs, opts);
    ss << "main=" << mainSegs.size() << " try=" << trySegs.size() << "\n";
    for (size_t i = 0; i < mainSegs.size(); ++i) {
        ss << "  [" << i << "] " << describeSegmentDecision(mainSegs[i]) << "\n";
    }
    if (!trySegs.empty()) {
        ss << "try-knife order:\n";
        for (size_t i = 0; i < trySegs.size(); ++i) {
            ss << "  [" << i << "] " << describeSegmentDecision(trySegs[i]) << "\n";
        }
    }
    if (!opts.g54g56_mode) {
        std::vector<int> tNums;
        for (const auto& s : mainSegs) tNums.push_back(resolveTNumber(s, opts));
        ss << "\nstandard_merge:\n";
        for (size_t i = 0; i < mainSegs.size(); ++i) {
            ss << "  group " << i << ": T" << tNums[i];
            if (auto next = preselectTool(tNums, i, opts.preselect_mode)) ss << " preselect=T" << *next;
            ss << "\n";
        }
        return ss.str();
    }

    for (size_t idx = 0; idx < mainSegs.size(); ++idx) {
        const auto& seg = mainSegs[idx];
        const int baseH = seg.h_num.value_or(0);
        ss << "\ngroup " << idx << ": " << describeSegmentDecision(seg) << "\n";
        for (size_t passIdx = 0; passIdx < opts.work_offsets.size(); ++passIdx) {
            const auto& cfg = opts.work_offsets[passIdx];
            int h = baseH + cfg.h_offset;
            int liftZ = (passIdx + 1 < opts.work_offsets.size()) ? opts.g54g56_lift_z : 0;
            ss << "  pass " << passIdx << ": wcs=" << cfg.wcs << " h=" << h;
            if (liftZ > 0) ss << " lift_z=" << liftZ;
            ss << " reason=configured_work_offset\n";
        }
        if (auto next = preselectTool([&] {
                std::vector<int> tNums;
                for (const auto& s : mainSegs) tNums.push_back(resolveTNumber(s, opts));
                return tNums;
            }(), idx, opts.preselect_mode)) {
            ss << "  preselect=T" << *next << "\n";
        }
    }
    return ss.str();
}

static std::string describeSegmentDecision(const Segment& seg) {
    std::ostringstream ss;
    ss << seg.src_fn;
    if (seg.h_num) ss << " H=" << *seg.h_num;
    if (seg.wcs) ss << " WCS=" << *seg.wcs;
    if (seg.g0_xy_etc) ss << " G0=" << *seg.g0_xy_etc;
    if (seg.first_cut_z) ss << " Z=" << formatGcodeVal(*seg.first_cut_z);
    if (seg.tool_comment) ss << " TOOL=" << extractToolName(*seg.tool_comment);
    return ss.str();
}

static std::string describeMergeDecisionTrace(std::vector<Segment> segs, const MergeOptions& opts) {
    std::ostringstream ss;
    ss << "mode: " << (opts.g54g56_mode ? "MULTI_WCS" : "standard") << "\n";
    ss << "sort: " << opts.sort_strategy << "\n";
    ss << "preselect: " << opts.preselect_mode << "\n";
    ss << "work_offsets: " << formatWorkOffsetConfigText(opts.work_offsets) << "\n";
    ss << "lift_z: " << opts.g54g56_lift_z << "\n";
    ss << "experimental_compensation: " << (opts.experimental_compensation ? "on" : "off") << "\n";
    ss << "side_compensation_g41: " << (opts.side_compensation_g41 ? "on" : "off") << "\n";
    if (!opts.compensations.empty()) ss << "experimental_compensation_config: " << formatCompensationConfigText(opts.compensations) << "\n";
    ss << "\n";

    segs.erase(std::remove_if(segs.begin(), segs.end(), isFlyingKnifeSeg), segs.end());
    ss << "after_flying_knife_filter: " << segs.size() << " segment(s)\n";
    std::vector<Segment> mainSegs, trySegs;
    splitMainAndTrySegments(segs, opts, mainSegs, trySegs);
    sortMergeSegments(mainSegs, trySegs, opts);
    ss << "main=" << mainSegs.size() << " try=" << trySegs.size() << "\n";
    for (size_t i = 0; i < mainSegs.size(); ++i) {
        ss << "  [" << i << "] " << describeSegmentDecision(mainSegs[i]) << "\n";
    }
    if (!trySegs.empty()) {
        ss << "try-knife order:\n";
        for (size_t i = 0; i < trySegs.size(); ++i) {
            ss << "  [" << i << "] " << describeSegmentDecision(trySegs[i]) << "\n";
        }
    }
    if (!opts.g54g56_mode) {
        std::vector<int> tNums;
        for (const auto& s : mainSegs) tNums.push_back(resolveTNumber(s, opts));
        ss << "\nstandard_merge:\n";
        for (size_t i = 0; i < mainSegs.size(); ++i) {
            ss << "  group " << i << ": T" << tNums[i];
            if (auto next = preselectTool(tNums, i, opts.preselect_mode)) ss << " preselect=T" << *next;
            ss << "\n";
        }
        return ss.str();
    }

    for (size_t idx = 0; idx < mainSegs.size(); ++idx) {
        const auto& seg = mainSegs[idx];
        const int baseH = seg.h_num.value_or(0);
        ss << "\ngroup " << idx << ": " << describeSegmentDecision(seg) << "\n";
        for (size_t passIdx = 0; passIdx < opts.work_offsets.size(); ++passIdx) {
            const auto& cfg = opts.work_offsets[passIdx];
            int h = baseH + cfg.h_offset;
            int liftZ = (passIdx + 1 < opts.work_offsets.size()) ? opts.g54g56_lift_z : 0;
            ss << "  pass " << passIdx << ": wcs=" << cfg.wcs << " h=" << h;
            if (liftZ > 0) ss << " lift_z=" << liftZ;
            ss << " reason=configured_work_offset\n";
        }
        if (auto next = preselectTool([&] {
                std::vector<int> tNums;
                for (const auto& s : mainSegs) tNums.push_back(resolveTNumber(s, opts));
                return tNums;
            }(), idx, opts.preselect_mode)) {
            ss << "  preselect=T" << *next << "\n";
        }
    }
    return ss.str();
    }
    return ss.str();
}

static std::string mergeG54G56Strategy(std::vector<Segment> segs, const MergeOptions& opts) {
    if (segs.empty()) throw std::runtime_error("no segment to merge");
    segs.erase(std::remove_if(segs.begin(), segs.end(), isFlyingKnifeSeg), segs.end());
    if (segs.empty()) throw std::runtime_error("no segment to merge after filtering");

    std::vector<Segment> mainSegs, trySegs;
    splitMainAndTrySegments(segs, opts, mainSegs, trySegs);
    if (mainSegs.empty()) throw std::runtime_error("no main segment to merge");
    sortMergeSegments(mainSegs, trySegs, opts);

    for (const auto& s : mainSegs) {
        if (!s.h_num) throw std::runtime_error(s.src_fn + ": missing G43 H");
        if (!s.g0_xy_etc) throw std::runtime_error(s.src_fn + ": missing first G0");
    }

    struct Group { Segment primary; optional<Segment> paired; };
    std::vector<Group> groups;
    for (const auto& seg : mainSegs) groups.push_back({seg, std::nullopt});

    std::vector<int> tNums;
    for (auto& g : groups) tNums.push_back(resolveTNumber(g.primary, opts));

        std::vector<std::string> out;
        out.push_back("%");
        out.push_back(groups[0].primary.tool_comment.value_or(""));
        out.push_back(groups[0].primary.dia_comment.value_or(""));
        out.push_back(groups[0].primary.date_comment.value_or(""));
        out.push_back(opts.strip_header_g49g80 ? "G40 G17 G90" : "G40 G17 G49 G80 G90");
        if (opts.open_g28) out.push_back("G28 G91 Z0.0");
        out.push_back("T" + std::to_string(tNums[0]) + " M06");
        if (auto t = preselectTool(tNums, 0, opts.preselect_mode)) out.push_back("T" + std::to_string(*t));

        std::string modalWcs;
        for (size_t idx = 0; idx < groups.size(); ++idx) {
            const auto& group = groups[idx];
            const Segment& base = group.primary;
        MachineModalState modalState;
        for (const auto& pass : buildG54G56Passes(base, group.paired, idx, opts, modalState, idx + 1 == groups.size())) {
            appendRun(out, pass, opts);
            updateModalWcs(modalState, pass);
        }

        // 修复 #14、#21: 多坐标 EXTREME 档安全网，在刀末/M05 前强制关 G40
        if (opts.side_compensation_g41) {
            out.push_back("G40");
        }
        out.push_back("M05");
        // 修复 #14、#21: 多坐标 EXTREME 档安全网，在刀末/M05 前强制关 G40
        if (opts.side_compensation_g41) {
            out.push_back("G40");
        }
        out.push_back("M05");
        out.push_back("M09");
        if (idx + 1 != mainSegs.size()) {
            out.push_back("G28 G91 Z0.0");
            out.push_back("T" + std::to_string(tNums[idx + 1]) + " M06");
            if (auto t = preselectTool(tNums, idx + 1, opts.preselect_mode)) out.push_back("T" + std::to_string(*t));

            // M00插入逻辑 (从第二把刀开始)
            if (opts.m00_wait_mode == M00_WAIT_ALL_TOOLS) {
                out.push_back("M00");
            } else if (opts.m00_wait_mode == M00_WAIT_DRILL_ONLY) {
                const Segment& nextSeg = mainSegs[idx + 1];
                if (nextSeg.has_drill_cycle) {
                    out.push_back("M00");
                }
            }

            const auto& nxt = mainSegs[idx + 1];
            // M00插入逻辑 (从第二把刀开始, idx >= 0 表示已经加工过第一把)
            if (opts.m00_wait_mode == M00_WAIT_ALL_TOOLS) {
                out.push_back("M00");
            } else if (opts.m00_wait_mode == M00_WAIT_DRILL_ONLY) {
                const Segment& nextSeg = groups[idx + 1].primary;
                if (nextSeg.has_drill_cycle) {
                    out.push_back("M00");
                }
            }

            if (opts.g54g56_lift_z <= 0) {
            // M00插入逻辑 (从第二把刀开始, idx >= 0 表示已经加工过第一把)
            if (opts.m00_wait_mode == M00_WAIT_ALL_TOOLS) {
                out.push_back("M00");
            } else if (opts.m00_wait_mode == M00_WAIT_DRILL_ONLY) {
                const Segment& nextSeg = groups[idx + 1].primary;
                if (nextSeg.has_drill_cycle) {
                    out.push_back("M00");
                }
            }

            if (opts.g54g56_lift_z <= 0) {
                const auto& nxt = groups[idx + 1].primary;
                out.push_back(nxt.tool_comment.value_or(""));
                out.push_back(nxt.dia_comment.value_or(""));
                out.push_back(nxt.date_comment.value_or(""));
            }
        } else {
            if (opts.end_zero_zero && opts.version == "H") out.push_back("G28 G91 Z0.0 0.0");
            else out.push_back(opts.end_dual_axis ? "G28 G91 Z0.0 Y0.0" : "G28 G91 Z0.0");
            if (base.machine_time) out.push_back(*base.machine_time);
            if (base.cutting_time) out.push_back(*base.cutting_time);
            out.push_back("M30");
            out.push_back("%");
            for (int i = 0; i < opts.trailing_blank_lines; ++i) out.push_back("");
        }
    }
    return joinOutputLines(out);
}

static std::string mergeStandardStrategy(std::vector<Segment> segs, const MergeOptions& opts) {
    if (segs.empty()) throw std::runtime_error("没有段可合并");
    segs.erase(std::remove_if(segs.begin(), segs.end(), isFlyingKnifeSeg), segs.end());
    if (segs.empty()) throw std::runtime_error("剔除飞刀(-11+H01)后没有段可合并");

    std::vector<Segment> mainSegs, trySegs;
    splitMainAndTrySegments(segs, opts, mainSegs, trySegs);
    if (mainSegs.empty()) throw std::runtime_error("拆掉飞刀段后没有主段可合并");
    sortMergeSegments(mainSegs, trySegs, opts);

    for (const auto& s : mainSegs) {
        if (!s.h_num) throw std::runtime_error(s.src_fn + ": 缺 G43 行/H 号");
        if (!s.g0_xy_etc) throw std::runtime_error(s.src_fn + ": 缺 G0 首切行");
    }

    std::vector<int> tNums;
    for (auto& s : mainSegs) tNums.push_back(resolveTNumber(s, opts));
    std::vector<std::string> out;
    out.push_back("%");
    out.push_back(mainSegs[0].tool_comment.value_or(""));
    out.push_back(mainSegs[0].dia_comment.value_or(""));
    out.push_back(mainSegs[0].date_comment.value_or(""));
    out.push_back(opts.strip_header_g49g80 ? "G40 G17 G90" : "G40 G17 G49 G80 G90");
    if (opts.open_g28) out.push_back("G28 G91 Z0.0");
    out.push_back("T" + std::to_string(tNums[0]) + " M06");
    if (auto t = preselectTool(tNums, 0, opts.preselect_mode)) out.push_back("T" + std::to_string(*t));

    for (size_t idx = 0; idx < mainSegs.size(); ++idx) {
        const auto& seg = mainSegs[idx];
        // 修复 #41、#42: G0 定位行也施加坐标补偿，与 body 一致
        std::string g0Line = std::string(idx == 0 ? "G0 G54 G90 " : "G0 G90 ") + seg.g0_xy_etc.value_or("");
        applyExperimentalCompensation(g0Line, seg.wcs.value_or("G54"), opts);
        out.push_back(g0Line);
        std::string g43 = seg.g43_line.value_or("");
        out.push_back(formatG43ForVersion(g43, opts));
        auto body = seg.cutting_body;
        applyExperimentalCompensation(body, seg.wcs.value_or("G54"), opts);
        body = applySideCompensationToBody(std::move(body), opts, seg.h_num.value_or(0));
        auto body = applySideCompensationToBody(seg.cutting_body, opts, seg.h_num.value_or(0));
        out.insert(out.end(), body.begin(), body.end());
        // 修复 #14、#15: EXTREME 档安全网，在段末/M05 前强制关 G40，防止跨刀/跨 M30 残留
        if (opts.side_compensation_g41) {
            out.push_back("G40");
        }
        out.push_back("M05");
        out.push_back("M09");
        if (idx + 1 != mainSegs.size()) {
            out.push_back("G28 G91 Z0.0");
            out.push_back("T" + std::to_string(tNums[idx + 1]) + " M06");
        if (auto t = preselectTool(tNums, 0, opts.preselect_mode)) out.push_back("T" + std::to_string(*t));
            if (opts.m00_wait_mode == M00_WAIT_ALL_TOOLS) {
                out.push_back("M00");
            } else if (opts.m00_wait_mode == M00_WAIT_DRILL_ONLY) {
                const Segment& nextSeg = mainSegs[idx + 1];
                if (nextSeg.has_drill_cycle) {
                    out.push_back("M00");
                }
            }

            const auto& nxt = mainSegs[idx + 1];
            out.push_back(nxt.tool_comment.value_or(""));
            out.push_back(nxt.dia_comment.value_or(""));
            out.push_back(nxt.date_comment.value_or(""));
        } else {
            if (opts.end_zero_zero && opts.version == "H") out.push_back("G28 G91 Z0.0 0.0");
            else out.push_back(opts.end_dual_axis ? "G28 G91 Z0.0 Y0.0" : "G28 G91 Z0.0");
            if (seg.machine_time) out.push_back(*seg.machine_time);
            if (seg.cutting_time) out.push_back(*seg.cutting_time);
            out.push_back("M30");
            out.push_back("%");
            for (int i = 0; i < opts.trailing_blank_lines; ++i) out.push_back("");
        }
    }
    return joinOutputLines(out);
}

static std::string mergeSegments(std::vector<Segment> segs, const MergeOptions& opts) {
    if (opts.g54g56_mode) return mergeG54G56Strategy(std::move(segs), opts);
    return mergeStandardStrategy(std::move(segs), opts);
}


static bool hasTokenG(const std::string& line, int code) {
    for (const auto& t : parseGcodeLine(line)) if (t.ch == 'G' && std::abs(t.val - (double)code) < 1e-9) return true;
    return false;
}

static bool hasTokenM(const std::string& line, int code) {
    for (const auto& t : parseGcodeLine(line)) if (t.ch == 'M' && std::abs(t.val - (double)code) < 1e-9) return true;
    return false;
}

static bool hasAnyGRange(const std::string& line, int lo, int hi) {
    for (const auto& t : parseGcodeLine(line)) if (t.ch == 'G' && t.val >= lo && t.val <= hi) return true;
    return false;
}

static std::string boolCn(bool v) { return v ? "是" : "否"; }

static std::string twoDigitLetter(char ch, int n) {
    std::ostringstream ss;
    ss << ch << std::setw(2) << std::setfill('0') << n << std::setfill(' ');
    return ss.str();
}

static std::string m00ModeCn(const std::string& mode) {
    if (mode == M00_WAIT_ALL_TOOLS) return "每次换刀后暂停";
    if (mode == M00_WAIT_DRILL_ONLY) return "钻孔刀换刀后暂停";
    return "不加 M00 暂停";
}

static std::string g41StrategyCn(const std::string& strategy) {
    if (strategy == G41_RISK_EXTREME) return "危险：极限速度，不自动关 G40";
    if (strategy == G41_RISK_FAST || strategy == "SEGMENT_END") return "偏快：旧版兼容，段末才 G40";
    if (strategy == G41_RISK_BALANCED) return "平衡：G0/固定循环/停机前 G40";
    if (strategy == G41_RISK_SAFE) return "偏安全：G0/纯Z/固定循环前 G40";
    return "安全：G0前先G40，每段保守包络";
}

static std::vector<std::string> scanM70SafetyText(const std::string& text) {
    std::vector<std::string> issues;
    bool g41 = false, canned = false, g91 = false, g43NoH = false;
    int g41Line = 0, lineNo = 1;
    for (const auto& raw : splitLines(text)) {
        std::string line = trim(raw);
        bool opensG41 = hasTokenG(line, 41), closesG40 = hasTokenG(line, 40);
        bool pureZ = lineHasZ(line) && !lineHasXy(line);
        bool dangerous = hasTokenG(line, 0) || pureZ || hasAnyGRange(line, 81, 89) || hasTokenG(line, 28) || hasTokenM(line, 5) || hasTokenM(line, 9) || hasTokenM(line, 30);
        if (g41 && closesG40 && dangerous) issues.push_back("FATAL L" + std::to_string(lineNo) + ": G40 与危险动作同块，建议 G40 独立成块: " + line);
        if (g41 && !closesG40 && dangerous) issues.push_back("FATAL L" + std::to_string(lineNo) + ": G41 自 L" + std::to_string(g41Line) + " 起仍激活，期间出现危险动作: " + line);
        if (opensG41) { g41 = true; g41Line = lineNo; }
        if (closesG40) g41 = false;
        if (hasAnyGRange(line, 81, 89)) canned = true;
        if (hasTokenG(line, 80)) canned = false;
        // M70/Fanuc-style home return commonly uses G28 G91 Z0. as a local return block.
        // Do not leave the audit state in G91 for that idiom; flag standalone G91 instead.
        if (hasTokenG(line, 91) && !hasTokenG(line, 28)) g91 = true;
        if (hasTokenG(line, 90) || hasTokenG(line, 28)) g91 = false;
        if (hasTokenG(line, 43)) {
            bool hasH = false;
            for (const auto& t : parseGcodeLine(line)) if (t.ch == 'H') hasH = true;
            if (!hasH) g43NoH = true;
        }
        ++lineNo;
    }
    if (g41) issues.push_back("FATAL: 程序结束仍有未关闭 G41");
    if (canned) issues.push_back("ERROR: 程序结束前固定循环 G81-G89 可能未用 G80 取消");
    if (g91) issues.push_back("ERROR: 程序结束前仍处于 G91 增量模式或未明确恢复 G90");
    if (g43NoH) issues.push_back("ERROR: 存在 G43 但同块未检测到 H 号");
    return issues;
}


static bool hasShopPrecheckToggle(const MergeOptions& opts) {
    return opts.shop_precheck_input || opts.shop_keyword_preview || opts.shop_coord_dry_run ||
           opts.shop_g41_envelope;
}

static bool hasAxisToken(const std::string& line, char axis) {
    for (const auto& t : parseGcodeLine(line)) if (t.ch == axis) return true;
    return false;
}

static optional<ExperimentalCompensation> compensationForWcs(const MergeOptions& opts, const std::string& wcs) {
    for (const auto& comp : opts.compensations) if (comp.wcs == wcs) return comp;
    return std::nullopt;
}

static bool isCoordDryRunLine(const std::string& line) {
    bool motion = false;
    for (const auto& t : parseGcodeLine(line)) {
        if (t.ch == 'G' && (std::abs(t.val) < 1e-9 || std::abs(t.val - 1.0) < 1e-9 || (t.val >= 81.0 && t.val <= 89.0))) motion = true;
    }
    return motion && (hasAxisToken(line, 'X') || hasAxisToken(line, 'Y') || hasAxisToken(line, 'Z'));
}

static std::string axisDeltaText(const ExperimentalCompensation& comp, const std::string& line) {
    std::ostringstream ss;
    bool first = true;
    auto add = [&](char axis, double v) {
        if (std::abs(v) < 1e-12 || !hasAxisToken(line, axis)) return;
        if (!first) ss << ' ';
        first = false;
        ss << axis << (v >= 0 ? "+" : "") << formatGcodeVal(v);
    };
    add('X', comp.x); add('Y', comp.y); add('Z', comp.z);
    return ss.str();
}

static std::string formatCoordDryRunReport(const std::vector<Segment>& mainSegs, const MergeOptions& opts) {
    std::ostringstream ss;
    ss << "\n坐标补偿 Dry-run 明细\n";
    if (!opts.experimental_compensation) {
        ss << "未启用坐标偏移补偿：本段只预览，不改 NC。\n";
        return ss.str();
    }
    if (opts.compensations.empty()) {
        ss << "未填写补偿参数：请在坐标偏移参数中填写如 G56:X0.02:Y-0.01。\n";
        return ss.str();
    }
    int shown = 0;
    auto showLine = [&](const Segment& seg, const std::string& wcs, int lineNo, const std::string& raw) {
        auto comp = compensationForWcs(opts, wcs);
        if (!comp || !isCoordDryRunLine(raw)) return;
        std::string after = raw;
        applyExperimentalCompensation(after, wcs, opts);
        if (after == raw) return;
        std::string delta = axisDeltaText(*comp, raw);
        if (delta.empty()) return;
        ss << seg.src_fn << "\t" << wcs << "\tL" << lineNo << "\t原: " << trim(raw) << "\t新: " << trim(after) << "\t差: " << delta << "\n";
        ++shown;
    };
    for (const auto& seg : mainSegs) {
        if (opts.g54g56_mode) {
            for (const auto& cfg : opts.work_offsets) {
                std::string g0 = "G0 " + cfg.wcs + " " + g0PayloadForWcs(seg, cfg.wcs);
                showLine(seg, cfg.wcs, 0, g0);
                int lineNo = 1;
                for (const auto& body : seg.cutting_body) showLine(seg, cfg.wcs, lineNo++, body);
            }
        } else {
            std::string wcs = seg.wcs.value_or("G54");
            if (seg.g0_xy_etc) showLine(seg, wcs, 0, "G0 " + *seg.g0_xy_etc);
            int lineNo = 1;
            for (const auto& body : seg.cutting_body) showLine(seg, wcs, lineNo++, body);
        }
    }
    if (!shown) ss << "未发现会被当前补偿配置改变的 G0/G1/G81-G89 坐标行；未填写的 WCS 或行内不存在的轴不会强行添加。\n";
    return ss.str();
}

static bool isMergedName(const fs::path& p);

static bool isMergedName(const fs::path& p);

static bool isMergedName(const fs::path& p);

static std::string formatInputPrecheckReport(const std::vector<Segment>& allSegs, const std::vector<Segment>& mainSegs, const MergeOptions& opts) {
    (void)mainSegs;
    std::ostringstream ss;
    std::ostringstream ss;
    ss << "\n发布前输入预检\n";
    auto compIssues = scanCompensationLimitIssues(opts);
    if (allSegs.empty()) ss << "ERROR: 输入为空，未解析到任何 PTP 程序\n";
    for (const auto& seg : allSegs) {
        bool hasM30 = false;
        try {
            for (const auto& line : readTextLines(seg.src_path)) if (hasTokenM(trim(line), 30)) { hasM30 = true; break; }
        } catch (const std::exception& e) {
            ss << "ERROR: " << seg.src_fn << " 源文件读取失败，无法确认 M30: " << e.what() << "\n";
        }
        if (isMergedName(seg.src_path)) ss << "WARN: " << seg.src_fn << " 看起来是已合并 H/HH 文件，避免重复合并\n";
        if (isTryKnifeName(seg.src_fn)) ss << "INFO: " << seg.src_fn << " 文件名像飞刀/试刀(-11)，请确认是否应进主程序\n";
        if (!seg.tool_comment) ss << "WARN: " << seg.src_fn << " 缺 Tool 注释\n";
        if (!seg.g43_line) ss << "ERROR: " << seg.src_fn << " 缺 G43/H 刀长补偿行\n";
        if (!seg.h_num) ss << "ERROR: " << seg.src_fn << " 未解析到 H 号\n";
        if (!seg.g0_xy_etc) ss << "WARN: " << seg.src_fn << " 缺首个 G0 定位行\n";
        if (!hasM30) ss << "WARN: " << seg.src_fn << " 源文件未检测到 M30，程序可能不完整\n";
    }
    for (const auto& issue : compIssues) ss << issue.severity << ": " << issue.text << "\n";
    ss << "OK: 预检完成；WARN/INFO 需人工复核，ERROR/FATAL 不建议直接上机。\n";
    return ss.str();
}

static std::string formatG41EnvelopeForText(const char* label, const std::string& text) {
    std::ostringstream ss;
    ss << label << "\n";
    bool active = false;
    int startLine = 0;
    std::string startText;
    std::vector<std::string> risks;
    int segNo = 0;
    int lineNo = 1;
    for (const auto& raw : splitLines(text)) {
        std::string line = trim(raw);
        bool opens = hasTokenG(line, 41), closes = hasTokenG(line, 40);
        bool dangerous = hasTokenG(line, 0) || (lineHasZ(line) && !lineHasXy(line)) || hasAnyGRange(line, 81, 89) || hasTokenG(line, 28) || hasTokenM(line, 5) || hasTokenM(line, 9) || hasTokenM(line, 30);
        if (opens && !active) { active = true; startLine = lineNo; startText = line; risks.clear(); }
        if (active && dangerous && !opens && !closes) risks.push_back("风险 L" + std::to_string(lineNo) + ": " + line);
        if (active && closes) {
            ++segNo;
            ss << "G41段 " << segNo << ": 开始 L" << startLine << " " << startText << " / 结束 L" << lineNo << " " << line << "\n";
            if (risks.empty()) ss << "  状态 OK：未发现 G41 内 G0/纯Z/固定循环/M05/M09/G28/M30\n";
            else { for (const auto& r : risks) ss << "  " << r << "\n"; ss << "  状态 FATAL：危险动作出现在 G41 内\n"; }
            active = false;
        }
        ++lineNo;
    }
    if (active) ss << "G41段未关闭：开始 L" << startLine << " " << startText << "\n  状态 FATAL\n";
    if (segNo == 0 && !active) ss << "未发现 G41 段。\n";
    return ss.str();
}

static std::string formatG41EnvelopeReport(const std::string* hText, const std::string* hhText) {
    std::ostringstream ss;
    ss << "\nG41/G40 包络报告\n";
    if (!hText && !hhText) { ss << "未提供最终 H/HH 文本，无法生成包络报告。\n"; return ss.str(); }
    if (hText) ss << formatG41EnvelopeForText("H 版", *hText);
    if (hhText) ss << formatG41EnvelopeForText("HH 版", *hhText);
    return ss.str();
}

static std::string makeSafetyAuditReport(std::vector<Segment> segs, const MergeOptions& opts, const std::string* hText = nullptr, const std::string* hhText = nullptr) {
    std::ostringstream ss;
    const bool legacySafetyReport = opts.safety_audit_report && !hasShopPrecheckToggle(opts);
    const bool showInput = opts.shop_precheck_input;
    const bool showKeyword = opts.shop_keyword_preview;
    const bool showCoordDry = opts.shop_coord_dry_run;
    const bool showG41Envelope = opts.shop_g41_envelope;

    ss << "=== UG7.5 / M70 车间防错 / 发布前检查报告 ===\n";
    ss << "=== UG7.5 / M70 安全审计报告 ===\n";
    ss << "说明: 本报告按当前规则扫描，不能替代正式加工前人工复核、仿真、空跑/单段验证。新增车间防错项目默认关闭，只在勾选后显示。\n\n";
    ss << "配置\n";
    ss << "- M00: " << m00ModeCn(opts.m00_wait_mode) << "\n";
    ss << "- G41/G40: " << g41StrategyCn(opts.g41_close_strategy) << "\n";
    ss << "- G41刀损补偿: " << boolCn(opts.side_compensation_g41) << "\n";
    ss << "- 多坐标: " << boolCn(opts.g54g56_mode) << " work_offsets=" << formatWorkOffsetConfigText(opts.work_offsets) << "\n";
    ss << "- 坐标偏移补偿: " << boolCn(opts.experimental_compensation);
    if (!opts.compensations.empty()) ss << " " << formatCompensationConfigText(opts.compensations);
    ss << "\n- 坐标补偿限值检查: " << boolCn(opts.compensation_limit_check);
    if (opts.compensation_limit_check) ss << " 最大绝对值=" << formatGcodeVal(opts.compensation_limit_abs);
    ss << "\n- 发布前输入预检: " << boolCn(opts.shop_precheck_input) << "\n";
    ss << "- H/D/T/WCS/M00 汇总预览: " << boolCn(opts.shop_keyword_preview) << "\n";
    ss << "- 坐标补偿 Dry-run 明细: " << boolCn(opts.shop_coord_dry_run) << "\n";
    ss << "- G41/G40 包络报告: " << boolCn(opts.shop_g41_envelope) << "\n";
    ss << "- 输出前自动备份: " << boolCn(opts.shop_auto_backup) << "\n";
    ss << "- 配置快照/版本留痕: " << boolCn(opts.shop_config_snapshot) << "\n";
    ss << "- 严格审计: " << boolCn(opts.safety_audit_strict) << "\n\n";

    std::vector<Segment> allSegs = segs;
    std::vector<Segment> mainSegs, trySegs;
    segs.erase(std::remove_if(segs.begin(), segs.end(), isFlyingKnifeSeg), segs.end());
    splitMainAndTrySegments(segs, opts, mainSegs, trySegs);
    sortMergeSegments(mainSegs, trySegs, opts);
    std::vector<int> tNums;
    for (const auto& seg : mainSegs) tNums.push_back(resolveTNumber(seg, opts));

    if (showKeyword) {
        ss << "刀具 / H-D / WCS / M00 预览\n";
        ss << "序号\t文件\tTool\tT\t原H\tWCS\t输出H\t输出D\t钻孔\tM00说明\n";
        for (size_t i = 0; i < mainSegs.size(); ++i) {
            const auto& seg = mainSegs[i];
            std::string tool = extractToolName(seg.tool_comment.value_or(""));
            std::string m00 = (i == 0) ? "首刀跳过" : (opts.m00_wait_mode == M00_WAIT_ALL_TOOLS ? "换刀后暂停" : (opts.m00_wait_mode == M00_WAIT_DRILL_ONLY ? (seg.has_drill_cycle ? "钻孔刀暂停" : "非钻孔不暂停") : "无"));
            if (opts.g54g56_lift_z <= 0) {

                for (const auto& cfg : opts.work_offsets) {
                    int h = seg.h_num.value_or(0) + cfg.h_offset;
                    ss << (i + 1) << '\t' << seg.src_fn << '\t' << tool << '\t' << 'T' << tNums[i] << '\t' << twoDigitLetter('H', seg.h_num.value_or(0)) << '\t' << cfg.wcs << '\t' << twoDigitLetter('H', h) << '\t' << twoDigitLetter('D', h) << '\t' << boolCn(seg.has_drill_cycle) << '\t' << m00 << "\n";
                }
            } else {
                int h = seg.h_num.value_or(0);
                ss << (i + 1) << '\t' << seg.src_fn << '\t' << tool << '\t' << 'T' << tNums[i] << '\t' << twoDigitLetter('H', h) << '\t' << seg.wcs.value_or("G54") << '\t' << twoDigitLetter('H', h) << '\t' << twoDigitLetter('D', h) << '\t' << boolCn(seg.has_drill_cycle) << '\t' << m00 << "\n";
            }
        }
    }

    if (opts.compensation_limit_check || legacySafetyReport) {
        ss << "\n坐标补偿限值检查\n";
        auto compIssues = scanCompensationLimitIssues(opts);
        if (!opts.compensation_limit_check) ss << "关闭：默认不限制坐标偏移补偿，需勾选限值检查或使用 CLI --compensation-limit 才会拦截超大补偿。\n";
        else if (compIssues.empty()) ss << "OK: 所有已配置 X/Y/Z 补偿绝对值均 <= " << formatGcodeVal(opts.compensation_limit_abs) << "\n";
        else for (const auto& issue : compIssues) ss << issue.severity << ": " << issue.text << "\n";
    }

    if (showInput) ss << formatInputPrecheckReport(allSegs, mainSegs, opts);
    if (showCoordDry) ss << formatCoordDryRunReport(mainSegs, opts);
    if (showG41Envelope) ss << formatG41EnvelopeReport(hText, hhText);

    ss << "\nM70 风险扫描\n";
    std::vector<std::string> allIssues;
    for (const auto& issue : scanCompensationLimitIssues(opts)) allIssues.push_back("COMP[" + issue.severity + "]: " + issue.text);
    auto appendIssues = [&](const char* label, const std::string& text) {
        auto issues = scanM70SafetyText(text);
        if (issues.empty()) ss << label << ": OK，未发现 G41/G40、G91、固定循环收敛等规则风险\n";
        else for (const auto& x : issues) { ss << label << ": " << x << "\n"; allIssues.push_back(std::string(label) + ": " + x); }
    };
    if (hText) appendIssues("H", *hText);
    if (hhText) appendIssues("HH", *hhText);
    if (!hText && !hhText) ss << "未提供最终 H/HH 文本，仅生成段级预览。\n";
    ss << "\n差异/样本原则\n- expected/golden PTP 只作为历史证据；若与当前输入不一致，不应盲目改代码去匹配。\n- H/D/T、G54/G56、G41/G40、M00、坐标补偿差异属于高风险，必须人工解释。\n\n结论\n";
    if (allIssues.empty()) ss << "已按当前样本和规则验证通过；正式加工前仍需人工复核 NC 输出，并建议空跑/单段验证。\n";
    else ss << "发现 " << allIssues.size() << " 项风险；请先处理或人工确认，不建议直接上机。\n";
    return ss.str();
}

struct NormalState {
    bool wcs_ready = false;
    bool cross_line_g43 = true;
    bool pending_g43 = false;
    optional<double> pending_g43_z;
    optional<double> pending_g43_h;
};

static std::string flushPendingG43(NormalState& st) {
    std::vector<std::string> parts{"G43"};
    if (st.pending_g43_z) parts.push_back("Z" + formatGcodeVal(*st.pending_g43_z));
    if (st.pending_g43_h) {
        std::ostringstream hs;
        hs << "H" << std::setw(2) << std::setfill('0') << (int)*st.pending_g43_h;
        parts.push_back(hs.str());
    }
    parts.push_back("G1 F4000");
    st.pending_g43 = false;
    st.pending_g43_z.reset();
    st.pending_g43_h.reset();
    std::ostringstream ss;
    for (size_t i = 0; i < parts.size(); ++i) {
        if (i) ss << ' ';
        ss << parts[i];
    }
    return ss.str() + "\n";
}

struct LineResult {
    std::vector<std::string> emit;
    bool changed = false;
    std::string reason;
};

static LineResult processLineLogic(const std::string& originalLine, NormalState& st);

static LineResult processLineLogic(const std::string& originalLine, NormalState& st) {
    std::string line = originalLine;
    while (!line.empty() && (line.back() == '\n' || line.back() == '\r')) line.pop_back();
    if (line.empty()) {
        if (st.pending_g43) return {{}, false, ""};
        return {{"\n"}, false, ""};
    }
    auto tokens = parseGcodeLine(line);
    if (tokens.empty()) return {{originalLine}, false, ""};

    std::vector<double> gCmds;
    bool hasX = false, hasY = false;
    optional<double> zVal, hVal;
    std::set<char> chars;
    for (auto& t : tokens) {
        chars.insert(t.ch);
        if (t.ch == 'G') gCmds.push_back(t.val);
        if (t.ch == 'X') hasX = true;
        if (t.ch == 'Y') hasY = true;
        if (t.ch == 'Z' && !zVal) zVal = t.val;
        if (t.ch == 'H' && !hVal) hVal = t.val;
    }

    if (st.cross_line_g43 && st.pending_g43) {
        if (chars == std::set<char>{'Z'} && zVal) {
            st.pending_g43_z = zVal;
            if (st.pending_g43_h) return {{flushPendingG43(st)}, true, "跨行缝合 G43/Z/H"};
            return {{}, true, "吸入 G43 的 Z 参数"};
        }
        if (chars == std::set<char>{'H'} && hVal) {
            st.pending_g43_h = hVal;
            if (st.pending_g43_z) return {{flushPendingG43(st)}, true, "跨行缝合 G43/Z/H"};
            return {{}, true, "吸入 G43 的 H 参数"};
        }
        if (!chars.count('G') && !hasX && !hasY && zVal && hVal) {
            st.pending_g43_z = zVal;
            st.pending_g43_h = hVal;
            return {{flushPendingG43(st)}, true, "跨行缝合 G43/Z/H"};
        }
        std::string forced = flushPendingG43(st);
        auto sub = processLineLogic(originalLine, st);
        sub.emit.insert(sub.emit.begin(), forced);
        sub.changed = true;
        sub.reason = "跨行 G43 末尾强吐";
        return sub;
    }

    std::string up = upperAscii(line);
    if (up.find("M06") != std::string::npos || up.find("M6") != std::string::npos || chars.count('T')) st.wcs_ready = false;
    for (double g : gCmds) if (g >= 54.0 && g <= 59.0) st.wcs_ready = true;

    if (std::find(gCmds.begin(), gCmds.end(), 0.0) != gCmds.end() && (hasX || hasY) && !st.wcs_ready) {
        static const std::regex g0Re(R"(G0*[0-9]?)", std::regex::icase);
        std::string newLine = std::regex_replace(line, g0Re, "$& G54", std::regex_constants::format_first_only);
        st.wcs_ready = true;
        return {{newLine + "\n"}, true, "精准补全初始 XY 定位的 G54 坐标系"};
    }

    if (std::find(gCmds.begin(), gCmds.end(), 43.0) != gCmds.end()) {
        if (zVal && hVal) {
            std::ostringstream hs;
            hs << "G43 Z" << formatGcodeVal(*zVal) << " H" << std::setw(2) << std::setfill('0') << (int)*hVal << " G1 F4000";
            return {{hs.str() + "\n"}, true, "缝合 G43/Z/H 刀长补偿至同行"};
        }
        if (st.cross_line_g43) {
            st.pending_g43 = true;
            st.pending_g43_z = zVal;
            st.pending_g43_h = hVal;
            return {{}, true, "G43 缺 Z/H, 进入跨行等待"};
        }
    }

    if (std::find(gCmds.begin(), gCmds.end(), 28.0) != gCmds.end() && zVal && *zVal == 0.0) {
        return {{"G28 G91 Z0. Y0.\n"}, true, "优化 G28 G91 回零格式"};
    }
    return {{originalLine}, false, ""};
static std::string processNormalText(const std::vector<std::string>& lines, bool crossLineG43, bool sideCompG41 = false, const std::string& g41CloseStrategy = G41_RISK_BALANCED) {
    NormalState st;
    st.cross_line_g43 = crossLineG43;
    std::vector<std::string> out;
    for (const auto& ln : lines) {
        if (ln.find("H02 G1") != std::string::npos && ln.find("G43") == std::string::npos) continue;
        auto r = processLineLogic(ln, st);
        out.insert(out.end(), r.emit.begin(), r.emit.end());
    }
    if (st.pending_g43) out.push_back(flushPendingG43(st));
    out = applySideCompensationToProgram(std::move(out), sideCompG41, g41CloseStrategy);
    std::ostringstream ss;
    for (const auto& line : out) ss << line;
    return ss.str();
}
        opts.side_compensation_g41 = true;
        int h = 0;
        for (const auto& line : out) {
            for (const auto& t : parseGcodeLine(line)) if (t.ch == 'H') { h = (int)std::llround(t.val); break; }
            if (h) break;
        }
        if (h) out = applySideCompensationToBody(std::move(out), opts, h);
    }
    std::ostringstream ss;
    for (const auto& line : out) ss << line;
    return ss.str();
}
}

static std::string makeDiff(const std::string& title, const std::vector<std::string>& before, const std::vector<std::string>& after) {
    const size_t n = before.size(), m = after.size();
    std::vector<std::string> out{"━━━ " + title + " ━━━"};
    size_t i = 0, j = 0;
    int changes = 0;
    constexpr size_t LOOKAHEAD = 24;

    auto findSync = [&](size_t bi, size_t aj) {
        struct Sync { size_t del = 1; size_t ins = 1; bool found = false; };
        Sync best;
        size_t maxDel = std::min(LOOKAHEAD, n - bi);
        size_t maxIns = std::min(LOOKAHEAD, m - aj);
        for (size_t del = 0; del <= maxDel; ++del) {
            for (size_t ins = 0; ins <= maxIns; ++ins) {
                if (del == 0 && ins == 0) continue;
                if (bi + del < n && aj + ins < m && before[bi + del] == after[aj + ins]) {
                    if (!best.found || del + ins < best.del + best.ins) {
                        best = {del, ins, true};
                    }
                }
            }
        }
        if (!best.found) {
            if (bi >= n) best = {0, 1, true};
            else if (aj >= m) best = {1, 0, true};
            else best = {1, 1, true};
        }
        return best;
    };

    while (i < n || j < m) {
        if (i < n && j < m && before[i] == after[j]) {
            ++i; ++j;
        } else {
            ++changes;
            out.push_back("@@ 变动 " + std::to_string(changes) + " @@");
            auto sync = findSync(i, j);
            size_t iEnd = std::min(n, i + sync.del);
            size_t jEnd = std::min(m, j + sync.ins);
            while (i < iEnd) out.push_back("- " + before[i++]);
            while (j < jEnd) out.push_back("+ " + after[j++]);
        }
    }
    if (!changes) out.push_back("(无变化)");
    out.push_back("");
    std::ostringstream ss;
    for (auto& line : out) ss << line << "\r\n";
    return ss.str();
}

static bool getCursorPoint(POINT& pt);

class App {
public:
    HWND hwnd = nullptr;
    HFONT font = nullptr;
    HFONT boldFont = nullptr;
    HMODULE richEditLib = nullptr;
    HBRUSH bgBrush = nullptr;
    HBRUSH cardBrush = nullptr;
    HWND tooltip = nullptr;
    HWND tooltipText = nullptr;
    HWND hoverTool = nullptr;
    bool hoverTracking = false;
    bool tooltipPending = false;
    bool tooltipPaused = false;
    std::unordered_map<HWND, std::wstring> tooltipTexts;
    std::vector<HWND> tooltipOrder;
    std::vector<fs::path> files;
    std::string normalCache, hCache, hhCache, logCache, safetyCache;
    std::string renderedNormal, renderedH, renderedHH, renderedLog, renderedSafety;
    int activeTab = -1;
    bool topmost = false;
    bool busy = false;
    std::wstring appliedTemplateName;

    HWND status = nullptr, list = nullptr, tabs = nullptr;
    HWND txtNormal = nullptr, txtH = nullptr, txtHH = nullptr, txtLog = nullptr, txtSafety = nullptr;

    bool create(HINSTANCE hinst);
    void layout(int w, int h);
    void addControls();
    void addTooltips();
    void addTooltip(int id, const char* text);
    void onToolMouse(HWND tool, UINT msg);
    void pollHover();
    void showTooltip();
    void hideTooltip();
    HWND toolAtPoint(POINT pt);
    std::wstring tooltipTextForTool(HWND tool);
    bool tooltipsEnabled() const;
    void pauseTooltips();
    void resumeTooltips();
    void onCommand(int id, int code, HWND from);
    void onJobDone(JobResult* result);
    void setBusy(bool value, const std::wstring& statusText = L"");
    void onDrop(HDROP drop);
    void startLoad(std::vector<fs::path> inputs, const std::wstring& busyText);
    void addPath(const fs::path& p, int& added, int& skipHh, int& skipTry, int& skipOther);
    void addDir(const fs::path& d, int& added, int& skipHh, int& skipTry, int& skipOther);
    void redrawList();
    void setStatus(const std::wstring& s);
    void log(const std::wstring& level, const std::wstring& msg);
    MergeOptions collectOptions();
    std::vector<Segment> parseAll();
    std::pair<std::string, std::string> buildMerge();
    fs::path okDir();
    void normalProcess();
    void mergeProcess();
    void previewDiff();
    void safetyReport();
    void refreshText();
    void updateTabVisibility();
    void setPreviewText(HWND edit, const std::string& content);
    void setPlainText(HWND edit, const std::string& content);
    void moveSelected(int delta);
    void removeSelected();
    void browseFiles();
    void browseFolder();
    void applyTemplateSelection();
    bool writeWithConfirm(const fs::path& path, const std::string& text);
    void loadSettings();
    void saveSettings();
};

static App* g_app = nullptr;

static HWND make(HWND parent, const wchar_t* cls, const wchar_t* text, DWORD style, int id) {
    return CreateWindowExW(0, cls, text, style | WS_CHILD | WS_VISIBLE, 0, 0, 10, 10, parent, (HMENU)(INT_PTR)id, GetModuleHandleW(nullptr), nullptr);
}

static void setFont(HWND h, HFONT f) { SendMessageW(h, WM_SETFONT, (WPARAM)f, TRUE); }

bool App::create(HINSTANCE hinst) {
    INITCOMMONCONTROLSEX icc{sizeof(icc), ICC_WIN95_CLASSES | ICC_TAB_CLASSES | ICC_BAR_CLASSES};
    InitCommonControlsEx(&icc);
    bgBrush = CreateSolidBrush(C_BG);
    cardBrush = CreateSolidBrush(C_CARD);

    WNDCLASSW wc{};
    wc.lpfnWndProc = [](HWND h, UINT msg, WPARAM w, LPARAM l) -> LRESULT {
        if (msg == WM_NCCREATE) {
            auto cs = (CREATESTRUCTW*)l;
            SetWindowLongPtrW(h, GWLP_USERDATA, (LONG_PTR)cs->lpCreateParams);
        }
        auto app = (App*)GetWindowLongPtrW(h, GWLP_USERDATA);
        switch (msg) {
        case WM_SIZE:
            if (app) app->layout(LOWORD(l), HIWORD(l));
            return 0;
        case WM_COMMAND:
            if (app) app->onCommand(LOWORD(w), HIWORD(w), (HWND)l);
            return 0;
        case WM_HSCROLL:
            // 2026-06-04 13:13 版已取消 G41 五档滑块。
            return 0;
        case WM_APP_JOB_DONE:
            if (app) app->onJobDone(reinterpret_cast<JobResult*>(w));
            else delete reinterpret_cast<JobResult*>(w);
            return 0;
        case WM_APP_SHOW_TOOLTIP:
            if (app && app->tooltipsEnabled()) {
                app->hideTooltip();
                app->hoverTool = reinterpret_cast<HWND>(w);
                app->showTooltip();
            }
            return 0;
        case WM_APP_JOB_PROGRESS:
            if (app) {
                std::unique_ptr<std::wstring> text(reinterpret_cast<std::wstring*>(w));
                app->setStatus(*text);
            } else {
                delete reinterpret_cast<std::wstring*>(w);
            }
            return 0;
        case WM_NOTIFY:
            if (app && ((LPNMHDR)l)->idFrom == ID_TABS && ((LPNMHDR)l)->code == TCN_SELCHANGE) app->updateTabVisibility();
            return 0;
        case WM_MOUSEMOVE:
            if (app && app->tooltipsEnabled()) {
                POINT pt{(int)(short)LOWORD(l), (int)(short)HIWORD(l)};
                ClientToScreen(h, &pt);
                HWND tool = app->toolAtPoint(pt);
                if (tool && app->hoverTool != tool) {
                    app->hideTooltip();
                    app->hoverTool = tool;
                    app->tooltipPending = true;
                    SetTimer(h, TOOLTIP_TIMER_ID, 450, nullptr);
                } else if (!tool && app->hoverTool) {
                    app->hideTooltip();
                }
            }
            break;
        case WM_DROPFILES:
            if (app) app->onDrop((HDROP)w);
            return 0;
        case WM_TIMER:
            if (app && w == TOOLTIP_TIMER_ID) {
                KillTimer(h, TOOLTIP_TIMER_ID);
                app->showTooltip();
                return 0;
            }
            if (app && w == HOVER_POLL_TIMER_ID) {
                app->pollHover();
                return 0;
            }
            break;
        case WM_CTLCOLORSTATIC:
        case WM_CTLCOLORBTN:
            if (app && ((HWND)l == app->tooltipText || (app->tooltip && IsChild(app->tooltip, (HWND)l)))) {
                SetBkColor((HDC)w, GetSysColor(COLOR_INFOBK));
                SetTextColor((HDC)w, GetSysColor(COLOR_INFOTEXT));
                static HBRUSH tipBrush = CreateSolidBrush(GetSysColor(COLOR_INFOBK));
                return (LRESULT)tipBrush;
            }
            SetBkColor((HDC)w, C_BG);
            SetTextColor((HDC)w, C_TEXT);
            return (LRESULT)app->bgBrush;
        case WM_CTLCOLOREDIT:
        case WM_CTLCOLORLISTBOX:
            SetBkColor((HDC)w, RGB(255,255,255));
            SetTextColor((HDC)w, C_TEXT);
            return (LRESULT)GetStockObject(WHITE_BRUSH);
        case WM_ERASEBKGND:
            if (app) {
                RECT rc; GetClientRect(h, &rc);
                FillRect((HDC)w, &rc, app->bgBrush);
                return 1;
            }
            break;
        case WM_GETMINMAXINFO:
            ((MINMAXINFO*)l)->ptMinTrackSize.x = 1020;
            ((MINMAXINFO*)l)->ptMinTrackSize.y = 740;
            return 0;
        case WM_DESTROY:
            KillTimer(h, TOOLTIP_TIMER_ID);
            KillTimer(h, HOVER_POLL_TIMER_ID);
            if (app) app->saveSettings();
            PostQuitMessage(0);
            return 0;
        }
        return DefWindowProcW(h, msg, w, l);
    };
    wc.hInstance = hinst;
    wc.lpszClassName = L"UGNativeRewriteWindow";
    wc.hIcon = LoadIconW(hinst, MAKEINTRESOURCEW(1));
    wc.hCursor = LoadCursorW(nullptr, IDC_ARROW);
    RegisterClassW(&wc);

    hwnd = CreateWindowExW(0, wc.lpszClassName, APP_TITLE, WS_OVERLAPPEDWINDOW,
                           CW_USEDEFAULT, CW_USEDEFAULT, 1180, 840, nullptr, nullptr, hinst, this);
    if (!hwnd) return false;
    HICON bigIcon = (HICON)LoadImageW(hinst, MAKEINTRESOURCEW(1), IMAGE_ICON, 32, 32, LR_DEFAULTCOLOR);
    HICON smallIcon = (HICON)LoadImageW(hinst, MAKEINTRESOURCEW(1), IMAGE_ICON, 16, 16, LR_DEFAULTCOLOR);
    if (bigIcon) SendMessageW(hwnd, WM_SETICON, ICON_BIG, (LPARAM)bigIcon);
    if (smallIcon) SendMessageW(hwnd, WM_SETICON, ICON_SMALL, (LPARAM)smallIcon);
    font = CreateFontW(-15, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, DEFAULT_CHARSET,
                       OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS, CLEARTYPE_QUALITY, DEFAULT_PITCH, L"Microsoft YaHei UI");
    boldFont = CreateFontW(-16, 0, 0, 0, FW_BOLD, FALSE, FALSE, FALSE, DEFAULT_CHARSET,
                            OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS, CLEARTYPE_QUALITY, DEFAULT_PITCH, L"Microsoft YaHei UI");
    richEditLib = LoadLibraryW(L"Msftedit.dll");
    addControls();
    loadSettings();
    DragAcceptFiles(hwnd, TRUE);
    ShowWindow(hwnd, SW_SHOW);
    UpdateWindow(hwnd);
    return true;
}

static HWND button(HWND p, const wchar_t* text, int id) {
    HWND h = make(p, L"BUTTON", text, WS_TABSTOP | BS_PUSHBUTTON, id);
    return h;
}

static HWND checkbox(HWND p, const wchar_t* text, int id, bool checked) {
    HWND h = make(p, L"BUTTON", text, WS_TABSTOP | BS_AUTOCHECKBOX, id);
    SendMessageW(h, BM_SETCHECK, checked ? BST_CHECKED : BST_UNCHECKED, 0);
    return h;
}

static HWND radio(HWND p, const wchar_t* text, int id, bool checked) {
    HWND h = make(p, L"BUTTON", text, WS_TABSTOP | BS_AUTORADIOBUTTON, id);
    SendMessageW(h, BM_SETCHECK, checked ? BST_CHECKED : BST_UNCHECKED, 0);
    return h;
}

static HWND radioFirst(HWND p, const wchar_t* text, int id, bool checked) {
    HWND h = make(p, L"BUTTON", text, WS_TABSTOP | WS_GROUP | BS_AUTORADIOBUTTON, id);
    SendMessageW(h, BM_SETCHECK, checked ? BST_CHECKED : BST_UNCHECKED, 0);
    return h;
}

static HWND groupBox(HWND p, const wchar_t* text, int id) {
    return make(p, L"BUTTON", text, BS_GROUPBOX, id);
}

void App::addControls() {
    setFont(button(hwnd, L"🔧 正常处理", ID_BTN_NORMAL), boldFont);
    setFont(button(hwnd, L"🚀 合并处理", ID_BTN_MERGE), boldFont);
    setFont(button(hwnd, L"👁 预览", ID_BTN_PREVIEW), boldFont);
    setFont(button(hwnd, L"📌 置顶", ID_BTN_TOPMOST), boldFont);
    status = make(hwnd, L"STATIC", L"拖入 .ptp 文件或文件夹开始", SS_RIGHT, 0);
    setFont(status, font);

    setFont(button(hwnd, L"➕ 添加文件", ID_BTN_ADD_FILES), font);
    setFont(button(hwnd, L"📁 添加文件夹", ID_BTN_ADD_FOLDER), font);
    setFont(button(hwnd, L"↑ 上移", ID_BTN_UP), font);
    setFont(button(hwnd, L"↓ 下移", ID_BTN_DOWN), font);
    setFont(button(hwnd, L"✕ 删除", ID_BTN_REMOVE), font);
    setFont(button(hwnd, L"清空", ID_BTN_CLEAR), font);

    list = make(hwnd, L"LISTBOX", L"", WS_BORDER | LBS_EXTENDEDSEL | WS_VSCROLL | LBS_NOINTEGRALHEIGHT, ID_LIST_FILES);
    setFont(list, font);
    setFont(checkbox(hwnd, L"允许 H / HH 合并文件", ID_ALLOW_HH, false), font);
    setFont(checkbox(hwnd, L"飞刀过滤", ID_FILTER_TRY, true), font);

    setFont(checkbox(hwnd, L"合并头部砍 G49 G80", ID_STRIP, true), font);
    setFont(checkbox(hwnd, L"开机写 G28 G91 Z0.0", ID_OPEN_G28, true), font);
    setFont(checkbox(hwnd, L"末段 G28 写双 Z+Y", ID_END_DUAL, true), font);
    setFont(checkbox(hwnd, L"HH 版去 G1 F4000 加尾空格", ID_HH_STRIP, true), font);
    setFont(checkbox(hwnd, L"H 版每段 G43 补 G1 F4000", ID_H_FORCE, true), font);
    setFont(checkbox(hwnd, L"正常处理: 跨行 G43 缝合", ID_CROSS_G43, true), font);
    setFont(checkbox(hwnd, L"G54/G56 双坐标模式", ID_G54G56_MODE, false), font);
    setFont(radioFirst(hwnd, L"不抬Z", ID_G54G56_LIFT_OFF, false), font);
    setFont(radio(hwnd, L"Z50", ID_G54G56_LIFT_50, false), font);
    setFont(radio(hwnd, L"Z100", ID_G54G56_LIFT_100, true), font);

    setFont(groupBox(hwnd, L"基础处理", ID_GROUP_HEAD), boldFont);
    setFont(groupBox(hwnd, L"段顺序", ID_GROUP_SORT), boldFont);
    setFont(groupBox(hwnd, L"飞刀 / 备刀", ID_GROUP_TOOL), boldFont);
    setFont(groupBox(hwnd, L"G54 / G56", ID_GROUP_PARAMS), boldFont);

    setFont(radioFirst(hwnd, L"H 号升序", ID_SORT_H, true), font);
    setFont(radio(hwnd, L"按文件添加顺序", ID_SORT_FILE, false), font);
    setFont(radio(hwnd, L"Z 接力全局排", ID_SORT_Z_GLOBAL, false), font);
    setFont(radio(hwnd, L"同 XY 簇内 Z 排", ID_SORT_Z_CLUSTER, false), font);
    setFont(radio(hwnd, L"智能选主批次", ID_SORT_SMART, false), font);

    setFont(checkbox(hwnd, L"末尾追加飞刀(-11)", ID_APPEND_TRY, false), font);
    setFont(radioFirst(hwnd, L"隔一把提前备刀", ID_PRE_LEGACY, true), font);
    setFont(radio(hwnd, L"不提前备刀", ID_PRE_OFF, false), font);
    setFont(radio(hwnd, L"换刀后备下一把", ID_PRE_NEXT, false), font);
    setFont(radio(hwnd, L"循环加工备首刀", ID_PRE_RING, false), font);
    HWND trailing = make(hwnd, L"EDIT", L"1", WS_BORDER | ES_NUMBER, ID_TRAILING);
    setFont(trailing, font);
    HWND tmap = make(hwnd, L"EDIT", L"", WS_BORDER | ES_AUTOHSCROLL, ID_TMAP);
    setFont(tmap, font);
    HWND multiWcs = make(hwnd, L"EDIT", L"G54:0,G56:10", WS_BORDER | ES_AUTOHSCROLL, ID_MULTI_WCS_CONFIG);
    setFont(multiWcs, font);
    setFont(checkbox(hwnd, L"坐标偏移补偿(默认关)", ID_EXP_COMP_ENABLE, false), font);
    setFont(checkbox(hwnd, L"G41 刀损补偿", ID_SIDE_COMP_ENABLE, false), font);
    HWND expComp = make(hwnd, L"EDIT", L"", WS_BORDER | ES_AUTOHSCROLL, ID_EXP_COMP_CONFIG);
    setFont(expComp, font);
    setFont(make(hwnd, L"STATIC", L"% 后空行数:", SS_LEFT | SS_NOTIFY, ID_LABEL_TRAILING), font);
    HWND multiWcs = make(hwnd, L"EDIT", L"G54:0,G56:10", WS_BORDER | ES_AUTOHSCROLL, ID_MULTI_WCS_CONFIG);
    setFont(multiWcs, font);
    setFont(checkbox(hwnd, L"坐标偏移补偿", ID_EXP_COMP_ENABLE, false), font);
    setFont(checkbox(hwnd, L"G41 刀损补偿", ID_SIDE_COMP_ENABLE, false), font);

    // M00暂停选项 (三个单选)
    setFont(radioFirst(hwnd, L"不加 M00 暂停", ID_M00_WAIT_OFF, true), font);
    setFont(radio(hwnd, L"每次换刀后暂停", ID_M00_WAIT_ALL, false), font);
    setFont(radio(hwnd, L"钻孔刀换刀后暂停", ID_M00_WAIT_DRILL, false), font);

    // 2026-06-04 13:13 版：不再暴露 G41 五档滑块，避免现场误选复杂策略。
    // G41 开启后固定使用“平衡”策略：G0/固定循环/圆弧/停机前先 G40。
    setFont(make(hwnd, L"STATIC", L"G41策略：固定平衡 - 危险动作前关G40", SS_LEFT | SS_NOTIFY, ID_G41_RISK_TEXT), font);

    HWND expComp = make(hwnd, L"EDIT", L"", WS_BORDER | ES_AUTOHSCROLL, ID_EXP_COMP_CONFIG);
    setFont(expComp, font);
    setFont(make(hwnd, L"STATIC", L"% 后空行数:", SS_LEFT | SS_NOTIFY, ID_LABEL_TRAILING), font);
    setFont(make(hwnd, L"STATIC", L"刀名→T:", SS_LEFT | SS_NOTIFY, ID_LABEL_TMAP), font);
    setFont(checkbox(hwnd, L"兼容: 不提前选刀", ID_G54G56_NO_PRESELECT, false), font);
    setFont(checkbox(hwnd, L"新手模式", ID_NOVICE, true), font);
    setFont(groupBox(hwnd, L"车间防错 / 发布前检查", ID_GROUP_SAFETY), boldFont);
    setFont(checkbox(hwnd, L"启用安全审计报告", ID_SAFETY_AUDIT_ENABLE, false), font);
    setFont(checkbox(hwnd, L"严格模式: 有风险时报错", ID_SAFETY_AUDIT_STRICT, false), font);
    setFont(checkbox(hwnd, L"发布前输入预检", ID_SHOP_PRECHECK_INPUT, false), font);
    setFont(checkbox(hwnd, L"H/D/T/WCS/M00 汇总预览", ID_SHOP_KEYWORD_PREVIEW, false), font);
    setFont(checkbox(hwnd, L"坐标补偿 Dry-run 明细", ID_SHOP_COORD_DRY_RUN, false), font);
    setFont(checkbox(hwnd, L"G41/G40 包络报告", ID_SHOP_G41_ENVELOPE, false), font);
    setFont(checkbox(hwnd, L"输出前自动备份", ID_SHOP_AUTO_BACKUP, false), font);
    setFont(checkbox(hwnd, L"配置快照/版本留痕", ID_SHOP_CONFIG_SNAPSHOT, false), font);
    setFont(groupBox(hwnd, L"机床 / 工艺配置模板", ID_GROUP_TEMPLATE), boldFont);
    HWND tmpl = make(hwnd, WC_COMBOBOXW, L"", WS_TABSTOP | CBS_DROPDOWNLIST | WS_VSCROLL, ID_TEMPLATE_COMBO);
    setFont(tmpl, font);
    const wchar_t* templates[] = {L"选择模板...", L"M70默认安全", L"G54/G56 H+10", L"多工位 G54/G56/G55", L"钻孔刀暂停", L"老师傅兼容"};
    for (const wchar_t* item : templates) SendMessageW(tmpl, CB_ADDSTRING, 0, (LPARAM)item);
    SendMessageW(tmpl, CB_SETCURSEL, 0, 0);
    setFont(button(hwnd, L"套用模板", ID_BTN_TEMPLATE_APPLY), font);
    setFont(checkbox(hwnd, L"检查坐标补偿上限", ID_COMP_LIMIT_ENABLE, false), font);
    HWND compLimit = make(hwnd, L"EDIT", L"0.10", WS_BORDER | ES_AUTOHSCROLL, ID_COMP_LIMIT_VALUE);
    setFont(compLimit, font);
    setFont(button(hwnd, L"立即预检 / 生成报告", ID_BTN_SAFETY_REPORT), font);

    tabs = make(hwnd, WC_TABCONTROLW, L"", WS_CLIPSIBLINGS | WS_TABSTOP, ID_TABS);
    setFont(tabs, font);
    const wchar_t* names[] = {L"正常处理预览", L"H 版预览", L"HH 版预览", L"安全审计报告", L"日志"};
    for (int i = 0; i < 5; ++i) {
        TCITEMW item{};
        item.mask = TCIF_TEXT;
        item.pszText = const_cast<wchar_t*>(names[i]);
        TabCtrl_InsertItem(tabs, i, &item);
    }
    auto editStyle = WS_BORDER | ES_MULTILINE | ES_AUTOVSCROLL | ES_AUTOHSCROLL | WS_VSCROLL | WS_HSCROLL | ES_READONLY;
    const wchar_t* textClass = richEditLib ? MSFTEDIT_CLASS : L"EDIT";
    txtNormal = make(hwnd, textClass, L"", editStyle, ID_TEXT_NORMAL);
    txtH = make(hwnd, textClass, L"", editStyle, ID_TEXT_H);
    txtHH = make(hwnd, textClass, L"", editStyle, ID_TEXT_HH);
    txtLog = make(hwnd, textClass, L"", editStyle, ID_TEXT_LOG);
    txtSafety = make(hwnd, textClass, L"", editStyle, ID_TEXT_LOG + 100);
    for (HWND h : {txtNormal, txtH, txtHH, txtSafety, txtLog}) setFont(h, font);
    addTooltips();
    refreshText();
}

void App::addTooltip(int id, const char* text) {
    if (!text || !*text) return;
    HWND control = GetDlgItem(hwnd, id);
    if (!control) return;
    bool firstRegister = tooltipTexts.find(control) == tooltipTexts.end();
    tooltipTexts[control] = widen(text);
    if (!firstRegister) return;
    tooltipOrder.push_back(control);
    SetWindowSubclass(control, [](HWND h, UINT msg, WPARAM w, LPARAM l, UINT_PTR, DWORD_PTR refData) -> LRESULT {
        App* app = reinterpret_cast<App*>(refData);
        if (app) {
            switch (msg) {
            case WM_MOUSEMOVE:
            case WM_MOUSELEAVE:
            case WM_LBUTTONDOWN:
            case WM_RBUTTONDOWN:
            case WM_KEYDOWN:
            case WM_DESTROY:
                app->onToolMouse(h, msg);
                break;
            }
        }
        return DefSubclassProc(h, msg, w, l);
    }, 1, reinterpret_cast<DWORD_PTR>(this));
}

void App::addTooltips() {
    tooltip = CreateWindowExW(
        WS_EX_TOPMOST | WS_EX_TOOLWINDOW | WS_EX_NOACTIVATE,
        L"STATIC", nullptr, WS_POPUP | WS_BORDER | SS_LEFT,
        CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,
        nullptr, nullptr, GetModuleHandleW(nullptr), nullptr);
    tooltipText = tooltip;
    if (tooltipText) setFont(tooltipText, font);
    for (const auto& def : tooltipDefs()) addTooltip(def.id, def.text);
    addTooltip(ID_G54G56_MODE, "多坐标模式：开启后同一把刀按多坐标配置依次加工各工位，再换下一把刀；默认配置 G54:0,G56:10。此处只表达工艺配置，不暴露内部兼容开关。");
    addTooltip(ID_MULTI_WCS_CONFIG, "多坐标配置：格式为 G54:0,G56:10,G55:20，冒号后是该坐标系使用的 H 号偏移；例如原 H02 在 G56:10 下输出 H12。顺序就是加工顺序。");
    addTooltip(ID_G54G56_LIFT_OFF, "坐标切换不抬 Z：多坐标模式下，从一个坐标系移动到下一个坐标系前不额外改写收尾 Z。");
    addTooltip(ID_G54G56_LIFT_50, "坐标切换抬 Z50：多坐标模式下，从一个坐标系移动到下一个坐标系前，把上一段最后的退刀 Z 改为 Z50.。");
    addTooltip(ID_G54G56_LIFT_100, "坐标切换抬 Z100：多坐标模式下，从一个坐标系移动到下一个坐标系前，把上一段最后的退刀 Z 改为 Z100.。");
    addTooltip(ID_EXP_COMP_ENABLE, "坐标偏移补偿：按坐标系对输出的 X/Y/Z 数值做加减微调，作用于该坐标系下的定位与加工坐标。它不是 G41 刀具半径补偿，也不会改 H/D 刀补号。常用场景：同一程序在 G56 工位整体向 X+0.02、Y-0.01 修正；或某工位 Z 整体补 +0.03。开启前必须确认单位为当前程序单位，正式加工前逐行复核。未勾选时完全不改坐标。");
    addTooltip(ID_SIDE_COMP_ENABLE, "G41 刀损补偿：开启后自动插入 G41 D当前H。下方滑块决定自动 G40 的保守程度：越靠左越少关补偿、加工越快但越危险；越靠右越早关补偿、M70 干涉风险越低但动作更碎。正式上机前建议配合 G41/G40 包络报告复核。");
    addTooltip(ID_EXP_COMP_CONFIG, "坐标偏移参数填写完整格式：坐标系:轴和值:轴和值；多坐标系用分号分隔。例1：G56:X0.02:Y-0.01:Z0，表示只对 G56 输出 X 加 0.02、Y 减 0.01、Z 不变。例2：G54:X0:Y0:Z0;G56:X0.02:Y-0.01:Z0;G55:X-0.03:Y0:Z0.02。可只写需要的轴，如 G56:X0.02；未填写的坐标系不补偿。数值是叠加量，不是绝对坐标。建议配合下方安全审计里的“检查坐标补偿上限”。");
    addTooltip(ID_M00_WAIT_OFF, "不加 M00 暂停：合并输出中不插入 M00。适合确认程序可连续加工时使用。");
    addTooltip(ID_M00_WAIT_ALL, "每次换刀后暂停：第一把刀不暂停；从第二把刀开始，每次 Tn M06 后、预选下一把 T 后插入 M00。只对合并输出生效。");
    addTooltip(ID_M00_WAIT_DRILL, "钻孔刀换刀后暂停：第一把刀不暂停；从第二把刀开始，只有该刀程序含 G81-G89 固定循环时，才在 Tn M06 和预选 T 后插入 M00。只对合并输出生效。");
    addTooltip(ID_G41_RISK_TEXT, "G41 刀损补偿采用固定平衡策略：只在 G1 且含 XY、不是固定循环/圆弧/G28/M30 时建立 G41 D当前H；遇 G0、G81-G89 固定循环、G2/G3 圆弧、M05/M09/G28/M30 前先输出 G40。已取消五档滑块，避免现场误选过快或过慢策略。");
    addTooltip(ID_SAFETY_AUDIT_ENABLE, "车间防错 / 发布前检查总开关：合并时自动写报告；也可点“立即预检”。报告不改写 NC。默认不启用。");
    addTooltip(ID_SAFETY_AUDIT_STRICT, "严格模式：审计报告发现 FATAL/ERROR 风险时，CLI 返回非零；GUI 仍显示报告并要求人工确认。默认不启用。");
    addTooltip(ID_SHOP_PRECHECK_INPUT, "发布前输入预检：检查缺 Tool、缺 G43/H、缺首个 G0、缺 M30、已合并 H/HH 混入、飞刀/试刀、坐标补偿超限等。默认关闭。");
    addTooltip(ID_SHOP_KEYWORD_PREVIEW, "H/D/T/WCS/M00 汇总预览：在报告里列出每段刀号、H/D、坐标系、钻孔、M00 策略，方便上机前快速复核。默认关闭。");
    addTooltip(ID_SHOP_COORD_DRY_RUN, "坐标补偿 Dry-run 明细：只预览坐标偏移会把哪些 G0/G1/G81-G89 行从原坐标改成新坐标，不写 NC，不强行添加原行没有的轴。默认关闭。");
    addTooltip(ID_SHOP_G41_ENVELOPE, "G41/G40 包络报告：列出每个 G41 段开始/结束，并标记 G41 内出现 G0、纯Z、固定循环、M05/M09/G28/M30 的高风险段。默认关闭。");
    addTooltip(ID_SHOP_AUTO_BACKUP, "输出前自动备份：合并覆盖旧 H/HH 前，把已存在的目标文件复制到 ok/_backup，文件名带时间戳。默认关闭。");
    addTooltip(ID_SHOP_CONFIG_SNAPSHOT, "配置快照/版本留痕：合并输出时写 ok/_run_config.txt，记录当前关键选项、输入文件和程序标题/版本。默认关闭。");
    addTooltip(ID_TEMPLATE_COMBO, "机床 / 工艺配置模板：选择常用安全组合后点“套用模板”。只改当前界面勾选项，不会立刻写 NC；套用后仍可手动调整。包含 M70默认安全、G54/G56 H+10、多工位、钻孔刀暂停、老师傅兼容。");
    addTooltip(ID_SHOP_CONFIG_SNAPSHOT, "配置快照/版本留痕：合并输出时写 ok/_run_config.txt，记录当前关键选项、输入文件和程序标题/版本。默认关闭。");
    addTooltip(ID_TEMPLATE_COMBO, "机床 / 工艺配置模板：选择常用安全组合后点“套用模板”。只改当前界面勾选项，不会立刻写 NC；套用后仍可手动调整。包含 M70默认安全、G54/G56 H+10、多工位、钻孔刀暂停、老师傅兼容。");
    addTooltip(ID_BTN_TEMPLATE_APPLY, "套用模板：把所选模板写入当前 UI 选项。模板不会自动执行处理；请预览/报告复核后再合并。");
    addTooltip(ID_COMP_LIMIT_ENABLE, "检查坐标补偿上限：默认关闭，只在安全审计中检查，不会改 NC。勾选后，若坐标偏移配置中任一 X/Y/Z 绝对值超过右侧上限，非严格报告 WARN，严格报告 ERROR；等于上限允许。完整例子：上限 0.10，G56:X0.10:Y-0.10:Z0 通过；G56:X0.101:Y0:Z0 超限。");
    addTooltip(ID_COMP_LIMIT_VALUE, "坐标补偿上限：填写允许的最大绝对补偿量，单位按当前 NC 程序单位理解。例：0.10 表示 X/Y/Z 任一轴补偿超过 ±0.10 才提示；0 表示任何非零补偿都提示。配置示例：G56:X0.02:Y-0.01:Z0 通过；G55:X-0.12:Y0:Z0 超限。默认 0.10，未勾选时不生效。");
    addTooltip(ID_BTN_SAFETY_REPORT, "生成安全审计报告：按当前列表和当前选项生成预检报告，显示在“安全审计报告”页，并写入 ok/_safety_report.txt。");
}

void App::onToolMouse(HWND tool, UINT msg) {
    if (!tooltipsEnabled()) return;
    if (!tooltipTexts.contains(tool)) return;
    if (msg == WM_MOUSEMOVE) {
        bool changed = hoverTool != tool;
        if (hoverTool != tool) {
            hideTooltip();
            hoverTool = tool;
            hoverTracking = false;
        }
        if (!hoverTracking) {
            TRACKMOUSEEVENT tme{};
            tme.cbSize = sizeof(tme);
            tme.dwFlags = TME_LEAVE;
            tme.hwndTrack = tool;
            hoverTracking = TrackMouseEvent(&tme) == TRUE;
        }
        if (changed || !IsWindowVisible(tooltip)) SetTimer(hwnd, TOOLTIP_TIMER_ID, 450, nullptr);
        tooltipPending = true;
        return;
    }
    if (hoverTool == tool) {
        hideTooltip();
        hoverTracking = false;
    }
}

std::wstring App::tooltipTextForTool(HWND tool) {
    if (!tool) return L"";
    auto it = tooltipTexts.find(tool);
    if (it != tooltipTexts.end()) return it->second;
    int id = GetDlgCtrlID(tool);
    if (const char* text = tooltipUtf8ForId(id)) return widen(text);
    return L"";
}

HWND App::toolAtPoint(POINT pt) {
    for (auto it = tooltipOrder.rbegin(); it != tooltipOrder.rend(); ++it) {
        HWND candidate = *it;
        if (!candidate || !IsWindow(candidate) || !IsWindowVisible(candidate)) continue;
        RECT rc{};
        if (!GetWindowRect(candidate, &rc)) continue;
        if (PtInRect(&rc, pt) && !tooltipTextForTool(candidate).empty()) return candidate;
    }

    HWND hit = WindowFromPoint(pt);
    if (!hit || (hit != hwnd && !IsChild(hwnd, hit))) return nullptr;
    HWND cur = hit;
    while (cur && cur != hwnd) {
        if (!tooltipTextForTool(cur).empty()) return cur;
        cur = GetParent(cur);
    }
    return nullptr;
}

void App::pollHover() {
    if (!tooltipsEnabled()) return;
    if (!hwnd || !IsWindowVisible(hwnd)) return;
    POINT pt{};
    if (!getCursorPoint(pt)) return;

    if (tooltip && IsWindowVisible(tooltip)) {
        RECT tipRc{};
        GetWindowRect(tooltip, &tipRc);
        if (PtInRect(&tipRc, pt)) return;
    }

    HWND tool = toolAtPoint(pt);
    if (!tool) {
        if (hoverTool) hideTooltip();
        return;
    }

    if (hoverTool != tool) {
        hideTooltip();
        hoverTool = tool;
        tooltipPending = true;
        SetTimer(hwnd, TOOLTIP_TIMER_ID, 450, nullptr);
    }
}

void App::showTooltip() {
    if (!tooltipsEnabled()) return;
    if (!tooltip) {
        tooltip = CreateWindowExW(
            WS_EX_TOPMOST | WS_EX_TOOLWINDOW | WS_EX_NOACTIVATE,
            L"STATIC", nullptr, WS_POPUP | WS_BORDER | SS_LEFT,
            CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,
            nullptr, nullptr, GetModuleHandleW(nullptr), nullptr);
        tooltipText = tooltip;
        if (tooltipText) setFont(tooltipText, font);
    }
    POINT pt{};
    if (!getCursorPoint(pt)) {
        RECT toolRc{};
        if (!hoverTool || !GetWindowRect(hoverTool, &toolRc)) return;
        pt.x = toolRc.left;
        pt.y = toolRc.bottom;
    }
    if (!hoverTool || !IsWindow(hoverTool)) hoverTool = toolAtPoint(pt);
    if (!hoverTool || !tooltip || !IsWindow(hoverTool)) return;
    std::wstring tipText = tooltipTextForTool(hoverTool);
    if (tipText.empty()) {
        hoverTool = toolAtPoint(pt);
        tipText = tooltipTextForTool(hoverTool);
    }
    if (tipText.empty()) return;
    tooltipPending = false;

    SetWindowTextW(tooltipText, tipText.c_str());
    HDC dc = GetDC(tooltipText);
    RECT textRc{0, 0, 440, 0};
    HFONT old = (HFONT)SelectObject(dc, font);
    DrawTextW(dc, tipText.c_str(), -1, &textRc, DT_CALCRECT | DT_LEFT | DT_WORDBREAK);
    SelectObject(dc, old);
    ReleaseDC(tooltipText, dc);

    int measuredW = static_cast<int>(textRc.right - textRc.left + 24);
    int measuredH = static_cast<int>(textRc.bottom - textRc.top + 18);
    int tipW = std::max(180, std::min(460, measuredW));
    int tipH = std::max(34, measuredH);

    int x = pt.x + 18;
    int y = pt.y + 22;
    HMONITOR mon = MonitorFromPoint(pt, MONITOR_DEFAULTTONEAREST);
    MONITORINFO mi{};
    mi.cbSize = sizeof(mi);
    if (GetMonitorInfoW(mon, &mi)) {
        int maxH = std::max(34, (int)(mi.rcWork.bottom - mi.rcWork.top - 24));
        tipH = std::min(tipH, maxH);
        if (x + tipW > mi.rcWork.right) x = pt.x - tipW - 18;
        if (x < mi.rcWork.left) x = mi.rcWork.left;
        if (y + tipH > mi.rcWork.bottom) y = pt.y - tipH - 18;
        if (y < mi.rcWork.top) y = mi.rcWork.top;
    }
    SetWindowPos(tooltip, HWND_TOPMOST, x, y, tipW, tipH,
                 SWP_NOACTIVATE | SWP_SHOWWINDOW);
}

void App::hideTooltip() {
    KillTimer(hwnd, TOOLTIP_TIMER_ID);
    tooltipPending = false;
    if (tooltip) ShowWindow(tooltip, SW_HIDE);
}

bool App::tooltipsEnabled() const {
    HWND novice = GetDlgItem(hwnd, ID_NOVICE);
    return !tooltipPaused && novice && SendMessageW(novice, BM_GETCHECK, 0, 0) == BST_CHECKED;
}

void App::pauseTooltips() {
    tooltipPaused = true;
    KillTimer(hwnd, HOVER_POLL_TIMER_ID);
    hideTooltip();
}

void App::resumeTooltips() {
    tooltipPaused = false;
    if (hwnd) SetTimer(hwnd, HOVER_POLL_TIMER_ID, 200, nullptr);
}

static void mv(HWND parent, int id, int x, int y, int w, int h) {
    MoveWindow(GetDlgItem(parent, id), x, y, w, h, TRUE);
}

void App::layout(int w, int h) {
    const int margin = 14;
    const int gap = 8;
    int x = margin, y = 10;
    int bw = 154, bh = 44;
    mv(hwnd, ID_BTN_NORMAL, x, y, bw, bh); x += bw + gap;
    mv(hwnd, ID_BTN_MERGE, x, y, bw, bh); x += bw + gap;
    mv(hwnd, ID_BTN_PREVIEW, x, y, bw, bh); x += bw + gap;
    mv(hwnd, ID_BTN_TOPMOST, x, y, bw, bh);
    MoveWindow(status, w - 374, y + 10, 360, 24, TRUE);

    y += 58; x = margin;
    mv(hwnd, ID_BTN_ADD_FILES, x, y, 112, 28); x += 112 + gap;
    mv(hwnd, ID_BTN_ADD_FOLDER, x, y, 126, 28); x += 126 + gap;
    mv(hwnd, ID_BTN_UP, x, y, 70, 28); x += 70 + gap;
    mv(hwnd, ID_BTN_DOWN, x, y, 70, 28); x += 70 + gap;
    mv(hwnd, ID_BTN_REMOVE, x, y, 76, 28); x += 76 + gap;
    mv(hwnd, ID_BTN_CLEAR, x, y, 76, 28);
    y += 34;
    MoveWindow(list, margin, y, w - margin * 2, 120, TRUE);
    y += 126;
    mv(hwnd, ID_ALLOW_HH, margin, y, 190, 24);
    mv(hwnd, ID_FILTER_TRY, margin + 208, y, 110, 24);
    const int paramLabelW = 94;
    int paramX = margin + 338;
    mv(hwnd, ID_LABEL_TRAILING, paramX, y + 3, paramLabelW, 22);
    mv(hwnd, ID_TRAILING, paramX + paramLabelW + 6, y, 54, 24);
    paramX += paramLabelW + 6 + 54 + 22;
    mv(hwnd, ID_LABEL_TMAP, paramX, y + 3, 70, 22);
    mv(hwnd, ID_TMAP, paramX + 70 + 6, y, std::max(170, w - (paramX + 70 + 6) - margin), 24);
    int groupH = 306;
    int yy = y;
    int line = 24;
    mv(hwnd, ID_GROUP_HEAD, c1, yy, colW, groupH);
    mv(hwnd, ID_GROUP_SORT, c2, yy, colW, groupH);
    mv(hwnd, ID_GROUP_TOOL, c3, yy, colW, groupH);
    mv(hwnd, ID_GROUP_PARAMS, c4, yy, colW, groupH);
    for (int id : {ID_GROUP_HEAD, ID_GROUP_SORT, ID_GROUP_TOOL, ID_GROUP_PARAMS}) {
        SetWindowPos(GetDlgItem(hwnd, id), HWND_BOTTOM, 0, 0, 0, 0,
                     SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE);
    }
    const int padX = 12;
    const int padTop = 24;
    const int innerW = colW - padX * 2;
    yy = y + padTop;
    int ids1[] = {ID_STRIP, ID_OPEN_G28, ID_END_DUAL, ID_HH_STRIP, ID_H_FORCE, ID_CROSS_G43};
    for (int id : ids1) { mv(hwnd, id, c1 + padX, yy, innerW, line); yy += line; }
    mv(hwnd, ID_SILENT, c1 + padX, yy + 4, innerW, line); yy += line;
    mv(hwnd, ID_NOVICE, c1 + padX, yy + 4, innerW, line);
    yy = y + padTop;
    int ids2[] = {ID_SORT_H, ID_SORT_FILE, ID_SORT_Z_GLOBAL, ID_SORT_Z_CLUSTER, ID_SORT_SMART};
    for (int id : ids2) { mv(hwnd, id, c2 + padX, yy, innerW, line); yy += line; }
    yy = y + padTop;
    mv(hwnd, ID_APPEND_TRY, c3 + padX, yy, innerW, line); yy += line + 8;
    int ids3[] = {ID_PRE_LEGACY, ID_PRE_OFF, ID_PRE_NEXT, ID_PRE_RING};
    for (int id : ids3) { mv(hwnd, id, c3 + padX, yy, innerW, line); yy += line; }
    yy += 8;
    int idsM00[] = {ID_M00_WAIT_OFF, ID_M00_WAIT_ALL, ID_M00_WAIT_DRILL};
    for (int id : idsM00) { mv(hwnd, id, c3 + padX, yy, innerW, line); yy += line; }
    yy = y + padTop;
    mv(hwnd, ID_G54G56_MODE, c4 + padX, yy, innerW, line); yy += line;
    mv(hwnd, ID_MULTI_WCS_CONFIG, c4 + padX, yy, innerW, line); yy += line + 8;
    int thirdW = (innerW - gap * 2) / 3;
    mv(hwnd, ID_G54G56_LIFT_OFF, c4 + padX, yy, thirdW, line);
    mv(hwnd, ID_G54G56_LIFT_50, c4 + padX + thirdW + gap, yy, thirdW, line);
    mv(hwnd, ID_G54G56_LIFT_100, c4 + padX + (thirdW + gap) * 2, yy, thirdW, line); yy += line + 8;
    mv(hwnd, ID_EXP_COMP_ENABLE, c4 + padX, yy, innerW, line); yy += line;
    mv(hwnd, ID_EXP_COMP_CONFIG, c4 + padX + 14, yy, innerW - 14, line); yy += line + 8;
    mv(hwnd, ID_SIDE_COMP_ENABLE, c4 + padX, yy, innerW, line); yy += line;
    mv(hwnd, ID_G41_CLOSE_ADAPTIVE, c4 + padX + 14, yy, innerW - 14, line); yy += line;
    mv(hwnd, ID_G41_CLOSE_SEGMENT, c4 + padX + 14, yy, innerW - 14, line);

    y += groupH + 12;

    mv(hwnd, ID_G54G56_LIFT_OFF, c4 + padX, yy, thirdW, line);
    mv(hwnd, ID_G54G56_LIFT_50, c4 + padX + thirdW + gap, yy, thirdW, line);
    mv(hwnd, ID_G54G56_LIFT_100, c4 + padX + (thirdW + gap) * 2, yy, thirdW, line); yy += line + 8;
    mv(hwnd, ID_G54G56_PRETTY, c4 + padX, yy, halfW, line); yy += line;

    mv(hwnd, ID_SIDE_COMP_ENABLE, c4 + padX, yy, innerW, line); yy += line;
    mv(hwnd, ID_G41_RISK_TEXT, c4 + padX + 14, yy, innerW - 14, line); yy += line + 8;

    y += groupH + 12;
    int templateH = 54;
    mv(hwnd, ID_GROUP_TEMPLATE, margin, y, w - margin * 2, templateH);
    SetWindowPos(GetDlgItem(hwnd, ID_GROUP_TEMPLATE), HWND_BOTTOM, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE);
    mv(hwnd, ID_TEMPLATE_COMBO, margin + 12, y + 22, 260, 240);
    mv(hwnd, ID_BTN_TEMPLATE_APPLY, margin + 286, y + 18, 110, 28);
    y += templateH + 8;
    int safetyH = 126;
    mv(hwnd, ID_GROUP_SAFETY, margin, y, w - margin * 2, safetyH);
    SetWindowPos(GetDlgItem(hwnd, ID_GROUP_SAFETY), HWND_BOTTOM, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE);
    int sx = margin + 12;
    int sy = y + 22;
    mv(hwnd, ID_SAFETY_AUDIT_ENABLE, sx, sy, 160, 24);
    mv(hwnd, ID_SAFETY_AUDIT_STRICT, sx + 178, sy, 190, 24);
    mv(hwnd, ID_BTN_SAFETY_REPORT, sx + 390, sy - 4, 180, 28);
    mv(hwnd, ID_COMP_LIMIT_ENABLE, sx + 590, sy, 160, 24);
    mv(hwnd, ID_COMP_LIMIT_VALUE, sx + 760, sy, 80, 24);
    sy += 28;
    mv(hwnd, ID_SHOP_PRECHECK_INPUT, sx, sy, 170, 24);
    mv(hwnd, ID_SHOP_KEYWORD_PREVIEW, sx + 190, sy, 220, 24);
    mv(hwnd, ID_SHOP_COORD_DRY_RUN, sx + 430, sy, 210, 24);
    sy += 28;
    mv(hwnd, ID_SHOP_G41_ENVELOPE, sx, sy, 180, 24);
    mv(hwnd, ID_SHOP_AUTO_BACKUP, sx + 190, sy, 170, 24);
    mv(hwnd, ID_SHOP_CONFIG_SNAPSHOT, sx + 380, sy, 180, 24);
    y += safetyH + 10;
    MoveWindow(tabs, margin, y, w - margin * 2, h - y - margin, TRUE);
    RECT tr; GetClientRect(tabs, &tr);
    TabCtrl_AdjustRect(tabs, FALSE, &tr);
    MapWindowPoints(tabs, hwnd, (POINT*)&tr, 2);
    for (HWND ed : {txtNormal, txtH, txtHH, txtSafety, txtLog}) MoveWindow(ed, tr.left + 4, tr.top + 4, tr.right - tr.left - 8, tr.bottom - tr.top - 8, TRUE);
    updateTabVisibility();
}

static bool checked(HWND parent, int id) {
    return SendMessageW(GetDlgItem(parent, id), BM_GETCHECK, 0, 0) == BST_CHECKED;
}

static void writeCliWarning(const std::string& message) {
    DWORD written = 0;
    HANDLE err = GetStdHandle(STD_ERROR_HANDLE);
    if (err && err != INVALID_HANDLE_VALUE) {
        WriteFile(err, message.data(), (DWORD)message.size(), &written, nullptr);
    }
    std::cerr << message;
}

static void applyG41RiskCliOption(std::string& g41CloseStrategy, const std::wstring& value) {
    std::string risk = upperAscii(narrowUtf8(value));
    if (risk == "0" || risk == "EXTREME" || risk == "DANGER") g41CloseStrategy = G41_RISK_EXTREME;
    else if (risk == "1" || risk == "FAST") g41CloseStrategy = G41_RISK_FAST;
    else if (risk == "2" || risk == "BALANCED") g41CloseStrategy = G41_RISK_BALANCED;
    else if (risk == "3" || risk == "SAFE") g41CloseStrategy = G41_RISK_SAFE;
    else if (risk == "4" || risk == "SAFEST") g41CloseStrategy = G41_RISK_SAFEST;
    else throw std::runtime_error("未知 G41 策略: " + risk);
}

static void applyMergeCliOptions(MergeOptions& opts, const std::vector<std::wstring>& args, size_t start) {
    for (size_t i = start; i < args.size(); ++i) {
        else if (args[i] == L"--g54g56-no-preselect") opts.preselect_mode = PRESELECT_OFF;
        else if (args[i] == L"--g56-h-plus10") opts.work_offsets = {{"G54", 0}, {"G56", 10}};
        else if (args[i] == L"--multi-wcs" && i + 1 < args.size()) { opts.g54g56_mode = true; opts.work_offsets = parseWorkOffsetConfigText(narrowUtf8(args[++i])); }
        else if (args[i] == L"--experimental-compensation") opts.experimental_compensation = true;
        else if (args[i] == L"--experimental-compensation") opts.experimental_compensation = true;
        else if (args[i] == L"--side-comp-g41") opts.side_compensation_g41 = true;
        else if (args[i] == L"--experimental-compensation-config" && i + 1 < args.size()) opts.compensations = parseCompensationConfigText(narrowUtf8(args[++i]));

        else if (args[i] == L"--end-zero-zero") opts.end_zero_zero = true;
        else if (args[i] == L"--g54g56-pretty") opts.g54g56_pretty_compact = true;

        else if (args[i] == L"--g54g56-lift-z" && i + 1 < args.size()) {
            int z = _wtoi(args[++i].c_str());
            if (z == 50 || z == 100) opts.g54g56_lift_z = z;
            else opts.g54g56_lift_z = 0;
        }
        else if (args[i] == L"--g54g56-second-wcs" && i + 1 < args.size()) {
            ++i;
        }
        else if (args[i] == L"--sort-file") opts.sort_strategy = SORT_FILE;
        else if (args[i] == L"--no-preselect") opts.preselect_mode = PRESELECT_OFF;
        else if (args[i] == L"--m00-wait-off") opts.m00_wait_mode = M00_WAIT_OFF;
        else if (args[i] == L"--m00-wait-all") opts.m00_wait_mode = M00_WAIT_ALL_TOOLS;
        else if (args[i] == L"--m00-wait-drill") opts.m00_wait_mode = M00_WAIT_DRILL_ONLY;
        else if (args[i] == L"--m00-wait-drill") opts.m00_wait_mode = M00_WAIT_DRILL_ONLY;
        else if (args[i] == L"--g41-close-segment") {
            opts.g41_close_strategy = G41_CLOSE_SEGMENT;
            writeCliWarning("WARNING: --g41-close-segment legacy high-risk strategy: G41 may span G0/Z lift/canned cycles; M70 may alarm or interfere. Use --g41-close-adaptive for production.\n");
        }
        else if (args[i] == L"--g41-close-adaptive") opts.g41_close_strategy = G41_CLOSE_ADAPTIVE;
        else if (args[i] == L"--g41-risk" && i + 1 < args.size()) applyG41RiskCliOption(opts.g41_close_strategy, args[++i]);
        else if (args[i] == L"--safety-audit") opts.safety_audit_report = true;
        else if (args[i] == L"--safety-audit-strict") { opts.safety_audit_report = true; opts.safety_audit_strict = true; }
        else if (args[i] == L"--compensation-limit" && i + 1 < args.size()) { opts.compensation_limit_check = true; opts.compensation_limit_abs = parseStrictDouble(narrowUtf8(args[++i]), "坐标补偿上限"); if (opts.compensation_limit_abs < 0.0) throw std::runtime_error("坐标补偿上限必须非负"); }
        else if (args[i] == L"--shop-precheck-input") opts.shop_precheck_input = true;
        else if (args[i] == L"--shop-keyword-preview") opts.shop_keyword_preview = true;
        else if (args[i] == L"--shop-coord-dry-run") opts.shop_coord_dry_run = true;
        else if (args[i] == L"--shop-g41-envelope") opts.shop_g41_envelope = true;
        else if (args[i] == L"--shop-auto-backup") opts.shop_auto_backup = true;
        else if (args[i] == L"--shop-config-snapshot") opts.shop_config_snapshot = true;
    }
}

static bool getCursorPoint(POINT& pt) {
    if (GetCursorPos(&pt)) return true;
    if (GetPhysicalCursorPos(&pt)) return true;
    CURSORINFO ci{};
    ci.cbSize = sizeof(ci);
    if (GetCursorInfo(&ci)) {
        pt = ci.ptScreenPos;
        return true;
    }
    DWORD pos = GetMessagePos();
    pt.x = (int)(short)LOWORD(pos);
    pt.y = (int)(short)HIWORD(pos);
    return true;
}

static fs::path settingsPath() {
    PWSTR localAppData = nullptr;
    fs::path base;
    if (SUCCEEDED(SHGetKnownFolderPath(FOLDERID_LocalAppData, KF_FLAG_DEFAULT, nullptr, &localAppData)) && localAppData) {
        base = localAppData;
        CoTaskMemFree(localAppData);
    } else {
        wchar_t temp[MAX_PATH]{};
        GetTempPathW((DWORD)std::size(temp), temp);
        base = temp;
    }
    return base / L"UGPostProcessor" / L"ug_settings.ini";
}

static int readIniInt(const wchar_t* section, const wchar_t* key, int def) {
    return GetPrivateProfileIntW(section, key, def, settingsPath().wstring().c_str());
}

static std::wstring readIniString(const wchar_t* section, const wchar_t* key, const wchar_t* def = L"") {
    wchar_t buf[4096]{};
    GetPrivateProfileStringW(section, key, def, buf, (DWORD)std::size(buf), settingsPath().wstring().c_str());
    return buf;
}

static void writeIniInt(const wchar_t* section, const wchar_t* key, int value) {
    std::wstring s = std::to_wstring(value);
    WritePrivateProfileStringW(section, key, s.c_str(), settingsPath().wstring().c_str());
}

static void writeIniString(const wchar_t* section, const wchar_t* key, const std::wstring& value) {
    WritePrivateProfileStringW(section, key, value.c_str(), settingsPath().wstring().c_str());
}

static void setChecked(HWND parent, int id, bool value) {
    if (HWND h = GetDlgItem(parent, id)) SendMessageW(h, BM_SETCHECK, value ? BST_CHECKED : BST_UNCHECKED, 0);
}

static std::wstring getControlText(HWND parent, int id, int maxLen = 4096) {
    std::wstring s(maxLen, L'\0');
    int n = GetWindowTextW(GetDlgItem(parent, id), s.data(), maxLen);
    s.resize(std::max(0, n));
    return s;
}

static void setControlText(HWND parent, int id, const std::wstring& value) {
    if (HWND h = GetDlgItem(parent, id)) SetWindowTextW(h, value.c_str());
}

void App::loadSettings() {
    fs::path cfg = settingsPath();
    if (!fs::exists(cfg)) return;

    struct CheckOpt { int id; const wchar_t* key; bool def; };
    const CheckOpt checks[] = {
        {ID_ALLOW_HH, L"allow_hh", false},
        {ID_FILTER_TRY, L"filter_try", true},
        {ID_STRIP, L"strip_header_g49g80", true},
        {ID_OPEN_G28, L"open_g28", true},
        {ID_END_DUAL, L"end_dual_axis", true},
        {ID_HH_STRIP, L"hh_strip_f4000", true},
        {ID_H_FORCE, L"h_force_f4000", true},
        {ID_CROSS_G43, L"cross_g43", true},
        {ID_G54G56_MODE, L"g54g56_mode", false},
        {ID_EXP_COMP_ENABLE, L"experimental_compensation", false},
        {ID_SIDE_COMP_ENABLE, L"side_compensation_g41", false},
        {ID_APPEND_TRY, L"append_try", false},

        {ID_SAFETY_AUDIT_ENABLE, L"safety_audit_report", false},
        {ID_SAFETY_AUDIT_STRICT, L"safety_audit_strict", false},
        {ID_COMP_LIMIT_ENABLE, L"compensation_limit_check", false},
        {ID_APPEND_TRY, L"append_try", false},
        {ID_SILENT, L"silent", true},
        {ID_NOVICE, L"novice", true},
    };
    for (const auto& opt : checks) setChecked(hwnd, opt.id, readIniInt(L"Options", opt.key, opt.def ? 1 : 0) != 0);

    int sortId = readIniInt(L"Options", L"sort_id", ID_SORT_H);
    if (sortId < ID_SORT_H || sortId > ID_SORT_SMART) sortId = ID_SORT_H;
    for (int id : {ID_SORT_H, ID_SORT_FILE, ID_SORT_Z_GLOBAL, ID_SORT_Z_CLUSTER, ID_SORT_SMART}) setChecked(hwnd, id, id == sortId);

    int preId = readIniInt(L"Options", L"preselect_id", ID_PRE_LEGACY);
    if (preId < ID_PRE_LEGACY || preId > ID_PRE_RING) preId = ID_PRE_LEGACY;
    for (int id : {ID_PRE_LEGACY, ID_PRE_OFF, ID_PRE_NEXT, ID_PRE_RING}) setChecked(hwnd, id, id == preId);

    int liftId = readIniInt(L"Options", L"g54g56_lift_id", ID_G54G56_LIFT_100);
    if (liftId < ID_G54G56_LIFT_OFF || liftId > ID_G54G56_LIFT_100) liftId = ID_G54G56_LIFT_OFF;
    for (int id : {ID_G54G56_LIFT_OFF, ID_G54G56_LIFT_50, ID_G54G56_LIFT_100}) setChecked(hwnd, id, id == liftId);
    int secondWcsId = readIniInt(L"Options", L"g54g56_second_wcs_id", ID_G54G56_SECOND_TOGGLE);
    if (secondWcsId < ID_G54G56_SECOND_AUTO || secondWcsId > ID_G54G56_SECOND_G56) secondWcsId = ID_G54G56_SECOND_AUTO;
    for (int id : {ID_G54G56_SECOND_AUTO, ID_G54G56_SECOND_TOGGLE, ID_G54G56_SECOND_G54, ID_G54G56_SECOND_G56}) setChecked(hwnd, id, id == secondWcsId);

    // 读取M00模式
    int m00WaitId = readIniInt(L"Options", L"m00_wait_id", ID_M00_WAIT_OFF);
    if (m00WaitId < ID_M00_WAIT_OFF || m00WaitId > ID_M00_WAIT_DRILL) m00WaitId = ID_M00_WAIT_OFF;
    for (int id : {ID_M00_WAIT_OFF, ID_M00_WAIT_ALL, ID_M00_WAIT_DRILL}) setChecked(hwnd, id, id == m00WaitId);

    // 读取G41策略
    int g41CloseId = readIniInt(L"Options", L"g41_close_id", ID_G41_CLOSE_ADAPTIVE);
    if (g41CloseId < ID_G41_CLOSE_ADAPTIVE || g41CloseId > ID_G41_CLOSE_SEGMENT) g41CloseId = ID_G41_CLOSE_ADAPTIVE;
    for (int id : {ID_G41_CLOSE_ADAPTIVE, ID_G41_CLOSE_SEGMENT}) setChecked(hwnd, id, id == g41CloseId);

    setControlText(hwnd, ID_TRAILING, readIniString(L"Options", L"trailing", L"1"));
    // 读取M00模式
    int m00WaitId = readIniInt(L"Options", L"m00_wait_id", ID_M00_WAIT_OFF);
    if (m00WaitId < ID_M00_WAIT_OFF || m00WaitId > ID_M00_WAIT_DRILL) m00WaitId = ID_M00_WAIT_OFF;
    for (int id : {ID_M00_WAIT_OFF, ID_M00_WAIT_ALL, ID_M00_WAIT_DRILL}) setChecked(hwnd, id, id == m00WaitId);

    setControlText(hwnd, ID_G41_RISK_TEXT, L"G41策略：固定平衡 - 危险动作前关G40");

    setControlText(hwnd, ID_TRAILING, readIniString(L"Options", L"trailing", L"1"));
    setControlText(hwnd, ID_TMAP, readIniString(L"Options", L"t_map", L""));
    setControlText(hwnd, ID_MULTI_WCS_CONFIG, readIniString(L"Options", L"multi_wcs_config", L"G54:0,G56:10"));
    setControlText(hwnd, ID_EXP_COMP_CONFIG, readIniString(L"Options", L"experimental_compensation_config", L""));
    setControlText(hwnd, ID_MULTI_WCS_CONFIG, readIniString(L"Options", L"multi_wcs_config", L"G54:0,G56:10"));
    setControlText(hwnd, ID_EXP_COMP_CONFIG, readIniString(L"Options", L"experimental_compensation_config", L""));
    setControlText(hwnd, ID_COMP_LIMIT_VALUE, readIniString(L"Options", L"compensation_limit_abs", L"0.10"));

    topmost = readIniInt(L"Window", L"topmost", 0) != 0;
    if (topmost) SetWindowPos(hwnd, HWND_TOPMOST, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE);

    int left = readIniInt(L"Window", L"left", INT_MIN);
    int top = readIniInt(L"Window", L"top", INT_MIN);
    int width = readIniInt(L"Window", L"width", 0);
    int height = readIniInt(L"Window", L"height", 0);
    if (left != INT_MIN && top != INT_MIN && width >= 1020 && height >= 740) {
        RECT savedRc{left, top, left + width, top + height};
        HMONITOR mon = MonitorFromRect(&savedRc, MONITOR_DEFAULTTONEAREST);
        MONITORINFO mi{};
        mi.cbSize = sizeof(mi);
        if (GetMonitorInfoW(mon, &mi)) {
            int minLeft = (int)mi.rcWork.left;
            int maxLeft = std::max(minLeft, (int)mi.rcWork.right - 120);
            int minTop = (int)mi.rcWork.top;
            int maxTop = std::max(minTop, (int)mi.rcWork.bottom - 80);
            left = std::clamp(left, minLeft, maxLeft);
            top = std::clamp(top, minTop, maxTop);
        }
        SetWindowPos(hwnd, nullptr, left, top, width, height, SWP_NOACTIVATE | SWP_NOZORDER);
    }
}

void App::saveSettings() {
    std::error_code ec;
    fs::create_directories(settingsPath().parent_path(), ec);

    struct CheckOpt { int id; const wchar_t* key; };
    const CheckOpt checks[] = {
        {ID_ALLOW_HH, L"allow_hh"},
        {ID_FILTER_TRY, L"filter_try"},
        {ID_STRIP, L"strip_header_g49g80"},
        {ID_OPEN_G28, L"open_g28"},
        {ID_END_DUAL, L"end_dual_axis"},
        {ID_HH_STRIP, L"hh_strip_f4000"},
        {ID_H_FORCE, L"h_force_f4000"},
        {ID_CROSS_G43, L"cross_g43"},
        {ID_G54G56_MODE, L"g54g56_mode"},
        {ID_APPEND_TRY, L"append_try"},
        {ID_EXP_COMP_ENABLE, L"experimental_compensation"},
        {ID_SIDE_COMP_ENABLE, L"side_compensation_g41"},
        {ID_SIDE_COMP_ENABLE, L"side_compensation_g41"},
        {ID_SAFETY_AUDIT_ENABLE, L"safety_audit_report"},
        {ID_SAFETY_AUDIT_STRICT, L"safety_audit_strict"},
        {ID_COMP_LIMIT_ENABLE, L"compensation_limit_check"},
        {ID_SILENT, L"silent"},
        {ID_NOVICE, L"novice"},
    };
    for (const auto& opt : checks) writeIniInt(L"Options", opt.key, checked(hwnd, opt.id) ? 1 : 0);

    int sortId = ID_SORT_H;
    for (int id : {ID_SORT_H, ID_SORT_FILE, ID_SORT_Z_GLOBAL, ID_SORT_Z_CLUSTER, ID_SORT_SMART}) {
        if (checked(hwnd, id)) { sortId = id; break; }
    }
    writeIniInt(L"Options", L"sort_id", sortId);

    int preId = ID_PRE_LEGACY;
    for (int id : {ID_PRE_LEGACY, ID_PRE_OFF, ID_PRE_NEXT, ID_PRE_RING}) {
        if (checked(hwnd, id)) { preId = id; break; }
    }
    writeIniInt(L"Options", L"preselect_id", preId);
    int liftId = ID_G54G56_LIFT_OFF;
    for (int id : {ID_G54G56_LIFT_OFF, ID_G54G56_LIFT_50, ID_G54G56_LIFT_100}) {
        if (checked(hwnd, id)) { liftId = id; break; }
    }
    writeIniInt(L"Options", L"g54g56_lift_id", liftId);

    int secondWcsId = ID_G54G56_SECOND_TOGGLE;
    for (int id : {ID_G54G56_SECOND_AUTO, ID_G54G56_SECOND_TOGGLE, ID_G54G56_SECOND_G54, ID_G54G56_SECOND_G56}) {
        if (checked(hwnd, id)) { secondWcsId = id; break; }
    }
    writeIniInt(L"Options", L"g54g56_second_wcs_id", secondWcsId);

    // 保存M00模式
    int m00WaitId = ID_M00_WAIT_OFF;
    for (int id : {ID_M00_WAIT_OFF, ID_M00_WAIT_ALL, ID_M00_WAIT_DRILL}) {
        if (checked(hwnd, id)) { m00WaitId = id; break; }
    }
    writeIniInt(L"Options", L"m00_wait_id", m00WaitId);

    // 保存G41策略
    int g41CloseId = ID_G41_CLOSE_ADAPTIVE;
    for (int id : {ID_G41_CLOSE_SEGMENT, ID_G41_CLOSE_ADAPTIVE}) {
        if (checked(hwnd, id)) { g41CloseId = id; break; }
    }
    writeIniInt(L"Options", L"g41_close_id", g41CloseId);

    writeIniString(L"Options", L"trailing", getControlText(hwnd, ID_TRAILING, 32));
    int secondWcsId = ID_G54G56_SECOND_TOGGLE;
    for (int id : {ID_G54G56_SECOND_AUTO, ID_G54G56_SECOND_TOGGLE, ID_G54G56_SECOND_G54, ID_G54G56_SECOND_G56}) {
        if (checked(hwnd, id)) { secondWcsId = id; break; }
    }
    writeIniInt(L"Options", L"g54g56_second_wcs_id", secondWcsId);

    // 保存M00模式
    int m00WaitId = ID_M00_WAIT_OFF;
    for (int id : {ID_M00_WAIT_OFF, ID_M00_WAIT_ALL, ID_M00_WAIT_DRILL}) {
        if (checked(hwnd, id)) { m00WaitId = id; break; }
    }
    writeIniInt(L"Options", L"m00_wait_id", m00WaitId);

    writeIniInt(L"Options", L"g41_risk_level", 2);

    writeIniString(L"Options", L"trailing", getControlText(hwnd, ID_TRAILING, 32));
    writeIniString(L"Options", L"t_map", getControlText(hwnd, ID_TMAP, 4096));
    writeIniString(L"Options", L"multi_wcs_config", getControlText(hwnd, ID_MULTI_WCS_CONFIG, 4096));
    writeIniString(L"Options", L"experimental_compensation_config", getControlText(hwnd, ID_EXP_COMP_CONFIG, 4096));
    writeIniString(L"Options", L"compensation_limit_abs", getControlText(hwnd, ID_COMP_LIMIT_VALUE, 64));
    writeIniInt(L"Window", L"topmost", topmost ? 1 : 0);

    WINDOWPLACEMENT wp{};
    wp.length = sizeof(wp);
    if (GetWindowPlacement(hwnd, &wp)) {
        RECT rc = wp.rcNormalPosition;
        writeIniInt(L"Window", L"left", rc.left);
        writeIniInt(L"Window", L"top", rc.top);
        writeIniInt(L"Window", L"width", rc.right - rc.left);
        writeIniInt(L"Window", L"height", rc.bottom - rc.top);
    }
}

void App::onCommand(int id, int, HWND) {
    if (busy && id != ID_BTN_TOPMOST) return;
    try {
        switch (id) {
        case ID_BTN_ADD_FILES: browseFiles(); break;
        case ID_BTN_ADD_FOLDER: browseFolder(); break;
        case ID_BTN_UP: moveSelected(-1); break;
        case ID_BTN_DOWN: moveSelected(1); break;
        case ID_BTN_REMOVE: removeSelected(); break;
        case ID_BTN_CLEAR: files.clear(); redrawList(); setStatus(L"已清空"); break;
        case ID_BTN_NORMAL: normalProcess(); break;
        case ID_BTN_MERGE: mergeProcess(); break;
        case ID_BTN_PREVIEW: previewDiff(); break;
        case ID_BTN_SAFETY_REPORT: safetyReport(); break;
        case ID_NOVICE:
            hideTooltip();
            setStatus(checked(hwnd, ID_NOVICE) ? L"新手模式已开启" : L"新手模式已关闭");
            break;
        case ID_BTN_TOPMOST:
            topmost = !topmost;
            SetWindowPos(hwnd, topmost ? HWND_TOPMOST : HWND_NOTOPMOST, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE);
            setStatus(topmost ? L"窗口已置顶" : L"已取消置顶");
            break;
        }
    } catch (const std::exception& e) {
        MessageBoxW(hwnd, widen(e.what()).c_str(), L"错误", MB_ICONERROR);
    }
}

static bool isMergedName(const fs::path& p) {
    std::wstring stem = p.stem().wstring();
    if (stem.empty()) return false;
    wchar_t c = towlower(stem.back());
    if (c != L'h') return false;
    stem.pop_back();
    if (!stem.empty() && towlower(stem.back()) == L'h') stem.pop_back();
    return true;
}

struct LoadOptions {
    bool allowHh = false;
    bool filterTry = false;
};

struct LoadScanResult {
    std::vector<fs::path> paths;
    int added = 0;
    int skippedHh = 0;
    int skippedTry = 0;
    int skippedOther = 0;
};

static std::wstring pathKey(const fs::path& p) {
    // 性能优化：加载/扫描大目录只需要稳定去重 key，不需要对每个文件做 weakly_canonical 的磁盘级解析。
    // absolute + lexically_normal 足够区分本工具扫描到的路径，避免大目录扫描超过 5 秒。
    std::error_code ec;
    fs::path k = fs::absolute(p, ec);
    if (ec) k = p;
    std::wstring s = k.lexically_normal().wstring();
    std::transform(s.begin(), s.end(), s.begin(), [](wchar_t ch) { return (wchar_t)towlower(ch); });
    return s;
}

static void scanOnePath(const fs::path& p, const LoadOptions& opts,
                        std::unordered_set<std::wstring>& seen, LoadScanResult& out) {
    if (!endsWithLower(p.wstring(), L".ptp")) { ++out.skippedOther; return; }
    std::wstring key = pathKey(p);
    if (seen.find(key) != seen.end()) { ++out.skippedOther; return; }
    if (!opts.allowHh && isMergedName(p)) { ++out.skippedHh; return; }
    std::string fn = baseNameUtf8(p);
    if (opts.filterTry && isTryKnifeName(fn)) {
        try {
            auto seg = parseSegment(readTextLines(p), fn, p);
            if (seg.h_num && *seg.h_num == 1) { ++out.skippedTry; return; }
        } catch (...) {}
    }
    seen.insert(std::move(key));
    out.paths.push_back(p);
    ++out.added;
}

static LoadScanResult scanLoadInputs(const std::vector<fs::path>& inputs,
                                     const std::vector<fs::path>& existing,
                                     const LoadOptions& opts) {
    LoadScanResult out;
    std::unordered_set<std::wstring> seen;
    seen.reserve(existing.size() + inputs.size() + 64);
    for (const auto& p : existing) seen.insert(pathKey(p));

    for (const auto& input : inputs) {
        std::error_code ec;
        if (fs::is_directory(input, ec)) {
            std::vector<fs::path> found;
            fs::recursive_directory_iterator it(input, fs::directory_options::skip_permission_denied, ec), end;
            for (; !ec && it != end; it.increment(ec)) {
                std::error_code entEc;
                if (it->is_regular_file(entEc)) found.push_back(it->path());
            }
            std::sort(found.begin(), found.end());
            out.paths.reserve(out.paths.size() + found.size());
            for (const auto& p : found) scanOnePath(p, opts, seen, out);
        } else if (!ec) {
            scanOnePath(input, opts, seen, out);
        } else {
            ++out.skippedOther;
        }
    }
    return out;
}

void App::setBusy(bool value, const std::wstring& statusText) {
    busy = value;
    int ids[] = {
        ID_BTN_NORMAL, ID_BTN_MERGE, ID_BTN_PREVIEW,
        ID_BTN_ADD_FILES, ID_BTN_ADD_FOLDER, ID_BTN_UP, ID_BTN_DOWN,
        ID_BTN_REMOVE, ID_BTN_CLEAR,
        ID_ALLOW_HH, ID_FILTER_TRY, ID_STRIP, ID_OPEN_G28, ID_END_DUAL,
        ID_HH_STRIP, ID_H_FORCE, ID_CROSS_G43, ID_SORT_H, ID_SORT_FILE,
        ID_SORT_Z_GLOBAL, ID_SORT_Z_CLUSTER, ID_SORT_SMART, ID_APPEND_TRY,
        ID_G54G56_MODE, ID_MULTI_WCS_CONFIG, ID_G54G56_LIFT_OFF, ID_G54G56_LIFT_50, ID_G54G56_LIFT_100,
        ID_EXP_COMP_ENABLE, ID_SIDE_COMP_ENABLE, ID_EXP_COMP_CONFIG,

        ID_M00_WAIT_OFF, ID_M00_WAIT_ALL, ID_M00_WAIT_DRILL,
        ID_PRE_LEGACY, ID_PRE_OFF, ID_PRE_NEXT, ID_PRE_RING,
        ID_TRAILING, ID_TMAP, ID_SILENT, ID_NOVICE,
        ID_SAFETY_AUDIT_ENABLE, ID_SAFETY_AUDIT_STRICT, ID_COMP_LIMIT_ENABLE, ID_COMP_LIMIT_VALUE, ID_BTN_SAFETY_REPORT,
        ID_SHOP_PRECHECK_INPUT, ID_SHOP_KEYWORD_PREVIEW, ID_SHOP_COORD_DRY_RUN, ID_SHOP_G41_ENVELOPE,
        ID_SHOP_AUTO_BACKUP, ID_SHOP_CONFIG_SNAPSHOT
    };
    for (int cid : ids) {
        HWND h = GetDlgItem(hwnd, cid);
        if (h) EnableWindow(h, value ? FALSE : TRUE);
    }
    if (!statusText.empty()) setStatus(statusText);
}

void App::onJobDone(JobResult* raw) {
    std::unique_ptr<JobResult> result(raw);
    setBusy(false);
    if (!result) return;
    if (!result->ok) {
        setStatus(result->status.empty() ? L"处理失败" : result->status);
        MessageBoxW(hwnd, result->errorMessage.c_str(),
                    result->errorTitle.empty() ? L"错误" : result->errorTitle.c_str(),
                    MB_ICONERROR);
        return;
    }
    if (result->kind == JobKind::Load) {
        files.insert(files.end(), result->loadedFiles.begin(), result->loadedFiles.end());
        redrawList();
    } else if (result->kind == JobKind::Preview) {
        normalCache = std::move(result->normalText);
        hCache = std::move(result->hText);
        hhCache = std::move(result->hhText);
        refreshText();
    } else if (result->kind == JobKind::Merge) {
        if (!result->hText.empty() || !result->hhText.empty()) {
            hCache = std::move(result->hText);
            hhCache = std::move(result->hhText);
            if (!result->safetyText.empty()) safetyCache = std::move(result->safetyText);
            refreshText();
        }
    } else if (result->kind == JobKind::Safety) {
        safetyCache = std::move(result->safetyText);
        refreshText();
        if (tabs) TabCtrl_SetCurSel(tabs, 3);
        activeTab = -1;
        updateTabVisibility();
    }
    if (!result->status.empty()) setStatus(result->status);
    if (!result->logMessage.empty()) log(L"OK", result->logMessage);
    if (!result->outDir.empty()) {
        ShellExecuteW(hwnd, L"open", result->outDir.c_str(), nullptr, nullptr, SW_SHOWNORMAL);
    }
}

void App::startLoad(std::vector<fs::path> inputs, const std::wstring& busyText) {
    if (inputs.empty()) return;
    if (busy) return;
    auto existing = files;
    LoadOptions opts;
    opts.allowHh = checked(hwnd, ID_ALLOW_HH);
    opts.filterTry = checked(hwnd, ID_FILTER_TRY);
    HWND target = hwnd;
    setBusy(true, busyText);
    std::thread([inputs = std::move(inputs), existing = std::move(existing), opts, target]() mutable {
        auto* result = new JobResult();
        result->kind = JobKind::Load;
        try {
            LoadScanResult scan = scanLoadInputs(inputs, existing, opts);
            result->loadedFiles = std::move(scan.paths);
            result->added = scan.added;
            result->skippedHh = scan.skippedHh;
            result->skippedTry = scan.skippedTry;
            result->skippedOther = scan.skippedOther;
            result->ok = true;
            result->status = L"已添加 " + std::to_wstring(result->added) +
                             L" 个，跳过 " + std::to_wstring(result->skippedHh + result->skippedTry + result->skippedOther) + L" 个";
        } catch (const std::exception& e) {
            result->ok = false;
            result->status = L"扫描失败";
            result->errorTitle = L"扫描失败";
            result->errorMessage = widen(e.what());
        }
        if (!PostMessageW(target, WM_APP_JOB_DONE, (WPARAM)result, 0)) delete result;
    }).detach();
}

void App::onDrop(HDROP drop) {
    if (busy) {
        DragFinish(drop);
        return;
    }
    std::vector<fs::path> inputs;
    UINT n = DragQueryFileW(drop, 0xFFFFFFFF, nullptr, 0);
    inputs.reserve(n);
    for (UINT i = 0; i < n; ++i) {
        wchar_t buf[MAX_PATH * 4];
        DragQueryFileW(drop, i, buf, (UINT)std::size(buf));
        inputs.emplace_back(buf);
    }
    DragFinish(drop);
    startLoad(std::move(inputs), L"正在扫描...");
}

void App::addPath(const fs::path& p, int& added, int& skipHh, int& skipTry, int& skipOther) {
    if (!endsWithLower(p.wstring(), L".ptp")) { ++skipOther; return; }
    for (auto& old : files) if (fs::equivalent(old, p)) { ++skipOther; return; }
    if (!checked(hwnd, ID_ALLOW_HH) && isMergedName(p)) { ++skipHh; return; }
    std::string fn = baseNameUtf8(p);
    if (checked(hwnd, ID_FILTER_TRY) && isTryKnifeName(fn)) {
        try {
            auto seg = parseSegment(readTextLines(p), fn, p);
            if (seg.h_num && *seg.h_num == 1) { ++skipTry; return; }
        } catch (...) {}
    }
    files.push_back(p);
    ++added;
}

void App::addDir(const fs::path& d, int& added, int& skipHh, int& skipTry, int& skipOther) {
    std::vector<fs::path> paths;
    for (auto& ent : fs::recursive_directory_iterator(d)) {
        if (ent.is_regular_file()) paths.push_back(ent.path());
    }
    std::sort(paths.begin(), paths.end());
    for (auto& p : paths) addPath(p, added, skipHh, skipTry, skipOther);
}

void App::redrawList() {
    SendMessageW(list, WM_SETREDRAW, FALSE, 0);
    SendMessageW(list, LB_RESETCONTENT, 0, 0);
    SendMessageW(list, LB_INITSTORAGE, (WPARAM)files.size(), (LPARAM)(files.size() * MAX_PATH * sizeof(wchar_t)));
    for (auto& p : files) SendMessageW(list, LB_ADDSTRING, 0, (LPARAM)p.filename().wstring().c_str());
    SendMessageW(list, WM_SETREDRAW, TRUE, 0);
    InvalidateRect(list, nullptr, TRUE);
}

void App::setStatus(const std::wstring& s) { SetWindowTextW(status, s.c_str()); }

void App::log(const std::wstring& level, const std::wstring& msg) {
    SYSTEMTIME st; GetLocalTime(&st);
    wchar_t buf[64];
    wsprintfW(buf, L"[%02d:%02d:%02d] ", st.wHour, st.wMinute, st.wSecond);
    logCache += narrowUtf8(buf) + narrowUtf8(level + L" " + msg) + "\r\n";
    refreshText();
}

MergeOptions App::collectOptions() {
    MergeOptions o;
    o.strip_header_g49g80 = checked(hwnd, ID_STRIP);
    o.open_g28 = checked(hwnd, ID_OPEN_G28);
    o.end_dual_axis = checked(hwnd, ID_END_DUAL);
    o.hh_strip_f4000 = checked(hwnd, ID_HH_STRIP);
    o.h_force_f4000 = checked(hwnd, ID_H_FORCE);
        o.g54g56_no_preselect = false;
    o.side_compensation_g41 = checked(hwnd, ID_SIDE_COMP_ENABLE);
    o.experimental_compensation = checked(hwnd, ID_EXP_COMP_ENABLE);
    o.safety_audit_report = checked(hwnd, ID_SAFETY_AUDIT_ENABLE);
    o.safety_audit_strict = checked(hwnd, ID_SAFETY_AUDIT_STRICT);
    o.compensation_limit_check = checked(hwnd, ID_COMP_LIMIT_ENABLE);
    // 修复 #6: 只在勾选时解析 compensation_limit，且防御性解析
    o.compensation_limit_abs = 0.10;  // 默认值
    if (o.compensation_limit_check) {
        std::wstring raw = getControlText(hwnd, ID_COMP_LIMIT_VALUE, 64);
        wchar_t* endp = nullptr;
        double v = wcstod(raw.c_str(), &endp);
        while (endp && *endp && std::iswspace((wint_t)*endp)) ++endp;
        if (endp == raw.c_str() || (endp && *endp) || !std::isfinite(v) || v < 0.0) {
            throw std::runtime_error("坐标补偿上限填写无效，请输入非负数字(例 0.10)");
        }
        o.compensation_limit_abs = v;
    }
    o.shop_precheck_input = checked(hwnd, ID_SHOP_PRECHECK_INPUT);
    o.shop_keyword_preview = checked(hwnd, ID_SHOP_KEYWORD_PREVIEW);
    o.shop_coord_dry_run = checked(hwnd, ID_SHOP_COORD_DRY_RUN);
    o.shop_g41_envelope = checked(hwnd, ID_SHOP_G41_ENVELOPE);
    o.shop_auto_backup = checked(hwnd, ID_SHOP_AUTO_BACKUP);
    o.shop_config_snapshot = checked(hwnd, ID_SHOP_CONFIG_SNAPSHOT);
        o.experimental_compensation = checked(hwnd, ID_EXP_COMP_ENABLE);
        o.compensations = parseCompensationConfigText(narrowUtf8(getControlText(hwnd, ID_EXP_COMP_CONFIG, 4096)));
        o.side_compensation_g41 = checked(hwnd, ID_SIDE_COMP_ENABLE);

    }

    // 收集M00模式
    if (checked(hwnd, ID_M00_WAIT_ALL)) o.m00_wait_mode = M00_WAIT_ALL_TOOLS;
    else if (checked(hwnd, ID_M00_WAIT_DRILL)) o.m00_wait_mode = M00_WAIT_DRILL_ONLY;
    else o.m00_wait_mode = M00_WAIT_OFF;

    o.g41_close_strategy = G41_RISK_BALANCED;

    if (checked(hwnd, ID_G54G56_LIFT_100)) o.g54g56_lift_z = 100;
    else if (checked(hwnd, ID_G54G56_LIFT_50)) o.g54g56_lift_z = 50;
    else o.g54g56_lift_z = 0;
    if (o.g54g56_mode) {
        o.work_offsets = parseWorkOffsetConfigText(narrowUtf8(getControlText(hwnd, ID_MULTI_WCS_CONFIG, 4096)));
    }
    o.append_try_knife_at_end = checked(hwnd, ID_APPEND_TRY);
    if (checked(hwnd, ID_SORT_FILE)) o.sort_strategy = SORT_FILE;
    else if (checked(hwnd, ID_SORT_Z_GLOBAL)) o.sort_strategy = SORT_Z_GLOBAL;
    else if (checked(hwnd, ID_SORT_Z_CLUSTER)) o.sort_strategy = SORT_Z_CLUSTER;
    else if (checked(hwnd, ID_SORT_SMART)) o.sort_strategy = SORT_SMART_AUTO;
    else o.sort_strategy = SORT_H_ASC;
    if (checked(hwnd, ID_PRE_OFF)) o.preselect_mode = PRESELECT_OFF;
    else if (checked(hwnd, ID_PRE_NEXT)) o.preselect_mode = PRESELECT_NEXT;
    else if (checked(hwnd, ID_PRE_RING)) o.preselect_mode = PRESELECT_RING;
    else o.preselect_mode = PRESELECT_LEGACY;
    wchar_t buf[4096]{};
    GetWindowTextW(GetDlgItem(hwnd, ID_TRAILING), buf, 32);
    o.trailing_blank_lines = parseStrictInt(narrowUtf8(buf), "% 后空行数", 0, 5);
    GetWindowTextW(GetDlgItem(hwnd, ID_TMAP), buf, 4096);
    std::string raw = narrowUtf8(buf);
    std::stringstream ss(raw);
    for (std::string piece; std::getline(ss, piece, ',');) {
        piece = trim(piece);
        if (piece.empty()) continue;
        auto pos = piece.find(':');
        if (pos == std::string::npos) throw std::runtime_error("刀名映射格式错: " + piece);
        o.tool_t_map[trim(piece.substr(0, pos))] = parseStrictInt(piece.substr(pos + 1), "T 号", 1, 200);
    }
    return o;
}

std::vector<Segment> App::parseAll() {
    std::vector<Segment> segs;
    for (auto& p : files) segs.push_back(parseSegment(readTextLines(p), baseNameUtf8(p), p));
    return segs;
}

std::pair<std::string, std::string> App::buildMerge() {
    if (files.empty()) throw std::runtime_error("还没有添加题目文件");
    auto segs = parseAll();
    auto base = collectOptions();
    MergeOptions h = base; h.version = "H";
    MergeOptions hh = base; hh.version = "HH";
    return {mergeSegments(segs, h), mergeSegments(segs, hh)};
}

fs::path App::okDir() {
    if (files.empty()) throw std::runtime_error("先添加题目文件再试");
    fs::path d = files[0].parent_path() / L"ok";
    fs::create_directories(d);
    return d;
}

bool App::writeWithConfirm(const fs::path& path, const std::string& text) {
    if (fs::exists(path)) {
        std::wstring msg = L"目标文件已存在:\n" + path.wstring() + L"\n\n确认覆盖?";
        if (MessageBoxW(hwnd, msg.c_str(), L"文件已存在", MB_YESNO | MB_DEFBUTTON2 | MB_ICONQUESTION) != IDYES) return false;
    }
    writeUtf8File(path, text);
    return true;
}

void App::normalProcess() {
    if (files.empty()) { MessageBoxW(hwnd, L"先添加题目文件再试", L"没有文件", MB_ICONWARNING); return; }
    auto filesCopy = files;
    bool cross = checked(hwnd, ID_CROSS_G43);
    bool cross = checked(hwnd, ID_CROSS_G43);
    MergeOptions opts = collectOptions();
    fs::path outDir = filesCopy[0].parent_path() / L"ok";
    HWND target = hwnd;
    setBusy(true, L"正在正常处理...");
    std::thread([filesCopy, cross, opts, outDir, target]() {
        auto* result = new JobResult();
        result->kind = JobKind::Normal;
        try {
            fs::create_directories(outDir);
            int written = 0, errors = 0;
            for (auto& p : filesCopy) {
                try {
                    writeUtf8File(outDir / p.filename(), processNormalText(readNormalLines(p), cross, opts.side_compensation_g41, opts.g41_close_strategy));
                    ++written;
                } catch (...) {
                    ++errors;
                }
            }
            result->ok = true;
            result->status = L"已写出 " + std::to_wstring(written) + L" 个，失败 " + std::to_wstring(errors) + L" 个";
            result->logMessage = L"正常处理输出到 " + outDir.wstring();
            result->outDir = outDir.wstring();
        } catch (const std::exception& e) {
            result->ok = false;
            result->status = L"正常处理失败";
            result->errorTitle = L"正常处理失败";
            result->errorMessage = widen(e.what());
        }
        if (!PostMessageW(target, WM_APP_JOB_DONE, (WPARAM)result, 0)) delete result;
    }).detach();
}


static std::string timestampForFileName() {
    SYSTEMTIME st{};
    GetLocalTime(&st);
    char buf[40];
    std::snprintf(buf, sizeof(buf), "%04d%02d%02d_%02d%02d%02d_%03d", st.wYear, st.wMonth, st.wDay, st.wHour, st.wMinute, st.wSecond, st.wMilliseconds);
    return buf;
}

static void backupExistingOutput(const fs::path& path, const fs::path& outDir, const std::string& stamp) {
    if (!fs::exists(path)) return;
    fs::path backupDir = outDir / L"_backup";
    fs::create_directories(backupDir);
    fs::path backup = backupDir / (path.stem().wstring() + L"_" + widen(stamp) + L"_before" + path.extension().wstring());
    int suffix = 1;
    while (fs::exists(backup)) {
        backup = backupDir / (path.stem().wstring() + L"_" + widen(stamp) + L"_before_" + std::to_wstring(suffix++) + path.extension().wstring());
    }
    fs::copy_file(path, backup);
}

static std::string makeRunConfigSnapshot(const std::vector<fs::path>& files, const MergeOptions& opts) {
    std::ostringstream ss;
    ss << "=== UG 后处理配置快照 / 版本留痕 ===\n";
    ss << "title=" << narrowUtf8(APP_TITLE) << "\n";
    ss << "m00=" << m00ModeCn(opts.m00_wait_mode) << "\n";
    ss << "g41_strategy=" << g41StrategyCn(opts.g41_close_strategy) << "\n";
    ss << "g54g56_mode=" << boolCn(opts.g54g56_mode) << "\n";
    ss << "work_offsets=" << formatWorkOffsetConfigText(opts.work_offsets) << "\n";
    ss << "experimental_compensation=" << boolCn(opts.experimental_compensation) << "\n";
    ss << "compensation_config=" << formatCompensationConfigText(opts.compensations) << "\n";
    ss << "compensation_limit_check=" << boolCn(opts.compensation_limit_check) << " limit=" << formatGcodeVal(opts.compensation_limit_abs) << "\n";
    ss << "shop_precheck_input=" << boolCn(opts.shop_precheck_input) << "\n";
    ss << "shop_keyword_preview=" << boolCn(opts.shop_keyword_preview) << "\n";
    ss << "shop_coord_dry_run=" << boolCn(opts.shop_coord_dry_run) << "\n";
    ss << "shop_g41_envelope=" << boolCn(opts.shop_g41_envelope) << "\n";
    ss << "shop_auto_backup=" << boolCn(opts.shop_auto_backup) << "\n";
    ss << "shop_config_snapshot=" << boolCn(opts.shop_config_snapshot) << "\n";
    ss << "inputs\n";
    for (const auto& p : files) ss << "- " << narrowUtf8(p.wstring()) << "\n";
    return ss.str();
}

void App::mergeProcess() {
    if (files.empty()) { MessageBoxW(hwnd, L"先添加题目文件再试", L"没有文件", MB_ICONWARNING); return; }
    auto filesCopy = files;
    MergeOptions opts = collectOptions();
    fs::path outDir = filesCopy[0].parent_path() / L"ok";
    std::wstring stem = files[0].stem().wstring();
    std::wregex tail(LR"(-\d+$)");
    std::wstring base = std::regex_replace(stem, tail, L"");
    fs::path outH = outDir / (base + L"H.ptp");
    fs::path outHH = outDir / (base + L"HH.ptp");
    bool writeH = true, writeHH = true;
    if (fs::exists(outH)) {
        std::wstring msg = L"目标文件已存在:\n" + outH.wstring() + L"\n\n确认覆盖?";
        writeH = MessageBoxW(hwnd, msg.c_str(), L"文件已存在", MB_YESNO | MB_DEFBUTTON2 | MB_ICONQUESTION) == IDYES;
    }
    if (fs::exists(outHH)) {
        std::wstring msg = L"目标文件已存在:\n" + outHH.wstring() + L"\n\n确认覆盖?";
        writeHH = MessageBoxW(hwnd, msg.c_str(), L"文件已存在", MB_YESNO | MB_DEFBUTTON2 | MB_ICONQUESTION) == IDYES;
    }
    if (!writeH && !writeHH) {
        setStatus(L"已取消覆盖");
        return;
    }
    HWND target = hwnd;
    setBusy(true, L"正在合并...");
    std::thread([filesCopy, opts, outDir, outH, outHH, writeH, writeHH, target]() {
        auto* result = new JobResult();
        result->kind = JobKind::Merge;
        auto postProgress = [target](const std::wstring& text) {
            auto* msg = new std::wstring(text);
            if (!PostMessageW(target, WM_APP_JOB_PROGRESS, (WPARAM)msg, 0)) delete msg;
        };
        try {
            std::vector<Segment> segs;
            segs.reserve(filesCopy.size());
            for (size_t i = 0; i < filesCopy.size(); ++i) {
                if ((i % 100) == 0) {
                    postProgress(L"正在合并：解析 " + std::to_wstring(i) + L" / " + std::to_wstring(filesCopy.size()));
                }
                const auto& p = filesCopy[i];
                segs.push_back(parseSegment(readTextLines(p), baseNameUtf8(p), p));
            }
            postProgress(L"正在合并：生成 H / HH 输出...");
            enforceCompensationLimitForOutput(opts, false);
            for (const auto& comp : opts.compensations) enforceExperimentalCompensationHardCap(comp);
            MergeOptions hOpts = opts; hOpts.version = "H";
            MergeOptions hhOpts = opts; hhOpts.version = "HH";
            std::string h = mergeSegments(segs, hOpts);
            std::string hh = mergeSegments(segs, hhOpts);
            postProgress(L"正在合并：写入磁盘...");
            fs::create_directories(outDir);
            if (opts.shop_auto_backup) {
                std::string stamp = timestampForFileName();
                if (writeH) backupExistingOutput(outH, outDir, stamp);
                if (writeHH) backupExistingOutput(outHH, outDir, stamp);
            }
            int written = 0;
            if (writeH) { writeUtf8File(outH, h); ++written; }
            if (writeHH) { writeUtf8File(outHH, hh); ++written; }
            if (opts.shop_config_snapshot) writeUtf8File(outDir / L"_run_config.txt", makeRunConfigSnapshot(filesCopy, opts));
            if (opts.safety_audit_report || hasShopPrecheckToggle(opts)) {
                std::string report = makeSafetyAuditReport(segs, opts, &h, &hh);
                fs::path reportPath = outDir / L"_safety_report.txt";
                writeUtf8File(reportPath, report);
                result->safetyText = std::move(report);
            }
            result->ok = true;
            result->status = L"已合并 " + std::to_wstring(written) + L" 个";
            result->logMessage = L"合并输出到 " + outDir.wstring();
            result->outDir = outDir.wstring();
        } catch (const std::exception& e) {
            result->ok = false;
            result->status = L"合并失败";
            result->errorTitle = L"合并失败";
            result->errorMessage = widen(e.what());
        }
        if (!PostMessageW(target, WM_APP_JOB_DONE, (WPARAM)result, 0)) delete result;
    }).detach();
}


void App::safetyReport() {
    if (files.empty()) { MessageBoxW(hwnd, L"先添加题目文件再试", L"没有文件", MB_ICONWARNING); return; }
    auto filesCopy = files;
    MergeOptions opts = collectOptions();
    opts.safety_audit_report = true;
    fs::path outDir = filesCopy[0].parent_path() / L"ok";
    HWND target = hwnd;
    setBusy(true, L"正在生成安全审计报告...");
    std::thread([filesCopy, cross, sideComp, outDir, target]() {
        auto* result = new JobResult();
        result->kind = JobKind::Safety;
        try {
            std::vector<Segment> segs;
            segs.reserve(filesCopy.size());
            for (const auto& p : filesCopy) segs.push_back(parseSegment(readTextLines(p), baseNameUtf8(p), p));
            MergeOptions hOpts = opts; hOpts.version = "H";
            MergeOptions hhOpts = opts; hhOpts.version = "HH";
            std::string h, hh;
            std::string report;
            try {
                h = mergeSegments(segs, hOpts);
                hh = mergeSegments(segs, hhOpts);
                report = makeSafetyAuditReport(segs, opts, &h, &hh);
            } catch (const std::exception& mergeError) {
                report = makeSafetyAuditReport(segs, opts, nullptr, nullptr);
                report += "\nERROR: 合并输出生成失败，无法完成 H/HH/M70/G41 包络复核: ";
                report += mergeError.what();
                report += "\n";
            }
            fs::create_directories(outDir);
            fs::path reportPath = outDir / L"_safety_report.txt";
            writeUtf8File(reportPath, report);
            result->safetyText = std::move(report);
            result->ok = true;
            result->status = L"安全审计报告已生成";
            result->logMessage = L"安全审计报告: " + reportPath.wstring();
        } catch (const std::exception& e) {
            result->ok = false;
            result->status = L"安全审计失败";
            result->errorTitle = L"安全审计失败";
            result->errorMessage = widen(e.what());
        }
        if (!PostMessageW(target, WM_APP_JOB_DONE, (WPARAM)result, 0)) delete result;
    }).detach();
}

void App::previewDiff() {
    if (files.empty()) { MessageBoxW(hwnd, L"先添加题目文件再试.", L"没有文件", MB_ICONWARNING); return; }
    auto filesCopy = files;
    MergeOptions opts = collectOptions();
    bool cross = checked(hwnd, ID_CROSS_G43);
    HWND target = hwnd;
    setBusy(true, L"正在生成预览...");
    std::thread([filesCopy, opts, cross, target]() {
        auto* result = new JobResult();
        result->kind = JobKind::Preview;
        try {
            std::vector<Segment> segs;
            for (auto& p : filesCopy) segs.push_back(parseSegment(readTextLines(p), baseNameUtf8(p), p));
            MergeOptions hOpts = opts; hOpts.version = "H";
            MergeOptions hhOpts = opts; hhOpts.version = "HH";
            std::string h = mergeSegments(segs, hOpts);
            std::string hh = mergeSegments(segs, hhOpts);

            std::string normal;
            std::string src;
            for (auto& p : filesCopy) {
                auto before = readNormalLines(p);
                auto after = splitLines(processNormalText(before, cross, opts.side_compensation_g41, opts.g41_close_strategy));
                normal += makeDiff(baseNameUtf8(p), before, after);
                src += "━━━ " + baseNameUtf8(p) + " ━━━\n";
                for (auto& ln : readTextLines(p)) src += ln + "\n";
                src += "\n";
            }
            result->ok = true;
            result->status = L"预览已刷新";
            result->normalText = std::move(normal);
            result->hText = makeDiff("源文件合并前 → H 版输出", splitLines(src), splitLines(h));
            result->hhText = makeDiff("源文件合并前 → HH 版输出", splitLines(src), splitLines(hh));
        } catch (const std::exception& e) {
            result->ok = false;
            result->status = L"预览失败";
            result->errorTitle = L"预览失败";
            result->errorMessage = widen(e.what());
        }
        if (!PostMessageW(target, WM_APP_JOB_DONE, (WPARAM)result, 0)) delete result;
    }).detach();
}

static CHARFORMAT2W makeCharFormat(COLORREF fg, COLORREF bg, bool bold, const wchar_t* face) {
    CHARFORMAT2W cf{};
    cf.cbSize = sizeof(cf);
    cf.dwMask = CFM_COLOR | CFM_BACKCOLOR | CFM_FACE | CFM_SIZE | CFM_BOLD;
    cf.crTextColor = fg;
    cf.crBackColor = bg;
    cf.yHeight = 200;
    cf.dwEffects = bold ? CFE_BOLD : 0;
    wcscpy_s(cf.szFaceName, face);
    return cf;
}

void App::setPreviewText(HWND edit, const std::string& content) {
    if (!edit) return;
    if (!richEditLib) {
        SetWindowTextW(edit, widen(content).c_str());
        return;
    }
    SendMessageW(edit, WM_SETREDRAW, FALSE, 0);
    SendMessageW(edit, EM_SETREADONLY, FALSE, 0);
    SetWindowTextW(edit, L"");
    SendMessageW(edit, EM_SETBKGNDCOLOR, 0, RGB(255, 255, 255));

    const COLORREF fileFg = RGB(21, 73, 143);   // Python C_PRIMARY_DARK
    const COLORREF hunkFg = RGB(106, 92, 219);
    const COLORREF hunkBg = RGB(240, 234, 254);
    const COLORREF addFg = RGB(30, 107, 30);
    const COLORREF addBg = RGB(230, 255, 230);
    const COLORREF remFg = RGB(163, 21, 21);
    const COLORREF remBg = RGB(255, 230, 230);
    const COLORREF ctxFg = RGB(107, 119, 145);  // Python C_MUTED
    const COLORREF white = RGB(255, 255, 255);

    for (const auto& rawLine : splitLines(content)) {
        std::string line = rawLine;
        CHARFORMAT2W cf{};
        if (startsWith(line, "━━━")) cf = makeCharFormat(fileFg, white, true, L"Consolas");
        else if (startsWith(line, "@@")) cf = makeCharFormat(hunkFg, hunkBg, false, L"Consolas");
        else if (startsWith(line, "+")) cf = makeCharFormat(addFg, addBg, false, L"Consolas");
        else if (startsWith(line, "-")) cf = makeCharFormat(remFg, remBg, false, L"Consolas");
        else cf = makeCharFormat(ctxFg, white, false, L"Consolas");

        CHARRANGE cr{-1, -1};
        SendMessageW(edit, EM_EXSETSEL, 0, (LPARAM)&cr);
        SendMessageW(edit, EM_SETCHARFORMAT, SCF_SELECTION, (LPARAM)&cf);
        std::wstring wline = widen(line + "\r\n");
        SendMessageW(edit, EM_REPLACESEL, FALSE, (LPARAM)wline.c_str());
    }
    SendMessageW(edit, EM_SETREADONLY, TRUE, 0);
    SendMessageW(edit, WM_SETREDRAW, TRUE, 0);
    InvalidateRect(edit, nullptr, TRUE);
}

void App::setPlainText(HWND edit, const std::string& content) {
    if (!edit) return;
    if (richEditLib) {
        SendMessageW(edit, EM_SETREADONLY, FALSE, 0);
        SendMessageW(edit, EM_SETBKGNDCOLOR, 0, RGB(255, 255, 255));
        CHARFORMAT2W cf = makeCharFormat(RGB(0, 0, 0), RGB(255, 255, 255), false, L"Microsoft YaHei UI");
        CHARRANGE cr{0, -1};
        SendMessageW(edit, EM_EXSETSEL, 0, (LPARAM)&cr);
        SendMessageW(edit, EM_SETCHARFORMAT, SCF_SELECTION, (LPARAM)&cf);
        SetWindowTextW(edit, widen(content).c_str());
        SendMessageW(edit, EM_SETREADONLY, TRUE, 0);
    } else {
        SetWindowTextW(edit, widen(content).c_str());
    }
}

void App::refreshText() {
    if (renderedNormal != normalCache) {
        setPreviewText(txtNormal, normalCache);
        renderedNormal = normalCache;
    }
    if (renderedH != hCache) {
        setPreviewText(txtH, hCache);
        renderedH = hCache;
    }
    if (renderedHH != hhCache) {
        setPreviewText(txtHH, hhCache);
        renderedHH = hhCache;
    }
    if (renderedSafety != safetyCache) {
        setPlainText(txtSafety, safetyCache);
        renderedSafety = safetyCache;
    }
    if (renderedLog != logCache) {
        setPlainText(txtLog, logCache);
        renderedLog = logCache;
    }
    updateTabVisibility();
}

void App::updateTabVisibility() {
    int sel = tabs ? TabCtrl_GetCurSel(tabs) : 0;
    if (sel < 0) sel = 0;
    if (sel == activeTab) return;
    HWND edits[] = {txtNormal, txtH, txtHH, txtSafety, txtLog};
    HDWP dwp = BeginDeferWindowPos(5);
    for (int i = 0; i < 5; ++i) {
        if (!edits[i]) continue;
        dwp = DeferWindowPos(dwp, edits[i], nullptr, 0, 0, 0, 0,
                             SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER |
                             SWP_NOACTIVATE | (i == sel ? SWP_SHOWWINDOW : SWP_HIDEWINDOW));
    }
    if (dwp) EndDeferWindowPos(dwp);
    activeTab = sel;
}

void App::moveSelected(int delta) {
    int count = (int)SendMessageW(list, LB_GETSELCOUNT, 0, 0);
    if (count <= 0) return;
    std::vector<int> sel(count);
    SendMessageW(list, LB_GETSELITEMS, count, (LPARAM)sel.data());
    if (delta < 0 && sel.front() == 0) return;
    if (delta > 0 && sel.back() == (int)files.size() - 1) return;
    if (delta < 0) {
        for (int i : sel) std::swap(files[i], files[i - 1]);
    } else {
        for (auto it = sel.rbegin(); it != sel.rend(); ++it) std::swap(files[*it], files[*it + 1]);
    }
    redrawList();
    for (int i : sel) SendMessageW(list, LB_SETSEL, TRUE, i + delta);
}

void App::removeSelected() {
    int count = (int)SendMessageW(list, LB_GETSELCOUNT, 0, 0);
    if (count <= 0) return;
    std::vector<int> sel(count);
    SendMessageW(list, LB_GETSELITEMS, count, (LPARAM)sel.data());
    std::sort(sel.rbegin(), sel.rend());
    for (int i : sel) files.erase(files.begin() + i);
    redrawList();
}

void App::browseFiles() {
    if (busy) return;
    pauseTooltips();
    wchar_t buf[32768]{};
    OPENFILENAMEW ofn{};
    ofn.lStructSize = sizeof(ofn);
    ofn.hwndOwner = hwnd;
    ofn.lpstrFilter = L"PTP\0*.ptp\0所有文件\0*.*\0";
    ofn.lpstrFile = buf;
    ofn.nMaxFile = (DWORD)std::size(buf);
    ofn.Flags = OFN_ALLOWMULTISELECT | OFN_EXPLORER | OFN_FILEMUSTEXIST;
    if (!GetOpenFileNameW(&ofn)) {
        resumeTooltips();
        return;
    }
    std::vector<fs::path> inputs;
    wchar_t* p = buf;
    std::wstring dir = p;
    p += dir.size() + 1;
    if (*p == 0) {
        inputs.emplace_back(dir);
    } else {
        for (; *p; p += wcslen(p) + 1) inputs.emplace_back(fs::path(dir) / p);
    }
    resumeTooltips();
    startLoad(std::move(inputs), L"正在扫描...");
}

void App::browseFolder() {
    if (busy) return;
    pauseTooltips();
    IFileOpenDialog* dlg = nullptr;
    HRESULT hr = CoCreateInstance(CLSID_FileOpenDialog, nullptr, CLSCTX_INPROC_SERVER, IID_PPV_ARGS(&dlg));
    if (FAILED(hr) || !dlg) {
        resumeTooltips();
        return;
    }
    DWORD opts = 0;
    dlg->GetOptions(&opts);
    dlg->SetOptions(opts | FOS_PICKFOLDERS | FOS_FORCEFILESYSTEM | FOS_PATHMUSTEXIST);
    dlg->SetTitle(L"选择文件夹");
    std::vector<fs::path> inputs;
    hr = dlg->Show(hwnd);
    if (SUCCEEDED(hr)) {
        IShellItem* item = nullptr;
        if (SUCCEEDED(dlg->GetResult(&item)) && item) {
            PWSTR path = nullptr;
            if (SUCCEEDED(item->GetDisplayName(SIGDN_FILESYSPATH, &path)) && path) {
                inputs.emplace_back(path);
                CoTaskMemFree(path);
            }
            item->Release();
        }
    }
    dlg->Release();
    resumeTooltips();
    startLoad(std::move(inputs), L"正在扫描...");
}

static const char* eventKindName(nc::EventKind kind) {
    switch (kind) {
    case nc::EventKind::Empty: return "Empty";
    case nc::EventKind::Comment: return "Comment";
    case nc::EventKind::RawLine: return "RawLine";
    case nc::EventKind::ToolChange: return "ToolChange";
    case nc::EventKind::ToolPreselect: return "ToolPreselect";
    case nc::EventKind::WorkOffsetChange: return "WorkOffsetChange";
    case nc::EventKind::RapidPosition: return "RapidPosition";
    case nc::EventKind::LengthComp: return "LengthComp";
    case nc::EventKind::Retract: return "Retract";
    case nc::EventKind::CuttingMove: return "CuttingMove";
    case nc::EventKind::Spindle: return "Spindle";
    case nc::EventKind::Coolant: return "Coolant";
    }
    return "Unknown";
}

static std::string describeMachineState(const nc::MachineModalState& state) {
    std::ostringstream ss;
    ss << "WCS=" << state.currentWcs << " DIST=" << state.distanceMode;
    if (!state.motionMode.empty()) ss << " MOTION=" << state.motionMode;
    if (state.tool) ss << " T=" << *state.tool;
    if (state.h) ss << " H=" << *state.h;
    return ss.str();
}

static std::string describeTokens(const std::vector<nc::GToken>& tokens) {
    std::ostringstream ss;
    for (size_t i = 0; i < tokens.size(); ++i) {
        if (i) ss << ' ';
        ss << tokens[i].ch << formatGcodeVal(tokens[i].val);
    }
    return ss.str();
}

static std::string makeSemanticTrace(const std::vector<std::string>& lines) {
    nc::MachineModalState state;
    std::ostringstream ss;
    for (size_t i = 0; i < lines.size(); ++i) {
        nc::MachineModalState before = state;
        auto ev = nc::classifyLine(lines[i], state);
        ss << "line " << (i + 1) << ": " << trim(lines[i]) << "\n";
        ss << "  before: " << describeMachineState(before) << "\n";
        ss << "  tokens: " << describeTokens(ev.tokens) << "\n";
        ss << "  event: " << eventKindName(ev.kind);
        if (!ev.explicitWcs.empty()) ss << " explicitWcs=" << ev.explicitWcs;
        if (!ev.effectiveWcs.empty()) ss << " effectiveWcs=" << ev.effectiveWcs;
        if (ev.tool) ss << " T=" << *ev.tool;
        if (ev.h) ss << " H=" << *ev.h;
        if (ev.x) ss << " X=" << formatGcodeVal(*ev.x);
        if (ev.y) ss << " Y=" << formatGcodeVal(*ev.y);
        if (ev.z) ss << " Z=" << formatGcodeVal(*ev.z);
        ss << "\n";
        ss << "  after: " << describeMachineState(state) << "\n\n";
    }
    return ss.str();
}


static bool safetyReportHasBlockingIssue(const std::string& report) {
    return report.find("FATAL") != std::string::npos || report.find("ERROR") != std::string::npos;
}

static std::vector<Segment> parseSegmentsFromArgs(const std::vector<std::wstring>& args, size_t start) {
    std::vector<Segment> segs;
    for (size_t i = start; i < args.size(); ++i) {
        if (isCliOption(args[i])) {
            if (cliOptionTakesValue(args[i]) && i + 1 < args.size()) ++i;
            continue;
        }
        fs::path p = args[i];
        segs.push_back(parseSegment(readTextLines(p), baseNameUtf8(p), p));
    }
    return segs;
}

static std::vector<Segment> parseSegmentsFromListFile(const fs::path& listFile) {
    std::vector<Segment> segs;
    for (const auto& line : splitLines(readFileBytes(listFile))) {
        std::string s = trim(line);
        if (s.empty()) continue;
        fs::path p = widen(s);
        segs.push_back(parseSegment(readTextLines(p), baseNameUtf8(p), p));
    }
    return segs;
}

static const char* eventKindName(nc::EventKind kind) {
    switch (kind) {
    case nc::EventKind::Empty: return "Empty";
    case nc::EventKind::Comment: return "Comment";
    case nc::EventKind::RawLine: return "RawLine";
    case nc::EventKind::ToolChange: return "ToolChange";
    case nc::EventKind::ToolPreselect: return "ToolPreselect";
    case nc::EventKind::WorkOffsetChange: return "WorkOffsetChange";
    case nc::EventKind::RapidPosition: return "RapidPosition";
    case nc::EventKind::LengthComp: return "LengthComp";
    case nc::EventKind::Retract: return "Retract";
    case nc::EventKind::CuttingMove: return "CuttingMove";
    case nc::EventKind::Spindle: return "Spindle";
    case nc::EventKind::Coolant: return "Coolant";
    }
    return "Unknown";
}

static std::string describeMachineState(const nc::MachineModalState& state) {
    std::ostringstream ss;
    ss << "WCS=" << state.currentWcs << " DIST=" << state.distanceMode;
    if (!state.motionMode.empty()) ss << " MOTION=" << state.motionMode;
    if (state.tool) ss << " T=" << *state.tool;
    if (state.h) ss << " H=" << *state.h;
    return ss.str();
}

static std::string describeTokens(const std::vector<nc::GToken>& tokens) {
    std::ostringstream ss;
    for (size_t i = 0; i < tokens.size(); ++i) {
        if (i) ss << ' ';
        ss << tokens[i].ch << formatGcodeVal(tokens[i].val);
    }
    return ss.str();
}

static std::string makeSemanticTrace(const std::vector<std::string>& lines) {
    nc::MachineModalState state;
    std::ostringstream ss;
    for (size_t i = 0; i < lines.size(); ++i) {
        nc::MachineModalState before = state;
        auto ev = nc::classifyLine(lines[i], state);
        ss << "line " << (i + 1) << ": " << trim(lines[i]) << "\n";
        ss << "  before: " << describeMachineState(before) << "\n";
        ss << "  tokens: " << describeTokens(ev.tokens) << "\n";
        ss << "  event: " << eventKindName(ev.kind);
        if (!ev.explicitWcs.empty()) ss << " explicitWcs=" << ev.explicitWcs;
        if (!ev.effectiveWcs.empty()) ss << " effectiveWcs=" << ev.effectiveWcs;
        if (ev.tool) ss << " T=" << *ev.tool;
        if (ev.h) ss << " H=" << *ev.h;
        if (ev.x) ss << " X=" << formatGcodeVal(*ev.x);
        if (ev.y) ss << " Y=" << formatGcodeVal(*ev.y);
        if (ev.z) ss << " Z=" << formatGcodeVal(*ev.z);
        ss << "\n";
        ss << "  after: " << describeMachineState(state) << "\n\n";
    }
    return ss.str();
}

static int runCli(const std::vector<std::wstring>& args) {
    try {
        if (args.size() >= 3 && args[1] == L"--dump-tooltips") {
            dumpTooltipsFile(args[2]);
            return 0;
        }
        if (args.size() >= 4 && (args[1] == L"--trace-semantics" || args[1] == L"--dump-events")) {
            fs::path out = args[2];
            fs::path input = args[3];
            writeUtf8File(out, makeSemanticTrace(readNormalLines(input)));
            return 0;
        }
        if (args.size() >= 4 && args[1] == L"--trace-merge") {
            fs::path out = args[2];
            std::vector<Segment> segs;
            for (size_t i = 3; i < args.size(); ++i) {
                if (isCliOption(args[i])) {
                    if (cliOptionTakesValue(args[i]) && i + 1 < args.size()) ++i;
            for (size_t i = 4; i < args.size(); ++i) {
                if (isCliOption(args[i])) {
                    if (cliOptionTakesValue(args[i]) && i + 1 < args.size()) ++i;
                    continue;
                }
                fs::path p = args[i];
                segs.push_back(parseSegment(readTextLines(p), baseNameUtf8(p), p));
            }
            MergeOptions opts;
            applyMergeCliOptions(opts, args, 3);
            writeUtf8File(out, describeMergeDecisionTrace(segs, opts));
            return 0;
        }
        if (args.size() >= 5 && args[1] == L"--trace-merge-list") {
            fs::path out = args[2];
            fs::path listFile = args[3];
            std::vector<Segment> segs;
            for (const auto& line : splitLines(readFileBytes(listFile))) {
                std::string s = trim(line);
                if (s.empty()) continue;
                fs::path p = widen(s);
                segs.push_back(parseSegment(readTextLines(p), baseNameUtf8(p), p));
            }
            MergeOptions opts;
            applyMergeCliOptions(opts, args, 4);
            writeUtf8File(out, describeMergeDecisionTrace(segs, opts));
            return 0;
        }
        if (args.size() >= 4 && args[1] == L"--normal-tree") {
            fs::path out = args[2];
            MergeOptions opts;
            opts.safety_audit_report = true;
            applyMergeCliOptions(opts, args, 3);
            std::vector<Segment> segs = parseSegmentsFromArgs(args, 3);
            MergeOptions hOpts = opts; hOpts.version = "H";
            MergeOptions hhOpts = opts; hhOpts.version = "HH";
            std::string h = mergeSegments(segs, hOpts);
            std::string hh = mergeSegments(segs, hhOpts);
            std::string report = makeSafetyAuditReport(segs, opts, &h, &hh);
            writeUtf8File(out, report);
            return opts.safety_audit_strict && safetyReportHasBlockingIssue(report) ? 3 : 0;
        }
        if (args.size() >= 4 && args[1] == L"--safety-report-list") {
            fs::path out = args[2];
            fs::path listFile = args[3];
            MergeOptions opts;
            opts.safety_audit_report = true;
            applyMergeCliOptions(opts, args, 4);
            std::vector<Segment> segs = parseSegmentsFromListFile(listFile);
            MergeOptions hOpts = opts; hOpts.version = "H";
            MergeOptions hhOpts = opts; hhOpts.version = "HH";
            std::string h = mergeSegments(segs, hOpts);
            std::string hh = mergeSegments(segs, hhOpts);
            std::string report = makeSafetyAuditReport(segs, opts, &h, &hh);
            writeUtf8File(out, report);
            return opts.safety_audit_strict && safetyReportHasBlockingIssue(report) ? 3 : 0;
        }
        if (args.size() >= 4 && (args[1] == L"--trace-semantics" || args[1] == L"--dump-events")) {
            fs::path out = args[2];
            fs::path input = args[3];
            writeUtf8File(out, makeSemanticTrace(readNormalLines(input)));
            return 0;
        }
        if (args.size() >= 4 && args[1] == L"--trace-merge") {
            fs::path out = args[2];
            std::vector<Segment> segs;
            for (size_t i = 3; i < args.size(); ++i) {
                if (isCliOption(args[i])) {
                    if (cliOptionTakesValue(args[i]) && i + 1 < args.size()) ++i;
                    continue;
                }
                fs::path p = args[i];
                segs.push_back(parseSegment(readTextLines(p), baseNameUtf8(p), p));
            }
            MergeOptions opts;
            applyMergeCliOptions(opts, args, 3);
            writeUtf8File(out, describeMergeDecisionTrace(segs, opts));
            return 0;
        }
        if (args.size() >= 5 && args[1] == L"--trace-merge-list") {
            fs::path out = args[2];
            fs::path listFile = args[3];
            std::vector<Segment> segs;
            for (const auto& line : splitLines(readFileBytes(listFile))) {
                std::string s = trim(line);
                if (s.empty()) continue;
                fs::path p = widen(s);
                segs.push_back(parseSegment(readTextLines(p), baseNameUtf8(p), p));
            }
            MergeOptions opts;
            applyMergeCliOptions(opts, args, 4);
            writeUtf8File(out, describeMergeDecisionTrace(segs, opts));
            return 0;
        }
        if (args.size() >= 4 && args[1] == L"--normal-tree") {
            fs::path root = fs::absolute(args[2]);
            fs::path outRoot = args[3];
            bool cross = true;
            bool sideCompG41 = false;
            // 修复 #1: CLI 默认档从 SAFEST 改为 BALANCED（与 GUI/规格一致）
            std::string g41CloseStrategy = G41_RISK_BALANCED;
            std::string g41CloseStrategy = G41_RISK_BALANCED;
            for (size_t i = 4; i < args.size(); ++i) {
                if (args[i] == L"--no-cross") cross = false;
                if (args[i] == L"--side-comp-g41") sideCompG41 = true;
                if (args[i] == L"--g41-close-segment") {
                    g41CloseStrategy = G41_CLOSE_SEGMENT;
                    std::wcerr << L"WARNING: --g41-close-segment legacy high-risk mode: G41 may span G0/Z lift/fixed cycles; M70 may alarm/interfere. Use --g41-close-adaptive for production.\n";
            bool cross = true;
            bool sideCompG41 = false;
            std::string g41CloseStrategy = G41_CLOSE_ADAPTIVE;
            for (size_t i = 4; i < args.size(); ++i) {
                if (args[i] == L"--no-cross") cross = false;
                if (args[i] == L"--side-comp-g41") sideCompG41 = true;
        else if (args[i] == L"--g41-close-segment") {
            opts.g41_close_strategy = G41_CLOSE_SEGMENT;
            std::wcerr << L"WARNING: --g41-close-segment 是旧版高风险策略，G41 可能跨过 G0/抬刀/固定循环，M70 可能补偿干涉或报警；生产加工建议使用 --g41-close-adaptive。\n";
        }
        else if (args[i] == L"--g41-close-adaptive") opts.g41_close_strategy = G41_CLOSE_ADAPTIVE;
            }
            for (auto& ent : fs::recursive_directory_iterator(root)) {
                if (!ent.is_regular_file()) continue;
                fs::path p = ent.path();
                if (!endsWithLower(p.wstring(), L".ptp")) continue;
                fs::path rel = fs::relative(p, root);
                fs::path out = outRoot / rel;
                fs::create_directories(out.parent_path());
                writeUtf8File(out, processNormalText(readNormalLines(p), cross, sideCompG41, g41CloseStrategy));
            }
        if (args.size() >= 4 && args[1] == L"--normal") {
            fs::path out = args[2];
            fs::path input = args[3];
            bool cross = true;
            bool sideCompG41 = false;
            // 修复 #1: CLI 默认档从 SAFEST 改为 BALANCED（与 GUI/规格一致）
            std::string g41CloseStrategy = G41_RISK_BALANCED;
            for (size_t i = 4; i < args.size(); ++i) {
            std::string g41CloseStrategy = G41_RISK_BALANCED;
            for (size_t i = 4; i < args.size(); ++i) {
                if (args[i] == L"--no-cross") cross = false;
                if (args[i] == L"--side-comp-g41") sideCompG41 = true;
                if (args[i] == L"--g41-close-segment") {
                    g41CloseStrategy = G41_CLOSE_SEGMENT;
                    std::wcerr << L"WARNING: --g41-close-segment legacy high-risk mode: G41 may span G0/Z lift/fixed cycles; M70 may alarm/interfere. Use --g41-close-adaptive for production.\n";
                }
                if (args[i] == L"--g41-close-adaptive") g41CloseStrategy = G41_CLOSE_ADAPTIVE;
                if (args[i] == L"--g41-risk" && i + 1 < args.size()) applyG41RiskCliOption(g41CloseStrategy, args[++i]);
            }
            writeUtf8File(out, processNormalText(readNormalLines(input), cross, sideCompG41, g41CloseStrategy));
            return 0;
        }
        if (args.size() >= 4 && args[1] == L"--normal-preview") {
            fs::path out = args[2];
            fs::path input = args[3];
            bool cross = true;
            bool sideCompG41 = false;
            // 修复 #1: CLI 默认档从 SAFEST 改为 BALANCED（与 GUI/规格一致）
            std::string g41CloseStrategy = G41_RISK_BALANCED;
            for (size_t i = 4; i < args.size(); ++i) {
            for (size_t i = 4; i < args.size(); ++i) {
                if (args[i] == L"--no-cross") cross = false;
                if (args[i] == L"--side-comp-g41") sideCompG41 = true;
                if (args[i] == L"--g41-close-segment") {
                    g41CloseStrategy = G41_CLOSE_SEGMENT;
                    std::wcerr << L"WARNING: --g41-close-segment legacy high-risk mode: G41 may span G0/Z lift/fixed cycles; M70 may alarm/interfere. Use --g41-close-adaptive for production.\n";
                }
                if (args[i] == L"--g41-close-adaptive") g41CloseStrategy = G41_CLOSE_ADAPTIVE;
                if (args[i] == L"--g41-risk" && i + 1 < args.size()) applyG41RiskCliOption(g41CloseStrategy, args[++i]);
            }
            auto before = readNormalLines(input);
                auto after = splitLines(processNormalText(before, cross, opts.side_compensation_g41, opts.g41_close_strategy));
            writeUtf8File(out, makeDiff(baseNameUtf8(input), before, after));
            return 0;
        }
        if (args.size() >= 5 && args[1] == L"--merge") {
            fs::path outH = args[2];
            fs::path outHH = args[3];
            std::vector<Segment> segs;
            std::vector<fs::path> inputFiles;
            for (size_t i = 4; i < args.size(); ++i) {
                if (isCliOption(args[i])) {
                    if (cliOptionTakesValue(args[i]) && i + 1 < args.size()) ++i;
                    continue;
                }
                fs::path p = args[i];
                inputFiles.push_back(p);
                segs.push_back(parseSegment(readTextLines(p), baseNameUtf8(p), p));
            }
            MergeOptions h; h.version = "H";
            MergeOptions hh; hh.version = "HH";
            applyMergeCliOptions(h, args, 4);
            applyMergeCliOptions(hh, args, 4);
            std::string hText = mergeSegments(segs, h);
            std::string hhText = mergeSegments(segs, hh);
            if (h.shop_auto_backup || hh.shop_auto_backup) {
                std::string stamp = timestampForFileName();
                backupExistingOutput(outH, outH.parent_path(), stamp);
                backupExistingOutput(outHH, outHH.parent_path(), stamp);
            }
            writeUtf8File(outH, hText);
            writeUtf8File(outHH, hhText);
            if (h.shop_config_snapshot || hh.shop_config_snapshot) writeUtf8File(outH.parent_path() / L"_run_config.txt", makeRunConfigSnapshot(inputFiles, h));
            return 0;
            enforceCompensationLimitForOutput(hh, true);
            for (const auto& comp : h.compensations) enforceExperimentalCompensationHardCap(comp);
            std::string hText = mergeSegments(segs, h);
            std::string hhText = mergeSegments(segs, hh);
            if (h.shop_auto_backup || hh.shop_auto_backup) {
                std::string stamp = timestampForFileName();
                backupExistingOutput(outH, outH.parent_path(), stamp);
                backupExistingOutput(outHH, outHH.parent_path(), stamp);
            }
            writeUtf8File(outH, hText);
            writeUtf8File(outHH, hhText);
            if (h.shop_config_snapshot || hh.shop_config_snapshot) writeUtf8File(outH.parent_path() / L"_run_config.txt", makeRunConfigSnapshot(inputFiles, h));
            if (h.safety_audit_report || hh.safety_audit_report || hasShopPrecheckToggle(h) || hasShopPrecheckToggle(hh)) {
                std::string report = makeSafetyAuditReport(segs, h, &hText, &hhText);
                writeUtf8File(outH.parent_path() / L"_safety_report.txt", report);
                if ((h.safety_audit_strict || hh.safety_audit_strict) && safetyReportHasBlockingIssue(report)) return 3;
            }
            return 0;
        }
        if (args.size() >= 5 && args[1] == L"--merge-list") {
            fs::path outH = args[2];
            fs::path outHH = args[3];
            fs::path listFile = args[4];
            std::vector<Segment> segs;
            std::vector<fs::path> inputFiles;
            for (const auto& line : splitLines(readFileBytes(listFile))) {
                std::string s = trim(line);
                if (s.empty()) continue;
                fs::path p = widen(s);
                inputFiles.push_back(p);
                segs.push_back(parseSegment(readTextLines(p), baseNameUtf8(p), p));
            }
            MergeOptions h; h.version = "H";
            MergeOptions hh; hh.version = "HH";
            applyMergeCliOptions(h, args, 5);
            applyMergeCliOptions(hh, args, 5);
            std::string hText = mergeSegments(segs, h);
            std::string hhText = mergeSegments(segs, hh);
            if (h.shop_auto_backup || hh.shop_auto_backup) {
                std::string stamp = timestampForFileName();
                backupExistingOutput(outH, outH.parent_path(), stamp);
                backupExistingOutput(outHH, outHH.parent_path(), stamp);
            }
            writeUtf8File(outH, hText);
            writeUtf8File(outHH, hhText);
            if (h.shop_config_snapshot || hh.shop_config_snapshot) writeUtf8File(outH.parent_path() / L"_run_config.txt", makeRunConfigSnapshot(inputFiles, h));
            return 0;
            enforceCompensationLimitForOutput(hh, true);
            for (const auto& comp : h.compensations) enforceExperimentalCompensationHardCap(comp);
            std::string hText = mergeSegments(segs, h);
            std::string hhText = mergeSegments(segs, hh);
            if (h.shop_auto_backup || hh.shop_auto_backup) {
                std::string stamp = timestampForFileName();
                backupExistingOutput(outH, outH.parent_path(), stamp);
                backupExistingOutput(outHH, outHH.parent_path(), stamp);
            }
            writeUtf8File(outH, hText);
            writeUtf8File(outHH, hhText);
            if (h.shop_config_snapshot || hh.shop_config_snapshot) writeUtf8File(outH.parent_path() / L"_run_config.txt", makeRunConfigSnapshot(inputFiles, h));
            if (h.safety_audit_report || hh.safety_audit_report || hasShopPrecheckToggle(h) || hasShopPrecheckToggle(hh)) {
                std::string report = makeSafetyAuditReport(segs, h, &hText, &hhText);
                writeUtf8File(outH.parent_path() / L"_safety_report.txt", report);
                if ((h.safety_audit_strict || hh.safety_audit_strict) && safetyReportHasBlockingIssue(report)) return 3;
            }
            return 0;
        }
        if (args.size() >= 4 && args[1] == L"--scan-tree") {
            fs::path out = args[2];
            fs::path root = args[3];
            LoadOptions opts;
            opts.allowHh = false;
            // CLI 扫描树用于批量清点，默认不深读 -11 文件，避免大目录扫描被 45MB 级 PTP 拖慢；如需过滤试刀可另走 GUI/显式流程。
            opts.filterTry = false;
            for (size_t i = 4; i < args.size(); ++i) {
                if (args[i] == L"--allow-hh") opts.allowHh = true;
                if (args[i] == L"--no-filter-try") opts.filterTry = false;
            }
            LoadScanResult scan = scanLoadInputs({root}, {}, opts);
            std::ostringstream ss;
            ss << "added\t" << scan.added << "\n";
            ss << "skipped\t" << (scan.skippedHh + scan.skippedTry + scan.skippedOther) << "\n";
            ss << "skipped_hh\t" << scan.skippedHh << "\n";
            ss << "skipped_try\t" << scan.skippedTry << "\n";
            ss << "skipped_other\t" << scan.skippedOther << "\n";
            for (const auto& p : scan.paths) ss << narrowUtf8(p.wstring()) << "\n";
            writeUtf8File(out, ss.str());
            return 0;
        }
        if (args.size() >= 2 && args[1] == L"--version") return 0;
    } catch (const std::exception& e) {
        // 修复 #3、#9: 捕获异常并输出 e.what() 到 stderr，便于排错
        writeCliWarning(std::string("错误: ") + e.what() + "\n");
        return 2;
    } catch (...) {
        writeCliWarning("错误: 未知异常\n");
        return 2;
    }
    // 未匹配任何子命令
    writeCliWarning("错误: 未识别的命令或参数不足。使用 --help 查看用法。\n");
    return 1;
}

int WINAPI wWinMain(HINSTANCE hInstance, HINSTANCE, PWSTR, int) {
    int argc = 0;
    LPWSTR* argv = CommandLineToArgvW(GetCommandLineW(), &argc);
    if (argv && argc > 1) {
        std::vector<std::wstring> args(argv, argv + argc);
        LocalFree(argv);
        return runCli(args);
    }
    if (argv) LocalFree(argv);
    App app;
    g_app = &app;
    HRESULT coInit = CoInitializeEx(nullptr, COINIT_APARTMENTTHREADED | COINIT_DISABLE_OLE1DDE);
    if (!app.create(hInstance)) {
        if (SUCCEEDED(coInit)) CoUninitialize();
        return 1;
    }
    MSG msg;
    while (GetMessageW(&msg, nullptr, 0, 0)) {
        TranslateMessage(&msg);
        DispatchMessageW(&msg);
    }
    if (SUCCEEDED(coInit)) CoUninitialize();
    return 0;
}