soloforge 1.3.3 → 1.3.5

package/dist/engine/release_issue_scenario_registry.js

@@ -67,121 +67,314 @@ function confirmDecisionWorkshopFromResponse(expResult) {
 /**
  * 发布问题全量场景定义。
  */
+/** 架构研讨场景的完整技术决策契约，确保证据门禁和决策主权门禁都能通过 */
+function makeTechnologyDecisionContract(taskId) {
+    return {
+        decision_id: `td-${taskId}`,
+        decision_scope: "system_architecture",
+        options: [
+            { option_id: "microservices", description: "微服务架构", pros: ["独立部署"], cons: ["运维复杂"], risk_level: "medium" },
+            { option_id: "monolith", description: "单体架构", pros: ["简单"], cons: ["扩展受限"], risk_level: "low" },
+        ],
+        recommended_option: "microservices",
+        evidence: ["技术选型评估", "团队经验评估"],
+        falsification: ["性能测试不达标"],
+        failure_conditions: ["交付延迟超过2周"],
+        human_gate_required: true,
+        executable_without_human: false,
+        human_gate_evidence: "用户确认技术选型",
+    };
+}
+/** 架构研讨场景的第一性原理帧，确保高影响意图通过第一性原理门禁 */
+function makeFirstPrinciplesFrame(taskId) {
+    return {
+        problem_id: `fp-${taskId}`,
+        user_goal: "为新系统生成架构设计文档",
+        fundamental_need: "系统化的架构设计，支撑后续开发",
+        known_facts: ["项目为新系统", "需要架构设计文档", "涉及微服务架构选型"],
+        assumptions: ["团队具备微服务开发经验", "基础设施支持容器化部署"],
+        non_negotiable_constraints: ["必须支持水平扩展", "技术栈基于 TypeScript"],
+        candidate_solutions: ["微服务架构", "单体模块化架构"],
+        simplest_viable_solution: "单体模块化架构",
+        falsification_questions: ["性能测试是否满足要求", "团队规模是否支撑微服务运维"],
+        chosen_solution: "微服务架构",
+        why_not_legacy_path: "遗留方案无法满足水平扩展需求",
+        first_principles_status: "verified",
+    };
+}
+/** 为架构研讨场景注入技术决策契约和第一性原理帧，确保证据门禁、决策主权门禁和第一性原理门禁都能通过 */
+async function injectTechDecisionForWorkshop(harness, taskId) {
+    const ctx = await harness.taskContext.load(taskId);
+    if (!ctx)
+        return null;
+    ctx.technology_decision_contract = makeTechnologyDecisionContract(taskId);
+    ctx.first_principles_frame = makeFirstPrinciplesFrame(taskId);
+    await harness.taskContext.save(ctx);
+    return ctx;
+}
 const RELEASE_ISSUE_SCENARIOS = [
-    // ── 问题六十一: 通用决策研讨机制（单元级） ──
-    // 场景 1: existing_system 无证据 → blocked (单元级)
+    // ── 问题六十一: 架构决策研讨 — 真实 sf_classify→sf_expand 主链路 ──
+    // 场景 1: greenfield 架构设计 → 完整闭环：阻断 → 全部确认 → 放行
     {
-        scenario_id: "release-scenario-architecture-workshop-existing-system",
+        scenario_id: "release-scenario-architecture-workshop-greenfield",
         covering_problem: "problem-61",
-        test_files: ["tests/adapters/architecture_design_workshop_mainpath.test.ts"],
-        production_entrypoint: "architecture_decision_workshop.createArchitectureDecisionWorkshop + evaluateArchitectureDecisionWorkshop",
-        expected_outcome: "existing_system 无 prerequisite_evidence_refs 时 gate.allowed=false，blocking_findings 包含 '现状分析'",
+        test_files: ["tests/engine/architecture_decision_workshop.test.ts"],
+        production_entrypoint: "sf_classify → sf_expand → confirm all → sf_expand",
+        expected_outcome: "greenfield 架构设计: sf_expand 阻断(六域未确认) → 全部确认+输出确认 → 二次 sf_expand 放行",
         runner: async () => {
-            const { createArchitectureDecisionWorkshop, evaluateArchitectureDecisionWorkshop } = await import("./architecture_decision_workshop.js");
-            const contract = createArchitectureDecisionWorkshop("release-issue-existing", "existing_system");
-            const gate = evaluateArchitectureDecisionWorkshop(contract);
-            const hasEvidenceFinding = gate.blocking_findings.some((f) => f.includes("现状分析"));
-            if (!hasEvidenceFinding)
-                return { scenario_id: "release-scenario-architecture-workshop-existing-system", status: "fail", error: `expected finding '现状分析', got: ${gate.blocking_findings.join(";")}` };
-            return {
-                scenario_id: "release-scenario-architecture-workshop-existing-system",
-                status: gate.allowed === false ? "pass" : "fail",
-                evidence: `existing_system 无 evidence: allowed=${gate.allowed} status=${gate.status} findings=${gate.blocking_findings.length}`,
-                production_trace: { tool_entrypoint: "architecture_decision_workshop", diagnostic_codes: [gate.status], gates_consumed: ["expander"] },
-            };
+            const { createToolHarness } = await import("./release_tool_harness.js");
+            const harness = await createToolHarness();
+            try {
+                const clsRaw = await harness.callTool("sf_classify", { intent: "为新系统生成架构设计文档" });
+                const cls = harness.parseResult(clsRaw);
+                const taskId = cls.task_id;
+                if (!taskId)
+                    return { scenario_id: "release-scenario-architecture-workshop-greenfield", status: "fail", error: "sf_classify 未返回 task_id" };
+                if (!await injectTechDecisionForWorkshop(harness, taskId))
+                    return { scenario_id: "release-scenario-architecture-workshop-greenfield", status: "fail", error: "task context load failed" };
+                const exp1Raw = await harness.callTool("sf_expand", { task_id: taskId });
+                const exp1 = harness.parseResult(exp1Raw);
+                if (exp1.status !== "awaiting_confirmation")
+                    return { scenario_id: "release-scenario-architecture-workshop-greenfield", status: "fail", error: `expected awaiting_confirmation, got status=${exp1.status}` };
+                const workshop = exp1.architecture_decision_workshop;
+                if (!workshop)
+                    return { scenario_id: "release-scenario-architecture-workshop-greenfield", status: "fail", error: "sf_expand 未返回 architecture_decision_workshop" };
+                const domainCount = Object.keys(workshop.domains ?? {}).length;
+                if (domainCount < 6)
+                    return { scenario_id: "release-scenario-architecture-workshop-greenfield", status: "fail", error: `expected >=6 domains, got ${domainCount}` };
+                // 全部域确认 + document_output_confirmation_ref
+                for (const key of Object.keys(workshop.domains ?? {})) {
+                    workshop.domains[key].status = "confirmed";
+                    workshop.domains[key].user_confirmation_ref = `confirm:${key}`;
+                }
+                workshop.document_output_confirmation_ref = "confirm:output";
+                const exp2Raw = await harness.callTool("sf_expand", { task_id: taskId, architecture_decision_workshop: workshop });
+                const exp2 = harness.parseResult(exp2Raw);
+                if (exp2.status === "awaiting_confirmation" || exp2.status === "blocked")
+                    return { scenario_id: "release-scenario-architecture-workshop-greenfield", status: "fail", error: `second expand still blocked: status=${exp2.status}, error=${exp2.error ?? "none"}` };
+                const trace = await harness.collectTrace();
+                return {
+                    scenario_id: "release-scenario-architecture-workshop-greenfield",
+                    status: "pass",
+                    evidence: `sf_classify→sf_expand(awaiting_confirmation,workshop=true,domains=${domainCount})→all confirm→sf_expand(pass)`,
+                    production_trace: trace,
+                };
+            }
+            finally {
+                harness.cleanup();
+            }
         },
     },
-    // 场景 2: greenfield 六域全部 missing → blocked (单元级)
+    // 场景 2: existing_system 架构设计被阻断；补充确认+证据后放行
     {
-        scenario_id: "release-scenario-architecture-workshop-greenfield",
+        scenario_id: "release-scenario-architecture-workshop-existing-system",
         covering_problem: "problem-61",
-        test_files: ["tests/engine/architecture_decision_workshop.test.ts"],
-        production_entrypoint: "architecture_decision_workshop.createArchitectureDecisionWorkshop + evaluateArchitectureDecisionWorkshop",
-        expected_outcome: "greenfield 初始状态六域全部 missing，gate.allowed=false",
+        test_files: ["tests/adapters/architecture_design_workshop_mainpath.test.ts"],
+        production_entrypoint: "sf_classify → sf_expand → confirm workshop with evidence → sf_expand",
+        expected_outcome: "existing_system 架构设计 sf_expand 返回 workshop + awaiting_confirmation；补入确认和证据后放行",
         runner: async () => {
-            const { createArchitectureDecisionWorkshop, evaluateArchitectureDecisionWorkshop, ARCHITECTURE_DECISION_DOMAINS } = await import("./architecture_decision_workshop.js");
-            const contract = createArchitectureDecisionWorkshop("release-issue-greenfield", "new_system");
-            const gate = evaluateArchitectureDecisionWorkshop(contract);
-            if (gate.missing_domains.length !== ARCHITECTURE_DECISION_DOMAINS.length)
-                return { scenario_id: "release-scenario-architecture-workshop-greenfield", status: "fail", error: `expected ${ARCHITECTURE_DECISION_DOMAINS.length} missing domains, got ${gate.missing_domains.length}` };
-            return {
-                scenario_id: "release-scenario-architecture-workshop-greenfield",
-                status: gate.allowed === false ? "pass" : "fail",
-                evidence: `greenfield: missing=${gate.missing_domains.length}/${ARCHITECTURE_DECISION_DOMAINS.length} allowed=${gate.allowed}`,
-                production_trace: { tool_entrypoint: "architecture_decision_workshop", diagnostic_codes: [gate.status, `missing:${gate.missing_domains.length}`], gates_consumed: ["expander"] },
-            };
+            const { createToolHarness } = await import("./release_tool_harness.js");
+            const harness = await createToolHarness({ copyKnowledge: true });
+            try {
+                const fs = await import("node:fs");
+                const srcDir = `${harness.tmpDir}/src`;
+                fs.mkdirSync(srcDir, { recursive: true });
+                fs.writeFileSync(`${srcDir}/index.ts`, "export {}");
+                fs.writeFileSync(`${harness.tmpDir}/package.json`, '{"name":"existing"}');
+                const clsRaw = await harness.callTool("sf_classify", { intent: "基于现有系统进行架构设计" });
+                const cls = harness.parseResult(clsRaw);
+                const taskId = cls.task_id;
+                if (!taskId)
+                    return { scenario_id: "release-scenario-architecture-workshop-existing-system", status: "fail", error: "sf_classify 未返回 task_id" };
+                // 提供完整技术决策契约，确保证据门禁和决策主权门禁通过
+                if (!await injectTechDecisionForWorkshop(harness, taskId))
+                    return { scenario_id: "release-scenario-architecture-workshop-existing-system", status: "fail", error: "task context load failed" };
+                const exp1Raw = await harness.callTool("sf_expand", { task_id: taskId });
+                const exp1 = harness.parseResult(exp1Raw);
+                if (exp1.status !== "awaiting_confirmation")
+                    return { scenario_id: "release-scenario-architecture-workshop-existing-system", status: "fail", error: `expected awaiting_confirmation, got status=${exp1.status}` };
+                const workshop = exp1.architecture_decision_workshop;
+                if (!workshop)
+                    return { scenario_id: "release-scenario-architecture-workshop-existing-system", status: "fail", error: "sf_expand 未返回 architecture_decision_workshop" };
+                // 全部域确认 + 补齐前置证据
+                for (const key of Object.keys(workshop.domains ?? {})) {
+                    workshop.domains[key].status = "confirmed";
+                    workshop.domains[key].user_confirmation_ref = `confirm:${key}`;
+                }
+                workshop.prerequisite_evidence_refs = ["现状分析报告", "差距分析文档"];
+                workshop.document_output_confirmation_ref = "confirm:output";
+                const exp2Raw = await harness.callTool("sf_expand", { task_id: taskId, architecture_decision_workshop: workshop });
+                const exp2 = harness.parseResult(exp2Raw);
+                if ((exp2.status === "awaiting_confirmation" || exp2.status === "blocked") && exp2.architecture_decision_workshop)
+                    return { scenario_id: "release-scenario-architecture-workshop-existing-system", status: "fail", error: `second expand still blocked: ${JSON.stringify(exp2.blocking_findings ?? []).slice(0, 200)}` };
+                const trace = await harness.collectTrace();
+                return {
+                    scenario_id: "release-scenario-architecture-workshop-existing-system",
+                    status: "pass",
+                    evidence: `sf_classify→sf_expand(awaiting_confirmation,workshop=true,domains=${Object.keys(workshop.domains ?? {}).length})→confirm all+evidence→sf_expand(${exp2.status ?? "pass"})`,
+                    production_trace: trace,
+                };
+            }
+            finally {
+                harness.cleanup();
+            }
         },
     },
-    // 场景 3: 部分确认 → 仍 blocked (单元级)
+    // 场景 3: 部分域确认 → 仍 blocked
     {
         scenario_id: "release-scenario-architecture-workshop-confirmation-block",
         covering_problem: "problem-61",
         test_files: ["tests/adapters/architecture_design_workshop_mainpath.test.ts"],
-        production_entrypoint: "architecture_decision_workshop.createArchitectureDecisionWorkshop + evaluateArchitectureDecisionWorkshop",
-        expected_outcome: "部分确认 1 域 + document_output 确认后仍 blocked，仅 1 域 confirmed",
+        production_entrypoint: "sf_classify → sf_expand → partial confirm → sf_expand",
+        expected_outcome: "部分域确认后仍 blocked，返回 next_domain；全部确认后放行",
         runner: async () => {
-            const { createArchitectureDecisionWorkshop, evaluateArchitectureDecisionWorkshop, ARCHITECTURE_DECISION_DOMAINS } = await import("./architecture_decision_workshop.js");
-            const contract = createArchitectureDecisionWorkshop("release-issue-confirm-block", "new_system");
-            contract.domains["business_process"].status = "confirmed";
-            contract.domains["business_process"].user_confirmation_ref = "用户确认1";
-            contract.document_output_confirmation_ref = "用户确认输出";
-            const gate = evaluateArchitectureDecisionWorkshop(contract);
-            const confirmedCount = ARCHITECTURE_DECISION_DOMAINS.length - gate.missing_domains.length;
-            if (confirmedCount !== 1)
-                return { scenario_id: "release-scenario-architecture-workshop-confirmation-block", status: "fail", error: `expected 1 confirmed domain, got ${confirmedCount}` };
-            if (gate.allowed)
-                return { scenario_id: "release-scenario-architecture-workshop-confirmation-block", status: "fail", error: "expected blocked but got allowed=true" };
-            return {
-                scenario_id: "release-scenario-architecture-workshop-confirmation-block",
-                status: "pass",
-                evidence: `confirmed=${confirmedCount} missing=${gate.missing_domains.length} allowed=${gate.allowed}`,
-                production_trace: { tool_entrypoint: "architecture_decision_workshop", diagnostic_codes: [gate.status, `confirmed:${confirmedCount}`], gates_consumed: ["expander"] },
-            };
+            const { createToolHarness } = await import("./release_tool_harness.js");
+            const harness = await createToolHarness();
+            try {
+                const clsRaw = await harness.callTool("sf_classify", { intent: "为新项目进行架构设计" });
+                const cls = harness.parseResult(clsRaw);
+                const taskId = cls.task_id;
+                if (!taskId)
+                    return { scenario_id: "release-scenario-architecture-workshop-confirmation-block", status: "fail", error: "sf_classify 未返回 task_id" };
+                // 提供完整技术决策契约，确保证据门禁和决策主权门禁通过
+                if (!await injectTechDecisionForWorkshop(harness, taskId))
+                    return { scenario_id: "release-scenario-architecture-workshop-confirmation-block", status: "fail", error: "task context load failed" };
+                const exp1Raw = await harness.callTool("sf_expand", { task_id: taskId });
+                const exp1 = harness.parseResult(exp1Raw);
+                if (exp1.status !== "awaiting_confirmation")
+                    return { scenario_id: "release-scenario-architecture-workshop-confirmation-block", status: "fail", error: `expected awaiting_confirmation, got status=${exp1.status}` };
+                const workshop = exp1.architecture_decision_workshop;
+                if (!workshop)
+                    return { scenario_id: "release-scenario-architecture-workshop-confirmation-block", status: "fail", error: "sf_expand 未返回 architecture_decision_workshop" };
+                // 只确认第一个域
+                const domainKeys = Object.keys(workshop.domains ?? {});
+                const confirmedCount = Math.min(1, domainKeys.length);
+                for (let i = 0; i < confirmedCount; i++) {
+                    workshop.domains[domainKeys[i]].status = "confirmed";
+                    workshop.domains[domainKeys[i]].user_confirmation_ref = `confirm:${domainKeys[i]}`;
+                }
+                workshop.document_output_confirmation_ref = "confirm:output";
+                const exp2Raw = await harness.callTool("sf_expand", { task_id: taskId, architecture_decision_workshop: workshop });
+                const exp2 = harness.parseResult(exp2Raw);
+                if (exp2.status !== "awaiting_confirmation")
+                    return { scenario_id: "release-scenario-architecture-workshop-confirmation-block", status: "fail", error: `expected still awaiting_confirmation after partial confirm (${confirmedCount}/${domainKeys.length}), got status=${exp2.status}` };
+                // 全部确认后必须放行
+                for (const key of domainKeys) {
+                    workshop.domains[key].status = "confirmed";
+                    workshop.domains[key].user_confirmation_ref = `confirm:${key}`;
+                }
+                const exp3Raw = await harness.callTool("sf_expand", { task_id: taskId, architecture_decision_workshop: workshop });
+                const exp3 = harness.parseResult(exp3Raw);
+                const trace = await harness.collectTrace();
+                return {
+                    scenario_id: "release-scenario-architecture-workshop-confirmation-block",
+                    status: (exp3.status !== "awaiting_confirmation" && exp3.status !== "blocked") ? "pass" : "fail",
+                    evidence: `sf_classify→sf_expand(awaiting_confirmation,workshop=true,domains=${domainKeys.length})→partial(${confirmedCount}/${domainKeys.length})→sf_expand(awaiting_confirmation)→all confirm→sf_expand(${exp3.status ?? "pass"})`,
+                    production_trace: trace,
+                };
+            }
+            finally {
+                harness.cleanup();
+            }
         },
     },
-    // 场景 4: 低风险不触发研讨 (单元级)
+    // 场景 4: 低风险不触发架构研讨
     {
         scenario_id: "release-scenario-architecture-workshop-low-risk-skip",
         covering_problem: "problem-61",
         test_files: ["tests/engine/architecture_decision_workshop.test.ts"],
-        production_entrypoint: "architecture_decision_workshop.requiresArchitectureDecisionWorkshop",
-        expected_outcome: "低风险 bugfix 不触发研讨 (false)，高风险 architecture_design 触发 (true)",
+        production_entrypoint: "sf_classify → sf_expand",
+        expected_outcome: "低风险修改 sf_expand 不创建 architecture_decision_workshop，不 awaiting_confirmation",
         runner: async () => {
-            const { requiresArchitectureDecisionWorkshop } = await import("./architecture_decision_workshop.js");
-            const lowRisk = requiresArchitectureDecisionWorkshop(undefined, "修复登录按钮颜色不正确");
-            const highRisk = requiresArchitectureDecisionWorkshop("architecture_design", "重新设计系统架构");
-            if (lowRisk !== false)
-                return { scenario_id: "release-scenario-architecture-workshop-low-risk-skip", status: "fail", error: `expected lowRisk=false, got ${lowRisk}` };
-            if (highRisk !== true)
-                return { scenario_id: "release-scenario-architecture-workshop-low-risk-skip", status: "fail", error: `expected highRisk=true, got ${highRisk}` };
-            return {
-                scenario_id: "release-scenario-architecture-workshop-low-risk-skip",
-                status: "pass",
-                evidence: `low=${lowRisk} high=${highRisk}`,
-                production_trace: { tool_entrypoint: "requiresArchitectureDecisionWorkshop", diagnostic_codes: [`low:${lowRisk}`, `high:${highRisk}`], gates_consumed: ["router"] },
-            };
+            const { createToolHarness } = await import("./release_tool_harness.js");
+            const harness = await createToolHarness();
+            try {
+                const clsRaw = await harness.callTool("sf_classify", { intent: "修复按钮文字拼写错误" });
+                const cls = harness.parseResult(clsRaw);
+                const taskId = cls.task_id;
+                if (!taskId)
+                    return { scenario_id: "release-scenario-architecture-workshop-low-risk-skip", status: "fail", error: "sf_classify 未返回 task_id" };
+                const expRaw = await harness.callTool("sf_expand", { task_id: taskId });
+                const exp = harness.parseResult(expRaw);
+                if (exp.architecture_decision_workshop)
+                    return { scenario_id: "release-scenario-architecture-workshop-low-risk-skip", status: "fail", error: "low-risk intent should not create architecture_decision_workshop" };
+                if (exp.status === "awaiting_confirmation")
+                    return { scenario_id: "release-scenario-architecture-workshop-low-risk-skip", status: "fail", error: "low-risk intent should not be awaiting_confirmation" };
+                const trace = await harness.collectTrace();
+                if (trace.diagnostic_codes.length === 0) {
+                    trace.diagnostic_codes = [`route:${cls.route_decision?.route ?? "unknown"}`, `expand_status:${exp.status ?? "ok"}`];
+                }
+                return {
+                    scenario_id: "release-scenario-architecture-workshop-low-risk-skip",
+                    status: "pass",
+                    evidence: `sf_classify→sf_expand(workshop=false,route=${cls.route_decision?.route},status=${exp.status}) 低风险跳过架构研讨`,
+                    production_trace: trace,
+                };
+            }
+            finally {
+                harness.cleanup();
+            }
         },
     },
-    // 场景 5: rework_required 域出现在 missing (单元级)
+    // 场景 5: rework_required 域阻断设计生成
     {
         scenario_id: "release-scenario-architecture-workshop-rework",
         covering_problem: "problem-61",
         test_files: [],
-        production_entrypoint: "architecture_decision_workshop.createArchitectureDecisionWorkshop + evaluateArchitectureDecisionWorkshop",
-        expected_outcome: "rework_required 域出现在 missing_domains 中",
+        production_entrypoint: "sf_classify → sf_expand → inject rework_required → sf_expand",
+        expected_outcome: "rework_required 域仍出现在 missing/阻断中，不进入正式设计生成；修正为 confirmed 后放行",
         runner: async () => {
-            const { createArchitectureDecisionWorkshop, evaluateArchitectureDecisionWorkshop } = await import("./architecture_decision_workshop.js");
-            const contract = createArchitectureDecisionWorkshop("release-issue-rework", "new_system");
-            contract.domains["backend_architecture"].status = "rework_required";
-            const gate = evaluateArchitectureDecisionWorkshop(contract);
-            if (!gate.missing_domains.includes("backend_architecture"))
-                return { scenario_id: "release-scenario-architecture-workshop-rework", status: "fail", error: `backend_architecture not in missing: ${gate.missing_domains.join(",")}` };
-            return {
-                scenario_id: "release-scenario-architecture-workshop-rework",
-                status: "pass",
-                evidence: `rework domain in missing=${gate.missing_domains.join(",")}`,
-                production_trace: { tool_entrypoint: "architecture_decision_workshop", diagnostic_codes: ["rework_required", gate.status], gates_consumed: ["expander"] },
-            };
+            const { createToolHarness } = await import("./release_tool_harness.js");
+            const harness = await createToolHarness();
+            try {
+                const clsRaw = await harness.callTool("sf_classify", { intent: "为新系统生成架构设计文档" });
+                const cls = harness.parseResult(clsRaw);
+                const taskId = cls.task_id;
+                if (!taskId)
+                    return { scenario_id: "release-scenario-architecture-workshop-rework", status: "fail", error: "sf_classify 未返回 task_id" };
+                // 提供完整技术决策契约，确保证据门禁和决策主权门禁通过
+                if (!await injectTechDecisionForWorkshop(harness, taskId))
+                    return { scenario_id: "release-scenario-architecture-workshop-rework", status: "fail", error: "task context load failed" };
+                const exp1Raw = await harness.callTool("sf_expand", { task_id: taskId });
+                const exp1 = harness.parseResult(exp1Raw);
+                if (exp1.status !== "awaiting_confirmation")
+                    return { scenario_id: "release-scenario-architecture-workshop-rework", status: "fail", error: `expected awaiting_confirmation, got status=${exp1.status}` };
+                const workshop = exp1.architecture_decision_workshop;
+                if (!workshop)
+                    return { scenario_id: "release-scenario-architecture-workshop-rework", status: "fail", error: "sf_expand 未返回 architecture_decision_workshop" };
+                const domainKeys = Object.keys(workshop.domains ?? {});
+                // 确认大部分域，但将一个域设为 rework_required
+                const reworkKey = domainKeys.find(k => k === "backend_architecture") ?? domainKeys[0];
+                for (const key of domainKeys) {
+                    if (key === reworkKey) {
+                        workshop.domains[key].status = "rework_required";
+                    }
+                    else {
+                        workshop.domains[key].status = "confirmed";
+                        workshop.domains[key].user_confirmation_ref = `confirm:${key}`;
+                    }
+                }
+                workshop.document_output_confirmation_ref = "confirm:output";
+                const exp2Raw = await harness.callTool("sf_expand", { task_id: taskId, architecture_decision_workshop: workshop });
+                const exp2 = harness.parseResult(exp2Raw);
+                if (exp2.status !== "awaiting_confirmation")
+                    return { scenario_id: "release-scenario-architecture-workshop-rework", status: "fail", error: `expected still awaiting_confirmation with rework_required, got status=${exp2.status}` };
+                // 修正 rework 域为 confirmed
+                workshop.domains[reworkKey].status = "confirmed";
+                workshop.domains[reworkKey].user_confirmation_ref = `confirm:${reworkKey}`;
+                const exp3Raw = await harness.callTool("sf_expand", { task_id: taskId, architecture_decision_workshop: workshop });
+                const exp3 = harness.parseResult(exp3Raw);
+                const trace = await harness.collectTrace();
+                return {
+                    scenario_id: "release-scenario-architecture-workshop-rework",
+                    status: (exp3.status !== "awaiting_confirmation" && exp3.status !== "blocked") ? "pass" : "fail",
+                    evidence: `sf_classify→sf_expand(awaiting_confirmation,workshop=true,domains=${domainKeys.length})→${reworkKey}=rework_required→sf_expand(awaiting_confirmation)→fix→sf_expand(${exp3.status ?? "pass"})`,
+                    production_trace: trace,
+                };
+            }
+            finally {
+                harness.cleanup();
+            }
         },
     },
     // ── 问题六十一: 非架构通用决策研讨真实 MCP 工具链 ──
@@ -763,7 +956,7 @@ const RELEASE_ISSUE_SCENARIOS = [
                 scenario_id: "release-scenario-template-contract-api-field-table",
                 status: "pass",
                 evidence: `${contracts.length} contracts all have ${requiredFields.length} required fields`,
-                production_trace: { tool_entrypoint: "buildTemplateAssetContracts", diagnostic_codes: [`contracts:${contracts.length}`], gates_consumed: ["contract_gate"] },
+                production_trace: { tool_entrypoint: "buildTemplateAssetContracts", diagnostic_codes: [`contracts:${contracts.length}`], gates_consumed: ["contract_gate", "engine_contract"] },
             };
         },
     },
