@dommaker/harness 1.1.0 → 1.2.0

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

@@ -87,7 +87,7 @@ describe('status command', () => {
       mockFs.readFileSync.mockReturnValue(mockTraces.map(t => JSON.stringify(t)).join('\n'));
 
       const mockSummarize = jest.fn().mockReturnValue([
-        { constraintId: 'test1', level: 'iron_law', passRate: 1, totalChecks: 1, bypassRate: 0 },
+        { constraintId: 'test1', level: 'iron_law', passRate: 1, failRate: 0, totalChecks: 1 },
       ]);
       const mockAnalyze = {
         summarize: mockSummarize,
@@ -106,7 +106,7 @@ describe('status command', () => {
       mockFs.readFileSync.mockReturnValue(mockTraces.map(t => JSON.stringify(t)).join('\n'));
 
       const mockSummarize = jest.fn().mockReturnValue([
-        { constraintId: 'no_bypass_checkpoint', level: 'iron_law', passRate: 1, totalChecks: 5, bypassRate: 0 },
+        { constraintId: 'no_bypass_checkpoint', level: 'iron_law', passRate: 1, failRate: 0, totalChecks: 5 },
       ]);
       const mockAnalyze = {
         summarize: mockSummarize,
@@ -131,7 +131,7 @@ describe('status command', () => {
       ];
       const mockAnalyze = {
         summarize: jest.fn().mockReturnValue([
-          { constraintId: 'test1', level: 'iron_law', passRate: 0.2, totalChecks: 5, bypassRate: 0 },
+          { constraintId: 'test1', level: 'iron_law', passRate: 0.2, failRate: 0.8, totalChecks: 5 },
         ]),
         detectAnomalies: jest.fn().mockReturnValue(mockAnomalies),
       };
@@ -150,7 +150,7 @@ describe('status command', () => {
       mockFs.readFileSync.mockReturnValue(mockTraces.map(t => JSON.stringify(t)).join('\n'));
 
       const mockSummarize = jest.fn().mockReturnValue([
-        { constraintId: 'test1', level: 'iron_law', passRate: 0.8, totalChecks: 10, bypassRate: 0.1 },
+        { constraintId: 'test1', level: 'iron_law', passRate: 0.8, failRate: 0.2, totalChecks: 10 },
       ]);
       const mockAnalyze = {
         summarize: mockSummarize,
@@ -184,7 +184,7 @@ describe('status command', () => {
 
       const mockAnalyze = {
         summarize: jest.fn().mockReturnValue([
-          { constraintId: 'test_guide', level: 'guideline', passRate: 0.9, totalChecks: 10, bypassRate: 0 },
+          { constraintId: 'test_guide', level: 'guideline', passRate: 0.9, failRate: 0.1, totalChecks: 10 },
         ]),
         detectAnomalies: jest.fn().mockReturnValue([]),
       };
@@ -193,21 +193,6 @@ describe('status command', () => {
       await status({});
       expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('Guidelines'));
     });
-
-    it('应该显示 Tips 统计', async () => {
-      mockFs.readFileSync.mockReturnValue('{"constraintId":"test"}');
-
-      const mockAnalyze = {
-        summarize: jest.fn().mockReturnValue([
-          { constraintId: 'test_tip', level: 'tip', passRate: 1, totalChecks: 5, bypassRate: 0 },
-        ]),
-        detectAnomalies: jest.fn().mockReturnValue([]),
-      };
-      (MockTraceAnalyzer as any).mockImplementation(() => mockAnalyze);
-
-      await status({});
-      expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('Tips'));
-    });
   });
 
   describe('异常模式', () => {
@@ -291,7 +276,7 @@ describe('status command', () => {
 
       const mockAnalyze = {
         summarize: jest.fn().mockReturnValue([
-          { constraintId: 'test_guide', level: 'guideline', passRate: 0.6, totalChecks: 10, bypassRate: 0.1 },
+          { constraintId: 'test_guide', level: 'guideline', passRate: 0.6, failRate: 0.4, totalChecks: 10 },
         ]),
         detectAnomalies: jest.fn().mockReturnValue([]),
       };

package/src/cli/commands/check.ts

@@ -2,17 +2,16 @@
  * harness check 命令
  *
  * 检查约束是否满足（check 层：Iron Laws / Guidelines；prompt 层仅注入不检查）
- * 工单 23：触发条件与证据检测迁至 core/constraints/context-builder；--preset 经 mergeConstraints 生效
- * ADR-0001：约束集统一走 mergeConstraints 生效集链路（preset/config 禁用/custom/scenes）
+ * 工单 23：触发条件与证据检测迁至 core/constraints/context-builder
+ * ADR-0001：约束集统一走 getMergedConstraintsConfig 生效集链路（preset/config 禁用/custom/scenes）
  */
 
 import chalk from 'chalk';
 import * as fs from 'fs';
 import * as path from 'path';
 import { constraintChecker } from '../../core/constraints/checker';
-import { getTraceCollector } from '../../monitoring/traces';
 import { IRON_LAWS, GUIDELINES, PROMPTS } from '../../core/constraints/definitions';
-import { ProjectConfigLoader } from '../../core/project-config-loader';
+import { getMergedConstraintsConfig } from '../../core/effective-constraints';
 import { buildConstraintContext } from '../../core/constraints/context-builder';
 import { detectInjectionDrift } from '../../core/constraints/injection-drift';
 import { DEFAULT_TRACE_FILE } from '../../types/trace';
@@ -37,18 +36,12 @@ export async function check(options: CheckOptions): Promise<void> {
   console.log(chalk.gray(`预设: ${options.preset}`));
 
   try {
-    // 加载项目级自定义约束
     const projectPath = options.projectPath || process.cwd();
-    const configLoader = new ProjectConfigLoader(projectPath);
-    configLoader.load();
-    constraintChecker.setTraceRecorder(getTraceCollector());
 
     // 生效约束集（ADR-0001）：内置 → preset → config.yml 禁用 → custom 追加 → scenes 过滤。
-    // --preset 仅在没有项目自定义配置时覆盖 config.yml 的 preset（保持工单 23 语义：
-    // 项目自定义配置优先于 CLI 预设）。
-    const merged = configLoader.hasCustomConfig()
-      ? configLoader.mergeConstraints()
-      : configLoader.mergeConstraints({ preset: options.preset || 'standard' });
+    // --preset 仅在没有项目自定义配置时覆盖 config.yml 的 preset（工单 23 语义：
+    // 项目自定义配置优先于 CLI 预设），优先级规则收在 getMergedConstraintsConfig 一处。
+    const merged = getMergedConstraintsConfig(projectPath, { preset: options.preset });
     if (merged.custom.length > 0) {
       console.log(chalk.gray(`自定义约束: ${merged.custom.length} 条`));
     }
@@ -199,23 +192,7 @@ async function getSmartHint(projectPath: string): Promise<string | null> {
     hints.push('📊 记录已足够，运行 harness status 查看统计');
     state.shownHints.push('trace_50');
   }
-  
-  // 条件 2: 检查异常趋势（简单检查绕过率）
-  const bypassCount = lines.filter(line => {
-    try {
-      const trace = JSON.parse(line);
-      return trace.result === 'bypassed';
-    } catch {
-      return false;
-    }
-  }).length;
-  
-  const bypassRate = traceCount > 10 ? bypassCount / traceCount : 0;
-  if (bypassRate > 0.3 && !state.shownHints.includes('high_bypass')) {
-    hints.push('⚠️ 发现异常趋势，建议运行 harness status 查看详情');
-    state.shownHints.push('high_bypass');
-  }
-  
+
   // 保存状态
   if (hints.length > 0) {
     fs.mkdirSync(path.dirname(statePath), { recursive: true });
@@ -242,14 +219,11 @@ export function listLaws(): void {
   });
 
   // Guidelines
-  console.log(chalk.yellow('🟡 指导原则 (Guidelines) - 优先建议，有例外:\n'));
+  console.log(chalk.yellow('🟡 指导原则 (Guidelines) - 优先建议，违背发警告但不阻止:\n'));
   Object.values(GUIDELINES).forEach(constraint => {
     console.log(chalk.yellow(`  ${constraint.id}`));
     console.log(chalk.gray(`    ${constraint.rule}`));
     console.log(chalk.gray(`    ${constraint.message}`));
-    if (constraint.exceptions && constraint.exceptions.length > 0) {
-      console.log(chalk.gray(`    例外: ${constraint.exceptions.join(', ')}`));
-    }
     console.log();
   });
 

package/src/cli/commands/definitions.ts

@@ -81,6 +81,8 @@ export interface CommandDefinition {
   subcommands?: Record<string, CommandSubcommand>;
   /** false = 未知位置参数不报错、落回默认 action（spec 的文件参数用法） */
   subcommandStrict?: boolean;
+  /** true = 有 subcommands 但无位置参数时运行默认 action 而非显示帮助（门禁命令语义） */
+  bareRunsAction?: boolean;
   /** 选项条件路由（匹配时替代默认 action 执行） */
   optionRoutes?: CommandOptionRoute[];
   /** 默认 action 实参构造（缺省为 [options]） */

package/src/cli/commands/init.ts

@@ -37,19 +37,15 @@ export interface InitOptions {
 
 /**
  * 默认配置
+ *
+ * 只写有运行时消费者的字段：preset（ADR-0001 生效集链路由 mergeConstraints 消费）。
+ * 历史模板里的 enabled / ironLaws.enforceErrors / ironLaws.warnWarnings /
+ * validators.{checkpoint,passesGate,cso} 均为零消费者的死字段，不再写入；
+ * strict/standard/relaxed 三档差异曾只存在于这些死字段上（实为两档），
+ * 现在三档差异完全由 preset 键经生效集链路体现。
  */
 const DEFAULT_CONFIG = {
   preset: 'standard',
-  enabled: true,
-  ironLaws: {
-    enforceErrors: true,
-    warnWarnings: true,
-  },
-  validators: {
-    checkpoint: true,
-    passesGate: true,
-    cso: false,
-  },
 };
 
 /**
@@ -59,15 +55,6 @@ const PRESETS = {
   strict: {
     ...DEFAULT_CONFIG,
     preset: 'strict',
-    ironLaws: {
-      enforceErrors: true,
-      warnWarnings: true,
-    },
-    validators: {
-      checkpoint: true,
-      passesGate: true,
-      cso: true,
-    },
   },
   standard: {
     ...DEFAULT_CONFIG,
@@ -76,10 +63,6 @@ const PRESETS = {
   relaxed: {
     ...DEFAULT_CONFIG,
     preset: 'relaxed',
-    ironLaws: {
-      enforceErrors: true,
-      warnWarnings: false,
-    },
   },
 };
 
@@ -483,7 +466,6 @@ custom_constraints:
   #   rule: "NO MOMENT.JS IMPORTS"
   #   message: "禁止使用 moment.js，请使用 date-fns 或 dayjs"
   #   trigger: ["code_implementation"]
-  #   exceptions: ["legacy_migration"]
 
   # 示例 3：要求特定的文件命名
   # my_project_component_naming:
@@ -492,19 +474,6 @@ custom_constraints:
   #   rule: "REACT COMPONENTS SHOULD BE PASCAL CASE"
   #   message: "React 组件文件名应使用 PascalCase"
   #   trigger: ["file_creation"]
-
-# ========================================
-# 扩展内置约束的例外
-# ========================================
-
-# 如果需要为内置约束添加项目特定的例外，
-# 可以在 .harness/config.yml 中配置：
-
-# constraints:
-#   no_fix_without_root_cause:
-#     # 添加项目特定的例外
-#     exceptions:
-#       - my_custom_exception
 `;
 
   await fs.writeFile(customConstraintsPath, content, 'utf-8');

package/src/cli/commands/knowledge.ts

@@ -81,22 +81,7 @@ export async function knowledgeSearch(
   const store = new KnowledgeStore({ baseDir: getKnowledgeDir(options.projectPath) });
   const queryEngine = new KnowledgeQuery(store);
 
-  const budget = {
-    phase: 'cli',
-    maxTokens: 10000,
-    maxEntries: options.limit || 20,
-    focusTypes: [] as KnowledgeSubsystem[],
-  };
-
-  const result = queryEngine.query(budget);
-
-  // 简单文本匹配过滤
-  const q = query.toLowerCase();
-  const matched = result.entries.filter(e =>
-    e.title.toLowerCase().includes(q) ||
-    e.content.toLowerCase().includes(q) ||
-    e.tags.some(t => t.toLowerCase().includes(q))
-  );
+  const matched = queryEngine.search(query, { limit: options.limit || 20 });
 
   if (options.json) {
     console.log(JSON.stringify({ query, total: matched.length, entries: matched }, null, 2));

package/src/cli/commands/report.ts

@@ -7,7 +7,6 @@
 import chalk from 'chalk';
 import * as fs from 'fs/promises';
 import { ConstraintChecker } from '../../core/constraints/checker';
-import { getTraceCollector } from '../../monitoring/traces';
 import { IRON_LAWS, GUIDELINES, PROMPTS } from '../../core/constraints/definitions';
 import { executeWithCollect } from '../../failure/constraint-handler';
 import type { ConstraintContext } from '../../types/constraint';
@@ -48,7 +47,6 @@ export async function report(options: ReportOptions): Promise<void> {
 
   const projectPath = options.projectPath || process.cwd();
   const checker = ConstraintChecker.getInstance();
-  checker.setTraceRecorder(getTraceCollector());
 
   const allConstraints = { ...IRON_LAWS, ...GUIDELINES, ...PROMPTS };
   const totalConstraints = Object.keys(allConstraints).length;

package/src/cli/commands/status.ts

@@ -109,7 +109,7 @@ export async function status(options: StatusOptions): Promise<void> {
       const status = s.passRate >= 1 ? '✅' : '❌';
       console.log(`  ${status} ${s.constraintId}`);
       if (options.detail) {
-        console.log(chalk.gray(`     检查: ${s.totalChecks} | 通过: ${(s.passRate * 100).toFixed(0)}% | 绕过: ${(s.bypassRate * 100).toFixed(0)}%`));
+        console.log(chalk.gray(`     检查: ${s.totalChecks} | 通过: ${(s.passRate * 100).toFixed(0)}% | 失败: ${(s.failRate * 100).toFixed(0)}%`));
       }
     });
     console.log();
@@ -123,22 +123,12 @@ export async function status(options: StatusOptions): Promise<void> {
       const status = s.passRate >= 0.8 ? '✅' : s.passRate >= 0.5 ? '⚠️' : '❌';
       console.log(`  ${status} ${s.constraintId}`);
       if (options.detail) {
-        console.log(chalk.gray(`     检查: ${s.totalChecks} | 通过: ${(s.passRate * 100).toFixed(0)}% | 绕过: ${(s.bypassRate * 100).toFixed(0)}%`));
+        console.log(chalk.gray(`     检查: ${s.totalChecks} | 通过: ${(s.passRate * 100).toFixed(0)}% | 失败: ${(s.failRate * 100).toFixed(0)}%`));
       }
     });
     console.log();
   }
 
-  // Tips
-  const tipSummaries = summaries.filter((s: TraceSummary) => s.level === 'tip');
-  if (tipSummaries.length > 0) {
-    console.log(chalk.blue('🔵 Tips:'));
-    tipSummaries.forEach((s: TraceSummary) => {
-      console.log(`  💡 ${s.constraintId}`);
-    });
-    console.log();
-  }
-
   // 异常检测
   if (anomalies.length > 0) {
     console.log(chalk.yellow(`⚠️  发现 ${anomalies.length} 个异常`));

package/src/context/index.ts

@@ -1,11 +1,34 @@
 /**
- * 上下文管理模块
+ * 上下文管理模块（ADR-0003：显式清单，禁 export *）
  *
  * Token 预算 + 会话压缩 + 知识注入
  */
 
-export * from './types';
-export * from './token-budget';
-export * from './compaction';
-export * from './session-manager';
-export * from './knowledge-injector';
+// 类型
+export type {
+  CompactionConfig,
+  CompactionLevel,
+  ContextSource,
+  ContextSourceType,
+  ContextUsageSnapshot,
+  SessionCheckpoint,
+  SessionEvent,
+  SessionEventType,
+  SessionHandle,
+  SessionMessage,
+} from './types';
+export { DEFAULT_COMPACTION_CONFIG } from './types';
+
+// Token 预算
+export { AdaptiveTokenBudget, TokenBudget, TokenEstimator } from './token-budget';
+
+// 会话压缩
+export { SessionCompaction } from './compaction';
+export type { CompactionResult } from './compaction';
+
+// 会话管理
+export { SessionManager } from './session-manager';
+
+// 知识注入
+export { KnowledgeInjector } from './knowledge-injector';
+export type { InjectionConfig, InjectionResult } from './knowledge-injector';

package/src/core/CONTEXT.md

@@ -4,12 +4,13 @@
 约束引擎核心：check/prompt 二元约束系统（ADR-0001）、生效集合并（effective-constraints）、检查点验证器(CSO/passes-gate)、会话管理、Spec 验证器、项目配置加载。
 
 ## 核心导出
-- `constraints/` — 约束定义(IRON_LAWS/GUIDELINES/PROMPTS；TIPS 已退役为空表) + 检查引擎(ConstraintChecker) + 拦截器(ConstraintInterceptor) + 缓存(CheckCache：TTL 缓存 + 计数采样，H6/G5 起公开导出) + 注入渲染(injection-renderer) + Agent prompt 渲染(agent-prompt-renderer：trigger 参数化分组渲染，role 路由留 studio，H6/G6)/漂移校验(injection-drift)/使用统计(usage-report)
-- `effective-constraints.ts` — `getEffectiveConstraints(projectRoot)`：全仓唯一生效集来源（内置 → preset → config.yml 禁用（内置与 custom 同效）→ custom 追加（禁用/已退役的不追加）→ scenes 过滤）；`lintEffectiveConfig` 配置诊断
+- `constraints/` — 约束定义(IRON_LAWS/GUIDELINES/PROMPTS) + 检查引擎(ConstraintChecker，拦截统一由 checkBeforeExecution 承担，ADR-0004) + 缓存(CheckCache：TTL 缓存 + 计数采样，H6/G5 起公开导出) + 注入渲染(injection-renderer) + Agent prompt 渲染(agent-prompt-renderer：trigger 参数化分组渲染，role 路由留 studio，H6/G6)/漂移校验(injection-drift)/使用统计(usage-report)；CheckEnv 生产侧唯一构造点 `buildCheckEnv(context, providers|'none')`（checkers/types.ts：providers = 证据接线，'none' = 显式不接 → evidence flag checker 按契约 skip）
+- `effective-constraints.ts` — `getEffectiveConstraints(projectRoot, {preset?})`：全仓唯一生效集来源（内置 → preset → config.yml 禁用（内置与 custom 同效）→ custom 追加（禁用/已退役的不追加）→ scenes 过滤）；`getMergedConstraintsConfig(projectRoot, {preset?})`：同链路的完整 MergedConstraintsConfig 形状（含 disabled/custom/unknownIds），内置工单 23 优先级规则（--preset 仅在无项目自定义配置时生效），check 命令经此入口；`lintEffectiveConfig` 配置诊断
+- `effective-set.ts` — `filterEnabledEntries(knownIds, entries, {onUnknownId})`：约束侧（collect）与门禁侧（throw）共用的 config 条目筛选器
 - `validators/` — checkpoints、passes-gate、CSO 验证器
 - `session/` — 会话管理
 - `spec/validator` — SpecValidator
-- `project-config-loader` — 项目配置加载 + 约束合并
+- `project-config-loader` — 项目配置加载 + 约束合并（mergeConstraints 内含 preset 裁剪：presets/ 纯数据 + 未知名回落 standard，禁用到未知 id 经 effective-set 共享筛选器 collect 模式）
 
 ## 依赖关系
 - 被所有模块依赖（基础层，无上层依赖）

package/src/core/__tests__/effective-set.test.ts

@@ -0,0 +1,80 @@
+/**
+ * effective-set 共享筛选器测试
+ *
+ * 覆盖约束侧（collect）与门禁侧（throw）两种 onUnknownId 模式。
+ */
+
+import { filterEnabledEntries } from '../effective-set';
+
+const KNOWN = new Set(['a', 'b', 'c']);
+
+describe('filterEnabledEntries', () => {
+  describe('onUnknownId: collect（约束侧）', () => {
+    it('已知 id 全部通过，enabled:false 收进 disabledIds', () => {
+      const result = filterEnabledEntries(
+        KNOWN,
+        { a: { enabled: false }, b: { enabled: true }, c: {} },
+        { onUnknownId: 'collect' }
+      );
+      expect(result.disabledIds).toEqual(['a']);
+      expect(result.unknownIds).toEqual([]);
+    });
+
+    it('未知 id 静默忽略并收集进 unknownIds', () => {
+      const result = filterEnabledEntries(
+        KNOWN,
+        { a: {}, ghost: { enabled: false } },
+        { onUnknownId: 'collect' }
+      );
+      expect(result.unknownIds).toEqual(['ghost']);
+      // 未知 id 带 enabled:false 同样计入 disabledIds（历史行为：delete 空桶为 no-op）
+      expect(result.disabledIds).toEqual(['ghost']);
+    });
+
+    it('未知 id 无 enabled 标记时只收集不进 disabledIds', () => {
+      const result = filterEnabledEntries(
+        KNOWN,
+        { ghost: {} },
+        { onUnknownId: 'collect' }
+      );
+      expect(result.unknownIds).toEqual(['ghost']);
+      expect(result.disabledIds).toEqual([]);
+    });
+
+    it('空 entries → 空结果', () => {
+      const result = filterEnabledEntries(KNOWN, {}, { onUnknownId: 'collect' });
+      expect(result).toEqual({ disabledIds: [], unknownIds: [] });
+    });
+  });
+
+  describe('onUnknownId: throw（门禁侧）', () => {
+    it('未知 id 抛错（默认消息）', () => {
+      expect(() =>
+        filterEnabledEntries(KNOWN, { nope: { enabled: false } }, { onUnknownId: 'throw' })
+      ).toThrow(/未注册的 id "nope"/);
+    });
+
+    it('未知 id 抛错（unknownIdError 定制消息）', () => {
+      expect(() =>
+        filterEnabledEntries(
+          KNOWN,
+          { nope: {} },
+          {
+            onUnknownId: 'throw',
+            unknownIdError: id => `gates.${id} 引用了未注册的门禁。可用门禁: a, b, c。`,
+          }
+        )
+      ).toThrow(/gates\.nope 引用了未注册的门禁/);
+    });
+
+    it('已知 id 的 enabled:false 正常收集，不抛错', () => {
+      const result = filterEnabledEntries(
+        KNOWN,
+        { a: { enabled: false }, b: { enabled: true } },
+        { onUnknownId: 'throw' }
+      );
+      expect(result.disabledIds).toEqual(['a']);
+      expect(result.unknownIds).toEqual([]);
+    });
+  });
+});

package/src/core/constraints/capabilities-parser.ts

@@ -9,9 +9,16 @@
 
 import * as fs from 'fs';
 import { IRON_LAWS, GUIDELINES } from './definitions';
+import { COMMAND_DEFINITIONS } from '../../cli/commands/definitions';
+import { GATE_DEFINITIONS } from '../../gates/definitions';
 import { FreshnessRunner } from './doc-freshness/runner';
 import type { DocFreshnessCheck } from '../../types/project-config';
 
+/** CLI 命令数 = 非门禁命令定义 + 门禁命令定义（ADR-0002：定义表是命令形状单一来源） */
+function cliCommandCount(): number {
+  return COMMAND_DEFINITIONS.length + GATE_DEFINITIONS.filter(g => g.cli).length;
+}
+
 /** 匹配表格单元格中的源码文件条目（如 `src/foo.ts`、`foo.tsx`） */
 const FILE_CELL_REGEX = /\|\s*([^|]+?\.(?:ts|tsx|js|jsx))\s*\|/g;
 
@@ -104,41 +111,40 @@ export function aggregateToSourceSubdir(root: string, file: string): string {
 
 // ── 能力清单计数 ────────────────────────────────────────────
 
+/**
+ * 能力清单统计规则单份定义（ADR-0008：check/write 两方向共用，
+ * 此前 label+pattern 在 buildCapabilityChecks 与 updateCapabilityCounts 各写一遍）
+ *
+ * - label：CAPABILITIES.md 计数行 label（check 的 DocFreshnessCheck.label +
+ *   write 的替换文本前缀，如 `Quality Gates (6)`）
+ * - pattern：同时供 check（doc_regex_count 字符串 pattern，捕获组为文档计数）
+ *   与 write（编译为替换 regex）
+ * - actual：定义表实际计数（ADR-0002 单一来源）
+ */
+interface CapabilityCountRule {
+  label: string;
+  pattern: string;
+  actual: () => number;
+}
+
+const CAPABILITY_COUNT_RULES: CapabilityCountRule[] = [
+  { label: 'CLI Commands', pattern: 'CLI Commands\\s*\\((\\d+)\\)', actual: cliCommandCount },
+  { label: 'Quality Gates', pattern: 'Quality Gates?\\s*\\((\\d+)\\)', actual: () => GATE_DEFINITIONS.length },
+  { label: 'Iron Laws', pattern: 'Iron Laws?\\s*\\((\\d+)\\)', actual: () => Object.keys(IRON_LAWS).length },
+  { label: 'Guidelines', pattern: 'Guidelines?\\s*\\((\\d+)\\)', actual: () => Object.keys(GUIDELINES).length },
+];
+
 /**
  * 构建 CAPABILITIES.md 能力清单格式的检查配置
  */
 function buildCapabilityChecks(): DocFreshnessCheck[] {
-  return [
-    {
-      type: 'doc_regex_count',
-      doc: 'CAPABILITIES.md',
-      label: 'CLI Commands',
-      pattern: 'CLI Commands\\s*\\((\\d+)\\)',
-      // index.ts（已删 barrel）与 definitions.ts（命令注册表纯数据）不是命令实现，不计入
-      actual: { kind: 'dir_count', path: 'src/cli/commands', extension: '.ts', exclude: ['index.ts', 'definitions.ts'] },
-    },
-    {
-      type: 'doc_regex_count',
-      doc: 'CAPABILITIES.md',
-      label: 'Quality Gates',
-      pattern: 'Quality Gates?\\s*\\((\\d+)\\)',
-      actual: { kind: 'dir_count', path: 'src/gates', extension: '.ts', exclude: ['index.ts', 'types.ts'] },
-    },
-    {
-      type: 'doc_regex_count',
-      doc: 'CAPABILITIES.md',
-      label: 'Iron Laws',
-      pattern: 'Iron Laws?\\s*\\((\\d+)\\)',
-      actual: { kind: 'const_count', value: Object.keys(IRON_LAWS).length },
-    },
-    {
-      type: 'doc_regex_count',
-      doc: 'CAPABILITIES.md',
-      label: 'Guidelines',
-      pattern: 'Guidelines?\\s*\\((\\d+)\\)',
-      actual: { kind: 'const_count', value: Object.keys(GUIDELINES).length },
-    },
-  ];
+  return CAPABILITY_COUNT_RULES.map(rule => ({
+    type: 'doc_regex_count' as const,
+    doc: 'CAPABILITIES.md',
+    label: rule.label,
+    pattern: rule.pattern,
+    actual: { kind: 'const_count' as const, value: rule.actual() },
+  }));
 }
 
 /**
@@ -164,26 +170,14 @@ export function checkCapabilityCounts(
 /**
  * 更新 CAPABILITIES.md 中的能力清单计数（write 模式）
  *
- * 使用 FreshnessRunner 获取实际计数，然后 regex 替换文档计数行。
+ * 命令/门禁计数取自定义表（ADR-0002 单一来源），regex 替换文档计数行；
+ * 规则与 check 方向共用 CAPABILITY_COUNT_RULES（ADR-0008）。
  */
-export function updateCapabilityCounts(content: string, projectPath: string): string {
-  const runner = new FreshnessRunner();
-
-  const cliCount = runner.countFromDir('src/cli/commands', '.ts', ['index.ts', 'definitions.ts'], projectPath);
-  const gateCount = runner.countFromDir('src/gates', '.ts', ['index.ts', 'types.ts'], projectPath);
-  const ironCount = Object.keys(IRON_LAWS).length;
-  const guideCount = Object.keys(GUIDELINES).length;
-
-  const replacements: [RegExp, string][] = [
-    [/CLI Commands\s*\(\d+\)/, `CLI Commands (${cliCount})`],
-    [/Quality Gates?\s*\(\d+\)/, `Quality Gates (${gateCount})`],
-    [/Iron Laws?\s*\(\d+\)/, `Iron Laws (${ironCount})`],
-    [/Guidelines?\s*\(\d+\)/, `Guidelines (${guideCount})`],
-  ];
-
-  for (const [regex, replacement] of replacements) {
+export function updateCapabilityCounts(content: string, _projectPath: string): string {
+  for (const rule of CAPABILITY_COUNT_RULES) {
+    const regex = new RegExp(rule.pattern);
     if (regex.test(content)) {
-      content = content.replace(regex, replacement);
+      content = content.replace(regex, `${rule.label} (${rule.actual()})`);
     }
   }