@dommaker/harness 1.4.0 → 1.6.0

package/src/core/validators/passes-gate.ts

@@ -7,13 +7,12 @@
  * 「过了没」的判定依据不在本文件：唯一入口是 test-output.ts 的 judgeTestRun（ADR-0014）
  */
 
-import { execAsync, delay } from '../../utils/exec';
+import { execAsync } from '../../utils/exec';
 import { judgeTestRun } from './test-output';
 import * as fs from 'fs/promises';
 import * as path from 'path';
 import type {
   PassesGateConfig,
-  PassesGateResult,
   TaskTestResult,
   DynamicTask,
   TestResult,
@@ -30,24 +29,8 @@ const DEFAULT_CONFIG: Required<PassesGateConfig> = {
   testCommand: '',
   requireEvidence: true,
   allowPartialPass: false,
-  maxRetries: 2,
-  retryDelay: 1000,
 };
 
-/**
- * 测试文件保护模式
- */
-const PROTECTED_TEST_PATTERNS = [
-  '**/*.test.ts',
-  '**/*.test.tsx',
-  '**/*.test.js',
-  '**/*.spec.ts',
-  '**/*.spec.tsx',
-  '**/*.spec.js',
-  '**/tests/**',
-  '**/__tests__/**',
-];
-
 /**
  * 检测项目的测试命令（唯一正本，CLI 与库调用共消费，架构评审 A2）
  *
@@ -98,7 +81,6 @@ export async function detectTestCommand(projectPath: string): Promise<string | u
  */
 export class PassesGate {
   private config: Required<PassesGateConfig>;
-  private testResults: Map<string, TaskTestResult> = new Map();
 
   constructor(config: Partial<PassesGateConfig> = {}) {
     this.config = { ...DEFAULT_CONFIG, ...config };
@@ -170,99 +152,6 @@ export class PassesGate {
     };
   }
 
-  /**
-   * 设置任务通过状态
-   * 核心方法：强制测试验证
-   */
-  async setPasses(
-    taskId: string,
-    value: boolean,
-    workDir: string,
-    task?: DynamicTask
-  ): Promise<PassesGateResult> {
-    if (!this.config.enabled) {
-      return {
-        taskId,
-        allowed: true,
-        attempts: 0,
-      };
-    }
-
-    // 如果设置为 false，直接允许
-    if (value === false) {
-      return {
-        taskId,
-        allowed: true,
-        testResult: {
-          passed: false,
-          command: 'manual',
-          timestamp: new Date(),
-        },
-        attempts: 0,
-      };
-    }
-
-    // 如果设置为 true，必须运行测试
-    let attempts = 0;
-    let lastError: string | undefined;
-    let testResult: TaskTestResult | undefined;
-
-    while (attempts <= this.config.maxRetries) {
-      attempts++;
-      
-      try {
-        testResult = await this.runTest(workDir, task);
-        
-        if (testResult.passed) {
-          // 记录测试结果
-          this.testResults.set(taskId, testResult);
-          
-          // 如果要求证据，验证证据存在
-          if (this.config.requireEvidence && testResult.evidence) {
-            const evidenceExists = await this.verifyEvidence(testResult.evidence, workDir);
-            if (!evidenceExists) {
-              return {
-                taskId,
-                allowed: false,
-                error: 'Test evidence not found',
-                testResult,
-                attempts,
-              };
-            }
-          }
-          
-          return {
-            taskId,
-            allowed: true,
-            testResult,
-            attempts,
-          };
-        }
-        
-        lastError = `Tests failed: ${testResult.failures?.join(', ') || 'Unknown error'}`;
-        
-        // 等待后重试
-        if (attempts <= this.config.maxRetries) {
-          await delay(this.config.retryDelay);
-        }
-      } catch (error: any) {
-        lastError = error.message;
-        
-        if (attempts <= this.config.maxRetries) {
-          await delay(this.config.retryDelay);
-        }
-      }
-    }
-
-    return {
-      taskId,
-      allowed: false,
-      error: lastError,
-      testResult,
-      attempts,
-    };
-  }
-
   /**
    * 运行测试（CLI 使用）
    *
@@ -404,43 +293,6 @@ export class PassesGate {
     }
   }
 
-  /**
-   * 检测是否修改了测试文件
-   */
-  async checkTestFileChanges(workDir: string): Promise<string[]> {
-    const changedTestFiles: string[] = [];
-
-    try {
-      const { stdout } = await execAsync('git diff --name-only', { cwd: workDir });
-      const changedFiles = stdout.split('\n').filter(Boolean);
-
-      // 简单的模式匹配
-      for (const file of changedFiles) {
-        const isTestFile = PROTECTED_TEST_PATTERNS.some(() => {
-          return file.includes('.test.') ||
-                 file.includes('.spec.') ||
-                 file.includes('/tests/') ||
-                 file.includes('/__tests__/');
-        });
-
-        if (isTestFile) {
-          changedTestFiles.push(file);
-        }
-      }
-    } catch {
-      // Git 不可用，跳过检查
-    }
-
-    return changedTestFiles;
-  }
-
-  /**
-   * 获取任务的测试结果
-   */
-  getTestResult(taskId: string): TaskTestResult | undefined {
-    return this.testResults.get(taskId);
-  }
-
 }
 
 /**

package/src/failure/CONTEXT.md

@@ -1,18 +1,16 @@
 # failure/
 
 ## 职责
-失败处理：错误分类(可扩展规则)、失败记录(文件存储)、约束违规统一处理策略。
+失败处理：错误分类(可扩展规则)、失败记录(文件存储)。
 
 ## 核心导出
 - `ErrorClassifier` — 错误分类器(可配置规则)
 - `FailureRecorder` — 失败记录器(文件存储)
-- `ConstraintViolationHandler` — 约束违规处理: block / collect / safeBoolean 三种策略
 - `types.ts` — 错误分类/记录类型定义
 
 ## 依赖关系
-- 依赖 `src/types/constraint` ConstraintViolationError
-- 依赖 `src/core/constraints/` 约束检查结果
-- 被 `src/cli/commands/report.ts` 消费（executeWithCollect），并经包根导出
+- 依赖 `src/types/` 错误分类/记录类型
+- 经包根导出（ADR-0003 显式清单）
 
 ## 约定
 - 分类规则可扩展(自定义 ErrorClassifierConfig)
@@ -20,5 +18,9 @@
 - 不包含业务逻辑，只提供通用能力
 
 ## 注意事项
-- S4 统一处理策略：executeWithBlock / executeWithCollect / executeWithSafeBoolean
 - 分类器基于规则匹配，不调用 LLM
+- S4 约束违规处理策略模块（ConstraintViolationHandler / executeWithBlock /
+  executeWithCollect / executeWithSafeBoolean）已删除（架构评审候选1）：
+  COLLECT 对真实 checker 结构上不可交付（checker 首个铁律违规即 throw，
+  handler 的 catch 只能吞证据造假绿）。语义归宿——阻断 = `checkConstraints` 本体，
+  收集 = `checker.collectConstraints`（report 直调）；BLOCK/SAFE_BOOLEAN 零生产消费者随迁

package/src/failure/index.ts

@@ -23,13 +23,3 @@ export {
   createFailureRecorder,
   type FailureRecorderConfig,
 } from './recorder';
-
-// 约束违规处理（S4：统一处理策略）
-export {
-  ConstraintViolationHandler,
-  executeWithBlock,
-  executeWithCollect,
-  executeWithSafeBoolean,
-  type ViolationStrategy,
-  type ViolationHandlingResult,
-} from './constraint-handler';

package/src/gates/CONTEXT.md

@@ -9,7 +9,7 @@
 - 定义表：`GATE_DEFINITIONS`（`definitions.ts`）——id/description/默认 order/CLI 元数据；CLI 元数据形状即 `CommandDefinition`（ADR-0007：门禁与非门禁共用同一命令定义形状，bin 单引擎单循环；门禁特有语义 = `subcommandStrict:false` 未知子命令落回默认 action + `bareRunsAction:true` 裸跑执行 action）；bin/harness.js 注册表驱动生成 6 门禁命令（纯数据模块，禁 import 实现，保 --help 懒加载；CLI 实现引用为 module+export，per-command 懒加载，H5）
 - 执行器：`runGates`（`runner.ts`）——按 order 升序；deny 单调（下游 abstain 不得改回 allow）+ ask 枚举预留 fail-closed = deny；决策浅冻结
 - 生效集：`getEffectiveGates(projectRoot)`（`effective-gates.ts`）——对齐 getEffectiveConstraints 裁剪模式：config.yml `gates.order` 重排 + `gates.<id>.enabled:false` 移除；enabled 段未注册校验与裁剪走 core/effective-set 共享筛选器（throw 模式），order 重排与重复 id 检测留本侧
-- checker-as-guard 接线点：`createCheckerGate(check)`（`checker-gate.ts`）——ConstraintCheck → Gate（studio #129 随动）；false→deny，true/'skip'→abstain；env 经 `buildCheckEnv(..., 'none')` 构造（显式不接证据，语义见 core/constraints/checkers/types.ts 工厂 doc）
+- checker-as-guard 接线点：`createCheckerGate(check)`（`checker-gate.ts`）——ConstraintCheck → Gate（studio #129 随动）；判定经唯一归一点 `normalizeCheckOutcome`（harness#119/ADR-0016）：`false` 或 `CheckDetail.pass=false` → deny（证据行随理由带出），`true`（含 pass+提示）/'skip' → abstain；env 经 `buildCheckEnv(..., 'none')` 构造（显式不接证据，语义见 core/constraints/checkers/types.ts 工厂 doc）
 - 门禁类：`ReviewGate` / `SecurityGate` / `PerformanceGate` / `ContractGate` / `SpecAcceptanceGate` / `CommandGate`（各自执行细节私有，保留 `check()`/`scan()` 报告方法）；SpecAcceptanceGate 的 runner 输出解读与 e2e 判负都从 `core/validators/test-output.ts` 的 `judgeTestRun` 取（解析收口 ADR-0012、判定依据 ADR-0014，本层既不自带正则也不自写判定 `if`）
 - `types.ts` — GateResult（报告结构，保留）/ GateContext / GateDecision 等公共类型 + 报告构造器 `pass` / `fail` / `fromError`（动态 passed 走 `gateResult`）：timestamp 与 duration 口径唯一落点，门禁实现禁止手写 GateResult 字面量（duration 是可选字段，漏写无编译期报错）
 - 便捷工厂函数：createReviewGate / createSecurityGate / createPerformanceGate / createContractGate / createSpecAcceptanceGate / createCommandGate
@@ -23,11 +23,12 @@
 - deny 单调是接口契约：决策浅冻结，下游不得改写上游决策
 - `runGates` 是 Gate 链语义的**参考实现**（deny 单调 / ask fail-closed / 全决策浅冻结）：仓内暂无生产调用方（harness CLI 文件驱动逐命令执行，studio `runCompletionGuards` 经 checker-gate 复用语义但不 import），消费方只有测试。「deny 后短路跳过剩余门禁」类优化在出现真实消费者前不做——它与「按执行顺序的全部决策」报告契约直接冲突，短路等于改 GateResult 语义（harness#115 裁决，防后续评审重复提议）
 - ask 枚举预留：暂无实现，runGates fail-closed 按 deny 计
-- **收到的根要传到自己每个 IO/执行点（harness#95）**：门禁只认 `context.projectPath`，内部相对子路径一律锚到它（`SpecAcceptanceGate` 的 tasksPath、`ContractGate` 的 contractPath、e2e/scan/benchmark 的 `cwd`），禁止「根已传入却又取 cwd」、禁止 `xxxPath: './…'` 相对默认值——否则 `-p` 半失效且表现为假绿（acceptance 的「无 tasks.yml 即跳过」= passed:true）。本层唯一保留的 cwd 站点是 `checker-gate` 对 `ctx.projectPath` 的缺省兜底（豁免理由见守护表）。约定正本与两道机器可检的闸见 `src/cli/commands/CONTEXT.md`
+- **收到的根要传到自己每个 IO/执行点（harness#95）**：门禁只认 `context.projectPath`，内部相对子路径一律锚到它（`SpecAcceptanceGate` 的 tasksPath、`ContractGate` 的 contractPath、e2e/scan 的 `cwd`），禁止「根已传入却又取 cwd」、禁止 `xxxPath: './…'` 相对默认值——否则 `-p` 半失效且表现为假绿（acceptance 的「无 tasks.yml 即跳过」= passed:true）。本层唯一保留的 cwd 站点是 `checker-gate` 对 `ctx.projectPath` 的缺省兜底（豁免理由见守护表）。约定正本与两道机器可检的闸见 `src/cli/commands/CONTEXT.md`
 
 ## 注意事项
 - 门禁系统不包含业务逻辑，只提供检查能力
 - `acceptance.ts` 的 13 处 return 是 `AcceptanceGateResult`（无 gate/duration 字段，`evaluate()` 归一化为 GateResult 报告——设计如此，见该方法注释），不是 GateResult 字面量，故不套 `pass`/`fail` 构造器；改成 GateResult 会动公共类型形状
-- 统一的是决策协议（id/order/三态），执行细节（gh pr view/正则黑名单/OpenAPI diff/benchmark）私有——不要把执行细节塞进 Gate 接口
+- 统一的是决策协议（id/order/三态），执行细节（gh pr view/正则黑名单/OpenAPI diff/json-summary 覆盖率）私有——不要把执行细节塞进 Gate 接口
+- `PerformanceGate` 只执法有真实现的维度（coverage 走 json-summary、bundleSize 走 dist 测量）；responseTime/memoryUsage/throughput 三维无真实现（原 Math.random 伪造 + 未接线的 runBenchmark）已随 benchmark 机制整体删除（ADR-0018，架构评审候选2）
 - config.yml gates 段为新增面：引用未注册 id 直接抛错（无历史残留配置需兼容）
 - CommandGate 为命令黑名单检查(SEC-006)

package/src/gates/__tests__/checker-gate.test.ts

@@ -37,6 +37,30 @@ describe('createCheckerGate', () => {
     expect(decision.result.message).toContain('跳过');
   });
 
+  // harness#119：CheckDetail 形状接入后，映射必须经 normalizeCheckOutcome——
+  // 写 `outcome !== false` 会把 { pass: false } 读成「不是 false」= 通过，deny 静默丢失
+  it('CheckDetail{pass:false} → deny，理由带出证据行', async () => {
+    const gate = createCheckerGate({
+      id: 'detail-fail',
+      evaluate: () => ({ pass: false, evidence: ['src/gone.ts'] }),
+    });
+    const decision = await gate.evaluate(ctx);
+    expect(decision.status).toBe('deny');
+    expect(decision.result.passed).toBe(false);
+    expect(decision.result.message).toContain('判定违规');
+    expect(decision.result.message).toContain('src/gone.ts');
+  });
+
+  it('CheckDetail{pass:true} + 提示证据 → abstain（提示不得变拦截）', async () => {
+    const gate = createCheckerGate({
+      id: 'detail-hint',
+      evaluate: () => ({ pass: true, evidence: ['仓库级漂移 1 项', 'src/drifted.ts'] }),
+    });
+    const decision = await gate.evaluate(ctx);
+    expect(decision.status).toBe('abstain');
+    expect(decision.result.message).toContain('通过');
+  });
+
   it('决策浅冻结（单调语义契约）', async () => {
     const gate = createCheckerGate(contextFlag('flag-freeze', () => true));
     const decision = await gate.evaluate(ctx);

package/src/gates/__tests__/performance.test.ts

@@ -37,21 +37,16 @@ describe('PerformanceGate', () => {
       const defaultGate = new PerformanceGate();
       const config = defaultGate.getConfig();
       expect(config.enabled).toBe(true);
-      expect(config.warmupRuns).toBe(2);
-      expect(config.measureRuns).toBe(5);
+      expect(config.thresholds).toEqual({});
     });
 
     it('should accept custom config', () => {
       const customGate = new PerformanceGate({
         enabled: false,
-        warmupRuns: 3,
-        measureRuns: 10,
         coverageTimeout: 60000,
       });
       const config = customGate.getConfig();
       expect(config.enabled).toBe(false);
-      expect(config.warmupRuns).toBe(3);
-      expect(config.measureRuns).toBe(10);
       expect(config.coverageTimeout).toBe(60000);
     });
   });
@@ -164,17 +159,16 @@ describe('PerformanceGate', () => {
 
     it('should include metrics in result', async () => {
       const strictGate = new PerformanceGate({
-        thresholds: {
-          maxResponseTime: 1000,
-          maxMemoryUsage: 500,
-        },
+        thresholds: { maxBundleSize: 1000 },
       });
 
+      mockFs.readdir.mockResolvedValueOnce(['bundle.js'] as any);
+      mockFs.stat.mockResolvedValueOnce({ isFile: () => true, size: 500 * 1024 } as any);
+
       const result = await strictGate.check(baseContext);
 
       expect(result.details?.metrics).toBeDefined();
-      expect(result.details?.metrics.responseTime).toBeDefined();
-      expect(result.details?.metrics.memoryUsage).toBeDefined();
+      expect(result.details?.metrics.bundleSize).toBeDefined();
     });
   });
 
@@ -257,66 +251,6 @@ describe('PerformanceGate', () => {
     });
   });
 
-  describe('runBenchmark()', () => {
-    it('should return benchmark results', async () => {
-      mockExec.mockImplementation((cmd, opts, callback) => {
-        callback(null, { stdout: '', stderr: '' });
-      });
-
-      const result = await gate.runBenchmark(baseContext);
-
-      expect(result.avgResponseTime).toBeGreaterThanOrEqual(0);
-      expect(result.avgMemoryUsage).toBeGreaterThanOrEqual(0);
-    });
-
-    it('should run warmup and measure runs', async () => {
-      const customGate = new PerformanceGate({
-        warmupRuns: 1,
-        measureRuns: 2,
-        benchmarkCommand: 'npm run bench',
-      });
-
-      // Each exec call should succeed
-      mockExec.mockImplementation((cmd, opts, callback) => {
-        callback(null, { stdout: '', stderr: '' });
-      });
-
-      await customGate.runBenchmark(baseContext);
-
-      // warmupRuns + measureRuns = 3 calls
-      expect(mockExec).toHaveBeenCalledTimes(3);
-    });
-
-    it('should use custom benchmark command', async () => {
-      const customGate = new PerformanceGate({
-        benchmarkCommand: 'npm run benchmark',
-      });
-
-      mockExec.mockImplementation((cmd, opts, callback) => {
-        expect(cmd).toContain('npm run benchmark');
-        callback(null, { stdout: '', stderr: '' });
-      });
-
-      await customGate.runBenchmark(baseContext);
-    });
-
-    it('should handle benchmark error', async () => {
-      const errorGate = new PerformanceGate({
-        warmupRuns: 1,
-        benchmarkCommand: 'npm run bench',
-      });
-
-      // Mock exec to fail
-      mockExec.mockImplementationOnce((cmd, opts, callback) => {
-        callback(new Error('Benchmark failed'), null);
-      });
-
-      const result = await errorGate.runBenchmark(baseContext);
-
-      expect(result.error).toContain('failed');
-    });
-  });
-
   describe('setThresholds()', () => {
     it('should update thresholds', () => {
       gate.setThresholds({
@@ -346,12 +280,10 @@ describe('PerformanceGate', () => {
     it('should update timeouts', () => {
       gate.setTimeouts({
         coverage: 30000,
-        benchmark: 20000,
       });
 
       const config = gate.getConfig();
       expect(config.coverageTimeout).toBe(30000);
-      expect(config.benchmarkTimeout).toBe(20000);
     });
   });
 

package/src/gates/checker-gate.ts

@@ -8,7 +8,7 @@
  */
 
 import type { ConstraintCheck } from '../core/constraints/checkers';
-import { buildCheckEnv } from '../core/constraints/checkers';
+import { buildCheckEnv, normalizeCheckOutcome } from '../core/constraints/checkers';
 import type { Gate, GateContext, GateDecision } from './types';
 import { gateResult } from './types';
 import { decisionFromResult } from './decision';
@@ -16,7 +16,8 @@ import { decisionFromResult } from './decision';
 /**
  * 将已注册 checker 适配为统一 Gate（checker-as-guard 接线点）
  *
- * 判定映射：false（违反）→ deny；true（满足）/ 'skip'（未评估）→ abstain。
+ * 判定映射：violated（false 或 CheckDetail.pass=false）→ deny；
+ * 满足 / 'skip'（未评估）→ abstain。违规证据随理由带出。
  *
  * @param check 已注册的 ConstraintCheck（经 checkers 注册表取回）
  * @param order 门禁顺序（供 guard 链排序）
@@ -29,19 +30,14 @@ export function createCheckerGate(check: ConstraintCheck, order = 0): Gate {
       const startTime = Date.now();
       const projectPath = ctx.projectPath || process.cwd();
       const env = buildCheckEnv({ operation: 'manual', projectPath }, 'none');
-      const outcome = await check.evaluate(env);
-      return decisionFromResult(
-        gateResult(
-          check.id,
-          outcome !== false,
-          outcome === false
-            ? `checker "${check.id}" 判定违规`
-            : outcome === 'skip'
-              ? `checker "${check.id}" 跳过（证据未接线）`
-              : `checker "${check.id}" 通过`,
-          startTime
-        )
-      );
+      const outcome = normalizeCheckOutcome(await check.evaluate(env));
+      const evidence = outcome.evidence.map((e) => `\n  - ${e}`).join('');
+      const reason = outcome.skipped
+        ? `checker "${check.id}" 跳过（证据未接线）`
+        : outcome.satisfied
+          ? `checker "${check.id}" 通过`
+          : `checker "${check.id}" 判定违规${evidence}`;
+      return decisionFromResult(gateResult(check.id, outcome.satisfied, reason, startTime));
     },
   };
 }

package/src/gates/definitions.ts

@@ -111,8 +111,6 @@ export const GATE_DEFINITIONS: GateDefinition[] = [
         { flags: '--coverage-threshold <n>', description: '覆盖率阈值', defaultValue: '80' },
         { flags: '--bundle', description: '检查打包大小', defaultValue: false },
         { flags: '--bundle-threshold <n>', description: '打包大小阈值 (KB)', defaultValue: '500' },
-        { flags: '--benchmark', description: '运行基准测试', defaultValue: false },
-        { flags: '--benchmark-timeout <n>', description: '基准测试超时（秒）', defaultValue: '60' },
       ],
       action: { module: 'performance', export: 'performance' },
       mapActionArgs: (_positionals, options) => [
@@ -122,8 +120,6 @@ export const GATE_DEFINITIONS: GateDefinition[] = [
           coverageThreshold: parseInt(String(options.coverageThreshold), 10),
           bundle: options.bundle,
           bundleThreshold: parseInt(String(options.bundleThreshold), 10),
-          benchmark: options.benchmark,
-          benchmarkTimeout: parseInt(String(options.benchmarkTimeout), 10),
         },
       ],
     },

package/src/gates/performance.ts

@@ -1,12 +1,14 @@
 /**
  * 性能门禁
- * 
- * 检查性能指标：
- * - 响应时间
- * - 内存使用
- * - 测试覆盖率
- * - 打包大小
- * 
+ *
+ * 检查性能指标（架构评审候选2：只留有真实现的维度）：
+ * - 测试覆盖率（json-summary）
+ * - 打包大小（dist 目录测量）
+ *
+ * 响应时间/内存使用/吞吐量维度已删除：原实现用 Math.random() 伪造指标并据此判负，
+ * runBenchmark 的真实现从未被 check() 调用且语义可疑（量的是 harness 进程自己的
+ * heap）——零真实消费者的维度按 ADR-0015 同构判例删薄（ADR-0018）。
+ *
  * 改进：
  * - 添加超时机制
  * - 改进错误处理
@@ -23,8 +25,6 @@ import { decisionFromResult } from './decision';
 // 默认超时时间（毫秒）
 const DEFAULT_TIMEOUTS = {
   coverage: 120000,  // 覆盖率测试：2分钟
-  benchmark: 60000,  // 基准测试：1分钟
-  bundle: 10000,     // 打包大小：10秒
 };
 
 /**
@@ -33,8 +33,6 @@ const DEFAULT_TIMEOUTS = {
 export interface ExtendedPerformanceGateConfig extends PerformanceGateConfig {
   /** 覆盖率测试超时（毫秒） */
   coverageTimeout?: number;
-  /** 基准测试超时（毫秒） */
-  benchmarkTimeout?: number;
 }
 
 /**
@@ -48,12 +46,8 @@ export class PerformanceGate implements Gate {
   constructor(config: Partial<ExtendedPerformanceGateConfig> = {}) {
     this.config = {
       enabled: config.enabled ?? true,
-      benchmarkCommand: config.benchmarkCommand ?? '',
       thresholds: config.thresholds ?? {},
-      warmupRuns: config.warmupRuns ?? 2,
-      measureRuns: config.measureRuns ?? 5,
       coverageTimeout: config.coverageTimeout ?? DEFAULT_TIMEOUTS.coverage,
-      benchmarkTimeout: config.benchmarkTimeout ?? DEFAULT_TIMEOUTS.benchmark,
     };
   }
 
@@ -80,20 +74,6 @@ export class PerformanceGate implements Gate {
       const failures: string[] = [];
       const warnings: string[] = [];
 
-      // 检查响应时间
-      if (thresholds.maxResponseTime && metrics.responseTime !== undefined) {
-        if (metrics.responseTime > thresholds.maxResponseTime) {
-          failures.push(`响应时间 ${metrics.responseTime}ms > ${thresholds.maxResponseTime}ms`);
-        }
-      }
-
-      // 检查内存使用
-      if (thresholds.maxMemoryUsage && metrics.memoryUsage !== undefined) {
-        if (metrics.memoryUsage > thresholds.maxMemoryUsage) {
-          failures.push(`内存使用 ${metrics.memoryUsage}MB > ${thresholds.maxMemoryUsage}MB`);
-        }
-      }
-
       // 检查覆盖率
       if (thresholds.minCoverage) {
         if (metrics.coverageError) {
@@ -124,8 +104,6 @@ export class PerformanceGate implements Gate {
         startTime,
         {
           metrics: {
-            responseTime: metrics.responseTime,
-            memoryUsage: metrics.memoryUsage,
             coverage: metrics.coverage,
             bundleSize: metrics.bundleSize,
           },
@@ -146,8 +124,6 @@ export class PerformanceGate implements Gate {
     projectPath: string,
     thresholds: PerformanceThresholds
   ): Promise<{
-    responseTime?: number;
-    memoryUsage?: number;
     coverage?: number;
     coverageError?: string;
     bundleSize?: number;
@@ -175,15 +151,6 @@ export class PerformanceGate implements Gate {
       }
     }
 
-    // 模拟响应时间和内存（需要实际基准测试）
-    if (thresholds.maxResponseTime) {
-      metrics.responseTime = Math.floor(Math.random() * 500) + 100;
-    }
-
-    if (thresholds.maxMemoryUsage) {
-      metrics.memoryUsage = Math.floor(Math.random() * 200) + 50;
-    }
-
     return metrics;
   }
 
@@ -258,78 +225,11 @@ export class PerformanceGate implements Gate {
    */
   private formatMetrics(metrics: any): string {
     const parts: string[] = [];
-    if (metrics.responseTime !== undefined) parts.push(`响应时间=${metrics.responseTime}ms`);
-    if (metrics.memoryUsage !== undefined) parts.push(`内存=${metrics.memoryUsage}MB`);
     if (metrics.coverage !== undefined) parts.push(`覆盖率=${metrics.coverage}%`);
     if (metrics.bundleSize !== undefined) parts.push(`打包=${metrics.bundleSize}KB`);
     return parts.join(', ') || '无指标';
   }
 
