@dommaker/harness 1.9.0 → 1.11.0

package/src/knowledge/lint.ts

@@ -13,6 +13,7 @@
 import type { KnowledgeStore } from './store';
 import { ReferenceTracker } from './reference-tracker';
 import type { KnowledgeEntry, LintIssue, LintIssueType, MaturityLevel } from './types';
+import { MATURITY_LEVELS, STORAGE_LAYERS } from './types';
 
 const MAX_SOURCE_REFS = 20;
 
@@ -46,6 +47,7 @@ export class KnowledgeLinter {
     issues.push(...this.checkOutdated(entries));
     issues.push(...this.checkDuplicates(entries));
     issues.push(...this.checkContradictions(entries));
+    issues.push(...this.checkInvalidEnums(entries));
 
     // 自动修复
     let fixed = 0;
@@ -60,6 +62,7 @@ export class KnowledgeLinter {
       outdated: 0,
       duplicate: 0,
       index_inconsistent: 0,
+      invalid_enum: 0,
     };
     for (const issue of issues) {
       summary[issue.type]++;
@@ -204,6 +207,55 @@ export class KnowledgeLinter {
     return issues;
   }
 
+  /**
+   * 检查存量条目的 maturity/layer 枚举值域（E1 复盘修正 M1 收口：
+   * 写入闸只挡新写，存量脏值由本检查进 lint 报告；缺字段在存量侧算脏值）。
+   * 与 validateEntry 共用同一判定正本（invalidEnumIssues），autoFix 不动此类
+   * issue——枚举映射需人工裁定，不自动改。
+   */
+  checkInvalidEnums(entries: KnowledgeEntry[]): LintIssue[] {
+    const issues: LintIssue[] = [];
+    for (const entry of entries) {
+      issues.push(...this.invalidEnumIssues(entry, true, entry.id));
+    }
+    return issues;
+  }
+
+  /**
+   * maturity/layer 枚举判定正本。missingIsDirty=false 时字段缺省跳过
+   * （pre-ingest 调用方只传四字段的兼容面）；存量扫描传 true（缺字段即脏）。
+   */
+  private invalidEnumIssues(
+    fields: { maturity?: string; layer?: string },
+    missingIsDirty: boolean,
+    entryId?: string
+  ): LintIssue[] {
+    const issues: LintIssue[] = [];
+    if ((missingIsDirty || fields.maturity !== undefined) && !(MATURITY_LEVELS as readonly string[]).includes(fields.maturity as string)) {
+      issues.push({
+        type: 'invalid_enum',
+        entryId,
+        severity: 'high',
+        description: fields.maturity === undefined
+          ? `maturity is missing (declared values: ${MATURITY_LEVELS.join(' | ')}).`
+          : `maturity "${fields.maturity}" is not a declared value (${MATURITY_LEVELS.join(' | ')}).`,
+        suggestion: 'Map to a declared maturity (e.g. pending → draft) before writing; the store write gate rejects undeclared values.',
+      });
+    }
+    if ((missingIsDirty || fields.layer !== undefined) && !(STORAGE_LAYERS as readonly string[]).includes(fields.layer as string)) {
+      issues.push({
+        type: 'invalid_enum',
+        entryId,
+        severity: 'high',
+        description: fields.layer === undefined
+          ? `layer is missing (declared values: ${STORAGE_LAYERS.join(' | ')}).`
+          : `layer "${fields.layer}" is not a declared value (${STORAGE_LAYERS.join(' | ')}).`,
+        suggestion: 'Map to a declared layer or drop the field; the store write gate rejects undeclared values.',
+      });
+    }
+    return issues;
+  }
+
   /**
    * 检查矛盾（同主题相反结论）
    *
@@ -260,10 +312,17 @@ export class KnowledgeLinter {
    * - Title too vague (common stop words only) → flag
    * - Contradicts a proven entry with same tags → reject
    * - Near-duplicate of existing entry (title similarity > 80%) → flag merge
+   * - maturity/layer 未声明枚举值 → reject（E1 复盘修正 M1；字段缺省则跳过，
+   *   兼容只传 title/content/tags/type 的 pre-ingest 调用方；存量报告由调用方
+   *   把条目字段显式传入触发）
    */
-  validateEntry(entry: { title: string; content: string; tags: string[]; type: string }): LintIssue[] {
+  validateEntry(entry: { title: string; content: string; tags: string[]; type: string; maturity?: string; layer?: string }): LintIssue[] {
     const issues: LintIssue[] = [];
 
+    // Undeclared maturity/layer enum values（判定正本 = invalidEnumIssues；字段缺省跳过，
+    // 兼容只传四字段的 pre-ingest 调用方；存量扫描走 run() → checkInvalidEnums）
+    issues.push(...this.invalidEnumIssues(entry, false));
+
     // Content too short
     if ((entry.content || '').length < 20) {
       issues.push({

package/src/knowledge/store.ts

@@ -18,6 +18,7 @@ import type {
   SnapshotSurvival,
   StoreUpdate,
 } from './types';
+import { MATURITY_LEVELS, STORAGE_LAYERS } from './types';
 
 const DEFAULT_DIR = '.harness/knowledge';
 const INDEX_FILE = 'index.json';
@@ -109,12 +110,36 @@ export class FileKnowledgeStore implements KnowledgeStore {
   }
 
   save(entry: KnowledgeEntry): void {
+    this.assertEnumFields(entry);
     this.writeEntryFile(entry);
     this.updateIndexEntry(entry);
   }
 
+  /**
+   * 写入闸（E1 复盘修正 M1）：maturity/layer 是声明枚举（值域正本在 types.ts），
+   * 未声明值拒写报错，不静默降级。save/saveAll/applyAll 三条落盘路径共用；
+   * update 经 save 继承同一闸。存量脏条目（绕过本 store 直写文件的）在被
+   * 任一写入路径触及时抛错——先修脏值再写。
+   */
+  private assertEnumFields(entry: KnowledgeEntry): void {
+    if (!MATURITY_LEVELS.includes(entry.maturity)) {
+      throw new Error(
+        `[harness] 知识条目 ${entry.id} 的 maturity 值 "${entry.maturity}" 未声明` +
+        `（允许: ${MATURITY_LEVELS.join(' | ')}），拒写`
+      );
+    }
+    if (!STORAGE_LAYERS.includes(entry.layer)) {
+      throw new Error(
+        `[harness] 知识条目 ${entry.id} 的 layer 值 "${entry.layer}" 未声明` +
+        `（允许: ${STORAGE_LAYERS.join(' | ')}），拒写`
+      );
+    }
+  }
+
   saveAll(entries: KnowledgeEntry[]): void {
     if (entries.length === 0) return;
+    // 整批预校验（写入闸）：任一脏值全批拒写，不落半个批次
+    for (const entry of entries) this.assertEnumFields(entry);
     const index = this.readIndex();
     const position = new Map(index.map((e, i) => [e.id, i]));
     for (const entry of entries) {
@@ -133,25 +158,37 @@ export class FileKnowledgeStore implements KnowledgeStore {
 
   applyAll(updates: StoreUpdate[]): void {
     if (updates.length === 0) return;
+    // 先合并再整批预校验（写入闸）：任一合并结果脏值全批拒写，不落半个批次。
+    // 批内同 id 多条按序累积合并（后者基于前者的合并结果，与逐条 update 同语义）。
+    const merged: KnowledgeEntry[] = [];
+    const pending = new Map<string, number>(); // id → merged 下标
+    for (const { id, partial } of updates) {
+      const idx = pending.get(id);
+      const base = idx !== undefined ? merged[idx] : this.get(id);
+      if (!base) continue;
+      const next: KnowledgeEntry = { ...base, ...partial, id };
+      if (idx !== undefined) {
+        merged[idx] = next;
+      } else {
+        pending.set(id, merged.length);
+        merged.push(next);
+      }
+    }
+    if (merged.length === 0) return;
+    for (const entry of merged) this.assertEnumFields(entry);
     const index = this.readIndex();
     const position = new Map(index.map((e, i) => [e.id, i]));
-    let applied = 0;
-    for (const { id, partial } of updates) {
-      const existing = this.get(id);
-      if (!existing) continue;
-      const updated: KnowledgeEntry = { ...existing, ...partial, id };
-      this.writeEntryFile(updated);
-      const indexEntry = this.toIndexEntry(updated);
-      const idx = position.get(id);
+    for (const entry of merged) {
+      this.writeEntryFile(entry);
+      const indexEntry = this.toIndexEntry(entry);
+      const idx = position.get(entry.id);
       if (idx !== undefined) {
         index[idx] = indexEntry;
       } else {
-        position.set(id, index.length);
+        position.set(entry.id, index.length);
         index.push(indexEntry);
       }
-      applied++;
     }
-    if (applied === 0) return;
     this.writeIndex(index);
   }
 

package/src/knowledge/types.ts

@@ -15,6 +15,12 @@ export type MaturityLevel = 'draft' | 'verified' | 'proven' | 'archived' | 'acti
 
 export type StorageLayer = 'personal' | 'team' | 'tech' | 'domain' | 'project' | 'system';
 
+/** MaturityLevel 的运行时值域正本（store 写入闸与 lint 枚举校验共用） */
+export const MATURITY_LEVELS: readonly MaturityLevel[] = ['draft', 'verified', 'proven', 'archived', 'active', 'deprecated'];
+
+/** StorageLayer 的运行时值域正本（store 写入闸与 lint 枚举校验共用） */
+export const STORAGE_LAYERS: readonly StorageLayer[] = ['personal', 'team', 'tech', 'domain', 'project', 'system'];
+
 /** How agent consumes this knowledge — drives injection strategy and lifecycle */
 export type ConsumptionMode = 'rule' | 'reference' | 'context' | 'signal';
 
@@ -101,7 +107,7 @@ export interface QueryFilter {
 
 // ── Lint ────────────────────────────────────────────────────
 
-export type LintIssueType = 'orphan' | 'contradiction' | 'outdated' | 'duplicate' | 'index_inconsistent';
+export type LintIssueType = 'orphan' | 'contradiction' | 'outdated' | 'duplicate' | 'index_inconsistent' | 'invalid_enum';
 
 export interface LintIssue {
   type: LintIssueType;

package/src/monitoring/CONTEXT.md

@@ -22,7 +22,7 @@
 - 零 Token 成本：不调用 LLM
 - **凡以 `skip` 策略读 JSONL，坏行计数必须到达该消费面的用户可见输出，或在该调用点显式记名豁免并写明理由（harness#100）**——静默吞掉「数据不全」不是一种可选项。承载方式纯增量：新报告入口带计数，旧入口退化为丢计数的薄包装（#82 裁决 4 的兼容约束继续成立），不另立第二份计数概念、不把 `JsonlReadResult` 提升进包根（ADR-0003）
   - 机器可检：`src/utils/__tests__/jsonl-skip-disposition.test.ts` 三道闸——每个 `readJsonl` 调用点必须判得出策略（判不出即形状逃逸，失败）、skip 读点集合冻结（新增未声明即失败，站点消失却不删条目也失败）、每个读点上方 6 行内有 `计数去向：` 声明且邻居声明不得顶替
-  - 三类去向（逐条对得上代码）：**报告体内部的降级位**随报告体走 stdout——`constraints report` 的坏行提示紧挨既有的 `traceFileExists` 说明；**不挤动既有输出的诊断告知**走 stderr——`status`（`logError`，stdout 的 `记录数` 口径与字节不变）、`failure list`（#96 定稿的 `console.error`）、`constraints retire`（交互与 `--yes` 直达两条路径各自告知）；**结构化面用字段**——`constraints report --json` 的 `skippedLines`、`--export` markdown 的警示行、studio 端点响应体（配套票 studio#451）
+  - 三类去向（逐条对得上代码）：**报告体内部的降级位**随报告体走 stdout——`constraints report` 的坏行提示紧挨既有的 `traceFileExists` 说明；**不挤动既有输出的诊断告知**走 stderr——`status`（`logError`，stdout 的 `记录数` 口径与字节不变）、`failure list`（#96 定稿的 `console.error`）、`constraints retire`（交互与 `--yes` 直达两条路径各自告知）；**结构化面用字段**——`constraints report --json-output` 的 `skippedLines`、`--export` markdown 的警示行、studio 端点响应体（配套票 studio#451）
 
 ## 注意事项
 - 追踪数据供 `harness constraints report` 统计与退役候选诊断消费（观测用途，不做自动降级）

package/src/monitoring/__tests__/trace-file-anchoring.test.ts

@@ -14,7 +14,7 @@ import { createProjectFixture } from '../../test-setup/project-fixture';
 
 const trace = (constraintId: string): ExecutionTrace => ({
   constraintId,
-  level: 'guideline',
+  severity: 'warning',
   timestamp: 1700000000000,
   result: 'pass',
 });

package/src/monitoring/__tests__/traces.test.ts

@@ -42,7 +42,7 @@ describe('TraceCollector', () => {
       const disabledCollector = new TraceCollector({ enabled: false });
       disabledCollector.record({
         constraintId: 'test',
-        level: 'iron_law',
+        severity: 'error',
         timestamp: Date.now(),
         result: 'pass',
       });
@@ -54,7 +54,7 @@ describe('TraceCollector', () => {
     it('should append trace to file', () => {
       collector.record({
         constraintId: 'test',
-        level: 'iron_law',
+        severity: 'error',
         timestamp: Date.now(),
         result: 'pass',
       });
@@ -64,7 +64,7 @@ describe('TraceCollector', () => {
 
   describe('recordPass()', () => {
     it('should record pass trace', () => {
-      collector.recordPass('test_constraint', 'iron_law');
+      collector.recordPass('test_constraint', 'error');
       const call = mockFs.appendFileSync.mock.calls[0];
       const content = JSON.parse(call[1] as string);
       expect(content.result).toBe('pass');
@@ -73,7 +73,7 @@ describe('TraceCollector', () => {
 
   describe('recordFail()', () => {
     it('should record fail trace', () => {
-      collector.recordFail('test_constraint', 'iron_law');
+      collector.recordFail('test_constraint', 'error');
       const call = mockFs.appendFileSync.mock.calls[0];
       const content = JSON.parse(call[1] as string);
       expect(content.result).toBe('fail');
@@ -91,8 +91,8 @@ describe('TraceCollector', () => {
 
     it('should parse all traces from file', () => {
       mockFs.readFileSync.mockReturnValueOnce(
-        '{"constraintId":"a","level":"iron_law","timestamp":100,"result":"pass"}\n' +
-        '{"constraintId":"b","level":"guideline","timestamp":200,"result":"fail"}\n'
+        '{"constraintId":"a","severity":"error","timestamp":100,"result":"pass"}\n' +
+        '{"constraintId":"b","severity":"warning","timestamp":200,"result":"fail"}\n'
       );
       const traces = collector.read();
       expect(traces.length).toBe(2);
@@ -100,19 +100,19 @@ describe('TraceCollector', () => {
 
     it('should apply constraintId filter', () => {
       mockFs.readFileSync.mockReturnValueOnce(
-        '{"constraintId":"a","level":"iron_law","timestamp":100,"result":"pass"}\n' +
-        '{"constraintId":"b","level":"guideline","timestamp":200,"result":"fail"}\n'
+        '{"constraintId":"a","severity":"error","timestamp":100,"result":"pass"}\n' +
+        '{"constraintId":"b","severity":"warning","timestamp":200,"result":"fail"}\n'
       );
       const traces = collector.read({ constraintId: 'a' });
       expect(traces.length).toBe(1);
     });
 
-    it('should apply level filter', () => {
+    it('should apply severity filter', () => {
       mockFs.readFileSync.mockReturnValueOnce(
-        '{"constraintId":"a","level":"iron_law","timestamp":100,"result":"pass"}\n' +
-        '{"constraintId":"b","level":"guideline","timestamp":200,"result":"fail"}\n'
+        '{"constraintId":"a","severity":"error","timestamp":100,"result":"pass"}\n' +
+        '{"constraintId":"b","severity":"warning","timestamp":200,"result":"fail"}\n'
       );
-      const traces = collector.read({ level: 'guideline' });
+      const traces = collector.read({ severity: 'warning' });
       expect(traces.length).toBe(1);
     });
   });
@@ -121,7 +121,7 @@ describe('TraceCollector', () => {
     it('should read recent traces', () => {
       const now = Date.now();
       mockFs.readFileSync.mockReturnValueOnce(
-        `{"constraintId":"new","level":"iron_law","timestamp":${now - 1000},"result":"pass"}\n`
+        `{"constraintId":"new","severity":"error","timestamp":${now - 1000},"result":"pass"}\n`
       );
       const traces = collector.readRecent(1);
       expect(traces.length).toBe(1);
@@ -131,7 +131,7 @@ describe('TraceCollector', () => {
   describe('readByConstraint()', () => {
     it('should read by constraint', () => {
       mockFs.readFileSync.mockReturnValueOnce(
-        '{"constraintId":"a","level":"iron_law","timestamp":100,"result":"pass"}\n'
+        '{"constraintId":"a","severity":"error","timestamp":100,"result":"pass"}\n'
       );
       const traces = collector.readByConstraint('a');
       expect(traces.length).toBe(1);
@@ -143,7 +143,7 @@ describe('TraceCollector', () => {
       mockFs.statSync.mockReturnValueOnce({ size: 11 * 1024 * 1024 } as any);
       collector.record({
         constraintId: 'test',
-        level: 'iron_law',
+        severity: 'error',
         timestamp: Date.now(),
         result: 'pass',
       });
@@ -155,7 +155,7 @@ describe('TraceCollector', () => {
     it('should return stats', () => {
       mockFs.existsSync.mockReturnValueOnce(true);
       mockFs.readFileSync.mockReturnValueOnce(
-        '{"constraintId":"a","level":"iron_law","timestamp":100,"result":"pass"}\n'
+        '{"constraintId":"a","severity":"error","timestamp":100,"result":"pass"}\n'
       );
       mockFs.statSync.mockReturnValueOnce({ size: 1024 } as any);
       const stats = collector.getStats();
@@ -166,9 +166,9 @@ describe('TraceCollector', () => {
   describe('坏行容错（harness#82 裁决 4：原「抛」改 skip，签名与返回类型不变）', () => {
     it('read() 单行损坏只丢该行，合法 trace 照常返回', () => {
       mockFs.readFileSync.mockReturnValueOnce(
-        '{"constraintId":"a","level":"iron_law","timestamp":100,"result":"pass"}\n' +
+        '{"constraintId":"a","severity":"error","timestamp":100,"result":"pass"}\n' +
         '{"constraintId":"b","broken"\n' +
-        '{"constraintId":"c","level":"guideline","timestamp":200,"result":"fail"}\n'
+        '{"constraintId":"c","severity":"warning","timestamp":200,"result":"fail"}\n'
       );
       const traces = collector.read();
       expect(traces.map(t => t.constraintId)).toEqual(['a', 'c']);
@@ -176,9 +176,9 @@ describe('TraceCollector', () => {
 
     it('read() 坏行不阻断过滤', () => {
       mockFs.readFileSync.mockReturnValueOnce(
-        '{"constraintId":"a","level":"iron_law","timestamp":100,"result":"pass"}\n' +
+        '{"constraintId":"a","severity":"error","timestamp":100,"result":"pass"}\n' +
         'not-json\n' +
-        '{"constraintId":"a","level":"iron_law","timestamp":200,"result":"fail"}\n'
+        '{"constraintId":"a","severity":"error","timestamp":200,"result":"fail"}\n'
       );
       const traces = collector.read({ constraintId: 'a' });
       expect(traces).toHaveLength(2);
@@ -187,8 +187,8 @@ describe('TraceCollector', () => {
     it('getStats() 首末行坏时不抛：totalLines 保持原始行数，时间戳取合法记录', () => {
       mockFs.readFileSync.mockReturnValueOnce(
         'not-json\n' +
-        '{"constraintId":"a","level":"iron_law","timestamp":100,"result":"pass"}\n' +
-        '{"constraintId":"b","level":"guideline","timestamp":200,"result":"fail"}\n' +
+        '{"constraintId":"a","severity":"error","timestamp":100,"result":"pass"}\n' +
+        '{"constraintId":"b","severity":"warning","timestamp":200,"result":"fail"}\n' +
         'also-bad\n'
       );
       mockFs.statSync.mockReturnValueOnce({ size: 2048 } as any);

package/src/monitoring/trace-analyzer.ts

@@ -94,8 +94,8 @@ export function summarizeTraces(traces: ExecutionTrace[]): TraceSummary[] {
   const summaries: TraceSummary[] = [];
 
   for (const [constraintId, group] of grouped) {
-    // 提取层级（从第一条 trace）
-    const level = group[0].level;
+    // 提取严重性（从第一条 trace）
+    const severity = group[0].severity;
 
     // 计算时间范围
     const timeRange = timeRangeOf(group.map(t => t.timestamp));
@@ -120,7 +120,7 @@ export function summarizeTraces(traces: ExecutionTrace[]): TraceSummary[] {
 
     summaries.push({
       constraintId,
-      level,
+      severity,
       timeRange,
       totalChecks,
       passCount,
@@ -155,7 +155,7 @@ export function detectTraceAnomalies(
       anomalies.push({
         type: 'rising_fail_rate',
         constraintId: summary.constraintId,
-        level: summary.level,
+        severity: summary.severity,
         message: `约束 ${summary.constraintId} 失败率 ${Math.round(summary.failRate * 100)}% 且趋势上升`,
         data: {
           currentRate: summary.failRate,
@@ -172,7 +172,7 @@ export function detectTraceAnomalies(
       anomalies.push({
         type: 'low_pass_rate',
         constraintId: summary.constraintId,
-        level: summary.level,
+        severity: summary.severity,
         message: `约束 ${summary.constraintId} 通过率 ${Math.round(summary.passRate * 100)}%，低于 30%`,
         data: {
           currentRate: summary.passRate,
@@ -358,14 +358,13 @@ export class TraceAnalyzer {
     lines.push('');
 
     for (const summary of summaries) {
-      const levelEmoji = {
-        iron_law: '🔴',
-        guideline: '🟡',
-        prompt: '🟣',
-        tip: '🔵',
-      }[summary.level];
-
-      lines.push(`${levelEmoji} **${summary.constraintId}**`);
+      const severityEmoji = {
+        error: '🔴',
+        warning: '🟡',
+        info: '🔵',
+      }[summary.severity];
+
+      lines.push(`${severityEmoji} **${summary.constraintId}**`);
       lines.push(`  - Checks: ${summary.totalChecks}`);
       lines.push(`  - Pass: ${Math.round(summary.passRate * 100)}%`);
       lines.push(`  - Fail: ${Math.round(summary.failRate * 100)}%`);

package/src/monitoring/traces.ts

@@ -38,8 +38,8 @@ const DEFAULT_CONFIG: TraceCollectorConfig = {
  * ```typescript
  * const collector = new TraceCollector({ projectPath: '/path/to/project' });
  * collector.record({
- *   constraintId: 'no_fix_without_root_cause',
- *   level: 'iron_law',
+ *   constraintId: 'no_completion_without_verification',
+ *   severity: 'error',
  *   timestamp: Date.now(),
  *   result: 'fail',
  * });
@@ -92,12 +92,12 @@ export class TraceCollector {
    */
   recordPass(
     constraintId: string,
-    level: 'iron_law' | 'guideline',
+    severity: 'error' | 'warning',
     options?: Partial<ExecutionTrace>
   ): void {
     this.record({
       constraintId,
-      level,
+      severity,
       timestamp: Date.now(),
       result: 'pass',
       ...options,
@@ -109,12 +109,12 @@ export class TraceCollector {
    */
   recordFail(
     constraintId: string,
-    level: 'iron_law' | 'guideline',
+    severity: 'error' | 'warning',
     options?: Partial<ExecutionTrace>
   ): void {
     this.record({
       constraintId,
-      level,
+      severity,
       timestamp: Date.now(),
       result: 'fail',
       ...options,
@@ -184,8 +184,8 @@ export class TraceCollector {
         return false;
       }
 
-      // 层级
-      if (filter.level && trace.level !== filter.level) {
+      // 严重性
+      if (filter.severity && trace.severity !== filter.severity) {
         return false;
       }
 

package/src/presets/__tests__/standard.test.ts

@@ -1,7 +1,7 @@
 /**
  * presets 纯数据测试
  *
- * 预设只保留数据（ADR-0001：筛选逻辑统一在 mergeConstraints），
+ * 预设只保留数据（ADR-0029：键按 severity 命名；筛选逻辑统一在 mergeConstraints），
  * 这里锁定数据形状与 strict→standard 别名语义。
  */
 
@@ -16,43 +16,39 @@ describe('预设数据', () => {
   describe('STRICT_PRESET', () => {
     it('应该启用所有约束', () => {
       expect(STRICT_PRESET.name).toBe('strict');
-      expect(STRICT_PRESET.ironLaws).toBeNull();
-      expect(STRICT_PRESET.guidelines).toBeNull();
-      expect(STRICT_PRESET.prompts).toBeNull();
+      expect(STRICT_PRESET.errors).toBeNull();
+      expect(STRICT_PRESET.warnings).toBeNull();
     });
   });
 
   describe('STANDARD_PRESET', () => {
     it('应该启用所有约束', () => {
       expect(STANDARD_PRESET.name).toBe('standard');
-      expect(STANDARD_PRESET.ironLaws).toBeNull();
-      expect(STANDARD_PRESET.guidelines).toBeNull();
-      expect(STANDARD_PRESET.prompts).toBeNull();
+      expect(STANDARD_PRESET.errors).toBeNull();
+      expect(STANDARD_PRESET.warnings).toBeNull();
     });
   });
 
   describe('RELAXED_PRESET', () => {
     it('应该只启用核心约束', () => {
       expect(RELAXED_PRESET.name).toBe('relaxed');
-      expect(RELAXED_PRESET.ironLaws).toHaveLength(3);
-      expect(RELAXED_PRESET.guidelines).toHaveLength(2);
-      expect(RELAXED_PRESET.prompts).toEqual([]);
+      expect(RELAXED_PRESET.errors).toHaveLength(1);
+      expect(RELAXED_PRESET.warnings).toHaveLength(1);
     });
 
     it('应该包含 no_completion_without_verification', () => {
-      expect(RELAXED_PRESET.ironLaws).toContain('no_completion_without_verification');
+      expect(RELAXED_PRESET.errors).toContain('no_completion_without_verification');
     });
 
-    it('应该包含 no_bypass_checkpoint', () => {
-      expect(RELAXED_PRESET.guidelines).toContain('no_bypass_checkpoint');
+    it('应该包含 no_hardcoded_credentials', () => {
+      expect(RELAXED_PRESET.warnings).toContain('no_hardcoded_credentials');
     });
   });
 
   describe('PRESETS_BY_NAME', () => {
     it('strict 是 standard 的别名（同为全部启用）', () => {
-      expect(PRESETS_BY_NAME['strict']?.ironLaws).toBeNull();
-      expect(PRESETS_BY_NAME['strict']?.guidelines).toBeNull();
-      expect(PRESETS_BY_NAME['strict']?.prompts).toBeNull();
+      expect(PRESETS_BY_NAME['strict']?.errors).toBeNull();
+      expect(PRESETS_BY_NAME['strict']?.warnings).toBeNull();
     });
 
     it('三个预设名均可解析', () => {

package/src/presets/standard.ts

@@ -2,10 +2,10 @@
  * 约束预设（纯数据）
  *
  * 预设定义哪些内置约束被启用。筛选与合并逻辑统一在
- * core/project-config-loader.ts 的 mergeConstraints（ADR-0001 生效集链路），
+ * core/project-config-loader.ts 的 mergeConstraints（生效集链路），
  * 本文件只保留预设数据，不再含函数。
  *
- * ADR-0001：kind 二元（check + prompt 纯注入层）。
+ * ADR-0029：桶按 severity 命名（errors / warnings），取代三层命名。
  */
 
 /**
@@ -15,14 +15,11 @@ export interface PresetConfig {
   /** 预设名称 */
   name: string;
 
-  /** 启用的铁律 ID 列表（null 表示全部启用） */
-  ironLaws: string[] | null;
+  /** 启用的 severity='error' 约束 ID 列表（null 表示全部启用） */
+  errors: string[] | null;
 
-  /** 启用的指导原则 ID 列表（null 表示全部启用） */
-  guidelines: string[] | null;
-
-  /** 启用的提示 ID 列表（null 表示全部启用） */
-  prompts: string[] | null;
+  /** 启用的 severity='warning' 约束 ID 列表（null 表示全部启用） */
+  warnings: string[] | null;
 }
 
 /**
@@ -32,40 +29,34 @@ export interface PresetConfig {
  */
 export const STRICT_PRESET: PresetConfig = {
   name: 'strict',
-  ironLaws: null,    // 全部启用
-  guidelines: null,  // 全部启用
-  prompts: null,     // 全部启用
+  errors: null,    // 全部启用
+  warnings: null,  // 全部启用
 };
 
 /**
  * 标准预设
  *
- * 铁律全部启用，指导原则和提示选择性启用
+ * 全部约束启用
  */
 export const STANDARD_PRESET: PresetConfig = {
   name: 'standard',
-  ironLaws: null,    // 全部启用
-  guidelines: null,  // 全部启用
-  prompts: null,     // 全部启用
+  errors: null,    // 全部启用
+  warnings: null,  // 全部启用
 };
 
 /**
  * 宽松预设
  *
- * 仅启用核心铁律，禁用提示
+ * 仅启用核心 error 级与凭证扫描
  */
 export const RELAXED_PRESET: PresetConfig = {
   name: 'relaxed',
-  ironLaws: [
+  errors: [
     'no_completion_without_verification',
-    'incremental_progress',
-    'no_implementation_without_requirement',
   ],
-  guidelines: [
-    'no_bypass_checkpoint',
+  warnings: [
     'no_hardcoded_credentials',
   ],
-  prompts: [],  // 禁用提示
 };
 
 /**

package/src/types/__tests__/types.test.ts

@@ -17,7 +17,7 @@ describe('ConstraintViolationError', () => {
   it('应该使用 result.message 作为错误消息', () => {
     const error = new ConstraintViolationError({
       id: 'test',
-      level: 'iron_law',
+      severity: 'error',
       satisfied: false,
       message: '测试违规消息',
       checkedAt: new Date(),
@@ -31,7 +31,7 @@ describe('ConstraintViolationError', () => {
   it('应该在 message 为空时使用默认消息', () => {
     const error = new ConstraintViolationError({
       id: 'test',
-      level: 'iron_law',
+      severity: 'error',
       satisfied: false,
       checkedAt: new Date(),
     });
@@ -42,7 +42,7 @@ describe('ConstraintViolationError', () => {
   it('应该在 message 为空字符串时使用默认消息', () => {
     const error = new ConstraintViolationError({
       id: 'test',
-      level: 'iron_law',
+      severity: 'error',
       satisfied: false,
       message: '',
       checkedAt: new Date(),