@dommaker/harness 0.16.9 → 0.17.1

package/src/core/constraints/checker.ts

@@ -1,10 +1,10 @@
 /**
  * 约束检查引擎
- * 
- * 三层约束体系检查：
- * - Iron Laws：检查失败立即抛出异常
- * - Guidelines：检查失败记录警告
- * - Tips：检查失败记录提示
+ *
+ * kind 二元模型（ADR-0001）：
+ * - check · Iron Laws：检查失败立即抛出异常
+ * - check · Guidelines：检查失败记录警告
+ * - prompt：不执行 checker，仅参与注入
  */
 
 import {
@@ -17,14 +17,14 @@ import {
   ConstraintViolationError,
 } from '../../types/constraint';
 import type { ExecutionTrace } from '../../types/trace';
-import { IRON_LAWS, GUIDELINES, TIPS } from './definitions';
+import { IRON_LAWS, GUIDELINES, TIPS, PROMPTS } from './definitions';
 import type { MergedConstraintsConfig } from '../../types/project-config';
 import { normalizeTriggers } from '../../utils/exec';
 import { runCommand } from '../../utils/exec';
 import { join, relative } from 'path';
 import { CheckCache } from './check-cache';
 import { findTsSourceFiles } from '../../utils/file-walk';
-import { getConstraintCheck, type CheckEnv } from './checkers';
+import { getConstraintCheck, type CheckEnv, type CheckOutcome } from './checkers';
 
 /**
  * 例外名称 → ConstraintContext 中布尔字段的映射
@@ -158,11 +158,12 @@ export class ConstraintChecker {
     ironLaws: Record<string, Constraint & { check: (ctx: ConstraintContext) => Promise<ConstraintResult> }>;
     guidelines: Record<string, Constraint & { check: (ctx: ConstraintContext) => Promise<ConstraintResult> }>;
     tips: Record<string, Constraint & { check: (ctx: ConstraintContext) => Promise<ConstraintResult> }>;
+    prompts: Record<string, Constraint & { check: (ctx: ConstraintContext) => Promise<ConstraintResult> }>;
   } {
     const config = customConfig ?? this.customConfig;
     const source = config
-      ? { ironLaws: config.ironLaws, guidelines: config.guidelines, tips: config.tips }
-      : { ironLaws: IRON_LAWS, guidelines: GUIDELINES, tips: TIPS };
+      ? { ironLaws: config.ironLaws, guidelines: config.guidelines, tips: config.tips, prompts: config.prompts ?? PROMPTS }
+      : { ironLaws: IRON_LAWS, guidelines: GUIDELINES, tips: TIPS, prompts: PROMPTS };
 
     // Wire unified check() method on every constraint
     const wire = (constraints: Record<string, Constraint>) => {
@@ -171,7 +172,12 @@ export class ConstraintChecker {
       }
       return constraints as Record<string, Constraint & { check: (ctx: ConstraintContext) => Promise<ConstraintResult> }>;
     };
-    return { ironLaws: wire(source.ironLaws), guidelines: wire(source.guidelines), tips: wire(source.tips) };
+    return {
+      ironLaws: wire(source.ironLaws),
+      guidelines: wire(source.guidelines),
+      tips: wire(source.tips),
+      prompts: wire(source.prompts),
+    };
   }
 
   /**
@@ -181,6 +187,17 @@ export class ConstraintChecker {
     constraint: Constraint,
     context: ConstraintContext
   ): Promise<ConstraintResult> {
+    // prompt 类约束不参与 checker 执行（ADR-0001：仅参与注入）
+    if (constraint.kind === 'prompt') {
+      return {
+        id: constraint.id,
+        level: constraint.level,
+        satisfied: true,
+        constraint,
+        checkedAt: new Date(),
+      };
+    }
+
     // 检查例外条件（仅 Guidelines 有效）
     if (constraint.level === 'guideline' && constraint.exceptions) {
       if (this.checkException(constraint, context)) {
@@ -195,8 +212,22 @@ export class ConstraintChecker {
       }
     }
 
-    // 检查前置条件
-    const satisfied = await this.checkPrecondition(constraint, context);
+    // 检查前置条件（'skip' = 约定未采用/证据未接线：satisfied 置 true 但不计 pass/fail）
+    const outcome = await this.checkPrecondition(constraint, context);
+
+    if (outcome === 'skip') {
+      return {
+        id: constraint.id,
+        level: constraint.level,
+        satisfied: true,
+        skipped: true,
+        constraint,
+        message: `约束 ${constraint.id} 跳过评估（约定未采用或证据未接线）`,
+        checkedAt: new Date(),
+      };
+    }
+
+    const satisfied = outcome;
 
     return {
       id: constraint.id,
@@ -228,6 +259,7 @@ export class ConstraintChecker {
         return 'error';
       case 'guideline':
         return 'warning';
+      case 'prompt':
       case 'tip':
         return 'info';
       default:
@@ -237,10 +269,14 @@ export class ConstraintChecker {
 
   /**
    * 判断约束是否匹配当前触发条件
+   *
+   * context.operation 为主触发条件，context.extraTriggers 为次级推断
+   * （ADR-0001：pre-commit 代码变更附加 code_implementation），任一命中即匹配。
    */
-  private matchesTrigger(constraint: Constraint, operation: ConstraintTrigger): boolean {
+  private matchesTrigger(constraint: Constraint, context: ConstraintContext): boolean {
     const triggers = normalizeTriggers<ConstraintTrigger>(constraint.trigger);
-    return triggers.includes(operation);
+    const operations = [context.operation, ...(context.extraTriggers ?? [])];
+    return operations.some(op => triggers.includes(op));
   }
 
   /**
@@ -256,7 +292,7 @@ export class ConstraintChecker {
       constraintId: constraint.id,
       level: constraint.level,
       timestamp: Date.now(),
-      result: checkResult.satisfied ? 'pass' : 'fail',
+      result: checkResult.skipped ? 'skip' : checkResult.satisfied ? 'pass' : 'fail',
       operation: context.operation,
       severity: this.getSeverity(constraint.level),
       exceptionApplied: checkResult.message?.includes('豁免')
@@ -270,14 +306,20 @@ export class ConstraintChecker {
   /**
    * 检查约束前置条件（工单 21：分发至 checkers/ 注册表）
    *
-   * 未注册的约束默认通过（保持历史 default 分支语义）。
+   * 注册表闭环（ADR-0001）：kind='check' 未注册 checker 直接抛错，
+   * 不再有"未注册默认通过"路径；kind='prompt' 在 check() 入口已短路。
    */
   private async checkPrecondition(
     constraint: Constraint,
     context: ConstraintContext
-  ): Promise<boolean> {
+  ): Promise<CheckOutcome> {
     const impl = getConstraintCheck(constraint.id);
-    if (!impl) return true;
+    if (!impl) {
+      throw new Error(
+        `[harness] 约束 "${constraint.id}" (kind='check') 未注册 checker，拒绝静默通过。` +
+        `请在 checkers/ 注册实现，或将约束改为 kind='prompt'。`
+      );
+    }
 
     const projectPath = context.projectPath || process.cwd();
     const env: CheckEnv = {
@@ -309,8 +351,9 @@ export class ConstraintChecker {
     ironLaws: Constraint[];
     guidelines: Constraint[];
     tips: Constraint[];
+    prompts: Constraint[];
   } {
-    const trigger = context.operation;
+    const operations = [context.operation, ...(context.extraTriggers ?? [])];
     const constraints = this.getConstraints(customConfig);
 
     const filterByTrigger = (constraintSet: Record<string, Constraint>): Constraint[] => {
@@ -318,7 +361,7 @@ export class ConstraintChecker {
         const triggers = Array.isArray(constraint.trigger)
           ? constraint.trigger
           : [constraint.trigger];
-        return triggers.includes(trigger);
+        return operations.some(op => triggers.includes(op));
       });
     };
 
@@ -326,6 +369,7 @@ export class ConstraintChecker {
       ironLaws: filterByTrigger(constraints.ironLaws),
       guidelines: filterByTrigger(constraints.guidelines),
       tips: filterByTrigger(constraints.tips),
+      prompts: filterByTrigger(constraints.prompts),
     };
   }
 
@@ -362,7 +406,7 @@ export class ConstraintChecker {
 
       // 1. Iron Laws: 必须全部通过
       for (const constraint of Object.values(constraints.ironLaws)) {
-        if (!this.matchesTrigger(constraint, context.operation)) continue;
+        if (!this.matchesTrigger(constraint, context)) continue;
 
         const checkResult = await this.check(constraint, context);
         result.ironLaws.push(checkResult);
@@ -376,7 +420,7 @@ export class ConstraintChecker {
 
       // 2. Guidelines: 记录警告
       for (const constraint of Object.values(constraints.guidelines)) {
-        if (!this.matchesTrigger(constraint, context.operation)) continue;
+        if (!this.matchesTrigger(constraint, context)) continue;
 
         const checkResult = await this.check(constraint, context);
         result.guidelines.push(checkResult);
@@ -389,7 +433,7 @@ export class ConstraintChecker {
 
       // 3. Tips: 仅记录
       for (const constraint of Object.values(constraints.tips)) {
-        if (!this.matchesTrigger(constraint, context.operation)) continue;
+        if (!this.matchesTrigger(constraint, context)) continue;
 
         const checkResult = await this.check(constraint, context);
         result.tips.push(checkResult);
@@ -434,7 +478,7 @@ export class ConstraintChecker {
       const constraints = this.getConstraints(customConfig);
 
       for (const constraint of Object.values(constraints.ironLaws)) {
-        if (!this.matchesTrigger(constraint, context.operation)) continue;
+        if (!this.matchesTrigger(constraint, context)) continue;
         const checkResult = await this.check(constraint, context);
         result.ironLaws.push(checkResult);
         this.recordTrace(traceCollector, constraint, checkResult, context);
@@ -442,7 +486,7 @@ export class ConstraintChecker {
       }
 
       for (const constraint of Object.values(constraints.guidelines)) {
-        if (!this.matchesTrigger(constraint, context.operation)) continue;
+        if (!this.matchesTrigger(constraint, context)) continue;
         const checkResult = await this.check(constraint, context);
         result.guidelines.push(checkResult);
         this.recordTrace(traceCollector, constraint, checkResult, context);
@@ -450,7 +494,7 @@ export class ConstraintChecker {
       }
 
       for (const constraint of Object.values(constraints.tips)) {
-        if (!this.matchesTrigger(constraint, context.operation)) continue;
+        if (!this.matchesTrigger(constraint, context)) continue;
         const checkResult = await this.check(constraint, context);
         result.tips.push(checkResult);
         this.recordTrace(traceCollector, constraint, checkResult, context);
@@ -475,7 +519,7 @@ export class ConstraintChecker {
     customConfig?: MergedConstraintsConfig | null
   ): Promise<void> {
     const constraints = this.getConstraints(customConfig);
-    const operations = normalizeTriggers(context.operation);
+    const operations = [context.operation, ...(context.extraTriggers ?? [])];
 
     for (const constraint of Object.values(constraints.ironLaws)) {
       if (!normalizeTriggers(constraint.trigger).some((t) => operations.includes(t))) continue;
@@ -505,7 +549,8 @@ export async function checkConstraint(
   const constraint =
     constraints.ironLaws[constraintId] ||
     constraints.guidelines[constraintId] ||
-    constraints.tips[constraintId];
+    constraints.tips[constraintId] ||
+    constraints.prompts[constraintId];
 
   if (!constraint) {
     return {

package/src/core/constraints/checkers/capability-sync.ts

@@ -5,21 +5,54 @@
  *   1. Git diff 增量 — 当前变更的非测试文件是否在文档中有记录
  *   2. 全量扫描 — 源码根下所有源文件是否都在 CAPABILITIES.md 中（T-058）
  *
- * governance.capabilities.mode=module 时 step 2 改按目录覆盖判定：
- * 文件条目精确匹配或目录条目前缀覆盖，未覆盖文件按源码根下第一级子目录聚合。
+ * 覆盖判定两步统一（isCoveredBy）：目录条目（以 / 结尾）前缀匹配，
+ * 文件条目精确匹配或路径边界后缀匹配。module 模式下目录条目参与覆盖，
+ * 未覆盖文件按源码根下第一级子目录聚合。
+ *
+ * 清单格式（计数行，mode=listing 或嗅探命中）无文件表可核对，直接放行；
+ * 检查异常时 fail-open 但输出 console.warn 保留可观测性。
+ *
+ * ADR-0001 存在性探测：项目根无 CAPABILITIES.md（未采用该约定）时返回 'skip'，
+ * 不计 pass/fail，避免在未采用约定的项目上全量误报。
  */
 
-import { existsSync } from 'fs';
+import { existsSync, readFileSync } from 'fs';
 import { join } from 'path';
-import { aggregateToSourceSubdir, readCapabilitiesEntries } from '../capabilities-parser';
+import {
+  aggregateToSourceSubdir,
+  isCapabilityListingFormat,
+  parseCapabilitiesEntries,
+} from '../capabilities-parser';
 import { getCapabilitiesMode } from '../../project-config-loader';
 import { detectSourceRoots } from '../../../utils/detect-source-roots';
 import type { ConstraintCheck } from './types';
 
+/** markdown 表格分隔行（|------|------|）：区分「无表格的散文文档」与「有表格但零条目」 */
+const TABLE_SEPARATOR_REGEX = /^\s*\|[\s:|-]+\|\s*$/m;
+
+/**
+ * 变更文件是否被条目覆盖
+ *
+ * 目录条目（以 / 结尾）前缀匹配；文件条目精确匹配或路径边界后缀匹配
+ * （兼容 basename 条目，但拒绝 xfoo.ts 命中 foo.ts、docs/src/foo.tsx 命中 src/foo.ts
+ * 这类 endsWith/includes 模糊匹配造成的碰撞）
+ */
+function isCoveredBy(entries: string[], changed: string): boolean {
+  return entries.some((listed) =>
+    listed.endsWith('/')
+      ? changed.startsWith(listed)
+      : changed === listed || changed.endsWith('/' + listed)
+  );
+}
+
 export const capabilitySync: ConstraintCheck = {
   id: 'capability_sync',
   async evaluate(env) {
     const projectPath = env.projectPath;
+    // ADR-0001 存在性探测：项目未采用 CAPABILITIES.md 约定 → skip（不计 pass/fail）
+    if (!existsSync(join(projectPath, 'CAPABILITIES.md'))) {
+      return 'skip';
+    }
     try {
       const capabilitiesPath = join(projectPath, 'CAPABILITIES.md');
       if (!existsSync(capabilitiesPath)) {
@@ -31,45 +64,53 @@ export const capabilitySync: ConstraintCheck = {
         return changedCodeFiles.length === 0;
       }
 
-      const listedFiles = readCapabilitiesEntries(capabilitiesPath, { secondColumnOnly: true });
+      const content = readFileSync(capabilitiesPath, 'utf-8');
+      const capabilitiesMode = getCapabilitiesMode(projectPath);
+
+      // 清单格式（计数行）没有文件表可核对，计数由 sync-docs 维护，直接放行
+      if (capabilitiesMode === 'listing' || isCapabilityListingFormat(content)) {
+        return true;
+      }
+
+      const listedFiles = parseCapabilitiesEntries(content, { secondColumnOnly: true });
+      // module 模式下目录条目同样构成覆盖依据，与 step 2 判定对齐
+      const entries =
+        capabilitiesMode === 'module'
+          ? parseCapabilitiesEntries(content, { includeDirs: true })
+          : listedFiles;
+      // 有表格但零条目 = 文档什么都没登记，不得直接放行；无表格的散文文档保持历史放行
+      const hasTable = TABLE_SEPARATOR_REGEX.test(content);
 
       // ── Step 1: Git diff 增量检查 ──
       const diff = await env.stagedDiffNames();
       const changedCodeFiles = diff.split('\n').filter(
         (f: string) => f.endsWith('.ts') || f.endsWith('.tsx') || f.endsWith('.js')
       );
+      const significantChanges = changedCodeFiles.filter(
+        (f: string) => !f.includes('__tests__') && !f.includes('.test.') && !f.includes('.spec.')
+      );
 
-      if (changedCodeFiles.length > 0 && listedFiles.length > 0) {
-        const significantChanges = changedCodeFiles.filter(
-          (f: string) => !f.includes('__tests__') && !f.includes('.test.') && !f.includes('.spec.')
-        );
-
-        if (significantChanges.length > 0) {
-          const covered = significantChanges.some((changed: string) =>
-            listedFiles.some((listed: string) => changed.endsWith(listed) || changed.includes(listed))
-          );
-          if (!covered) return false;
-        }
+      // 每个变更文件都必须被覆盖（every；some 会让一个命中掩盖其余漏网）
+      if (
+        significantChanges.length > 0 &&
+        (entries.length > 0 || hasTable) &&
+        !significantChanges.every((changed: string) => isCoveredBy(entries, changed))
+      ) {
+        return false;
       }
 
       // ── Step 2: 全量源码根扫描（T-058 修复核心）──
-      const capabilitiesMode = getCapabilitiesMode(projectPath);
       if (capabilitiesMode === 'module') {
-        // module 模式：文件条目精确匹配 或 目录条目前缀覆盖；
+        // module 模式：目录条目参与覆盖（isCoveredBy 统一判定）；
         // 未覆盖文件按源码根下第一级子目录聚合，任一组非空即失败
-        const entries = readCapabilitiesEntries(capabilitiesPath, { includeDirs: true });
-        if (entries.length > 0) {
-          const fileEntries = entries.filter(e => !e.endsWith('/'));
-          const dirEntries = entries.filter(e => e.endsWith('/'));
+        if (entries.length > 0 || hasTable) {
           const uncoveredDirs = new Set<string>();
           const sourceRoots = detectSourceRoots(projectPath);
           for (const root of sourceRoots) {
             const srcDir = join(projectPath, root);
             if (existsSync(srcDir)) {
               for (const file of env.srcScan(root)) {
-                const covered =
-                  fileEntries.includes(file) || dirEntries.some(d => file.startsWith(d));
-                if (!covered) {
+                if (!isCoveredBy(entries, file)) {
                   uncoveredDirs.add(aggregateToSourceSubdir(root, file));
                 }
               }
@@ -77,13 +118,13 @@ export const capabilitySync: ConstraintCheck = {
           }
           if (uncoveredDirs.size > 0) return false;
         }
-      } else if (listedFiles.length > 0) {
+      } else if (listedFiles.length > 0 || hasTable) {
         const sourceRoots = detectSourceRoots(projectPath);
         for (const root of sourceRoots) {
           const srcDir = join(projectPath, root);
           if (existsSync(srcDir)) {
             for (const file of env.srcScan(root)) {
-              if (!listedFiles.includes(file)) {
+              if (!isCoveredBy(listedFiles, file)) {
                 return false;
               }
             }
@@ -92,8 +133,10 @@ export const capabilitySync: ConstraintCheck = {
       }
 
       return true;
-    } catch {
-      return true; // 检查失败，默认通过
+    } catch (err) {
+      // fail-open 语义保留，但必须可观测：静默吞错会让解析 bug 变成「永远通过」
+      console.warn('[capability_sync] 检查执行异常，默认放行：', err);
+      return true;
     }
   },
 };

package/src/core/constraints/checkers/context-doc-sync.ts

@@ -1,5 +1,8 @@
 /**
  * context_doc_sync：关键目录必须有 CONTEXT.md（工单 21）
+ *
+ * ADR-0001 存在性探测：项目未配置 governance.context_files 约定
+ * （未启用或无 required_dirs）时返回 'skip'，不计 pass/fail。
  */
 
 import { existsSync } from 'fs';
@@ -17,10 +20,14 @@ export const contextDocSync: ConstraintCheck = {
       const contextFiles = governance?.context_files as Record<string, unknown> | undefined;
 
       if (!contextFiles?.enabled || !Array.isArray(contextFiles.required_dirs)) {
-        return true; // 未配置，跳过
+        return 'skip'; // 未配置 context_files 约定，跳过评估
       }
 
       const requiredDirs = contextFiles.required_dirs as string[];
+      if (requiredDirs.length === 0) {
+        return 'skip'; // 无目标目录，约定未生效
+      }
+
       for (const dir of requiredDirs) {
         const contextPath = join(projectPath, dir, 'CONTEXT.md');
         if (!existsSync(contextPath)) {
@@ -30,7 +37,7 @@ export const contextDocSync: ConstraintCheck = {
 
       return true;
     } catch {
-      return true; // 配置不存在或解析失败，跳过
+      return 'skip'; // 配置不存在或解析失败 = 无法判定约定，跳过
     }
   },
 };

package/src/core/constraints/checkers/docs-freshness.ts

@@ -1,6 +1,7 @@
 /**
  * docs_freshness：CAPABILITIES.md 文件表 + 能力清单格式 + CLAUDE.md + CHANGELOG（工单 21）
  *
+ * 0. 存在性探测（ADR-0001）：项目无任何 freshness 配置/目标时 skip，不计 pass/fail
  * 1. 文件表格式：CAPABILITIES.md 中列出的文件必须仍存在（防过期引用）
  * 2. 能力清单格式：FreshnessRunner 配置驱动检查
  * 3. 无配置时注入内置默认配置（等价旧硬编码行为）
@@ -71,11 +72,53 @@ function checkCapabilitiesFreshness(projectPath: string): boolean {
   }
 }
 
+/**
+ * ADR-0001 存在性探测：项目是否存在任何 freshness 配置/检查目标。
+ *
+ * 判定信号（任一命中即视为采用了文档新鲜度约定）：
+ * - 配置了 governance.doc_freshness.checks
+ * - 配置了 governance.context_files（enabled + 非空 required_dirs）
+ * - 项目根存在 CAPABILITIES.md
+ * - 项目根存在 CHANGELOG.md / CHANGELOG
+ *
+ * 全部缺失 → 项目未采用该约定，调用方应 skip 而非评估内置默认配置。
+ */
+function hasFreshnessTargets(projectPath: string): boolean {
+  if (existsSync(join(projectPath, 'CAPABILITIES.md'))) return true;
+  if (existsSync(join(projectPath, 'CHANGELOG.md')) || existsSync(join(projectPath, 'CHANGELOG'))) {
+    return true;
+  }
+
+  try {
+    const raw = loadRawProjectConfig(projectPath);
+    const governance = raw?.governance as Record<string, unknown> | undefined;
+
+    const freshnessConfig = governance?.doc_freshness as DocFreshnessConfig | undefined;
+    if (freshnessConfig?.checks && freshnessConfig.checks.length > 0) return true;
+
+    const contextFiles = governance?.context_files as Record<string, unknown> | undefined;
+    if (
+      contextFiles?.enabled &&
+      Array.isArray(contextFiles.required_dirs) &&
+      (contextFiles.required_dirs as string[]).length > 0
+    ) {
+      return true;
+    }
+  } catch {
+    // 配置不可读视为无配置
+  }
+
+  return false;
+}
+
 export const docsFreshness: ConstraintCheck = {
   id: 'docs_freshness',
   async evaluate(env) {
     const projectPath = env.projectPath;
 
+    // ADR-0001 存在性探测：项目无任何 freshness 配置/目标 → skip（不计 pass/fail）
+    if (!hasFreshnessTargets(projectPath)) return 'skip';
+
     // Step 1: 文件表格式 — 检查列出的文件是否还存在
     if (!checkCapabilitiesFreshness(projectPath)) return false;
 

package/src/core/constraints/checkers/index.ts

@@ -1,104 +1,71 @@
 /**
  * 约束检查器注册表（工单 21）
  *
- * checker.ts 编排层通过 getConstraintCheck(id) 查找实现，
- * 未注册的约束默认通过（保持历史 default 分支语义）。
+ * checker.ts 编排层通过 getConstraintCheck(id) 查找实现。
+ *
+ * 注册表闭环（ADR-0001）：模块加载时校验全部 kind='check' 的内置约束
+ * 都有已注册 checker，且注册表中没有无对应 check 定义的孤儿实现；
+ * 任一不满足即抛错（加载期失败，不许静默 pass）。
  */
 
 import type { ConstraintCheck } from './types';
+import { getAllConstraints } from '../definitions';
 
 import {
-  noSelfApproval,
   noCompletionWithoutVerification,
   incrementalProgress,
-  verifyExternalCapability,
-  noImplementationWithoutRequirementReview,
   noImplementationWithoutRequirement,
-  preferWorktree,
-  noClaimWithoutEvidence,
-  noDeleteWithoutContext,
-  twoStageReviewRequired,
 } from './iron-flags';
-import {
-  noFixWithoutRootCause,
-  noCodeWithoutTest,
-  simplestSolutionFirst,
-  noCreationWithoutReuseCheck,
-  noSkillWithoutTest,
-} from './guideline-flags';
-import {
-  surgicalChangesOnly,
-  noModelForDeterministic,
-  noConflictBlending,
-  readBeforeWrite,
-  followConventions,
-  firstPrinciplesFirst,
-  fixTheProblemNotTheGate,
-  diagnosisToFixGate,
-  readmeRequired,
-  docRequiredForPublicApi,
-} from './always-pass';
 import { noBypassCheckpoint } from './no-bypass-checkpoint';
 import { noTestSimplification } from './no-test-simplification';
-import { noFuzzyCompletionClaim } from './no-fuzzy-completion-claim';
-import { noPerformativeAgreement } from './no-performative-agreement';
-import { noExcusePatterns } from './no-excuse-patterns';
-import { noAnyType } from './no-any-type';
 import { capabilitySync } from './capability-sync';
-import { noSimplificationWithoutApproval } from './no-simplification-without-approval';
-import { testCoverageRequired } from './test-coverage';
 import { contextDocSync } from './context-doc-sync';
 import { docsFreshness } from './docs-freshness';
-import { yagniCheck } from './yagni';
+import { noHardcodedCredentials } from './no-hardcoded-credentials';
 
 const CHECKS: ConstraintCheck[] = [
   // Iron Laws
-  noBypassCheckpoint,
-  noSelfApproval,
   noCompletionWithoutVerification,
-  noTestSimplification,
   incrementalProgress,
-  verifyExternalCapability,
-  noImplementationWithoutRequirementReview,
   noImplementationWithoutRequirement,
-  preferWorktree,
-  noFuzzyCompletionClaim,
-  noClaimWithoutEvidence,
-  noDeleteWithoutContext,
-  noPerformativeAgreement,
-  twoStageReviewRequired,
+  noTestSimplification,
+  docsFreshness,
   // Guidelines
-  noFixWithoutRootCause,
-  noCodeWithoutTest,
-  noAnyType,
-  simplestSolutionFirst,
-  noCreationWithoutReuseCheck,
+  noHardcodedCredentials,
+  noBypassCheckpoint,
   capabilitySync,
-  noSimplificationWithoutApproval,
-  noSkillWithoutTest,
-  testCoverageRequired,
   contextDocSync,
-  docsFreshness,
-  noExcusePatterns,
-  yagniCheck,
-  // 行为类（promptInjection 驱动）恒通过
-  surgicalChangesOnly,
-  noModelForDeterministic,
-  noConflictBlending,
-  readBeforeWrite,
-  followConventions,
-  firstPrinciplesFirst,
-  fixTheProblemNotTheGate,
-  diagnosisToFixGate,
-  // Tips
-  readmeRequired,
-  docRequiredForPublicApi,
 ];
 
 const registry = new Map<string, ConstraintCheck>(CHECKS.map(c => [c.id, c]));
 
+// ========================================
+// 注册表闭环校验（加载期）
+// ========================================
+
+const checkConstraints = getAllConstraints().filter(c => c.kind === 'check');
+
+for (const c of checkConstraints) {
+  if (!registry.has(c.id)) {
+    throw new Error(
+      `[harness] 约束注册表闭环校验失败：kind='check' 的约束 "${c.id}" 未注册 checker。` +
+      `请在 checkers/ 中实现并注册，或将该约束降级为 kind='prompt'。`
+    );
+  }
+}
+
+for (const id of registry.keys()) {
+  if (!checkConstraints.some(c => c.id === id)) {
+    throw new Error(
+      `[harness] 约束注册表闭环校验失败：checker "${id}" 没有对应的 kind='check' 约束定义。` +
+      `请在 definitions/ 中补齐定义，或从注册表移除。`
+    );
+  }
+}
+
 /**
- * 按约束 ID 查找检查实现；未注册返回 undefined（编排层默认通过）
+ * 按约束 ID 查找检查实现；未注册返回 undefined
+ * （编排层对 kind='check' 未注册的情况抛错，kind='prompt' 不查表）
  */
 export function getConstraintCheck(id: string): ConstraintCheck | undefined {
   return registry.get(id);
@@ -111,4 +78,4 @@ export function registeredCheckCount(): number {
   return registry.size;
 }
 
-export type { ConstraintCheck, CheckEnv } from './types';
+export type { ConstraintCheck, CheckEnv, CheckOutcome } from './types';