@dommaker/harness 0.19.0 → 1.0.0

package/src/core/constraints/checker.ts

@@ -17,7 +17,7 @@ import {
   ConstraintViolationError,
 } from '../../types/constraint';
 import type { ExecutionTrace } from '../../types/trace';
-import { IRON_LAWS, GUIDELINES, TIPS, PROMPTS } from './definitions';
+import { IRON_LAWS, GUIDELINES, PROMPTS } from './definitions';
 import type { MergedConstraintsConfig } from '../../types/project-config';
 import { normalizeTriggers } from '../../utils/exec';
 import { runCommand } from '../../utils/exec';
@@ -74,9 +74,6 @@ const NOOP_TRACE_RECORDER: TraceRecorder = { record: () => undefined };
 export class ConstraintChecker {
   private static instance: ConstraintChecker;
 
-  /** 自定义约束配置（项目级） */
-  private customConfig: MergedConstraintsConfig | null = null;
-
   /** 检查结果缓存（S7：src 扫描等重复 I/O，TTL=1s 防跨测试污染） */
   private cache: CheckCache = new CheckCache({ ttlMs: 1000 });
 
@@ -139,31 +136,20 @@ export class ConstraintChecker {
     this.traceRecorder = recorder;
   }
 
-  /**
-   * 设置项目级约束配置
-   *
-   * @deprecated 修改单例状态，多项目并发时存在污染风险。
-   * 请改用 checkConstraints() / beforeExecution() 的 customConfig 参数实现 per-request 隔离。
-   */
-  setCustomConfig(config: MergedConstraintsConfig): void {
-    this.customConfig = config;
-  }
-
   /**
    * 获取当前的约束集合（内置 + 自定义）
    *
-   * @param customConfig 可选，per-request 自定义配置（优先级高于 setCustomConfig 的单例状态）
+   * @param customConfig 可选，per-request 自定义配置；不传则返回内置约束集
    */
   getConstraints(customConfig?: MergedConstraintsConfig | null): {
     ironLaws: Record<string, Constraint & { check: (ctx: ConstraintContext) => Promise<ConstraintResult> }>;
     guidelines: Record<string, Constraint & { check: (ctx: ConstraintContext) => Promise<ConstraintResult> }>;
-    tips: Record<string, Constraint & { check: (ctx: ConstraintContext) => Promise<ConstraintResult> }>;
     prompts: Record<string, Constraint & { check: (ctx: ConstraintContext) => Promise<ConstraintResult> }>;
   } {
-    const config = customConfig ?? this.customConfig;
+    const config = customConfig;
     const source = config
-      ? { ironLaws: config.ironLaws, guidelines: config.guidelines, tips: config.tips, prompts: config.prompts ?? PROMPTS }
-      : { ironLaws: IRON_LAWS, guidelines: GUIDELINES, tips: TIPS, prompts: PROMPTS };
+      ? { ironLaws: config.ironLaws, guidelines: config.guidelines, prompts: config.prompts ?? PROMPTS }
+      : { ironLaws: IRON_LAWS, guidelines: GUIDELINES, prompts: PROMPTS };
 
     // Wire unified check() method on every constraint
     const wire = (constraints: Record<string, Constraint>) => {
@@ -175,7 +161,6 @@ export class ConstraintChecker {
     return {
       ironLaws: wire(source.ironLaws),
       guidelines: wire(source.guidelines),
-      tips: wire(source.tips),
       prompts: wire(source.prompts),
     };
   }
@@ -260,7 +245,6 @@ export class ConstraintChecker {
       case 'guideline':
         return 'warning';
       case 'prompt':
-      case 'tip':
         return 'info';
       default:
         return 'warning';
@@ -350,7 +334,6 @@ export class ConstraintChecker {
   ): {
     ironLaws: Constraint[];
     guidelines: Constraint[];
-    tips: Constraint[];
     prompts: Constraint[];
   } {
     const operations = [context.operation, ...(context.extraTriggers ?? [])];
@@ -368,17 +351,15 @@ export class ConstraintChecker {
     return {
       ironLaws: filterByTrigger(constraints.ironLaws),
       guidelines: filterByTrigger(constraints.guidelines),
-      tips: filterByTrigger(constraints.tips),
       prompts: filterByTrigger(constraints.prompts),
     };
   }
 
   /**
-   * 执行三层约束检查
+   * 执行约束检查
    *
    * - Iron Laws：检查失败立即抛出异常
    * - Guidelines：检查失败记录警告
-   * - Tips：检查失败记录提示
    *
    * @param context 约束上下文
    * @param customConfig 可选，per-request 自定义配置（避免多请求间的单例状态污染）
@@ -395,10 +376,8 @@ export class ConstraintChecker {
       const result: ConstraintCheckResult = {
         ironLaws: [],
         guidelines: [],
-        tips: [],
         passed: true,
         warningCount: 0,
-        tipCount: 0,
       };
 
       const traceCollector = this.traceRecorder;
@@ -431,19 +410,6 @@ export class ConstraintChecker {
         }
       }
 
-      // 3. Tips: 仅记录
-      for (const constraint of Object.values(constraints.tips)) {
-        if (!this.matchesTrigger(constraint, context)) continue;
-
-        const checkResult = await this.check(constraint, context);
-        result.tips.push(checkResult);
-        this.recordTrace(traceCollector, constraint, checkResult, context);
-
-        if (!checkResult.satisfied) {
-          result.tipCount++;
-        }
-      }
-
       return result;
     } finally {
       this.runCache = null;
@@ -451,7 +417,7 @@ export class ConstraintChecker {
   }
 
   /**
-   * S11: 安全全量检查 — 全部三层约束检查，不抛异常
+   * S11: 安全全量检查 — 全部约束检查，不抛异常
    *
    * 区别 checkConstraints(): Iron Law 违规收集在结果中而不是抛异常。
    * 调用方通过 result.passed + result.warningCount 判断状态。
@@ -468,10 +434,8 @@ export class ConstraintChecker {
       const result: ConstraintCheckResult = {
         ironLaws: [],
         guidelines: [],
-        tips: [],
         passed: true,
         warningCount: 0,
-        tipCount: 0,
       };
 
       const traceCollector = this.traceRecorder;
@@ -493,14 +457,6 @@ export class ConstraintChecker {
         if (!checkResult.satisfied) result.warningCount++;
       }
 
-      for (const constraint of Object.values(constraints.tips)) {
-        if (!this.matchesTrigger(constraint, context)) continue;
-        const checkResult = await this.check(constraint, context);
-        result.tips.push(checkResult);
-        this.recordTrace(traceCollector, constraint, checkResult, context);
-        if (!checkResult.satisfied) result.tipCount++;
-      }
-
       return result;
     } finally {
       this.runCache = null;
@@ -549,13 +505,12 @@ export async function checkConstraint(
   const constraint =
     constraints.ironLaws[constraintId] ||
     constraints.guidelines[constraintId] ||
-    constraints.tips[constraintId] ||
     constraints.prompts[constraintId];
 
   if (!constraint) {
     return {
       id: constraintId,
-      level: 'tip',
+      level: 'guideline',
       satisfied: false,
       message: `未知的约束: ${constraintId}`,
       checkedAt: new Date(),

package/src/core/constraints/definitions.ts

@@ -4,8 +4,6 @@
  * kind 二元模型（ADR-0001）：
  * - IRON_LAWS / GUIDELINES：check 层，必须带真实 checker（注册表闭环）
  * - PROMPTS：prompt 层，纯文本注入，不占检查位
- * - TIPS：已退役，导出空表仅为在途消费者（capabilities-syncer）编译兼容，
- *   后续阶段随其改造一并删除
  *
  * 工单 20：字面量定义按层拆至 ./definitions/{iron-laws,guidelines,prompts}.ts；
  * 本文件保持原路径做薄聚合（studio rule-scanner 按此路径解析，P0 #8）。
@@ -16,12 +14,6 @@ import { IRON_LAWS } from './definitions/iron-laws';
 import { GUIDELINES } from './definitions/guidelines';
 import { PROMPTS } from './definitions/prompts';
 
-/**
- * @deprecated TIPS 已退役（ADR-0001），恒为空表。
- * 仅为在途 capabilities-syncer 编译兼容保留，后续阶段删除。
- */
-export const TIPS: Record<string, Constraint> = {};
-
 export { IRON_LAWS, GUIDELINES, PROMPTS };
 
 // ========================================

package/src/core/constraints/doc-freshness/runner.ts

@@ -44,7 +44,6 @@ interface RunContext {
   constraintCounts?: {
     ironLaws?: number;
     guidelines?: number;
-    tips?: number;
   };
 }
 
@@ -58,7 +57,7 @@ export class FreshnessRunner {
   runAll(
     config: DocFreshnessConfig,
     projectPath: string,
-    ctx?: { requiredDirs?: string[]; constraintCounts?: { ironLaws?: number; guidelines?: number; tips?: number } }
+    ctx?: { requiredDirs?: string[]; constraintCounts?: { ironLaws?: number; guidelines?: number } }
   ): FreshnessCheckResult[] {
     if (config.enabled === false) return [];
     if (!config.checks || config.checks.length === 0) return [];

package/src/core/constraints/index.ts

@@ -2,12 +2,11 @@
  * 约束模块入口
  */
 
-// 约束定义（kind 二元：check 层 + prompt 层；TIPS 已退役，空表仅为在途兼容保留）
+// 约束定义（kind 二元：check 层 + prompt 层）
 export {
   IRON_LAWS,
   GUIDELINES,
   PROMPTS,
-  TIPS,
   getAllConstraints,
   findConstraintsByTrigger,
   getConstraint,

package/src/core/constraints/interceptor.ts

@@ -115,14 +115,13 @@ export class ConstraintInterceptor {
     const allConstraints = [
       ...Object.values(constraints.ironLaws),
       ...Object.values(constraints.guidelines),
-      ...Object.values(constraints.tips),
     ].filter(c => c.kind !== 'prompt');
 
     const applicableConstraints = allConstraints.filter(
       (c) => normalizeTriggers<ConstraintTrigger>(c.trigger).includes(trigger)
     );
 
-    const order: Record<ConstraintLevel, number> = { iron_law: 0, guideline: 1, prompt: 2, tip: 3 };
+    const order: Record<ConstraintLevel, number> = { iron_law: 0, guideline: 1, prompt: 2 };
     const ordered = applicableConstraints.sort((a, b) => order[a.level] - order[b.level]);
 
     for (const constraint of ordered) {
@@ -200,10 +199,6 @@ export class ConstraintInterceptor {
 
 export const constraintInterceptor = ConstraintInterceptor.getInstance();
 
-// 注册内置 executors
-import { registerDefaultExecutors } from './default-executors';
-registerDefaultExecutors();
-
 export async function interceptOperation(
   trigger: ConstraintTrigger,
   context: ConstraintContext

package/src/core/effective-constraints.ts

@@ -29,7 +29,6 @@ export function getEffectiveConstraints(projectRoot: string = process.cwd()): Co
   return [
     ...Object.values(merged.ironLaws),
     ...Object.values(merged.guidelines),
-    ...Object.values(merged.tips),
     ...Object.values(merged.prompts ?? {}),
   ];
 }

package/src/core/project-config-loader.ts

@@ -172,7 +172,6 @@ export class ProjectConfigLoader {
     const result: MergedConstraintsConfig = {
       ironLaws: presetMerged.ironLaws,
       guidelines: presetMerged.guidelines,
-      tips: {},
       prompts: presetMerged.prompts ?? {},
       disabled: [...presetMerged.disabled],
       custom: [],
@@ -196,7 +195,6 @@ export class ProjectConfigLoader {
           // 从对应层级中移除
           delete result.ironLaws[constraintId];
           delete result.guidelines[constraintId];
-          delete result.tips[constraintId];
           delete result.prompts![constraintId];
         }
       }
@@ -225,7 +223,6 @@ export class ProjectConfigLoader {
           ];
           if (result.ironLaws[id]) result.ironLaws[id] = constraint;
           if (result.guidelines[id]) result.guidelines[id] = constraint;
-          if (result.tips[id]) result.tips[id] = constraint;
           if (result.prompts![id]) result.prompts![id] = constraint;
           continue;
         }
@@ -255,9 +252,6 @@ export class ProjectConfigLoader {
         case 'prompt':
           result.prompts![id] = constraint;
           break;
-        case 'tip':
-          result.tips[id] = constraint;
-          break;
       }
     }
 
@@ -285,7 +279,7 @@ export class ProjectConfigLoader {
     id: string,
     merged: MergedConstraintsConfig
   ): Constraint | undefined {
-    return merged.ironLaws[id] || merged.guidelines[id] || merged.tips[id] || merged.prompts?.[id];
+    return merged.ironLaws[id] || merged.guidelines[id] || merged.prompts?.[id];
   }
 
   /**

package/src/dashboard/stats.ts

@@ -4,7 +4,7 @@
  * 纯函数，从原始数据计算统计指标
  */
 
-import type { KnowledgeEntry, KnowledgeType } from '../knowledge/types';
+import type { KnowledgeEntry, KnowledgeSubsystem } from '../knowledge/types';
 import type { KnowledgeOverview, KnowledgeFlow } from './types';
 
 /**
@@ -36,7 +36,7 @@ export function computeKnowledgeOverview(entries: KnowledgeEntry[]): KnowledgeOv
  * 按类型分组统计
  */
 function computeByType(entries: KnowledgeEntry[]): KnowledgeOverview['byType'] {
-  const typeMap = new Map<KnowledgeType, { total: number; proven: number; verified: number; draft: number }>();
+  const typeMap = new Map<KnowledgeSubsystem, { total: number; proven: number; verified: number; draft: number }>();
 
   for (const entry of entries) {
     const existing = typeMap.get(entry.type) || { total: 0, proven: 0, verified: 0, draft: 0 };

package/src/dashboard/types.ts

@@ -4,7 +4,7 @@
  * harness 提供数据，studio 负责渲染
  */
 
-import type { KnowledgeType } from '../knowledge/types';
+import type { KnowledgeSubsystem } from '../knowledge/types';
 
 // ── 约束分层（原 src/constraints/types，约束分层子系统删除后归位 dashboard）──
 
@@ -28,7 +28,7 @@ export interface ConstraintStats {
 
 export interface KnowledgeOverview {
   byType: Array<{
-    type: KnowledgeType;
+    type: KnowledgeSubsystem;
     total: number;
     proven: number;
     verified: number;

package/src/failure/constraint-handler.ts

@@ -108,10 +108,8 @@ export class ConstraintViolationHandler {
       const empty: ConstraintCheckResult = {
         ironLaws: [],
         guidelines: [],
-        tips: [],
         passed: false,
         warningCount: 0,
-        tipCount: 0,
       };
       return {
         strategy: 'COLLECT',

package/src/gates/CONTEXT.md

@@ -1,27 +1,30 @@
 # gates/
 
 ## 职责
-质量门禁系统：6 种门禁检查（验收/命令/契约/性能/审查/安全）。
+质量门禁系统：6 种门禁检查（验收/命令/契约/性能/审查/安全）。统一 Gate 三态协议 + 注册表闭环 + 声明式生效集（G1）。
 
 ## 核心导出
-- `ReviewGate` — 代码审查门禁
-- `SecurityGate` — 安全检查门禁
-- `PerformanceGate` — 性能门禁
-- `ContractGate` — 契约(OpenAPI)门禁
-- `SpecAcceptanceGate` — Spec 验收门禁
-- `CommandGate` — 命令黑名单门禁
-- `types.ts` — GateResult / GateContext 等公共类型
-- 便捷工厂函数：createReviewGate / createSecurityGate / createPerformanceGate / createContractGate / createSpecAcceptanceGate
+- 统一协议：`Gate{id, order, evaluate(ctx)}` → `GateDecision{status: deny|abstain|ask, result: GateResult}`（`types.ts`；`decisionFromResult` 报告→决策映射，浅冻结）
+- 注册表：`gateRegistry`（`registry.ts`）——定义即注册 + 构建期双向闭环（定义无实现/实现无定义/重复 id → 加载期抛错）；`getGate`（未注册抛错）/`listRegisteredGates`/`registeredGateCount`
+- 定义表：`GATE_DEFINITIONS`（`definitions.ts`）——id/description/默认 order/CLI 元数据；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` 移除；引用未注册 id 抛错
+- checker-as-guard 接线点：`createCheckerGate(check)`（`checker-gate.ts`）——ConstraintCheck → Gate（studio #129 随动）；false→deny，true/'skip'→abstain
+- 门禁类：`ReviewGate` / `SecurityGate` / `PerformanceGate` / `ContractGate` / `SpecAcceptanceGate` / `CommandGate`（各自执行细节私有，保留 `check()`/`scan()` 报告方法）
+- `types.ts` — GateResult（报告结构，保留）/ GateContext / GateDecision 等公共类型
+- 便捷工厂函数：createReviewGate / createSecurityGate / createPerformanceGate / createContractGate / createSpecAcceptanceGate / createCommandGate
 
 ## 依赖关系
-- 依赖 `src/core/` 类型(GateResult)
+- 依赖 `src/core/`（effective-gates 读 project-config-loader；checker-gate 适配 checkers 注册表类型）
 - 依赖 `src/types/` 公共类型
 
 ## 约定
-- 所有门禁实现 GateResult 接口
-- 新门禁必须配 CLI 命令 + 测试文件
-- 工厂函数在 index.ts 中统一导出
+- 新门禁必须：① 在 `definitions.ts` 补 GateDefinition（含 CLI 元数据）② 在 `registry.ts` IMPLEMENTATIONS 注册实现（缺一 → 加载期抛错）③ 实现统一 Gate 接口（evaluate 产三态决策，报告走 GateResult）④ 配 CLI 命令（命令实现文件 + CLI 元数据的 module+export 引用，bin 由定义表驱动生成，不再手写块）+ 测试文件
+- deny 单调是接口契约：决策浅冻结，下游不得改写上游决策
+- ask 枚举预留：暂无实现，runGates fail-closed 按 deny 计
 
 ## 注意事项
 - 门禁系统不包含业务逻辑，只提供检查能力
+- 统一的是决策协议（id/order/三态），执行细节（gh pr view/正则黑名单/OpenAPI diff/benchmark）私有——不要把执行细节塞进 Gate 接口
+- config.yml gates 段为新增面：引用未注册 id 直接抛错（无历史残留配置需兼容）
 - CommandGate 为命令黑名单检查(SEC-006)

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

@@ -0,0 +1,45 @@
+/**
+ * checker-as-guard 接线点测试（G1 / studio #129 随动）
+ */
+
+import { createCheckerGate } from '../checker-gate';
+import { contextFlag, contextEvidenceFlag } from '../../core/constraints/checkers/types';
+
+describe('createCheckerGate', () => {
+  const ctx = { projectId: 'p', projectPath: '/tmp/project' };
+
+  it('checker 通过（true）→ abstain', async () => {
+    const gate = createCheckerGate(contextFlag('flag-pass', () => true), 7);
+    expect(gate.id).toBe('flag-pass');
+    expect(gate.order).toBe(7);
+
+    const decision = await gate.evaluate(ctx);
+    expect(decision.status).toBe('abstain');
+    expect(decision.result.gate).toBe('flag-pass');
+    expect(decision.result.passed).toBe(true);
+    expect(decision.result.message).toContain('通过');
+  });
+
+  it('checker 违规（false）→ deny', async () => {
+    const gate = createCheckerGate(contextFlag('flag-fail', () => false));
+    const decision = await gate.evaluate(ctx);
+    expect(decision.status).toBe('deny');
+    expect(decision.result.passed).toBe(false);
+    expect(decision.result.message).toContain('判定违规');
+  });
+
+  it('证据未接线（skip）→ abstain（不阻断）', async () => {
+    const gate = createCheckerGate(
+      contextEvidenceFlag('flag-skip', () => undefined)
+    );
+    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);
+    expect(Object.isFrozen(decision)).toBe(true);
+  });
+});

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

@@ -0,0 +1,73 @@
+/**
+ * ContractGate 测试（门禁规则：每个门禁必须有测试文件）
+ */
+
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { ContractGate } from '../contract';
+
+const VALID_SPEC = [
+  'openapi: 3.0.0',
+  'info:',
+  '  title: Test API',
+  '  version: 1.0.0',
+  'paths:',
+  '  /users:',
+  '    get: {}',
+].join('\n');
+
+const INVALID_SPEC = ['info:', '  title: Test API', 'paths:', '  /users:', '    get: {}'].join('\n');
+
+describe('ContractGate', () => {
+  let dir: string;
+
+  beforeEach(() => {
+    dir = fs.mkdtempSync(path.join(os.tmpdir(), 'harness-gate-contract-'));
+  });
+
+  afterEach(() => {
+    fs.rmSync(dir, { recursive: true, force: true });
+  });
+
+  it('有效 OpenAPI → check 通过', async () => {
+    fs.writeFileSync(path.join(dir, 'openapi.yaml'), VALID_SPEC);
+    const result = await new ContractGate().check({ projectId: 'p', projectPath: dir });
+    expect(result.passed).toBe(true);
+  });
+
+  it('缺 openapi 版本 → check 失败', async () => {
+    fs.writeFileSync(path.join(dir, 'openapi.yaml'), INVALID_SPEC);
+    const result = await new ContractGate().check({ projectId: 'p', projectPath: dir });
+    expect(result.passed).toBe(false);
+  });
+
+  it('契约文件缺失 → 跳过（passed）', async () => {
+    const result = await new ContractGate().check({ projectId: 'p', projectPath: dir });
+    expect(result.passed).toBe(true);
+    expect(result.message).toContain('未找到契约文件');
+  });
+
+  describe('统一接口 evaluate', () => {
+    it('有效契约 → abstain（冻结决策）', async () => {
+      fs.writeFileSync(path.join(dir, 'openapi.yaml'), VALID_SPEC);
+      const decision = await new ContractGate().evaluate({ projectId: 'p', projectPath: dir });
+      expect(decision.status).toBe('abstain');
+      expect(decision.result.gate).toBe('contract');
+      expect(Object.isFrozen(decision)).toBe(true);
+    });
+
+    it('无效契约 → deny', async () => {
+      fs.writeFileSync(path.join(dir, 'openapi.yaml'), INVALID_SPEC);
+      const decision = await new ContractGate().evaluate({ projectId: 'p', projectPath: dir });
+      expect(decision.status).toBe('deny');
+      expect(decision.result.passed).toBe(false);
+    });
+
+    it('id/order 字段齐备', () => {
+      const gate = new ContractGate();
+      expect(gate.id).toBe('contract');
+      expect(gate.order).toBe(0);
+    });
+  });
+});

package/src/gates/__tests__/effective-gates.test.ts

@@ -0,0 +1,82 @@
+/**
+ * 生效门禁集测试（G1：config.yml order/enabled 裁剪，对齐 getEffectiveConstraints 模式）
+ */
+
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { getEffectiveGates } from '../effective-gates';
+
+const DEFAULT_ORDER = ['acceptance', 'command', 'contract', 'performance', 'review', 'security'];
+
+describe('getEffectiveGates', () => {
+  let dir: string;
+
+  beforeEach(() => {
+    dir = fs.mkdtempSync(path.join(os.tmpdir(), 'harness-gates-'));
+  });
+
+  afterEach(() => {
+    fs.rmSync(dir, { recursive: true, force: true });
+  });
+
+  function writeConfig(yamlText: string): void {
+    const harnessDir = path.join(dir, '.harness');
+    fs.mkdirSync(harnessDir, { recursive: true });
+    fs.writeFileSync(path.join(harnessDir, 'config.yml'), yamlText);
+  }
+
+  it('无 config.yml → 6 门禁按默认 order', () => {
+    expect(getEffectiveGates(dir).map(g => g.id)).toEqual(DEFAULT_ORDER);
+  });
+
+  it('gates.order 声明式重排：列出的按列表序，未列出的按默认序排后', () => {
+    writeConfig('gates:\n  order:\n    - security\n    - review\n');
+    expect(getEffectiveGates(dir).map(g => g.id)).toEqual([
+      'security',
+      'review',
+      'acceptance',
+      'command',
+      'contract',
+      'performance',
+    ]);
+  });
+
+  it('gates.<id>.enabled:false 裁剪（与 getEffectiveConstraints 同款删除语义）', () => {
+    writeConfig('gates:\n  review:\n    enabled: false\n');
+    const ids = getEffectiveGates(dir).map(g => g.id);
+    expect(ids).toHaveLength(5);
+    expect(ids).not.toContain('review');
+  });
+
+  it('order 与 enabled 组合：禁用胜出，其余按 order 重排', () => {
+    writeConfig('gates:\n  order:\n    - security\n    - review\n  review:\n    enabled: false\n');
+    expect(getEffectiveGates(dir).map(g => g.id)).toEqual([
+      'security',
+      'acceptance',
+      'command',
+      'contract',
+      'performance',
+    ]);
+  });
+
+  it('order 引用未注册门禁 → 抛错（闭环）', () => {
+    writeConfig('gates:\n  order:\n    - nope\n');
+    expect(() => getEffectiveGates(dir)).toThrow(/gates.order 引用了未注册的门禁 "nope"/);
+  });
+
+  it('enabled 段引用未注册门禁 → 抛错（闭环）', () => {
+    writeConfig('gates:\n  nope:\n    enabled: false\n');
+    expect(() => getEffectiveGates(dir)).toThrow(/gates.nope 引用了未注册的门禁/);
+  });
+
+  it('order 重复 id → 抛错', () => {
+    writeConfig('gates:\n  order:\n    - review\n    - review\n');
+    expect(() => getEffectiveGates(dir)).toThrow(/门禁 "review" 重复/);
+  });
+
+  it('enabled:true 不裁剪', () => {
+    writeConfig('gates:\n  review:\n    enabled: true\n');
+    expect(getEffectiveGates(dir).map(g => g.id)).toEqual(DEFAULT_ORDER);
+  });
+});