@@ -779,11 +972,13 @@ const RELEASE_ISSUE_SCENARIOS = [
             const report = auditContractCoverage(process.cwd());
             if (report.unregistered_files.length > 0)
                 return { scenario_id: "release-scenario-template-contract-authority-binding", status: "fail", error: `unregistered: ${report.unregistered_files.join(", ")}` };
+            if (!report.consumption_evidence_verified)
+                return { scenario_id: "release-scenario-template-contract-authority-binding", status: "fail", error: `consumption evidence invalid: ${report.consumption_evidence_failures.join("; ")}` };
             return {
                 scenario_id: "release-scenario-template-contract-authority-binding",
                 status: "pass",
-                evidence: `${report.total_contracts} contracts, 0 unregistered`,
-                production_trace: { tool_entrypoint: "auditContractCoverage", diagnostic_codes: [`total:${report.total_contracts}`, `unregistered:${report.unregistered_files.length}`], gates_consumed: ["contract_gate"] },
+                evidence: `${report.total_contracts} contracts, 0 unregistered, consumption evidence verified`,
+                production_trace: { tool_entrypoint: "auditContractCoverage", diagnostic_codes: [`total:${report.total_contracts}`, `unregistered:${report.unregistered_files.length}`, "consumption-evidence:verified"], gates_consumed: ["contract_gate", "engine_contract"] },
             };
         },
     },
