soloforge 1.5.0 → 2.0.0

package/dist/engine/release_issue_scenario_registry.js

@@ -1,1748 +0,0 @@
-/**
- * 发布问题场景注册表 — 结构化场景定义 + 真实生产入口执行证据。
- *
- * R11: 所有 MCP 工具链场景使用 ToolInvocationObservation 记录。
- * 确认通过 架构设计 的 decision_workshop / architecture_decision_workshop 输入，
- * 不再直接修改 TaskContext 确认研讨域。
- */
-import fs from "node:fs";
-import path from "node:path";
-import os from "node:os";
-// ── 共享 fixture 创建 ──
-function createDesignFixtureDir() {
-    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "soloforge-b62-"));
-    const archDir = path.join(tmpDir, "docs", "architecture");
-    fs.mkdirSync(archDir, { recursive: true });
-    return tmpDir;
-}
-function createDesignFixtureWithPartialDocs() {
-    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "soloforge-b62-partial-"));
-    const archDir = path.join(tmpDir, "docs", "architecture");
-    fs.mkdirSync(archDir, { recursive: true });
-    fs.writeFileSync(path.join(archDir, "api-spec.md"), "# API\n\n## /users\n\nGET /users\n", "utf-8");
-    return tmpDir;
-}
-/** 创建完整设计产物 fixture（所有标准文档齐全、内容合规） */
-function createCompleteDesignFixture(tmpDir) {
-    const archDir = path.join(tmpDir, "docs", "architecture");
-    const apiDir = path.join(tmpDir, "docs", "api");
-    const traceDir = path.join(tmpDir, "docs", "traceability");
-    const sqlDir = path.join(tmpDir, "db", "migrations");
-    fs.mkdirSync(archDir, { recursive: true });
-    fs.mkdirSync(apiDir, { recursive: true });
-    fs.mkdirSync(traceDir, { recursive: true });
-    fs.mkdirSync(sqlDir, { recursive: true });
-    fs.writeFileSync(path.join(archDir, "00-架构决策记录.md"), "# 决策记录\n\n## D1 微服务\n\n选择微服务\n", "utf-8");
-    fs.writeFileSync(path.join(archDir, "01-架构设计文档.md"), "# 架构设计\n\n## 来源追踪\n\nREQ-001、PROTO-001。\n\n## 系统概述\n\n微服务\n\n## 架构决策\n\nARCH-001 微服务\n\n## 技术选型\n\nTS\n\n## 模块设计\n\n模块\n", "utf-8");
-    fs.writeFileSync(path.join(archDir, "02-数据库设计文档.md"), "# 数据库设计\n\n追踪: DD-T001 | 上游: ARCH-001\n\n## 数据模型\n\n用户\n\n## 实体关系\n\n1:N\n\n## 表结构\n\n| 字段 | 类型 | 约束 | 说明 |\n|------|------|------|------|\n| id | uuid | PK | 主键 |\n", "utf-8");
-    // 合规 API 文档: 含完整字段表
-    fs.writeFileSync(path.join(archDir, "03-API接口规格文档.md"), "# 接口概览\n\n追踪: DD-A001 | 上游: ARCH-001\n\n用户管理 API。\n\n# 请求响应规范\n\n## GET /api/users\n\n### 请求字段表\n\n| 请求字段名 | 类型 | 必填 | 来源 | 说明 | 示例 | 校验规则 | 错误语义 |\n|--------|------|------|------|------|------|----------|----------|\n| page | int | 否 | query | 页码 | 1 | >=1 | 页码无效 |\n\n### 响应字段表\n\n| 响应字段名 | 类型 | 必填 | 来源 | 说明 | 示例 | 校验规则 | 错误语义 |\n|--------|------|------|------|------|------|----------|----------|\n| id | string | 是 | db | 用户ID | usr-1 | uuid | 用户不存在 |\n", "utf-8");
-    fs.writeFileSync(path.join(archDir, "04-开发切片计划.md"), "# 开发切片计划\n\nPHASE-001\nSLICE-001\n设计来源: DD-T001, DD-A001\n验收: AC-001\n", "utf-8");
-    fs.writeFileSync(path.join(archDir, "99-设计一致性验收报告.md"), "# 一致性报告\n\n通过\n", "utf-8");
-    fs.writeFileSync(path.join(apiDir, "openapi.yaml"), "openapi: 3.0.0\ninfo:\n  title: API\n  version: '1.0'\npaths:\n  /api/users:\n    get:\n      summary: List users\n      responses:\n        '200':\n          description: OK\n", "utf-8");
-    fs.writeFileSync(path.join(traceDir, "01-需求原型设计实现追踪矩阵.md"), [
-        "# 需求原型设计实现追踪矩阵",
-        "",
-        "| ID | 类型 | 来源 | 关联 |",
-        "|----|------|------|------|",
-        "| REQ-001 | 需求 | docs/requirements.md | PROTO-001 ARCH-001 |",
-        "| PROTO-001 | 原型 | docs/prototype.md | REQ-001 ARCH-001 |",
-        "| ARCH-001 | 架构 | docs/architecture/01-架构设计文档.md | REQ-001 PROTO-001 DD-T001 DD-A001 |",
-        "| DD-T001 | 数据库详细设计 | docs/architecture/02-数据库设计文档.md | ARCH-001 SLICE-001 |",
-        "| DD-A001 | API 详细设计 | docs/architecture/03-API接口规格文档.md | ARCH-001 SLICE-001 |",
-        "| PHASE-001 | 阶段 | docs/architecture/04-开发切片计划.md | SLICE-001 |",
-        "| SLICE-001 | 切片 | docs/architecture/04-开发切片计划.md | PHASE-001 DD-T001 DD-A001 AC-001 |",
-        "| AC-001 | 验收 | docs/acceptance/AC-001.md | SLICE-001 |",
-    ].join("\n"), "utf-8");
-    fs.writeFileSync(path.join(sqlDir, "001-init.sql"), "CREATE TABLE users (id UUID PRIMARY KEY);\n", "utf-8");
-}
-// ── 共享前置条件设置 ──
-/**
- * 从 架构设计 返回结果中提取并确认通用 decision_workshop。
- * 合同来源于第一次 架构设计 返回对象，经用户确认字段修改后回传。
- * 不得自行新建一份合同。
- */
-function confirmDecisionWorkshopFromResponse(expResult) {
-    const workshop = expResult?.decision_workshop;
-    if (!workshop)
-        return undefined;
-    // 确认所有扩展域
-    for (const key of Object.keys(workshop.extended_domains ?? {})) {
-        const domain = workshop.extended_domains[key];
-        if (domain) {
-            domain.status = "confirmed";
-            domain.user_confirmation_ref = "scenario-user-confirm-ref";
-        }
-    }
-    workshop.prerequisite_evidence_refs = ["scenario-evidence-ref"];
-    // 清除阻断发现（evaluateDecisionWorkshop 会继承 contract.blocking_findings）
-    workshop.blocking_findings = [];
-    workshop.status = "confirmed";
-    workshop.generation_allowed = true;
-    return workshop;
-}
-/**
- * 发布问题全量场景定义。
- */
-/** 架构研讨场景的完整技术决策契约，确保证据门禁和决策主权门禁都能通过 */
-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: greenfield 架构设计 → 完整闭环：阻断 → 全部确认 → 放行
-    {
-        scenario_id: "release-scenario-architecture-workshop-greenfield",
-        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 { 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: existing_system 架构设计被阻断；补充确认+证据后放行
-    {
-        scenario_id: "release-scenario-architecture-workshop-existing-system",
-        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 sf_expand 返回 workshop + awaiting_confirmation；补入确认和证据后放行",
-        runner: async () => {
-            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
-    {
-        scenario_id: "release-scenario-architecture-workshop-confirmation-block",
-        test_files: ["tests/adapters/architecture_design_workshop_mainpath.test.ts"],
-        production_entrypoint: "sf_classify → sf_expand → partial confirm → sf_expand",
-        expected_outcome: "部分域确认后仍 blocked，返回 next_domain；全部确认后放行",
-        runner: async () => {
-            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: 低风险不触发架构研讨
-    {
-        scenario_id: "release-scenario-architecture-workshop-low-risk-skip",
-        test_files: ["tests/engine/architecture_decision_workshop.test.ts"],
-        production_entrypoint: "sf_classify → sf_expand",
-        expected_outcome: "低风险修改 sf_expand 不创建 architecture_decision_workshop，不 awaiting_confirmation",
-        runner: async () => {
-            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 域阻断设计生成
-    {
-        scenario_id: "release-scenario-architecture-workshop-rework",
-        test_files: [],
-        production_entrypoint: "sf_classify → sf_expand → inject rework_required → sf_expand",
-        expected_outcome: "rework_required 域仍出现在 missing/阻断中，不进入正式设计生成；修正为 confirmed 后放行",
-        runner: async () => {
-            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 工具链 ──
-    // 场景 6: 数据迁移 — 自然语言意图（不含"架构设计"）
-    {
-        scenario_id: "release-scenario-decision-workshop-data-migration",
-        test_files: ["tests/engine/release_issue_scenario_matrix.test.ts"],
-        production_entrypoint: "sf_classify → sf_expand → decision_workshop(data_migration) → confirm from response → sf_expand",
-        expected_outcome: "数据迁移意图 sf_expand 返回 awaiting_confirmation + activated_packs 含 data_migration; 从响应提取确认后第二次 sf_expand 放行",
-        runner: async () => {
-            const { createToolHarness } = await import("./release_tool_harness.js");
-            const harness = await createToolHarness();
-            try {
-                const intent = "实现数据库迁移功能，把 MySQL 迁移到 PostgreSQL";
-                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-decision-workshop-data-migration", status: "fail", error: "sf_classify 未返回 task_id" };
-                const exp1Raw = await harness.callTool("sf_expand", { task_id: taskId });
-                const exp1 = harness.parseResult(exp1Raw);
-                // 断言第一次 sf_expand 返回 decision_workshop.activated_packs 含 data_migration
-                const activatedPacks = exp1.activated_packs ?? exp1.decision_workshop?.activated_packs ?? [];
-                if (!activatedPacks.includes("data_migration"))
-                    return { scenario_id: "release-scenario-decision-workshop-data-migration", status: "fail", error: `expected data_migration in activated_packs, got ${JSON.stringify(activatedPacks)} status=${exp1.status}` };
-                if (exp1.status !== "awaiting_confirmation")
-                    return { scenario_id: "release-scenario-decision-workshop-data-migration", status: "fail", error: `expected awaiting_confirmation, got status=${exp1.status}` };
-                // 从第一次 sf_expand 响应提取 decision_workshop（不新建），确认域后回传
-                const genericWorkshop = confirmDecisionWorkshopFromResponse(exp1);
-                if (!genericWorkshop)
-                    return { scenario_id: "release-scenario-decision-workshop-data-migration", status: "fail", error: "no decision_workshop in first sf_expand response" };
-                const exp2Raw = await harness.callTool("sf_expand", {
-                    task_id: taskId,
-                    decision_workshop: genericWorkshop,
-                });
-                const exp2 = harness.parseResult(exp2Raw);
-                if (exp2.status === "awaiting_confirmation" && exp2.decision_workshop)
-                    return { scenario_id: "release-scenario-decision-workshop-data-migration", status: "fail", error: "second expand still blocked by workshop" };
-                const trace = await harness.collectTrace();
-                return {
-                    scenario_id: "release-scenario-decision-workshop-data-migration",
-                    status: "pass",
-                    evidence: `sf_classify→sf_expand(awaiting,packs=${activatedPacks.join(",")})→confirm from response→sf_expand(pass) route=${cls.route_decision?.route}`,
-                    production_trace: trace,
-                };
-            }
-            finally {
-                harness.cleanup();
-            }
-        },
-    },
-    // 场景 7: 安全策略 — 自然语言意图（不含"架构设计"）
-    {
-        scenario_id: "release-scenario-decision-workshop-security-policy",
-        test_files: ["tests/engine/release_issue_scenario_matrix.test.ts"],
-        production_entrypoint: "sf_classify → sf_expand → decision_workshop(security_policy) → confirm from response → sf_expand",
-        expected_outcome: "安全策略意图 sf_expand 返回 awaiting_confirmation + activated_packs 含 security_policy; 从响应提取确认后第二次 sf_expand 放行",
-        runner: async () => {
-            const { createToolHarness } = await import("./release_tool_harness.js");
-            const harness = await createToolHarness();
-            try {
-                const intent = "开发安全策略调整功能，修改认证授权和权限模型";
-                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-decision-workshop-security-policy", status: "fail", error: "sf_classify 未返回 task_id" };
-                const exp1Raw = await harness.callTool("sf_expand", { task_id: taskId });
-                const exp1 = harness.parseResult(exp1Raw);
-                const activatedPacks = exp1.activated_packs ?? exp1.decision_workshop?.activated_packs ?? [];
-                if (!activatedPacks.includes("security_policy"))
-                    return { scenario_id: "release-scenario-decision-workshop-security-policy", status: "fail", error: `expected security_policy in activated_packs, got ${JSON.stringify(activatedPacks)}` };
-                if (exp1.status !== "awaiting_confirmation")
-                    return { scenario_id: "release-scenario-decision-workshop-security-policy", status: "fail", error: `expected awaiting_confirmation, got status=${exp1.status}` };
-                const genericWorkshop = confirmDecisionWorkshopFromResponse(exp1);
-                if (!genericWorkshop)
-                    return { scenario_id: "release-scenario-decision-workshop-security-policy", status: "fail", error: "no decision_workshop in first sf_expand response" };
-                const exp2Raw = await harness.callTool("sf_expand", {
-                    task_id: taskId,
-                    decision_workshop: genericWorkshop,
-                });
-                const exp2 = harness.parseResult(exp2Raw);
-                if (exp2.status === "awaiting_confirmation" && exp2.decision_workshop)
-                    return { scenario_id: "release-scenario-decision-workshop-security-policy", status: "fail", error: "second expand still blocked by workshop" };
-                const trace = await harness.collectTrace();
-                return {
-                    scenario_id: "release-scenario-decision-workshop-security-policy",
-                    status: "pass",
-                    evidence: `sf_classify→sf_expand(awaiting,packs=${activatedPacks.join(",")})→confirm from response→sf_expand(pass) route=${cls.route_decision?.route}`,
-                    production_trace: trace,
-                };
-            }
-            finally {
-                harness.cleanup();
-            }
-        },
-    },
-    // 场景 8: 交付验证/发布策略 — 自然语言意图（不含"架构设计"）
-    {
-        scenario_id: "release-scenario-decision-workshop-release-validation",
-        test_files: ["tests/engine/release_issue_scenario_matrix.test.ts"],
-        production_entrypoint: "sf_classify → sf_expand → decision_workshop(delivery_validation) → confirm from response → sf_expand",
-        expected_outcome: "发布验证意图 sf_expand 返回 awaiting_confirmation + activated_packs 含 delivery_validation; 从响应提取确认后第二次 sf_expand 放行",
-        runner: async () => {
-            const { createToolHarness } = await import("./release_tool_harness.js");
-            const harness = await createToolHarness();
-            try {
-                const intent = "实现发布策略和回滚方案的功能";
-                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-decision-workshop-release-validation", status: "fail", error: "sf_classify 未返回 task_id" };
-                const exp1Raw = await harness.callTool("sf_expand", { task_id: taskId });
-                const exp1 = harness.parseResult(exp1Raw);
-                const activatedPacks = exp1.activated_packs ?? exp1.decision_workshop?.activated_packs ?? [];
-                if (!activatedPacks.includes("delivery_validation"))
-                    return { scenario_id: "release-scenario-decision-workshop-release-validation", status: "fail", error: `expected delivery_validation in activated_packs, got ${JSON.stringify(activatedPacks)}` };
-                if (exp1.status !== "awaiting_confirmation")
-                    return { scenario_id: "release-scenario-decision-workshop-release-validation", status: "fail", error: `expected awaiting_confirmation, got status=${exp1.status}` };
-                const genericWorkshop = confirmDecisionWorkshopFromResponse(exp1);
-                if (!genericWorkshop)
-                    return { scenario_id: "release-scenario-decision-workshop-release-validation", status: "fail", error: "no decision_workshop in first sf_expand response" };
-                const exp2Raw = await harness.callTool("sf_expand", {
-                    task_id: taskId,
-                    decision_workshop: genericWorkshop,
-                });
-                const exp2 = harness.parseResult(exp2Raw);
-                if (exp2.status === "awaiting_confirmation" && exp2.decision_workshop)
-                    return { scenario_id: "release-scenario-decision-workshop-release-validation", status: "fail", error: "second expand still blocked by workshop" };
-                const trace = await harness.collectTrace();
-                return {
-                    scenario_id: "release-scenario-decision-workshop-release-validation",
-                    status: "pass",
-                    evidence: `sf_classify→sf_expand(awaiting,packs=${activatedPacks.join(",")})→confirm from response→sf_expand(pass) route=${cls.route_decision?.route}`,
-                    production_trace: trace,
-                };
-            }
-            finally {
-                harness.cleanup();
-            }
-        },
-    },
-    // 场景 9: 低风险 README → 真实 sf_classify→sf_expand 不触发研讨
-    {
-        scenario_id: "release-scenario-decision-workshop-low-risk-skip",
-        test_files: ["tests/engine/release_issue_scenario_matrix.test.ts"],
-        production_entrypoint: "sf_classify → sf_expand",
-        expected_outcome: "低风险意图 sf_expand 不创建 decision_workshop、不阻断; status !== awaiting_confirmation",
-        runner: async () => {
-            const { createToolHarness } = await import("./release_tool_harness.js");
-            const harness = await createToolHarness();
-            try {
-                const clsRaw = await harness.callTool("sf_classify", { intent: "修复 README 中的拼写错误" });
-                const cls = harness.parseResult(clsRaw);
-                const taskId = cls.task_id;
-                if (!taskId)
-                    return { scenario_id: "release-scenario-decision-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);
-                // 断言不创建 decision_workshop、不阻断
-                if (exp.decision_workshop)
-                    return { scenario_id: "release-scenario-decision-workshop-low-risk-skip", status: "fail", error: "low-risk intent should not create decision_workshop" };
-                if (exp.architecture_decision_workshop)
-                    return { scenario_id: "release-scenario-decision-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-decision-workshop-low-risk-skip", status: "fail", error: "low-risk intent should not be awaiting_confirmation" };
-                const trace = await harness.collectTrace();
-                // 补充 diagnostic_codes（release gate 要求非空，低风险路径工具不返回诊断码）
-                const diagCodes = trace.diagnostic_codes.length > 0
-                    ? trace.diagnostic_codes
-                    : [`route:${cls.route_decision?.route ?? "unknown"}`, `status:${exp.status ?? "done"}`];
-                return {
-                    scenario_id: "release-scenario-decision-workshop-low-risk-skip",
-                    status: "pass",
-                    evidence: `sf_classify→sf_expand(no workshop) route=${cls.route_decision?.route} status=${exp.status}`,
-                    production_trace: { tool_entrypoint: trace.tool_entrypoint, diagnostic_codes: diagCodes, gates_consumed: trace.gates_consumed },
-                };
-            }
-            finally {
-                harness.cleanup();
-            }
-        },
-    },
-    // 场景 10: 交付验证 → 真实 sf_deliver 路径
-    {
-        scenario_id: "release-scenario-decision-workshop-delivery-validation",
-        test_files: ["tests/engine/release_issue_scenario_matrix.test.ts"],
-        production_entrypoint: "sf_classify→sf_expand→sf_verify→sf_record_verification_execution→sf_accept→sf_deliver",
-        expected_outcome: "确认研讨后 sf_deliver 对满足前置条件的任务得到成功结果; 缺确认时由 decision_workshop 阻断",
-        runner: async () => {
-            const { createToolHarness } = await import("./release_tool_harness.js");
-            const harness = await createToolHarness({ techStack: { backend: { lang: "none", framework: "none", version: "0" }, frontend: { lang: "none", framework: "none", version: "0" } } });
-            try {
-                const intent = "开发发布验证与回滚功能，按发布策略执行";
-                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-decision-workshop-delivery-validation", status: "fail", error: "sf_classify 未返回 task_id" };
-                // 第一次 sf_expand → workshop 阻断（缺确认）
-                const exp1Raw = await harness.callTool("sf_expand", { task_id: taskId });
-                const exp1 = harness.parseResult(exp1Raw);
-                const genericWorkshop = confirmDecisionWorkshopFromResponse(exp1);
-                if (genericWorkshop) {
-                    const exp2Raw = await harness.callTool("sf_expand", {
-                        task_id: taskId,
-                        decision_workshop: genericWorkshop,
-                    });
-                    const exp2 = harness.parseResult(exp2Raw);
-                    if (exp2.diagnostic_code === "SF-OOD-6601") {
-                        const summary = exp2.ood_solid_summary;
-                        summary.objects = [{ name: "ReleaseValidationService", responsibility: "编排发布验证和回滚策略" }];
-                        summary.interfaces = ["ReleaseVerifier", "RollbackExecutor"];
-                        summary.dependency_direction = ["ReleaseValidationService -> ReleaseVerifier"];
-                        summary.change_points = ["验证策略", "回滚策略"];
-                        summary.solid_risks = ["DIP: 执行器通过接口注入", "SRP: 发布编排不承担部署细节"];
-                        await harness.callTool("sf_expand", {
-                            task_id: taskId,
-                            decision_workshop: genericWorkshop,
-                            ood_solid_summary: summary,
-                        });
-                    }
-                }
-                await harness.setupPlanGate(taskId);
-                // 验证前置: sf_verify → sf_record_verification_execution
-                await harness.callTool("sf_verify", { task_id: taskId, changed_files: ["README.md"], confirm: true });
-                const tc = harness.taskContext;
-                const ctxForV = await tc.load(taskId);
-                if (!ctxForV?.verification_plan)
-                    return { scenario_id: "release-scenario-decision-workshop-delivery-validation", status: "fail", error: "no verification_plan after sf_verify" };
-                await harness.callTool("sf_record_verification_execution", {
-                    task_id: taskId,
-                    plan_id: ctxForV.verification_plan.plan_id,
-                    execution_records: ctxForV.verification_plan.commands.map((cmd, i) => ({
-                        command: cmd,
-                        exit_code: 0,
-                        stdout_hash: "a".repeat(64),
-                        stderr_hash: "e".repeat(64),
-                        started_at: new Date().toISOString(),
-                        finished_at: new Date().toISOString(),
-                        evidence_id: `evidence-${taskId}-${i}`,
-                    })),
-                });
-                // 验收必须携带显式用户确认引用；此场景无用户可访问界面，因此明确标记不适用。
-                const acceptance = harness.parseResult(await harness.callTool("sf_accept", {
-                    task_id: taskId,
-                    confirm: true,
-                    confirmed_by: "release-reviewer",
-                    confirmation_ref: `decision-delivery:${taskId}`,
-                    acceptance_notes: "该场景验证后端发布决策链，无本地界面验收目标",
-                    run_mode: "not_applicable",
-                }));
-                if (acceptance.acceptance_status !== "passed")
-                    return { scenario_id: "release-scenario-decision-workshop-delivery-validation", status: "fail", error: `sf_accept failed: ${acceptance.error ?? "unknown"}` };
-                // sf_deliver → 必须成功
-                const delRaw = await harness.callTool("sf_deliver", { task_id: taskId, confirm: true });
-                const del = harness.parseResult(delRaw);
-                if (del.diagnostic_code)
-                    return { scenario_id: "release-scenario-decision-workshop-delivery-validation", status: "fail", error: `sf_deliver blocked: ${del.diagnostic_code}, error=${del.error ?? "none"}` };
-                const obs = harness.getObservations().slice().reverse().find(o => o.tool_name === "sf_deliver");
-                if (!obs || obs.is_error)
-                    return { scenario_id: "release-scenario-decision-workshop-delivery-validation", status: "fail", error: `sf_deliver observation error: ${obs?.parsed_response?.error ?? "no obs"}` };
-                const trace = await harness.collectTrace();
-                return {
-                    scenario_id: "release-scenario-decision-workshop-delivery-validation",
-                    status: "pass",
-                    evidence: `sf_classify→sf_expand→sf_verify→sf_record_verification_execution→sf_accept→sf_deliver(success) route=${cls.route_decision?.route}`,
-                    production_trace: trace,
-                };
-            }
-            finally {
-                harness.cleanup();
-            }
-        },
-    },
-    // 场景 10b: 组合意图 → 数据迁移+安全策略同时触发（不含"架构设计"）
-    {
-        scenario_id: "release-scenario-decision-workshop-combined-intent",
-        test_files: ["tests/engine/release_issue_scenario_matrix.test.ts"],
-        production_entrypoint: "sf_classify → sf_expand → decision_workshop(data_migration + security_policy) → confirm from response → sf_expand",
-        expected_outcome: "组合意图同时触发 data_migration + security_policy 包; 从响应提取确认后放行",
-        runner: async () => {
-            const { createToolHarness } = await import("./release_tool_harness.js");
-            const harness = await createToolHarness();
-            try {
-                const intent = "实现数据库迁移功能并调整安全策略和认证授权";
-                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-decision-workshop-combined-intent", status: "fail", error: "sf_classify 未返回 task_id" };
-                const exp1Raw = await harness.callTool("sf_expand", { task_id: taskId });
-                const exp1 = harness.parseResult(exp1Raw);
-                // 验证 activated_packs 同时包含两个包
-                const activatedPacks = exp1.activated_packs ?? exp1.decision_workshop?.activated_packs ?? [];
-                if (!activatedPacks.includes("data_migration"))
-                    return { scenario_id: "release-scenario-decision-workshop-combined-intent", status: "fail", error: `expected data_migration in activated_packs, got ${JSON.stringify(activatedPacks)}` };
-                if (!activatedPacks.includes("security_policy"))
-                    return { scenario_id: "release-scenario-decision-workshop-combined-intent", status: "fail", error: `expected security_policy in activated_packs, got ${JSON.stringify(activatedPacks)}` };
-                // 验证 decision_workshop 同时包含两个包的域
-                const genericWorkshop = confirmDecisionWorkshopFromResponse(exp1);
-                if (!genericWorkshop)
-                    return { scenario_id: "release-scenario-decision-workshop-combined-intent", status: "fail", error: "no decision_workshop in response" };
-                const hasDataMigration = "data_migration" in (genericWorkshop.extended_domains ?? {});
-                const hasSecurityPolicy = "security_policy" in (genericWorkshop.extended_domains ?? {});
-                if (!hasDataMigration || !hasSecurityPolicy)
-                    return { scenario_id: "release-scenario-decision-workshop-combined-intent", status: "fail", error: `expected both domains in workshop, got data=${hasDataMigration} sec=${hasSecurityPolicy}` };
-                const exp2Raw = await harness.callTool("sf_expand", {
-                    task_id: taskId,
-                    decision_workshop: genericWorkshop,
-                });
-                const exp2 = harness.parseResult(exp2Raw);
-                if (exp2.status === "awaiting_confirmation" && exp2.decision_workshop)
-                    return { scenario_id: "release-scenario-decision-workshop-combined-intent", status: "fail", error: "second expand still blocked by workshop" };
-                const trace = await harness.collectTrace();
-                return {
-                    scenario_id: "release-scenario-decision-workshop-combined-intent",
-                    status: "pass",
-                    evidence: `combined packs=${activatedPacks.join(",")} confirmed from response, route=${cls.route_decision?.route}`,
-                    production_trace: trace,
-                };
-            }
-            finally {
-                harness.cleanup();
-            }
-        },
-    },
-    // ── 问题六十二: 设计产物包 ──
-    // 场景 11: 新项目缺设计文档 → sf_classify→sf_expand→sf_verify→DESIGN_ARTIFACT_MISSING
-    {
-        scenario_id: "release-scenario-design-pack-new-project",
-        test_files: ["tests/engine/design_artifact_pack.test.ts"],
-        production_entrypoint: "sf_classify → sf_expand → sf_verify → design_artifact_pack",
-        expected_outcome: "新项目缺设计文档 → sf_verify 返回 SF-DESIGN-PACK-VERIFY-FAILED 且 findings 包含 DESIGN_ARTIFACT_MISSING",
-        runner: async () => {
-            const { createToolHarness } = await import("./release_tool_harness.js");
-            const harness = await createToolHarness();
-            try {
-                fs.mkdirSync(path.join(harness.tmpDir, "docs", "architecture"), { recursive: true });
-                const clsRaw = await harness.callTool("sf_classify", { intent: "修复登录按钮 CSS，绑定 PHASE-001 SLICE-001 DD-T001 DD-A001 AC-001" });
-                const cls = harness.parseResult(clsRaw);
-                const taskId = cls.task_id;
-                await harness.callTool("sf_expand", { task_id: taskId });
-                await harness.setupPlanGate(taskId);
-                const verRaw = await harness.callTool("sf_verify", {
-                    task_id: taskId,
-                    changed_files: ["docs/architecture/architecture.md"],
-                });
-                const ver = harness.parseResult(verRaw);
-                if (ver.diagnostic_code !== "SF-DESIGN-PACK-VERIFY-FAILED")
-                    return { scenario_id: "release-scenario-design-pack-new-project", status: "fail", error: `expected SF-DESIGN-PACK-VERIFY-FAILED, got code=${ver.diagnostic_code} status=${ver.status}` };
-                const missingCodes = (ver.design_artifact_findings ?? []).filter((f) => f.code === "DESIGN_ARTIFACT_MISSING");
-                if (missingCodes.length === 0)
-                    return { scenario_id: "release-scenario-design-pack-new-project", status: "fail", error: "expected DESIGN_ARTIFACT_MISSING in findings" };
-                const trace = await harness.collectTrace();
-                return {
-                    scenario_id: "release-scenario-design-pack-new-project",
-                    status: "pass",
-                    evidence: `sf_classify→sf_expand→sf_verify SF-DESIGN-PACK-VERIFY-FAILED findings=${missingCodes.length}`,
-                    production_trace: trace,
-                };
-            }
-            finally {
-                harness.cleanup();
-            }
-        },
-    },
-    // 场景 12: API 字段表缺失 → sf_classify→sf_expand→sf_verify→API_FIELD_TABLE_INCOMPLETE
-    {
-        scenario_id: "release-scenario-design-pack-api-field-incomplete",
-        test_files: ["tests/engine/release_issue_scenario_matrix.test.ts"],
-        production_entrypoint: "sf_classify → sf_expand → sf_verify → design_artifact_pack",
-        expected_outcome: "API 文档含 endpoint 但缺字段表 → sf_verify findings 包含 API_FIELD_TABLE_INCOMPLETE",
-        runner: async () => {
-            const { createToolHarness } = await import("./release_tool_harness.js");
-            const harness = await createToolHarness();
-            try {
-                createCompleteDesignFixture(harness.tmpDir);
-                // 替换 API 文档为含 endpoint 但缺字段表的版本
-                fs.writeFileSync(path.join(harness.tmpDir, "docs", "architecture", "03-API接口规格文档.md"), "# 接口概览\n\n追踪: DD-A001 | 上游: ARCH-001\n\n用户管理 API。\n\n## GET /api/users\n\n获取用户列表。\n\n## POST /api/users\n\n创建用户。\n", "utf-8");
-                const clsRaw = await harness.callTool("sf_classify", { intent: "修复登录按钮 CSS，绑定 PHASE-001 SLICE-001 DD-T001 DD-A001 AC-001" });
-                const cls = harness.parseResult(clsRaw);
-                const taskId = cls.task_id;
-                await harness.callTool("sf_expand", { task_id: taskId });
-                await harness.setupPlanGate(taskId);
-                const verRaw = await harness.callTool("sf_verify", {
-                    task_id: taskId,
-                    changed_files: ["docs/architecture/03-API接口规格文档.md"],
-                });
-                const ver = harness.parseResult(verRaw);
-                const allFindings = (ver.design_artifact_findings ?? []);
-                const apiFinding = allFindings.find((f) => f.code === "API_FIELD_TABLE_INCOMPLETE");
-                if (!apiFinding)
-                    return { scenario_id: "release-scenario-design-pack-api-field-incomplete", status: "fail", error: `expected API_FIELD_TABLE_INCOMPLETE, got codes: ${allFindings.map((f) => f.code).join(",")}` };
-                const trace = await harness.collectTrace();
-                return {
-                    scenario_id: "release-scenario-design-pack-api-field-incomplete",
-                    status: "pass",
-                    evidence: `sf_classify→sf_expand→sf_verify API_FIELD_TABLE_INCOMPLETE found`,
-                    production_trace: trace,
-                };
-            }
-            finally {
-                harness.cleanup();
-            }
-        },
-    },
-    // 场景 13: SQL 权威缺失 → sf_classify→sf_expand→sf_verify→SQL_AUTHORITY_MISSING
-    {
-        scenario_id: "release-scenario-design-pack-sql-authority-missing",
-        test_files: ["tests/engine/design_artifact_pack.test.ts"],
-        production_entrypoint: "sf_classify → sf_expand → sf_verify → design_artifact_pack",
-        expected_outcome: "完整 fixture 但无 SQL 文件 → sf_verify findings 包含 SQL_AUTHORITY_MISSING",
-        runner: async () => {
-            const { createToolHarness } = await import("./release_tool_harness.js");
-            const harness = await createToolHarness();
-            try {
-                createCompleteDesignFixture(harness.tmpDir);
-                // 删除 SQL 文件触发 SQL_AUTHORITY_MISSING
-                fs.rmSync(path.join(harness.tmpDir, "db", "migrations", "001-init.sql"));
-                const clsRaw = await harness.callTool("sf_classify", { intent: "修复登录按钮 CSS，绑定 PHASE-001 SLICE-001 DD-T001 DD-A001 AC-001" });
-                const cls = harness.parseResult(clsRaw);
-                const taskId = cls.task_id;
-                await harness.callTool("sf_expand", { task_id: taskId });
-                await harness.setupPlanGate(taskId);
-                const verRaw = await harness.callTool("sf_verify", {
-                    task_id: taskId,
-                    changed_files: ["docs/architecture/02-数据库设计文档.md"],
-                });
-                const ver = harness.parseResult(verRaw);
-                const allFindings = (ver.design_artifact_findings ?? []);
-                const sqlFinding = allFindings.find((f) => f.code === "SQL_AUTHORITY_MISSING");
-                if (!sqlFinding)
-                    return { scenario_id: "release-scenario-design-pack-sql-authority-missing", status: "fail", error: `expected SQL_AUTHORITY_MISSING, got codes: ${allFindings.map((f) => f.code).join(",")}` };
-                const trace = await harness.collectTrace();
-                return {
-                    scenario_id: "release-scenario-design-pack-sql-authority-missing",
-                    status: "pass",
-                    evidence: `sf_classify→sf_expand→sf_verify SQL_AUTHORITY_MISSING found`,
-                    production_trace: trace,
-                };
-            }
-            finally {
-                harness.cleanup();
-            }
-        },
-    },
-    // 场景 14: PostgreSQL 部分唯一约束非法 → sf_classify→sf_expand→sf_verify→POSTGRES_PARTIAL_UNIQUE_INVALID
-    {
-        scenario_id: "release-scenario-design-pack-postgres-partial-unique",
-        test_files: ["tests/engine/design_artifact_pack.test.ts"],
-        production_entrypoint: "sf_classify → sf_expand → sf_verify → design_artifact_pack",
-        expected_outcome: "SQL 含 CONSTRAINT ... UNIQUE (...) WHERE → sf_verify findings 包含 POSTGRES_PARTIAL_UNIQUE_INVALID",
-        runner: async () => {
-            const { createToolHarness } = await import("./release_tool_harness.js");
-            const harness = await createToolHarness();
-            try {
-                createCompleteDesignFixture(harness.tmpDir);
-                // 替换 SQL 为含非法约束的版本
-                fs.writeFileSync(path.join(harness.tmpDir, "db", "migrations", "001-init.sql"), "CREATE TABLE users (id UUID PRIMARY KEY, email TEXT NOT NULL, CONSTRAINT uq_users_email UNIQUE (email) WHERE active = true);\n", "utf-8");
-                const clsRaw = await harness.callTool("sf_classify", { intent: "修复登录按钮 CSS，绑定 PHASE-001 SLICE-001 DD-T001 DD-A001 AC-001" });
-                const cls = harness.parseResult(clsRaw);
-                const taskId = cls.task_id;
-                await harness.callTool("sf_expand", { task_id: taskId });
-                await harness.setupPlanGate(taskId);
-                const verRaw = await harness.callTool("sf_verify", {
-                    task_id: taskId,
-                    changed_files: ["db/migrations/001-init.sql"],
-                });
-                const ver = harness.parseResult(verRaw);
-                const allFindings = (ver.design_artifact_findings ?? []);
-                const pgFinding = allFindings.find((f) => f.code === "POSTGRES_PARTIAL_UNIQUE_INVALID");
-                if (!pgFinding)
-                    return { scenario_id: "release-scenario-design-pack-postgres-partial-unique", status: "fail", error: `expected POSTGRES_PARTIAL_UNIQUE_INVALID, got codes: ${allFindings.map((f) => f.code).join(",")}` };
-                const trace = await harness.collectTrace();
-                return {
-                    scenario_id: "release-scenario-design-pack-postgres-partial-unique",
-                    status: "pass",
-                    evidence: `sf_classify→sf_expand→sf_verify POSTGRES_PARTIAL_UNIQUE_INVALID found`,
-                    production_trace: trace,
-                };
-            }
-            finally {
-                harness.cleanup();
-            }
-        },
-    },
-    // 场景 15: 跨文档响应码冲突 → sf_classify→sf_expand→sf_verify→CROSS_DOC_RESPONSE_CODE_CONFLICT
-    {
-        scenario_id: "release-scenario-design-pack-cross-doc-conflict",
-        test_files: ["tests/engine/design_artifact_pack.test.ts"],
-        production_entrypoint: "sf_classify → sf_expand → sf_verify → design_artifact_pack",
-        expected_outcome: "架构文档含 code:200 但 API 文档含 code:0 → sf_verify findings 包含 CROSS_DOC_RESPONSE_CODE_CONFLICT",
-        runner: async () => {
-            const { createToolHarness } = await import("./release_tool_harness.js");
-            const harness = await createToolHarness();
-            try {
-                createCompleteDesignFixture(harness.tmpDir);
-                // 替换架构文档: 含 "code": 200
-                fs.writeFileSync(path.join(harness.tmpDir, "docs", "architecture", "01-架构设计文档.md"), "# 架构设计\n\n## 来源追踪\n\nREQ-001、PROTO-001。\n\n## 系统概述\n\n微服务。统一响应格式: {\"code\": 200, \"data\": {}}。\n\n## 架构决策\n\nARCH-001 微服务\n\n## 技术选型\n\nTS\n\n## 模块设计\n\n模块\n", "utf-8");
-                // 替换 API 文档: 含 "code": 0
-                fs.writeFileSync(path.join(harness.tmpDir, "docs", "architecture", "03-API接口规格文档.md"), "# 接口概览\n\n追踪: DD-A001 | 上游: ARCH-001\n\n响应格式: {\"code\": 0, \"msg\": \"\", \"data\": {}}。\n\n## GET /api/users\n\n### 请求字段表\n\n| 请求字段名 | 类型 | 必填 | 来源 | 说明 | 示例 | 校验规则 | 错误语义 |\n|--------|------|------|------|------|------|----------|----------|\n| page | int | 否 | query | 页码 | 1 | >=1 | 页码无效 |\n\n### 响应字段表\n\n| 响应字段名 | 类型 | 必填 | 来源 | 说明 | 示例 | 校验规则 | 错误语义 |\n|--------|------|------|------|------|------|----------|----------|\n| id | string | 是 | db | 用户ID | usr-1 | uuid | 用户不存在 |\n", "utf-8");
-                const clsRaw = await harness.callTool("sf_classify", { intent: "修复登录按钮 CSS，绑定 PHASE-001 SLICE-001 DD-T001 DD-A001 AC-001" });
-                const cls = harness.parseResult(clsRaw);
-                const taskId = cls.task_id;
-                await harness.callTool("sf_expand", { task_id: taskId });
-                await harness.setupPlanGate(taskId);
-                const verRaw = await harness.callTool("sf_verify", {
-                    task_id: taskId,
-                    changed_files: ["docs/architecture/01-架构设计文档.md", "docs/architecture/03-API接口规格文档.md"],
-                });
-                const ver = harness.parseResult(verRaw);
-                const allFindings = (ver.design_artifact_findings ?? []);
-                const crossDocFinding = allFindings.find((f) => f.code === "CROSS_DOC_RESPONSE_CODE_CONFLICT");
-                if (!crossDocFinding)
-                    return { scenario_id: "release-scenario-design-pack-cross-doc-conflict", status: "fail", error: `expected CROSS_DOC_RESPONSE_CODE_CONFLICT, got codes: ${allFindings.map((f) => f.code).join(",")}` };
-                const trace = await harness.collectTrace();
-                return {
-                    scenario_id: "release-scenario-design-pack-cross-doc-conflict",
-                    status: "pass",
-                    evidence: `sf_classify→sf_expand→sf_verify CROSS_DOC_RESPONSE_CODE_CONFLICT found`,
-                    production_trace: trace,
-                };
-            }
-            finally {
-                harness.cleanup();
-            }
-        },
-    },
-    // 场景 16: 低风险不触发设计产物包
-    {
-        scenario_id: "release-scenario-design-pack-low-risk-skip",
-        test_files: ["tests/adapters/architecture_design_workshop_mainpath.test.ts"],
-        production_entrypoint: "sf_classify",
-        expected_outcome: "低风险 CSS 修复 route 非 artifact_generation，不触发设计产物包",
-        runner: async () => {
-            const { classify } = await import("./classifier.js");
-            const result = classify({ intent: "修复 CSS 样式问题" });
-            const route = result.route_decision?.route ?? "";
-            if (route === "artifact_generation")
-                return { scenario_id: "release-scenario-design-pack-low-risk-skip", status: "fail", error: `CSS fix should not be artifact_generation, got ${route}` };
-            return {
-                scenario_id: "release-scenario-design-pack-low-risk-skip",
-                status: "pass",
-                evidence: `route=${route} risk=${result.risk}`,
-                production_trace: { tool_entrypoint: "sf_classify", diagnostic_codes: [`route:${route}`, `risk:${result.risk}`], gates_consumed: ["router"] },
-            };
-        },
-    },
-    // ── 问题六十三: 标准资产契约 ──
-    // 场景 17: 13 必填字段
-    {
-        scenario_id: "release-scenario-template-contract-api-field-table",
-        test_files: ["tests/engine/release_issue_scenario_matrix.test.ts"],
-        production_entrypoint: "template_asset_contract_registry.buildTemplateAssetContracts",
-        expected_outcome: "所有合同 13 个必填字段全部存在且非 undefined",
-        runner: async () => {
-            const { buildTemplateAssetContracts } = await import("./template_asset_contract_registry.js");
-            const contracts = buildTemplateAssetContracts(process.cwd());
-            const requiredFields = ["path", "asset_kind", "contract_version", "owner_mechanism_id", "asset_visibility", "sync_to_user_project", "sync_target", "runtime_visibility", "evidence_role", "user_visible", "lifecycle_status", "consume_category", "validation_entrypoint"];
-            const missing = contracts.flatMap((c) => requiredFields.filter((f) => !(f in c) || c[f] === undefined).map((f) => `${c.path}: ${f}`));
-            if (missing.length > 0)
-                return { scenario_id: "release-scenario-template-contract-api-field-table", status: "fail", error: missing.join("; ") };
-            return {
-                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", "engine_contract"] },
-            };
-        },
-    },
-    // 场景 18: 权威绑定全量覆盖
-    {
-        scenario_id: "release-scenario-template-contract-authority-binding",
-        test_files: ["tests/engine/release_issue_scenario_matrix.test.ts"],
-        production_entrypoint: "template_asset_contract_registry.auditContractCoverage",
-        expected_outcome: "unregistered_files.length === 0（全量覆盖）",
-        runner: async () => {
-            const { auditContractCoverage } = await import("./template_asset_contract_registry.js");
-            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, 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"] },
-            };
-        },
-    },
-    // 场景 19: lifecycle_status 合法
-    {
-        scenario_id: "release-scenario-template-contract-existing-doc-upgrade",
-        test_files: ["tests/engine/release_issue_scenario_matrix.test.ts"],
-        production_entrypoint: "template_asset_contract_registry.buildTemplateAssetContracts",
-        expected_outcome: "所有合同 lifecycle_status=active 或 deprecated/internal_only，版本升级路径不遗漏",
-        runner: async () => {
-            const { buildTemplateAssetContracts } = await import("./template_asset_contract_registry.js");
-            const contracts = buildTemplateAssetContracts(process.cwd());
-            const validStatuses = ["active", "deprecated", "internal_only"];
-            const invalid = contracts.filter((c) => !validStatuses.includes(c.lifecycle_status));
-            if (invalid.length > 0)
-                return { scenario_id: "release-scenario-template-contract-existing-doc-upgrade", status: "fail", error: `invalid lifecycle: ${invalid.map((c) => `${c.path}: ${c.lifecycle_status}`).join(", ")}` };
-            const activeCount = contracts.filter((c) => c.lifecycle_status === "active").length;
-            if (activeCount === 0)
-                return { scenario_id: "release-scenario-template-contract-existing-doc-upgrade", status: "fail", error: "no active contracts" };
-            return {
-                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", "engine_contract"] },
-            };
-        },
-    },
-    // 场景 20: 决策一致性
-    {
-        scenario_id: "release-scenario-template-contract-conflict",
-        test_files: ["tests/engine/release_issue_scenario_matrix.test.ts"],
-        production_entrypoint: "template_asset_contract_registry.getContractDecision",
-        expected_outcome: "同一 path 两次 getContractDecision 结果一致（0 conflicts）",
-        runner: async () => {
-            const { buildTemplateAssetContracts, getContractDecision } = await import("./template_asset_contract_registry.js");
-            const contracts = buildTemplateAssetContracts(process.cwd());
-            let conflicts = 0;
-            const conflictPaths = [];
-            for (const c of contracts) {
-                const d1 = getContractDecision(c.path);
-                const d2 = getContractDecision(c.path);
-                if (d1.decision !== d2.decision) {
-                    conflicts++;
-                    conflictPaths.push(`${c.path}: ${d1.decision} vs ${d2.decision}`);
-                }
-            }
-            if (conflicts > 0)
-                return { scenario_id: "release-scenario-template-contract-conflict", status: "fail", error: conflictPaths.join("; ") };
-            return {
-                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", "engine_contract"] },
-            };
-        },
-    },
-    // 场景 21: 非 active 合同不出现在 syncable
-    {
-        scenario_id: "release-scenario-template-contract-draft-skip",
-        test_files: ["tests/engine/release_issue_scenario_matrix.test.ts"],
-        production_entrypoint: "template_asset_contract_registry.buildTemplateAssetContracts + getSyncableAssetPaths",
-        expected_outcome: "非 active 合同（deprecated/internal_only）存在且不出现在 syncable 列表",
-        runner: async () => {
-            const { buildTemplateAssetContracts, getSyncableAssetPaths } = await import("./template_asset_contract_registry.js");
-            const contracts = buildTemplateAssetContracts(process.cwd());
-            const syncable = new Set(getSyncableAssetPaths());
-            const nonActive = contracts.filter((c) => c.lifecycle_status !== "active");
-            if (nonActive.length === 0)
-                return { scenario_id: "release-scenario-template-contract-draft-skip", status: "fail", error: "no non-active contracts to verify skip behavior" };
-            const leakedNonActive = nonActive.filter((c) => syncable.has(c.path) && c.asset_visibility === "soloforge_internal");
-            if (leakedNonActive.length > 0)
-                return { scenario_id: "release-scenario-template-contract-draft-skip", status: "fail", error: `internal assets in syncable: ${leakedNonActive.map((c) => c.path).join(", ")}` };
-            return {
-                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", "engine_contract"] },
-            };
-        },
-    },
-    // 场景 22: 低风险意图路由
-    {
-        scenario_id: "release-scenario-template-contract-low-risk-skip",
-        test_files: ["tests/engine/release_issue_scenario_matrix.test.ts"],
-        production_entrypoint: "sf_classify",
-        expected_outcome: "低风险意图 route 为 code_change/operation/skip_chat",
-        runner: async () => {
-            const { classify } = await import("./classifier.js");
-            const result = classify({ intent: "添加一行日志" });
-            const route = result.route_decision?.route ?? "";
-            const lowRiskRoutes = ["code_change", "operation", "skip_chat"];
-            if (!lowRiskRoutes.includes(route))
-                return { scenario_id: "release-scenario-template-contract-low-risk-skip", status: "fail", error: `expected low-risk route, got ${route}` };
-            return {
-                scenario_id: "release-scenario-template-contract-low-risk-skip",
-                status: "pass",
-                evidence: `route=${route}`,
-                production_trace: { tool_entrypoint: "sf_classify", diagnostic_codes: [`route:${route}`], gates_consumed: ["router"] },
-            };
-        },
-    },
-    // 场景 22b: 一个任务内证明正式 API 产物从草稿阻断，经修复重验和人工确认后才能交付。
-    {
-        scenario_id: "release-scenario-template-contract-repair-directive",
-        test_files: ["tests/engine/release_issue_scenario_matrix.test.ts"],
-        production_entrypoint: "sf_classify→sf_expand(api_spec artifact)→sf_verify(draft)→sf_deliver(SF-CONTRACT-0003)→sf_learn→sf_verify(clear)→sf_record_verification_execution→sf_accept(confirm)→sf_deliver",
-        expected_outcome: "同一正式 API 产物与同一 task_id 在修复前阻断，修复重验及显式人工确认后 status=accepted 并可交付",
-        runner: async () => {
-            const { createToolHarness } = await import("./release_tool_harness.js");
-            const intent = "根据 docs/prd.md 生成接口设计";
-            const harness = await createToolHarness({ techStack: { backend: { lang: "none", framework: "none", version: "0" }, frontend: { lang: "none", framework: "none", version: "0" } } });
-            try {
-                const sourceDocPath = path.join(harness.tmpDir, "docs", "prd.md");
-                fs.mkdirSync(path.dirname(sourceDocPath), { recursive: true });
-                fs.writeFileSync(sourceDocPath, "# 用户列表需求\n\n提供用户列表查询接口，支持分页并返回用户 ID。\n", "utf-8");
-                const cls = harness.parseResult(await harness.callTool("sf_classify", { intent }));
-                const taskId = cls.task_id;
-                if (!taskId)
-                    return { scenario_id: "release-scenario-template-contract-repair-directive", status: "fail", error: "sf_classify 未返回 task_id" };
-                const exp = harness.parseResult(await harness.callTool("sf_expand", {
-                    task_id: taskId,
-                    input_material_confirmations: ["docs/prd.md"],
-                }));
-                if (exp.status === "awaiting_confirmation")
-                    return { scenario_id: "release-scenario-template-contract-repair-directive", status: "fail", error: "unexpected awaiting_confirmation" };
-                const tc = harness.taskContext;
-                const expandedCtx = await tc.load(taskId);
-                const artifactPath = expandedCtx?.artifact_output?.path;
-                if (!artifactPath || expandedCtx?.artifact_output?.kind !== "api_spec")
-                    return { scenario_id: "release-scenario-template-contract-repair-directive", status: "fail", error: `sf_expand 未创建正式 api_spec artifact_output: ${exp.error ?? exp.status ?? JSON.stringify(exp).slice(0, 180)}` };
-                const artifactAbs = path.join(harness.tmpDir, artifactPath);
-                fs.mkdirSync(path.dirname(artifactAbs), { recursive: true });
-                const openApiAbs = path.join(harness.tmpDir, "docs", "api", "openapi.yaml");
-                fs.mkdirSync(path.dirname(openApiAbs), { recursive: true });
-                fs.writeFileSync(openApiAbs, [
-                    "openapi: 3.0.0", "info:", "  title: Users API", "  version: '1.0'",
-                    "paths:", "  /users:", "    get:", "      responses:", "        '200':",
-                    "          description: OK",
-                ].join("\n"), "utf-8");
-                const compliantApiContent = [
-                    "# API 接口规格", "## 接口概览", "提供分页用户列表查询。", "## 请求响应规范",
-                    "### GET /users", "#### 请求字段表",
-                    "| 请求字段名 | 类型 | 必填 | 来源 | 说明 | 示例 | 校验规则 | 错误语义 |",
-                    "| --- | --- | --- | --- | --- | --- | --- | --- |",
-                    "| page | number | 否 | query | 页码 | 1 | >= 1 | 页码无效 |",
-                    "#### 响应字段表",
-                    "| 响应字段名 | 类型 | 必填 | 来源 | 说明 | 示例 | 校验规则 | 错误语义 |",
-                    "| --- | --- | --- | --- | --- | --- | --- | --- |",
-                    "| data | array | 是 | response | 用户列表 | [] | array | 无 |",
-                ].join("\n");
-                fs.writeFileSync(artifactAbs, `draft\n\n${compliantApiContent}`, "utf-8");
-                await harness.setupPlanGate(taskId);
-                const ver1 = harness.parseResult(await harness.callTool("sf_verify", { task_id: taskId, changed_files: [artifactPath], confirm: true }));
-                if (ver1.diagnostic_code !== "SF-CONTRACT-DRAFT")
-                    return { scenario_id: "release-scenario-template-contract-repair-directive", status: "fail", error: `expected SF-CONTRACT-DRAFT, got ${ver1.diagnostic_code ?? "none"}: ${ver1.error ?? JSON.stringify(ver1).slice(0, 240)}` };
-                const ctx1 = await tc.load(taskId);
-                if (!ctx1?.repair_reverify_directive?.blocked)
-                    return { scenario_id: "release-scenario-template-contract-repair-directive", status: "fail", error: "directive not blocked" };
-                const blockedDeliver = harness.parseResult(await harness.callTool("sf_deliver", { task_id: taskId, confirm: true }));
-                if (blockedDeliver.diagnostic_code !== "SF-CONTRACT-0003")
-                    return { scenario_id: "release-scenario-template-contract-repair-directive", status: "fail", error: `expected delivery SF-CONTRACT-0003, got ${blockedDeliver.diagnostic_code ?? "none"}` };
-                await harness.callTool("sf_learn", { task_id: taskId, result: "failure", failure_type: "integration" });
-                fs.writeFileSync(artifactAbs, compliantApiContent, "utf-8");
-                const ver2 = harness.parseResult(await harness.callTool("sf_verify", { task_id: taskId, changed_files: [artifactPath], confirm: true }));
-                const ctx2 = await tc.load(taskId);
-                if (ctx2?.repair_reverify_directive?.blocked)
-                    return { scenario_id: "release-scenario-template-contract-repair-directive", status: "fail", error: "directive not cleared after fix" };
-                if (ver2.diagnostic_code === "SF-CONTRACT-DRAFT" || ver2.diagnostic_code === "SF-CONTRACT-0003")
-                    return { scenario_id: "release-scenario-template-contract-repair-directive", status: "fail", error: `sf_verify still failing, code=${ver2.diagnostic_code}` };
-                if (ctx2?.artifact_output?.status !== "verified")
-                    return { scenario_id: "release-scenario-template-contract-repair-directive", status: "fail", error: `artifact did not reach verified: ${ctx2?.artifact_output?.status}; verification=${JSON.stringify(ver2.artifact_verification ?? ver2.artifact_warning ?? ver2).slice(0, 300)}` };
-                const ctxForV = await tc.load(taskId);
-                if (!ctxForV?.verification_plan)
-                    return { scenario_id: "release-scenario-template-contract-repair-directive", status: "fail", error: "no verification_plan after sf_verify" };
-                await harness.callTool("sf_record_verification_execution", {
-                    task_id: taskId,
-                    plan_id: ctxForV.verification_plan.plan_id,
-                    execution_records: ctxForV.verification_plan.commands.map((cmd, i) => ({
-                        command: cmd, exit_code: 0,
-                        stdout_hash: "a".repeat(64), stderr_hash: "e".repeat(64),
-                        started_at: new Date().toISOString(), finished_at: new Date().toISOString(),
-                        evidence_id: `evidence-${taskId}-${i}`,
-                    })),
-                });
-                const accept = harness.parseResult(await harness.callTool("sf_accept", {
-                    task_id: taskId, confirm: true, confirmed_by: "release-reviewer",
-                    confirmation_ref: `api-artifact:${taskId}`, acceptance_notes: "API 字段表与响应结构已人工确认",
-                    run_mode: "not_applicable",
-                }));
-                if (accept.artifact_transition !== "accepted")
-                    return { scenario_id: "release-scenario-template-contract-repair-directive", status: "fail", error: `artifact acceptance failed: ${accept.error ?? accept.artifact_transition}` };
-                const del = harness.parseResult(await harness.callTool("sf_deliver", { task_id: taskId, confirm: true }));
-                if (del.diagnostic_code)
-                    return { scenario_id: "release-scenario-template-contract-repair-directive", status: "fail", error: `sf_deliver still blocked: ${del.diagnostic_code}, error=${del.error ?? "none"}` };
-                const delObs = harness.getObservations().slice().reverse().find(o => o.tool_name === "sf_deliver");
-                if (!delObs || delObs.is_error)
-                    return { scenario_id: "release-scenario-template-contract-repair-directive", status: "fail", error: `sf_deliver observation error: ${delObs?.parsed_response?.error ?? "no obs"}` };
-                const finalCtx = await tc.load(taskId);
-                if (!finalCtx)
-                    return { scenario_id: "release-scenario-template-contract-repair-directive", status: "fail", error: "task context lost after delivery" };
-                const trace = await harness.collectTrace();
-                return {
-                    scenario_id: "release-scenario-template-contract-repair-directive",
-                    status: "pass",
-                    evidence: `task=${taskId} artifact=${finalCtx.artifact_output?.status} directive_cleared=${!finalCtx.repair_reverify_directive} delivered=${!delObs.is_error}`,
-                    production_trace: trace,
-                    behavioral_proof: {
-                        task_id: taskId, blocked_task_id: taskId, delivered_task_id: taskId,
-                        contract_blocked: blockedDeliver.diagnostic_code === "SF-CONTRACT-0003",
-                        repair_directive_cleared: !finalCtx.repair_reverify_directive,
-                        artifact_status: finalCtx.artifact_output?.status,
-                        acceptance_confirmation_ref: `api-artifact:${taskId}`,
-                        delivery_succeeded: !delObs.is_error,
-                    },
-                };
-            }
-            finally {
-                harness.cleanup();
-            }
-        },
-    },
-    // ── 问题六十四: 模板可见性 ──
-    // 场景 23: internal_runtime 资产全部 validation_result=pass
-    {
-        scenario_id: "release-scenario-template-visibility-fresh-init",
-        test_files: ["tests/engine/release_issue_scenario_matrix.test.ts"],
-        production_entrypoint: "observed_consumption.observeAllConsumption",
-        expected_outcome: "internal_runtime 资产全部 validation_result=pass（无 visibility fail）",
-        runner: async () => {
-            const { observeAllConsumption } = await import("./observed_consumption.js");
-            const report = await observeAllConsumption(process.cwd());
-            const visFails = report.observations.filter((o) => o.consume_category === "internal_runtime" && o.validation_result === "fail");
-            if (visFails.length > 0)
-                return { scenario_id: "release-scenario-template-visibility-fresh-init", status: "fail", error: `${visFails.length} internal_runtime visibility fails: ${visFails.map((o) => o.asset_path).join(",")}` };
-            return {
-                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", "engine_contract"] },
-            };
-        },
-    },
-    // 场景 24: internal_runtime 资产全部 contract_decision=denied
-    {
-        scenario_id: "release-scenario-template-visibility-internal-leak",
-        test_files: ["tests/engine/release_issue_scenario_matrix.test.ts"],
-        production_entrypoint: "observed_consumption.observeAllConsumption",
-        expected_outcome: "internal_runtime 资产全部 contract_decision=denied",
-        runner: async () => {
-            const { observeAllConsumption } = await import("./observed_consumption.js");
-            const report = await observeAllConsumption(process.cwd());
-            const notDenied = report.observations.filter((o) => o.consume_category === "internal_runtime" && o.contract_decision !== "denied");
-            if (notDenied.length > 0)
-                return { scenario_id: "release-scenario-template-visibility-internal-leak", status: "fail", error: `not denied: ${notDenied.map((o) => o.asset_path).join(", ")}` };
-            return {
-                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", "engine_contract"] },
-            };
-        },
-    },
-    // 场景 25: 内置模板回退 → syncable + copy
-    {
-        scenario_id: "release-scenario-template-visibility-builtin-fallback",
-        test_files: ["tests/engine/release_issue_scenario_matrix.test.ts"],
-        production_entrypoint: "template_asset_contract_registry.getSyncableAssetPaths + template_init_sync.copyKnowledgeToProject",
-        expected_outcome: "syncable 路径数量 > 0 且 init 后实际生成文件数 > 0",
-        runner: async () => {
-            const { getSyncableAssetPaths } = await import("./template_asset_contract_registry.js");
-            const { copyKnowledgeToProject } = await import("./template_init_sync.js");
-            const syncable = getSyncableAssetPaths();
-            if (syncable.length === 0)
-                return { scenario_id: "release-scenario-template-visibility-builtin-fallback", status: "fail", error: "no syncable assets" };
-            const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "soloforge-builtin-"));
-            try {
-                const result = await copyKnowledgeToProject(process.cwd(), tmpDir);
-                if (result.copied === 0)
-                    return { scenario_id: "release-scenario-template-visibility-builtin-fallback", status: "fail", error: "copyKnowledgeToProject copied 0 files" };
-                return {
-                    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", "engine_contract"] },
-                };
-            }
-            finally {
-                fs.rmSync(tmpDir, { recursive: true, force: true });
-            }
-        },
-    },
-    // 场景 26: 技术栈过滤 — 真实 sf_scaffold 工具消费真实受限资产。
-    {
-        scenario_id: "release-scenario-template-visibility-tech-stack",
-        test_files: ["tests/engine/release_issue_scenario_matrix.test.ts"],
-        production_entrypoint: "sf_classify→sf_expand→sf_scaffold→scaffolder.generateScaffold",
-        expected_outcome: "React 仅生成前端资产、Spring Boot 仅生成后端资产、不支持栈不生成内置脚手架",
-        runner: async () => {
-            const { createToolHarness } = await import("./release_tool_harness.js");
-            const { buildTemplateAssetContracts } = await import("./template_asset_contract_registry.js");
-            const contracts = buildTemplateAssetContracts(process.cwd());
-            const restricted = contracts.filter((contract) => contract.asset_kind === "scaffold" && contract.applicable_tech_stack.length > 0);
-            if (restricted.length !== 18)
-                return { scenario_id: "release-scenario-template-visibility-tech-stack", status: "fail", error: `expected 18 restricted scaffold contracts, got ${restricted.length}` };
-            const run = async (techStack) => {
-                const harness = await createToolHarness({ techStack });
-                try {
-                    const cls = harness.parseResult(await harness.callTool("sf_classify", { intent: "使用脚手架创建用户管理模块" }));
-                    if (!cls.task_id)
-                        throw new Error("sf_classify 未返回 task_id");
-                    await harness.callTool("sf_expand", { task_id: cls.task_id });
-                    await harness.setupPlanGate(cls.task_id);
-                    const response = harness.parseResult(await harness.callTool("sf_scaffold", { task_id: cls.task_id }));
-                    return { response, trace: await harness.collectTrace() };
-                }
-                finally {
-                    harness.cleanup();
-                }
-            };
-            const react = await run({ backend: { lang: "go", framework: "gin", version: "1" }, frontend: { lang: "typescript", framework: "react", version: "18" } });
-            const spring = await run({ backend: { lang: "java", framework: "spring-boot", version: "3" }, frontend: { lang: "none", framework: "none", version: "0" } });
-            const unsupported = await run({ backend: { lang: "python", framework: "django", version: "5" }, frontend: { lang: "typescript", framework: "angular", version: "18" } });
-            const reactFiles = react.response.files ?? [];
-            const springFiles = spring.response.files ?? [];
-            const unsupportedFiles = unsupported.response.files ?? [];
-            if (reactFiles.length === 0 || reactFiles.some((file) => file.path.endsWith(".java")))
-                return { scenario_id: "release-scenario-template-visibility-tech-stack", status: "fail", error: "React 脚手架生成结果含后端 Java 资产或为空" };
-            if (springFiles.length === 0 || springFiles.some((file) => /\.tsx?$/.test(file.path)))
-                return { scenario_id: "release-scenario-template-visibility-tech-stack", status: "fail", error: "Spring Boot 脚手架生成结果含 React 资产或为空" };
-            if (unsupportedFiles.length !== 0)
-                return { scenario_id: "release-scenario-template-visibility-tech-stack", status: "fail", error: `不支持技术栈错误生成 ${unsupportedFiles.length} 个内置文件` };
-            return {
-                scenario_id: "release-scenario-template-visibility-tech-stack",
-                status: "pass",
-                evidence: `restricted=${restricted.length} react=${reactFiles.length} spring=${springFiles.length} unsupported=0`,
-                production_trace: { tool_entrypoint: react.trace.tool_entrypoint, diagnostic_codes: [`restricted:${restricted.length}`, `react:${reactFiles.length}`, `spring:${springFiles.length}`, "unsupported:0"], gates_consumed: [...new Set([...react.trace.gates_consumed, ...spring.trace.gates_consumed])] },
-            };
-        },
-    },
-    // 场景 27: 用户可见资产不含内部术语
-    {
-        scenario_id: "release-scenario-template-visibility-user-visible-terms",
-        test_files: ["tests/engine/release_issue_scenario_matrix.test.ts"],
-        production_entrypoint: "template_asset_contract_registry.buildTemplateAssetContracts",
-        expected_outcome: "user_visible=true 的资产文件必须存在且内容不含 Batch/validate-release/Registry 等内部术语；合同标记用户可见而实体文件缺失必须 fail",
-        runner: async () => {
-            const { buildTemplateAssetContracts } = await import("./template_asset_contract_registry.js");
-            const contracts = buildTemplateAssetContracts(process.cwd());
-            const userVisible = contracts.filter((c) => c.user_visible === true && c.sync_to_user_project);
-            if (userVisible.length === 0)
-                return { scenario_id: "release-scenario-template-visibility-user-visible-terms", status: "fail", error: "no user_visible syncable assets" };
-            const internalTerms = [`Batch${6}`, "validate-release", "implementation_roadmap", `BATCH${6}_SCENARIO`];
-            const violations = [];
-            for (const c of userVisible) {
-                const absPath = path.join(process.cwd(), c.path);
-                // 合同标记用户可见而实体文件缺失必须 fail（不得 continue 跳过）
-                if (!fs.existsSync(absPath))
-                    return { scenario_id: "release-scenario-template-visibility-user-visible-terms", status: "fail", error: `用户可见合同 ${c.path} 标记 sync_to_user_project 但文件不存在: ${absPath}` };
-                const content = fs.readFileSync(absPath, "utf-8");
-                for (const term of internalTerms) {
-                    if (content.includes(term))
-                        violations.push(`${c.path}: ${term}`);
-                }
-            }
-            if (violations.length > 0)
-                return { scenario_id: "release-scenario-template-visibility-user-visible-terms", status: "fail", error: `internal terms found: ${violations.join("; ")}` };
-            return {
-                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", "engine_contract"] },
-            };
-        },
-    },
-    // 场景 28: copy→KIM→sf_classify→sf_expand 完整链路 + index_only/injectable 验证
-    {
-        scenario_id: "release-scenario-template-visibility-old-project-migration",
-        test_files: ["tests/engine/release_issue_scenario_matrix.test.ts"],
-        production_entrypoint: "sf_classify → sf_expand (via createToolHarness + copyKnowledge)",
-        expected_outcome: "init 后 KIM 索引同步资产；内部资产零泄漏；至少一条 index_only 资产已索引但其独特内容未进入 prompt/matched_knowledge；injectable 资产在适用路由可被召回",
-        runner: async () => {
-            const { createToolHarness } = await import("./release_tool_harness.js");
-            const { buildTemplateAssetContracts } = await import("./template_asset_contract_registry.js");
-            const harness = await createToolHarness({ copyKnowledge: true });
-            try {
-                const all = harness.knowledgeIndex.getAllEntries();
-                // 内部资产不应被索引
-                const leaked = all.project.find((e) => e.name?.includes("标准资产覆盖") || e.name?.includes("演进回归"));
-                if (leaked)
-                    return { scenario_id: "release-scenario-template-visibility-old-project-migration", status: "fail", error: `internal asset leaked: ${leaked.name}` };
-                // sf_classify → sf_expand 完整链路
-                const clsRaw = await harness.callTool("sf_classify", { intent: "创建用户管理 API" });
-                const cls = harness.parseResult(clsRaw);
-                if (!cls.task_id)
-                    return { scenario_id: "release-scenario-template-visibility-old-project-migration", status: "fail", error: "sf_classify did not return task_id" };
-                const expRaw = await harness.callTool("sf_expand", { task_id: cls.task_id });
-                const exp = harness.parseResult(expRaw);
-                if (exp.degraded)
-                    return { scenario_id: "release-scenario-template-visibility-old-project-migration", status: "fail", error: `sf_expand degraded: ${exp.prompt?.slice(0, 200)}` };
-                // 验证 domain 资产被索引
-                const domainEntry = all.project.find((e) => { const n = e.file_path?.replace(/\\/g, "/") ?? ""; return n.includes("domain/"); });
-                if (!domainEntry)
-                    return { scenario_id: "release-scenario-template-visibility-old-project-migration", status: "fail", error: "no domain entries indexed" };
-                // 验证 index_only 资产已索引但其独特内容不进入 prompt/matched_knowledge
-                const contracts = buildTemplateAssetContracts(process.cwd());
-                const indexOnlyContracts = contracts.filter((c) => c.runtime_visibility === "index_only");
-                if (indexOnlyContracts.length === 0)
-                    return { scenario_id: "release-scenario-template-visibility-old-project-migration", status: "fail", error: "no index_only contracts found" };
-                // 找一条已索引的 index_only 资产
-                const indexedIndexOnly = indexOnlyContracts.find((c) => {
-                    const fileName = path.basename(c.path, ".md");
-                    return all.project.some((e) => e.file_path?.includes(fileName));
-                });
-                if (!indexedIndexOnly)
-                    return { scenario_id: "release-scenario-template-visibility-old-project-migration", status: "fail", error: "no index_only asset found in index" };
-                // 验证 index_only 不在 matched_knowledge 中
-                const matchedIds = (exp.matched_knowledge ?? []).map((k) => k.id ?? k.name);
-                const indexOnlyName = path.basename(indexedIndexOnly.path, ".md");
-                const leakedToMatched = matchedIds.some((id) => id?.includes(indexOnlyName));
-                if (leakedToMatched)
-                    return { scenario_id: "release-scenario-template-visibility-old-project-migration", status: "fail", error: `index_only asset ${indexOnlyName} leaked to matched_knowledge` };
-                // 验证 index_only 独特内容不在 prompt 中
-                const indexOnlyEntry = all.project.find((e) => e.file_path?.includes(indexOnlyName));
-                if (indexOnlyEntry?.body) {
-                    const uniqueContent = indexOnlyEntry.body.slice(0, 80);
-                    if (exp.prompt && exp.prompt.includes(uniqueContent))
-                        return { scenario_id: "release-scenario-template-visibility-old-project-migration", status: "fail", error: `index_only asset content leaked to prompt: ${uniqueContent.slice(0, 40)}` };
-                }
-                // tool_entrypoint 由 ToolInvocationObservation 自动生成
-                const trace = await harness.collectTrace();
-                return {
-                    scenario_id: "release-scenario-template-visibility-old-project-migration",
-                    status: "pass",
-                    evidence: `indexed=${all.project.length} no internal leaks index_only=${indexOnlyName} not in prompt/matched domain found`,
-                    production_trace: trace,
-                };
-            }
-            finally {
-                harness.cleanup();
-            }
-        },
-    },
-    // 场景 29: scaffold 边界 — 真实 sf_scaffold MCP 工具调用
-    {
-        scenario_id: "release-scenario-template-visibility-scaffold-boundary",
-        test_files: ["tests/engine/release_issue_scenario_matrix.test.ts"],
-        production_entrypoint: "sf_classify→sf_expand→sf_scaffold + template_asset_contract_registry.getSyncableAssetPaths",
-        expected_outcome: "scaffold 合同不出现在同步列表; sf_scaffold 真实调用返回生成文件列表且无 .hbs 文件泄漏到用户项目",
-        runner: async () => {
-            const { createToolHarness } = await import("./release_tool_harness.js");
-            const { buildTemplateAssetContracts, getSyncableAssetPaths } = await import("./template_asset_contract_registry.js");
-            // 合同边界: scaffold 不在 syncable 列表
-            const contracts = buildTemplateAssetContracts(process.cwd());
-            const scaffoldContracts = contracts.filter((c) => c.asset_kind === "scaffold");
-            if (scaffoldContracts.length === 0)
-                return { scenario_id: "release-scenario-template-visibility-scaffold-boundary", status: "fail", error: "no scaffold contracts" };
-            const syncable = new Set(getSyncableAssetPaths());
-            const leaked = scaffoldContracts.filter((sc) => syncable.has(sc.path));
-            if (leaked.length > 0)
-                return { scenario_id: "release-scenario-template-visibility-scaffold-boundary", status: "fail", error: `scaffolds in syncable: ${leaked.map((s) => s.path).join(", ")}` };
-            // 真实 sf_scaffold 工具调用
-            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-template-visibility-scaffold-boundary", status: "fail", error: "sf_classify 未返回 task_id" };
-                const expRaw = await harness.callTool("sf_expand", { task_id: taskId });
-                const exp = harness.parseResult(expRaw);
-                await harness.setupPlanGate(taskId);
-                const scfRaw = await harness.callTool("sf_scaffold", { task_id: taskId });
-                const scf = harness.parseResult(scfRaw);
-                // sf_scaffold 必须返回结果（非错误）
-                const scfObs = harness.getLastObservation();
-                if (scfObs?.is_error && scf?.error?.includes("仅适用于 scaffold"))
-                    return { scenario_id: "release-scenario-template-visibility-scaffold-boundary", status: "fail", error: `sf_scaffold rejected: task_type=${cls.classification?.task_type ?? "unknown"}, expected scaffold` };
-                // sf_scaffold 结果应包含 generated_files 或 templates_applied
-                const hasFiles = Array.isArray(scf?.generated_files) || Array.isArray(scf?.templates_applied) || Array.isArray(scf?.files);
-                if (!hasFiles && !scf?.error)
-                    return { scenario_id: "release-scenario-template-visibility-scaffold-boundary", status: "fail", error: `sf_scaffold returned no file list: ${JSON.stringify(scf).slice(0, 300)}` };
-                const trace = await harness.collectTrace();
-                // 补充诊断码（sf_scaffold 不返回诊断码，从观察记录提取）
-                if (trace.diagnostic_codes.length === 0) {
-                    const scaffoldObs = harness.getObservations().find(o => o.tool_name === "sf_scaffold");
-                    trace.diagnostic_codes = [`scaffold_files:${scf?.total_files ?? scf?.files?.length ?? 0}`, `contracts:${scaffoldContracts.length}`];
-                }
-                return {
-                    scenario_id: "release-scenario-template-visibility-scaffold-boundary",
-                    status: "pass",
-                    evidence: `scaffolds=${scaffoldContracts.length} leaked=0 sf_scaffold=${scf?.total_files ?? scf?.files?.length ?? "?"} files generated`,
-                    production_trace: trace,
-                };
-            }
-            finally {
-                harness.cleanup();
-            }
-        },
-    },
-    // ── 问题六十八: 代码可维护性与可观测性契约 ──
-    {
-        scenario_id: "release-scenario-code-observability-payment-status-no-log",
-        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",
-        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",
-        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: unknown) {
-    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",
-        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",
-        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",
-        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",
-        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",
-        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() {
-    return RELEASE_ISSUE_SCENARIOS;
-}
-/**
- * 验证 发布问题场景覆盖:
- * - 所有场景必须有 runner + production_entrypoint + expected_outcome
- * - 所有引用测试文件的场景: 测试文件必须存在
- * - 返回结构化验证结果
- */
-export function validateReleaseIssueScenarios(rootDir) {
-    const missing_tests = [];
-    const missing_runners = [];
-    const missing_entrypoints = [];
-    const tautology_suspects = [];
-    for (const scenario of RELEASE_ISSUE_SCENARIOS) {
-        if (!scenario.runner) {
-            missing_runners.push(scenario.scenario_id);
-        }
-        if (!scenario.production_entrypoint) {
-            missing_entrypoints.push(scenario.scenario_id);
-        }
-        if (!scenario.expected_outcome) {
-            missing_entrypoints.push(`${scenario.scenario_id}: missing expected_outcome`);
-        }
-        for (const testFile of scenario.test_files) {
-            const fullPath = path.join(rootDir, testFile);
-            if (!fs.existsSync(fullPath)) {
-                missing_tests.push(`${scenario.scenario_id}: ${testFile}`);
-            }
-        }
-    }
-    return {
-        valid: missing_tests.length === 0 && missing_runners.length === 0 && missing_entrypoints.length === 0,
-        missing_tests,
-        missing_runners,
-        missing_entrypoints,
-        tautology_suspects,
-        scenario_count: RELEASE_ISSUE_SCENARIOS.length,
-    };
-}
-/**
- * 运行所有场景，收集执行证据。
- * 每个场景必须有 runner，无 runner 视为 fail。
- */
-export async function executeReleaseIssueScenarios() {
-    const results = [];
-    for (const scenario of RELEASE_ISSUE_SCENARIOS) {
-        const start = Date.now();
-        try {
-            const result = await scenario.runner();
-            result.duration_ms = Date.now() - start;
-            results.push(result);
-        }
-        catch (e) {
-            results.push({ scenario_id: scenario.scenario_id, status: "fail", error: e.message, duration_ms: Date.now() - start });
-        }
-    }
-    return results;
-}
-//# sourceMappingURL=release_issue_scenario_registry.js.map