-  /**
-   * 运行基准测试（带超时）
-   */
-  async runBenchmark(context: GateContext): Promise<{
-    avgResponseTime: number;
-    avgMemoryUsage: number;
-    minResponseTime: number;
-    maxResponseTime: number;
-    error?: string;
-  }> {
-    const results: Array<{ responseTime: number; memoryUsage: number }> = [];
-
-    try {
-      // 预热运行
-      for (let i = 0; i < this.config.warmupRuns; i++) {
-        await this.singleBenchmark(context);
-      }
-
-      // 测量运行
-      for (let i = 0; i < this.config.measureRuns; i++) {
-        const result = await this.singleBenchmark(context);
-        results.push(result);
-      }
-
-      const responseTimes = results.map(r => r.responseTime);
-      const memoryUsages = results.map(r => r.memoryUsage);
-
-      return {
-        avgResponseTime: responseTimes.reduce((a, b) => a + b, 0) / responseTimes.length,
-        avgMemoryUsage: memoryUsages.reduce((a, b) => a + b, 0) / memoryUsages.length,
-        minResponseTime: Math.min(...responseTimes),
-        maxResponseTime: Math.max(...responseTimes),
-      };
-    } catch (error: any) {
-      return {
-        avgResponseTime: 0,
-        avgMemoryUsage: 0,
-        minResponseTime: 0,
-        maxResponseTime: 0,
-        error: error.message || '基准测试失败',
-      };
-    }
-  }
-
-  /**
-   * 单次基准测试（带超时）
-   */
-  private async singleBenchmark(context: GateContext): Promise<{ responseTime: number; memoryUsage: number }> {
-    const start = Date.now();
-
-    // 如果有基准测试命令，运行它
-    if (this.config.benchmarkCommand || context.benchmarkCommand) {
-      await execAsync(this.config.benchmarkCommand || context.benchmarkCommand!, {
-        cwd: context.projectPath,
-        timeout: this.config.benchmarkTimeout,
-        killSignal: 'SIGTERM',
-      });
-    }
-
-    const responseTime = Date.now() - start;
-    const memoryUsage = process.memoryUsage().heapUsed / 1024 / 1024;
-
-    return { responseTime, memoryUsage };
-  }
-
   /**
    * 设置阈值
    */
@@ -342,10 +242,8 @@ export class PerformanceGate implements Gate {
    */
   setTimeouts(options: {
     coverage?: number;
-    benchmark?: number;
   }): void {
     if (options.coverage) this.config.coverageTimeout = options.coverage;
-    if (options.benchmark) this.config.benchmarkTimeout = options.benchmark;
   }
 
   /**