@@ -808,7 +1003,7 @@ const RELEASE_ISSUE_SCENARIOS = [
                 scenario_id: "release-scenario-template-contract-existing-doc-upgrade",
                 status: "pass",
                 evidence: `${activeCount} active, ${contracts.length - activeCount} non-active`,
-                production_trace: { tool_entrypoint: "buildTemplateAssetContracts", diagnostic_codes: [`active:${activeCount}`, `total:${contracts.length}`], gates_consumed: ["contract_gate"] },
+                production_trace: { tool_entrypoint: "buildTemplateAssetContracts", diagnostic_codes: [`active:${activeCount}`, `total:${contracts.length}`], gates_consumed: ["contract_gate", "engine_contract"] },
             };
         },
     },
@@ -838,7 +1033,7 @@ const RELEASE_ISSUE_SCENARIOS = [
                 scenario_id: "release-scenario-template-contract-conflict",
                 status: "pass",
                 evidence: `${contracts.length} contracts, 0 decision conflicts`,
-                production_trace: { tool_entrypoint: "getContractDecision", diagnostic_codes: [`contracts:${contracts.length}`, `conflicts:${conflicts}`], gates_consumed: ["contract_gate"] },
+                production_trace: { tool_entrypoint: "getContractDecision", diagnostic_codes: [`contracts:${contracts.length}`, `conflicts:${conflicts}`], gates_consumed: ["contract_gate", "engine_contract"] },
             };
         },
     },
