vxlan 0.4.2 → 0.5.0

data/lib/vxlan/cli/report.rb

@@ -50,19 +50,19 @@ module Vxlan
       def finish(results, interrupted: false, requested: [], report_error: nil, execution_error: nil, output_error: nil)
         @report.finish(results, interrupted: interrupted, requested: requested, report_error: report_error,
           execution_error: execution_error, output_error: output_error, review: @review_summary) do |summary|
-          pending = summary.fetch(:pending)
-          text = [ "VXLAN 证据：#{summary.fetch(:status)}；完成 #{results.size} 台", "分类：#{summary.fetch(:counts)}", "证据完整性不代表 Fabric 健康。" ]
-          text << "逐设备诊断：devices/；候选脚本：scripts/；所有候选配置未执行。"
+          pending = summary.fetch("pending")
+          text = [ "VXLAN evidence: #{summary.fetch('status')}; completed #{summary.fetch('completed')} devices", "Categories: #{summary.fetch('counts')}", "Complete evidence does not establish Fabric health." ]
+          text << "Per-device diagnostics: devices/; candidate scripts: scripts/; no candidate configuration was executed."
           text << @review_text if @review_text
-          text << "批次报告状态：参见 summary.json；文本中的证据状态不确认报告发布完成。"
-          text << "报告错误：#{report_error}" if report_error
-          text << "执行错误：#{execution_error}" if execution_error
-          text << "进度输出错误：#{output_error[:error_type]}；设备结果已保留" if output_error
-          results.each do |r|
-            saved = r[:report_saved] == true ? "已保存" : "保存未确认"
-            text << "#{r[:device]['host']}\t#{r[:device]['name']}\t#{r[:status]}\t#{saved}\t#{r[:error]}"
+          text << "Batch report status: see summary.json; evidence status in text does not confirm report publication."
+          text << "Report error: #{summary['report_error']}" if summary["report_error"]
+          text << "Execution error: #{summary['execution_error']}" if summary["execution_error"]
+          text << "Progress output error: #{summary['output_error']['error_type']}; device results retained" if summary["output_error"]
+          summary.fetch("devices").each do |r|
+            saved = r["report_saved"] == true ? "saved" : "persistence unconfirmed"
+            text << "#{r['device']['host']}\t#{r['device']['name']}\t#{r['status']}\t#{saved}\t#{r['error']}"
           end
-          pending.each { |device| text << "#{device['host']}\t#{device['name']}\t未采集" }
+          pending.each { |device| text << "#{device['host']}\t#{device['name']}\tnot collected" }
           text.join("\n") + "\n"
         end
       end

data/lib/vxlan/cli/review/fabric.rb

@@ -13,35 +13,35 @@ module Vxlan
         # 相同事实合并展示；规则版本保持匹配顺序，完整证据由聚合计划保存。
         def fabric_text(audit, documents)
           by_host = documents.to_h { |document| [ document.fetch("device").fetch("host"), document ] }
-          lines = [ "Fabric 共同业务一致性", "范围：按显式 Fabric 和角色比较共同 VNI；Leaf、Border 分开比较，Spine 检查业务承载配置。", "部署事实联合 VLAN/NVE/EVPN 识别；不完整部署不等于未部署。保留部署范围差异。", "ACL 比较包含有序规则与依赖对象；不以多数无 ACL 为删除依据。", "" ]
+          lines = [ "Fabric shared-service consistency", "Scope: compare shared VNIs within explicit Fabrics and roles; compare Leaf and Border separately, and check Spine for service-bearing configuration.", "Deployment facts combine VLAN/NVE/EVPN evidence; incomplete deployment does not mean absence. Deployment scope differences are retained.", "ACL comparison includes ordered rules and dependencies; a majority without an ACL is not grounds for removal.", "" ]
           inventory = audit[:inventory]
           if inventory
-            lines << "覆盖：已纳入 #{inventory[:assigned].size} 台；未纳入 #{inventory[:unassigned].size} 台；缺证据 #{inventory[:missing].size} 台。"
+            lines << "Coverage: included #{inventory[:assigned].size} devices; excluded #{inventory[:unassigned].size} devices; missing evidence #{inventory[:missing].size} devices."
             inventory[:groups].each do |fabric, roles|
-              lines << "#{fabric}：Leaf #{roles['leaves'].size} / Border #{roles['borders'].size} / Spine #{roles['spines'].size}"
+              lines << "#{fabric}: Leaf #{roles['leaves'].size} / Border #{roles['borders'].size} / Spine #{roles['spines'].size}"
               %w[leaves borders].each do |role|
                 services = audit[:coverage].select { |entry| entry[:fabric] == fabric && entry[:role] == role }
                 partial = services.select { |entry| entry[:incomplete].any? }
-                lines << "  #{role}：已部署业务 #{services.size}，多设备共同业务 #{services.count { |entry| entry[:deployed].size >= 2 }}，关联不完整 #{partial.size}。"
-                partial.each { |entry| lines << "    VNI #{entry[:vni]} 待补齐：#{entry[:incomplete].map { |host| by_host.dig(host, 'device', 'name') || host }.join('、')}" }
+                lines << "  #{role}: deployed services #{services.size}, services shared across devices #{services.count { |entry| entry[:deployed].size >= 2 }}, incomplete associations #{partial.size}."
+                partial.each { |entry| lines << "    VNI #{entry[:vni]} missing: #{entry[:incomplete].map { |host| by_host.dig(host, 'device', 'name') || host }.join(', ')}" }
               end
             end
             lines << ""
           end
           audit[:findings].each_with_index do |finding, index|
-            lines << "#{index + 1}. #{finding[:fabric]} / #{finding[:role] || '全 Fabric'} / #{finding[:vni] ? "VNI #{finding[:vni]}" : '公共策略'}：#{finding[:title]}"
+            lines << "#{index + 1}. #{finding[:fabric]} / #{finding[:role] || 'entire Fabric'} / #{finding[:vni] ? "VNI #{finding[:vni]}" : 'shared policy'}: #{finding[:title]}"
           end
           audit[:findings].each_with_index do |finding, index|
-            lines.concat([ "", "[#{index + 1}] #{finding[:fabric]} / #{finding[:role] || '全 Fabric'} / #{finding[:vni] || '公共策略'} — #{finding[:title]}", "规则：#{finding[:code]}" ])
+            lines.concat([ "", "[#{index + 1}] #{finding[:fabric]} / #{finding[:role] || 'entire Fabric'} / #{finding[:vni] || 'shared policy'} — #{finding[:title]}", "Rule: #{finding[:code]}" ])
             evidence = finding[:evidence]
             if finding[:code] == "fabric_address_group"
               defined = evidence.filter_map { |row| row[:value] }
               common = defined.reduce { |all, members| all & members } || []
