soloforge 1.1.2 → 1.1.30

package/dist/engine/contracts/extension_scenario_registry.js

@@ -0,0 +1,963 @@
+/**
+ * 扩展平台场景注册表 — A-M 场景定义与运行器。
+ *
+ * 13 个场景覆盖 13 个扩展平台问题。
+ * 每个场景通过真实函数调用产生 evidence，不硬编码 PASS。
+ */
+import { validateExtensionManifest, createExtensionManifest, evaluateExtensionLifecycle, grantExtensionPermissions } from "./extension_contract.js";
+import { normalizePathRef, checkPathSafety, createTestPlatformContext } from "./platform_context.js";
+import { createMetricContract, evaluateMetrics, createGovernanceFinding, evaluateGovernanceAction } from "./metric_governance.js";
+import { createTechnologyDecision, validateTechnologyDecision, evaluateDecisionExecution, createDecisionRecord } from "./technology_decision.js";
+import { createBrainstormSession, createOptionRecord, validateBrainstormSession, canBrainstormAutoExecute, createTradeoffMatrix } from "./brainstorm_contract.js";
+import { createDetailDisciplineContract, performDetailCheck, checkDetailGateIntegration } from "./detail_discipline.js";
+import { createFirstPrinciplesFrame, performFirstPrinciplesCheck, validateFirstPrinciplesForHighImpact } from "./first_principles.js";
+import { createArchitectureDesignContract, reviewArchitectureDesign, validateOutputDirectoryDecision, validateMermaidDiagrams } from "./architecture_design_contract.js";
+import { detectProjectContext, checkAnalysisGate } from "./existing_system_analysis.js";
+import { createCodingReadinessContract, createTestFirstPlan, evaluateCodingReadiness, performMainlineConsumptionCheck } from "./coding_readiness_gate.js";
+import { createLocalDockerAcceptanceContract, requiresLocalAcceptance, validateFinalAccess, performBrowserAcceptance, evaluateRepairLoop, createServiceRuntimeSpec, executeHttpAcceptanceWithTransport, realResultToBrowserEvidence, validateLocalAcceptanceEvidence } from "./local_docker_acceptance.js";
+import { createWorkflowTemplatePackContract, createWorkflowTemplateEntry, createTemplateConsumptionEvidence, validateWorkflowTemplatePack, advanceTemplateConsumptionStatus } from "./workflow_template_pack.js";
+import { createNewIssueRegressionGate, checkDuplicateIssue, analyzeTemplateEvolutionImpact, performEvolutionGate } from "./evolution_regression_gate.js";
+// ── 场景定义 ──
+export const EXTENSION_SCENARIOS = [
+    {
+        id: "scenario-A", name: "扩展生命周期与权限管控",
+        fixture: "ExtensionManifest / ExtensionGrant / ExtensionCapabilityDeclaration",
+        command_or_entry: "validateExtensionManifest / evaluateExtensionLifecycle / grantExtensionPermissions",
+        expected_evidence: ["第三方扩展不得自称 enforced", "权限授权正确", "高风险权限需人类审批"],
+        pass_fail_rules: ["第三方扩展 enforced 被阻断", "合法生命周期转移通过", "高风险权限未审批被拒绝"],
+    },
+    {
+        id: "scenario-B", name: "指标真实性与治理动作",
+        fixture: "MetricContract / MetricSample / GovernanceFinding / GovernanceActionBinding",
+        command_or_entry: "evaluateMetrics / createGovernanceFinding / evaluateGovernanceAction",
+        expected_evidence: ["skipped 不算 passed", "degraded 不算 passed", "高风险动作不自动触发"],
+        pass_fail_rules: ["非 passed 状态不算通过", "critical 级高风险动作需人类确认"],
+    },
+    {
+        id: "scenario-C", name: "决策主权与脑暴联动",
+        fixture: "BrainstormSession / TechnologyDecisionContract / TechnologyDecisionRecord / DecisionEvidence",
+        command_or_entry: "createBrainstormSession / validateBrainstormSession / canBrainstormAutoExecute / createTechnologyDecision / validateTechnologyDecision / createDecisionRecord / evaluateDecisionExecution",
+        expected_evidence: ["高风险决策需 human gate", "脑暴必须产生候选方案", "脑暴推荐不能自动执行", "recommended 状态不可执行", "approved 可执行"],
+        pass_fail_rules: [
+            "高风险技术决策必须先有多方案探索记录",
+            "高风险技术决策需要 human gate",
+            "recommended_option 与 executable_without_human 必须分离",
+            "脑暴推荐不绕过 Decision Sovereignty",
+            "destructive decision 必须有 rollback_or_exit_plan",
+        ],
+    },
+    {
+        id: "scenario-D", name: "细节纪律",
+        fixture: "DetailDisciplineContract / DetailDisciplineCheck / DetailRiskItem",
+        command_or_entry: "performDetailCheck / summarizeDetailChecks / checkDetailGateIntegration",
+        expected_evidence: ["缺失维度被检测", "blocking 项阻止交付", "检查接入交付 gate"],
+        pass_fail_rules: ["细节纪律必须接入验证与交付 gate"],
+    },
+    {
+        id: "scenario-E", name: "第一性原理",
+        fixture: "FirstPrinciplesFrame / FirstPrinciplesCheck",
+        command_or_entry: "performFirstPrinciplesCheck / validateFirstPrinciplesForHighImpact",
+        expected_evidence: ["缺少 fundamental_need 被阻断", "缺少证伪被检测", "能阻断错误前提"],
+        pass_fail_rules: ["high impact 变更必须有 fundamental_need"],
+    },
+    {
+        id: "scenario-F", name: "跨平台路径安全",
+        fixture: "PlatformContext / NormalizedPathRef / PathSafetyCheck",
+        command_or_entry: "detectPlatformContext / normalizePathRef / checkPathSafety",
+        expected_evidence: ["路径规范化正确", "scope 逃逸被检测", "symlink 被检测"],
+        pass_fail_rules: ["工作区内路径安全", ".. 路径逃逸被阻断", "大小写冲突被检测"],
+    },
+    {
+        id: "scenario-G", name: "脑暴多方案探索与原则联动",
+        fixture: "BrainstormSession / OptionExplorationRecord / OptionTradeoffMatrix / FirstPrinciplesFrame / DetailDisciplineContract",
+        command_or_entry: "createBrainstormSession / validateBrainstormSession / canBrainstormAutoExecute / createTradeoffMatrix / createFirstPrinciplesFrame / performFirstPrinciplesCheck / createDetailDisciplineContract / performDetailCheck",
+        expected_evidence: ["脑暴产生 3+ 候选方案", "取舍矩阵生成", "脑暴推荐不绕过 Decision Sovereignty", "第一性原理框架完整", "细节纪律检查接入", "三个契约联动"],
+        pass_fail_rules: [
+            "高影响方案必须至少包含候选方案、优缺点、适用边界、失败条件和验证方式",
+            "推荐方案必须包含不推荐其他方案的原因",
+            "脑暴推荐不得绕过 Decision Sovereignty human gate",
+            "脑暴结论必须进入 TaskContext / decision record / evidence refs 之一",
+        ],
+    },
+    {
+        id: "scenario-H", name: "架构设计审查",
+        fixture: "ArchitectureDesignContract / ArchitectureDesignReview",
+        command_or_entry: "reviewArchitectureDesign / validateOutputDirectoryDecision / validateMermaidDiagrams",
+        expected_evidence: ["输出目录未确认阻断 delivered", "Mermaid 图必须可渲染", "输入集不完整被检测"],
+        pass_fail_rules: ["未确认目录不得 delivered", "Mermaid 渲染失败被检测"],
+    },
+    {
+        id: "scenario-I", name: "现有系统分析与差距分析",
+        fixture: "ProjectContextDetection / ExistingSystemAnalysisContract / RequirementGapAnalysis",
+        command_or_entry: "detectProjectContext / checkAnalysisGate / reviewExistingSystemDevelopment",
+        expected_evidence: ["existing_system 必须先分析", "差距分析前置检查", "缺失分析被阻断"],
+        pass_fail_rules: ["existing_system + new_requirement 必须先做分析"],
+    },
+    {
+        id: "scenario-J", name: "编码准备门与测试优先",
+        fixture: "CodingReadinessContract / TestFirstPlan / CodingCompletionReview",
+        command_or_entry: "evaluateCodingReadiness / performMainlineConsumptionCheck / reviewCodingCompletion",
+        expected_evidence: ["编码不是第一步", "blocked 时不得编码", "测试优先计划被检查"],
+        pass_fail_rules: ["coding 不能作为第一步", "blocked/manual_required 时不得写代码"],
+    },
+    {
+        id: "scenario-K", name: "本地 Docker/浏览器验收",
+        fixture: "LocalDockerAcceptanceContract / BrowserAcceptanceEvidence / FinalLocalReviewAccess",
+        command_or_entry: "requiresLocalAcceptance / validateFinalAccess / performBrowserAcceptance",
+        expected_evidence: ["有前端时不得只停单测", "必须提供本地 URL", "修复循环策略"],
+        pass_fail_rules: ["最终必须给用户本地可访问 URL", "浏览器验收失败需要修复"],
+    },
+    {
+        id: "scenario-L", name: "工作流模板包消费",
+        fixture: "WorkflowTemplatePackContract / TemplateConsumptionEvidence",
+        command_or_entry: "validateWorkflowTemplatePack / advanceTemplateConsumptionStatus",
+        expected_evidence: ["模板必须走完消费 pipeline", "停在中间状态被检测"],
+        pass_fail_rules: ["模板文件存在但未消费不得 completed"],
+    },
+    {
+        id: "scenario-M", name: "演进回归与新问题门控",
+        fixture: "NewIssueRegressionGate / DuplicateIssueCheck / TemplateEvolutionImpact",
+        command_or_entry: "checkDuplicateIssue / analyzeTemplateEvolutionImpact / performEvolutionGate",
+        expected_evidence: ["重复问题被检测", "模板演进影响被分析", "未通过门控不得 accepted"],
+        pass_fail_rules: ["没有 NewIssueRegressionGate 的新增问题不得 accepted"],
+    },
+];
+// ── 场景运行器 ──
+function runScenarioA() {
+    const evidence = [];
+    const failures = [];
+    // 第三方扩展自称 enforced 被阻断
+    const manifest = createExtensionManifest({ extension_id: "ext-1", permissions: ["read_project"] });
+    const capDecl = { extension_id: "ext-1", claimed_capabilities: [], claimed_enforcement: "enforced_by_host", third_party: true };
+    const v1 = validateExtensionManifest(manifest, capDecl);
+    if (!v1.valid && v1.violations.some(v => v.includes("第三方"))) {
+        evidence.push("第三方扩展不得自称 enforced");
+    }
+    else {
+        failures.push("第三方扩展自称 enforced 应被阻断");
+    }
+    // 合法生命周期转移
+    const lc1 = evaluateExtensionLifecycle("ext-1", "draft", "installed");
+    if (lc1.allowed)
+        evidence.push("合法生命周期转移通过");
+    else
+        failures.push("draft→installed 应允许");
+    const lc2 = evaluateExtensionLifecycle("ext-1", "active", "draft");
+    if (!lc2.allowed)
+        evidence.push("非法转移被阻断");
+    else
+        failures.push("active→draft 应被阻断");
+    // 高风险权限需人类审批
+    const grant1 = grantExtensionPermissions("ext-1", ["execute_command", "read_project"], "system", "test", false);
+    if (!grant1.granted_permissions.includes("execute_command"))
+        evidence.push("高风险权限需人类审批");
+    else
+        failures.push("execute_command 未审批不应被授权");
+    const grant2 = grantExtensionPermissions("ext-1", ["execute_command"], "human", "test", true);
+    if (grant2.granted_permissions.includes("execute_command"))
+        evidence.push("人类审批后高风险权限被授权");
+    else
+        failures.push("审批后 execute_command 应被授权");
+    return { scenario_id: "scenario-A", scenario_name: "扩展生命周期与权限管控", status: failures.length === 0 ? "PASS" : "FAIL", evidence, failures };
+}
+function runScenarioB() {
+    const evidence = [];
+    const failures = [];
+    // skipped 不算 passed
+    const eval1 = evaluateMetrics([
+        { metric_id: "m1", value: 1, sampled_at: "", sample_status: "passed" },
+        { metric_id: "m2", value: 0, sampled_at: "", sample_status: "skipped" },
+    ]);
+    if (!eval1.passed)
+        evidence.push("skipped 不算 passed");
+    else
+        failures.push("含 skipped 样本不应算全部通过");
+    if (eval1.skipped_count === 1)
+        evidence.push("skipped 计数正确");
+    else
+        failures.push(`skipped 计数应为 1，实际 ${eval1.skipped_count}`);
+    // degraded 不算 passed
+    const eval2 = evaluateMetrics([
+        { metric_id: "m3", value: 0, sampled_at: "", sample_status: "degraded" },
+    ]);
+    if (!eval2.passed && eval2.degraded_count === 1)
+        evidence.push("degraded 不算 passed");
+    else
+        failures.push("degraded 应不算 passed");
+    // 高风险动作不自动触发
+    const metric = createMetricContract({ id: "m-gov", metric_type: "governance" });
+    const finding = createGovernanceFinding(metric, "critical", ["ev-1"]);
+    const action1 = evaluateGovernanceAction(finding, "downgrade");
+    if (action1.requires_human && !action1.auto_triggered)
+        evidence.push("高风险动作需人类确认不自动触发");
+    else
+        failures.push("高风险动作应需人类确认");
+    return { scenario_id: "scenario-B", scenario_name: "指标真实性与治理动作", status: failures.length === 0 ? "PASS" : "FAIL", evidence, failures };
+}
+function runScenarioC() {
+    const evidence = [];
+    const failures = [];
+    // 1. 创建高风险架构决策（仅 heuristic 证据）
+    const contract = createTechnologyDecision({
+        decision_id: "dec-c-1",
+        decision_scope: "architecture",
+        options: [
+            { option_id: "opt-a", title: "微服务架构", description: "拆分为独立微服务" },
+            { option_id: "opt-b", title: "单体模块化", description: "保持单体但模块化" },
+            { option_id: "opt-c", title: "事件驱动架构", description: "基于消息队列的事件驱动" },
+        ],
+        recommended_option: "opt-b",
+        human_gate_required: true,
+        executable_without_human: false,
+        evidence: [{ source_type: "heuristic", source_ref: "行业趋势", confidence: 0.6 }],
+        falsification: ["微服务增加运维复杂度", "事件驱动带来最终一致性挑战"],
+        failure_conditions: ["团队规模不支持微服务", "性能不达标"],
+        validation_plan: ["概念验证 POC"],
+        rollback_or_exit_plan: ["保留单体代码作为回退基线"],
+    });
+    // 2. 验证架构范围需要 human gate
+    const v1 = validateTechnologyDecision(contract);
+    if (v1.valid)
+        evidence.push("高风险决策需 human gate");
+    else
+        failures.push(`高风险决策校验失败: ${v1.violations.join("; ")}`);
+    // 3. 创建脑暴会话并验证
+    const session = createBrainstormSession({
+        session_id: "bs-c-1",
+        problem_statement: "选择后端架构方案",
+        trigger: "technology_choice",
+        options: [
+            createOptionRecord({ option_id: "opt-a", title: "微服务架构", pros: ["独立部署", "技术栈灵活"], cons: ["运维复杂", "网络延迟"], failure_conditions: ["团队规模不足", "分布式事务"] }),
+            createOptionRecord({ option_id: "opt-b", title: "单体模块化", pros: ["简单", "部署快"], cons: ["扩展性有限"], failure_conditions: ["模块边界不清"] }),
+            createOptionRecord({ option_id: "opt-c", title: "事件驱动架构", pros: ["解耦", "可扩展"], cons: ["最终一致性", "调试困难"], failure_conditions: ["消息堆积", "调试复杂度高"] }),
+        ],
+        recommended_option_id: "opt-b",
+        rejected_option_ids: ["opt-a", "opt-c"],
+        brainstorm_status: "options_ready",
+        human_gate_required: true,
+        evidence_refs: ["dec-c-1"],
+    });
+    const v2 = validateBrainstormSession(session);
+    if (v2.valid)
+        evidence.push("脑暴必须产生候选方案");
+    else
+        failures.push(`脑暴校验失败: ${v2.violations.join("; ")}`);
+    // 4. 验证脑暴推荐不能自动执行
+    if (!canBrainstormAutoExecute(session))
+        evidence.push("脑暴推荐不能自动执行");
+    else
+        failures.push("脑暴推荐不应自动执行");
+    // 5. 创建 recommended 决策记录，验证不可执行
+    const record1 = createDecisionRecord("dec-c-1", { decision_status: "recommended" });
+    const exec1 = evaluateDecisionExecution(contract, record1);
+    if (!exec1.allowed)
+        evidence.push("recommended 状态不可执行");
+    else
+        failures.push("推荐状态不应允许执行");
+    // 6. 创建 approved 决策记录，验证可执行
+    const record2 = createDecisionRecord("dec-c-1", { decision_status: "approved", approved_by: "human" });
+    const exec2 = evaluateDecisionExecution(contract, record2);
+    if (exec2.allowed)
+        evidence.push("approved 可执行");
+    else
+        failures.push("已批准应允许执行");
+    return { scenario_id: "scenario-C", scenario_name: "决策主权与脑暴联动", status: failures.length === 0 ? "PASS" : "FAIL", evidence, failures };
+}
+function runScenarioD() {
+    const evidence = [];
+    const failures = [];
+    const contract = createDetailDisciplineContract({ contract_id: "dd-1" });
+    // 缺失维度被检测
+    const check1 = performDetailCheck(contract, "target-1", "implementation", {});
+    if (check1.missing_details.length > 0 && check1.blocking)
+        evidence.push("缺失维度被检测为 blocking");
+    else
+        failures.push("缺失维度应被检测");
+    // 检查接入交付 gate
+    const gate1 = checkDetailGateIntegration(check1, true);
+    if (gate1.allowed)
+        evidence.push("检查接入交付 gate");
+    else
+        failures.push("有交付 gate 应允许");
+    const gate2 = checkDetailGateIntegration(check1, false);
+    if (!gate2.allowed)
+        evidence.push("未接入交付 gate 被阻断");
+    else
+        failures.push("blocking 检查未接入交付 gate 应被阻断");
+    // 完整检查通过
+    const check2 = performDetailCheck(contract, "target-2", "design", {
+        edge_cases: ["边界1"], defaults: ["默认1"], failure_paths: ["失败1"],
+        cleanup: ["清理1"], idempotency: ["幂等1"], overwrite_behavior: ["覆盖1"],
+        rollback: ["回滚1"], evidence: ["证据1"],
+    });
+    if (check2.detail_check_status === "passed")
+        evidence.push("完整维度检查通过");
+    else
+        failures.push(`完整维度应通过，实际 ${check2.detail_check_status}`);
+    return { scenario_id: "scenario-D", scenario_name: "细节纪律", status: failures.length === 0 ? "PASS" : "FAIL", evidence, failures };
+}
+function runScenarioE() {
+    const evidence = [];
+    const failures = [];
+    // 缺少 fundamental_need 被阻断
+    const frame1 = createFirstPrinciplesFrame({ problem_id: "p1", user_goal: "目标" });
+    const check1 = performFirstPrinciplesCheck(frame1);
+    if (!check1.passed && check1.failures.some(f => f.includes("fundamental_need"))) {
+        evidence.push("缺少 fundamental_need 被阻断");
+    }
+    else {
+        failures.push("缺少 fundamental_need 应被阻断");
+    }
+    // 缺少证伪被检测
+    if (check1.failures.some(f => f.includes("falsification")))
+        evidence.push("缺少证伪被检测");
+    else
+        failures.push("缺少证伪问题应被检测");
+    // 完整框架通过
+    const frame2 = createFirstPrinciplesFrame({
+        problem_id: "p2",
+        user_goal: "实现缓存方案",
+        fundamental_need: "高可用缓存",
+        known_facts: ["当前使用 Redis", "QPS 约 1000"],
+        assumptions: ["Redis 不会宕机"],
+        candidate_solutions: ["Redis 集群", "本地缓存 + Redis"],
+        simplest_viable_solution: "单节点 Redis + 本地缓存降级",
+        falsification_questions: ["如果 Redis 宕机怎么办？"],
+        chosen_solution: "单节点 Redis + 本地缓存降级",
+        why_not_legacy_path: "旧方案无降级策略",
+        first_principles_status: "framed",
+    });
+    const check2 = performFirstPrinciplesCheck(frame2);
+    if (check2.passed)
+        evidence.push("完整框架通过");
+    else
+        failures.push(`完整框架应通过: ${check2.failures.join("; ")}`);
+    // high impact 校验
+    const hp = validateFirstPrinciplesForHighImpact(frame2);
+    if (hp.passed)
+        evidence.push("high impact 校验通过");
+    else
+        failures.push(`完整框架 high impact 应通过: ${hp.violations.join("; ")}`);
+    return { scenario_id: "scenario-E", scenario_name: "第一性原理", status: failures.length === 0 ? "PASS" : "FAIL", evidence, failures };
+}
+function runScenarioF() {
+    const evidence = [];
+    const failures = [];
+    const platform = createTestPlatformContext();
+    const scope = "/tmp/test-workspace";
+    // 工作区内路径安全
+    const ref1 = normalizePathRef("/tmp/test-workspace/src/main.ts", platform, scope);
+    if (ref1.path_safety_status === "safe")
+        evidence.push("工作区内路径安全");
+    else
+        failures.push(`工作区内路径应安全，实际 ${ref1.path_safety_status}`);
+    // .. 路径逃逸
+    const ref2 = normalizePathRef("/tmp/test-workspace/../../../etc/passwd", platform, scope);
+    if (ref2.path_safety_status !== "safe")
+        evidence.push(".. 路径逃逸被检测");
+    else
+        failures.push(".. 路径应被检测为不安全");
+    // scope 外路径
+    const safety = checkPathSafety(ref2, scope);
+    if (!safety.passes)
+        evidence.push("scope 外路径被阻断");
+    else
+        failures.push("scope 外路径应被阻断");
+    // 大小写检测
+    const macPlatform = createTestPlatformContext({ path_case_sensitive: false, os: "darwin" });
+    const ref3 = normalizePathRef("/tmp/test-workspace/SRC/Main.ts", macPlatform, scope);
+    if (ref3.case_normalized || ref3.path_safety_status === "safe")
+        evidence.push("大小写处理正确");
+    else
+        failures.push("macOS 大小写处理异常");
+    return { scenario_id: "scenario-F", scenario_name: "跨平台路径安全", status: failures.length === 0 ? "PASS" : "FAIL", evidence, failures };
+}
+function runScenarioG() {
+    const evidence = [];
+    const failures = [];
+    // 1. 创建脑暴会话：3+ 选项、取舍、失败条件
+    const options = [
+        createOptionRecord({
+            option_id: "g-o1", title: "Redis 集群",
+            pros: ["高可用", "自动故障转移", "数据分片"],
+            cons: ["运维复杂", "内存成本高", "集群配置复杂"],
+            failure_conditions: ["脑裂导致数据不一致", "内存不足时 OOM", "网络分区时写入失败"],
+        }),
+        createOptionRecord({
+            option_id: "g-o2", title: "本地缓存 + Redis 单节点",
+            pros: ["简单", "成本低", "读取快"],
+            cons: ["多实例不一致", "单点故障", "缓存穿透"],
+            failure_conditions: ["Redis 宕机全站不可用", "缓存击穿", "本地缓存脏数据"],
+        }),
+        createOptionRecord({
+            option_id: "g-o3", title: "多级缓存 + 消息队列",
+            pros: ["高可用", "高性能", "解耦"],
+            cons: ["架构复杂", "一致性挑战", "延迟较高"],
+            failure_conditions: ["消息堆积", "多级缓存不一致", "队列服务不可用"],
+        }),
+    ];
+    const session = createBrainstormSession({
+        session_id: "bs-g-1",
+        problem_statement: "选择高可用缓存方案",
+        trigger: "high_impact_change",
+        options,
+        recommended_option_id: "g-o1",
+        rejected_option_ids: ["g-o2", "g-o3"],
+        brainstorm_status: "options_ready",
+        human_gate_required: true,
+        evidence_refs: ["dec-g-1"],
+    });
+    // 2. 验证脑暴会话
+    const v1 = validateBrainstormSession(session);
+    if (v1.valid)
+        evidence.push("脑暴产生 3+ 候选方案");
+    else
+        failures.push(`脑暴校验失败: ${v1.violations.join("; ")}`);
+    // 3. 验证有推荐和拒绝项
+    if (session.recommended_option_id && session.rejected_option_ids.length > 0) {
+        evidence.push("脑暴有推荐方案和拒绝方案");
+    }
+    else {
+        failures.push("脑暴缺少推荐方案或拒绝方案");
+    }
+    // 4. 验证脑暴推荐不能自动执行
+    if (!canBrainstormAutoExecute(session))
+        evidence.push("脑暴推荐不绕过 Decision Sovereignty");
+    else
+        failures.push("脑暴推荐不应自动执行");
+    // 5. 创建取舍矩阵
+    const matrix = createTradeoffMatrix({
+        matrix_id: "tm-g-1",
+        criteria: ["可用性", "复杂度", "成本", "一致性"],
+        selected_option_id: "g-o1",
+        why_selected_zh: "Redis 集群在高可用场景下综合得分最高",
+        why_rejected_zh: [
+            { option_id: "g-o2", reason: "单点故障风险过高，不适合生产环境" },
+            { option_id: "g-o3", reason: "架构过于复杂，当前团队规模不支持" },
+        ],
+    }, options);
+    if (matrix.selected_option_id === "g-o1" && matrix.why_rejected_zh.length === 2) {
+        evidence.push("取舍矩阵生成");
+    }
+    else {
+        failures.push("取舍矩阵内容不完整");
+    }
+    // 6. 创建第一性原理框架
+    const frame = createFirstPrinciplesFrame({
+        problem_id: "p-g-1",
+        user_goal: "实现高可用缓存",
+        fundamental_need: "保证服务在缓存层故障时仍可用",
+        known_facts: ["当前 QPS 约 5000", "数据量约 50GB", "团队 3 人"],
+        assumptions: ["网络延迟 < 1ms", "读写比 10:1"],
+        candidate_solutions: ["Redis 集群", "本地缓存 + Redis", "多级缓存 + MQ"],
+        simplest_viable_solution: "Redis 集群 + 本地缓存降级",
+        falsification_questions: ["如果 Redis 集群全部宕机怎么办？", "如果网络分区导致脑裂怎么办？"],
+        chosen_solution: "Redis 集群 + 本地缓存降级",
+        why_not_legacy_path: "当前无缓存方案，不是改造场景",
+        first_principles_status: "framed",
+    });
+    const check1 = performFirstPrinciplesCheck(frame);
+    if (check1.passed)
+        evidence.push("第一性原理框架完整");
+    else
+        failures.push(`第一性原理框架不完整: ${check1.failures.join("; ")}`);
+    // 7. 创建细节纪律契约并检查
+    const ddContract = createDetailDisciplineContract({ contract_id: "dd-g-1" });
+    const ddCheck = performDetailCheck(ddContract, "cache-impl", "implementation", {
+        edge_cases: ["缓存穿透", "缓存击穿", "缓存雪崩"],
+        defaults: ["空缓存默认回源", "连接超时默认 3s"],
+        failure_paths: ["Redis 宕机", "网络分区", "内存溢出"],
+        cleanup: ["过期 key 自动清理", "宕机后本地缓存自动过期"],
+        idempotency: ["相同 key 写入幂等", "删除操作幂等"],
+        overwrite_behavior: ["同 key 覆盖写入", "版本号校验"],
+        rollback: ["降级到本地缓存", "直接查数据库"],
+        evidence: ["压力测试报告", "故障恢复验证"],
+    });
+    if (ddCheck.detail_check_status === "passed")
+        evidence.push("细节纪律检查接入");
+    else
+        failures.push(`细节纪律检查失败: ${ddCheck.detail_check_status}`);
+    // 8. 验证三个契约联动
+    if (session.evidence_refs.length > 0 && frame.chosen_solution && ddCheck.detail_check_status === "passed") {
+        evidence.push("三个契约联动");
+    }
+    else {
+        failures.push("三个契约联动验证失败");
+    }
+    return { scenario_id: "scenario-G", scenario_name: "脑暴多方案探索与原则联动", status: failures.length === 0 ? "PASS" : "FAIL", evidence, failures };
+}
+function runScenarioH() {
+    const evidence = [];
+    const failures = [];
+    // 输出目录未确认阻断 delivered
+    const contract = createArchitectureDesignContract({
+        contract_id: "arch-1",
+        architecture_design_status: "delivered",
+        output_directory_decision: { recommended_name: "output", recommendation_reason_zh: "原因", architecture_output_directory_status: "recommended" },
+    });
+    const dirCheck = validateOutputDirectoryDecision(contract.output_directory_decision, contract.architecture_design_status);
+    if (!dirCheck.allowed)
+        evidence.push("输出目录未确认阻断 delivered");
+    else
+        failures.push("未确认目录不应允许 delivered");
+    // Mermaid 渲染失败被检测
+    const mermaidCheck = validateMermaidDiagrams([{
+            diagram_id: "d1", diagram_type: "sequenceDiagram", required_for: "test",
+            mermaid_source: "invalid", render_check_status: "failed",
+        }]);
+    if (!mermaidCheck.allRenderable)
+        evidence.push("Mermaid 渲染失败被检测");
+    else
+        failures.push("渲染失败应被检测");
+    // 架构设计审查
+    const goodContract = createArchitectureDesignContract({
+        contract_id: "arch-2",
+        architecture_design_status: "completed",
+        input_set: { task_ids: ["t1"], required_source_artifacts: ["prototype_description"], consumed_files: ["f1"], missing_required_files: [], all_clients_covered: true },
+        output_directory_decision: { recommended_name: "output", recommendation_reason_zh: "原因", architecture_output_directory_status: "confirmed", confirmed_name: "output" },
+        mermaid_diagram_requirements: [],
+    });
+    const review = reviewArchitectureDesign(goodContract);
+    if (review.passed)
+        evidence.push("合规架构设计审查通过");
+    else
+        failures.push(`合规架构设计应通过: ${review.review.failed_rules.join("; ")}`);
+    return { scenario_id: "scenario-H", scenario_name: "架构设计审查", status: failures.length === 0 ? "PASS" : "FAIL", evidence, failures };
+}
+function runScenarioI() {
+    const evidence = [];
+    const failures = [];
+    // existing_system 必须先分析
+    const ctx1 = detectProjectContext(true, true, true);
+    if (ctx1.project_context_type === "existing_system")
+        evidence.push("existing_system 正确检测");
+    else
+        failures.push("应检测为 existing_system");
+    const gate1 = checkAnalysisGate(ctx1, false, false);
+    if (!gate1.allowed)
+        evidence.push("existing_system 必须先分析");
+    else
+        failures.push("existing_system 未分析不应允许");
+    // 有分析后通过
+    const gate2 = checkAnalysisGate(ctx1, true, true);
+    if (gate2.allowed)
+        evidence.push("有分析后通过");
+    else
+        failures.push("已有分析应允许");
+    // empty_project 不要求分析
+    const ctx2 = detectProjectContext(false, false, false);
+    const gate3 = checkAnalysisGate(ctx2, false, false);
+    if (gate3.allowed)
+        evidence.push("empty_project 不强制分析");
+    else
+        failures.push("empty_project 不应强制分析");
+    return { scenario_id: "scenario-I", scenario_name: "现有系统分析与差距分析", status: failures.length === 0 ? "PASS" : "FAIL", evidence, failures };
+}
+function runScenarioJ() {
+    const evidence = [];
+    const failures = [];
+    // 编码不是第一步 — 缺少验证计划应被阻断
+    const contract1 = createCodingReadinessContract({
+        task_id: "t1",
+        required_preconditions: ["gap_analysis"],
+        consumed_constraints: ["gap_analysis"],
+        test_first_plan: { ...createTestFirstPlan(true, true, "feature"), test_first_status: "planned" },
+        verification_plan_ref: "",
+    });
+    const eval1 = evaluateCodingReadiness(contract1, true, false, false);
+    if (!eval1.allowed)
+        evidence.push("缺少验证计划被阻断");
+    else
+        failures.push("缺少验证计划应被阻断");
+    // 完整条件通过
+    const eval2 = evaluateCodingReadiness(contract1, true, false, true);
+    // 使用完整前置条件
+    const contract2 = createCodingReadinessContract({
+        task_id: "t2",
+        project_context_type: "existing_system",
+        required_preconditions: [],
+        consumed_constraints: [],
+        test_first_plan: { ...createTestFirstPlan(true, true, "feature"), test_first_status: "written" },
+        verification_plan_ref: "vp-2",
+    });
+    const eval3 = evaluateCodingReadiness(contract2, true, false, true);
+    if (eval3.allowed)
+        evidence.push("完整条件通过编码准备门");
+    else
+        failures.push(`完整条件应通过: ${eval3.missing_preconditions.join("; ")}`);
+    // 主线消费检查
+    const mainline = performMainlineConsumptionCheck(["src/new.ts"], ["new"], ["api/new"]);
+    if (mainline.orphan_findings.length === 0)
+        evidence.push("主线消费检查通过");
+    else
+        failures.push(`主线孤立: ${mainline.orphan_findings.join("; ")}`);
+    return { scenario_id: "scenario-J", scenario_name: "编码准备门与测试优先", status: failures.length === 0 ? "PASS" : "FAIL", evidence, failures };
+}
+/** @deprecated 使用 runScenarioKAsync 代替，同步版本不含 transport-level 验收 */
+export function runScenarioK() {
+    const evidence = [];
+    const failures = [];
+    // ── 步骤 1: 项目检测 → 决定是否需要本地验收 ──
+    // 前端+docker-compose 项目必须本地验收
+    const req1 = requiresLocalAcceptance(true, true, true, false);
+    if (req1.required && req1.run_mode === "docker_compose")
+        evidence.push("docker_compose 项目需要本地验收");
+    else
+        failures.push("docker_compose 项目应需要本地验收");
+    // 纯后端无容器 → local_dev_server
+    const req2 = requiresLocalAcceptance(false, true, false, false);
+    if (req2.required && req2.run_mode === "local_dev_server")
+        evidence.push("纯后端项目需要本地验收");
+    else
+        failures.push("纯后端应使用 local_dev_server");
+    // CI 无 Docker 且无前后端 → not_applicable
+    const req3 = requiresLocalAcceptance(false, false, false, false);
+    if (!req3.required && req3.run_mode === "not_applicable")
+        evidence.push("无前后端项目不需要本地验收");
+    else
+        failures.push("无前后端项目应 not_applicable");
+    // ── 步骤 2: 服务运行规格 ──
+    const frontendSpec = createServiceRuntimeSpec({
+        service_name: "frontend",
+        service_type: "frontend",
+        ports: [{ internal: 3000, external: 3000 }],
+        health_check: "http://localhost:3000/health",
+        required_env: ["NODE_ENV"],
+    });
+    const backendSpec = createServiceRuntimeSpec({
+        service_name: "backend",
+        service_type: "backend_api",
+        ports: [{ internal: 8080, external: 8080 }],
+        health_check: "http://localhost:8080/api/health",
+        required_env: ["NODE_ENV", "DATABASE_URL"],
+    });
+    if (frontendSpec.service_name === "frontend" && backendSpec.service_name === "backend") {
+        evidence.push("服务运行规格识别完成");
+    }
+    else {
+        failures.push("服务运行规格识别失败");
+    }
+    // ── 步骤 3: 浏览器验收（首次，有错误触发修复） ──
+    const plan = {
+        target_urls: ["http://localhost:3000"],
+        user_flows: ["首页加载", "登录流程", "数据提交"],
+        viewport_matrix: ["desktop"],
+        required_assertions: ["页面可访问", "表单可提交", "API 联动正常"],
+        screenshot_or_trace_required: true,
+    };
+    const firstAttempt = performBrowserAcceptance(plan, ["TypeError: Cannot read properties of undefined"], {
+        max_iterations: 3,
+        rebuild_required_after_fix: true,
+        redeploy_required_after_fix: true,
+        retest_required_after_fix: true,
+        stop_conditions: ["retry_budget_exhausted", "same_error_repeated"],
+    });
+    if (firstAttempt.needsRepair && firstAttempt.evidence.acceptance_status === "failed") {
+        evidence.push("首次验收失败被捕获");
+    }
+    else {
+        failures.push("首次验收失败应触发修复");
+    }
+    if (firstAttempt.evidence.console_errors.length > 0) {
+        evidence.push("失败错误被记录（capture）");
+    }
+    else {
+        failures.push("失败应有 console_errors");
+    }
+    // ── 步骤 4: 修复循环 ──
+    // 修复循环: 第一次修复（不同错误 → 继续）
+    const repair1 = evaluateRepairLoop(1, {
+        max_iterations: 3,
+        rebuild_required_after_fix: true,
+        redeploy_required_after_fix: true,
+        retest_required_after_fix: true,
+        stop_conditions: ["retry_budget_exhausted", "same_error_repeated"],
+    }, ["ReferenceError: new error"], ["TypeError: Cannot read properties of undefined"]);
+    if (repair1.continue_repair)
+        evidence.push("修复循环第1次继续");
+    else
+        failures.push("修复循环第1次应继续");
+    // 修复循环: 超预算停止
+    const repair2 = evaluateRepairLoop(3, {
+        max_iterations: 3,
+        rebuild_required_after_fix: true,
+        redeploy_required_after_fix: true,
+        retest_required_after_fix: true,
+        stop_conditions: ["retry_budget_exhausted"],
+    }, ["error1"], []);
+    if (!repair2.continue_repair)
+        evidence.push("超预算停止");
+    else
+        failures.push("超预算应停止");
+    // ── 步骤 5: performBrowserAcceptance 拒绝空 errors 模拟成功 ──
+    const emptyAttempt = performBrowserAcceptance(plan, [], {
+        max_iterations: 3,
+        rebuild_required_after_fix: true,
+        redeploy_required_after_fix: true,
+        retest_required_after_fix: true,
+        stop_conditions: ["retry_budget_exhausted"],
+    });
+    if (emptyAttempt.evidence.acceptance_status === "failed" && emptyAttempt.stopReason?.includes("executeRealHttpAcceptance")) {
+        evidence.push("空 errors 被正确拒绝，必须使用 executeRealHttpAcceptance 或 executeHttpAcceptanceWithTransport");
+    }
+    else {
+        failures.push("空 errors 不应直接判定 passed");
+    }
+    // ── 步骤 6: 最终 URL 交付 ──
+    const contract = createLocalDockerAcceptanceContract({
+        project_run_mode: "docker_compose",
+        final_access: {
+            frontend_urls: ["http://localhost:3000"],
+            backend_urls: ["http://localhost:8080"],
+            docs_or_swagger_urls: ["http://localhost:8080/api/docs"],
+            start_commands: ["docker compose up -d"],
+            stop_commands: ["docker compose down"],
+            running_status: "running",
+            manual_review_steps_zh: ["检查首页加载", "检查登录功能"],
+            known_limits_zh: ["首次启动需等待约 30 秒"],
+        },
+    });
+    const access = validateFinalAccess(contract.final_access, contract.project_run_mode);
+    if (access.passed)
+        evidence.push("最终 URL 交付完整");
+    else
+        failures.push(`最终 URL 交付失败: ${access.blocking_reasons.join("; ")}`);
+    // 无 URL 不得 delivered
+    const contractNoUrl = createLocalDockerAcceptanceContract({
+        project_run_mode: "docker_compose",
+        final_access: {
+            frontend_urls: [], backend_urls: [], docs_or_swagger_urls: [],
+            start_commands: ["docker compose up -d"],
+            stop_commands: ["docker compose down"],
+            running_status: "not_started",
+            manual_review_steps_zh: [],
+            known_limits_zh: [],
+        },
+    });
+    const accessNoUrl = validateFinalAccess(contractNoUrl.final_access, contractNoUrl.project_run_mode);
+    if (!accessNoUrl.passed)
+        evidence.push("无 URL 不得 delivered");
+    else
+        failures.push("无 URL 应被阻断");
+    return { scenario_id: "scenario-K", scenario_name: "本地 Docker/浏览器验收", status: failures.length === 0 ? "PASS" : "FAIL", evidence, failures };
+}
+function runScenarioL() {
+    const evidence = [];
+    const failures = [];
+    // 模板必须走完消费 pipeline — 使用真实 owner_mechanism_id
+    const workflowEntry = createWorkflowTemplateEntry("architecture_design", "templates/procedures/架构设计工作流.md");
+    workflowEntry.owner_mechanism_ids = ["mc-architecture-design"];
+    const pack = createWorkflowTemplatePackContract({
+        workflows: [workflowEntry],
+        mechanism_consumption_map: [{ template_path: "templates/procedures/架构设计工作流.md", consumed_mechanism_id: "mc-architecture-design", consumption_type: "route_trigger", evidence_required: true }],
+    });
+    // 消费停在中间被检测
+    const evidences = [createTemplateConsumptionEvidence("templates/procedures/架构设计工作流.md")];
+    evidences[0].template_consumption_status = "file_created";
+    const v1 = validateWorkflowTemplatePack(pack, evidences);
+    if (!v1.valid)
+        evidence.push("停在中间状态被检测");
+    else
+        failures.push("停在 file_created 应不合规");
+    // 走完 pipeline 通过 — 必须有真实链路证据
+    evidences[0].template_consumption_status = "verified";
+    evidences[0].workflow_template_refs = ["wf-architecture-design"];
+    evidences[0].route_trigger_refs = ["架构设计"];
+    evidences[0].adapter_prompt_refs = [];
+    evidences[0].sync_migration_refs = ["manifest:templates/procedures/架构设计工作流.md"];
+    evidences[0].scenario_refs = ["scenario-H"];
+    const v2 = validateWorkflowTemplatePack(pack, evidences);
+    if (v2.valid)
+        evidence.push("走完 pipeline 通过");
+    else
+        failures.push(`走完 pipeline 应通过: ${v2.violations.join("; ")}`);
+    // pipeline 顺序正确
+    const adv1 = advanceTemplateConsumptionStatus("missing");
+    if (adv1.allowed && adv1.next === "file_created")
+        evidence.push("pipeline 顺序正确");
+    else
+        failures.push("missing → file_created 应允许");
+    // 手工置绿必须被检测
+    const fakeEvidences = [createTemplateConsumptionEvidence("templates/procedures/架构设计工作流.md")];
+    fakeEvidences[0].template_consumption_status = "verified";
+    const v3 = validateWorkflowTemplatePack(pack, fakeEvidences);
+    if (!v3.valid)
+        evidence.push("手工置绿被检测");
+    else
+        failures.push("手工设置 verified 但无链路引用应不合规");
+    return { scenario_id: "scenario-L", scenario_name: "工作流模板包消费", status: failures.length === 0 ? "PASS" : "FAIL", evidence, failures };
+}
+function runScenarioM() {
+    const evidence = [];
+    const failures = [];
+    // 重复问题被检测
+    const dup = checkDuplicateIssue("实现缓存方案", [
+        { id: "issue-1", title: "实现缓存方案", status: "open" },
+    ]);
+    if (dup.possible_duplicates.length > 0 && dup.can_merge_into_existing_issue) {
+        evidence.push("重复问题被检测");
+    }
+    else {
+        failures.push("重复问题应被检测");
+    }
+    // 模板演进影响被分析
+    const impact = analyzeTemplateEvolutionImpact(["extension_contracts"], ["architecture_design"]);
+    if (impact.template_update_required)
+        evidence.push("模板演进影响被分析");
+    else
+        failures.push("有 contract 变更应需要模板更新");
+    // 未通过门控不得 accepted
+    const gate = createNewIssueRegressionGate({
+        issue_candidate_id: "new-1",
+        candidate_title: "新问题",
+        evolution_gate_status: "pending",
+    });
+    const result = performEvolutionGate(gate);
+    if (!result.allowed)
+        evidence.push("未通过门控不得 accepted");
+    else
+        failures.push("pending 状态不应被接受");
+    // 通过门控
+    const gate2 = createNewIssueRegressionGate({
+        issue_candidate_id: "new-2",
+        candidate_title: "全新问题",
+        evolution_gate_status: "accepted",
+        decision: "create_new_batch",
+    });
+    const result2 = performEvolutionGate(gate2);
+    if (result2.allowed)
+        evidence.push("通过门控被接受");
+    else
+        failures.push(`合规门控应通过: ${result2.reasons.join("; ")}`);
+    return { scenario_id: "scenario-M", scenario_name: "演进回归与新问题门控", status: failures.length === 0 ? "PASS" : "FAIL", evidence, failures };
+}
+/** 运行全部 A-M 场景（场景 K 使用 transport-level 内存验收） */
+export async function runAllExtensionScenarios() {
+    return [
+        runScenarioA(), runScenarioB(), runScenarioC(), runScenarioD(),
+        runScenarioE(), runScenarioF(), runScenarioG(), runScenarioH(),
+        runScenarioI(), runScenarioJ(),
+        await runScenarioKAsync(),
+        runScenarioL(), runScenarioM(),
+    ];
+}
+/**
+ * 异步版本场景 K: 使用 executeHttpAcceptanceWithTransport() 执行 transport-level 验收。
+ * 不启动真实本地 HTTP 服务，使用内存 transport。
+ * PASS 证据包含 target_url、health_check_output、browser_steps、assertion_results、run_hash。
+ * executeRealHttpAcceptance() 属于实际运行/集成验收能力，不属于默认 gate。
+ */
+export async function runScenarioKAsync() {
+    const evidence = [];
+    const failures = [];
+    // ── 步骤 1: 评估是否需要本地验收 ──
+    const req1 = requiresLocalAcceptance(true, true, true, false);
+    if (req1.required && req1.run_mode === "docker_compose")
+        evidence.push("docker_compose 项目需要本地验收");
+    else
+        failures.push("docker_compose 项目应需要本地验收");
+    // ── 步骤 2: 内存 transport 验收（不绑定端口） ──
+    const targetUrl = "http://127.0.0.1:1/memory-acceptance";
+    const transport = async (_url) => ({
+        status: 200,
+        text: async () => "<html><head><title>SoloForge Test</title></head><body><h1>OK</h1></body></html>",
+    });
+    // ── 步骤 3: 执行 transport-level HTTP 验收 ──
+    const realResult = await executeHttpAcceptanceWithTransport(targetUrl, [
+        { name: "状态码 200", check: (status) => status === 200 },
+        { name: "body 含 OK", check: (_s, body) => body.includes("OK") },
+    ], transport);
+    if (realResult.health_check_ok && realResult.http_status === 200) {
+        evidence.push(`transport-level 验收通过: ${realResult.health_check_output}`);
+    }
+    else {
+        failures.push(`transport-level 验收失败: ${realResult.health_check_output}`);
+    }
+    if (realResult.assertion_results.length >= 2 && realResult.assertion_results.every(r => r.endsWith(": PASS"))) {
+        evidence.push("transport 断言全部通过");
+    }
+    else {
+        failures.push(`transport 断言失败: ${realResult.assertion_results.join(", ")}`);
+    }
+    if (realResult.timestamp && realResult.run_hash) {
+        evidence.push(`运行证据: ts=${realResult.timestamp}, hash=${realResult.run_hash.slice(0, 20)}...`);
+    }
+    else {
+        failures.push("缺少运行时间戳或 hash");
+    }
+    // ── 步骤 4: 构造浏览器验收证据 ──
+    const browserEvidence = realResultToBrowserEvidence(realResult, "场景K transport-level 验收");
+    if (browserEvidence.acceptance_status === "passed") {
+        evidence.push("浏览器验收证据状态为 passed");
+    }
+    else {
+        failures.push(`浏览器验收证据状态为 ${browserEvidence.acceptance_status}，期望 passed`);
+    }
+    if (browserEvidence.browser_steps.length > 0 && browserEvidence.assertion_results.length > 0) {
+        evidence.push(`browser_steps: ${browserEvidence.browser_steps[0]}`);
+    }
+    else {
+        failures.push("浏览器验收证据缺少 browser_steps 或 assertion_results");
+    }
+    // ── 步骤 5: 完整本地验收契约验证 ──
+    const contract = createLocalDockerAcceptanceContract({
+        project_run_mode: "local_dev_server",
+        local_runtime_evidence: {
+            build_command: "npm run build",
+            image_ids: [],
+            build_artifacts: ["dist/bundle.js"],
+            container_ids: [],
+            service_urls: [targetUrl],
+            health_check_outputs: [realResult.health_check_output],
+            logs_summary_zh: ["内存 transport 服务正常"],
+        },
+        browser_acceptance_evidence: [browserEvidence],
+        final_access: {
+            frontend_urls: [targetUrl],
+            backend_urls: [],
+            docs_or_swagger_urls: [],
+            start_commands: ["npm run dev"],
+            stop_commands: ["Ctrl+C"],
+            running_status: "running",
+            manual_review_steps_zh: [],
+            known_limits_zh: [],
+        },
+    });
+    const fullResult = validateLocalAcceptanceEvidence(contract);
+    if (fullResult.passed) {
+        evidence.push("完整本地验收契约验证通过");
+    }
+    else {
+        failures.push(`完整本地验收契约验证失败: ${fullResult.blocking_reasons.join("; ")}`);
+    }
+    // ── 步骤 6: 首次验收失败 → 修复循环 ──
+    const firstAttempt = performBrowserAcceptance({ target_urls: [targetUrl], user_flows: ["首页"], viewport_matrix: ["desktop"], required_assertions: [], screenshot_or_trace_required: false }, ["TypeError: 模拟错误"], { max_iterations: 3, rebuild_required_after_fix: true, redeploy_required_after_fix: true, retest_required_after_fix: true, stop_conditions: ["retry_budget_exhausted"] });
+    if (firstAttempt.needsRepair && firstAttempt.evidence.acceptance_status === "failed") {
+        evidence.push("首次验收失败被捕获（capture）");
+    }
+    else {
+        failures.push("首次验收失败应触发修复");
+    }
+    // 空 errors 被 rejected
+    const emptyAttempt = performBrowserAcceptance({ target_urls: [targetUrl], user_flows: ["首页"], viewport_matrix: ["desktop"], required_assertions: [], screenshot_or_trace_required: false }, [], { max_iterations: 3, rebuild_required_after_fix: true, redeploy_required_after_fix: true, retest_required_after_fix: true, stop_conditions: ["retry_budget_exhausted"] });
+    if (emptyAttempt.evidence.acceptance_status === "failed" && emptyAttempt.stopReason?.includes("executeRealHttpAcceptance")) {
+        evidence.push("空 errors 被正确拒绝");
+    }
+    else {
+        failures.push("空 errors 不应直接判定 passed");
+    }
+    // 无 URL 不得 delivered
+    const noUrlResult = validateFinalAccess({
+        frontend_urls: [], backend_urls: [], docs_or_swagger_urls: [],
+        start_commands: [], stop_commands: [], running_status: "not_started",
+        manual_review_steps_zh: [], known_limits_zh: [],
+    }, "docker_compose");
+    if (!noUrlResult.passed)
+        evidence.push("无 URL 不得 delivered");
+    else
+        failures.push("无 URL 应被阻断");
+    return { scenario_id: "scenario-K", scenario_name: "本地 Docker/浏览器验收（transport-level acceptance）", status: failures.length === 0 ? "PASS" : "FAIL", evidence, failures };
+}
+/** @deprecated 使用 runAllExtensionScenarios() 代替，后者已改为 async */
+export const runAllExtensionScenariosAsync = runAllExtensionScenarios;
+//# sourceMappingURL=extension_scenario_registry.js.map