soloforge 1.3.2 → 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: 4 };
+    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 <= 6; 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 模块调用");
             }
         }
     }
@@ -1508,6 +1512,144 @@ function checkDependencyAudit(rootDir, hardFail, _info) {
         hardFail("DEPENDENCY_AUDIT", "漏洞扫描报告格式无效", ["package.json"], "依赖健康", "旧 gate 不验证报告格式", "删除 .soloforge/advisory-report.json 并重新运行 npm run audit-deps");
     }
 }
+// ── 16. 工作流导航契约行为验证（问题六十五） ──
+async function checkWorkflowNavigationBehavior(rootDir, hardFail, _info) {
+    // 1. 编译产物存在性
+    const navPath = path.join(rootDir, "dist", "engine", "next_action_planner.js");
+    if (!fs.existsSync(navPath)) {
+        hardFail("NAVIGATION_MODULE_MISSING", "problem-65: next_action_planner.js 未编译到 dist/", ["src/engine/next_action_planner.ts"], "problem-65", "发布门禁不检查问题-65 导航机制是否存在", "实现 next_action_planner 并编译");
+        return;
+    }
+    // 2. 核心导出存在性
+    let nav;
+    try {
+        nav = await import(navPath);
+    }
+    catch (e) {
+        hardFail("NAVIGATION_IMPORT_ERROR", `problem-65: next_action_planner 导入失败: ${e.message}`, ["src/engine/next_action_planner.ts"], "problem-65", "导航模块存在但不可导入", "修复导入错误");
+        return;
+    }
+    if (typeof nav.planNextAction !== "function") {
+        hardFail("NAVIGATION_EXPORT_MISSING", "problem-65: next_action_planner 未导出 planNextAction 函数", ["src/engine/next_action_planner.ts"], "problem-65", "导航模块缺少核心导出", "添加 planNextAction 导出");
+    }
+    if (typeof nav.computeDisallowedActions !== "function") {
+        hardFail("NAVIGATION_DISALLOWED_MISSING", "problem-65: next_action_planner 未导出 computeDisallowedActions 函数", ["src/engine/next_action_planner.ts"], "problem-65", "禁止动作规则计算函数缺失", "添加 computeDisallowedActions 导出");
+    }
+    // 3. 行为验证: 未初始化项目应返回 uninitialized
+    const tmpDir = path.join(rootDir, ".soloforge-gate-nav-test-" + Date.now());
+    try {
+        fs.mkdirSync(tmpDir, { recursive: true });
+        const plan = await nav.planNextAction(tmpDir);
+        if (plan.project_stage !== "uninitialized") {
+            hardFail("NAVIGATION_BEHAVIOR_UNINIT", `problem-65: 未初始化项目的阶段应为 uninitialized，实际为 ${plan.project_stage}`, ["src/engine/project_stage_detector.ts"], "problem-65", "导航未正确检测未初始化项目", "修复 detectProjectStage 逻辑");
+        }
+        if (!plan.work_package || plan.work_package.action !== "sf_init") {
+            hardFail("NAVIGATION_BEHAVIOR_INIT_WP", `problem-65: 未初始化项目的工作包应为 sf_init，实际为 ${plan.work_package?.action ?? "null"}`, ["src/engine/next_action_planner.ts"], "problem-65", "导航工作包未正确推荐初始化", "修复 computeWorkPackage 逻辑");
+        }
+    }
+    catch (e) {
+        hardFail("NAVIGATION_BEHAVIOR_ERROR", `problem-65: 行为级检查执行失败: ${e.message}`, ["src/engine/next_action_planner.ts"], "problem-65", "导航机制行为检查不可执行", "修复导航机制代码");
+    }
+    finally {
+        try {
+            fs.rmSync(tmpDir, { recursive: true });
+        }
+        catch { }
+    }
+    // 4. 知识文件存在性
+    const rulePath = path.join(rootDir, "templates", "knowledge", "rules", "工作流导航契约规则.md");
+    if (!fs.existsSync(rulePath)) {
+        hardFail("NAVIGATION_RULE_MISSING", "problem-65: 缺少知识规则文件 工作流导航契约规则.md", ["templates/knowledge/rules/工作流导航契约规则.md"], "problem-65", "导航知识规则缺失", "创建知识规则文件");
+    }
+    const procedurePath = path.join(rootDir, "templates", "knowledge", "procedures", "全生命周期工作流导航.md");
+    if (!fs.existsSync(procedurePath)) {
+        hardFail("NAVIGATION_PROCEDURE_MISSING", "problem-65: 缺少知识流程文件 全生命周期工作流导航.md", ["templates/knowledge/procedures/全生命周期工作流导航.md"], "problem-65", "导航知识流程缺失", "创建知识流程文件");
+    }
+    // 5. CLI 命令存在性
+    const cliDist = fs.readFileSync(path.join(rootDir, "dist", "bin", "soloforge.js"), "utf-8");
+    if (!cliDist.includes('case "next"') && !cliDist.includes("cmdNext")) {
+        hardFail("NAVIGATION_CLI_MISSING", "problem-65: CLI 缺少 next 命令入口", ["src/bin/soloforge.ts"], "problem-65", "CLI 无 next 命令", "添加 case 'next' dispatch");
+    }
+    if (!cliDist.includes('case "stage"') && !cliDist.includes("cmdStage")) {
+        hardFail("NAVIGATION_CLI_STAGE_MISSING", "problem-65: CLI 缺少 stage 命令入口", ["src/bin/soloforge.ts"], "problem-65", "CLI 无 stage 命令", "添加 case 'stage' dispatch");
+    }
+    _info("  problem-65 工作流导航行为验证完成");
+}
+// ── 17. 实现工程契约行为验证（问题六十六/六十七） ──
+async function checkImplementationContractBehavior(rootDir, hardFail, _info) {
+    const oodPath = path.join(rootDir, "dist", "engine", "ood_solid_contract.js");
+    const backendPath = path.join(rootDir, "dist", "engine", "backend_implementation_contract.js");
+    if (!fs.existsSync(oodPath) || !fs.existsSync(backendPath)) {
+        hardFail("IMPLEMENTATION_CONTRACT_MODULE_MISSING", "problem-66/67: OOD/SOLID 或后端工程契约未编译到 dist/", ["src/engine/ood_solid_contract.ts", "src/engine/backend_implementation_contract.ts"], "problem-66/problem-67", "仅登记问题而未验证运行时模块", "实现并编译两个工程契约模块");
+        return;
+    }
+    try {
+        const ood = await import(oodPath);
+        const backend = await import(backendPath);
+        const blockedOod = ood.evaluateOodDesignGate({
+            task_id: "gate-ood",
+            intent: "实现订单领域服务状态流转策略",
+            route: "code_change",
+        });
+        if (blockedOod.allowed || blockedOod.status !== "blocked") {
+            hardFail("OOD_SUMMARY_FALSE_PASS", "problem-66: 复杂业务编码缺少 OOD 摘要仍被放行", ["src/engine/ood_solid_contract.ts"], "problem-66", "文件存在不能证明编码前门禁有效", "修复 evaluateOodDesignGate 的缺摘要阻断");
+        }
+        const lowRisk = ood.evaluateOodDesignGate({
+            task_id: "gate-ood-low",
+            intent: "修复 README 文案错别字",
+            route: "code_change",
+        });
+        if (!lowRisk.allowed || lowRisk.status !== "not_applicable") {
+            hardFail("OOD_LOW_RISK_OVERBLOCK", "problem-66: 低风险文案任务被 OOD 门禁误阻断", ["src/engine/ood_solid_contract.ts"], "problem-66", "门禁不能以流程重量替代适用性判断", "修复低风险跳过判断");
+        }
+        const solidFindings = ood.reviewSolidCode({
+            "src/OrderController.ts": "class OrderController { save(){ return this.repository.save(this.calculate()); } }",
+        });
+        if (!ood.hasBlockingSolidFindings(solidFindings)) {
+            hardFail("SOLID_REVIEW_FALSE_PASS", "problem-66: Controller 职责膨胀没有产生阻断 finding", ["src/engine/ood_solid_contract.ts"], "problem-66", "必须用真实代码内容验证审查能力", "修复 SRP 阻断识别");
+        }
+        const blockedBackend = backend.evaluateBackendImplementationGate({
+            task_id: "gate-backend",
+            intent: "实现后端 API 支付接口",
+            route: "code_change",
+        });
+        if (blockedBackend.allowed || blockedBackend.status !== "blocked") {
+            hardFail("BACKEND_WORK_PACKAGE_FALSE_PASS", "problem-67: 后端实现缺少工程工作包仍被放行", ["src/engine/backend_implementation_contract.ts"], "problem-67", "文件存在不能证明编码前门禁有效", "修复 evaluateBackendImplementationGate");
+        }
+        const backendFindings = backend.reviewBackendImplementationFiles({
+            "src/PaymentController.java": "@PostMapping(\"/pay\") @Transactional public PaymentEntity pay(@RequestBody PaymentEntity value) { webClient.post(); return value; }",
+        });
+        if (!backend.hasBlockingBackendFindings(backendFindings)) {
+            hardFail("BACKEND_REVIEW_FALSE_PASS", "problem-67: 实体暴露或事务内外调没有产生阻断 finding", ["src/engine/backend_implementation_contract.ts"], "problem-67", "必须用真实代码内容验证后端审查能力", "修复后端工程 finding 检测");
+        }
+        if (backend.requiresBackendImplementationContract("实现简单 GET 详情只读接口", "code_change")) {
+            hardFail("BACKEND_LOW_RISK_OVERBLOCK", "problem-67: 简单只读接口被完整后端工程工作包误阻断", ["src/engine/backend_implementation_contract.ts"], "problem-67", "后端契约必须具备适用性边界", "修复低风险只读任务跳过逻辑");
+        }
+        const alignmentFindings = backend.verifyBackendArtifactAlignment({
+            apiDocumentText: "GET /api/payments/{id}",
+            openapiText: "paths:\n  /api/orders/{id}:",
+            migrationText: "create table payment(id bigint);",
+        });
+        if (!backend.hasBlockingBackendFindings(alignmentFindings)) {
+            hardFail("BACKEND_API_OPENAPI_DRIFT_FALSE_PASS", "problem-67: Markdown API 与 OpenAPI endpoint 漂移未阻断", ["src/engine/backend_implementation_contract.ts"], "problem-67", "契约对齐必须由行为检查证明", "修复 API/OpenAPI 漂移检测");
+        }
+    }
+    catch (e) {
+        hardFail("IMPLEMENTATION_CONTRACT_EXECUTION_ERROR", `problem-66/67: 实现工程行为检查执行失败: ${e.message}`, ["src/engine/ood_solid_contract.ts", "src/engine/backend_implementation_contract.ts"], "problem-66/problem-67", "契约模块必须可运行并返回确定结果", "修复运行时异常");
+    }
+    const toolsText = safeRead(path.join(rootDir, "src", "adapters", "claude_code", "tools.ts")) ?? "";
+    const requiredHooks = [
+        "lazyOodSolid", "lazyBackendImplementation", "evaluateOodDesignGate",
+        "evaluateBackendImplementationGate", "reviewSolidCode",
+        "reviewBackendImplementationFiles", "hasBlockingSolidFindings", "hasBlockingBackendFindings",
+    ];
+    for (const hook of requiredHooks) {
+        if (!toolsText.includes(hook)) {
+            hardFail("IMPLEMENTATION_CONTRACT_MAINPATH_MISSING", `problem-66/67: MCP 主链路缺少真实消费点 ${hook}`, ["src/adapters/claude_code/tools.ts"], "problem-66/problem-67", "只实现引擎函数不能证明用户路径受约束", "接入 sf_expand/sf_review/sf_verify/sf_deliver");
+        }
+    }
+    _info("  problem-66/67 实现工程契约行为验证完成");
+}
 // ── 15. 发布问题全局合同 ──
 async function checkReleaseIssueDesignPath(rootDir, hardFail, _info) {
     const toolsText = safeRead(path.join(rootDir, "src", "adapters", "claude_code", "tools.ts")) ?? "";
@@ -1555,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)));
@@ -1850,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] 统一匹配）
@@ -2079,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 = [];
@@ -2165,10 +2543,30 @@ export async function runReleaseReadinessGate(rootDir) {
     beginPhase("依赖漏洞扫描");
     checkDependencyAudit(rootDir, hardFail, _info);
     endPhase("依赖漏洞扫描");
-    // 15: 发布问题全局合同（问题六十一至六十四）
+    // 15: 发布问题全局合同（问题六十一至六十五）
     beginPhase("发布问题全局合同");
     await checkReleaseIssueDesignPath(rootDir, hardFail, _info);
     endPhase("发布问题全局合同");
+    // 16: 工作流导航契约行为验证（问题六十五）
+    beginPhase("工作流导航契约行为验证");
+    await checkWorkflowNavigationBehavior(rootDir, hardFail, _info);
+    endPhase("工作流导航契约行为验证");
+    // 17: OOD/SOLID 与后端实现工程契约行为验证（问题六十六/六十七）
+    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();