@dommaker/harness 1.8.1 → 1.10.0

package/src/cli/commands/__tests__/sync-docs-table-layout.test.ts

@@ -0,0 +1,259 @@
+/**
+ * sync-docs 表格排版回归测试（harness#171）
+ *
+ * 症状：撤下 CAPABILITIES.md 的模块登记行时清空该行而非删行，残留空行把
+ * CommonMark 表格切断。判定面 = 「上一行与下一行都是 `|` 表格行、本行为空」不得存在。
+ * 正本修复在写路径（整行删除 + 存量收拢 + 空表收掉），--check 侧必须报待清理
+ * （check/fix 同规则才收敛，ADR-0009 口径）。
+ */
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { captureIO, type CapturingIO } from '../../command-contract';
+import { normalizeCapabilitiesTableLayout } from '../sync-docs/capabilities-syncer';
+import { syncDocs } from '../sync-docs';
+
+let io: CapturingIO;
+beforeEach(() => {
+  io = captureIO();
+});
+
+const HEADER = '| 模块 | 文件 | 说明 |\n|------|------|------|\n';
+
+/** 「上一行与下一行都是表格行、本行为空」的行数 —— 本票的判定面 */
+function countBlankRowsInsideTable(content: string): number {
+  const lines = content.split('\n');
+  let n = 0;
+  for (let i = 1; i < lines.length - 1; i++) {
+    if (
+      lines[i].trim() === '' &&
+      /^\s*\|/.test(lines[i - 1]) &&
+      /^\s*\|/.test(lines[i + 1])
+    ) {
+      n++;
+    }
+  }
+  return n;
+}
+
+/** 建一个 file 模式的最小工程：srcFiles 存在，CAPABILITIES.md 由 rows 拼出 */
+function makeProject(
+  name: string,
+  srcFiles: string[],
+  doc: string
+): string {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), `sync-docs-layout-${name}-`));
+  fs.mkdirSync(path.join(dir, 'src'), { recursive: true });
+  for (const f of srcFiles) {
+    const file = path.join(dir, 'src', f);
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, 'export const x = 1;\n');
+  }
+  fs.writeFileSync(path.join(dir, 'CAPABILITIES.md'), doc);
+  return dir;
+}
+const read = (dir: string) => fs.readFileSync(path.join(dir, 'CAPABILITIES.md'), 'utf-8');
+const dataRow = (name: string, file: string, desc = 'D') => `| ${name} | ${file} | ${desc} |`;
+
+describe('sync-docs CAPABILITIES.md 表格排版（#171）', () => {
+  it('撤中间登记行：整行删除，表格保持连续', async () => {
+    const dir = makeProject(
+      'middle',
+      ['a.ts', 'c.ts'],
+      `# Capabilities\n\n${HEADER}${dataRow('a', 'src/a.ts')}\n${dataRow('b', 'src/b.ts')}\n${dataRow('c', 'src/c.ts')}\n`
+    );
+
+    await syncDocs({ projectPath: dir }, io);
+
+    const out = read(dir);
+    expect(out).not.toContain('src/b.ts');
+    expect(countBlankRowsInsideTable(out)).toBe(0);
+    expect(out).toBe(`# Capabilities\n\n${HEADER}${dataRow('a', 'src/a.ts')}\n${dataRow('c', 'src/c.ts')}\n`);
+    fs.rmSync(dir, { recursive: true, force: true });
+  });
+
+  it('撤目录条目行（studio 撤登记形状）：同样整行删除', async () => {
+    const dir = makeProject(
+      'dir-entry',
+      ['cli/cli.ts', 'harness/h.ts'],
+      `# Capabilities\n\n${HEADER}` +
+        `${dataRow('cli', 'src/cli/', 'C')}\n` +
+        `${dataRow('hooks', 'src/hooks/', 'H')}\n` +
+        `${dataRow('harness', 'src/harness/', 'A')}\n`
+    );
+
+    await syncDocs({ projectPath: dir }, io);
+
+    const out = read(dir);
+    expect(out).not.toContain('src/hooks/');
+    expect(countBlankRowsInsideTable(out)).toBe(0);
+    expect(out).toContain(`${dataRow('cli', 'src/cli/', 'C')}\n${dataRow('harness', 'src/harness/', 'A')}`);
+    fs.rmSync(dir, { recursive: true, force: true });
+  });
+
+  it('撤最后一行：不留文件末尾空行', async () => {
+    const dir = makeProject(
+      'last',
+      ['a.ts'],
+      `# Capabilities\n\n${HEADER}${dataRow('a', 'src/a.ts')}\n${dataRow('gone', 'src/gone.ts')}\n`
+    );
+
+    await syncDocs({ projectPath: dir }, io);
+
+    expect(read(dir)).toBe(`# Capabilities\n\n${HEADER}${dataRow('a', 'src/a.ts')}\n`);
+    fs.rmSync(dir, { recursive: true, force: true });
+  });
+
+  it('存量脏行（无其它漂移）：--check 报待清理，写模式收拢且收拢后 check 转绿', async () => {
+    const dirty = `# Capabilities\n\n${HEADER}${dataRow('a', 'src/a.ts')}\n\n${dataRow('z', 'src/z.ts')}\n`;
+    const dir = makeProject('legacy', ['a.ts', 'z.ts'], dirty);
+
+    expect(countBlankRowsInsideTable(read(dir))).toBe(1);
+    const check = await syncDocs({ projectPath: dir, check: true }, io);
+    expect(check).toEqual({ kind: 'fail', reason: expect.stringContaining('表格') });
+
+    await syncDocs({ projectPath: dir }, io);
+    const out = read(dir);
+    expect(countBlankRowsInsideTable(out)).toBe(0);
+    expect(out).toContain('src/a.ts');
+    expect(out).toContain('src/z.ts');
+    expect(await syncDocs({ projectPath: dir, check: true }, io)).toEqual({ kind: 'ok' });
+    fs.rmSync(dir, { recursive: true, force: true });
+  });
+
+  it('表格被撤空：连表头/分隔行一起收掉', async () => {
+    const dir = makeProject(
+      'empty-table',
+      [],
+      `# Capabilities\n\n${HEADER}${dataRow('gone1', 'src/gone1.ts')}\n${dataRow('gone2', 'src/gone2.ts')}\n`
+    );
+
+    await syncDocs({ projectPath: dir }, io);
+
+    const out = read(dir);
+    expect(out).not.toContain('|------|');
+    expect(out).not.toContain('模块 | 文件');
+    expect(out).not.toMatch(/\n{3,}/);
+    expect(await syncDocs({ projectPath: dir, check: true }, io)).toEqual({ kind: 'ok' });
+    fs.rmSync(dir, { recursive: true, force: true });
+  });
+
+  it('撤登同时有新增：不得把仍要使用的表头收掉', async () => {
+    const dir = makeProject(
+      'remove-and-add',
+      ['b.ts', 'fresh.ts'],
+      `# Capabilities\n\n${HEADER}${dataRow('a', 'src/gone.ts')}\n${dataRow('b', 'src/b.ts')}\n`
+    );
+
+    await syncDocs({ projectPath: dir }, io);
+
+    const out = read(dir);
+    expect(out).toContain('模块 | 文件 | 说明');
+    expect(out).toContain('fresh.ts');
+    expect(countBlankRowsInsideTable(out)).toBe(0);
+    fs.rmSync(dir, { recursive: true, force: true });
+  });
+
+  it('表格外的空行不动（段落分隔不是脏行）', async () => {
+    const doc = `# Capabilities\n\n${HEADER}${dataRow('a', 'src/a.ts')}\n\n## 说明\n\n散文。\n`;
+    const dir = makeProject('prose', ['a.ts'], doc);
+
+    const check = await syncDocs({ projectPath: dir, check: true }, io);
+    expect(check).toEqual({ kind: 'ok' });
+    expect(read(dir)).toBe(doc);
+    fs.rmSync(dir, { recursive: true, force: true });
+  });
+
+  it('代码块内「表头+分隔行无数据行」的示例不被收掉', async () => {
+    const doc =
+      `# Capabilities\n\n${HEADER}${dataRow('a', 'src/a.ts')}\n\n` +
+      `登记格式：\n\n\`\`\`markdown\n| 模块 | 文件 | 说明 |\n|------|------|------|\n\`\`\`\n\n散文。\n`;
+    const dir = makeProject('fenced-empty-table', ['a.ts'], doc);
+
+    expect(await syncDocs({ projectPath: dir, check: true }, io)).toEqual({ kind: 'ok' });
+
+    await syncDocs({ projectPath: dir }, io);
+    expect(read(dir)).toBe(doc);
+    fs.rmSync(dir, { recursive: true, force: true });
+  });
+
+  it('代码块内的表格样式行不被收拢（含块内空行）', async () => {
+    const doc =
+      `# Capabilities\n\n${HEADER}${dataRow('a', 'src/a.ts')}\n\n` +
+      `示例：\n\n\`\`\`\n| x | y |\n\n| z | w |\n\`\`\`\n`;
+    const dir = makeProject('fenced-blank-row', ['a.ts'], doc);
+
+    expect(await syncDocs({ projectPath: dir, check: true }, io)).toEqual({ kind: 'ok' });
+
+    await syncDocs({ projectPath: dir }, io);
+    expect(read(dir)).toBe(doc);
+    fs.rmSync(dir, { recursive: true, force: true });
+  });
+
+  it('两张空表相邻：一次收拢即干净（规则互相制造触发点，须跑到不动点）', () => {
+    // 规则①先吃掉两张空表之间的那个空行（两侧都是表格行），规则②在同一轮里
+    // 只看得到「表头+分隔行后面还有表格行」的前一张，收得掉后一张。不迭代就收不干净。
+    const first = normalizeCapabilitiesTableLayout(`${HEADER}\n${HEADER}`);
+
+    expect(first).toEqual({ content: '', blankLines: 1, emptyTables: 2 });
+    // 不动点：再跑一次零改动，`--check` 才不会修完还红
+    expect(normalizeCapabilitiesTableLayout(first.content)).toEqual({
+      content: '',
+      blankLines: 0,
+      emptyTables: 0,
+    });
+  });
+
+  it('收掉空表后不留三个以上连续换行（写模式收干净）', async () => {
+    const dir = makeProject(
+      'no-triple-newline',
+      [],
+      `# Capabilities\n\n${HEADER}${dataRow('gone', 'src/gone.ts')}\n\n## 说明\n\n散文。\n`
+    );
+
+    await syncDocs({ projectPath: dir }, io);
+
+    const out = read(dir);
+    expect(out).not.toMatch(/\n{3,}/);
+    expect(out).toContain('## 说明');
+    expect(out).toContain('散文。');
+    expect(await syncDocs({ projectPath: dir, check: true }, io)).toEqual({ kind: 'ok' });
+    fs.rmSync(dir, { recursive: true, force: true });
+  });
+
+  it('围栏内示例行引用已删文件：随幽灵行一起删掉，且 check 收敛（取舍见实现注释）', async () => {
+    // 登记条目由 capabilities-parser 全文扫描得出（ADR-0009），块内行也算登记项；
+    // 只让幽灵行删除豁免围栏，这个示例会永远被报成已删模块且修不掉。
+    const doc =
+      `# Capabilities\n\n${HEADER}${dataRow('a', 'src/a.ts')}\n\n` +
+      `登记格式示例：\n\n\`\`\`markdown\n${HEADER}${dataRow('gone', 'src/gone.ts')}\n\`\`\`\n`;
+    const dir = makeProject('fenced-ghost-entry', ['a.ts'], doc);
+
+    expect(await syncDocs({ projectPath: dir, check: true }, io)).toMatchObject({ kind: 'fail' });
+    expect(io.outText()).toContain('src/gone.ts');
+
+    await syncDocs({ projectPath: dir }, io);
+
+    const out = read(dir);
+    expect(out).not.toContain('src/gone.ts');
+    expect(out).toContain(dataRow('a', 'src/a.ts'));
+    // 只吃掉引用已删文件的那一行，块内其余正文留着（不是「把围栏里所有行一起删」）
+    expect(out).toContain('```markdown\n' + HEADER);
+    expect(countBlankRowsInsideTable(out)).toBe(0);
+    expect(await syncDocs({ projectPath: dir, check: true }, io)).toEqual({ kind: 'ok' });
+    fs.rmSync(dir, { recursive: true, force: true });
+  });
+
+  it('CRLF 文档撤行：整行连行尾一起删除', async () => {
+    const doc = `# Capabilities\r\n\r\n${HEADER.replace(/\n/g, '\r\n')}${dataRow('a', 'src/a.ts')}\r\n${dataRow('gone', 'src/gone.ts')}\r\n`;
+    const dir = makeProject('crlf', ['a.ts'], doc);
+
+    await syncDocs({ projectPath: dir }, io);
+
+    const out = read(dir);
+    expect(out).not.toContain('src/gone.ts');
+    expect(out.endsWith(`${dataRow('a', 'src/a.ts')}\r\n`)).toBe(true);
+    expect(countBlankRowsInsideTable(out)).toBe(0);
+    fs.rmSync(dir, { recursive: true, force: true });
+  });
+});

