@dommaker/harness 1.9.0 → 1.11.0

package/src/core/constraints/checkers/__tests__/check-outcome.test.ts

@@ -23,7 +23,7 @@ import type { MergedConstraintsConfig } from '../../../../types/project-config';
 const CAPABILITY_SYNC: Constraint = {
   id: 'capability_sync',
   kind: 'check',
-  level: 'guideline',
+  severity: 'warning',
   rule: 'CODE CHANGES MUST UPDATE CAPABILITIES.MD',
   message: '核心模块变更必须同步功能清单',
   trigger: ['module_modification'],
@@ -62,11 +62,8 @@ describe('normalizeCheckOutcome — 三态 + 证据归一', () => {
 /** 只含 capability_sync 的生效集：一次 run 一条 trace，不牵动其他约束 */
 function onlyCapabilitySync(): MergedConstraintsConfig {
   return {
-    ironLaws: {},
-    guidelines: { capability_sync: CAPABILITY_SYNC },
-    prompts: {},
+    constraints: { capability_sync: CAPABILITY_SYNC },
     disabled: [],
-    custom: [],
   };
 }
 
@@ -81,7 +78,7 @@ async function runGuideline(dir: string): Promise<{
     { operation: 'module_modification', projectPath: dir },
     onlyCapabilitySync()
   );
-  const result = run.guidelines.find(r => r.id === 'capability_sync')!;
+  const result = run.warnings.find(r => r.id === 'capability_sync')!;
   const trace = traces.find(t => t.constraintId === 'capability_sync')!;
   return { result, trace };
 }
@@ -151,7 +148,7 @@ describe('证据随铁律异常外溢（CLI catch 分支只打印 error.message
   it('ConstraintViolationError 文案带出证据行', () => {
     const error = new ConstraintViolationError({
       id: 'docs_freshness',
-      level: 'iron_law',
+      severity: 'error',
       satisfied: false,
       message: '文档新鲜度检查未通过',
       evidence: ['CAPABILITIES.md 登记的条目不存在:', 'src/gone.ts'],
@@ -165,7 +162,7 @@ describe('证据随铁律异常外溢（CLI catch 分支只打印 error.message
   it('无证据时文案保持原样（旧消费方断言不受影响）', () => {
     const error = new ConstraintViolationError({
       id: 'no_test_simplification',
-      level: 'iron_law',
+      severity: 'error',
       satisfied: false,
       message: '禁止简化测试绕过困难',
       checkedAt: new Date(),

package/src/core/constraints/checkers/__tests__/governance-presence.test.ts

@@ -16,7 +16,6 @@ import {
   hasGovernancePreserveBlock,
   hasClaudeGovernance,
 } from '../governance-presence';
-import { detectInjectionDrift } from '../../injection-drift';
 import { createProjectFixture, writeProjectConfig } from '../../../../test-setup/project-fixture';
 import { normalizeCheckOutcome, type CheckEnv } from '../types';
 import { createRunEnv } from '../../run-env';
@@ -99,7 +98,7 @@ describe('governance_presence checker', () => {
     const outcome = await outcomeOf(tempDir);
     expect(outcome.satisfied).toBe(false);
     expect(outcome.evidence.join('\n')).toContain('治理契约');
-    expect(outcome.evidence.join('\n')).toContain('harness init');
+    expect(outcome.evidence.join('\n')).toContain('PRESERVE:governance');
     // ADR-0016：证据只有一个出口。侧信道留着会让 CLI 结构化输出与 trace 两头口径不一致
     expect(errorSpy).not.toHaveBeenCalled();
   });
@@ -159,54 +158,3 @@ describe('hasGovernancePreserveBlock / hasClaudeGovernance 判定函数', () =>
     expect(hasGovernancePreserveBlock(p)).toBe(false);
   });
 });
-
-describe('governance_presence × detectInjectionDrift 同 fixture 一致性（#83）', () => {
-  let tempDir: string;
-
-  const writeConfig = () => writeProjectConfig(tempDir, 'preset: standard\n');
-
-  beforeEach(() => {
-    tempDir = createProjectFixture({
-      name: 'temp-test-gov-consistency',
-      parentDir: process.cwd(),
-    });
-  });
-
-  afterEach(() => {
-    fs.rmSync(tempDir, { recursive: true, force: true });
-  });
-
-  it('双空格标题：presence 认在场（pass），drift 严格计数 0 不报重复——两层不再互相矛盾', async () => {
-    writeConfig();
-    fs.writeFileSync(path.join(tempDir, 'CLAUDE.md'), '# CLAUDE.md\n\n##  Governance Rules\n\n条款\n');
-
-    expect(await governancePresence.evaluate(makeEnv(tempDir))).toBe(true);
-    const drift = detectInjectionDrift(tempDir);
-    expect(drift.notInjected).toBe(true);
-    expect(drift.duplicateHeading).toBe(false);
-    expect(drift.hasDrift).toBe(false);
-  });
-
-  it('精确拼写单标题：presence pass，drift 不报重复', async () => {
-    writeConfig();
-    fs.writeFileSync(path.join(tempDir, 'CLAUDE.md'), '# CLAUDE.md\n\n## Governance Rules\n\n条款\n');
-
-    expect(await governancePresence.evaluate(makeEnv(tempDir))).toBe(true);
-    const drift = detectInjectionDrift(tempDir);
-    expect(drift.notInjected).toBe(true);
-    expect(drift.duplicateHeading).toBe(false);
-  });
-
-  it('精确拼写双标题：presence 认在场，drift 报重复章节（计数是 drift 的独立职责）', async () => {
-    writeConfig();
-    fs.writeFileSync(
-      path.join(tempDir, 'CLAUDE.md'),
-      '# CLAUDE.md\n\n## Governance Rules\n\n甲\n\n## Governance Rules\n\n乙\n'
-    );
-
-    expect(await governancePresence.evaluate(makeEnv(tempDir))).toBe(true);
-    const drift = detectInjectionDrift(tempDir);
-    expect(drift.notInjected).toBe(true);
-    expect(drift.duplicateHeading).toBe(true);
-  });
-});

package/src/core/constraints/checkers/__tests__/iron-flags.test.ts

@@ -1,17 +1,16 @@
 /**
  * 铁律层 flag 检查旁测（架构评审候选4，ADR-0009 同模式）
  *
- * 三个 flag 铁律均为 contextEvidenceFlag 构造，真实 bug 面 = 读错上下文字段
+ * 唯一存活的 flag 铁律为 contextEvidenceFlag 构造，真实 bug 面 = 读错上下文字段
  * 与三态语义（undefined→skip / false→fail / true→pass）。直接喂不同字段组合
  * 钉死映射，不再经 engine facade（旧测在 skip-semantics/checker.test 间接打）。
+ *
+ * harness#174 删除 incremental_progress / no_implementation_without_requirement，
+ * 对应用例一并移除。
  */
 
 import { describe, it, expect } from '@jest/globals';
-import {
-  noCompletionWithoutVerification,
-  incrementalProgress,
-  noImplementationWithoutRequirement,
-} from '../iron-flags';
+import { noCompletionWithoutVerification } from '../iron-flags';
 import { buildCheckEnv } from '../types';
 import type { ConstraintContext } from '../../../../types/constraint';
 
@@ -28,23 +27,4 @@ describe('iron flags — 三态与字段映射', () => {
     // 相邻字段不串台：hasTest 不能顶替
     expect(await evaluate(noCompletionWithoutVerification, { hasTest: true })).toBe('skip');
   });
-
-  it('incremental_progress → 读 hasSingleTask', async () => {
-    expect(await evaluate(incrementalProgress, {})).toBe('skip');
-    expect(await evaluate(incrementalProgress, { hasSingleTask: false })).toBe(false);
-    expect(await evaluate(incrementalProgress, { hasSingleTask: true })).toBe(true);
-  });
-
-  it('no_implementation_without_requirement → 读 hasRequirement', async () => {
-    expect(await evaluate(noImplementationWithoutRequirement, {})).toBe('skip');
-    expect(await evaluate(noImplementationWithoutRequirement, { hasRequirement: false })).toBe(false);
-    expect(await evaluate(noImplementationWithoutRequirement, { hasRequirement: true })).toBe(true);
-  });
-
-  it('三 flag 各自独立判定（组合上下文互不影响）', async () => {
-    const ctx: Partial<ConstraintContext> = { hasVerificationEvidence: true, hasSingleTask: false };
-    expect(await evaluate(noCompletionWithoutVerification, ctx)).toBe(true);
-    expect(await evaluate(incrementalProgress, ctx)).toBe(false);
-    expect(await evaluate(noImplementationWithoutRequirement, ctx)).toBe('skip');
-  });
 });

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

@@ -90,7 +90,7 @@ export const docsFreshness: ConstraintCheck = {
     if (deadEntries.length > 0) {
       // 证据通道点名条目（harness#119）：此前是 console.error 侧信道（2026-08-08 studio
       // CI 4 连红时的临时办法），CLI 结构化输出与 trace 两头都拿不到，
-      // 铁律拦截时用户只看到一句通用提示，basename 碰撞下无从定位
+      // error 级拦截时用户只看到一句通用提示，basename 碰撞下无从定位
       return {
         pass: false,
         evidence: formatEvidence('CAPABILITIES.md 登记的条目不存在', deadEntries),

package/src/core/constraints/checkers/governance-presence.ts

@@ -2,7 +2,8 @@
  * governance_presence：治理契约在场守护（studio #302，ADR 2026-08-21 落点模型）
  *
  * 治理契约正本 = AGENTS.md 手写 `PRESERVE:governance` 段（旧模型仓 = CLAUDE.md
- * Governance Rules / HARNESS_CONSTRAINTS 注入段）。PRESERVE 只保「存在」不保「在场」：
+ * Governance Rules 块 / 历史 HARNESS_CONSTRAINTS 注入段，ADR-0029 后注入段不再
+ * 生成，残留段仅作历史兼容判据）。PRESERVE 只保「存在」不保「在场」：
  * 段被删除/掏空后 sync-docs 重新生成会静默丢失，此处补「在场」校验。
  *
  * ADR-0001 存在性探测：项目未采用 harness 治理（无 .harness/config.yml）→ skip。
@@ -48,12 +49,12 @@ export const governancePresence: ConstraintCheck = {
     if (hasClaudeGovernance(join(projectPath, 'CLAUDE.md'))) return true;
 
     // 证据随判定一并返回（ADR-0016 补迁）：此前这里是 console.error 侧信道——
-    // 只进本地 stderr，进不了 CLI 结论块与 trace，铁律拦截时用户看不到该恢复哪个正本
+    // 只进本地 stderr，进不了 CLI 结论块与 trace，error 级拦截时用户看不到该恢复哪个正本
     return {
       pass: false,
       evidence: [
         '治理契约缺失：AGENTS.md 无非空 PRESERVE:governance 段，CLAUDE.md 也无 Governance Rules 块（正本静默丢失）',
-        '修复: 恢复其一（重跑 `harness init` 会同步注入段）',
+        '修复: 恢复其一——AGENTS.md 补回手写 PRESERVE:governance 段，或 CLAUDE.md 补回 Governance Rules 块',
       ],
     };
   },

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

@@ -13,10 +13,7 @@ import { getAllConstraints } from '../definitions';
 
 import {
   noCompletionWithoutVerification,
-  incrementalProgress,
-  noImplementationWithoutRequirement,
 } from './iron-flags';
-import { noBypassCheckpoint } from './no-bypass-checkpoint';
 import { noTestSimplification } from './no-test-simplification';
 import { capabilitySync } from './capability-sync';
 import { contextDocSync } from './context-doc-sync';
@@ -25,15 +22,12 @@ import { noHardcodedCredentials } from './no-hardcoded-credentials';
 import { governancePresence } from './governance-presence';
 
 const CHECKS: ConstraintCheck[] = [
-  // Iron Laws
+  // severity='error'
   noCompletionWithoutVerification,
-  incrementalProgress,
-  noImplementationWithoutRequirement,
   noTestSimplification,
   docsFreshness,
-  // Guidelines
+  // severity='warning'
   noHardcodedCredentials,
-  noBypassCheckpoint,
   capabilitySync,
   contextDocSync,
   governancePresence,
@@ -51,7 +45,7 @@ for (const c of checkConstraints) {
   if (!registry.has(c.id)) {
     throw new Error(
       `[harness] 约束注册表闭环校验失败：kind='check' 的约束 "${c.id}" 未注册 checker。` +
-      `请在 checkers/ 中实现并注册，或将该约束降级为 kind='prompt'。`
+      `请在 checkers/ 中实现并注册（纯文本提示层已随 ADR-0029 关停）。`
     );
   }
 }
@@ -67,7 +61,7 @@ for (const id of registry.keys()) {
 
 /**
  * 按约束 ID 查找检查实现；未注册返回 undefined
- * （编排层对 kind='check' 未注册的情况抛错，kind='prompt' 不查表）
+ * （编排层对 kind='check' 未注册的情况抛错）
  */
 export function getConstraintCheck(id: string): ConstraintCheck | undefined {
   return registry.get(id);

package/src/core/constraints/checkers/iron-flags.ts

@@ -1,7 +1,8 @@
 /**
- * 铁律层轻量检查（工单 21）：纯上下文证据标志判定，无 I/O
+ * error 级轻量检查（工单 21）：纯上下文证据标志判定，无 I/O
  *
- * ADR-0001 后仅存活的三个 flag：hasVerificationEvidence / hasSingleTask / hasRequirement
+ * harness#174 后仅存活的 flag：hasVerificationEvidence
+ *（incremental_progress / no_implementation_without_requirement 已随定义一并删除）
  *
  * 三态语义（ADR-0001 防爆措施）：
  * - undefined = flag 未接线 → skip（不评估，CLI pre-commit 等路径不误报违规）
@@ -14,13 +15,3 @@ export const noCompletionWithoutVerification = contextEvidenceFlag(
   'no_completion_without_verification',
   ctx => ctx.hasVerificationEvidence
 );
-
-export const incrementalProgress = contextEvidenceFlag(
-  'incremental_progress',
-  ctx => ctx.hasSingleTask
-);
-
-export const noImplementationWithoutRequirement = contextEvidenceFlag(
-  'no_implementation_without_requirement',
-  ctx => ctx.hasRequirement
-);

package/src/core/constraints/checkers/no-test-simplification.ts

@@ -4,7 +4,7 @@
 
 import type { ConstraintCheck } from './types';
 
-// m 标志必需：真实 diff 首行恒为 `diff --git`，缺 m 则 ^ 永不命中删除行（铁律静默失效）
+// m 标志必需：真实 diff 首行恒为 `diff --git`，缺 m 则 ^ 永不命中删除行（checker 静默失效）
 const DELETED_TEST_PATTERNS = [
   /^-\s*(test|it|describe)\s*\(/m, // 删除 test/it/describe
   /^-\s*expect\s*\(/m,              // 删除 expect

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

@@ -113,7 +113,7 @@ export const MAX_EVIDENCE_ITEMS = 10;
 /**
  * 组装证据行：一行说明 + 逐条依据（超限截断）
  *
- * 每行自描述且不带缩进——缩进由消费端（CLI / gate 理由 / 铁律异常文案）决定，trace 原样存。
+ * 每行自描述且不带缩进——缩进由消费端（CLI / gate 理由 / error 级异常文案）决定，trace 原样存。
  * 修复入口不写在这里：那是各约束自己的事，写进各自的 summary 行（docs_freshness 的
  * 幽灵条目与 sync-docs 无关，共用一个指针会误导）。
  */

package/src/core/constraints/definitions/guidelines.ts

@@ -1,15 +1,15 @@
 /**
- * check · guideline 定义（ADR-0001：kind 二元模型）
+ * check 约束定义（severity='warning' 组，ADR-0029）
  *
- * 只保留带真实 checker 的指导原则。每条必须：
+ * 只保留带真实 checker 的约束。每条必须：
  * - kind: 'check'
- * - level: 'guideline'
+ * - severity: 'warning'（违规告警不阻断）
  * - 在 checkers/ 注册表中有对应实现（注册表闭环，缺失即加载期抛错）
  */
 
 import type { Constraint } from '../../../types/constraint';
 
-export const GUIDELINES: Record<string, Constraint> = {
+export const WARNING_CONSTRAINTS: Record<string, Constraint> = {
   /**
    * 禁止硬编码凭证
    * 原因：密码/token/密钥泄露是最严重的安全漏洞，一旦提交到版本控制即不可逆
@@ -19,27 +19,10 @@ export const GUIDELINES: Record<string, Constraint> = {
     kind: 'check',
     rule: 'NO HARDCODED PASSWORDS, TOKENS, SECRETS, OR CREDENTIALS IN ANY SOURCE FILE',
     message: '禁止在代码/文档/配置文件中硬编码密码、token、密钥、API key',
-    level: 'guideline',
+    severity: 'warning',
     trigger: ['code_implementation', 'doc_update', 'config_change', 'commit'],
     enforcement: 'credential-scan',
     description: `凭证（密码/token/密钥/API key）必须从环境变量或加密配置读取，严禁以明文形式出现在任何源代码文件中。包括但不限于：源码、Markdown 文档、YAML/JSON 配置、脚本文件。模板文件（.example/.sample/.template）允许占位符但不得包含真实值。建议配合 pre-commit hook 做自动扫描。`,
-    promptInjection: '禁止在代码中硬编码密码、API 密钥、Token 等凭证。使用环境变量或安全的凭证管理方案存储敏感信息。',
-  },
-
-  /**
-   * 禁止跳过检查点验证
-   * 原因：安全底线，检查点是质量门控
-   */
-  no_bypass_checkpoint: {
-    id: 'no_bypass_checkpoint',
-    kind: 'check',
-    rule: 'NO BYPASSING CHECKPOINTS',
-    message: '禁止跳过检查点验证',
-    level: 'guideline',
-    trigger: 'code_implementation',
-    enforcement: 'checkpoint-required',
-    description: '所有检查点必须通过，不能跳过验证步骤。检查点是质量的最后一道防线。',
-    promptInjection: '每个关键步骤后有 checkpoint 验证点，必须通过才能继续。通过标准：测试通过、类型检查无错误、lint 无新增警告。未通过时回退修复，不得跳过。',
   },
 
   /**
@@ -51,7 +34,7 @@ export const GUIDELINES: Record<string, Constraint> = {
     kind: 'check',
     rule: 'CODE CHANGES MUST UPDATE CAPABILITIES.MD',
     message: '核心模块变更必须同步功能清单（支持模块级目录条目登记）',
-    level: 'guideline',
+    severity: 'warning',
     trigger: ['module_creation', 'module_modification', 'module_deletion', 'module_extension'],
     enforcement: 'update-capabilities',
     description: `在创建/修改/删除/扩展核心模块时，必须同步更新 CAPABILITIES.md：
@@ -79,7 +62,7 @@ export const GUIDELINES: Record<string, Constraint> = {
     kind: 'check',
     rule: 'KEY DIRECTORIES SHOULD HAVE CONTEXT.MD',
     message: '关键目录缺少 CONTEXT.md，运行 harness sync-docs 创建模板后填写实际内容',
-    level: 'guideline',
+    severity: 'warning',
     trigger: 'module_modification',
     enforcement: 'context-check',
     description: `项目的关键目录应包含 CONTEXT.md 文件，描述目录职责和上下文。
@@ -108,7 +91,7 @@ export const GUIDELINES: Record<string, Constraint> = {
     kind: 'check',
     rule: 'GOVERNANCE CONTRACT MUST BE PRESENT (AGENTS.MD PRESERVE:GOVERNANCE BLOCK OR CLAUDE.MD GOVERNANCE RULES)',
     message: '治理契约缺失：AGENTS.md 缺少非空 PRESERVE:governance 段，且 CLAUDE.md 无 Governance Rules 块',
-    level: 'guideline',
+    severity: 'warning',
     trigger: ['file_modification', 'module_creation', 'module_modification', 'doc_update', 'config_change', 'commit'],
     enforcement: 'governance-presence-check',
     description: `治理契约（约束清单正本）必须在场，两处居其一：

package/src/core/constraints/definitions/iron-laws.ts

@@ -1,15 +1,15 @@
 /**
- * check · iron_law 定义（ADR-0001：kind 二元模型）
+ * check 约束定义（severity='error' 组，ADR-0029）
  *
- * 只保留带真实 checker 的铁律。每条必须：
+ * 只保留带真实 checker 的约束。每条必须：
  * - kind: 'check'
- * - level: 'iron_law'
+ * - severity: 'error'（违规即阻断）
  * - 在 checkers/ 注册表中有对应实现（注册表闭环，缺失即加载期抛错）
  */
 
 import type { Constraint } from '../../../types/constraint';
 
-export const IRON_LAWS: Record<string, Constraint> = {
+export const ERROR_CONSTRAINTS: Record<string, Constraint> = {
   /**
    * 禁止无验证声明完成
    * 原因：质量底线，必须有验证命令
@@ -19,95 +19,23 @@ export const IRON_LAWS: Record<string, Constraint> = {
     kind: 'check',
     rule: 'NO COMPLETION CLAIMS WITHOUT FRESH VERIFICATION EVIDENCE',
     message: '禁止无验证声明完成，必须运行验证命令',
-    level: 'iron_law',
+    severity: 'error',
     trigger: 'code_implementation',
     enforcement: 'verify-completion',
     description: '在声明任何任务完成之前，必须运行新鲜的验证命令（项目声明的测试 + type check），以新鲜输出作为完成证据。验证命令集由项目自行声明，全量验证留给 CI 流程。',
-    promptInjection: '在声明任务完成前，必须重新运行新鲜的验证命令（项目声明的测试 + type check），使用新鲜的输出作为完成证据，不得复用旧结果，不得凭记忆声称完成。',
-  },
-
-  /**
-   * 禁止一次做多个任务（one-shotting）
-   * 来源：Anthropic AI Harness - Effective Harnesses for Long-running Agents
-   * 原因：避免中途耗尽 context，保持专注和可控
-   */
-  incremental_progress: {
-    id: 'incremental_progress',
-    kind: 'check',
-    rule: 'ONE TASK PER SESSION',
-    message: '禁止一次做多个任务，每次只做一件事',
-    level: 'iron_law',
-    trigger: 'code_implementation',
-    enforcement: 'single-task-check',
-    description: `一个 session 只处理一个任务，避免 one-shotting。
-
-【禁止】
-- 一次做多个任务 → 中途耗尽 context
-- 大改动一次性完成 → 失控
-- 没有拆分的复杂任务 → 无法回滚
-
-【必须】
-- 一个 session 一个任务 → 保持专注
-- 大任务拆分为小步骤 → 分步执行
-- 每步都有 checkpoint → 可回滚
-
-【判断标准】
-- 改动涉及多个模块 → 需拆分
-- 改动超过 100 行 → 需拆分
-- 改动影响多个文件 → 需拆分
-
-【参考】
-Anthropic AI: "Effective Harnesses for Long-running Agents"
-https://www.anthropic.com/engineering/effective-harnesses-for-long-running-agents`,
-    promptInjection: '一次只处理一个任务。改动涉及多个模块、超过 100 行、或影响多个文件时，必须拆分为小步骤分步执行，每步有独立 checkpoint 可回滚。不要试图一次性完成所有改动。',
-  },
-
-  /**
-   * 禁止无需求就开始实现（吸收 no_implementation_without_requirement_review）
-   * 原因：没有需求就没有验收标准，实现方向不可控；
-   *       实现完成后必须逐条对照 AC 验证，避免偏离需求
-   */
-  no_implementation_without_requirement: {
-    id: 'no_implementation_without_requirement',
-    kind: 'check',
-    rule: 'NO IMPLEMENTATION WITHOUT REQUIREMENTS, AND REVIEW AGAINST AC AFTER IMPLEMENTATION',
-    message: '禁止无需求就开始实现，实现后必须逐条对照 AC 验证',
-    level: 'iron_law',
-    trigger: ['code_implementation', 'design_request'],
-    enforcement: 'requirement-exists',
-    description: `在开始实现之前，必须有明确的需求定义；实现完成后，必须逐条对照验收标准（AC）验证。
-
-【实现前必须执行】
-1. 确认需求来源（Spec/Issue/Roadmap/用户指令）
-2. 确认验收标准（AC）已定义
-3. 确认边界情况已明确
-
-【实现后必须执行】（吸收自 no_implementation_without_requirement_review）
-1. 回顾需求文档（Spec/Roadmap/Issue）
-2. 逐条检查实现是否符合每条 AC
-3. 确认边界情况已覆盖
-4. 输出验证清单（AC × 实现 × 状态）
-
-【禁止】
-- 没有需求就开始写代码、凭假设开始实现
-- 实现后不对比需求直接提交，只测"功能能跑"不验证 AC
-- 跳过边界情况验证，假设"差不多就行"
-
-【正确流程】
-需求确认 → AC 定义 → 实现 → 逐条对照 AC 验证`,
-    promptInjection: '开始编写代码前，必须确认：需求来源明确（Spec/Issue/Roadmap/用户指令）、验收标准(AC)已定义、边界情况已明确。不要凭假设或猜测开始实现。实现完成后，必须逐条对比原始需求文档中的验收标准(AC)，确认每条 AC 已实现且边界情况已覆盖，输出验证清单。不得仅凭"功能能跑"就认为完成。',
   },
 
   /**
    * 禁止简化测试
    * 原因：质量底线，测试困难必须解决
+   * （harness#174：checker 承载执行）
    */
   no_test_simplification: {
     id: 'no_test_simplification',
     kind: 'check',
     rule: 'NO SIMPLIFYING TESTS TO AVOID DIFFICULTY',
     message: '禁止简化测试绕过困难',
-    level: 'iron_law',
+    severity: 'error',
     trigger: 'test_creation',
     enforcement: 'full-test-coverage',
     description: `在编写测试时，不能因为遇到困难而简化或跳过测试。
@@ -121,19 +49,18 @@ https://www.anthropic.com/engineering/effective-harnesses-for-long-running-agent
 - 为了绕过 mock 困难而删除测试用例
 - 为了绕过异步问题而跳过断言
 - 降低测试覆盖率要求`,
-    promptInjection: '编写测试时遇到困难（mock、异步、环境），不得删除用例或跳过断言。正确做法：分析问题 → 查阅文档 → 尝试解决 → 仍不行则向用户说明困难请求指示。不得降低覆盖率要求。',
   },
 
   /**
    * 文档新鲜度
-   * 原因：guideline 只警告不阻断，导致文档持续腐烂。
+   * 原因：只警告不阻断会导致文档持续腐烂。
    */
   docs_freshness: {
     id: 'docs_freshness',
     kind: 'check',
     rule: 'CAPABILITIES.MD MUST BE IN SYNC WITH CODE',
     message: 'CAPABILITIES.md 与源码不同步，运行 harness sync-docs 更新后重新提交',
-    level: 'iron_law',
+    severity: 'error',
     trigger: ['file_modification', 'module_creation', 'module_modification'],
     enforcement: 'docs-sync-check',
     description: `CAPABILITIES.md 中列出的文件必须在 src/ 中实际存在。删除源文件时须从 CAPABILITIES.md 同步移除。运行 harness sync-docs 自动修复过期引用。

package/src/core/constraints/definitions.ts

@@ -1,34 +1,33 @@
 /**
  * 约束定义（薄聚合层）
  *
- * kind 二元模型（ADR-0001）：
- * - IRON_LAWS / GUIDELINES：check 层，必须带真实 checker（注册表闭环）
- * - PROMPTS：prompt 层，纯文本注入，不占检查位
+ * severity 显式模型（ADR-0029，取代 ADR-0001 三层命名）：
+ * 全部内置约束 kind='check'，severity 写死在定义上（error / warning），
+ * 纯文本提示层（prompts.ts）已随文本注入层关停整体删除。
  *
- * 工单 20：字面量定义按层拆至 ./definitions/{iron-laws,guidelines,prompts}.ts；
+ * 工单 20：字面量定义按 severity 分组放 ./definitions/{iron-laws,guidelines}.ts；
  * 本文件保持原路径做薄聚合（studio rule-scanner 按此路径解析，P0 #8）。
  */
 
 import type { Constraint, ConstraintTrigger } from '../../types/constraint';
-import { IRON_LAWS } from './definitions/iron-laws';
-import { GUIDELINES } from './definitions/guidelines';
-import { PROMPTS } from './definitions/prompts';
+import { ERROR_CONSTRAINTS } from './definitions/iron-laws';
+import { WARNING_CONSTRAINTS } from './definitions/guidelines';
 
-export { IRON_LAWS, GUIDELINES, PROMPTS };
+/** 全部内置约束（check 层全量，severity 在条目上） */
+export const CONSTRAINTS: Record<string, Constraint> = {
+  ...ERROR_CONSTRAINTS,
+  ...WARNING_CONSTRAINTS,
+};
 
 // ========================================
 // 辅助函数
 // ========================================
 
 /**
- * 获取所有约束（check + prompt 全量，带 kind）
+ * 获取所有约束（check 全量，带 kind/severity）
  */
 export function getAllConstraints(): Constraint[] {
-  return [
-    ...Object.values(IRON_LAWS),
-    ...Object.values(GUIDELINES),
-    ...Object.values(PROMPTS),
-  ];
+  return Object.values(CONSTRAINTS);
 }
 
 /**
@@ -45,5 +44,5 @@ export function findConstraintsByTrigger(trigger: ConstraintTrigger): Constraint
  * 根据 ID 获取约束
  */
 export function getConstraint(id: string): Constraint | undefined {
-  return IRON_LAWS[id] || GUIDELINES[id] || PROMPTS[id];
+  return CONSTRAINTS[id];
 }

package/src/core/constraints/index.ts

@@ -2,11 +2,9 @@
  * 约束模块入口
  */
 
-// 约束定义（kind 二元：check 层 + prompt 层）
+// 约束定义（check 全量，severity 在条目上）
 export {
-  IRON_LAWS,
-  GUIDELINES,
-  PROMPTS,
+  CONSTRAINTS,
   getAllConstraints,
   findConstraintsByTrigger,
   getConstraint,
@@ -22,28 +20,15 @@ export {
 } from './checker';
 export type { CheckConstraintsOptions, TraceRecorder } from './checker';
 
-// CLAUDE.md 约束注入段渲染（纯函数，init 注入与漂移校验共用）
-export {
-  CONSTRAINTS_START_MARKER,
-  CONSTRAINTS_END_MARKER,
-  renderConstraintsSection,
-} from './injection-renderer';
-
 // 约束检查缓存（H6/G5：TTL 缓存 + 计数采样，公开导出）
 export { CheckCache } from './check-cache';
 export type { CheckCacheConfig, CheckSamplingConfig } from './check-cache';
 
-// Agent prompt 约束段渲染（H6/G6：trigger 参数化分组渲染，role 路由留 studio）
-export {
-  renderConstraintsByTrigger,
-} from './agent-prompt-renderer';
-export type { RenderConstraintsByTriggerOptions } from './agent-prompt-renderer';
-
 // 类型导出
 export type {
   ConstraintId,
   ConstraintKind,
-  ConstraintLevel,
+  ConstraintSeverity,
   ConstraintTrigger,
   Constraint,
   ConstraintResult,
@@ -52,4 +37,4 @@ export type {
   IronLawContext,
 } from '../../types/constraint';
 
-export { ConstraintViolationError } from '../../types/constraint';
+export { ConstraintViolationError } from '../../types/constraint';