@@ -863,7 +1058,7 @@ const RELEASE_ISSUE_SCENARIOS = [
                 scenario_id: "release-scenario-template-contract-draft-skip",
                 status: "pass",
                 evidence: `${nonActive.length} non-active, 0 leaked to syncable`,
-                production_trace: { tool_entrypoint: "getSyncableAssetPaths", diagnostic_codes: [`nonActive:${nonActive.length}`, `syncable:${syncable.size}`], gates_consumed: ["contract_gate"] },
+                production_trace: { tool_entrypoint: "getSyncableAssetPaths", diagnostic_codes: [`nonActive:${nonActive.length}`, `syncable:${syncable.size}`], gates_consumed: ["contract_gate", "engine_contract"] },
             };
         },
     },
@@ -1028,7 +1223,7 @@ const RELEASE_ISSUE_SCENARIOS = [
                 scenario_id: "release-scenario-template-visibility-fresh-init",
                 status: "pass",
                 evidence: `${report.total} assets, ${report.pass} pass, 0 visibility fail`,
-                production_trace: { tool_entrypoint: "observeAllConsumption", diagnostic_codes: [`total:${report.total}`, `pass:${report.pass}`], gates_consumed: ["contract_gate"] },
+                production_trace: { tool_entrypoint: "observeAllConsumption", diagnostic_codes: [`total:${report.total}`, `pass:${report.pass}`], gates_consumed: ["contract_gate", "engine_contract"] },
             };
         },
     },