package/src/cli/commands/check.ts

@@ -1,9 +1,9 @@
 /**
  * harness check 命令
  *
- * 检查约束是否满足（check 层：Iron Laws / Guidelines；prompt 层仅注入不检查）
+ * 检查约束是否满足（severity='error' 阻断 / severity='warning' 告警）
  * 工单 23：触发条件与证据检测迁至 core/constraints/context-builder
- * ADR-0001：约束集统一走 getMergedConstraintsConfig 生效集链路（preset/config 禁用/custom/scenes）
+ * 约束集统一走 getMergedConstraintsConfig 生效集链路（preset/config 禁用）
  * harness#88：本命令是 trace 记录器的组合根——core 不上行依赖 monitoring，
  * 真实收集器在此经构造参数接线；#139：收集器锚根构造，trace 落点跟 --project-path 走
  */
@@ -11,13 +11,11 @@
 import chalk from 'chalk';
 import * as path from 'path';
 import { ConstraintChecker } from '../../core/constraints/checker';
-import { IRON_LAWS, GUIDELINES, PROMPTS } from '../../core/constraints/definitions';
-import { getMergedConstraintsConfig, constraintsFromMerged } from '../../core/effective-constraints';
+import { CONSTRAINTS } from '../../core/constraints/definitions';
+import { getMergedConstraintsConfig } from '../../core/effective-constraints';
 import { buildConstraintContext } from '../../core/constraints/context-builder';
 import { createGitEvidence, type GitEvidence } from '../../core/constraints/git-evidence';
 import { createRunEnv, type RunEnv } from '../../core/constraints/run-env';
