@dommaker/harness 0.16.8 → 0.17.0

package/src/core/constraints/injection-renderer.ts

@@ -0,0 +1,44 @@
+/**
+ * CLAUDE.md 约束注入段渲染（ADR-0001）
+ *
+ * 纯函数：输入生效约束集 + harness 版本，输出标记区间的期望文本。
+ * 与写文件分离——init 注入与 P6 注入漂移校验（期望 vs 实际）共用此渲染。
+ */
+
+import type { Constraint } from '../../types/constraint';
+
+/** 约束注入段开始标记 */
+export const CONSTRAINTS_START_MARKER = '<!-- HARNESS_CONSTRAINTS_START -->';
+/** 约束注入段结束标记 */
+export const CONSTRAINTS_END_MARKER = '<!-- HARNESS_CONSTRAINTS_END -->';
+
+/**
+ * 渲染 CLAUDE.md 约束注入段（含 START/END 标记，不含 `## Governance Rules` 标题）
+ *
+ * 结构：### Iron Laws / ### Guidelines / ### Prompts（行为约束），
+ * 条目为 `- **id**: promptInjection`；无 promptInjection 的 check 条目
+ * （如 docs_freshness）不出现在注入段。返回文本以换行结尾。
+ *
+ * @param constraints 生效约束集（getEffectiveConstraints 的输出）
+ * @param version harness 版本号（写入 `<!-- version: x -->` 供漂移校验）
+ */
+export function renderConstraintsSection(constraints: Constraint[], version: string): string {
+  const lines: string[] = [CONSTRAINTS_START_MARKER, `<!-- version: ${version} -->`];
+
+  const renderGroup = (level: 'iron_law' | 'guideline' | 'prompt', heading: string, first: boolean) => {
+    const items = constraints.filter(c => c.level === level && c.promptInjection);
+    if (items.length === 0) return;
+    if (!first) lines.push('');
+    lines.push(heading);
+    for (const c of items) {
+      lines.push(`- **${c.id}**: ${c.promptInjection}`);
+    }
+  };
+
+  renderGroup('iron_law', '### Iron Laws (违反将阻断)', true);
+  renderGroup('guideline', '### Guidelines (应遵循)', lines.length === 2);
+  renderGroup('prompt', '### Prompts (行为约束)', lines.length === 2);
+
+  lines.push(CONSTRAINTS_END_MARKER);
+  return lines.join('\n') + '\n';
+}

package/src/core/constraints/interceptor.ts

@@ -111,17 +111,18 @@ export class ConstraintInterceptor {
     };
 
     const constraints = constraintChecker.getConstraints();
+    // prompt 类约束不参与拦截执行（ADR-0001：仅参与注入）
     const allConstraints = [
       ...Object.values(constraints.ironLaws),
       ...Object.values(constraints.guidelines),
       ...Object.values(constraints.tips),
-    ];
+    ].filter(c => c.kind !== 'prompt');
 
     const applicableConstraints = allConstraints.filter(
       (c) => normalizeTriggers<ConstraintTrigger>(c.trigger).includes(trigger)
     );
 
