soloforge 1.3.3 → 1.3.4

package/dist/engine/release_readiness_gate.js

@@ -21,6 +21,9 @@
  * 13. 第五批一致性校验
  * 14. 依赖漏洞扫描
  * 15. 发布问题架构决策与设计产物真实消费
+ * 18. 代码可维护性与可观测性契约行为验证
+ * 19. 历史问题长期机制化行为验证
+ * 20. 诊断码集中治理检查
  */
 import fs from "node:fs";
 import os from "node:os";
@@ -1136,13 +1139,13 @@ async function checkBatchIssueFormatConsistency(rootDir, hardFail, _info) {
         hardFail("BATCH_ISSUE_FORMAT_INCONSISTENT", "loadBatchIssueDetails 导出未找到", ["scripts/batch_issue_details.mjs"], "构建系统", "共享解析脚本导出不正确", "修复脚本");
         return;
     }
-    const expectedCounts = { 1: 19, 2: 12, 3: 9, 4: 13, 5: 6, 6: 5, 7: 2 };
+    const expectedCounts = { 1: 19, 2: 12, 3: 9, 4: 13, 5: 6, 6: 5, 7: 2, 8: 1 };
     const requiredPerProblemSections = [
         "问题背景", "用户反馈 / 触发场景", "根因分析", "解决方案", "方案细节",
         "硬规则", "非目标", "影响范围", "落地文件", "验收标准", "回归风险",
         "与其他问题的关联", "发布门禁要求",
     ];