-              lines << "  已定义版本的共同成员（不代表批准基线）：#{common.empty? ? '无' : common.join('、')}"
+              lines << "  Members common to defined versions (not an approved baseline): #{common.empty? ? 'none' : common.join(', ')}"
               evidence.group_by { |row| row[:value] }.each do |members, rows|
                 names = rows.map { |row| by_host.dig(row[:host], "device", "name") || row[:host] }
-                value = members ? "#{members.size} 个成员；共同成员之外：#{(members - common).empty? ? '无' : (members - common).join('、')}" : "未提供定义或未采集对象证据"
-                lines.concat([ "  #{names.join('、')}", "    #{value}" ])
+                value = members ? "#{members.size} members; outside the common set: #{(members - common).empty? ? 'none' : (members - common).join(', ')}" : "No definition provided or object evidence not collected"
+                lines.concat([ "  #{names.join(', ')}", "    #{value}" ])
               end
               next
             end
@@ -53,18 +53,18 @@ module Vxlan
               value = row.key?(:value) ? row[:value] : row.reject { |key, _| %i[host name vlan entries semantics].include?(key) }
               value = value.reject { |key, _| key == :entries } if value.is_a?(Hash)
               if row[:semantics]
-                policy = row[:policy] ? "规则与依赖版本 #{CtxRunner::Fingerprint.call(row[:policy])[0, 12]}" : "依赖对象未验证"
-                value = "#{row[:entries].size} 条规则，#{policy}"
+                policy = row[:policy] ? "Rule and dependency version #{CtxRunner::Fingerprint.call(row[:policy])[0, 12]}" : "Dependencies unverified"
+                value = "#{row[:entries].size} rules, #{policy}"
               end
-              [ row[:vlan] || row[:interface] || "公共", display_fabric_value(value) ]
+              [ row[:vlan] || row[:interface] || "shared", display_fabric_value(value) ]
             end
             grouped.each do |(vlan, value), members|
               names = members.map { |row| row[:name] || by_host.dig(row[:host], "device", "name") || row[:host] }
-              lines.concat([ "  VLAN/接口 #{vlan}：#{value}", "    #{names.join('、')}" ])
+              lines.concat([ "  VLAN/interface #{vlan}: #{value}", "    #{names.join(', ')}" ])
             end
             if evidence.any? { |row| row[:semantics] }
               evidence.group_by { |row| row[:semantics] }.each_with_index do |(rules, members), variant|
-                lines << "  规则版本 #{variant + 1}：#{members.map { |row| by_host.dig(row[:host], 'device', 'name') || row[:host] }.join('、')}"
+                lines << "  Rule version #{variant + 1}: #{members.map { |row| by_host.dig(row[:host], 'device', 'name') || row[:host] }.join(', ')}"
                 lines.concat(rules.map { |rule| "    #{rule['action']} #{rule['expression']}" })
               end
             end
@@ -75,14 +75,14 @@ module Vxlan
         # 机器字段转换为运维读法，显式保留缺失和未知。
         def display_fabric_value(value)
           if value.is_a?(Hash) && value.key?(:acl)
-            return "未挂载 ACL" unless value[:acl]
-            return "#{value[:acl]}；本机缺少定义" unless value[:defined]
-            return "#{value[:acl]}；已定义，但依赖对象未验证" unless value[:policy_verified]
-            "#{value[:acl]}；已定义，版本 #{value[:digest].to_s[0, 12]}"
+            return "No ACL attached" unless value[:acl]
+            return "#{value[:acl]}; local definition missing" unless value[:defined]
+            return "#{value[:acl]}; defined, but dependencies unverified" unless value[:policy_verified]
+            "#{value[:acl]}; defined, version #{value[:digest].to_s[0, 12]}"
           elsif value.is_a?(Array)
-            value.empty? ? "未配置地址" : value.join("、")
+            value.empty? ? "No address configured" : value.join(", ")
           elsif value.nil?
-            "未提供"
+            "not provided"
           elsif value.is_a?(Hash)
             JSON.generate(value)
           else

data/lib/vxlan/cli/review/report.rb

@@ -28,7 +28,7 @@ module Vxlan
 
         # 配置和回退集中于每设备一份 cfg；有限类型动作汇总到批次计划，不接受 cfg 直接执行。
         def write_review(document, basename:, source:, source_sha256:, advice: nil)