-    const order: Record<ConstraintLevel, number> = { iron_law: 0, guideline: 1, tip: 2 };
+    const order: Record<ConstraintLevel, number> = { iron_law: 0, guideline: 1, prompt: 2, tip: 3 };
     const ordered = applicableConstraints.sort((a, b) => order[a.level] - order[b.level]);
 
     for (const constraint of ordered) {

package/src/core/constraints/usage-report.ts

@@ -0,0 +1,254 @@
+/**
+ * 约束使用统计与退役候选诊断（ADR-0001 决策 2/3）
+ *
+ * `harness constraints report` 与 `harness constraints retire`（交互模式）共用的
+ * 数据层：读取项目 traces.log，与生效集（getEffectiveConstraints）对齐，
+ * 产出 check 层统计表与四类退役候选诊断。
+ *
+ * 只读：不创建目录、不写任何文件。
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+import type { Constraint } from '../../types/constraint';
+import type { ExecutionTrace } from '../../types/trace';
+import { DEFAULT_TRACE_FILE } from '../../types/trace';
+import { getEffectiveConstraints, lintEffectiveConfig } from '../effective-constraints';
+import type { EffectiveConfigLint } from '../effective-constraints';
+
+/**
+ * flag 型 check 约束（证据来自 ConstraintContext flag，见 checkers/iron-flags.ts）。
+ * 全部 skip 时标注"证据 flag 未接线"（区别于存在性探测的"约定未采用"）。
+ */
+export const FLAG_EVIDENCE_CONSTRAINT_IDS: ReadonlySet<string> = new Set([
+  'no_completion_without_verification',
+  'incremental_progress',
+  'no_implementation_without_requirement',
+]);
+
+/**
+ * 单条 check 约束的使用统计
+ */
+export interface ConstraintUsageStats {
+  id: string;
+  level: Constraint['level'];
+
+  /** trace 总行数（含 skip/bypassed） */
+  total: number;
+  pass: number;
+  fail: number;
+  skip: number;
+  bypassed: number;
+
+  /** 实际评估次数（total - skip；skip 未评估不计入，与 TraceAnalyzer 一致） */
+  evaluated: number;
+
+  /** 失败率（fail / evaluated；evaluated=0 时为 0） */
+  failRate: number;
+
+  /** 首次/最近触发时间（Unix ms）；无 trace 时为 undefined */
+  firstAt?: number;
+  lastAt?: number;
+}
+
+/**
+ * 退役候选类别
+ */
+export type RetireCandidateKind =
+  | 'zero_trigger'   // 零触发：生效集中从未出现在 trace
+  | 'unevaluable'    // 不可评估：全部 skip
+  | 'high_noise'     // 高噪：fail 率异常高，疑似误报源
+  | 'zero_intercept'; // 零拦截：样本充足但从未 fail
+
+export interface RetireCandidate {
+  id: string;
+  kind: RetireCandidateKind;
+  stats: ConstraintUsageStats;
+  /** 人类可读的诊断说明（带证据数字） */
+  reason: string;
+}
+
+/**
+ * 候选诊断阈值（CLI 可覆盖）
+ */
+export interface DiagnoseThresholds {
+  /** 零拦截候选的最小评估样本数，默认 50 */
+  zeroInterceptMinEvaluated: number;
+  /** 高噪候选的 fail 率阈值（严格大于），默认 0.8 */
+  highNoiseFailRate: number;
+  /** 高噪候选的最小评估样本数，默认 20 */
+  highNoiseMinEvaluated: number;
+}
+
+export const DEFAULT_DIAGNOSE_THRESHOLDS: DiagnoseThresholds = {
+  zeroInterceptMinEvaluated: 50,
+  highNoiseFailRate: 0.8,
+  highNoiseMinEvaluated: 20,
+};
+
+/**
+ * report 数据模型
+ */
+export interface ConstraintsUsageReport {
+  /** check 层统计表（生效集内每条 check 约束一行，零出现 total=0） */
+  stats: ConstraintUsageStats[];
+  /** 退役候选诊断（按 zero_trigger → unevaluable → high_noise → zero_intercept 排序） */
+  candidates: RetireCandidate[];
+  /** 当前生效的 prompt 条目 id（注入清单） */
+  activePromptIds: string[];
+  /** 配置健康诊断（unknownIds 等） */
+  lint: EffectiveConfigLint;
+  /** trace 文件是否存在 */
+  traceFileExists: boolean;
+}
+
+/**
+ * 读取项目 traces.log（只读，容错：坏行跳过）
+ */
+export function readProjectTraces(projectRoot: string): ExecutionTrace[] {
+  const tracePath = path.join(projectRoot, DEFAULT_TRACE_FILE);
+  if (!fs.existsSync(tracePath)) return [];
+
+  const content = fs.readFileSync(tracePath, 'utf-8');
+  const traces: ExecutionTrace[] = [];
+  for (const line of content.split('\n')) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    try {
+      traces.push(JSON.parse(trimmed) as ExecutionTrace);
+    } catch {
+      // 坏行跳过（report 只读，不因单行损坏失败）
+    }
+  }
+  return traces;
+}
+
+/**
+ * 按约束聚合 trace 统计（Map: constraintId → 计数）
+ */
+export function collectUsageByConstraint(
+  traces: ExecutionTrace[]
+): Map<string, Omit<ConstraintUsageStats, 'id' | 'level' | 'evaluated' | 'failRate'>> {
+  const map = new Map<string, { total: number; pass: number; fail: number; skip: number; bypassed: number; firstAt?: number; lastAt?: number }>();
+  for (const t of traces) {
+    let agg = map.get(t.constraintId);
+    if (!agg) {
+      agg = { total: 0, pass: 0, fail: 0, skip: 0, bypassed: 0 };
+      map.set(t.constraintId, agg);
+    }
+    agg.total++;
+    if (t.result === 'pass') agg.pass++;
+    else if (t.result === 'fail') agg.fail++;
+    else if (t.result === 'skip') agg.skip++;
+    else if (t.result === 'bypassed') agg.bypassed++;
+    if (agg.firstAt === undefined || t.timestamp < agg.firstAt) agg.firstAt = t.timestamp;
+    if (agg.lastAt === undefined || t.timestamp > agg.lastAt) agg.lastAt = t.timestamp;
+  }
+  return map;
+}
+
+function toStats(id: string, level: Constraint['level'], agg: { total: number; pass: number; fail: number; skip: number; bypassed: number; firstAt?: number; lastAt?: number } | undefined): ConstraintUsageStats {
+  const a = agg ?? { total: 0, pass: 0, fail: 0, skip: 0, bypassed: 0 };
+  const evaluated = a.total - a.skip;
+  return {
+    id,
+    level,
+    total: a.total,
+    pass: a.pass,
+    fail: a.fail,
+    skip: a.skip,
+    bypassed: a.bypassed,
+    evaluated,
+    failRate: evaluated > 0 ? a.fail / evaluated : 0,
+    firstAt: a.firstAt,
+    lastAt: a.lastAt,
+  };
+}
+
+/**
+ * 退役候选诊断（纯函数）
+ *
+ * 每条 check 约束最多归入一个类别，优先级：
+ * zero_trigger → unevaluable → high_noise → zero_intercept
+ */
+export function diagnoseRetireCandidates(
+  stats: ConstraintUsageStats[],
+  thresholds: Partial<DiagnoseThresholds> = {}
+): RetireCandidate[] {
+  const t = { ...DEFAULT_DIAGNOSE_THRESHOLDS, ...thresholds };
+  const candidates: RetireCandidate[] = [];
+
+  for (const s of stats) {
+    if (s.total === 0) {
+      candidates.push({
+        id: s.id,
+        kind: 'zero_trigger',
+        stats: s,
+        reason: '零触发：生效集内从未出现在 trace',
+      });
+      continue;
+    }
+
+    if (s.skip === s.total) {
+      const wiring = FLAG_EVIDENCE_CONSTRAINT_IDS.has(s.id)
+        ? '证据 flag 未接线'
+        : '约定未采用（存在性探测未命中）';
+      candidates.push({
+        id: s.id,
+        kind: 'unevaluable',
+        stats: s,
+        reason: `不可评估：全部 ${s.total} 次均为 skip（${wiring}）`,
+      });
+      continue;
+    }
+
+    if (s.failRate > t.highNoiseFailRate && s.evaluated >= t.highNoiseMinEvaluated) {
+      candidates.push({
+        id: s.id,
+        kind: 'high_noise',
+        stats: s,
+        reason: `高噪：fail 率 ${Math.round(s.failRate * 100)}%（${s.fail}/${s.evaluated}），疑似误报源`,
+      });
+      continue;
+    }
+
+    if (s.fail === 0 && s.evaluated >= t.zeroInterceptMinEvaluated) {
+      candidates.push({
+        id: s.id,
+        kind: 'zero_intercept',
+        stats: s,
+        reason: `零拦截：${s.evaluated} 次评估从未 fail`,
+      });
+    }
+  }
+
+  return candidates;
+}
+
+/**
+ * 构建 report 数据模型（只读）
+ */
+export function buildConstraintsUsageReport(
+  projectRoot: string = process.cwd(),
+  thresholds: Partial<DiagnoseThresholds> = {}
+): ConstraintsUsageReport {
+  const effective = getEffectiveConstraints(projectRoot);
+  const checkConstraints = effective.filter(c => c.kind === 'check');
+  const activePromptIds = effective.filter(c => c.kind === 'prompt').map(c => c.id);
+
+  const tracePath = path.join(projectRoot, DEFAULT_TRACE_FILE);
+  const traces = readProjectTraces(projectRoot);
+  const usage = collectUsageByConstraint(traces);
+
+  const stats = checkConstraints.map(c => toStats(c.id, c.level, usage.get(c.id)));
+  const candidates = diagnoseRetireCandidates(stats, thresholds);
+  const lint = lintEffectiveConfig(projectRoot);
+
+  return {
+    stats,
+    candidates,
+    activePromptIds,
+    lint,
+    traceFileExists: fs.existsSync(tracePath),
+  };
+}

