@dommaker/harness 0.16.8 → 0.17.0

package/src/__tests__/constraint-doctor.test.ts

@@ -74,7 +74,7 @@ describe('ConstraintDoctor', () => {
     it('应该返回诊断结果', async () => {
       const anomaly: TraceAnomaly = {
         type: 'rising_fail_rate',
-        constraintId: 'no_self_approval',
+        constraintId: 'no_completion_without_verification',
         level: 'iron_law',
         message: '失败率上升',
         data: {
@@ -178,7 +178,7 @@ describe('ConstraintDoctor', () => {
     it('应该诊断 low_pass_rate', async () => {
       const anomaly: TraceAnomaly = {
         type: 'low_pass_rate',
-        constraintId: 'no_any_type',
+        constraintId: 'capability_sync',
         level: 'guideline',
         message: '通过率过低',
         data: { currentRate: 0.1, threshold: 0.5 },
@@ -211,7 +211,7 @@ describe('ConstraintDoctor', () => {
     it('rising_fail_rate 应该设置 severity 为 high 当 iron_law', async () => {
       const anomaly: TraceAnomaly = {
         type: 'rising_fail_rate',
-        constraintId: 'no_self_approval',
+        constraintId: 'no_completion_without_verification',
         level: 'iron_law',
         message: '失败率上升',
         data: { currentRate: 0.7, threshold: 0.3, trend: 'rising' },
@@ -237,7 +237,7 @@ describe('ConstraintDoctor', () => {
         },
         {
           type: 'low_pass_rate',
-          constraintId: 'no_any_type',
+          constraintId: 'capability_sync',
           level: 'guideline',
           message: '通过率过低',
           data: { currentRate: 0.1, threshold: 0.5 },
@@ -249,7 +249,7 @@ describe('ConstraintDoctor', () => {
 
       expect(results.length).toBe(2);
       expect(results[0].constraintId).toBe('no_fix_without_root_cause');
-      expect(results[1].constraintId).toBe('no_any_type');
+      expect(results[1].constraintId).toBe('capability_sync');
     });
   });
 

package/src/__tests__/doctor-extra.test.ts

@@ -0,0 +1,164 @@
+/**
+ * ConstraintDoctor 测试
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import { TraceCollector } from '../monitoring/traces';
+import { TraceAnalyzer } from '../monitoring/trace-analyzer';
+import { ConstraintDoctor, createDoctor } from '../monitoring/constraint-doctor';
+import type { ExecutionTrace, TraceAnomaly } from '../types/trace';
+
+describe('ConstraintDoctor', () => {
+  let tempDir: string;
+  let collector: TraceCollector;
+  let analyzer: TraceAnalyzer;
+  let doctor: ConstraintDoctor;
+
+  beforeEach(() => {
+    tempDir = path.join(os.tmpdir(), `harness-traces-${Date.now()}`);
+    fs.mkdirSync(tempDir, { recursive: true });
+    collector = new TraceCollector({
+      traceFile: path.join(tempDir, 'execution.log'),
+      enabled: true,
+    });
+    analyzer = new TraceAnalyzer(collector);
+    doctor = createDoctor();
+  });
+
+  afterEach(() => {
+    if (fs.existsSync(tempDir)) {
+      fs.rmSync(tempDir, { recursive: true });
+    }
+  });
+
+  test('should diagnose high bypass rate anomaly', async () => {
+    // 创建异常
+    const anomaly: TraceAnomaly = {
+      type: 'high_bypass_rate',
+      constraintId: 'test_constraint',
+      level: 'guideline',
+      message: 'Bypass rate 40%',
+      data: {
+        currentRate: 0.4,
+        threshold: 0.3,
+      },
+      detectedAt: Date.now(),
+      suggestedAction: 'diagnose',
+    };
+
+    // 添加 traces
+    const traces: ExecutionTrace[] = [];
+    for (let i = 0; i < 10; i++) {
+      traces.push({
+        constraintId: 'test_constraint',
+        level: 'guideline',
+        timestamp: Date.now() - i * 60 * 1000,
+        result: i < 6 ? 'bypassed' : 'pass',
+      });
+    }
+    doctor.setData(traces);
+
+    // 诊断
+    const diagnosis = await doctor.diagnose(anomaly);
+
+    expect(diagnosis.constraintId).toBe('test_constraint');
+    expect(diagnosis.needsChange).toBe(true);
+    expect(diagnosis.rootCause.primary).toContain('过于严格');
+    expect(diagnosis.recommendations.length).toBeGreaterThan(0);
+    expect(diagnosis.recommendations[0].type).toBe('add_exception');
+  });
+
+  test('should diagnose rising fail rate anomaly', async () => {
+    const anomaly: TraceAnomaly = {
+      type: 'rising_fail_rate',
+      constraintId: 'another_constraint',
+      level: 'iron_law',
+      message: 'Fail rate rising',
+      data: {
+        currentRate: 0.6,
+        threshold: 0.5,
+        trend: 'rising',
+      },
+      detectedAt: Date.now(),
+      suggestedAction: 'diagnose',
+    };
+
+    doctor.setData([]);
+    const diagnosis = await doctor.diagnose(anomaly);
+
+    expect(diagnosis.needsChange).toBe(true);
+    expect(diagnosis.impact.severity).toBe('high'); // Iron law
+    expect(diagnosis.urgency).toBe('medium'); // Iron law 强制 medium+
+  });
+
+  test('should detect exception overuse', async () => {
+    const anomaly: TraceAnomaly = {
+      type: 'exception_overuse',
+      constraintId: 'constraint_with_exceptions',
+      level: 'guideline',
+      message: 'Exception rate 50%',
+      data: {
+        currentRate: 0.5,
+        threshold: 0.4,
+      },
+      detectedAt: Date.now(),
+      suggestedAction: 'add_exception',
+    };
+
+    doctor.setData([]);
+    const diagnosis = await doctor.diagnose(anomaly);
+
+    expect(diagnosis.rootCause.primary).toContain('过度使用');
+    expect(diagnosis.recommendations[0].type).toBe('modify_constraint');
+  });
+
+  test('should generate diagnosis report', async () => {
+    const anomaly: TraceAnomaly = {
+      type: 'high_bypass_rate',
+      constraintId: 'test',
+      level: 'guideline',
+      message: 'Test',
+      data: {
+        currentRate: 0.5,
+        threshold: 0.3,
+      },
+      detectedAt: Date.now(),
+      suggestedAction: 'diagnose',
+    };
+
+    doctor.setData([]);
+    const diagnosis = await doctor.diagnose(anomaly);
+    const report = doctor.generateReport(diagnosis);
+
+    expect(report).toContain('# Diagnosis Report');
+    expect(report).toContain('Root Cause');
+    expect(report).toContain('Recommendations');
+    expect(report).toContain('test');
+  });
+
+  test('should save and load diagnosis', async () => {
+    const anomaly: TraceAnomaly = {
+      type: 'high_bypass_rate',
+      constraintId: 'save_test',
+      level: 'guideline',
+      message: 'Test',
+      data: { currentRate: 0.5, threshold: 0.3 },
+      detectedAt: Date.now(),
+      suggestedAction: 'diagnose',
+    };
+
+    doctor.setData([]);
+    const diagnosis = await doctor.diagnose(anomaly);
+
+    const outputPath = path.join(tempDir, 'diagnosis.json');
+    doctor.saveDiagnosis(diagnosis, outputPath);
+
+    expect(fs.existsSync(outputPath)).toBe(true);
+
+    const loaded = doctor.loadDiagnosis(outputPath);
+    expect(loaded.constraintId).toBe('save_test');
+    expect(loaded.needsChange).toBe(true);
+  });
+});

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

@@ -0,0 +1,147 @@
+/**
+ * 生效约束集（getEffectiveConstraints / lintEffectiveConfig）测试
+ *
+ * 合并矩阵：preset 裁剪 / config.yml 禁用 / custom 追加 / scenes 过滤 / 未知 id 诊断
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from '@jest/globals';
+import * as fs from 'fs';
+import * as path from 'path';
+import {
+  getEffectiveConstraints,
+  lintEffectiveConfig,
+} from '../core/effective-constraints';
+import { IRON_LAWS, GUIDELINES, PROMPTS } 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);
+
+describe('getEffectiveConstraints / lintEffectiveConfig', () => {
+  let tempDir: string;
+  let counter = 0;
+
+  const setupProject = (configYaml?: string, customYaml?: string): string => {
+    const dir = path.join(tempDir, `p${counter++}`);
+    fs.mkdirSync(path.join(dir, '.harness'), { recursive: true });
+    if (configYaml !== undefined) {
+      fs.writeFileSync(path.join(dir, '.harness', 'config.yml'), configYaml);
+    }
+    if (customYaml !== undefined) {
+      fs.writeFileSync(path.join(dir, '.harness', 'custom-constraints.yml'), customYaml);
+    }
+    return dir;
+  };
+
+  beforeEach(() => {
+    tempDir = fs.mkdtempSync(path.join(process.cwd(), 'temp-test-effective-'));
+  });
+
+  afterEach(() => {
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  describe('合并矩阵', () => {
+    it('无配置项目：内置全集减去场景专属 prompt（scenes 缺省为空）', () => {
+      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');
+    });
+
+    it('config.yml 禁用：check 与 prompt 条目均从生效集移除', () => {
+      const dir = setupProject(`
+constraints:
+  no_bypass_checkpoint:
+    enabled: false
+  no_fuzzy_completion_claim:
+    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('preset: relaxed 裁剪生效集', () => {
+      const dir = setupProject(`preset: relaxed\n`);
+      const constraints = getEffectiveConstraints(dir);
+      const ids = constraints.map(c => c.id);
+
+      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.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:
+  removed_legacy_constraint:
+    enabled: false
+`);
+      // 生效集不受影响、不抛错
+      const constraints = getEffectiveConstraints(dir);
+      expect(constraints.length).toBe(BUILTIN_TOTAL - SCENE_PROMPTS.length);
+
+      const lint = lintEffectiveConfig(dir);
+      expect(lint.unknownIds).toContain('removed_legacy_constraint');
+    });
+
+    it('lintEffectiveConfig 报告 scenes 与被场景过滤的 prompt', () => {
+      const dir = setupProject(`scenes:\n  - llm-app\n`);
+      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__/extend-exceptions.test.ts

@@ -38,8 +38,8 @@ custom_constraints:
     loader.load();
     const merged = loader.mergeConstraints();
 
-    // 注意：no_fix_without_root_cause 是 GUIDELINE
-    const constraint = merged.guidelines['no_fix_without_root_cause'];
+    // 注意：no_fix_without_root_cause 是 prompt 层约束（ADR-0001）
+    const constraint = merged.prompts!['no_fix_without_root_cause'];
     expect(constraint).toBeDefined();
     // 应该包含内置例外
     expect(constraint?.exceptions).toContain('simple_typo');
@@ -135,7 +135,7 @@ custom_constraints:
     loader.load();
     const merged = loader.mergeConstraints();
 
-    const constraint = merged.guidelines['no_fix_without_root_cause'];
+    const constraint = merged.prompts!['no_fix_without_root_cause'];
     expect(constraint).toBeDefined();
     // 应该保留内置约束的 rule
     expect(constraint?.rule).toBeTruthy();

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

@@ -1,55 +1,110 @@
 /**
- * 约束系统测试
+ * 约束系统测试（ADR-0001：kind 二元模型，25 条清单构成 + 注册表闭环）
  */
 
 import { describe, it, expect } from '@jest/globals';
-import { 
-  IRON_LAWS, 
-  GUIDELINES, 
-  TIPS, 
-  getAllConstraints, 
-  findConstraintsByTrigger, 
-  getConstraint 
+import {
+  IRON_LAWS,
+  GUIDELINES,
+  PROMPTS,
+  getAllConstraints,
+  findConstraintsByTrigger,
+  getConstraint
 } from '../core/constraints/definitions';
 import { constraintChecker } from '../core/constraints/checker';
+import { getConstraintCheck, registeredCheckCount } from '../core/constraints/checkers';
 import type { ConstraintContext } from '../types/constraint';
 
 describe('Constraint System', () => {
-  describe('Iron Laws', () => {
-    it('should have 12 iron laws defined', () => {
-      expect(Object.keys(IRON_LAWS).length).toBeGreaterThan(0); // 数量随版本变动
+  describe('清单构成（ADR-0001：42 → 25）', () => {
+    it('getAllConstraints 返回 25 条：9 check + 16 prompt', () => {
+      const all = getAllConstraints();
+      expect(all).toHaveLength(25);
+      expect(all.filter(c => c.kind === 'check')).toHaveLength(9);
+      expect(all.filter(c => c.kind === 'prompt')).toHaveLength(16);
     });
 
-    it('should have no exceptions for iron laws', () => {
-      Object.values(IRON_LAWS).forEach(law => {
-        expect(law.exceptions).toBeUndefined();
+    it('check 层 = 5 iron + 4 guideline', () => {
+      expect(Object.keys(IRON_LAWS)).toHaveLength(5);
+      expect(Object.keys(GUIDELINES)).toHaveLength(4);
+      Object.values(IRON_LAWS).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');
       });
     });
-  });
 
-  describe('Guidelines', () => {
-    it('should have guidelines defined', () => {
-      expect(Object.keys(GUIDELINES).length).toBeGreaterThan(0);
+    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('should have exceptions for some guidelines', () => {
-      const withExceptions = Object.values(GUIDELINES).filter(g => g.exceptions && g.exceptions.length > 0);
-      expect(withExceptions.length).toBeGreaterThan(0);
+    it('被删除的 8 条不再存在', () => {
+      const retired = [
+        'no_any_type',
+        'test_coverage_required',
+        'no_coverage_decrease',
+        'readme_required',
+        'doc_required_for_public_api',
+        'two_stage_review_required',
+        'prefer_worktree',
+        'read_before_write',
+      ];
+      for (const id of retired) {
+        expect(getConstraint(id)).toBeUndefined();
+      }
     });
-  });
 
-  describe('Tips', () => {
-    it('should have 2 tips defined', () => {
-      expect(Object.keys(TIPS)).toHaveLength(2);
+    it('被吸收的成员不再单独存在', () => {
+      const absorbed = [
+        'no_self_approval',
+        'no_claim_without_evidence',
+        'no_excuse_patterns',
+        'no_fallback_without_root_cause',
+        'analysis_verification_gate',
+        'diagnosis_to_fix_gate',
+        'no_creation_without_reuse_check',
+        'yagni_check',
+        'no_implementation_without_requirement_review',
+      ];
+      for (const id of absorbed) {
+        expect(getConstraint(id)).toBeUndefined();
+      }
+    });
+
+    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']);
     });
   });
 
-  describe('Helper Functions', () => {
-    it('should get all constraints', () => {
-      const all = getAllConstraints();
-      expect(all.length).toBeGreaterThan(0); // 约束数量随版本变动
+  describe('注册表闭环', () => {
+    it('每条 kind=check 约束都有已注册 checker', () => {
+      const checks = getAllConstraints().filter(c => c.kind === 'check');
+      for (const c of checks) {
+        expect(getConstraintCheck(c.id)).toBeDefined();
+      }
+    });
+
+    it('注册表数量与 check 约束数量一致（无孤儿 checker）', () => {
+      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', () => {
     it('should find constraints by trigger', () => {
       const constraints = findConstraintsByTrigger('code_implementation');
       expect(constraints.length).toBeGreaterThan(0);
@@ -58,7 +113,8 @@ describe('Constraint System', () => {
     it('should get single constraint by id', () => {
       const constraint = getConstraint('no_fix_without_root_cause');
       expect(constraint).toBeDefined();
-      expect(constraint?.level).toBe('guideline');
+      expect(constraint?.kind).toBe('prompt');
+      expect(constraint?.level).toBe('prompt');
     });
 
     it('should return undefined for unknown constraint', () => {
@@ -80,54 +136,59 @@ describe('Constraint Checker', () => {
     };
 
     const result = constraintChecker.findApplicableConstraints(context);
-    expect(result.ironLaws.length + result.guidelines.length + result.tips.length).toBeGreaterThan(0);
+    expect(result.ironLaws.length + result.guidelines.length).toBeGreaterThan(0);
   });
 
-  it('should check constraint', async () => {
+  it('prompt 约束 check() 短路 satisfied，不查注册表', async () => {
     const context: ConstraintContext = {
       operation: 'code_implementation',
-      hasRootCauseInvestigation: false,
     };
 
-    const result = await constraintChecker.check(GUIDELINES['no_fix_without_root_cause'], context);
-    expect(result.satisfied).toBe(false);
+    const result = await constraintChecker.check(PROMPTS['no_fix_without_root_cause'], context);
+    expect(result.satisfied).toBe(true);
   });
 
-  it('should check constraint with satisfied precondition', async () => {
+  it('kind=check 但未注册 checker 的约束应抛错（不许静默 pass）', async () => {
     const context: ConstraintContext = {
       operation: 'code_implementation',
-      hasRootCauseInvestigation: true,
     };
 
-    const result = await constraintChecker.check(GUIDELINES['no_fix_without_root_cause'], context);
-    expect(result.satisfied).toBe(true);
+    await expect(
+      constraintChecker.check(
+        {
+          id: 'ghost_check_constraint',
+          kind: 'check',
+          level: 'guideline',
+          rule: 'GHOST',
+          message: 'test',
+          trigger: 'code_implementation',
+          enforcement: 'test',
+        },
+        context
+      )
+    ).rejects.toThrow(/未注册 checker/);
   });
 
   it('should check all constraints', async () => {
     const context: ConstraintContext = {
       operation: 'code_implementation',
       hasRequirement: true,
-      hasWorktree: true,
-      hasTest: true,
       hasVerificationEvidence: true,
-      taskDescription: 'Test task',
       hasSingleTask: true,
-      hasRequirementReview: true,
-      hasTwoStageReview: true,
-      completionClaimText: '142 tests passed, coverage 87%',
     };
 
     const result = await constraintChecker.checkConstraints(context);
-    expect(result.ironLaws.length + result.guidelines.length + result.tips.length).toBeGreaterThan(0);
+    expect(result.ironLaws.length + result.guidelines.length).toBeGreaterThan(0);
   });
 
-  it('should fail incremental_progress when hasSingleTask is undefined', async () => {
+  it('should skip incremental_progress when hasSingleTask is undefined（未接线不评估）', async () => {
     const context: ConstraintContext = {
       operation: 'code_implementation',
     };
 
     const result = await constraintChecker.check(IRON_LAWS['incremental_progress'], context);
-    expect(result.satisfied).toBe(false);
+    expect(result.skipped).toBe(true);
+    expect(result.satisfied).toBe(true);
   });
 
   it('should pass incremental_progress when hasSingleTask is true', async () => {
@@ -140,51 +201,14 @@ describe('Constraint Checker', () => {
     expect(result.satisfied).toBe(true);
   });
 
-  it('should fail verify_external_capability when hasExternalCapabilityVerification is undefined', async () => {
-    const context: ConstraintContext = {
-      operation: 'api_change',
-    };
-
-    const result = await constraintChecker.check(IRON_LAWS['verify_external_capability'], context);
-    expect(result.satisfied).toBe(false);
-  });
-
-  it('should pass verify_external_capability when hasExternalCapabilityVerification is true', async () => {
-    const context: ConstraintContext = {
-      operation: 'api_change',
-      hasExternalCapabilityVerification: true,
-    };
-
-    const result = await constraintChecker.check(IRON_LAWS['verify_external_capability'], context);
-    expect(result.satisfied).toBe(true);
-  });
-
-  it('should fail no_implementation_without_requirement_review when hasRequirementReview is undefined', async () => {
-    const context: ConstraintContext = {
-      operation: 'code_implementation',
-    };
-
-    const result = await constraintChecker.check(IRON_LAWS['no_implementation_without_requirement_review'], context);
-    expect(result.satisfied).toBe(false);
-  });
-
-  it('should pass no_implementation_without_requirement_review when hasRequirementReview is true', async () => {
-    const context: ConstraintContext = {
-      operation: 'code_implementation',
-      hasRequirementReview: true,
-    };
-
-    const result = await constraintChecker.check(IRON_LAWS['no_implementation_without_requirement_review'], context);
-    expect(result.satisfied).toBe(true);
-  });
-
-  it('should fail no_implementation_without_requirement when hasRequirement is undefined', async () => {
+  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.satisfied).toBe(false);
+    expect(result.skipped).toBe(true);
+    expect(result.satisfied).toBe(true);
   });
 
   it('should pass no_implementation_without_requirement when hasRequirement is true', async () => {
@@ -211,9 +235,9 @@ describe('Constraint Levels', () => {
     });
   });
 
-  it('should have correct level for tips', () => {
-    Object.values(TIPS).forEach(tip => {
-      expect(tip.level).toBe('tip');
+  it('should have correct level for prompts', () => {
+    Object.values(PROMPTS).forEach(prompt => {
+      expect(prompt.level).toBe('prompt');
     });
   });
 });