@dommaker/harness 1.1.1 → 1.2.1

package/src/__tests__/public-exports.test.ts

@@ -0,0 +1,138 @@
+/**
+ * 公共导出防回归（ADR-0003）
+ *
+ * 包根导出收敛为显式清单后，任何增删公共符号都必须显式评审：
+ * 改动 src/index.ts 导出清单时同步更新本文件的 EXPECTED_RUNTIME_EXPORTS，
+ * diff 即 PR 评审材料。
+ *
+ * 注意：Object.keys 只能看到运行时（值）导出；纯类型导出由
+ * src/index.ts 显式清单在编译期把关，不在本测试断言范围内。
+ */
+
+const EXPECTED_RUNTIME_EXPORTS = [
+  'AdaptiveTokenBudget',
+  'AgentLifecycle',
+  'CONSTRAINTS_END_MARKER',
+  'CONSTRAINTS_START_MARKER',
+  'CSOValidator',
+  'CheckCache',
+  'CheckpointValidator',
+  'CleanStateManager',
+  'ColdStartImporter',
+  'CommandGate',
+  'ConstraintViolationError',
+  'ConstraintViolationHandler',
+  'ContextTracker',
+  'ContractGate',
+  'DEFAULT_CLASSIFICATION_RULES',
+  'DEFAULT_CODE_CHECKPOINTS',
+  'DEFAULT_COMMAND_BLACKLIST',
+  'DEFAULT_COMPACTION_CONFIG',
+  'DEFAULT_DECAY_CONFIG',
+  'DEFAULT_LEVEL_MAPPING',
+  'DEFAULT_NONCODE_GLOBS',
+  'DEFAULT_TEST_GLOBS',
+  'DEFAULT_TRACE_FILE',
+  'ErrorClassifier',
+  'ErrorType',
+  'FailureLevel',
+  'FailureRecorder',
+  'FileKnowledgeStore',
+  'GATE_DEFINITIONS',
+  'GUIDELINES',
+  'HookPipeline',
+  'HookRegistry',
+  'IRON_LAWS',
+  'KnowledgeAudit',
+  'KnowledgeHealthScorer',
+  'KnowledgeIngest',
+  'KnowledgeInjector',
+  'KnowledgeLifecycle',
+  'KnowledgeLifecycleHooks',
+  'KnowledgeLinter',
+  'KnowledgeQuery',
+  'MINIMAL_CHECKPOINTS',
+  'PHASE_SUBJECT_RE',
+  'PROMPTS',
+  'PassesGate',
+  'PerformanceGate',
+  'ReferenceTracker',
+  'ReviewGate',
+  'SecurityGate',
+  'SessionCompaction',
+  'SessionManager',
+  'SessionStartup',
+  'SpecAcceptanceGate',
+  'SpecValidator',
+  'TESTED_BY_RE',
+  'TESTS_NONE_RE',
+  'TokenBudget',
+  'TokenEstimator',
+  'TraceAnalyzer',
+  'TraceCollector',
+  'assertGateRegistryClosed',
+  'assertHookRegistryClosed',
+  'bootstrapHarness',
+  'bootstrapHarnessSync',
+  'checkBeforeExecution',
+  'checkConstraint',
+  'checkConstraints',
+  'classifyCommitFiles',
+  'classifyError',
+  'configureTraceCollector',
+  'createAnalyzer',
+  'createCheckerGate',
+  'createCleanStateManager',
+  'createCommandGate',
+  'createContractGate',
+  'createErrorClassifier',
+  'createFailureRecorder',
+  'createPassesGate',
+  'createPerformanceGate',
+  'createReviewGate',
+  'createSecurityGate',
+  'createSessionStartup',
+  'createSpecAcceptanceGate',
+  'decisionFromResult',
+  'executeWithBlock',
+  'executeWithCollect',
+  'executeWithSafeBoolean',
+  'extractCodeStructure',
+  'findConstraintsByTrigger',
+  'getAllConstraints',
+  'getCommandGate',
+  'getCommandRiskLevel',
+  'getConstraint',
+  'getEffectiveConstraints',
+  'getEffectiveGates',
+  'getFailureLevel',
+  'getGate',
+  'getRegistryPath',
+  'getToolsDir',
+  'getTraceCollector',
+  'isCommandAllowed',
+  'lintEffectiveConfig',
+  'listRegisteredGates',
+  'matchAnyGlob',
+  'matchGlob',
+  'migrateKnowledgeEntries',
+  'registeredGateCount',
+  'renderConstraintsByTrigger',
+  'renderConstraintsSection',
+  'resolveGlobs',
+  'runGates',
+  'sanitizeExternalContent',
+  'toErrorStrategy',
+  'validateAllSpecs',
+  'validateSpec',
+  'verifyContractPresence',
+  'verifyPhaseFormat',
+  'verifyTddChain',
+];
+
+describe('公共导出清单（ADR-0003）', () => {
+  it('包根运行时导出键集合与显式清单一致', async () => {
+    const mod = await import('../index');
+    expect(Object.keys(mod).sort()).toEqual([...EXPECTED_RUNTIME_EXPORTS].sort());
+  });
+});