package/src/core/effective-constraints.ts

@@ -0,0 +1,85 @@
+/**
+ * 生效约束集（ADR-0001）
+ *
+ * `getEffectiveConstraints(projectRoot)` 是全仓唯一的生效集来源：
+ * 内置 → preset → config.yml 禁用 → custom 追加 → scenes 过滤。
+ * init 注入、`harness check`、外部消费者（studio 等）全部消费它，
+ * 不再直接读 IRON_LAWS/GUIDELINES/PROMPTS 全集。
+ */
+
+import type { Constraint } from '../types/constraint';
+import { PROMPTS } from './constraints/definitions';
+import { ProjectConfigLoader } from './project-config-loader';
+
+/**
+ * 获取项目当前生效的约束集（check + prompt，带 kind）
+ *
+ * 内部完成完整合并：内置 → preset 裁剪 → config.yml `constraints.<id>.enabled:false`
+ * 删除 → custom-constraints 追加/extend_exceptions → scenes 过滤
+ * （带 appliesTo 的 prompt 仅当 config.yml `scenes` 与其交集非空时保留，
+ * 缺省 scenes=[] 即场景专属 prompt 默认不进入生效集）。
+ *
+ * @param projectRoot 项目根路径（缺省 process.cwd()）
+ */
+export function getEffectiveConstraints(projectRoot: string = process.cwd()): Constraint[] {
+  const loader = new ProjectConfigLoader(projectRoot);
+  loader.load();
+  const merged = loader.mergeConstraints();
+  return [
+    ...Object.values(merged.ironLaws),
+    ...Object.values(merged.guidelines),
+    ...Object.values(merged.tips),
+    ...Object.values(merged.prompts ?? {}),
+  ];
+}
+
+/**
+ * 生效集配置诊断结果
+ */
+export interface EffectiveConfigLint {
+  /**
+   * config.yml `constraints.<id>` 中既非内置也非自定义的未知 id
+   * （如禁用了已被本版移除的约束的残留配置）。生效集计算静默忽略，
+   * 在此列出供 report 提示。
+   */
+  unknownIds: string[];
+
+  /** 项目配置的场景标签（config.yml `scenes`，缺省 []） */
+  scenes: string[];
+
+  /**
+   * 因 scenes 过滤而未进入生效集的场景专属 prompt id
+   * （已被 preset/config 禁用的不重复列出）
+   */
+  sceneExcluded: string[];
+}
+
+/**
+ * 诊断项目约束配置：未知 id 残留、scenes 生效情况
+ *
+ * 不抛错、不修改任何文件，供 report / check 的诊断输出使用。
+ *
+ * @param projectRoot 项目根路径（缺省 process.cwd()）
+ */
+export function lintEffectiveConfig(projectRoot: string = process.cwd()): EffectiveConfigLint {
+  const loader = new ProjectConfigLoader(projectRoot);
+  const config = loader.load();
+  const merged = loader.mergeConstraints();
+  const scenes = config.scenes ?? [];
+
+  const sceneExcluded = Object.values(PROMPTS)
+    .filter(
+      c =>
+        c.appliesTo &&
+        c.appliesTo.length > 0 &&
+        !c.appliesTo.some(scene => scenes.includes(scene)) &&
+        !merged.disabled.includes(c.id)
+    )
+    .map(c => c.id);
+
+  return {
+    unknownIds: merged.unknownIds ?? [],
+    scenes,
+    sceneExcluded,
+  };
+}

