@dommaker/harness 1.5.0 → 1.7.0

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

@@ -7,15 +7,13 @@
  * 「过了没」的判定依据不在本文件：唯一入口是 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,
   PassesGateCheckResult,
   PassesGateViolation,
@@ -30,24 +28,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 +80,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 +151,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 使用）
    *
@@ -294,7 +182,7 @@ export class PassesGate {
         };
       }
 
-      const result = await this.runTest(workDir, undefined, testCommand);
+      const result = await this.runTest(workDir, testCommand);
       const duration = Date.now() - startTime;
 
       // 解析测试数量
@@ -329,7 +217,7 @@ export class PassesGate {
   /**
    * 运行测试
    */
-  private async runTest(workDir: string, _task?: DynamicTask, command?: string): Promise<TaskTestResult> {
+  private async runTest(workDir: string, command?: string): Promise<TaskTestResult> {
     const testCommand = command || this.config.testCommand || await detectTestCommand(workDir);
     const timestamp = new Date();
 
@@ -404,43 +292,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

@@ -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__/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/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;
   }
 
   /**

package/src/gates/types.ts

@@ -133,7 +133,6 @@ export interface GateContext {
   
   // Performance Gate
   performanceThresholds?: PerformanceThresholds;
-  benchmarkCommand?: string;
   
   // Contract Gate
   oldContractPath?: string;
@@ -151,14 +150,12 @@ export interface GateContext {
 }
 
 /**
- * 性能阈值
+ * 性能阈值（架构评审候选2：只留有真实现的维度——coverage 走 json-summary、
+ * bundleSize 走 dist 目录测量；responseTime/memoryUsage/throughput 无真实现已删）
  */
 export interface PerformanceThresholds {
-  maxResponseTime?: number;   // ms
-  maxMemoryUsage?: number;    // MB
   minCoverage?: number;       // %
   maxBundleSize?: number;     // KB
-  minThroughput?: number;     // req/s
 }
 
 /**
@@ -187,10 +184,7 @@ export interface SecurityGateConfig {
  */
 export interface PerformanceGateConfig {
   enabled: boolean;
-  benchmarkCommand?: string;
   thresholds: PerformanceThresholds;
-  warmupRuns: number;
-  measureRuns: number;
 }
 
 /**