soloforge 1.4.4 → 1.4.6

package/dist/engine/release_readiness_gate.js

@@ -1625,7 +1625,7 @@ async function checkWorkflowNavigationBehavior(rootDir, hardFail, _info) {
         fs.mkdirSync(sfDir, { recursive: true });
         fs.writeFileSync(path.join(sfDir, "config.yaml"), [
             "schema_version: 1",
-            "name: smartcare",
+            "name: demo-saas",
             "tech_stack:",
             "  backend:",
             "    lang: java",
@@ -1647,8 +1647,8 @@ async function checkWorkflowNavigationBehavior(rootDir, hardFail, _info) {
             "    test: npm test",
             "    full: npm run build && npm test",
             "scope:",
-            "  backend: smartcare-saas-backend",
-            "  frontend: smartcare-saas-frontend",
+            "  backend: demo-saas-backend",
+            "  frontend: demo-saas-frontend",
         ].join("\n"), "utf-8");
         fs.writeFileSync(path.join(sfDir, "config.evidence.json"), JSON.stringify({
             schema_version: 2,
@@ -1763,8 +1763,8 @@ async function checkImplementationContractBehavior(rootDir, hardFail, _info) {
             hardFail("BACKEND_API_OPENAPI_DRIFT_FALSE_PASS", "problem-67: Markdown API 与 OpenAPI endpoint 漂移未阻断", ["src/engine/backend_implementation_contract.ts"], "problem-67", "契约对齐必须由行为检查证明", "修复 API/OpenAPI 漂移检测");
         }
         const lombokFindings = backend.reviewBackendImplementationFiles({
-            "src/main/java/com/smartcare/staff/entity/Staff.java": "import jakarta.persistence.Entity; import lombok.Data; @Entity @Data public class Staff { private Long id; }",
-            "src/main/java/com/smartcare/staff/dto/StaffCreateRequest.java": "import lombok.Getter; import lombok.Setter; @Getter @Setter public class StaffCreateRequest { private String name; }",
+            "src/main/java/com/demoapp/account/entity/Account.java": "import jakarta.persistence.Entity; import lombok.Data; @Entity @Data public class Account { private Long id; }",
+            "src/main/java/com/demoapp/account/dto/AccountCreateRequest.java": "import lombok.Getter; import lombok.Setter; @Getter @Setter public class AccountCreateRequest { private String name; }",
         });
         const modelContractFindings = lombokFindings.filter((item) => item.category === "model_lombok_contract" && item.severity === "hard_fail");
         if (modelContractFindings.length < 2) {
@@ -2116,6 +2116,28 @@ async function checkReleaseIssueDesignPath(rootDir, hardFail, _info) {
         !designPackText.includes("auditDesignImplementationTraceability")) {
         hardFail("RELEASE_ISSUE_TRACEABILITY_DESIGN_AUDIT_MISSING", "问题七十三未并入设计产物包审计", ["src/engine/design_artifact_pack.ts"], "problem-73", "追踪矩阵不进入 audit-design-artifacts 会导致用户设计阶段无法发现缺口", "把追踪矩阵作为设计产物包权威资产审计");
     }
+    const lifecycleContractText = safeRead(path.join(rootDir, "src", "engine", "design_lifecycle_contract.ts")) ?? "";
+    const lifecycleKnowledgeText = safeRead(path.join(rootDir, "src", "engine", "lifecycle_knowledge_contract.ts")) ?? "";
+    if (!lifecycleContractText.includes("detail_design") ||
+        !lifecycleContractText.includes("docs/architecture/02-数据库设计文档.md") ||
+        !lifecycleContractText.includes("docs/architecture/03-API接口规格文档.md") ||
+        !lifecycleContractText.includes("optional_implementation_detail_document") ||
+        !lifecycleContractText.includes("docs/architecture/04-开发切片计划.md") ||
+        !lifecycleContractText.includes("DESIGN_LIFECYCLE_LEGACY_SLICE_PLAN_PATHS") ||
+        !lifecycleContractText.includes("slice_planning") ||
+        !designPackText.includes("getDesignLifecycleArtifactPaths")) {
+        hardFail("RELEASE_ISSUE_DESIGN_LIFECYCLE_CONTRACT_MISSING", "设计、实现、测试、验收生命周期 I/O 合同缺失或未被设计产物包消费", ["src/engine/design_lifecycle_contract.ts", "src/engine/design_artifact_pack.ts"], "problem-62/problem-73", "没有中心合同会导致后续门禁凭空新增输入输出，详细设计又被误判成单文件", "建立中心生命周期合同，并让设计产物包、追踪审计和 hook 消费同一合同");
+    }
+    if (!lifecycleKnowledgeText.includes("evaluateLifecycleKnowledgeDecision") ||
+        !lifecycleKnowledgeText.includes("selectProjectKnowledgeForTaskWithReasons") ||
+        !lifecycleKnowledgeText.includes("auditDesignImplementationTraceability") ||
+        !lifecycleKnowledgeText.includes("assessControlledGenerationChain")) {
+        hardFail("RELEASE_ISSUE_UNIFIED_LIFECYCLE_KNOWLEDGE_CONTRACT_MISSING", "生命周期、项目知识选择和证据消费仍未收口到统一决策合同", ["src/engine/lifecycle_knowledge_contract.ts"], "problem-62/problem-73/project-knowledge-control-plane", "三个并行机制会导致 next/expand/verify/deliver 各自新增局部口径", "建立并强制消费 evaluateLifecycleKnowledgeDecision");
+    }
+    const injectionBoundaryText = safeRead(path.join(rootDir, "src", "engine", "knowledge_injection_boundary.ts")) ?? "";
+    if (injectionBoundaryText.includes("buildTemplateAssetContracts(process.cwd())")) {
+        hardFail("RELEASE_ISSUE_KNOWLEDGE_CONTRACT_CWD_DRIFT", "知识注入边界仍用 process.cwd() 读取模板合同", ["src/engine/knowledge_injection_boundary.ts"], "project-knowledge-consumption", "用户项目、全局安装和测试目录会取错合同根目录", "改为从模块根或显式合同根读取模板合同");
+    }
     if (!cliText.includes("cmdAuditDesignArtifacts") ||
         !cliText.includes("cmdUpgradeDesignArtifacts") ||
         !cliText.includes("currentTask?.design_artifact_pack")) {
@@ -2149,6 +2171,26 @@ async function checkReleaseIssueDesignPath(rootDir, hardFail, _info) {
     try {
         const workshop = await import(path.join(rootDir, "dist", "engine", "architecture_decision_workshop.js"));
         const designPack = await import(path.join(rootDir, "dist", "engine", "design_artifact_pack.js"));
+        const lifecycle = await import(path.join(rootDir, "dist", "engine", "design_lifecycle_contract.js"));
+        const lifecycleFindings = lifecycle.validateDesignLifecycleContract();
+        if (lifecycleFindings.length > 0) {
+            hardFail("RELEASE_ISSUE_DESIGN_LIFECYCLE_CONTRACT_INVALID", `设计生命周期合同不满足不变量: ${lifecycleFindings.map((finding) => finding.code).join(",")}`, ["src/engine/design_lifecycle_contract.ts"], "problem-62/problem-73", "生命周期合同必须明确设计、实现、测试、验收节点的输入输出和门禁", "修复 validateDesignLifecycleContract 报告的不变量缺口");
+        }
+        const detailStage = lifecycle.getDesignLifecycleStageContract("detail_design");
+        const detailRequiredOutputs = detailStage.outputs.filter((artifact) => artifact.required).map((artifact) => artifact.path);
+        if (!detailRequiredOutputs.includes("docs/architecture/02-数据库设计文档.md") ||
+            !detailRequiredOutputs.includes("docs/architecture/03-API接口规格文档.md") ||
+            detailRequiredOutputs.includes("docs/architecture/04-详细设计文档.md")) {
+            hardFail("RELEASE_ISSUE_DETAIL_DESIGN_TOPOLOGY_INVALID", "详细设计阶段输出拓扑错误", ["src/engine/design_lifecycle_contract.ts"], "problem-62/problem-73", "详细设计必需载体是数据库设计和 API 规格，04-详细设计文档只能是可选兼容", "修复 detail_design 生命周期合同");
+        }
+        const lifecyclePaths = lifecycle.getDesignLifecycleArtifactPaths();
+        if (lifecyclePaths.slice_plan !== "docs/architecture/04-开发切片计划.md") {
+            hardFail("RELEASE_ISSUE_SLICE_PLAN_CANONICAL_PATH_INVALID", "开发切片计划仍绑定到固定阶段文件", ["src/engine/design_lifecycle_contract.ts"], "problem-62/problem-73", "切片计划是全项目调度权威资产，不能命名成第一阶段", "将 canonical slice_plan 改为 docs/architecture/04-开发切片计划.md，旧第一阶段文件仅作为 alias");
+        }
+        const packPaths = designPack.defaultDesignArtifactPaths();
+        if (JSON.stringify(lifecyclePaths) !== JSON.stringify(packPaths)) {
+            hardFail("RELEASE_ISSUE_DESIGN_PACK_PATH_DRIFT", "设计产物包路径与生命周期合同漂移", ["src/engine/design_lifecycle_contract.ts", "src/engine/design_artifact_pack.ts"], "problem-62/problem-73", "设计产物包不得独立硬编码另一套输入输出路径", "让 defaultDesignArtifactPaths 从 getDesignLifecycleArtifactPaths 派生");
+        }
         const draft = workshop.createArchitectureDecisionWorkshop("release-issue", "new_system");
         if (workshop.evaluateArchitectureDecisionWorkshop(draft).allowed) {
             hardFail("RELEASE_ISSUE_BEHAVIOR_FALSE_PASS", "问题六十一未确认六域的草稿错误放行", ["src/engine/architecture_decision_workshop.ts"], "problem-61", "必须有负向行为证据", "修复研讨生成门");
@@ -2173,29 +2215,30 @@ async function checkReleaseIssueDesignPath(rootDir, hardFail, _info) {
             "# 需求原型设计实现追踪矩阵",
             "| 需求 | 原型 | 架构 | 详细设计 | 切片 | 验收 |",
             "| --- | --- | --- | --- | --- | --- |",
-            "| REQ-001 | PROTO-001 | ARCH-001 | DD-001 | SLICE-001 | AC-001 |",
+            "| REQ-001 | PROTO-001 | ARCH-001 | DD-T001, DD-A001 | PHASE-001, SLICE-001 | AC-001 |",
         ].join("\n"));
-        write("docs/architecture/04-详细设计文档.md", "# 详细设计\nARCH-001 -> DD-001");
-        write("docs/architecture/05-切片计划.md", "# 切片\nSLICE-001\n来源 DD-001\n验收 AC-001");
+        write("docs/architecture/02-数据库设计文档.md", "# 数据库设计\nARCH-001 -> DD-T001");
+        write("docs/architecture/03-API接口规格文档.md", "# API 设计\nARCH-001 -> DD-A001");
+        write("docs/architecture/04-开发切片计划.md", "# 开发切片计划\nPHASE-001\nSLICE-001\n来源 DD-T001, DD-A001\n验收 AC-001");
         const bindingFail = traceability.verifyChangedFilesAgainstDesignTraceability(tmp, ["src/main/java/demo/BedService.java"], {
             task_id: "trace-gate",
             created_at: new Date().toISOString(),
-            intent: "实现床位管理",
+            intent: "实现资源管理",
             product_profile: "default",
             status: "executing",
         });
         if (bindingFail.passed || !bindingFail.findings.some((f) => f.code === "TRACEABILITY_CODE_BINDING_MISSING")) {
-            hardFail("RELEASE_ISSUE_TRACEABILITY_CODE_BINDING_FALSE_PASS", "问题七十三编码缺少 SLICE/DD/AC 绑定时错误放行", ["src/engine/traceability.ts", "src/adapters/claude_code/tools.ts"], "problem-73", "实现代码必须能追溯到详细设计、切片和验收", "修复 sf_expand/sf_verify 追踪绑定门");
+            hardFail("RELEASE_ISSUE_TRACEABILITY_CODE_BINDING_FALSE_PASS", "问题七十三编码缺少 PHASE/SLICE/DD/AC 绑定时错误放行", ["src/engine/traceability.ts", "src/adapters/claude_code/tools.ts"], "problem-73", "实现代码必须能追溯到详细设计、切片和验收", "修复 sf_expand/sf_verify 追踪绑定门");
         }
         const bindingPass = traceability.verifyChangedFilesAgainstDesignTraceability(tmp, ["src/main/java/demo/BedService.java"], {
             task_id: "trace-gate-ok",
             created_at: new Date().toISOString(),
-            intent: "实现床位管理 SLICE-001 DD-001 AC-001",
+            intent: "实现资源管理 PHASE-001 SLICE-001 DD-T001 DD-A001 AC-001",
             product_profile: "default",
             status: "executing",
         });
         if (!bindingPass.passed) {
-            hardFail("RELEASE_ISSUE_TRACEABILITY_CODE_BINDING_FALSE_BLOCK", "问题七十三合法 SLICE/DD/AC 绑定被错误阻断", ["src/engine/traceability.ts"], "problem-73", "合法追踪绑定应允许编码验证继续", "修复 traceability binding 校验");
+            hardFail("RELEASE_ISSUE_TRACEABILITY_CODE_BINDING_FALSE_BLOCK", "问题七十三合法 PHASE/SLICE/DD/AC 绑定被错误阻断", ["src/engine/traceability.ts"], "problem-73", "合法追踪绑定应允许编码验证继续", "修复 traceability binding 校验");
         }
     }
     catch (error) {
@@ -2539,26 +2582,26 @@ async function checkCodeObservabilityBehavior(rootDir, hardFail, _info) {
         }
         // 行为验证: 普通 Spring 后端 Slice 的 CRUD/事务双写无日志无注释也必须被检测。
         const smartCareSliceFindings = obs.verifyChangedFilesObservability({
-            changed_files: ["src/main/java/com/smartcare/staff/service/impl/StaffServiceImpl.java"],
+            changed_files: ["src/main/java/com/demoapp/account/service/impl/AccountServiceImpl.java"],
             file_contents: {
-                "src/main/java/com/smartcare/staff/service/impl/StaffServiceImpl.java": `@Service
-public class StaffServiceImpl implements StaffService {
+                "src/main/java/com/demoapp/account/service/impl/AccountServiceImpl.java": `@Service
+public class AccountServiceImpl implements AccountService {
   @Transactional
-  public StaffVO create(StaffCreateRequest request) {
-    Staff staff = convert(request);
-    staffMapper.insert(staff);
+  public AccountVO create(AccountCreateRequest request) {
+    Account account = convert(request);
+    accountMapper.insert(account);
     SysUser user = buildUser(request);
     sysUserMapper.insert(user);
-    return toVO(staff);
+    return toVO(account);
   }
   @Transactional
-  public void resign(Long staffId) {
-    staffMapper.updateStatus(staffId, StaffStatus.RESIGNED);
-    sysUserMapper.updateAccountStatus(staffId, 0);
+  public void resign(Long accountId) {
+    accountMapper.updateStatus(accountId, AccountStatus.RESIGNED);
+    sysUserMapper.updateAccountStatus(accountId, 0);
   }
 }`,
             },
-            intent: "完成 Slice 2 机构设施与员工管理后端实现",
+            intent: "完成 Slice 2 资源目录与账号管理后端实现",
         });
         const smartCareBlocked = smartCareSliceFindings.some((f) => f.category === "missing_log_business_write" && f.severity === "hard_fail")
             && smartCareSliceFindings.some((f) => f.category === "missing_comment_complex");
@@ -2566,46 +2609,46 @@ public class StaffServiceImpl implements StaffService {
             hardFail("CODE_OBSERVABILITY_BACKEND_SLICE_FALSE_PASS", "problem-68: 普通后端 Slice 的 Controller/Service 事务双写和级联规则无日志无注释未被阻断", ["src/engine/code_maintainability_observability_contract.ts"], "problem-68", "旧门禁只覆盖支付/安全/迁移，真实 CRUD 后端实现仍可无日志无注释通过", "扩展后端实现文件检测，覆盖 Controller/Service/DTO/Entity");
         }
         const javaDocAndChineseFindings = obs.verifyChangedFilesObservability({
-            changed_files: ["src/main/java/com/smartcare/staff/service/impl/StaffServiceImpl.java"],
+            changed_files: ["src/main/java/com/demoapp/account/service/impl/AccountServiceImpl.java"],
             file_contents: {
-                "src/main/java/com/smartcare/staff/service/impl/StaffServiceImpl.java": `@Service
-public class StaffServiceImpl implements StaffService {
-  public StaffVO create(StaffCreateRequest request) {
-    Staff staff = convert(request);
-    staffMapper.insert(staff);
-    logger.info("staff created staffId=" + staff.getId());
-    return toVO(staff);
+                "src/main/java/com/demoapp/account/service/impl/AccountServiceImpl.java": `@Service
+public class AccountServiceImpl implements AccountService {
+  public AccountVO create(AccountCreateRequest request) {
+    Account account = convert(request);
+    accountMapper.insert(account);
+    logger.info("account created accountId=" + account.getId());
+    return toVO(account);
   }
 }`,
             },
-            intent: "完成 Slice 2 员工管理后端实现",
+            intent: "完成 Slice 2 账号管理后端实现",
         });
         const javaDocAndChineseBlocked = ["missing_class_doc", "missing_method_doc", "missing_important_line_comment", "non_chinese_log"].every((category) => javaDocAndChineseFindings.some((f) => f.category === category && f.severity === "hard_fail"));
         if (!javaDocAndChineseBlocked) {
             hardFail("CODE_OBSERVABILITY_CHINESE_DOC_CONTRACT_FALSE_PASS", "problem-68: 后端类/方法中文 Javadoc、关键行中文注释或中文日志缺失未被阻断", ["src/engine/code_maintainability_observability_contract.ts"], "problem-68", "只检查是否有日志/注释会放过英文日志、无类说明、无方法入参出参说明和关键行业务意图缺失", "扩展 reviewCommentQuality/reviewMissingLogs，强制中文日志、中文注释、类 Javadoc、方法 Javadoc 和关键行注释");
         }
         const crossStackFindings = obs.verifyChangedFilesObservability({
-            changed_files: ["src/routes/staff.route.ts", "app/api/staff.py", "src/pages/StaffForm.tsx"],
+            changed_files: ["src/routes/account.route.ts", "app/api/account.py", "src/pages/AccountForm.tsx"],
             file_contents: {
-                "src/routes/staff.route.ts": `router.post('/staff', async (req, res) => {
-  const staff = await staffRepo.create(req.body);
-  await userRepo.create({ staffId: staff.id });
-  res.json(staff);
+                "src/routes/account.route.ts": `router.post('/account', async (req, res) => {
+  const account = await accountRepo.create(req.body);
+  await userRepo.create({ accountId: account.id });
+  res.json(account);
 });`,
-                "app/api/staff.py": `@router.post("/staff")
-async def create_staff(payload: StaffCreate):
-    staff = await staff_repo.create(payload)
-    await user_repo.create(staff_id=staff.id)
-    return staff`,
-                "src/pages/StaffForm.tsx": `export function StaffForm() {
+                "app/api/account.py": `@router.post("/account")
+async def create_account(payload: AccountCreate):
+    account = await account_repo.create(payload)
+    await user_repo.create(account_id=account.id)
+    return account`,
+                "src/pages/AccountForm.tsx": `export function AccountForm() {
   async function handleSubmit(values) {
-    await apiClient.post('/api/institution/staff', values);
+    await apiClient.post('/api/tenant/users', values);
     setStatus('created');
   }
   return <form onSubmit={handleSubmit}>...</form>;
 }`,
             },
-            intent: "实现员工新增前后端接口与表单",
+            intent: "实现账号新增前后端接口与表单",
         });
         const crossStackBlocked = crossStackFindings.filter((f) => f.category === "missing_log_business_write" && f.severity === "hard_fail").length >= 3;
         if (!crossStackBlocked) {
@@ -2763,7 +2806,7 @@ async function checkTemplateAndProjectKnowledgeHygiene(rootDir, hardFail, _info)
     }
     try {
         const obs = await import(path.join(rootDir, "dist", "engine", "code_maintainability_observability_contract.js"));
-        const ordinaryApiImplementationTriggers = obs.requiresCodeObservabilityContract?.("实现机构端入住列表接口", "code_change") === true;
+        const ordinaryApiImplementationTriggers = obs.requiresCodeObservabilityContract?.("实现业务端业务办理列表接口", "code_change") === true;
         if (!ordinaryApiImplementationTriggers) {
             hardFail("CODE_OBSERVABILITY_BUSINESS_API_NOT_TRIGGERED", "problem-68: 普通业务接口实现未触发代码注释与日志契约，真实项目会绕过问题六十八", ["src/engine/code_maintainability_observability_contract.ts", "src/adapters/claude_code/tools.ts"], "problem-68", "旧行为只覆盖支付/安全等关键词，未覆盖普通 Controller/API/Service 编码", "扩展触发条件并在 sf_expand 聚合返回工作包");
         }
@@ -2776,7 +2819,7 @@ async function checkTemplateAndProjectKnowledgeHygiene(rootDir, hardFail, _info)
         const goodDir = path.join(tmp, ".soloforge", "knowledge", "rules");
         fs.mkdirSync(goodDir, { recursive: true });
         fs.writeFileSync(path.join(goodDir, "API响应规则.md"), `---
-id: smartcare-api-response-rule
+id: demo-api-response-rule
 asset_kind: hard_rule
 routes:
   - code_change
@@ -2795,21 +2838,56 @@ enforcement:
 必须使用项目统一响应结构，错误码、字段表和 OpenAPI 保持一致。
 `, "utf-8");
         const projectKnowledge = await import(path.join(rootDir, "dist", "engine", "project_knowledge_contract.js"));
+        const lifecycleKnowledge = await import(path.join(rootDir, "dist", "engine", "lifecycle_knowledge_contract.js"));
         const report = projectKnowledge.auditProjectKnowledge(tmp);
         if (report.hard_fail_count !== 0 || report.injectable < 1) {
             hardFail("PROJECT_KNOWLEDGE_RULE_NOT_CONSUMABLE", "用户项目 .soloforge/knowledge hard rule 未被识别为可消费规则", ["src/engine/project_knowledge_contract.ts"], "project-knowledge-consumption", "旧链路只同步/索引内置模板，未证明用户项目自定义规则可被承载消费", "修复项目知识合同审计与选择逻辑");
         }
-        const selected = projectKnowledge.selectProjectKnowledgeForTask(report, {
-            intent: "实现机构端 API 接口统一响应",
+        const selected = projectKnowledge.selectProjectKnowledgeForTaskWithReasons(report, {
+            intent: "实现业务端 API 接口统一响应",
             route: "code_change",
             tech_stack: ["spring"],
         });
-        if (!selected.some((asset) => asset.id === "smartcare-api-response-rule")) {
+        if (!selected.selected.some((decision) => decision.asset.id === "demo-api-response-rule")) {
             hardFail("PROJECT_KNOWLEDGE_RULE_NOT_SELECTED", "用户项目自定义 hard rule 未按意图/路由/技术栈被选中", ["src/engine/project_knowledge_contract.ts"], "project-knowledge-consumption", "索引存在不等于任务会消费", "补齐 selectProjectKnowledgeForTask 行为和门禁");
         }
+        const selection = projectKnowledge.selectProjectKnowledgeForTaskWithReasons(report, {
+            intent: "实现业务端 API 接口统一响应 PHASE-001 SLICE-001 DD-A001 AC-001",
+            route: "code_change",
+            tech_stack: ["spring"],
+            lifecycle_stage: "implementation",
+            changed_files: ["backend/web/src/main/java/com/example/web/tenant/TenantUserController.java"],
+            traceability_ids: ["PHASE-001", "SLICE-001", "DD-A001", "AC-001"],
+        });
+        const selectedDecision = selection.selected.find((decision) => decision.asset.id === "demo-api-response-rule");
+        if (!selectedDecision || !selectedDecision.reason_zh || !Array.isArray(selectedDecision.matched_signals)) {
+            hardFail("PROJECT_KNOWLEDGE_SELECTION_REASON_MISSING", "用户项目规则选择缺少 why selected / matched_signals 结构化解释", ["src/engine/project_knowledge_contract.ts", "src/engine/intent_expander.ts"], "project-knowledge-consumption", "用户不知道为什么规则被选中就无法判断必须确认和修复路径", "让项目知识选择返回 SelectionDecision 而不是裸资产");
+        }
+        const unifiedDecision = lifecycleKnowledge.evaluateLifecycleKnowledgeDecision({
+            projectPath: tmp,
+            consumer: "sf_expand",
+            intent: "实现业务端 API 接口统一响应 PHASE-001 SLICE-001 DD-A001 AC-001",
+            route: "code_change",
+            lifecycle_stage: "implementation",
+            changed_files: ["backend/web/src/main/java/com/example/web/tenant/TenantUserController.java"],
+            verified_files: ["backend/web/src/main/java/com/example/web/tenant/TenantUserController.java"],
+            traceability_ids: ["PHASE-001", "SLICE-001", "DD-A001", "AC-001"],
+            tech_stack: ["spring"],
+            generation_traces: [
+                { tool_name: "sf_classify", status: "passed", evidence_kind: "result" },
+                { tool_name: "sf_expand", status: "passed", evidence_kind: "result" },
+            ],
+            record_trace: true,
+        });
+        if (unifiedDecision.contract_id !== "lifecycle_knowledge_contract/v1" ||
+            !unifiedDecision.knowledge_selection.selected.some((decision) => decision.asset.id === "demo-api-response-rule") ||
+            !unifiedDecision.authoritative_paths.traceability_matrix ||
+            !Array.isArray(unifiedDecision.recovery_commands)) {
+            hardFail("LIFECYCLE_KNOWLEDGE_DECISION_BUNDLE_INVALID", "统一生命周期知识决策包未同时携带权威路径、SelectionDecision、恢复命令和消费 trace", ["src/engine/lifecycle_knowledge_contract.ts", "src/engine/project_knowledge_contract.ts"], "project-knowledge-consumption", "next/expand/verify/deliver 如果不消费同一决策包，会再次产生局部口径", "修复 evaluateLifecycleKnowledgeDecision 返回结构和入口消费");
+        }
         const expander = await import(path.join(rootDir, "dist", "engine", "intent_expander.js"));
         const expandResult = await expander.expand({
-            intent: "实现机构端 API 接口统一响应",
+            intent: "实现业务端 API 接口统一响应",
             classification: {
                 task_type: "feature",
                 risk: "low",
@@ -2852,8 +2930,10 @@ enforcement:
                 decision_version: 1,
             },
         });
-        if (!expandResult.project_knowledge?.selected?.some((asset) => asset.id === "smartcare-api-response-rule")
-            || !String(expandResult.prompt).includes("## 用户项目规则")) {
+        if (!expandResult.project_knowledge?.selected?.some((asset) => asset.id === "demo-api-response-rule")
+            || !String(expandResult.prompt).includes("## 用户项目规则")
+            || !String(expandResult.prompt).includes("选中原因")
+            || !expandResult.project_knowledge?.selection_decisions?.some((decision) => decision.id === "demo-api-response-rule" && decision.reason_zh)) {
             hardFail("PROJECT_KNOWLEDGE_NOT_IN_EXPAND_MAINPATH", "用户项目规则未进入 sf_expand 真实 prompt 和结构化结果", ["src/engine/intent_expander.ts", "src/engine/project_knowledge_contract.ts"], "project-knowledge-consumption", "审计/选择通过不等于 MCP 主链路会消费", "将项目规则接入 sf_expand 并补主链路测试");
         }
         const nextPlanner = await import(path.join(rootDir, "dist", "engine", "next_action_planner.js"));
@@ -2861,11 +2941,24 @@ enforcement:
         if (!nextPlan.project_knowledge_context || nextPlan.project_knowledge_context.total < 1) {
             hardFail("PROJECT_KNOWLEDGE_NOT_IN_NEXT", "soloforge next 未携带项目知识上下文，用户无法知道下一步会应用哪些项目规则", ["src/engine/next_action_planner.ts", "src/bin/soloforge.ts"], "project-knowledge-consumption", "旧导航只看阶段，不看项目规则", "将项目知识上下文接入 next JSON 和人类输出");
         }
+        if (nextPlan.project_knowledge_context?.selected?.length
+            && !nextPlan.project_knowledge_context.selected.some((item) => item.reason_zh && item.enforcement)) {
+            hardFail("PROJECT_KNOWLEDGE_NEXT_REASON_MISSING", "soloforge next 项目规则上下文缺少选中原因或强制级别", ["src/engine/next_action_planner.ts", "src/bin/soloforge.ts"], "project-knowledge-consumption", "next 只列规则名不能支撑用户确认哪些必须满足", "在 next 中展示 SelectionDecision 的 reason/enforcement/verification");
+        }
         const badTmp = fs.mkdtempSync(path.join(os.tmpdir(), "soloforge-project-knowledge-bad-"));
         try {
             const badDir = path.join(badTmp, ".soloforge", "knowledge", "rules");
             fs.mkdirSync(badDir, { recursive: true });
-            fs.writeFileSync(path.join(badDir, "未路由强规则.md"), "# 未路由强规则\n\n必须使用统一响应。", "utf-8");
+            fs.writeFileSync(path.join(badDir, "未路由强规则.md"), `---
+id: unrouted-hard-rule
+asset_kind: hard_rule
+enforcement:
+  level: hard_rule
+---
+# 未路由强规则
+
+必须使用统一响应。
+`, "utf-8");
             const badReport = projectKnowledge.auditProjectKnowledge(badTmp);
             if (badReport.hard_fail_count === 0) {
                 hardFail("PROJECT_KNOWLEDGE_UNROUTED_RULE_FALSE_PASS", "用户项目 hard rule 缺少 routes/primary_triggers 时错误放行", ["src/engine/project_knowledge_contract.ts"], "project-knowledge-consumption", "规则文件存在不等于可稳定消费", "对未路由 hard rule fail-closed");
@@ -2914,6 +3007,42 @@ enforcement:
         finally {
             fs.rmSync(conflictTmp, { recursive: true, force: true });
         }
+        const semanticConflictTmp = fs.mkdtempSync(path.join(os.tmpdir(), "soloforge-project-knowledge-semantic-conflict-"));
+        try {
+            const semanticDir = path.join(semanticConflictTmp, ".soloforge", "knowledge", "rules");
+            fs.mkdirSync(semanticDir, { recursive: true });
+            fs.writeFileSync(path.join(semanticDir, "响应ApiResponse.md"), `---
+id: response-api-response
+asset_kind: hard_rule
+routes: [code_change]
+primary_triggers: [API响应]
+enforcement:
+  level: hard_rule
+---
+# API 响应
+
+必须使用 ApiResponse。
+`, "utf-8");
+            fs.writeFileSync(path.join(semanticDir, "响应Result.md"), `---
+id: response-result
+asset_kind: hard_rule
+routes: [code_change]
+primary_triggers: [接口响应]
+enforcement:
+  level: hard_rule
+---
+# 接口响应
+
+必须使用 Result。
+`, "utf-8");
+            const semanticConflictReport = projectKnowledge.auditProjectKnowledge(semanticConflictTmp);
+            if (!semanticConflictReport.assets.some((asset) => asset.findings.some((finding) => finding.code === "PROJECT_KNOWLEDGE_RULE_CONFLICT"))) {
+                hardFail("PROJECT_KNOWLEDGE_SEMANTIC_CONFLICT_FALSE_PASS", "API 响应格式语义冲突依赖手写 conflict_group，未自动进入用户确认", ["src/engine/project_knowledge_contract.ts"], "project-knowledge-consumption", "项目规则冲突不能要求用户预先正确标注才能发现", "补 API 响应/分页/日志/DB/权限语义冲突检测");
+            }
+        }
+        finally {
+            fs.rmSync(semanticConflictTmp, { recursive: true, force: true });
+        }
     }
     catch (e) {
         hardFail("PROJECT_KNOWLEDGE_AUDIT_FAILED", `用户项目知识消费行为审计执行失败: ${e.message}`, ["src/engine/project_knowledge_contract.ts"], "project-knowledge-consumption", "项目知识消费必须有可执行行为门禁", "修复项目知识合同模块和编译产物");