package/src/core/index.ts

@@ -20,4 +20,7 @@ export type {
 } from '../types/spec';
 
 // 项目配置加载器
-export * from './project-config-loader';
+export * from './project-config-loader';
+
+// 生效约束集（ADR-0001：唯一生效集来源）
+export * from './effective-constraints';

package/src/core/project-config-loader.ts

@@ -13,8 +13,10 @@ import type {
   ProjectConfig,
   CustomConstraintDefinition,
   MergedConstraintsConfig,
+  CapabilitiesConfig,
 } from '../types/project-config';
-import { IRON_LAWS, GUIDELINES, TIPS } from './constraints/definitions';
+import { IRON_LAWS, GUIDELINES, PROMPTS } from './constraints/definitions';
+import { applyPreset } from '../presets';
 
 /**
  * 默认配置
@@ -69,6 +71,29 @@ export function loadRawProjectConfig(projectPath: string): Record<string, unknow
   return raw;
 }
 
+/**
+ * CAPABILITIES.md 登记模式（governance.capabilities.mode）
+ */
+export type CapabilitiesMode = NonNullable<CapabilitiesConfig['mode']>;
+
+/**
+ * 读取 governance.capabilities.mode（缺省 'file'，向后兼容）
+ *
+ * 配置缺失/解析失败/取值非法时一律回落 'file'。
+ */
+export function getCapabilitiesMode(projectPath: string): CapabilitiesMode {
+  try {
+    const raw = loadRawProjectConfig(projectPath);
+    const governance = raw?.governance as Record<string, unknown> | undefined;
+    const capabilities = governance?.capabilities as Record<string, unknown> | undefined;
+    const mode = capabilities?.mode;
+    if (mode === 'file' || mode === 'module' || mode === 'listing') return mode;
+  } catch {
+    // 配置缺失或解析失败，按默认 file 处理
+  }
+  return 'file';
+}
+
 /**
  * 项目配置加载器
  */
