@dommaker/harness 1.9.0 → 1.11.0

package/src/__tests__/checker.test.ts

@@ -1,15 +1,13 @@
 /**
  * checker.ts 测试
  *
- * ADR-0001：只覆盖存活 check 约束的 checker 行为；
- * prompt 类约束的短路语义见 'Prompt constraints' 一节；
- * 已退役/被吸收约束的用例随之移除。
+ * ADR-0029：只覆盖存活 check 约束的 checker 行为；
+ * prompt 面已删除，其短路用例随之移除。
  */
 
 import { ConstraintChecker, checkConstraint } from '../core/constraints/checker';
-import { PROMPTS } from '../core/constraints/definitions';
 import type { ConstraintContext } from '../types/constraint';
-import { writeFileSync, rmSync, mkdtempSync } from 'fs';
+import { rmSync, mkdtempSync } from 'fs';
 import { join } from 'path';
 import { tmpdir } from 'os';
 
@@ -31,42 +29,7 @@ describe('ConstraintChecker', () => {
     }
   });
 
-  describe('Iron Laws', () => {
-    it('should check no_bypass_checkpoint with skip patterns', async () => {
-      // 创建包含 skip 的文件
-      const skipFile = join(tempDir, 'skip-test.ts');
-      writeFileSync(skipFile, 'test.skip("skipped test", () => {});');
-
-      const context: ConstraintContext = {
-        operation: 'code_implementation',
-        changedFiles: [skipFile],
-      };
-
-      const result = await checker.check(
-        { id: 'no_bypass_checkpoint', kind: 'check', level: 'guideline', rule: 'NO BYPASS', message: 'test', trigger: 'code_implementation', enforcement: 'test' },
-        context
-      );
-
-      expect(result.satisfied).toBe(false);
-    });
-
-    it('should pass no_bypass_checkpoint without skip patterns', async () => {
-      const normalFile = join(tempDir, 'normal-test.ts');
-      writeFileSync(normalFile, 'test("normal test", () => { expect(true).toBe(true); });');
-
-      const context: ConstraintContext = {
-        operation: 'code_implementation',
-        changedFiles: [normalFile],
-      };
-
-      const result = await checker.check(
-        { id: 'no_bypass_checkpoint', kind: 'check', level: 'guideline', rule: 'NO BYPASS', message: 'test', trigger: 'code_implementation', enforcement: 'test' },
-        context
-      );
-
-      expect(result.satisfied).toBe(true);
-    });
-
+  describe('error 级约束', () => {
     it('should check no_completion_without_verification', async () => {
       const contextWithEvidence: ConstraintContext = {
         operation: 'code_implementation',
@@ -79,71 +42,21 @@ describe('ConstraintChecker', () => {
       };
 
       const resultWithEvidence = await checker.check(
-        { id: 'no_completion_without_verification', kind: 'check', level: 'iron_law', rule: 'NO COMPLETION', message: 'test', trigger: 'code_implementation', enforcement: 'test' },
+        { id: 'no_completion_without_verification', kind: 'check', severity: 'error', rule: 'NO COMPLETION', message: 'test', trigger: 'code_implementation', enforcement: 'test' },
         contextWithEvidence
       );
 
       const resultWithoutEvidence = await checker.check(
-        { id: 'no_completion_without_verification', kind: 'check', level: 'iron_law', rule: 'NO COMPLETION', message: 'test', trigger: 'code_implementation', enforcement: 'test' },
+        { id: 'no_completion_without_verification', kind: 'check', severity: 'error', rule: 'NO COMPLETION', message: 'test', trigger: 'code_implementation', enforcement: 'test' },
         contextWithoutEvidence
       );
 
       expect(resultWithEvidence.satisfied).toBe(true);
       expect(resultWithoutEvidence.satisfied).toBe(false);
     });
-
-    it('should check incremental_progress', async () => {
-      const contextWithSingleTask: ConstraintContext = {
-        operation: 'code_implementation',
-        hasSingleTask: true,
-      };
-
-      const contextWithMultipleTasks: ConstraintContext = {
-        operation: 'code_implementation',
-        hasSingleTask: false,
-      };
-
-      const resultWith = await checker.check(
-        { id: 'incremental_progress', kind: 'check', level: 'iron_law', rule: 'ONE TASK', message: 'test', trigger: 'code_implementation', enforcement: 'test' },
-        contextWithSingleTask
-      );
-
-      const resultWithout = await checker.check(
-        { id: 'incremental_progress', kind: 'check', level: 'iron_law', rule: 'ONE TASK', message: 'test', trigger: 'code_implementation', enforcement: 'test' },
-        contextWithMultipleTasks
-      );
-
-      expect(resultWith.satisfied).toBe(true);
-      expect(resultWithout.satisfied).toBe(false);
-    });
-
-    it('should check no_implementation_without_requirement', async () => {
-      const contextWithRequirement: ConstraintContext = {
-        operation: 'code_implementation',
-        hasRequirement: true,
-      };
-
-      const contextWithoutRequirement: ConstraintContext = {
-        operation: 'code_implementation',
-        hasRequirement: false,
-      };
-
-      const resultWith = await checker.check(
-        { id: 'no_implementation_without_requirement', kind: 'check', level: 'iron_law', rule: 'REQ EXISTS', message: 'test', trigger: 'code_implementation', enforcement: 'test' },
-        contextWithRequirement
-      );
-
-      const resultWithout = await checker.check(
-        { id: 'no_implementation_without_requirement', kind: 'check', level: 'iron_law', rule: 'REQ EXISTS', message: 'test', trigger: 'code_implementation', enforcement: 'test' },
-        contextWithoutRequirement
-      );
-
-      expect(resultWith.satisfied).toBe(true);
-      expect(resultWithout.satisfied).toBe(false);
-    });
   });
 
-  describe('Guidelines', () => {
+  describe('warning 级约束', () => {
     it('should check capability_sync without CAPABILITIES.md', async () => {
       // 注意：tempDir 在 harness 仓库内，如果有缓存的变更，会检查到代码变更
       // 所以需要创建一个无代码变更的场景或创建 CAPABILITIES.md
@@ -159,7 +72,7 @@ describe('ConstraintChecker', () => {
       fs.writeFileSync(capabilitiesPath, '# Capabilities\n');
 
       const result = await checker.check(
-        { id: 'capability_sync', kind: 'check', level: 'guideline', rule: 'CAPABILITY SYNC', message: 'test', trigger: 'commit', enforcement: 'test' },
+        { id: 'capability_sync', kind: 'check', severity: 'warning', rule: 'CAPABILITY SYNC', message: 'test', trigger: 'commit', enforcement: 'test' },
         context
       );
 
@@ -171,24 +84,6 @@ describe('ConstraintChecker', () => {
     });
   });
 
-  describe('Prompt constraints（ADR-0001：不执行 checker，check() 短路 satisfied）', () => {
-    it('所有内置 prompt 约束 check() 均短路通过', async () => {
-      const context: ConstraintContext = { operation: 'code_implementation' };
-      for (const prompt of Object.values(PROMPTS)) {
-        const result = await checker.check(prompt, context);
-        expect(result.satisfied).toBe(true);
-      }
-    });
-
-    it('prompt 短路不产生 requiredAction/message', async () => {
-      const context: ConstraintContext = { operation: 'code_implementation' };
-      const result = await checker.check(PROMPTS['no_fix_without_root_cause'], context);
-      expect(result.satisfied).toBe(true);
-      expect(result.message).toBeUndefined();
-      expect(result.requiredAction).toBeUndefined();
-    });
-  });
-
   describe('Helper functions', () => {
     it('should check single constraint via checkConstraint', async () => {
       const context: ConstraintContext = {
@@ -205,8 +100,8 @@ describe('ConstraintChecker', () => {
         operation: 'code_implementation',
       };
 
-      const result = await checkConstraint('no_fuzzy_completion_claim', context);
-      expect(result.id).toBe('no_fuzzy_completion_claim');
+      const result = await checkConstraint('no_completion_without_verification', context);
+      expect(result.id).toBe('no_completion_without_verification');
       expect(result.satisfied).toBe(true);
     });
 

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

@@ -1,7 +1,8 @@
 /**
  * 生效约束集（getEffectiveConstraints / lintEffectiveConfig）测试
  *
- * 合并矩阵：preset 裁剪 / config.yml 禁用 / custom 追加 / scenes 过滤 / 未知 id 诊断
+ * 合并矩阵（ADR-0029）：preset 裁剪 / config.yml 禁用 / 未知 id 诊断
+ * （custom 追加与 scenes 过滤已随文本注入层关停一并退役）
  */
 
 import { describe, it, expect, beforeEach, afterEach } from '@jest/globals';
@@ -11,25 +12,19 @@ import {
   lintEffectiveConfig,
 } from '../core/effective-constraints';
 import { createProjectFixture } from '../test-setup/project-fixture';
-import { IRON_LAWS, GUIDELINES, PROMPTS } from '../core/constraints/definitions';
+import { CONSTRAINTS } from '../core/constraints/definitions';
 
-const BUILTIN_TOTAL =
-  Object.keys(IRON_LAWS).length + Object.keys(GUIDELINES).length + Object.keys(PROMPTS).length;
-/** 带 appliesTo 标签的内置 prompt（scenes 过滤对象） */
-const SCENE_PROMPTS = Object.values(PROMPTS)
-  .filter(c => c.appliesTo && c.appliesTo.length > 0)
-  .map(c => c.id);
+const BUILTIN_TOTAL = Object.keys(CONSTRAINTS).length;
 
 describe('getEffectiveConstraints / lintEffectiveConfig', () => {
   let tempDir: string;
   let counter = 0;
 
-  const setupProject = (configYaml?: string, customYaml?: string): string =>
+  const setupProject = (configYaml?: string): string =>
     createProjectFixture({
       parentDir: tempDir,
       name: `p${counter++}`,
       config: configYaml,
-      files: customYaml === undefined ? undefined : { '.harness/custom-constraints.yml': customYaml },
     });
 
   beforeEach(() => {
@@ -42,65 +37,28 @@ describe('getEffectiveConstraints / lintEffectiveConfig', () => {
   });
 
   describe('合并矩阵', () => {
-    it('无配置项目：内置全集减去场景专属 prompt（scenes 缺省为空）', () => {
+    it('无配置项目：内置全集（全部 kind=check，带 severity）', () => {
       const dir = setupProject();
       const constraints = getEffectiveConstraints(dir);
-      const ids = constraints.map(c => c.id);
-
-      expect(constraints.length).toBe(BUILTIN_TOTAL - SCENE_PROMPTS.length);
-      for (const id of SCENE_PROMPTS) {
-        expect(ids).not.toContain(id);
-      }
-      // check + prompt 均带 kind
-      expect(constraints.every(c => c.kind === 'check' || c.kind === 'prompt')).toBe(true);
-      expect(constraints.filter(c => c.kind === 'check')).toHaveLength(
-        Object.keys(IRON_LAWS).length + Object.keys(GUIDELINES).length
-      );
-    });
-
-    it('scenes 命中：对应场景 prompt 进入生效集，其余场景 prompt 仍排除', () => {
-      const dir = setupProject(`scenes:\n  - agent-skill\n`);
-      const ids = getEffectiveConstraints(dir).map(c => c.id);
 
-      expect(ids).toContain('no_skill_without_test');
-      expect(ids).not.toContain('no_model_for_deterministic');
+      expect(constraints.length).toBe(BUILTIN_TOTAL);
+      expect(constraints.every(c => c.kind === 'check')).toBe(true);
     });
 
-    it('config.yml 禁用：check 与 prompt 条目均从生效集移除', () => {
+    it('config.yml 禁用：条目从生效集移除', () => {
       const dir = setupProject(`
 constraints:
-  no_bypass_checkpoint:
+  capability_sync:
     enabled: false
-  no_fuzzy_completion_claim:
+  docs_freshness:
     enabled: false
 `);
       const constraints = getEffectiveConstraints(dir);
       const ids = constraints.map(c => c.id);
 
-      expect(ids).not.toContain('no_bypass_checkpoint');
-      expect(ids).not.toContain('no_fuzzy_completion_claim');
-      expect(constraints.length).toBe(BUILTIN_TOTAL - SCENE_PROMPTS.length - 2);
-    });
-
-    it('config.yml 禁用：custom 约束同样从生效集移除（retire 落 config.yml 的退役路径）', () => {
-      const dir = setupProject(
-        `
-constraints:
-  my_project_rule:
-    enabled: false
-`,
-        `
-custom_constraints:
-  my_project_rule:
-    level: iron_law
-    rule: MY RULE
-    message: 项目自定义
-`
-      );
-      const constraints = getEffectiveConstraints(dir);
-      const ids = constraints.map(c => c.id);
-
-      expect(ids).not.toContain('my_project_rule');
+      expect(ids).not.toContain('capability_sync');
+      expect(ids).not.toContain('docs_freshness');
+      expect(constraints.length).toBe(BUILTIN_TOTAL - 2);
     });
 
     it('preset: relaxed 裁剪生效集', () => {
@@ -111,33 +69,13 @@ custom_constraints:
       expect(ids).toEqual(
         expect.arrayContaining([
           'no_completion_without_verification',
-          'incremental_progress',
-          'no_implementation_without_requirement',
-          'no_bypass_checkpoint',
           'no_hardcoded_credentials',
         ])
       );
-      expect(constraints).toHaveLength(5);
+      expect(constraints).toHaveLength(2);
       expect(constraints.every(c => c.kind === 'check')).toBe(true);
     });
 
-    it('custom-constraints.yml 追加自定义约束（kind=prompt）', () => {
-      const dir = setupProject(undefined, `
-custom_constraints:
-  my_project_rule:
-    level: guideline
-    rule: MY RULE
-    message: 项目自定义
-    trigger: code_implementation
-`);
-      const constraints = getEffectiveConstraints(dir);
-      const custom = constraints.find(c => c.id === 'my_project_rule');
-
-      expect(custom).toBeDefined();
-      expect(custom!.kind).toBe('prompt');
-      expect(custom!.level).toBe('guideline');
-    });
-
     it('禁用未知 id（已移除约束的残留配置）：不报错，lint 可诊断', () => {
       const dir = setupProject(`
 constraints:
@@ -146,19 +84,16 @@ constraints:
 `);
       // 生效集不受影响、不抛错
       const constraints = getEffectiveConstraints(dir);
-      expect(constraints.length).toBe(BUILTIN_TOTAL - SCENE_PROMPTS.length);
+      expect(constraints.length).toBe(BUILTIN_TOTAL);
 
       const lint = lintEffectiveConfig(dir);
       expect(lint.unknownIds).toContain('removed_legacy_constraint');
     });
 
-    it('lintEffectiveConfig 报告 scenes 与被场景过滤的 prompt', () => {
-      const dir = setupProject(`scenes:\n  - llm-app\n`);
+    it('lintEffectiveConfig：干净配置 unknownIds 为空', () => {
+      const dir = setupProject();
       const lint = lintEffectiveConfig(dir);
 
-      expect(lint.scenes).toEqual(['llm-app']);
-      expect(lint.sceneExcluded).toContain('no_skill_without_test');
-      expect(lint.sceneExcluded).not.toContain('no_model_for_deterministic');
       expect(lint.unknownIds).toEqual([]);
     });
   });

package/src/__tests__/iron-laws.test.ts

@@ -1,12 +1,10 @@
 /**
- * 约束系统测试（ADR-0001：kind 二元模型，26 条清单构成 + 注册表闭环）
+ * 约束系统测试（ADR-0029：severity 显式模型——三层命名废弃、prompt 面删除、注册表闭环保留）
  */
 
 import { describe, it, expect } from '@jest/globals';
 import {
-  IRON_LAWS,
-  GUIDELINES,
-  PROMPTS,
+  CONSTRAINTS,
   getAllConstraints,
   findConstraintsByTrigger,
   getConstraint
@@ -16,32 +14,28 @@ import { getConstraintCheck, registeredCheckCount } from '../core/constraints/ch
 import type { ConstraintContext } from '../types/constraint';
 
 describe('Constraint System', () => {
-  describe('清单构成（ADR-0001：42 → 26）', () => {
-    it('getAllConstraints 返回 26 条：10 check + 16 prompt', () => {
+  describe('清单构成（ADR-0029：16 → 7，全部 kind=check）', () => {
+    it('getAllConstraints 返回 7 条 check 约束', () => {
       const all = getAllConstraints();
-      expect(all).toHaveLength(26);
-      expect(all.filter(c => c.kind === 'check')).toHaveLength(10);
-      expect(all.filter(c => c.kind === 'prompt')).toHaveLength(16);
+      expect(all).toHaveLength(7);
+      expect(all.every(c => c.kind === 'check')).toBe(true);
     });
 
-    it('check 层 = 5 iron + 5 guideline', () => {
-      expect(Object.keys(IRON_LAWS)).toHaveLength(5);
-      expect(Object.keys(GUIDELINES)).toHaveLength(5);
-      Object.values(IRON_LAWS).forEach(c => {
+    it('severity 分桶 = 3 error + 4 warning', () => {
+      const errors = Object.values(CONSTRAINTS).filter(c => c.severity === 'error');
+      const warnings = Object.values(CONSTRAINTS).filter(c => c.severity === 'warning');
+      expect(errors).toHaveLength(3);
+      expect(warnings).toHaveLength(4);
+      Object.values(CONSTRAINTS).forEach(c => {
         expect(c.kind).toBe('check');
-        expect(c.level).toBe('iron_law');
-      });
-      Object.values(GUIDELINES).forEach(c => {
-        expect(c.kind).toBe('check');
-        expect(c.level).toBe('guideline');
       });
     });
 
-    it('prompt 层 16 条，level 统一为 prompt', () => {
-      expect(Object.keys(PROMPTS)).toHaveLength(16);
-      Object.values(PROMPTS).forEach(c => {
-        expect(c.kind).toBe('prompt');
-        expect(c.level).toBe('prompt');
+    it('prompt 面字段已删除（promptInjection / injectPrompt / appliesTo 不存在）', () => {
+      Object.values(CONSTRAINTS).forEach(c => {
+        expect('promptInjection' in c).toBe(false);
+        expect('injectPrompt' in c).toBe(false);
+        expect('appliesTo' in c).toBe(false);
       });
     });
 
@@ -78,20 +72,48 @@ describe('Constraint System', () => {
       }
     });
 
-    it('场景标签：no_skill_without_test / no_model_for_deterministic', () => {
-      expect(PROMPTS['no_skill_without_test'].appliesTo).toEqual(['agent-skill']);
-      expect(PROMPTS['no_model_for_deterministic'].appliesTo).toEqual(['llm-app']);
+    it('harness#174 删除的 10 条不再存在', () => {
+      const removed = [
+        'incremental_progress',
+        'no_implementation_without_requirement',
+        'no_bypass_checkpoint',
+        'simplest_solution_first',
+        'no_simplification_without_approval',
+        'follow_conventions',
+        'first_principles_first',
+        'no_conflict_blending',
+        'no_performative_agreement',
+        'no_skill_without_test',
+      ];
+      for (const id of removed) {
+        expect(getConstraint(id)).toBeUndefined();
+        expect(getConstraintCheck(id)).toBeUndefined();
+      }
+    });
+
+    it('ADR-0029：prompt 类 9 条随文本注入层关停删除', () => {
+      const removed = [
+        'no_fuzzy_completion_claim',
+        'no_fix_without_root_cause',
+        'no_code_without_test',
+        'fix_the_problem_not_the_gate',
+        'verify_external_capability',
+        'no_delete_without_context',
+        'design_decision_requires_discussion',
+        'surgical_changes_only',
+        'no_model_for_deterministic',
+      ];
+      for (const id of removed) {
+        expect(getConstraint(id)).toBeUndefined();
+        expect(getConstraintCheck(id)).toBeUndefined();
+      }
     });
 
     it('no_completion_without_verification 不硬编码具体命令示例（#25：口径由项目声明）', () => {
-      const law = IRON_LAWS['no_completion_without_verification'];
-      expect(law.promptInjection).not.toMatch(/npm test|npm run build/);
+      const law = CONSTRAINTS['no_completion_without_verification'];
       expect(law.description).not.toMatch(/npm test|npm run build/);
-      expect(law.promptInjection).not.toContain('完整');
       expect(law.description).not.toContain('完整');
-      expect(law.promptInjection).toContain('项目声明的测试');
       expect(law.description).toContain('项目声明的测试');
-      expect(law.promptInjection).toContain('不得凭记忆声称完成');
     });
   });
 
@@ -107,12 +129,6 @@ describe('Constraint System', () => {
       const checkCount = getAllConstraints().filter(c => c.kind === 'check').length;
       expect(registeredCheckCount()).toBe(checkCount);
     });
-
-    it('prompt 约束不注册 checker', () => {
-      for (const c of Object.values(PROMPTS)) {
-        expect(getConstraintCheck(c.id)).toBeUndefined();
-      }
-    });
   });
 
   describe('Helper Functions', () => {
@@ -122,10 +138,10 @@ describe('Constraint System', () => {
     });
 
     it('should get single constraint by id', () => {
-      const constraint = getConstraint('no_fix_without_root_cause');
+      const constraint = getConstraint('no_completion_without_verification');
       expect(constraint).toBeDefined();
-      expect(constraint?.kind).toBe('prompt');
-      expect(constraint?.level).toBe('prompt');
+      expect(constraint?.kind).toBe('check');
+      expect(constraint?.severity).toBe('error');
     });
 
     it('should return undefined for unknown constraint', () => {
@@ -147,16 +163,7 @@ describe('Constraint Checker', () => {
     };
 
     const result = constraintChecker.findApplicableConstraints(context);
-    expect(result.ironLaws.length + result.guidelines.length).toBeGreaterThan(0);
-  });
-
-  it('prompt 约束 check() 短路 satisfied，不查注册表', async () => {
-    const context: ConstraintContext = {
-      operation: 'code_implementation',
-    };
-
-    const result = await constraintChecker.check(PROMPTS['no_fix_without_root_cause'], context);
-    expect(result.satisfied).toBe(true);
+    expect(result.errors.length + result.warnings.length).toBeGreaterThan(0);
   });
 
   it('kind=check 但未注册 checker 的约束应抛错（不许静默 pass）', async () => {
@@ -169,7 +176,7 @@ describe('Constraint Checker', () => {
         {
           id: 'ghost_check_constraint',
           kind: 'check',
-          level: 'guideline',
+          severity: 'warning',
           rule: 'GHOST',
           message: 'test',
           trigger: 'code_implementation',
@@ -189,66 +196,40 @@ describe('Constraint Checker', () => {
     };
 
     const result = await constraintChecker.checkConstraints(context);
-    expect(result.ironLaws.length + result.guidelines.length).toBeGreaterThan(0);
+    expect(result.errors.length + result.warnings.length).toBeGreaterThan(0);
   });
 
-  it('should skip incremental_progress when hasSingleTask is undefined（未接线不评估）', async () => {
+  it('should skip no_completion_without_verification when hasVerificationEvidence is undefined（未接线不评估）', async () => {
     const context: ConstraintContext = {
       operation: 'code_implementation',
     };
 
-    const result = await constraintChecker.check(IRON_LAWS['incremental_progress'], context);
+    const result = await constraintChecker.check(CONSTRAINTS['no_completion_without_verification'], context);
     expect(result.skipped).toBe(true);
     expect(result.satisfied).toBe(true);
   });
 
-  it('should pass incremental_progress when hasSingleTask is true', async () => {
+  it('should pass no_completion_without_verification when hasVerificationEvidence is true', async () => {
     const context: ConstraintContext = {
       operation: 'code_implementation',
-      hasSingleTask: true,
-    };
-
-    const result = await constraintChecker.check(IRON_LAWS['incremental_progress'], context);
-    expect(result.satisfied).toBe(true);
-  });
-
-  it('should skip no_implementation_without_requirement when hasRequirement is undefined（未接线不评估）', async () => {
-    const context: ConstraintContext = {
-      operation: 'code_implementation',
-    };
-
-    const result = await constraintChecker.check(IRON_LAWS['no_implementation_without_requirement'], context);
-    expect(result.skipped).toBe(true);
-    expect(result.satisfied).toBe(true);
-  });
-
-  it('should pass no_implementation_without_requirement when hasRequirement is true', async () => {
-    const context: ConstraintContext = {
-      operation: 'code_implementation',
-      hasRequirement: true,
+      hasVerificationEvidence: true,
     };
 
-    const result = await constraintChecker.check(IRON_LAWS['no_implementation_without_requirement'], context);
+    const result = await constraintChecker.check(CONSTRAINTS['no_completion_without_verification'], context);
     expect(result.satisfied).toBe(true);
   });
 });
 
-describe('Constraint Levels', () => {
-  it('should have correct level for iron laws', () => {
-    Object.values(IRON_LAWS).forEach(law => {
-      expect(law.level).toBe('iron_law');
-    });
-  });
-
-  it('should have correct level for guidelines', () => {
-    Object.values(GUIDELINES).forEach(guideline => {
-      expect(guideline.level).toBe('guideline');
+describe('Constraint Severity', () => {
+  it('error 级约束 severity 均为 error', () => {
+    ['no_completion_without_verification', 'no_test_simplification', 'docs_freshness'].forEach(id => {
+      expect(CONSTRAINTS[id].severity).toBe('error');
     });
   });
 
-  it('should have correct level for prompts', () => {
-    Object.values(PROMPTS).forEach(prompt => {
-      expect(prompt.level).toBe('prompt');
+  it('warning 级约束 severity 均为 warning', () => {
+    ['no_hardcoded_credentials', 'capability_sync', 'context_doc_sync', 'governance_presence'].forEach(id => {
+      expect(CONSTRAINTS[id].severity).toBe('warning');
     });
   });
 });

package/src/__tests__/passes-gate-check.test.ts

@@ -30,7 +30,7 @@ describe('PassesGate.check()', () => {
     expect(result.violations).toBeDefined();
     expect(result.violations?.length).toBe(1);
     expect(result.violations?.[0]?.id).toBe('no_self_approval');
-    expect(result.violations?.[0]?.level).toBe('iron_law');
+    expect(result.violations?.[0]?.severity).toBe('error');
     expect(result.testResult).toEqual(testResult);
   });
 
@@ -47,7 +47,7 @@ describe('PassesGate.check()', () => {
     expect(result.violations).toBeDefined();
     expect(result.violations?.length).toBe(1);
     expect(result.violations?.[0]?.id).toBe('no_completion_without_verification');
-    expect(result.violations?.[0]?.level).toBe('iron_law');
+    expect(result.violations?.[0]?.severity).toBe('error');
     expect(result.testResult).toEqual(testResult);
   });