-    for (let batch = 1; batch <= 7; batch++) {
+    for (let batch = 1; batch <= 8; batch++) {
         const details = loadBatchIssueDetails(batch, rootDir);
         if (!details.loaded) {
             hardFail("BATCH_ISSUE_FORMAT_INCONSISTENT", `Batch${batch} 问题集未加载: ${details.error}`, [`docs/SoloForge-Batch${batch}问题集.md`], `Batch${batch}`, "旧 gate 只检查文档存在，不验证是否可解析", "第 3 步统一格式");
@@ -1341,7 +1344,7 @@ async function checkKnowledgeAssetSchema(rootDir, hardFail, _info) {
         }
     }
 }
-// ── Phase 11: engine console.log 检查 ──
+// ── Phase 11: engine console 直写检查 ──
 function checkEngineConsoleLog(rootDir, hardFail) {
     // 扫描全 src/ 目录（不仅 engine）
     const srcDir = path.join(rootDir, "src");
@@ -1359,12 +1362,13 @@ function checkEngineConsoleLog(rootDir, hardFail) {
                 continue;
             if (/"console\.log"|`console\.log`|'console\.log'|console\\.log/.test(line))
                 continue;
-            // 日志模块内部 stdout 封装允许 console.log
-            if (/logger\.ts$/.test(file) && /^\s*console\.log\(/.test(line))
+            // 日志模块内部 stdout/stderr 封装允许 console.log / console.error
+            if (/logger\.ts$/.test(file) && /^\s*console\.(log|error)\(/.test(line))
                 continue;
-            if (/console\.log\s*\(/.test(line)) {
+            const directConsole = line.match(/console\.(log|warn|error|debug)\s*\(/);
+            if (directConsole) {
                 const rel = path.relative(rootDir, file);
-                hardFail("ENGINE_CONSOLE_LOG", `${rel}:${i + 1} 使用 console.log（应使用 logger 或 console.error 写 stderr）`, [rel], "发布门禁 console 检查", "旧 gate 不检查 src/ 全目录 console.log", "替换为 logger 模块调用");
+                hardFail("ENGINE_DIRECT_CONSOLE", `${rel}:${i + 1} 使用 console.${directConsole[1]}（应使用 logger 模块）`, [rel], "发布门禁 console 检查", "旧 gate 不检查 src/ 全目录 console 直写", "替换为 logger 模块调用");
             }
         }
     }
@@ -1693,6 +1697,7 @@ async function checkReleaseIssueDesignPath(rootDir, hardFail, _info) {
             "problem-62": ["release-scenario-design-pack-"],
             "problem-63": ["release-scenario-template-contract-"],
             "problem-64": ["release-scenario-template-visibility-"],
+            "problem-68": ["release-scenario-code-observability-"],
         };
         for (const [problem, prefixes] of Object.entries(problemPrefixes)) {
             const problemScenarios = execResults.filter(r => prefixes.some(p => r.scenario_id.startsWith(p)));
@@ -1988,7 +1993,7 @@ async function checkReleaseIssueDesignPath(rootDir, hardFail, _info) {
         hardFail("RELEASE_ISSUE_CONTRACT_MISSING", "问题六十三缺少模板契约匹配、产物验证或修复重验函数", ["src/engine/standard_asset_contract.ts"], "problem-63", "缺少核心函数不能实现契约验证", "实现 matchTemplateContract / verifyOutputAgainstContract / createRepairReverifyDirective");
     }
     // sf_verify 必须按文件逐一匹配契约（不得使用 changed_files[0] 的契约校验全部文件）
-    if (!toolsText.includes("lazyStandardAssetContract") || !toolsText.includes("SF-CONTRACT-0003") || !toolsText.includes("repair_reverify_directive")) {
+    if (!toolsText.includes("lazyStandardAssetContract") || !toolsText.includes("TOOL_DIAGNOSTIC_CODES.contractDraft") || !toolsText.includes("repair_reverify_directive")) {
         hardFail("RELEASE_ISSUE_CONTRACT_MAINLINE_MISSING", "问题六十三未接入 sf_verify 模板契约验证和 sf_deliver 修复重验阻断", ["src/adapters/claude_code/tools.ts"], "problem-63", "仅有契约定义不能阻断交付", "在 sf_verify 消费模板契约验证、sf_deliver 消费修复重验阻断");
     }
     // 必须检查 per-file 匹配（不得 changed_files[0] 统一匹配）
@@ -2217,6 +2222,241 @@ async function checkReleaseIssueDesignPath(rootDir, hardFail, _info) {
         }
     }
 }
+// ── 18. 代码可维护性与可观测性契约行为验证（问题六十八） ──
+async function checkCodeObservabilityBehavior(rootDir, hardFail, _info) {
+    const obsPath = path.join(rootDir, "dist", "engine", "code_maintainability_observability_contract.js");
+    if (!fs.existsSync(obsPath)) {
+        hardFail("CODE_OBSERVABILITY_MODULE_MISSING", "problem-68: code_maintainability_observability_contract.js 未编译到 dist/", ["src/engine/code_maintainability_observability_contract.ts"], "problem-68", "发布门禁不检查问题-68 实现是否存在", "实现 code_maintainability_observability_contract 并编译");
+        return;
+    }
+    let obs;
+    try {
+        obs = await import(obsPath);
+    }
+    catch (e) {
+        hardFail("CODE_OBSERVABILITY_IMPORT_ERROR", `problem-68: code_maintainability_observability_contract 导入失败: ${e.message}`, ["src/engine/code_maintainability_observability_contract.ts"], "problem-68", "可观测性模块存在但不可导入", "修复导入错误");
+        return;
+    }
+    // 核心导出存在性
+    const requiredExports = ["reviewMissingLogs", "detectSensitiveLogs", "reviewCommentQuality", "hasBlockingObservabilityFindings", "requiresCodeObservabilityContract", "isLowRiskChange", "detectProjectLogger", "verifyChangedFilesObservability", "evaluateDeliveryBlock"];
+    for (const exp of requiredExports) {
+        if (typeof obs[exp] !== "function") {
+            hardFail("CODE_OBSERVABILITY_EXPORT_MISSING", `problem-68: code_maintainability_observability_contract.ts 缺少导出函数: ${exp}`, ["src/engine/code_maintainability_observability_contract.ts"], "problem-68", "可观测性模块缺少核心导出", `添加 ${exp} 导出`);
+        }
+    }
+    // 行为验证: 支付写操作无日志必须被检测
+    try {
+        const paymentFindings = obs.reviewMissingLogs({
+            "PaymentService.java": `public void refund(String orderId, BigDecimal amount) {
+  orderRepository.save(order);
+  paymentGateway.refund(orderId, amount);
+}`,
+        });
+        if (!obs.hasBlockingObservabilityFindings(paymentFindings)) {
+            hardFail("CODE_OBSERVABILITY_PAYMENT_FALSE_PASS", "problem-68: 支付写操作无日志未被检测到", ["src/engine/code_maintainability_observability_contract.ts"], "problem-68", "文件存在不能证明审查能力有效", "修复 reviewMissingLogs 检测逻辑");
+        }
+        // 行为验证: catch 吞异常无日志必须被检测
+        const catchFindings = obs.reviewMissingLogs({
+            "OrderService.ts": `async processOrder(orderId: string) {
+  try {
+    await this.client.submit(orderId);
+  } catch (e) {
+    return false;
+  }
+}`,
+        });
+        if (!obs.hasBlockingObservabilityFindings(catchFindings)) {
+            hardFail("CODE_OBSERVABILITY_CATCH_FALSE_PASS", "problem-68: catch 吞异常无日志未被检测到", ["src/engine/code_maintainability_observability_contract.ts"], "problem-68", "catch 吞异常必须产生阻断 finding", "修复 reviewMissingLogs 检测逻辑");
+        }
+        // 行为验证: 敏感信息日志泄漏必须被检测
+        const sensitiveFindings = obs.detectSensitiveLogs({
+            "UserService.ts": `function login(user) {
+  logger.info("user login", { token: "eyJhbGciOiJIUzI1NiJ9.xxxxx", password: user.password, phone: "13812345678" });
+}`,
+        });
+        if (!obs.hasBlockingObservabilityFindings(sensitiveFindings)) {
+            hardFail("CODE_OBSERVABILITY_SENSITIVE_FALSE_PASS", "problem-68: 敏感信息日志泄漏未被检测到", ["src/engine/code_maintainability_observability_contract.ts"], "problem-68", "token/password/手机号泄漏必须被阻断", "修复 detectSensitiveLogs 检测逻辑");
+        }
+        // 行为验证: 低风险任务不应触发
+        const notTriggered = !obs.requiresCodeObservabilityContract("修复 README 错别字", "code_change");
+        if (!notTriggered) {
+            hardFail("CODE_OBSERVABILITY_LOW_RISK_OVERBLOCK", "problem-68: 低风险文案任务错误触发可观测性检查", ["src/engine/code_maintainability_observability_contract.ts"], "problem-68", "低风险任务不应触发检查", "修复 requiresCodeObservabilityContract 判断逻辑");
+        }
+        // 行为验证: 项目 logger 类型检测
+        const javaLogger = obs.detectProjectLogger({
+            "Application.java": "import org.slf4j.LoggerFactory; private static final Logger log = LoggerFactory.getLogger(App.class);",
+        });
+        if (javaLogger.type !== "slf4j") {
+            hardFail("CODE_OBSERVABILITY_LOGGER_DETECT_FAIL", `problem-68: SLF4J logger 未被正确识别 (got: ${javaLogger.type})`, ["src/engine/code_maintainability_observability_contract.ts"], "problem-68", "项目 logger 类型检测必须准确", "修复 detectProjectLogger 逻辑");
+        }
+        // 行为验证: 迁移脚本无审计日志必须被检测
+        const migrationFindings = obs.reviewMissingLogs({
+            "scripts/data_fix_order_status.ts": `async function migrateOrderStatus() {
+  const orders = await db.query("SELECT * FROM orders WHERE status IS NULL");
+  for (const order of orders) {
+    await db.update("UPDATE orders SET status = 'pending' WHERE id = ?", [order.id]);
+  }
+}`,
+        });
+        if (!obs.hasBlockingObservabilityFindings(migrationFindings)) {
+            hardFail("CODE_OBSERVABILITY_MIGRATION_FALSE_PASS", "problem-68: 迁移脚本无审计日志未被检测到", ["src/engine/code_maintainability_observability_contract.ts"], "problem-68", "数据修复脚本必须有审计日志", "修复 reviewMissingLogs 迁移脚本检测逻辑");
+        }
+    }
+    catch (e) {
+        hardFail("CODE_OBSERVABILITY_EXECUTION_ERROR", `problem-68: 可观测性行为检查执行失败: ${e.message}`, ["src/engine/code_maintainability_observability_contract.ts"], "problem-68", "契约模块必须可运行并返回确定结果", "修复运行时异常");
+    }
+    // 主链路消费检查 — sf_verify 必须调用 verifyChangedFilesObservability
+    const toolsText = safeRead(path.join(rootDir, "src", "adapters", "claude_code", "tools.ts")) ?? "";
+    const requiredHooks = [
+        "lazyCodeObservability", "reviewCodeObservability",
+        "hasBlockingObservabilityFindings", "requiresCodeObservabilityContract",
+        "evaluateCodeObservabilityGate", "evaluateDeliveryBlock",
+        "verifyChangedFilesObservability",
+    ];
+    for (const hook of requiredHooks) {
+        if (!toolsText.includes(hook)) {
+            hardFail("CODE_OBSERVABILITY_MAINPATH_MISSING", `problem-68: MCP 主链路缺少真实消费点 ${hook}`, ["src/adapters/claude_code/tools.ts"], "problem-68", "只实现引擎函数不能证明用户路径受约束", "接入 sf_expand/sf_review/sf_verify/sf_deliver");
+        }
+    }
+    // 行为验证: sf_verify 必须真实消费 verifyChangedFilesObservability — 编译后检查
+    try {
+        const toolsJsPath = path.join(rootDir, "dist", "adapters", "claude_code", "tools.js");
+        if (fs.existsSync(toolsJsPath)) {
+            const toolsJs = safeRead(toolsJsPath) ?? "";
+            const hasObsVerifyCall = toolsJs.includes("codeObservabilityFinding")
+                && toolsJs.includes("verifyChangedFilesObservability");
+            if (!hasObsVerifyCall) {
+                hardFail("CODE_OBSERVABILITY_SF_VERIFY_NOT_CONSUMING", "problem-68: sf_verify 编译产物未包含可观测性诊断常量或 verifyChangedFilesObservability 调用", ["src/adapters/claude_code/tools.ts"], "problem-68", "字符串引用不能证明 sf_verify 真实消费可观测性检查", "在 sf_verify implementationFiles 分支中调用 verifyChangedFilesObservability 并处理结果");
+            }
+        }
+    }
+    catch {
+        // 编译产物不存在时由 build 门禁处理
+    }
+    // 行为验证: sf_verify 必须能阻断 — 敏感信息 + 支付写操作必须产生 hard_fail
+    try {
+        const mustFailFindings = obs.verifyChangedFilesObservability({
+            changed_files: ["PaymentService.ts"],
+            file_contents: {
+                "PaymentService.ts": `const api_key = "sk_live_abcdef123456";
+async function processPayment(order) { order.save(); }`,
+            },
+            intent: "添加支付退款日志和脱敏处理",
+        });
+        if (!obs.hasBlockingObservabilityFindings(mustFailFindings)) {
+            hardFail("CODE_OBSERVABILITY_VERIFY_MUST_FAIL_PASS", "problem-68: sf_verify 未对敏感信息泄漏+支付无日志场景产生阻断", ["src/engine/code_maintainability_observability_contract.ts"], "problem-68", "verifyChangedFilesObservability 必须对支付敏感信息场景 hard_fail", "修复 verifyChangedFilesObservability 检测逻辑");
+        }
+        // sf_verify 必须允许合规代码通过
+        const mustPassFindings = obs.verifyChangedFilesObservability({
+            changed_files: ["RefundService.ts"],
+            file_contents: {
+                "RefundService.ts": `const logger = require('./logger');
+async function processRefund(orderId: string) {
+  await db.refund(orderId);
+  logger.info("退款成功 orderId=" + orderId);
+}`,
+            },
+            intent: "添加支付退款日志和脱敏处理",
+        });
+        if (obs.hasBlockingObservabilityFindings(mustPassFindings)) {
+            hardFail("CODE_OBSERVABILITY_VERIFY_FALSE_BLOCK", "problem-68: sf_verify 对合规代码错误阻断", ["src/engine/code_maintainability_observability_contract.ts"], "problem-68", "合规代码不应被阻断", "修复 verifyChangedFilesObservability 检测逻辑");
+        }
+        // 行为验证: logger.info("退款成功") 无可定位字段必须 hard_fail
+        const unlocatableFailFindings = obs.verifyChangedFilesObservability({
+            changed_files: ["RefundService.ts"],
+            file_contents: {
+                "RefundService.ts": `const logger = require('./logger');
+async function refund(order) { order.save(); logger.info("退款成功"); }`,
+            },
+            intent: "添加支付退款日志和脱敏处理",
+        });
+        const unlocatableHardFails = unlocatableFailFindings.filter((f) => f.category === "unlocatable_log" && f.severity === "hard_fail");
+        if (unlocatableHardFails.length === 0) {
+            hardFail("CODE_OBSERVABILITY_UNLOCATABLE_LOG_PASS", "problem-68: logger.info('退款成功') 无可定位字段未被阻断", ["src/engine/code_maintainability_observability_contract.ts"], "problem-68", "仅含事件词的日志不可通过支付写操作检查", "修复可定位字段判断逻辑");
+        }
+        // 行为验证: logger.info("退款成功 orderId=" + orderId) 必须通过
+        const unlocatablePassFindings = obs.verifyChangedFilesObservability({
+            changed_files: ["RefundService.ts"],
+            file_contents: {
+                "RefundService.ts": `const logger = require('./logger');
+async function refund(order) { order.save(); logger.info("退款成功 orderId=" + orderId); }`,
+            },
+            intent: "添加支付退款日志和脱敏处理",
+        });
+        const unlocatableBlockers = unlocatablePassFindings.filter((f) => f.category === "unlocatable_log" && f.severity === "hard_fail");
+        if (unlocatableBlockers.length > 0) {
+            hardFail("CODE_OBSERVABILITY_LOCATABLE_FALSE_BLOCK", "problem-68: logger.info('退款成功 orderId=...') 含可定位字段被错误阻断", ["src/engine/code_maintainability_observability_contract.ts"], "problem-68", "包含对象 ID 的日志不应被阻断", "修复可定位字段判断逻辑");
+        }
+    }
+    catch (e) {
+        hardFail("CODE_OBSERVABILITY_VERIFY_EXECUTION_ERROR", `problem-68: sf_verify 行为检查执行失败: ${e.message}`, ["src/engine/code_maintainability_observability_contract.ts"], "problem-68", "verifyChangedFilesObservability 必须可运行并返回确定结果", "修复运行时异常");
+    }
+    _info("  problem-68 代码可维护性与可观测性行为验证完成");
+}
+async function checkLongTermMechanization(rootDir, hardFail, _info) {
+    try {
+        const health = await import("./mechanism_health_check.js");
+        const report = health.runFullHealthCheck(rootDir);
+        for (const finding of report.findings.filter((f) => f.severity === "hard_fail")) {
+            hardFail("LONGTERM_MECHANISM_HEALTH", finding.message_zh, [finding.target], "历史问题长期机制化", "旧 gate 不检查机制死代码/未消费资产", "修复机制消费链路");
+        }
+    }
+    catch (e) {
+        hardFail("LONGTERM_MECHANISM_HEALTH_EXCEPTION", `机制运行时健康度检查异常: ${e.message}`, ["src/engine/mechanism_health_check.ts"], "历史问题长期机制化", "旧 gate 不执行机制健康检查", "修复检查模块");
+    }
+    try {
+        const kg = await import("./knowledge_governance_gate.js");
+        const report = kg.runKnowledgeGovernanceCheck({
+            project_language: "zh",
+            contents: [{ id: "release-gate", domain: "user_feedback", content: "发布门禁保持中文语义优先" }],
+        });
+        if (report.hard_fail_count > 0) {
+            hardFail("LONGTERM_KNOWLEDGE_GOVERNANCE", `知识治理存在 ${report.hard_fail_count} 个 hard_fail`, ["src/engine/knowledge_governance_gate.ts"], "历史问题长期机制化", "旧 gate 只跑历史知识场景，不接统一治理入口", "修复知识治理检查");
+        }
+    }
+    catch (e) {
+        hardFail("LONGTERM_KNOWLEDGE_GOVERNANCE_EXCEPTION", `知识治理检查异常: ${e.message}`, ["src/engine/knowledge_governance_gate.ts"], "历史问题长期机制化", "旧 gate 不执行知识治理入口", "修复检查模块");
+    }
+    try {
+        const logGov = await import("./log_governance.js");
+        const clean = logGov.enforceLogGovernance("用户可见输出保持中文且无内部噪音");
+        const noisy = logGov.enforceLogGovernance("[soloForge] internal trace validate-release");
+        if (!clean.passed || noisy.passed) {
+            hardFail("LONGTERM_LOG_GOVERNANCE_BEHAVIOR", "日志治理 must-pass/must-fail 行为不成立", ["src/engine/log_governance.ts"], "历史问题长期机制化", "旧 gate 只扫描 console，不验证输出治理行为", "修复 log_governance 行为");
+        }
+    }
+    catch (e) {
+        hardFail("LONGTERM_LOG_GOVERNANCE_EXCEPTION", `日志治理检查异常: ${e.message}`, ["src/engine/log_governance.ts"], "历史问题长期机制化", "旧 gate 不执行日志治理入口", "修复检查模块");
+    }
+    try {
+        const cfg = await import("./config_write_boundary.js");
+        const runtimeCtx = cfg.classifyConfigContext(rootDir, { runtime_inference: true });
+        const runtimeDecision = cfg.isWriteAllowed(runtimeCtx, path.join(rootDir, ".soloforge", "config.yaml"));
+        const greenfieldDecision = cfg.isWriteAllowed({ kind: "greenfield", project_path: rootDir, evidence: ["empty_project"], confirmed: false }, path.join(rootDir, ".soloforge", "config.yaml"));
+        if (runtimeDecision.allowed || !greenfieldDecision.allowed) {
+            hardFail("LONGTERM_CONFIG_BOUNDARY_BEHAVIOR", "配置落盘边界 must-pass/must-fail 行为不成立", ["src/engine/config_write_boundary.ts"], "历史问题长期机制化", "旧 gate 不区分运行时推断与空项目写入", "修复配置写入边界");
+        }
+    }
+    catch (e) {
+        hardFail("LONGTERM_CONFIG_BOUNDARY_EXCEPTION", `配置落盘边界检查异常: ${e.message}`, ["src/engine/config_write_boundary.ts"], "历史问题长期机制化", "旧 gate 不执行配置落盘边界", "修复检查模块");
+    }
+    _info("  历史问题长期机制化行为验证完成");
+}
+async function checkDiagnosticCentralization(rootDir, hardFail) {
+    const toolsPath = path.join(rootDir, "src", "adapters", "claude_code", "tools.ts");
+    const toolsText = safeRead(toolsPath) ?? "";
+    const literalMatches = [...toolsText.matchAll(/["'`]SF-[A-Z]+-\d{4}["'`]/g)];
+    if (literalMatches.length > 0) {
+        hardFail("DIAGNOSTIC_CODE_HARDCODED_IN_TOOLS", `tools.ts 仍有 ${literalMatches.length} 个硬编码诊断码字面量`, ["src/adapters/claude_code/tools.ts"], "problem-36", "旧 gate 不检查诊断码集中治理", "改用 diagnostic_registry 导出的 TOOL_DIAGNOSTIC_CODES");
+    }
+    const registry = await import("./diagnostic_registry.js");
+    const required = Object.values(registry.TOOL_DIAGNOSTIC_CODES);
+    const registered = new Set(registry.listAllDiagnostics().map((d) => d.code));
+    const missing = required.filter((code) => !registered.has(code));
+    if (missing.length > 0) {
+        hardFail("DIAGNOSTIC_CODE_REGISTRY_MISSING", `诊断码常量未在注册表登记: ${missing.join(", ")}`, ["src/engine/diagnostic_registry.ts"], "problem-36", "旧 gate 不检查诊断码注册完整性", "补齐 BUILTIN_DIAGNOSTICS");
+    }
+}
 // ── 主入口 ──
 export async function runReleaseReadinessGate(rootDir) {
     const hardFails = [];
@@ -2315,6 +2555,18 @@ export async function runReleaseReadinessGate(rootDir) {
     beginPhase("实现工程契约行为验证");
     await checkImplementationContractBehavior(rootDir, hardFail, _info);
     endPhase("实现工程契约行为验证");
+    // 18: 代码可维护性与可观测性契约行为验证（问题六十八）
+    beginPhase("代码可维护性与可观测性行为验证");
+    await checkCodeObservabilityBehavior(rootDir, hardFail, _info);
+    endPhase("代码可维护性与可观测性行为验证");
+    // 19: 历史问题长期机制化行为验证
+    beginPhase("历史问题长期机制化行为验证");
+    await checkLongTermMechanization(rootDir, hardFail, _info);
+    endPhase("历史问题长期机制化行为验证");
+    // 20: 诊断码集中治理检查
+    beginPhase("诊断码集中治理检查");
+    await checkDiagnosticCentralization(rootDir, hardFail);
+    endPhase("诊断码集中治理检查");
     // 恢复 console.error 和日志器
     console.error = origConsoleError;
     resetLogger();