@@ -128,26 +153,50 @@ export class ProjectConfigLoader {
   }
 
   /**
-   * 合并内置约束和自定义约束
+   * 合并内置约束和自定义约束（ADR-0001 生效集完整链路）
+   *
+   * 合并顺序：内置 → preset 裁剪 → config.yml `constraints.<id>.enabled:false`
+   * 删除 → custom-constraints 追加/extend_exceptions → scenes 过滤
+   * （带 appliesTo 的 prompt 仅当 scenes 交集非空时保留）。
+   *
+   * config.yml 中未知约束 id（如已移除约束的禁用残留）静默忽略，
+   * 记录在结果 unknownIds 中供诊断。
+   *
+   * @param options.preset 覆盖 config.yml 的 preset（CLI --preset 用）
    */
-  mergeConstraints(): MergedConstraintsConfig {
+  mergeConstraints(options?: { preset?: string }): MergedConstraintsConfig {
+    // 0. preset 裁剪（未知预设名由 applyPreset 回落 standard）
+    const presetMerged = applyPreset(options?.preset ?? this.config.preset ?? 'standard');
+    const unknownIds: string[] = [];
     const result: MergedConstraintsConfig = {
-      ironLaws: { ...IRON_LAWS },
-      guidelines: { ...GUIDELINES },
-      tips: { ...TIPS },
-      disabled: [],
+      ironLaws: presetMerged.ironLaws,
+      guidelines: presetMerged.guidelines,
+      tips: {},
+      prompts: presetMerged.prompts ?? {},
+      disabled: [...presetMerged.disabled],
       custom: [],
+      unknownIds,
     };
 
     // 1. 处理启用/禁用配置
     if (this.config.constraints) {
       for (const [constraintId, config] of Object.entries(this.config.constraints)) {
+        const isKnown =
+          !!IRON_LAWS[constraintId] ||
+          !!GUIDELINES[constraintId] ||
+          !!PROMPTS[constraintId] ||
+          !!this.customConstraints[constraintId];
+        if (!isKnown) {
+          // 未知 id（如已移除约束的禁用残留）：不报错，记录供诊断
+          unknownIds.push(constraintId);
+        }
         if (config.enabled === false) {
           result.disabled.push(constraintId);
           // 从对应层级中移除
           delete result.ironLaws[constraintId];
           delete result.guidelines[constraintId];
           delete result.tips[constraintId];
+          delete result.prompts![constraintId];
         }
       }
     }
@@ -171,6 +220,7 @@ export class ProjectConfigLoader {
           if (result.ironLaws[id]) result.ironLaws[id] = constraint;
           if (result.guidelines[id]) result.guidelines[id] = constraint;
           if (result.tips[id]) result.tips[id] = constraint;
+          if (result.prompts![id]) result.prompts![id] = constraint;
           continue;
         }
       }
@@ -196,12 +246,29 @@ export class ProjectConfigLoader {
         case 'guideline':
           result.guidelines[id] = constraint;
           break;
+        case 'prompt':
+          result.prompts![id] = constraint;
+          break;
         case 'tip':
           result.tips[id] = constraint;
           break;
       }
     }
 