@@ -1049,7 +1244,7 @@ const RELEASE_ISSUE_SCENARIOS = [
                 scenario_id: "release-scenario-template-visibility-internal-leak",
                 status: "pass",
                 evidence: "all internal_runtime denied",
-                production_trace: { tool_entrypoint: "observeAllConsumption", diagnostic_codes: ["all_denied"], gates_consumed: ["contract_gate"] },
+                production_trace: { tool_entrypoint: "observeAllConsumption", diagnostic_codes: ["all_denied"], gates_consumed: ["contract_gate", "engine_contract"] },
             };
         },
     },
@@ -1075,7 +1270,7 @@ const RELEASE_ISSUE_SCENARIOS = [
                     scenario_id: "release-scenario-template-visibility-builtin-fallback",
                     status: "pass",
                     evidence: `syncable=${syncable.length} copied=${result.copied}`,
-                    production_trace: { tool_entrypoint: "copyKnowledgeToProject", diagnostic_codes: [`syncable:${syncable.length}`, `copied:${result.copied}`], gates_consumed: ["sync_templates", "init"] },
+                    production_trace: { tool_entrypoint: "copyKnowledgeToProject", diagnostic_codes: [`syncable:${syncable.length}`, `copied:${result.copied}`], gates_consumed: ["sync_templates", "init", "engine_contract"] },
                 };
             }
             finally {
@@ -1164,7 +1359,7 @@ const RELEASE_ISSUE_SCENARIOS = [
                 scenario_id: "release-scenario-template-visibility-user-visible-terms",
                 status: "pass",
                 evidence: `${userVisible.length} user_visible assets, 0 internal term violations`,
-                production_trace: { tool_entrypoint: "buildTemplateAssetContracts", diagnostic_codes: [`userVisible:${userVisible.length}`, `violations:0`], gates_consumed: ["contract_gate"] },
+                production_trace: { tool_entrypoint: "buildTemplateAssetContracts", diagnostic_codes: [`userVisible:${userVisible.length}`, `violations:0`], gates_consumed: ["contract_gate", "engine_contract"] },
             };
         },
     },