-          raise ArgumentError, "非法报告名称" unless basename.match?(/\A[A-Za-z0-9_.-]+\z/)
+          raise ArgumentError, "Invalid report name" unless basename.match?(/\A[A-Za-z0-9_.-]+\z/)
           advice = report_advice(advice || Recommendations.new(document).call).merge(source: source, source_sha256: source_sha256)
           advice[:items] = advice[:items].map(&:dup)
           entry = { device: advice[:device], counts: advice[:counts], basename: basename, report: "devices/#{basename}.txt", source: source,
@@ -95,14 +95,14 @@ module Vxlan
 
         # 每项包含作用域、条件、命令及注释化回退，不将多项当成原子变更。
         def script_text(items)
-          lines = [ "! 候选配置，未执行；先审阅同名 devices/*.txt；禁止整批直接粘贴。", "! apply 只读取 plan.json 中明确选择的单项，不执行本 cfg。" ]
+          lines = [ "! Candidate configuration, not executed; review the matching devices/*.txt first. Do not paste the entire batch.", "! apply reads only the explicitly selected item from plan.json; it does not execute this cfg file." ]
           items.each do |item|
-            lines.concat([ "", "! #{item[:scope]} / #{item[:title]}", "! 计划项：#{item[:plan_id] || '仅审阅草稿，不支持交互执行'}" ])
-            lines.concat(item[:prerequisites].map { |condition| "! 条件：#{condition}" })
+            lines.concat([ "", "! #{item[:scope]} / #{item[:title]}", "! Plan item: #{item[:plan_id] || 'Review draft only; interactive execution unsupported'}" ])
+            lines.concat(item[:prerequisites].map { |condition| "! Prerequisite: #{condition}" })
             lines.concat(item[:commands])
-            lines << "! 条件回退（不自动执行）："
+            lines << "! Conditional rollback (not executed automatically): "
             lines.concat(item[:rollback].map { |command| "! #{command}" })
-            lines << "! 核查：#{item[:verify].join(' ; ')}"
+            lines << "! Verification: #{item[:verify].join(' ; ')}"
           end
           lines.join("\n") + "\n"
         end
@@ -110,27 +110,27 @@ module Vxlan
         # 文本按设备、证据、问题、动作顺序组织，完整跨设备证据位于聚合计划。
         def device_text(entry, document)
           advice, device = entry.values_at(:advice, :device)
-          lines = [ "设备：#{device['name']}（#{device['host']}）", "模式：诊断与计划，未执行设备配置", "证据时间：#{advice[:observed_at] || '未知'}", "来源：#{entry[:source]}", "源文件 SHA256：#{entry[:source_sha256]}",
-            "建议：#{entry[:counts]}", "命令文件：#{entry[:script] || '未生成'}", "命令 SHA256：#{entry[:script_sha256] || '无'}", "计划文件：plan.json；交互计划项 #{entry[:plans].size} 个", "" ]
-          lines << "采集状态：#{document['status']}" if document["status"]
+          lines = [ "Device: #{device['name']} (#{device['host']})", "Mode: diagnostics and planning; no device configuration executed", "Evidence time: #{advice[:observed_at] || 'unknown'}", "Source: #{entry[:source]}", "Source file SHA256: #{entry[:source_sha256]}",
+            "Recommendations: #{entry[:counts]}", "Command file: #{entry[:script] || 'not generated'}", "Command SHA256: #{entry[:script_sha256] || 'none'}", "Plan file: plan.json; interactive plan items: #{entry[:plans].size} items", "" ]
+          lines << "Collection status: #{document['status']}" if document["status"]
           configuration_time = document.dig("snapshot", "dimensions", "configuration", "evidence", 0, "observed_at")
-          lines << "配置证据时间：#{configuration_time}" if configuration_time
-          lines << "当前规则未命中；不代表网络健康。" if advice[:items].empty?
+          lines << "Configuration evidence time: #{configuration_time}" if configuration_time
+          lines << "No current rules matched; this does not establish network health." if advice[:items].empty?
           advice[:items].each_with_index do |item, index|
-            lines.concat([ "", "#{index + 1}. #{item[:scope]} — #{item[:title]}", "状态：#{item[:status]}；规则：#{item[:code]}", "影响：#{item[:impact]}" ])
+            lines.concat([ "", "#{index + 1}. #{item[:scope]} — #{item[:title]}", "Status: #{item[:status]}; rule: #{item[:code]}", "Impact: #{item[:impact]}" ])
             evidence = item[:category] == "fabric" ? Array(item[:evidence]).select { |row| row[:host] == device["host"] } : item[:evidence]
-            lines.concat([ "本机依据：", JSON.pretty_generate(evidence) ])
-            lines << "跨设备对比：summary.txt；完整原始对比：plan.json 的 audits / fabric。" if item[:category] == "fabric"
+            lines.concat([ "Local evidence: ", JSON.pretty_generate(evidence) ])
+            lines << "Cross-device comparison: summary.txt; full raw comparison: audits / fabric in plan.json." if item[:category] == "fabric"
             if item[:plan_id]
-              lines << "交互计划项：#{item[:plan_id]}"
-              lines << "在批次目录运行：vxlan apply --plan plan.json --item #{item[:plan_id]}"
+              lines << "Interactive plan item: #{item[:plan_id]}"
+              lines << "Run in the batch directory: vxlan apply --plan plan.json --item #{item[:plan_id]}"
             end
-            { prerequisites: "适用条件", blockers: "待决信息", commands: "候选配置（未执行）", rollback: "条件回退", verify: "只读核查", template: "待补模板（不可执行）" }.each do |key, title|
+            { prerequisites: "Prerequisites", blockers: "Unresolved information", commands: "Candidate configuration (not executed)", rollback: "Conditional rollback", verify: "Read-only verification", template: "Incomplete template (not executable)" }.each do |key, title|
               values = item[key] || []
-              lines.concat([ "#{title}：", *values.map { |value| "  #{value}" } ]) if values.any?
+              lines.concat([ "#{title}: ", *values.map { |value| "  #{value}" } ]) if values.any?
             end
-            lines << "验收：#{item[:expected]}" if item[:expected]
-            lines << "命令参考：#{item[:references].join(' ')}" if item[:references]&.any?
+            lines << "Acceptance: #{item[:expected]}" if item[:expected]
+            lines << "Command reference: #{item[:references].join(' ')}" if item[:references]&.any?
           end
           lines.join("\n") + "\n"
         end
@@ -139,15 +139,15 @@ module Vxlan
         def summary_text(summary)
           entries, counts = summary.values_at(:reports, :counts)
           active = entries.count { |entry| entry[:counts].values.sum.positive? }
-          lines = [ "VXLAN 诊断与配置建议；模式：review；未执行设备变更。", "报告完成状态以 summary.json 为准。", "设备：#{entries.size} 台；有建议 #{active} 台；未命中规则 #{entries.size - active} 台（不代表健康）。",
-            "建议：待决 #{counts['blocked']}，候选 #{counts['candidate']}，排查 #{counts['investigate']}；Fabric 聚合差异 #{summary[:fabric_findings]} 项。",
-            "计划：#{entries.sum { |entry| entry[:plans].size }} 项可交互执行增量；#{entries.count { |entry| entry[:script] }} 份候选脚本。候选数与可执行计划数不同。",
-            "阅读顺序：summary.txt → devices/<设备>.txt → scripts/<设备>.cfg → plan.json 中的指定计划项。",
-            "evidence/ 保存程序使用的采集证据，日常阅读无需打开；devices/ 只包含可读诊断。",
-            "plan.json.sha256 校验聚合计划；events.jsonl 记录本次离线审查，不代表设备会话或下发回执。", "下发必须 --item 选择单项、交互确认、重读配置并核对指纹；无自动批量执行。", "" ]
+          lines = [ "VXLAN diagnostics and configuration recommendations; mode: review; no device changes executed.", "Report completion status is authoritative in summary.json.", "Devices: #{entries.size} devices; with recommendations #{active} devices; no rules matched #{entries.size - active} devices (does not establish health).",
+            "Recommendations: unresolved #{counts['blocked']}, candidates #{counts['candidate']}, investigations #{counts['investigate']}; aggregated Fabric differences #{summary[:fabric_findings]} items.",
+            "Plan: #{entries.sum { |entry| entry[:plans].size }} changes available for interactive execution; #{entries.count { |entry| entry[:script] }} candidate scripts. Candidate counts differ from executable plan counts.",
+            "Read in order: summary.txt -> devices/<device>.txt -> scripts/<device>.cfg -> the selected plan item in plan.json.",
+            "evidence/ stores collection evidence used by the program; routine review does not require opening it. devices/ contains readable diagnostics only.",
+            "plan.json.sha256 verifies the aggregate plan; events.jsonl records this offline review, not device sessions or execution receipts.", "Applying requires selecting one --item, interactive confirmation, configuration readback and fingerprint verification; there is no automatic bulk execution.", "" ]
           entries.sort_by { |entry| [ entry[:counts].values.sum.positive? ? 0 : 1, entry[:device]["name"].to_s ] }.each do |entry|
-            lines.concat([ "#{entry[:device]['host']} #{entry[:device]['name']} 待决=#{entry[:counts].fetch('blocked', 0)} 候选=#{entry[:counts].fetch('candidate', 0)} 排查=#{entry[:counts].fetch('investigate', 0)}",
-              "  设备报告：#{entry[:report]}", "  命令文件：#{entry[:script] || '未生成'}；可执行计划：#{entry[:plans].size} 项" ])
+            lines.concat([ "#{entry[:device]['host']} #{entry[:device]['name']} unresolved=#{entry[:counts].fetch('blocked', 0)} candidates=#{entry[:counts].fetch('candidate', 0)} investigations=#{entry[:counts].fetch('investigate', 0)}",
+              "  Device report: #{entry[:report]}", "  Command file: #{entry[:script] || 'not generated'}; executable plans: #{entry[:plans].size} items" ])
           end
           lines.concat([ "", @fabric_text ]) if @fabric_text
           lines.join("\n") + "\n"

data/lib/vxlan/cli/review.rb

@@ -18,12 +18,12 @@ module Vxlan
 
       # 返回零只代表建议生成完成，不代表问题已修复或候选配置已获批准。
       def run(argv)
-        command = CtxCli::Command.new(banner: "用法：vxlan review --batch DIR [--output DIR]（离线生成建议，不执行配置）", out: @out) do |p, options|
-          p.on("--fabric-policy FILE", "显式 Fabric/Leaf/Border/Spine 清单 YAML") { |value| options[:fabric_policy] = value }
-          p.on("--batch DIR", "已采集批次，含 evidence/*.json") { |value| options[:batch] = value }
-          p.on("--[no-]scripts", "可选导出配置建议，默认仅诊断") { |value| options[:scripts] = value }
-          p.on("--output DIR", "私有输出根目录，默认批次内 reviews") { |value| options[:output] = value }
-          p.on("-h", "--help", "查看帮助") { options[:help] = true }
+        command = CtxCli::Command.new(banner: "Usage: vxlan review --batch DIR [--output DIR] (generate recommendations offline without executing configuration)", out: @out) do |p, options|
+          p.on("--fabric-policy FILE", "Explicit Fabric/Leaf/Border/Spine inventory YAML") { |value| options[:fabric_policy] = value }
+          p.on("--batch DIR", "Collected batch containing evidence/*.json") { |value| options[:batch] = value }
+          p.on("--[no-]scripts", "Optionally export configuration suggestions; diagnostics only by default") { |value| options[:scripts] = value }
+          p.on("--output DIR", "Private output root; defaults to reviews inside the batch") { |value| options[:output] = value }
+          p.on("-h", "--help", "Show help") { options[:help] = true }
         end
         CtxCli::Review.new(command: command, directory: "evidence", adapter: self, out: @out, error: @error).run(argv)
       end
@@ -36,7 +36,7 @@ module Vxlan
         end
         hosts = documents.map { |entry| entry[2]["device"]["host"] }
         names = documents.map { |entry| CLI::Report.device_basename(entry[2].fetch("device")) }
-        raise ArgumentError, "设备身份或输出名称重复" unless hosts.uniq == hosts && names.uniq == names
+        raise ArgumentError, "Duplicate device identity or output name" unless hosts.uniq == hosts && names.uniq == names
         policy = options[:fabric_policy] && YAML.safe_load(CtxCli::Input.read(path: options[:fabric_policy]), aliases: false)
         Vxlan::Fabric::Scope.new(policy) if policy
         policy
@@ -46,7 +46,7 @@ module Vxlan
       def publish(documents, options, batch:, context:)
         report = CLI::Report.new(options[:output] || File.join(batch, "reviews"), scripts: options[:scripts] == true)
         report.build_review(documents, policy: context)
-        "建议已生成：#{report.directory}/summary.txt；#{documents.size} 台；未执行设备变更。"
+        "Recommendations generated: #{report.directory}/summary.txt; #{documents.size} devices; no device changes executed."
       end
 
       private
@@ -61,31 +61,31 @@ module Vxlan
         return unless dimension == "configuration"
         CtxRunner::Evidence.array(record.fetch("review_findings", []))
         nve = record.fetch("nve", {})
-        raise ArgumentError, "NVE/VLAN 结构错误" unless nve.is_a?(Hash) && record.fetch("vlan_vnis", {}).is_a?(Hash)
+        raise ArgumentError, "Invalid NVE/VLAN structure" unless nve.is_a?(Hash) && record.fetch("vlan_vnis", {}).is_a?(Hash)
         CtxRunner::Evidence.map(nve.fetch("members", {}))
         CtxRunner::Evidence.map(record.fetch("vrfs", {}))
         CtxRunner::Evidence.map(record.fetch("evpn", {})).each_value { |entry| CtxRunner::Evidence.array(entry.fetch("route_targets", [])) }
         CtxRunner::Evidence.map(record.fetch("interfaces", {})).each_value do |interface|
           addresses, bindings = interface.fetch("addresses", []), interface.fetch("acl_bindings", {})
           unless addresses.is_a?(Array) && addresses.all? { |address| address.is_a?(String) && address.include?("/") } && bindings.is_a?(Hash) && bindings.all? { |direction, name| %w[in out].include?(direction) && name.is_a?(String) }
-            raise ArgumentError, "接口结构错误"
+            raise ArgumentError, "Invalid interface structure"
           end
           addresses.each { |address| IPAddr.new(address) }
         end
         acls = record.fetch("acls", {})
-        raise ArgumentError, "ACL 结构错误" unless acls.is_a?(Hash)
+        raise ArgumentError, "Invalid ACL structure" unless acls.is_a?(Hash)
         acls.each_value do |entries|
           CtxRunner::Evidence.array(entries).each do |entry|
             unless entry["sequence"].is_a?(Integer) && %w[permit deny remark].include?(entry["action"]) && entry["expression"].is_a?(String)
-              raise ArgumentError, "ACL 规则结构错误"
+              raise ArgumentError, "Invalid ACL rule structure"
             end
           end
         end
         groups = record.fetch("address_groups", {})
-        raise ArgumentError, "地址组结构错误" unless groups.is_a?(Hash)
+        raise ArgumentError, "Invalid address group structure" unless groups.is_a?(Hash)
         groups.each_value do |members|
           unless members.is_a?(Array) && members.all? { |member| member.is_a?(String) && member.include?("/") && IPAddr.new(member).ipv4? }
-            raise ArgumentError, "地址组成员错误"
+            raise ArgumentError, "Invalid address group members"
           end
         end
       end

data/lib/vxlan/cli.rb

@@ -13,7 +13,7 @@ module Vxlan
           begin
             require_relative "cli/collect"
           rescue LoadError
-            error.puts "collect 需要含共享清单筛选的当前 net-connector；请安装项目依赖。"
+            error.puts "collect requires a current net-connector with shared inventory filters; install the project dependencies."
             next 2
           end
           Collect.new(env: env, out: out, error: error, input: input, **collect_options).run(arguments)
@@ -36,7 +36,7 @@ module Vxlan
     end
 
     # 全局帮助不读取配置、环境文件或设备清单。
-    USAGE = "用法：vxlan collect [选项]  只读采集与报告\n      vxlan parse [选项]    离线文件或 stdin 解析\n      vxlan review --batch DIR  离线修复建议\n      vxlan apply --plan FILE --item ID  交互确认后下发\n      vxlan --version\n使用 vxlan collect --help 、vxlan parse --help 或 vxlan review --help 查看参数；--help-all 查看完整约定，--examples 查看范例。".freeze
+    USAGE = "Usage: vxlan collect [options]  Read-only collection and reports\n       vxlan parse [options]    Parse offline files or stdin\n       vxlan review --batch DIR  Offline remediation recommendations\n       vxlan apply --plan FILE --item ID  Apply after interactive confirmation\n       vxlan --version\nUse vxlan collect --help, vxlan parse --help or vxlan review --help for options; --help-all for full conventions, --examples for examples.".freeze
     private_constant :USAGE
   end
 end

data/lib/vxlan/fabric/review.rb

@@ -18,7 +18,7 @@ module Vxlan
       # 比较范围由业务策略统一验证，审查器只负责组织规则与建议。
       def initialize(documents, policy)
         @documents = documents.to_h { |document| [ document.fetch("device").fetch("host"), document ] }
-        raise ArgumentError, "重复设备身份" unless @documents.size == documents.size
+        raise ArgumentError, "Duplicate device identity" unless @documents.size == documents.size
         @scope = Scope.new(policy)
       end
 
@@ -26,12 +26,12 @@ module Vxlan
       def call
         @findings, @items, @coverage, @subnet_indexes = [], Hash.new { |hash, host| hash[host] = [] }, [], {}
         inventory = @scope.coverage(@documents.keys)
-        finding("未归属", nil, "fabric_scope_unassigned", "已采集设备未纳入 Fabric 策略，跨设备审查未覆盖", inventory[:unassigned]) if inventory[:unassigned].any?
+        finding("unassigned", nil, "fabric_scope_unassigned", "Collected devices are outside the Fabric policy and are not covered by cross-device review", inventory[:unassigned]) if inventory[:unassigned].any?
         @scope.groups.each do |fabric, group|
           configs = group.values.flatten.to_h { |host| [ host, configuration(host) ] }
           unknown = configs.select { |_host, config| config.nil? }.keys
           unless unknown.empty?
-            finding(fabric, nil, "fabric_evidence_incomplete", "成员配置证据不完整，停止该 Fabric 的变更推导", unknown)
+            finding(fabric, nil, "fabric_evidence_incomplete", "Member configuration evidence is incomplete; change inference stopped for this Fabric", unknown)
             next
           end
           %w[leaves borders].each do |role|
@@ -63,11 +63,11 @@ module Vxlan
           @coverage << { fabric: fabric, role: @role, vni: vni, deployed: rows.map { |row| row[:host] }.uniq, not_deployed: configs.keys - rows.map { |row| row[:host] }, incomplete: rows.select { |row| row[:missing].any? }.map { |row| row[:host] }.uniq }
           incomplete = rows.select { |row| row[:missing].any? }
           if incomplete.any?
-            finding(fabric, vni, "fabric_service_incomplete", "业务已开始部署，但 VLAN/NVE/EVPN 关联不完整", observations(incomplete) { |row| { missing: row[:missing] } })
+            finding(fabric, vni, "fabric_service_incomplete", "Service deployment has started, but VLAN/NVE/EVPN associations are incomplete", observations(incomplete) { |row| { missing: row[:missing] } })
             review_missing_mappings(fabric, vni, rows, all_configs)
           end
           if rows.map { |row| row[:host] }.uniq.size != rows.size
-            finding(fabric, vni, "fabric_vlan_mapping_ambiguous", "同一 Leaf 将多个 VLAN 映射到相同 VNI", rows.map { |row| row.slice(:host, :vlan) })
+            finding(fabric, vni, "fabric_vlan_mapping_ambiguous", "One Leaf maps multiple VLANs to the same VNI", rows.map { |row| row.slice(:host, :vlan) })
             next
           end
           next unless rows.size >= 2
@@ -76,15 +76,15 @@ module Vxlan
           # 缺映射行没有可定位 SVI，不能再扩散为网关、MTU 等一串伪差异。
           rows = rows.select { |row| row[:vlan] }
           next unless rows.size >= 2
-          compare(fabric, vni, "fabric_vlan_mapping", "相同 VNI 的本地 VLAN 编号不一致", rows) { |row| row[:vlan] }
+          compare(fabric, vni, "fabric_vlan_mapping", "Local VLAN IDs differ for the same VNI", rows) { |row| row[:vlan] }
           # L2 业务没有网关可以是正常设计，但仍须检查承载与控制平面。
           next unless rows.any? { |row| row[:svi] && (row[:svi]["anycast"] || row[:svi].fetch("addresses", []).any?) }
           review_gateway(fabric, vni, rows, all_configs, service_blocked: service_blocked)
           %w[in out].each { |direction| review_acl(fabric, vni, rows, direction, policies: policies, service_blocked: service_blocked) }
           %w[vrf anycast mtu shutdown].each do |field|
-            compare(fabric, vni, "fabric_#{field}", "业务 SVI 的 #{field} 不一致", rows) { |row| row[:svi]&.fetch(field, nil) }
+            compare(fabric, vni, "fabric_#{field}", "Service SVI #{field} differs", rows) { |row| row[:svi]&.fetch(field, nil) }
           end
-          compare(fabric, vni, "fabric_anycast_mac", "Anycast 网关 MAC 不一致", rows) { |row| row[:config]["anycast_mac"] }
+          compare(fabric, vni, "fabric_anycast_mac", "Anycast gateway MACs differ", rows) { |row| row[:config]["anycast_mac"] }
         end
         review_acl_catalog(fabric, configs, policies)
         review_address_groups(fabric, configs)
@@ -94,27 +94,27 @@ module Vxlan
       def review_missing_mappings(fabric, vni, rows, configs)
         rows.select { |row| row[:missing] == [ "VLAN" ] }.each do |row|
           evidence = observations(rows) { |peer| { missing: peer[:missing], gateway: peer[:svi]&.fetch("addresses", []), vrf: peer[:svi]&.dig("vrf") } }
-          item = recommendation(fabric, vni, "fabric_vlan_mapping_missing", "补齐已有业务的 VLAN/VNI 关联", evidence)
+          item = recommendation(fabric, vni, "fabric_vlan_mapping_missing", "Complete the VLAN/VNI association for an existing service", evidence)
           plan = Service::Mapping.infer(vni, row, rows)
           change = plan&.to_h
           conflicts = change ? gateway_conflicts(configs, change, except: [ row[:host], "Vlan#{change['vlan']}" ]) : []
           if conflicts.any?
             item[:evidence].concat(conflicts)
-            item[:blockers] << "同 VRF 存在跨 SVI/跨 VNI 网段重叠，不能通过新增映射扩大冲突：#{conflicts.map { |entry| "#{entry[:name]} #{entry[:interface]}" }.join('、')}"
+            item[:blockers] << "Subnets overlap across SVIs/VNIs within the same VRF; adding a mapping must not extend the conflict: #{conflicts.map { |entry| "#{entry[:name]} #{entry[:interface]}" }.join(', ')}"
             plan = nil
           end
           if plan
             local_svi = row[:config].fetch("interfaces").fetch("Vlan#{change['vlan']}")
             item[:evidence] = evidence.map do |entry|
-              entry[:host] == row[:host] ? entry.merge(vlan: change["vlan"].to_s, value: { missing: [ "VLAN/VNI 映射" ], gateway: local_svi["addresses"], vrf: local_svi["vrf"] }) : entry
+              entry[:host] == row[:host] ? entry.merge(vlan: change["vlan"].to_s, value: { missing: [ "VLAN/VNI mapping" ], gateway: local_svi["addresses"], vrf: local_svi["vrf"] }) : entry
             end
-            item[:impact] = "将已有 VLAN 接入既有 VXLAN 业务，可能立即扩展广播域；不创建 VLAN，不更改网关或 ACL。"
-            item[:prerequisites] << "本机未映射 VLAN 的网关、VRF、Anycast 身份及 ACL 与完整对端一致，NVE/EVPN 也已匹配；确认该业务确应在本机接入。"
-            item[:expected] = "本机 VLAN/VNI 关联完整、VNI 状态符合预期，既有网关及 ACL 保持不变；接入业务验收通过。"
+            item[:impact] = "Attaching an existing VLAN to an existing VXLAN service may immediately extend the broadcast domain; no VLAN is created and gateways and ACLs are unchanged."
+            item[:prerequisites] << "The unmapped local VLAN's gateway, VRF, Anycast identity and ACL match a complete peer, and NVE/EVPN already match; confirm that this service should be attached locally."
+            item[:expected] = "Local VLAN/VNI association is complete, VNI state meets expectations, existing gateway and ACL remain unchanged, and service acceptance passes."
             item[:resolves] = [ { code: "nve_l2_without_vlan", vni: vni } ]
             propose(item, plan, service_blocked: false)
           else
-            item[:blockers] << "没有唯一且完整的业务对应关系；需核对本机未映射 VLAN、网关、VRF、ACL 与对端配置，禁止按 VNI 数值猜测 VLAN。"
+            item[:blockers] << "No unique and complete service correspondence exists; compare the local unmapped VLAN, gateway, VRF and ACL with peer configuration. Do not infer VLAN from VNI numbers."
           end
           @items[row[:host]] << item
         end
@@ -123,13 +123,13 @@ module Vxlan
       # 一致性约束先于增量生成；承载/路由声明冲突时停止叠加网关和 ACL 变更。
       def review_transport(fabric, vni, rows)
         before = @findings.size
-        compare(fabric, vni, "fabric_replication", "NVE 复制方式或组播组声明不一致", rows) { |row| Service::Catalog.nve_member(row[:config], row[:nve])&.slice("replication", "multicast_group") }
-        compare(fabric, vni, "fabric_arp_suppression", "ARP 抑制的显式配置不一致", rows) { |row| row[:nve]&.fetch("suppress_arp", nil) }
-        compare(fabric, vni, "fabric_route_targets", "EVPN 导入/导出 RT 声明不一致，需核对路由互通与隔离", rows) do |row|
+        compare(fabric, vni, "fabric_replication", "NVE replication modes or multicast group declarations differ", rows) { |row| Service::Catalog.nve_member(row[:config], row[:nve])&.slice("replication", "multicast_group") }
+        compare(fabric, vni, "fabric_arp_suppression", "Explicit ARP suppression settings differ", rows) { |row| row[:nve]&.fetch("suppress_arp", nil) }
+        compare(fabric, vni, "fabric_route_targets", "EVPN import/export RT declarations differ; verify routing reachability and isolation", rows) do |row|
           row[:evpn] && Service::Catalog.route_targets(row[:evpn]["route_targets"], asn: row[:config].dig("bgp", "asn"), vni: vni)
         end
         tenant_rows = rows.select { |row| row[:svi] && row[:svi]["vrf"] }
-        compare(fabric, vni, "fabric_tenant_routing", "共同业务的租户 VNI 或路由导入/导出声明不一致", tenant_rows) do |row|
+        compare(fabric, vni, "fabric_tenant_routing", "Tenant VNIs or route import/export declarations differ for a shared service", tenant_rows) do |row|
           Service::Catalog.tenant(row[:config], row[:svi]["vrf"])
         end if tenant_rows.size >= 2
         @findings.size > before
@@ -140,9 +140,9 @@ module Vxlan
         services = Service::Catalog.new(host => config).services
         return if services.empty?
         evidence = [ { host: host, value: { role: "spines", l2_vnis: services.keys.sort } } ]
-        finding(fabric, nil, "fabric_role_conflict", "声明为 Spine，但存在 L2 业务承载配置", evidence)
-        item = recommendation(fabric, nil, "fabric_role_conflict", "核对 Spine 是否应承担业务 VTEP 职责", evidence)
-        item[:blockers] << "先确认角色或迁移残留；不能因为出现 NVE 就自动把 Spine 当作 Leaf，不能自动补业务配置或删除 NVE。"
+        finding(fabric, nil, "fabric_role_conflict", "Declared as Spine but contains L2 service-bearing configuration", evidence)
+        item = recommendation(fabric, nil, "fabric_role_conflict", "Verify whether the Spine should act as a service VTEP", evidence)
+        item[:blockers] << "Confirm the role or migration remnants first; NVE presence does not automatically make a Spine a Leaf. Do not automatically add service configuration or delete NVE."
         @items[host] << item
       end
 
@@ -150,11 +150,11 @@ module Vxlan
       def review_gateway(fabric, vni, rows, configs, service_blocked:)
         values = rows.map { |row| row[:svi]&.fetch("addresses", [])&.sort }
         return if values.uniq.one?
-        finding(fabric, vni, "fabric_gateway", "同业务网关地址不一致", observations(rows) { |row| row[:svi]&.fetch("addresses", []) })
+        finding(fabric, vni, "fabric_gateway", "Gateway addresses differ for the same service", observations(rows) { |row| row[:svi]&.fetch("addresses", []) })
         expected = values.compact.reject(&:empty?).uniq
         rows.each do |row|
           next if expected.one? && row[:svi]&.fetch("addresses", [])&.sort == expected.first
-          item = recommendation(fabric, vni, "fabric_gateway", "网关地址需要一致", observations(rows) { |entry| entry[:svi]&.fetch("addresses", []) })
+          item = recommendation(fabric, vni, "fabric_gateway", "Gateway addresses must be consistent", observations(rows) { |entry| entry[:svi]&.fetch("addresses", []) })
           change = { "kind" => "svi_gateway_add", "vlan" => row[:vlan].to_i, "vni" => vni, "vrf" => row[:svi]&.dig("vrf"), "address" => expected.one? && expected.first.one? ? expected.first.first : nil }
           context = rows.map { |entry| [ entry[:svi]&.dig("vrf"), entry[:svi]&.dig("anycast"), entry[:config]["anycast_mac"] ] }.uniq
           conflicts = change["address"] ? gateway_conflicts(configs, change) : []
@@ -163,8 +163,8 @@ module Vxlan
               (plan = ChangePlan.candidate(change, config: row[:config]))
             propose(item, plan, service_blocked: service_blocked)
           else
-            item[:blockers] << "存在已有地址、跨 SVI/跨 VNI 网段冲突，或 VRF/Anycast 模式/MAC 不一致、缺少唯一网关；需先确认迁移设计，禁止重复添加网关。"
-            item[:blockers] << "Fabric 内冲突接口：#{conflicts.map { |conflict| "#{conflict[:name]} #{conflict[:interface]}" }.join('、')}" if conflicts.any?
+            item[:blockers] << "An existing address, cross-SVI/VNI subnet conflict, inconsistent VRF/Anycast mode/MAC, or lack of a unique gateway prevents this change; confirm the migration design first. Do not add duplicate gateways."
+            item[:blockers] << "Conflicting interfaces in the Fabric: #{conflicts.map { |conflict| "#{conflict[:name]} #{conflict[:interface]}" }.join(', ')}" if conflicts.any?
           end
           @items[row[:host]] << item
         end
@@ -195,11 +195,11 @@ module Vxlan
           { acl: name, defined: !entries.nil?, entries: entries, policy_verified: !policy.nil?, address_groups: policy&.address_groups, digest: policy && CtxRunner::Fingerprint.call(policy.to_h) }
         end
         code = different_binding ? "fabric_acl_binding" : "fabric_acl_content"
-        finding(fabric, vni, code, "#{direction} 方向 ACL 挂载/有序规则不一致", evidence)
+        finding(fabric, vni, code, "#{direction} ACL attachments or ordered rules differ", evidence)
         undefined = evidence.select { |row| row[:value][:acl] && !row[:value][:defined] }
-        finding(fabric, vni, "fabric_acl_undefined", "#{direction} 方向已挂载 ACL，但本机没有对应定义", undefined) if undefined.any?
+        finding(fabric, vni, "fabric_acl_undefined", "#{direction} ACL is attached but its local definition is missing", undefined) if undefined.any?
         unresolved = evidence.select { |row| row[:value][:defined] && !row[:value][:policy_verified] }
-        finding(fabric, vni, "fabric_acl_dependency", "#{direction} 方向 ACL 依赖对象缺失、为空或尚未解析，不能证明策略一致", unresolved) if unresolved.any?
+        finding(fabric, vni, "fabric_acl_dependency", "#{direction} ACL dependencies are missing, empty or unparsed; policy consistency cannot be established", unresolved) if unresolved.any?
         names = bindings.compact.uniq
         sources = rows.select { |row| row[:config].fetch("acls", {})[names.first] }
         originals = sources.map { |row| row[:config]["acls"][names.first] }
@@ -208,21 +208,21 @@ module Vxlan
           current_name = row[:svi]&.dig("acl_bindings", direction)
           current_entries = names.one? && row[:config].fetch("acls", {})[names.first]
           next if names.one? && unique.one? && unique.first && current_name == names.first && policies.dig(row[:host], names.first) == unique.first
-          item = recommendation(fabric, vni, code, "统一 #{direction} 方向访问控制", evidence)
+          item = recommendation(fabric, vni, code, "Align #{direction} access control", evidence)
           change = { "kind" => "svi_acl", "vlan" => row[:vlan].to_i, "vni" => vni, "direction" => direction,
             "acl" => names.first, "entries" => originals.first, "create_acl" => current_entries.nil?, "previous_binding" => current_name }
           change["address_groups"] = unique.first.address_groups if unique.one? && unique.first
           context_matches = rows.map { |entry| entry[:svi]&.dig("vrf") }.uniq.one?
           if names.one? && unique.one? && unique.first && context_matches &&
               (plan = ChangePlan.candidate(change, config: row[:config]))
-            item[:prerequisites] << "依据是本业务已挂载且有序内容一致的 ACL；即使挂载节点较少，也不以无 ACL 的多数节点为删除依据。确认此业务应统一受该 ACL 保护。"
+            item[:prerequisites] << "The basis is an ACL attached to this service with matching ordered contents; even if fewer nodes attach it, a majority without an ACL is not grounds for removal. Confirm that the service should uniformly use this ACL."
             propose(item, plan, service_blocked: service_blocked)
           else
-            item[:blockers] << "ACL 名称、有序规则、地址组成员、VRF 或当前绑定不能证明一致；需选择权威规则及完整依赖，不自动覆盖或撤销访问控制。"
+            item[:blockers] << "ACL names, ordered rules, address group members, VRF or current bindings do not establish consistency; choose authoritative rules and complete dependencies. Do not automatically overwrite or remove access control."
             shared = change["create_acl"] ? AclPolicy.bindings(row[:config], names.first) - [ { "interface" => "Vlan#{row[:vlan]}", "direction" => direction } ] : []
             if shared.any?
-              references = shared.map { |binding| "#{binding['interface']} #{binding['direction']}" }.join("、")
-              item[:blockers] << "创建 #{names.first} 还会激活既有引用：#{references}。需合并所有受影响接口核对策略和回退，禁止作为单个 SVI 的补齐执行。"
+              references = shared.map { |binding| "#{binding['interface']} #{binding['direction']}" }.join(", ")
+              item[:blockers] << "Creating #{names.first} would also activate existing references: #{references}. Review policy and rollback for all affected interfaces together; do not execute this as completion of a single SVI."
             end
           end
           @items[row[:host]] << item
@@ -238,10 +238,10 @@ module Vxlan
             { host: host, entries: entries, semantics: policies.dig(host, name)&.rules || AclPolicy.rules(entries), policy: policies.dig(host, name)&.to_h } if entries
           end
           if rows.map { |row| row[:semantics] }.uniq.size > 1 || rows.map { |row| row[:policy] }.uniq.size > 1
-            finding(fabric, nil, "fabric_acl_content", "同名 ACL #{name} 的有序规则或依赖对象不同（包括尚未挂载的定义）", rows)
+            finding(fabric, nil, "fabric_acl_content", "Same-name ACL #{name} has different ordered rules or dependencies (including unattached definitions)", rows)
           end
           unknown = rows.select { |row| row[:policy].nil? }
-          finding(fabric, nil, "fabric_acl_dependency", "ACL #{name} 的依赖对象未验证，不能证明策略一致（包括尚未挂载的定义）", unknown) if unknown.any?
+          finding(fabric, nil, "fabric_acl_dependency", "ACL #{name} has unverified dependencies; policy consistency cannot be established (including unattached definitions)", unknown) if unknown.any?
         end
       end
 
@@ -255,7 +255,7 @@ module Vxlan
         end
         references.sort.each do |name, rows|
           next unless rows.map { |row| row[:value] }.uniq.size > 1
-          finding(fabric, nil, "fabric_address_group", "ACL 地址组 #{name} 成员不同或缺失；仅比较引用此对象的业务，不自动复制", rows)
+          finding(fabric, nil, "fabric_address_group", "ACL address group #{name} has different or missing members; compare only services referencing this object and do not copy automatically", rows)
         end
       end
 
@@ -283,7 +283,7 @@ module Vxlan
             end
             conflicts << rows if rows.map { |row| row[:vni] }.uniq.size > 1
             conflicts.each do |evidence|
-              finding(fabric, nil, "fabric_subnet_vni_conflict", "VRF #{vrf} 的网段在不同 VNI 上重叠，需核对迁移或隔离设计", evidence)
+              finding(fabric, nil, "fabric_subnet_vni_conflict", "VRF #{vrf} has overlapping subnets across different VNIs; verify the migration or isolation design", evidence)
             end
             active << [ key, rows ]
           end
@@ -308,16 +308,16 @@ module Vxlan
 
       # 与单设备报告共享建议字段，跨设备来源完整保留。
       def recommendation(fabric, vni, code, title, evidence)
-        { code: code, category: "fabric", scope: "#{fabric} / #{@role} / #{vni ? "VNI #{vni}" : '角色核查'}", title: title, status: "blocked", evidence: evidence,
-          prerequisites: [ "仅在本 Fabric、相同已部署业务范围内适用；核对业务访问策略与维护窗口。", "下发前重新读取配置，任何变化均使计划过期；逐设备逐项确认，不批量重放。" ], blockers: [],
+        { code: code, category: "fabric", scope: "#{fabric} / #{@role} / #{vni ? "VNI #{vni}" : 'role review'}", title: title, status: "blocked", evidence: evidence,
+          prerequisites: [ "Applicable only within this Fabric and the same deployed service scope; verify the service access policy and maintenance window.", "Read configuration again before applying; any change makes the plan stale. Confirm each item on each device; do not replay in bulk." ], blockers: [],
           commands: [], rollback: [], verify: [ "show running-config", "show nve vni", "show ip interface brief vrf all" ],
-          impact: "改变网关或 ACL 可能改变可达性及业务隔离；配置回读通过后仍需业务验收。", expected: "共同业务的网关和访问控制一致，允许/拒绝流量均符合设计。", references: [] }
+          impact: "Changing a gateway or ACL may affect reachability and service isolation; service acceptance is still required after configuration readback passes.", expected: "Gateways and access control are consistent for the shared service; permitted and denied traffic match the design.", references: [] }
       end
 
       # 类型化增量才可导出可交互执行的计划，冲突项只有证据和待确认信息。
       def propose(item, plan, service_blocked:)
         if service_blocked
-          item[:blockers] << "共同业务的承载关联或复制/路由声明存在冲突，先解决这些前置问题，再生成网关或 ACL 增量。"
+          item[:blockers] << "Service-bearing associations or replication/routing declarations conflict for a shared service; resolve these prerequisites before generating gateway or ACL changes."
           return
         end
         item.merge!(status: "candidate", change: plan.to_h, commands: plan.commands, rollback: plan.rollback)