-import { detectInjectionDrift } from '../../core/constraints/injection-drift';
-import { GOVERNANCE_HEADING } from '../../core/constraints/injection-writer';
 import { TraceCollector } from '../../monitoring/traces';
 import { readJsonl } from '../../utils/jsonl';
 import { DEFAULT_TRACE_FILE, type ExecutionTrace } from '../../types/trace';
@@ -100,14 +98,11 @@ export async function check(
     const runEnv = options.runEnv ?? createRunEnv(projectPath);
     const stateIO = options.stateIO ?? fileStateIO(projectPath);
 
-    // 生效约束集（ADR-0001）：内置 → preset → config.yml 禁用 → custom 追加 → scenes 过滤。
+    // 生效约束集：内置 → preset → config.yml 禁用。
     // --preset 仅在没有项目自定义配置时覆盖 config.yml 的 preset（工单 23 语义：
     // 项目自定义配置优先于 CLI 预设），优先级规则收在 getMergedConstraintsConfig 一处。
     // CLI 不给 -p 缺省值：没传 = 尊重 config.yml（ADR-0023 步骤 4.5，缺省值曾让两者不可区分）
     const merged = getMergedConstraintsConfig(runEnv, { preset: options.preset });
-    if (merged.custom.length > 0) {
-      log(io, chalk.gray(`自定义约束: ${merged.custom.length} 条`));
-    }
     if (merged.disabled.length > 0) {
       log(io, chalk.gray(`已禁用约束: ${merged.disabled.join(', ')}`));
     }
@@ -132,7 +127,7 @@ export async function check(
     }
     log(io, chalk.gray(`触发条件: ${[context.operation, ...(context.extraTriggers ?? [])].join(', ')}`));
 
-    // 执行三层检查（per-request 传 customConfig，避免单例状态污染；证据同 run 同源）
+    // 执行约束检查（per-request 传 customConfig，避免单例状态污染；证据同 run 同源）
     // trace 记录器经构造参数接线（harness#88）：一次命令一个 checker 实例
     // #139：收集器锚根构造——不传 projectPath 时 trace 会落进调用方 cwd，B 侧读不到
     const checker = new ConstraintChecker(new TraceCollector({ projectPath }));
@@ -141,20 +136,20 @@ export async function check(
     // 输出结果
     log(io);
 
-    // skipped（约定未采用/证据未接线）单独列示，不进 pass/fail 统计（ADR-0001）
+    // skipped（约定未采用/证据未接线）单独列示，不进 pass/fail 统计
     const skippedResults = [
-      ...result.ironLaws,
-      ...result.guidelines,
+      ...result.errors,
+      ...result.warnings,
     ].filter(r => r.skipped);
 
-    // Iron Laws
-    const evaluatedIronLaws = result.ironLaws.filter(r => !r.skipped);
-    const ironLawViolations = evaluatedIronLaws.filter(r => !r.satisfied);
-    if (ironLawViolations.length === 0 && evaluatedIronLaws.length > 0) {
-      log(io, chalk.green(`✅ 铁律: 全部通过 (${evaluatedIronLaws.length} 条)`));
-    } else if (ironLawViolations.length > 0) {
-      log(io, chalk.red(`❌ 铁律违规: ${ironLawViolations.length} 条`));
-      ironLawViolations.forEach(r => {
+    // severity='error'（违规即阻断）
+    const evaluatedErrors = result.errors.filter(r => !r.skipped);
+    const errorViolations = evaluatedErrors.filter(r => !r.satisfied);
+    if (errorViolations.length === 0 && evaluatedErrors.length > 0) {
+      log(io, chalk.green(`✅ error 级约束: 全部通过 (${evaluatedErrors.length} 条)`));
+    } else if (errorViolations.length > 0) {
+      log(io, chalk.red(`❌ error 级约束违规: ${errorViolations.length} 条`));
+      errorViolations.forEach(r => {
         if (r.constraint) {
           log(io, chalk.red(`   - ${r.constraint.id}: ${r.constraint.message}`));
           log(io, chalk.red(`     ${r.constraint.rule}`));
@@ -162,31 +157,31 @@ export async function check(
         }
       });
       log(io);
-      log(io, chalk.red('🛑 铁律检查失败，请修复后再提交'));
+      log(io, chalk.red('🛑 error 级约束检查失败，请修复后再提交'));
       return {
         kind: 'fail',
-        reason: `iron law violated: ${ironLawViolations.map(r => r.constraint?.id ?? 'unknown').join(', ')}`,
+        reason: `error-severity constraint violated: ${errorViolations.map(r => r.constraint?.id ?? 'unknown').join(', ')}`,
       };
     }
 
-    // Guidelines
+    // severity='warning'（告警不阻断）
     if (result.warningCount > 0) {
-      log(io, chalk.yellow(`⚠️  指导原则警告: ${result.warningCount} 条`));
-      result.guidelines.filter(r => !r.satisfied).forEach(r => {
+      log(io, chalk.yellow(`⚠️  warning 级约束警告: ${result.warningCount} 条`));
+      result.warnings.filter(r => !r.satisfied).forEach(r => {
         if (r.constraint) {
           log(io, chalk.yellow(`   - ${r.constraint.id}: ${r.constraint.message}`));
           logEvidence(io, r, 'yellow');
         }
       });
-    } else if (result.guidelines.length > 0) {
-      const evaluatedGuidelines = result.guidelines.filter(r => !r.skipped);
-      const passedGuidelines = evaluatedGuidelines.filter(r => r.satisfied).length;
-      log(io, chalk.green(`✅ 指导原则: ${passedGuidelines}/${evaluatedGuidelines.length} 通过`));
+    } else if (result.warnings.length > 0) {
+      const evaluatedWarnings = result.warnings.filter(r => !r.skipped);
+      const passedWarnings = evaluatedWarnings.filter(r => r.satisfied).length;
+      log(io, chalk.green(`✅ warning 级约束: ${passedWarnings}/${evaluatedWarnings.length} 通过`));
     }
 
     // 提示：通过但带证据（harness#119）——与本次变更无因果的仓库级漂移在此露出，
     // 不判违规、不改 exit code，只保证「看得见且能自己修」
-    const hints = [...result.ironLaws, ...result.guidelines].filter(
+    const hints = [...result.errors, ...result.warnings].filter(
       r => !r.skipped && r.satisfied && (r.evidence?.length ?? 0) > 0
     );
     if (hints.length > 0) {
@@ -202,29 +197,6 @@ export async function check(
       });
     }
 
-    // 注入漂移校验（ADR-0001 决策 7）：黄色警告块，不改 exit code、不影响门禁结果。
-    // 无漂移/未注入零输出；漂移检测自身异常静默吞掉，绝不影响 check。
-    try {
-      // 生效集直接用本 run 那一份：一遍算完，且比对对象就是本次实际执法的规则集（ADR-0023 步骤 4.5）
-      const drift = detectInjectionDrift(runEnv, undefined, constraintsFromMerged(merged));
-      if (drift.hasDrift) {
-        log(io);
-        log(io, chalk.yellow(`⚠️  检测到 ${drift.injectionFile ?? '治理文档'} 约束注入漂移（仅警告，不阻断）:`));
-        if (drift.versionDrift) {
-          log(io, chalk.yellow(`   ⚠️⚠️ 注入段版本 (${drift.versionDrift.actual}) ≠ 已安装 harness 版本 (${drift.versionDrift.expected})：agent 上下文中的规则与已安装 harness 版本不一致`));
-        }
-        if (drift.contentDrift) {
-          log(io, chalk.yellow(`   内容漂移: 缺失 ${drift.contentDrift.missing.length} 条 / 多余 ${drift.contentDrift.extra.length} 条（条目级差异见 harness constraints report）`));
-        }
-        if (drift.duplicateHeading) {
-          log(io, chalk.yellow(`   检测到重复的 "${GOVERNANCE_HEADING}" 章节`));
-        }
-        log(io, chalk.yellow(`   修复: ${drift.fixHint}`));
-      }
-    } catch {
-      // 漂移检测失败不影响 check 结果
-    }
-
     log(io);
     log(io, chalk.green('✅ 约束检查通过'));
 
@@ -288,37 +260,26 @@ async function getSmartHint(projectPath: string, stateIO: StateIO): Promise<stri
 }
 
 /**
- * 列出所有约束
+ * 列出所有约束（按 severity 分组）
  */
 /** optionRoutes 一律以 (options) 调用；--list 不消费检查选项，形参仅占位 */
 export function listLaws(_options: Partial<CheckOptions> = {}, io: CommandIO = processIO): CommandResult {
   log(io, chalk.blue('\n📜 所有约束:\n'));
 
-  // Iron Laws
-  log(io, chalk.red('🔴 铁律 (Iron Laws) - 绝对禁止，无例外:\n'));
-  Object.values(IRON_LAWS).forEach(constraint => {
-    log(io, chalk.red(`  ${constraint.id}`));
-    log(io, chalk.gray(`    ${constraint.rule}`));
-    log(io, chalk.gray(`    ${constraint.message}`));
-    log(io);
-  });
-
-  // Guidelines
-  log(io, chalk.yellow('🟡 指导原则 (Guidelines) - 优先建议，违背发警告但不阻止:\n'));
-  Object.values(GUIDELINES).forEach(constraint => {
-    log(io, chalk.yellow(`  ${constraint.id}`));
-    log(io, chalk.gray(`    ${constraint.rule}`));
-    log(io, chalk.gray(`    ${constraint.message}`));
-    log(io);
-  });
-
-  // Prompts（ADR-0001：纯注入层，不执行检查）
-  log(io, chalk.blue('🔵 提示 (Prompts) - 纯文本注入，不参与检查:\n'));
-  Object.values(PROMPTS).forEach(constraint => {
-    log(io, chalk.blue(`  ${constraint.id}`));
-    log(io, chalk.gray(`    ${constraint.rule}`));
-    log(io, chalk.gray(`    ${constraint.message}`));
-    log(io);
-  });
+  const groups: Array<{ severity: 'error' | 'warning'; heading: string; paint: (s: string) => string }> = [
+    { severity: 'error', heading: '🔴 error 级 - 违规即阻断，无例外:', paint: chalk.red },
+    { severity: 'warning', heading: '🟡 warning 级 - 违规发警告但不阻止:', paint: chalk.yellow },
+  ];
+  for (const group of groups) {
+    log(io, group.paint(group.heading + '\n'));
+    Object.values(CONSTRAINTS)
+      .filter(c => c.severity === group.severity)
+      .forEach(constraint => {
+        log(io, group.paint(`  ${constraint.id}`));
+        log(io, chalk.gray(`    ${constraint.rule}`));
+        log(io, chalk.gray(`    ${constraint.message}`));
+        log(io);
+      });
+  }
   return { kind: 'ok' };
 }

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

@@ -1,10 +1,9 @@
 /**
- * harness constraints report —— 约束使用报告（ADR-0001 决策 3/4）
+ * harness constraints report —— 约束使用报告（ADR-0001 决策 3/4，ADR-0029 收窄）
  *
  * 只读。面向"人审约束"场景：
- * - check 层统计表（total/pass/fail/skip、fail 率、首次/最近触发）
+ * - check 约束统计表（total/pass/fail/skip、fail 率、首次/最近触发）
  * - 退役候选诊断（零触发/零拦截/不可评估/高噪），retire 交互模式的数据源
- * - 当前生效 prompt 注入清单
  * - 配置健康（unknownIds 残留提示）
  * - --export [file]：脱敏 markdown 摘要（不含项目路径）
  */
@@ -21,8 +20,6 @@ import {
   type DiagnoseThresholds,
 } from '../../core/constraints/usage-report';
 import { getConstraintsMeta } from './constraints';
-import { detectInjectionDrift, type InjectionDrift } from '../../core/constraints/injection-drift';
-import { GOVERNANCE_HEADING } from '../../core/constraints/injection-writer';
 import { log, processIO, type CommandIO, type CommandResult } from '../command-contract';
 
 export interface ConstraintsReportOptions {
@@ -75,7 +72,7 @@ export function renderExportMarkdown(
   }
   lines.push('');
 
-  lines.push('## 统计表（check 层）');
+  lines.push('## 统计表');
   lines.push('');
   lines.push('| id | total | pass | fail | skip | fail 率 | 首次触发 | 最近触发 |');
   lines.push('| --- | ---: | ---: | ---: | ---: | ---: | --- | --- |');
@@ -109,43 +106,6 @@ export function renderExportMarkdown(
   return lines.join('\n');
 }
 
-/**
- * 渲染"注入漂移"小节的文本行（ADR-0001 决策 7：详细条目级差异进 report）
- *
- * 返回纯文本行数组（不含 chalk 着色），调用方逐行 console.log。
- */
-export function renderInjectionDriftLines(drift: InjectionDrift): string[] {
-  const lines: string[] = [];
-  if (drift.notInjected) {
-    lines.push('  CLAUDE.md / AGENTS.md 均无约束注入标记段（未注入，不算漂移）；可运行 npx @dommaker/harness init 注入');
-    if (drift.duplicateHeading) {
-      lines.push(`  另检测到多个 "${GOVERNANCE_HEADING}" 标题（历史遗留重复章节），建议手工清理后重跑 npx @dommaker/harness init`);
-    }
-    return lines;
-  }
-  if (!drift.hasDrift) {
-    lines.push('  无漂移');
-    return lines;
-  }
-  if (drift.versionDrift) {
-    lines.push(`  版本漂移: 注入段版本 (${drift.versionDrift.actual}) ≠ 当前 harness 版本 (${drift.versionDrift.expected})`);
-  }
-  if (drift.contentDrift) {
-    lines.push('  内容漂移（条目级差异）:');
-    for (const l of drift.contentDrift.missing) {
-      lines.push(`    缺失: ${l}`);
-    }
-    for (const l of drift.contentDrift.extra) {
-      lines.push(`    多余: ${l}`);
-    }
-  }
-  if (drift.duplicateHeading) {
-    lines.push(`  重复章节: 标记段之外还存在另一个 "${GOVERNANCE_HEADING}" 标题`);
-  }
-  lines.push(`  修复: ${drift.fixHint}`);
-  return lines;
-}
-
 /**
  * CLI handler: harness constraints report
  */
@@ -173,7 +133,7 @@ export async function constraintsReport(options: ConstraintsReportOptions = {},
   log(io);
 
   // 统计表
-  log(io, chalk.bold('统计表（check 层）:'));
+  log(io, chalk.bold('统计表:'));
   for (const s of report.stats) {
     log(io, `  ${renderStatsRow(s)}`);
   }
@@ -191,13 +151,6 @@ export async function constraintsReport(options: ConstraintsReportOptions = {},
   }
   log(io);
 
-  // 注入清单
-  log(io, chalk.bold(`当前生效 prompt 注入（${report.activePromptIds.length} 条）:`));
-  for (const id of report.activePromptIds) {
-    log(io, `  ${id}`);
-  }
-  log(io);
-
   // 配置健康
   if (report.lint.unknownIds.length > 0) {
     log(io, chalk.yellow('⚠️  配置健康:'));
@@ -207,14 +160,6 @@ export async function constraintsReport(options: ConstraintsReportOptions = {},
     log(io);
   }
 
-  // 注入漂移（ADR-0001 决策 7：条目级差异 + 修复指引；--export 摘要不含本地漂移状态）
-  log(io, chalk.bold('注入漂移:'));
-  const drift = detectInjectionDrift(projectRoot);
-  for (const line of renderInjectionDriftLines(drift)) {
-    log(io, drift.hasDrift ? chalk.yellow(line) : line);
-  }
-  log(io);
-
   // --export
   if (options.export !== undefined && options.export !== false) {
     const version = getConstraintsMeta().version;