package/src/__tests__/trace-analyzer-extra.test.ts

@@ -65,22 +65,21 @@ describe('TraceAnalyzer - 补充覆盖', () => {
   describe('compareWithPrevious', () => {
     it('应该计算环比变化', () => {
       const current: any[] = [
-        { constraintId: 'test', passRate: 0.8, failRate: 0.2, bypassRate: 0.1, level: 'iron_law' },
+        { constraintId: 'test', passRate: 0.8, failRate: 0.2, level: 'iron_law' },
       ];
       const previous: any[] = [
-        { constraintId: 'test', passRate: 0.6, failRate: 0.4, bypassRate: 0.2, level: 'iron_law' },
+        { constraintId: 'test', passRate: 0.6, failRate: 0.4, level: 'iron_law' },
       ];
 
       const result = analyzer.compareWithPrevious(current, previous);
-      
+
       expect(result[0]?.changeFromLastPeriod?.passRateDelta).toBeCloseTo(0.2);
       expect(result[0]?.changeFromLastPeriod?.failRateDelta).toBeCloseTo(-0.2);
-      expect(result[0]?.changeFromLastPeriod?.bypassRateDelta).toBeCloseTo(-0.1);
     });
 
     it('无历史数据应该不设置变化', () => {
       const current: any[] = [
-        { constraintId: 'new_test', passRate: 0.8, failRate: 0.2, bypassRate: 0.1, level: 'iron_law' },
+        { constraintId: 'new_test', passRate: 0.8, failRate: 0.2, level: 'iron_law' },
       ];
       const previous: any[] = [];
 
@@ -93,7 +92,7 @@ describe('TraceAnalyzer - 补充覆盖', () => {
   describe('saveSummary/loadSummary', () => {
     it('应该保存和加载汇总', () => {
       const summaries: any[] = [
-        { constraintId: 'test', passRate: 0.8, failRate: 0.2, bypassRate: 0.1, level: 'iron_law', totalChecks: 10 },
+        { constraintId: 'test', passRate: 0.8, failRate: 0.2, level: 'iron_law', totalChecks: 10 },
       ];
 
       analyzer.saveSummary(summaries);
@@ -157,7 +156,6 @@ describe('TraceAnalyzer - 补充覆盖', () => {
           level: 'iron_law',
           passRate: 0.8,
           failRate: 0.2,
-          bypassRate: 0.1,
           totalChecks: 100,
           recentTrend: 'stable',
         },
@@ -190,46 +188,6 @@ describe('TraceAnalyzer - 补充覆盖', () => {
     });
   });
 
-  describe('findMostCommon', () => {
-    it('应该找出最常见元素', () => {
-      // 通过 bypassReasons 统计来触发
-      const traces: ExecutionTrace[] = [
-        { constraintId: 'common_test', level: 'iron_law', timestamp: 1000, result: 'pass' },
-        { constraintId: 'common_test', level: 'iron_law', timestamp: 2000, result: 'pass', bypassReason: 'reason_a' },
-        { constraintId: 'common_test', level: 'iron_law', timestamp: 3000, result: 'pass', bypassReason: 'reason_a' },
-        { constraintId: 'common_test', level: 'iron_law', timestamp: 4000, result: 'pass', bypassReason: 'reason_b' },
-      ];
-
-      const summaries = analyzer.summarize(traces);
-
-      // 验证汇总结果存在
-      expect(summaries.length).toBeGreaterThan(0);
-    });
-
-    it('应该通过 exceptionApplied 触发 findMostCommon', () => {
-      const traces: ExecutionTrace[] = [
-        { constraintId: 'exc_test', level: 'guideline', timestamp: 1000, result: 'pass', exceptionApplied: 'simple_typo' },
-        { constraintId: 'exc_test', level: 'guideline', timestamp: 2000, result: 'pass', exceptionApplied: 'simple_typo' },
-        { constraintId: 'exc_test', level: 'guideline', timestamp: 3000, result: 'pass', exceptionApplied: 'config_error' },
-      ];
-
-      const summaries = analyzer.summarize(traces);
-      const summary = summaries.find(s => s.constraintId === 'exc_test');
-
-      expect(summary?.exceptionCount).toBe(3);
-      expect(summary?.mostCommonException).toBe('simple_typo');
-    });
-
-    it('无 exception 时 mostCommonException 应该是 undefined', () => {
-      const traces: ExecutionTrace[] = [
-        { constraintId: 'no_exc', level: 'iron_law', timestamp: 1000, result: 'pass' },
-      ];
-
-      const summaries = analyzer.summarize(traces);
-      expect(summaries[0]?.mostCommonException).toBeUndefined();
-    });
-  });
-
   describe('detectAnomalies - 更多异常类型', () => {
     it('应该检测 rising_fail_rate', () => {
       // 前半段全 fail，后半段全 pass → rising 趋势
@@ -253,44 +211,6 @@ describe('TraceAnalyzer - 补充覆盖', () => {
       const risingFail = anomalies.find(a => a.type === 'rising_fail_rate');
       expect(risingFail).toBeDefined();
     });
-
-    it('应该检测 rising_bypass_rate', () => {
-      // 前半段全 fail，后半段混合 pass+bypass → rising 趋势
-      // bypassRate 需要 > 0.1，且 trend === 'rising'
-      const traces: ExecutionTrace[] = [];
-      for (let i = 0; i < 6; i++) {
-        traces.push({ constraintId: 'rising_bypass', level: 'guideline', timestamp: 1000 + i * 100, result: 'fail' });
-      }
-      for (let i = 6; i < 14; i++) {
-        // 后半段有 pass 也有 bypass，使 passRate 上升（rising），同时 bypassRate > 0.1
-        traces.push({ constraintId: 'rising_bypass', level: 'guideline', timestamp: 1000 + i * 100, result: i % 2 === 0 ? 'pass' : 'bypassed' });
-      }
-
-      const summaries = analyzer.summarize(traces);
-      const anomalies = analyzer.detectAnomalies(summaries);
-
-      const risingBypass = anomalies.find(a => a.type === 'rising_bypass_rate');
-      expect(risingBypass).toBeDefined();
-    });
-
-    it('应该检测 exception_overuse', () => {
-      const traces: ExecutionTrace[] = [];
-      for (let i = 0; i < 10; i++) {
-        traces.push({
-          constraintId: 'exc_overuse',
-          level: 'guideline',
-          timestamp: 1000 + i * 100,
-          result: 'pass',
-          exceptionApplied: i < 8 ? 'simple_typo' : undefined,
-        });
-      }
-
-      const summaries = analyzer.summarize(traces);
-      const anomalies = analyzer.detectAnomalies(summaries);
-
-      const excOveruse = anomalies.find(a => a.type === 'exception_overuse');
-      expect(excOveruse).toBeDefined();
-    });
   });
 
   describe('createAnalyzer 工厂函数', () => {
@@ -300,7 +220,7 @@ describe('TraceAnalyzer - 补充覆盖', () => {
     });
 
     it('应该支持自定义配置', () => {
-      const a = createAnalyzer({ thresholds: { bypassRate: 0.05 } });
+      const a = createAnalyzer({ thresholds: { failRate: 0.05 } });
       expect(a).toBeDefined();
     });
   });

package/src/__tests__/trace-analyzer.test.ts

@@ -75,11 +75,11 @@ describe('TraceAnalyzer', () => {
   });
 
   describe('detectAnomalies', () => {
-    it('应该检测高绕过率异常', () => {
+    it('应该检测失败率异常', () => {
       const traces: ExecutionTrace[] = [
-        { constraintId: 'test', level: 'guideline', timestamp: 1000, result: 'bypassed' },
-        { constraintId: 'test', level: 'guideline', timestamp: 2000, result: 'bypassed' },
-        { constraintId: 'test', level: 'guideline', timestamp: 3000, result: 'bypassed' },
+        { constraintId: 'test', level: 'guideline', timestamp: 1000, result: 'fail' },
+        { constraintId: 'test', level: 'guideline', timestamp: 2000, result: 'fail' },
+        { constraintId: 'test', level: 'guideline', timestamp: 3000, result: 'fail' },
         { constraintId: 'test', level: 'guideline', timestamp: 4000, result: 'pass' },
       ];
 
@@ -120,7 +120,6 @@ describe('TraceAnalyzer', () => {
     it('应该支持自定义阈值', () => {
       const customAnalyzer = new TraceAnalyzer(collector, {
         thresholds: {
-          bypassRate: 0.1,
           failRate: 0.2,
         },
       });

package/src/__tests__/trace-collector.test.ts

@@ -104,17 +104,6 @@ describe('TraceCollector', () => {
     });
   });
 
-  describe('recordBypass', () => {
-    it('应该记录绕过 trace', () => {
-      collector.recordBypass('no_bypass_checkpoint', 'iron_law', 'Emergency fix');
-
-      const traces = collector.read();
-      expect(traces.length).toBe(1);
-      expect(traces[0].result).toBe('bypassed');
-      expect(traces[0].bypassReason).toBe('Emergency fix');
-    });
-  });
-
   describe('read', () => {
     it('应该返回所有 traces', () => {
       collector.record({

package/src/__tests__/traces.test.ts

@@ -57,7 +57,7 @@ describe('TraceCollector', () => {
   test('should filter traces by constraint ID', () => {
     collector.recordPass('constraint_a', 'iron_law');
     collector.recordFail('constraint_b', 'guideline');
-    collector.recordBypass('constraint_a', 'iron_law', 'user reason');
+    collector.recordFail('constraint_a', 'iron_law');
 
     const traces = collector.read({ constraintId: 'constraint_a' });
     expect(traces.length).toBe(2);
@@ -226,7 +226,7 @@ describe('TraceAnalyzer', () => {
         constraintId: 'constraint_b',
         level: 'iron_law',
         timestamp: Date.now() - i * 60 * 1000,
-        result: i < 3 ? 'pass' : 'bypassed',
+        result: i < 3 ? 'pass' : 'fail',
       });
     }
 
@@ -243,26 +243,7 @@ describe('TraceAnalyzer', () => {
 
     const summaryB = summaries.find(s => s.constraintId === 'constraint_b');
     expect(summaryB).toBeDefined();
-    expect(summaryB!.bypassRate).toBeCloseTo(0.4, 1);
-  });
-
-  test('should detect high bypass rate anomaly', () => {
-    // 记录高绕过率的 traces
-    for (let i = 0; i < 10; i++) {
-      collector.record({
-        constraintId: 'problematic_constraint',
-        level: 'guideline',
-        timestamp: Date.now(),
-        result: i < 3 ? 'pass' : 'bypassed', // 70% 绕过率
-      });
-    }
-
-    const traces = collector.read();
-    const summaries = analyzer.summarize(traces);
-    const anomalies = analyzer.detectAnomalies(summaries);
-
-    expect(anomalies.length).toBeGreaterThan(0);
-    expect(anomalies.some(a => a.type === 'high_bypass_rate')).toBe(true);
+    expect(summaryB!.failRate).toBeCloseTo(0.4, 1);
   });
 
   test('should detect rising fail rate anomaly', () => {

package/src/cli/commands/CONTEXT.md

@@ -10,9 +10,9 @@ H5（#44）起：
 ## 核心导出
 - `COMMAND_DEFINITIONS`（definitions.ts）— 全部非门禁命令定义（纯数据模块，禁止 import 命令实现）
 - 各命令文件：check / validate / passes-gate / init / report / status / spec / sync-docs / knowledge / sdd / failure / posteval-plan / release / analyze-sessions / update-user-model / constraints / doc-freshness-check / spec-baseline-check
-- 6 门禁命令实现在 `acceptance` / `command` / `contract` / `performance` / `review` / `security`（其 CLI 元数据在 `src/gates/definitions.ts`）
+- 6 门禁命令实现在 `acceptance` / `command` / `contract` / `performance` / `review` / `security`（其 CLI 元数据在 `src/gates/definitions.ts`，形状同为 `CommandDefinition`，ADR-0007）
 
-`constraints` 下挂治理子命令：`constraints report`（使用统计 + 退役候选诊断 + 配置健康 + 注入漂移，`--export` 脱敏）、`constraints retire`（交互选择 + 人确认退役；带 id 直达需显式 `--yes`（#24 人确认闸门），无 `--yes` 报错 + 非零退出码且不落盘；内置落 config.yml retired 元数据，custom 落 custom-constraints.yml 条目 retired 段（#82 D6 一处真相）+ KnowledgeStore 沉淀 + CLAUDE.md 注入段同步）。
+`constraints` 下挂治理子命令：`constraints report`（使用统计 + 退役候选诊断 + 配置健康 + 注入漂移，`--export` 脱敏）、`constraints retire`（交互选择 + 人确认退役；带 id 直达需显式 `--yes`（#24 人确认闸门），无 `--yes` 报错 + 非零退出码且不落盘；内置落 config.yml retired 元数据，custom 落 custom-constraints.yml 条目 retired 段（#82 D6 一处真相）+ KnowledgeStore 沉淀 + 治理注入段同步）。
 
 ## 依赖关系
 - 依赖 `src/core/constraints/` 约束引擎
@@ -30,5 +30,8 @@ H5（#44）起：
 
 ## 注意事项
 - 新增命令需同步更新 CLAUDE.md / CAPABILITIES.md / src/CONTEXT.md
+- init 治理约束段写入落点（studio #302，ADR 2026-08-21 落点模型）：新仓 → AGENTS.md `PRESERVE:governance` 段（sync-docs 重新生成时保留）；旧模型仓（CLAUDE.md 已有 HARNESS_CONSTRAINTS 标记或 `## Governance Rules` 块）→ 续写 CLAUDE.md，幂等重跑不制造双份正本。治理段「在场守护」由 core 侧 governance_presence checker 承担（段缺失/为空时 check 报警）
+- PRESERVE:governance 段内写入纪律：机器管理的只有 HARNESS_CONSTRAINTS 标记区间——有标记只换标记区间，无标记（纯手写段）在段尾追加注入段；段内其余手写内容（治理契约引言/流程/纪律等）必须原样保留（曾整段替换清空手写内容的回归，init-injection.test 有防回归用例）
+- 注入段读取侧同一路由（studio #307）：`resolveInjectionTarget`（core/constraints/injection-drift）按「CLAUDE.md 有标记优先，否则 AGENTS.md」定位注入段，`detectInjectionDrift` 与 `constraints retire` 的注入段同步共用；未注入 = 两处均无完整标记段
 - knowledge 命令包含 13 个子操作（list/search/import/decay/stats/upsert/sync-status/sync-rag/audit/snapshot/migrate/index/health）
-- 特殊路由（选项条件、子命令兜底、退出码处理）表达在定义表的 optionRoutes / subcommands / afterRun 字段，bin 是纯通用引擎、不含单命令知识
+- 特殊路由（选项条件、子命令兜底、退出码处理、裸跑语义）表达在定义表的 optionRoutes / subcommands / subcommandStrict / bareRunsAction / afterRun 字段，bin 是纯通用引擎、不含单命令知识

package/src/cli/commands/__tests__/check-skip-output.test.ts

@@ -34,13 +34,16 @@ jest.mock('../../../core/constraints/checker', () => ({
   },
 }));
 
-// Mock ProjectConfigLoader
-jest.mock('../../../core/project-config-loader', () => ({
-  ProjectConfigLoader: jest.fn().mockImplementation(() => ({
-    load: jest.fn(),
-    hasCustomConfig: jest.fn().mockReturnValue(false),
-    mergeConstraints: jest.fn().mockReturnValue({ custom: [], disabled: [] }),
-  })),
+// Mock effective-constraints（ADR-0001：check 经 getMergedConstraintsConfig 走生效集链路）
+jest.mock('../../../core/effective-constraints', () => ({
+  getMergedConstraintsConfig: jest.fn().mockReturnValue({
+    ironLaws: {},
+    guidelines: {},
+    prompts: {},
+    custom: [],
+    disabled: [],
+    unknownIds: [],
+  }),
 }));
 
 // Mock chalk

package/src/cli/commands/__tests__/check.test.ts

@@ -5,7 +5,7 @@
 import { check, listLaws } from '../check';
 import * as fs from 'fs';
 import { constraintChecker } from '../../../core/constraints/checker';
-import { ProjectConfigLoader } from '../../../core/project-config-loader';
+import { getMergedConstraintsConfig } from '../../../core/effective-constraints';
 import { execAsync } from '../../../utils/exec';
 
 // Mock fs
@@ -45,13 +45,16 @@ jest.mock('../../../core/constraints/checker', () => ({
   },
 }));
 
-// Mock ProjectConfigLoader
-jest.mock('../../../core/project-config-loader', () => ({
-  ProjectConfigLoader: jest.fn().mockImplementation(() => ({
-    load: jest.fn(),
-    hasCustomConfig: jest.fn().mockReturnValue(false),
-    mergeConstraints: jest.fn().mockReturnValue({ custom: [], disabled: [] }),
-  })),
+// Mock effective-constraints（ADR-0001：check 经 getMergedConstraintsConfig 走生效集链路）
+jest.mock('../../../core/effective-constraints', () => ({
+  getMergedConstraintsConfig: jest.fn().mockReturnValue({
+    ironLaws: {},
+    guidelines: {},
+    prompts: {},
+    custom: [],
+    disabled: [],
+    unknownIds: [],
+  }),
 }));
 
 // Mock chalk
@@ -65,7 +68,7 @@ jest.mock('chalk', () => ({
 
 const mockFs = fs as jest.Mocked<typeof fs> & { readdirSync: jest.Mock };
 const mockChecker = constraintChecker as jest.Mocked<typeof constraintChecker>;
-const MockProjectConfigLoader = ProjectConfigLoader as jest.MockedClass<typeof ProjectConfigLoader>;
+const mockGetMergedConfig = getMergedConstraintsConfig as jest.MockedFunction<typeof getMergedConstraintsConfig>;
 const mockExecAsync = execAsync as jest.MockedFunction<typeof execAsync>;
 
 describe('check command', () => {
@@ -73,6 +76,15 @@ describe('check command', () => {
 
   beforeEach(() => {
     jest.clearAllMocks();
+    // clearAllMocks 不清实现，显式恢复默认 merged config，避免用例间泄漏
+    mockGetMergedConfig.mockReturnValue({
+      ironLaws: {},
+      guidelines: {},
+      prompts: {},
+      custom: [],
+      disabled: [],
+      unknownIds: [],
+    });
     consoleSpy = jest.spyOn(console, 'log').mockImplementation();
     process.exitCode = 0;
   });
@@ -123,12 +135,14 @@ describe('check command', () => {
     });
 
     it('应该加载自定义约束', async () => {
-      const mockLoader = {
-        load: jest.fn(),
-        hasCustomConfig: jest.fn().mockReturnValue(true),
-        mergeConstraints: jest.fn().mockReturnValue({ custom: [{ id: 'custom', rule: 'test', message: 'test', level: 'iron_law', trigger: 'code_implementation', enforcement: 'checkpoint-required' }], disabled: ['disabled_constraint'] }),
-      };
-      (MockProjectConfigLoader as any).mockImplementation(() => mockLoader);
+      mockGetMergedConfig.mockReturnValue({
+        ironLaws: {},
+        guidelines: {},
+        prompts: {},
+        custom: ['custom'],
+        disabled: ['disabled_constraint'],
+        unknownIds: [],
+      });
 
       mockChecker.checkConstraints.mockResolvedValue({
         passed: true,
@@ -399,23 +413,6 @@ describe('check command', () => {
       expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('记录已足够'));
     });
 
-    it('应该在绕过率高时提示查看详情', async () => {
-      // 20 条记录，15 条 bypassed (75% > 30%)
-      const traces = [
-        ...Array(5).fill('{"result":"pass"}'),
-        ...Array(15).fill('{"result":"bypassed"}'),
-      ].join('\n');
-      mockFs.existsSync.mockImplementation((p: any) => {
-        if (p.includes('traces.log')) return true;
-        if (p.includes('.state.json')) return false;
-        return false;
-      });
-      mockFs.readFileSync.mockReturnValue(traces);
-
-      await check({ preset: 'default', staged: false });
-      expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('异常趋势'));
-    });
-
     it('应该不重复显示已显示的提示', async () => {
       const traces = Array(50).fill('{"result":"pass"}').join('\n');
       mockFs.existsSync.mockReturnValue(true);
@@ -445,43 +442,6 @@ describe('check command', () => {
       expect(output).not.toContain('────────────────');
     });
 
-    it('应该在绕过率低于 30% 时不提示', async () => {
-      // 20 条记录，2 条 bypassed (10% < 30%)
-      const traces = [
-        ...Array(18).fill('{"result":"pass"}'),
-        ...Array(2).fill('{"result":"bypassed"}'),
-      ].join('\n');
-      mockFs.existsSync.mockImplementation((p: any) => {
-        if (p.includes('traces.log')) return true;
-        if (p.includes('.state.json')) return false;
-        return false;
-      });
-      mockFs.readFileSync.mockReturnValue(traces);
-
-      await check({ preset: 'default', staged: false });
-      const output = consoleSpy.mock.calls.map(c => c[0]).join('\n');
-      expect(output).not.toContain('异常趋势');
-    });
-
-    it('应该处理无效 JSON trace 行', async () => {
-      // 20 条记录，部分无效 JSON，部分 bypassed
-      const traces = [
-        ...Array(5).fill('invalid json'),
-        ...Array(5).fill('{"result":"pass"}'),
-        ...Array(10).fill('{"result":"bypassed"}'),
-      ].join('\n');
-      mockFs.existsSync.mockImplementation((p: any) => {
-        if (p.includes('traces.log')) return true;
-        if (p.includes('.state.json')) return false;
-        return false;
-      });
-      mockFs.readFileSync.mockReturnValue(traces);
-
-      await check({ preset: 'default', staged: false });
-      // 15 条有效，10 条 bypassed，bypassRate = 10/20 = 0.5 > 0.3
-      expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('异常趋势'));
-    });
-
     it('应该保存状态文件当有提示时', async () => {
       const traces = Array(50).fill('{"result":"pass"}').join('\n');
       mockFs.existsSync.mockImplementation((p: any) => {

package/src/cli/commands/__tests__/constraints-report.test.ts

@@ -57,14 +57,14 @@ describe('buildConstraintsUsageReport', () => {
     const report = buildConstraintsUsageReport(root);
 
     expect(report.traceFileExists).toBe(false);
-    expect(report.stats.length).toBe(9); // 5 iron + 4 guideline
+    expect(report.stats.length).toBe(10); // 5 iron + 5 guideline
     for (const s of report.stats) {
       expect(s.total).toBe(0);
       expect(s.evaluated).toBe(0);
       expect(s.failRate).toBe(0);
       expect(s.firstAt).toBeUndefined();
     }
-    expect(report.candidates.length).toBe(9);
+    expect(report.candidates.length).toBe(10);
     expect(report.candidates.every(c => c.kind === 'zero_trigger')).toBe(true);
     // prompt 注入清单（standard preset、无 scenes → 14 条通用 prompt）
     expect(report.activePromptIds.length).toBe(14);
@@ -170,7 +170,7 @@ describe('buildConstraintsUsageReport', () => {
     const candidates = diagnoseRetireCandidates([
       {
         id: 'x', level: 'guideline',
-        total: 60, pass: 0, fail: 0, skip: 60, bypassed: 0,
+        total: 60, pass: 0, fail: 0, skip: 60,
         evaluated: 0, failRate: 0,
       },
     ]);