+    // 3. scenes 过滤（ADR-0001）：带 appliesTo 标签的 prompt 仅当项目 scenes
+    // 与其交集非空时保留；无 appliesTo 的条目不受影响。缺省 scenes=[] 即
+    // 场景专属 prompt 默认不进入生效集。
+    const scenes = this.config.scenes ?? [];
+    for (const [id, constraint] of Object.entries(result.prompts!)) {
+      if (
+        constraint.appliesTo &&
+        constraint.appliesTo.length > 0 &&
+        !constraint.appliesTo.some(scene => scenes.includes(scene))
+      ) {
+        delete result.prompts![id];
+      }
+    }
+
     return result;
   }
 
@@ -212,16 +279,22 @@ export class ProjectConfigLoader {
     id: string,
     merged: MergedConstraintsConfig
   ): Constraint | undefined {
-    return merged.ironLaws[id] || merged.guidelines[id] || merged.tips[id];
+    return merged.ironLaws[id] || merged.guidelines[id] || merged.tips[id] || merged.prompts?.[id];
   }
 
   /**
    * 将自定义约束定义转换为 Constraint
+   *
+   * kind 推导（ADR-0001）：自定义约束没有注册表中的 checker，统一归为
+   * kind='prompt'（不执行 checker，check() 短路通过），level 仅决定其所在
+   * 桶与严重性行为，保持与历史"未注册默认通过"相同的执行语义。
    */
   private toConstraint(def: CustomConstraintDefinition, defaultId: string): Constraint {
+    const level = def.level || 'guideline';
     return {
       id: def.id || defaultId,
-      level: def.level || 'guideline',
+      kind: 'prompt',
+      level,
       rule: def.rule || '',
       message: def.message || '',
       trigger: (def.trigger || 'manual') as ConstraintTrigger | ConstraintTrigger[],

package/src/dashboard/__tests__/data.test.ts

@@ -4,7 +4,7 @@
 
 import { DashboardDataProvider } from '../data';
 import type { KnowledgeEntry } from '../../knowledge/types';
-import type { ConstraintStats } from '../../constraints/types';
+import type { ConstraintStats } from '../types';
 
 function makeEntry(overrides: Partial<KnowledgeEntry> = {}): KnowledgeEntry {
   return {
@@ -50,7 +50,7 @@ describe('DashboardDataProvider', () => {
 
     it('应该接受约束统计', () => {
       const stats: ConstraintStats[] = [{
-        constraintId: 'no_any_type',
+        constraintId: 'no_bypass_checkpoint',
         triggerCount: 100,
         passCount: 78,
         interceptCount: 22,
@@ -60,7 +60,7 @@ describe('DashboardDataProvider', () => {
 
       const data = provider.generate([], stats);
       const heatmap = data.constraintHeatmap;
-      const entry = heatmap.constraints.find(c => c.id === 'no_any_type');
+      const entry = heatmap.constraints.find(c => c.id === 'no_bypass_checkpoint');
       expect(entry?.trigger).toBe(100);
       expect(entry?.intercept).toBe(22);
     });
@@ -87,7 +87,7 @@ describe('DashboardDataProvider', () => {
 
     it('应该检测拦截率下降的约束', () => {
       const stats: ConstraintStats[] = [{
-        constraintId: 'no_any_type',
+        constraintId: 'no_bypass_checkpoint',
         triggerCount: 100,
         passCount: 90,
         interceptCount: 10,
@@ -95,7 +95,7 @@ describe('DashboardDataProvider', () => {
       }];
 
       const heatmap = provider.getConstraintHeatmap(stats);
-      expect(heatmap.decliningInterceptRate.some(c => c.id === 'no_any_type')).toBe(true);
+      expect(heatmap.decliningInterceptRate.some(c => c.id === 'no_bypass_checkpoint')).toBe(true);
     });
   });
 
@@ -108,11 +108,4 @@ describe('DashboardDataProvider', () => {
       expect(loop.feedbackToKnowledge).toBeDefined();
     });
   });
-
-  describe('getRegistry', () => {
-    it('应该返回约束注册表', () => {
-      expect(provider.getRegistry()).toBeDefined();
-      expect(provider.getRegistry().getAll().length).toBeGreaterThan(0);
-    });
-  });
 });

package/src/dashboard/data.ts

@@ -11,19 +11,14 @@ import type {
   ConstraintHeatmap,
   KnowledgeFlow,
   FeedbackLoopStatus,
+  ConstraintStats,
+  ConstraintLayer,
 } from './types';
 import type { KnowledgeEntry } from '../knowledge/types';
-import type { ConstraintStats } from '../constraints/types';
 import { computeKnowledgeOverview, computeKnowledgeFlow, computeInterceptRate } from './stats';
-import { ConstraintRegistry } from '../constraints/registry';
+import { getAllConstraints } from '../core/constraints/definitions';
 
 export class DashboardDataProvider {
-  private registry: ConstraintRegistry;
-
-  constructor(registry?: ConstraintRegistry) {
-    this.registry = registry ?? new ConstraintRegistry();
-  }
-
   /**
    * 生成完整 Dashboard 数据
    */
@@ -52,19 +47,21 @@ export class DashboardDataProvider {
    * 约束执行热力图
    */
   getConstraintHeatmap(stats: ConstraintStats[]): ConstraintHeatmap {
-    const allConstraints = this.registry.getAll();
+    // P1：直接读 definitions；prompt 类不产生 trace 统计，热力图只含 check 层
+    const allConstraints = getAllConstraints().filter(c => c.kind === 'check');
 
     const constraints = allConstraints.map(c => {
       const stat = stats.find(s => s.constraintId === c.id);
+      const layer: ConstraintLayer = c.level === 'iron_law' ? 'safety' : 'quality';
       return {
         id: c.id,
-        layer: c.layer,
+        layer,
         trigger: stat?.triggerCount ?? 0,
         pass: stat?.passCount ?? 0,
         intercept: stat?.interceptCount ?? 0,
         interceptRate: stat ? computeInterceptRate(stat.triggerCount, stat.interceptCount) : 0,
-        deprecationStatus: c.deprecationStatus,
-        permanent: c.permanent,
+        deprecationStatus: 'active' as const,
+        permanent: false,
       };
     });
 
@@ -103,11 +100,4 @@ export class DashboardDataProvider {
       feedbackToKnowledge: { total: 0, pending: 0 },
     };
   }
-
-  /**
-   * 获取约束注册表
-   */
-  getRegistry(): ConstraintRegistry {
-    return this.registry;
-  }
 }