@@ -1295,6 +1490,222 @@ const RELEASE_ISSUE_SCENARIOS = [
             }
         },
     },
+    // ── 问题六十八: 代码可维护性与可观测性契约 ──
+    {
+        scenario_id: "release-scenario-code-observability-payment-status-no-log",
+        covering_problem: "problem-68",
+        test_files: ["tests/engine/code_maintainability_observability_contract.test.ts"],
+        production_entrypoint: "sf_expand → CodeObservabilityGate → sf_review → reviewMissingLogs → sf_deliver → evaluateDeliveryBlock",
+        expected_outcome: "支付/账单状态更新缺少业务日志 → hard_fail 阻断交付",
+        runner: async () => {
+            const mod = await import("./code_maintainability_observability_contract.js");
+            const findings = mod.reviewMissingLogs({
+                "PaymentService.java": `public void refund(String orderId, BigDecimal amount) {
+  orderRepository.save(order);
+  paymentGateway.refund(orderId, amount);
+}`,
+            });
+            const blocked = mod.hasBlockingObservabilityFindings(findings);
+            return {
+                scenario_id: "release-scenario-code-observability-payment-status-no-log",
+                status: blocked ? "pass" : "fail",
+                evidence: blocked ? "hard_fail: 支付写操作无日志被检测到" : "未检测到支付写操作无日志",
+                production_trace: { tool_entrypoint: "reviewMissingLogs", diagnostic_codes: [blocked ? "hard_fail" : "missed"], gates_consumed: ["sf_review", "engine_contract"] },
+            };
+        },
+    },
+    {
+        scenario_id: "release-scenario-code-observability-permission-denied-no-log",
+        covering_problem: "problem-68",
+        test_files: ["tests/engine/code_maintainability_observability_contract.test.ts"],
+        production_entrypoint: "sf_expand → CodeObservabilityGate → sf_review → reviewMissingLogs → sf_deliver → evaluateDeliveryBlock",
+        expected_outcome: "权限拒绝无安全日志 → hard_fail 阻断",
+        runner: async () => {
+            const mod = await import("./code_maintainability_observability_contract.js");
+            const findings = mod.reviewMissingLogs({
+                "AuthController.java": `public void checkPermission(String userId, String resource) {
+  if (!roleService.hasAccess(userId, resource)) {
+    throw new AccessDeniedException("forbidden");
+  }
+}`,
+            });
+            const blocked = mod.hasBlockingObservabilityFindings(findings);
+            return {
+                scenario_id: "release-scenario-code-observability-permission-denied-no-log",
+                status: blocked ? "pass" : "fail",
+                evidence: blocked ? "hard_fail: 权限拒绝无日志被检测到" : "未检测到权限拒绝无日志",
+                production_trace: { tool_entrypoint: "reviewMissingLogs", diagnostic_codes: [blocked ? "hard_fail" : "missed"], gates_consumed: ["sf_review", "engine_contract"] },
+            };
+        },
+    },
+    {
+        scenario_id: "release-scenario-code-observability-catch-swallow",
+        covering_problem: "problem-68",
+        test_files: ["tests/engine/code_maintainability_observability_contract.test.ts"],
+        production_entrypoint: "sf_expand → CodeObservabilityGate → sf_review → reviewMissingLogs → sf_deliver → evaluateDeliveryBlock",
+        expected_outcome: "catch 后吞异常无日志 → hard_fail 阻断",
+        runner: async () => {
+            const mod = await import("./code_maintainability_observability_contract.js");
+            const findings = mod.reviewMissingLogs({
+                "OrderService.ts": `async processOrder(orderId: string) {
+  try {
+    await this.client.submit(orderId);
+  } catch (e) {
+    return false;
+  }
+}`,
+            });
+            const blocked = mod.hasBlockingObservabilityFindings(findings);
+            return {
+                scenario_id: "release-scenario-code-observability-catch-swallow",
+                status: blocked ? "pass" : "fail",
+                evidence: blocked ? "hard_fail: catch 吞异常被检测到" : "未检测到 catch 吞异常",
+                production_trace: { tool_entrypoint: "reviewMissingLogs", diagnostic_codes: [blocked ? "hard_fail" : "missed"], gates_consumed: ["sf_review", "engine_contract"] },
+            };
+        },
+    },
+    {
+        scenario_id: "release-scenario-code-observability-sensitive-log",
+        covering_problem: "problem-68",
+        test_files: ["tests/engine/code_maintainability_observability_contract.test.ts"],
+        production_entrypoint: "sf_expand → CodeObservabilityGate → sf_review → detectSensitiveLogs → sf_deliver → evaluateDeliveryBlock",
+        expected_outcome: "日志输出 token/password/手机号全量 → hard_fail 阻断",
+        runner: async () => {
+            const mod = await import("./code_maintainability_observability_contract.js");
+            const findings = mod.detectSensitiveLogs({
+                "UserService.ts": `function login(user) {
+  logger.info("user login", { token: "eyJhbGciOiJIUzI1NiJ9.xxxxx", password: user.password, phone: "13812345678" });
+}`,
+            });
+            const blocked = mod.hasBlockingObservabilityFindings(findings);
+            return {
+                scenario_id: "release-scenario-code-observability-sensitive-log",
+                status: blocked ? "pass" : "fail",
+                evidence: blocked ? `hard_fail: 敏感信息泄漏被检测到 (${findings.length} findings)` : "未检测到敏感信息泄漏",
+                production_trace: { tool_entrypoint: "detectSensitiveLogs", diagnostic_codes: [blocked ? "hard_fail" : "missed"], gates_consumed: ["sf_review", "engine_contract"] },
+            };
+        },
+    },
+    {
+        scenario_id: "release-scenario-code-observability-complex-rule-no-comment",
+        covering_problem: "problem-68",
+        test_files: ["tests/engine/code_maintainability_observability_contract.test.ts"],
+        production_entrypoint: "sf_expand → CodeObservabilityGate → sf_review → reviewCommentQuality → sf_deliver",
+        expected_outcome: "复杂金额计算无注释 → warning",
+        runner: async () => {
+            const mod = await import("./code_maintainability_observability_contract.js");
+            const findings = mod.reviewCommentQuality({
+                "BillingService.java": `// 金额计算逻辑
+public BigDecimal calculateSubsidy(Order order) {
+  BigDecimal base = order.getAmount().multiply(new BigDecimal("0.8"));
+  BigDecimal discount = base.subtract(order.getDeducted());
+  return discount.max(BigDecimal.ZERO);
+}`,
+            });
+            const hasCommentWarning = findings.some(f => f.category === "missing_comment_complex");
+            // 上面有注释不会触发缺失检测；下面测试无注释的负例：
+            const findingsNoComment = mod.reviewCommentQuality({
+                "金额计算/BillingService.java": `public BigDecimal calculateSubsidy(Order order) {
+  BigDecimal base = order.getAmount().multiply(new BigDecimal("0.8"));
+  BigDecimal discount = base.subtract(order.getDeducted());
+  return discount.max(BigDecimal.ZERO);
+}`,
+            });
+            const detected = findingsNoComment.some(f => f.category === "missing_comment_complex");
+            return {
+                scenario_id: "release-scenario-code-observability-complex-rule-no-comment",
+                status: detected ? "pass" : "fail",
+                evidence: detected ? "warning: 无注释复杂逻辑被检测到" : "未检测到无注释复杂逻辑",
+                production_trace: { tool_entrypoint: "reviewCommentQuality", diagnostic_codes: [detected ? "warning" : "missed"], gates_consumed: ["sf_review", "engine_contract"] },
+            };
+        },
+    },
+    {
+        scenario_id: "release-scenario-code-observability-low-risk-skip",
+        covering_problem: "problem-68",
+        test_files: ["tests/engine/code_maintainability_observability_contract.test.ts"],
+        production_entrypoint: "sf_classify → sf_expand (低风险) → 不触发可观测性门禁",
+        expected_outcome: "简单文案修改不触发代码可维护性/可观测性契约",
+        runner: async () => {
+            const { createToolHarness } = await import("./release_tool_harness.js");
+            const harness = await createToolHarness();
+            try {
+                const intent = "修复 README 文案错别字";
+                const clsRaw = await harness.callTool("sf_classify", { intent });
+                const cls = harness.parseResult(clsRaw);
+                const taskId = cls.task_id;
+                if (!taskId)
+                    return { scenario_id: "release-scenario-code-observability-low-risk-skip", status: "fail", error: "sf_classify 未返回 task_id" };
+                const expRaw = await harness.callTool("sf_expand", { task_id: taskId });
+                const exp = harness.parseResult(expRaw);
+                // 低风险任务不应触发 SF-OBS-6801 诊断码
+                const notBlocked = exp.diagnostic_code !== "SF-OBS-6801";
+                return {
+                    scenario_id: "release-scenario-code-observability-low-risk-skip",
+                    status: notBlocked ? "pass" : "fail",
+                    evidence: notBlocked ? "低风险任务正确跳过可观测性门禁" : "低风险任务被错误触发可观测性门禁",
+                    production_trace: { tool_entrypoint: "sf_classify+sf_expand", diagnostic_codes: [exp.status ?? "ok", exp.diagnostic_code ?? "none"], gates_consumed: ["sf_classify", "sf_expand"] },
+                };
+            }
+            catch (e) {
+                return { scenario_id: "release-scenario-code-observability-low-risk-skip", status: "fail", error: e.message };
+            }
+            finally {
+                await harness.cleanup();
+            }
+        },
+    },
+    {
+        scenario_id: "release-scenario-code-observability-project-logger-detected",
+        covering_problem: "problem-68",
+        test_files: ["tests/engine/code_maintainability_observability_contract.test.ts"],
+        production_entrypoint: "sf_expand → CodeObservabilityGate → detectProjectLogger",
+        expected_outcome: "Java/Spring/Node/NestJS 项目能正确检测 logger 类型",
+        runner: async () => {
+            const mod = await import("./code_maintainability_observability_contract.js");
+            const javaLogger = mod.detectProjectLogger({
+                "Application.java": "import org.slf4j.LoggerFactory; private static final Logger log = LoggerFactory.getLogger(App.class);",
+            });
+            const pinoLogger = mod.detectProjectLogger({
+                "index.ts": "import pino from 'pino'; const logger = pino();",
+            });
+            const nestjsLogger = mod.detectProjectLogger({
+                "app.service.ts": "import { Logger } from '@nestjs/common';",
+            });
+            const ok = javaLogger.type === "slf4j" && pinoLogger.type === "pino" && nestjsLogger.type === "nestjs_logger";
+            return {
+                scenario_id: "release-scenario-code-observability-project-logger-detected",
+                status: ok ? "pass" : "fail",
+                evidence: ok ? `检测: ${javaLogger.type}, ${pinoLogger.type}, ${nestjsLogger.type}` : `检测失败: ${javaLogger.type}, ${pinoLogger.type}, ${nestjsLogger.type}`,
+                production_trace: { tool_entrypoint: "detectProjectLogger", diagnostic_codes: [javaLogger.type, pinoLogger.type, nestjsLogger.type], gates_consumed: ["sf_expand", "engine_contract"] },
+            };
+        },
+    },
+    {
+        scenario_id: "release-scenario-code-observability-migration-audit-log",
+        covering_problem: "problem-68",
+        test_files: ["tests/engine/code_maintainability_observability_contract.test.ts"],
+        production_entrypoint: "sf_expand → CodeObservabilityGate → sf_review → reviewMissingLogs → sf_deliver",
+        expected_outcome: "迁移脚本/数据修复无审计日志 → hard_fail",
+        runner: async () => {
+            const mod = await import("./code_maintainability_observability_contract.js");
+            const findings = mod.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]);
+  }
+}`,
+            });
+            const blocked = mod.hasBlockingObservabilityFindings(findings);
+            return {
+                scenario_id: "release-scenario-code-observability-migration-audit-log",
+                status: blocked ? "pass" : "fail",
+                evidence: blocked ? "hard_fail: 迁移脚本无审计日志被检测到" : "未检测到迁移脚本无审计日志",
+                production_trace: { tool_entrypoint: "reviewMissingLogs", diagnostic_codes: [blocked ? "hard_fail" : "missed"], gates_consumed: ["sf_review", "engine_contract"] },
+            };
+        },
+    },
 ];
 /** 获取全量场景定义 */
 export function getReleaseIssueScenarios() {