@dommaker/harness 1.10.0 → 1.12.0

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

@@ -1,9 +1,10 @@
 /**
  * 项目配置加载器
  *
- * 解读 `.harness/config.yml` 与自定义约束文件、合并内置与项目自定义约束。
- * 本模块不碰文件系统：两份配置的读取口径 = 运行级观察面（`constraints/run-env.ts`，
- * ADR-0023 决策 2），一次运行内各至多读一次。
+ * 解读 `.harness/config.yml`、合并内置与应用层（`.harness/constraints.yml`，ADR-0033）约束。
+ * 本模块不碰文件系统：config.yml 的读取口径 = 运行级观察面（`constraints/run-env.ts`，
+ * ADR-0023 决策 2），一次运行内至多读一次；constraints.yml 的读取收在
+ * `app-constraints-loader.ts`（memo 口径与 rawConfig 同形）。
  */
 
 import type { Constraint } from '../types/constraint';
@@ -16,6 +17,7 @@ import type {
 import { CONSTRAINTS } from './constraints/definitions';
 import { PRESETS_BY_NAME, STANDARD_PRESET } from '../presets';
 import { filterEnabledEntries } from './effective-set';
+import { loadAppConstraints } from './app-constraints-loader';
 import { resolveRunEnv, type RunEnv, type RunTarget } from './constraints/run-env';
 
 /**
@@ -131,12 +133,14 @@ export class ProjectConfigLoader {
   }
 
   /**
-   * 合并内置约束（生效集完整链路，ADR-0029）
+   * 合并内置约束（生效集完整链路，ADR-0029 + ADR-0033）
    *
-   * 合并顺序：内置 → preset 裁剪 → config.yml `constraints.<id>.enabled:false` 删除。
+   * 合并顺序：内置 → preset 裁剪 → 并入应用层（`.harness/constraints.yml`）→
+   * config.yml `constraints.<id>.enabled:false` 删除（对内置与应用层同口径生效，
+   * retired 墓碑随 enabled:false 天然生效）。
    *
    * config.yml 中未知约束 id（如已移除约束的禁用残留）静默忽略，
-   * 记录在结果 unknownIds 中供诊断。
+   * 记录在结果 unknownIds 中供诊断；应用层 id 是已知 id，不进 unknownIds。
    *
    * @param options.preset 覆盖 config.yml 的 preset（CLI --preset 用）；
    *   未知预设名回落 standard + stderr 警告
@@ -184,9 +188,16 @@ export class ProjectConfigLoader {
       unknownIds,
     };
 
-    // 1. 处理启用/禁用配置（未知 id 静默忽略，记录供诊断）
+    // 1. 并入应用层约束（.harness/constraints.yml，ADR-0033）：先进桶再走 config.yml
+    //    筛选，enabled:false/retired 墓碑对应用层 id 才能同口径生效
+    const appConstraints = loadAppConstraints(this.env);
+    for (const c of appConstraints) {
+      result.constraints[c.id] = c;
+    }
+
+    // 2. 处理启用/禁用配置（未知 id 静默忽略，记录供诊断；应用层 id 属已知 id）
     if (this.config.constraints) {
-      const knownIds = new Set(Object.keys(CONSTRAINTS));
+      const knownIds = new Set([...Object.keys(CONSTRAINTS), ...appConstraints.map(c => c.id)]);
       const filtered = filterEnabledEntries(knownIds, this.config.constraints);
       unknownIds.push(...filtered.unknownIds);
       for (const constraintId of filtered.disabledIds) {

package/src/gates/__tests__/command.test.ts

@@ -196,4 +196,58 @@ describe('CommandGate', () => {
       expect(r.passed).toBe(true);
     });
   });
+
+  describe('git destructive rules（ADR-0031，票08 P1-6）', () => {
+    let gate: CommandGate;
+    beforeEach(() => { gate = new CommandGate(); });
+
+    it('should block git push --force', async () => {
+      const r = await gate.check('git push --force origin master');
+      expect(r.passed).toBe(false);
+      expect(r.details?.blocked.some((b: any) => b.id === 'git-push-force')).toBe(true);
+    });
+
+    it('should block git push -f and --force-with-lease', async () => {
+      expect((await gate.check('git push -f origin master')).passed).toBe(false);
+      expect((await gate.check('git push --force-with-lease')).passed).toBe(false);
+    });
+
+    it('should block git clean -f / -fd / -fdx', async () => {
+      for (const cmd of ['git clean -f', 'git clean -fd', 'git clean -fdx']) {
+        const r = await gate.check(cmd);
+        expect(r.passed).toBe(false);
+        expect(r.details?.blocked.some((b: any) => b.id === 'git-clean-force')).toBe(true);
+      }
+    });
+
+    it('should warn on git reset --hard / checkout -- / branch -D / filter-branch / reflog expire', async () => {
+      const cases: Array<[string, string]> = [
+        ['git reset --hard HEAD~3', 'git-reset-hard'],
+        ['git checkout -- src/foo.ts', 'git-checkout-discard'],
+        ['git branch -D feature-x', 'git-branch-force-delete'],
+        ['git filter-branch --tree-filter x', 'git-history-rewrite'],
+        ['git reflog expire --expire=now --all', 'git-reflog-expire'],
+      ];
+      for (const [cmd, id] of cases) {
+        const r = await gate.check(cmd);
+        expect(r.details?.warnings.some((w: any) => w.id === id)).toBe(true);
+      }
+    });
+
+    it('should allow safe git commands', async () => {
+      for (const cmd of [
+        'git status',
+        'git push origin master',
+        'git reset --soft HEAD~1',
+        'git clean -n',
+        'git checkout -b feature',
+        'git branch -d feature-x',
+        'git commit -m "msg"',
+      ]) {
+        const r = await gate.check(cmd);
+        expect(r.passed).toBe(true);
+        expect(r.details?.warnings ?? []).toEqual([]);
+      }
+    });
+  });
 });

package/src/gates/command.ts

@@ -192,6 +192,57 @@ export const DEFAULT_COMMAND_BLACKLIST: CommandBlacklistRule[] = [
     message: '卸载 Python 包需要确认',
     category: 'package',
   },
+
+  // ========== git 破坏类（ADR-0031，wayfinder 票08 P1-6：只补不可逆损失面） ==========
+  {
+    id: 'git-push-force',
+    pattern: /\bgit\s+push\b[^|;&]*(--force\b|-f\b)/i,
+    level: 'block',
+    message: '禁止强推远程（覆盖共享历史不可逆）',
+    category: 'git',
+  },
+  {
+    id: 'git-clean-force',
+    pattern: /\bgit\s+clean\b[^|;&]*-[a-z]*f/i,
+    level: 'block',
+    message: '禁止 git clean -f（未跟踪文件删除不可恢复）',
+    category: 'git',
+  },
+  {
+    id: 'git-reset-hard',
+    pattern: /\bgit\s+reset\s+--hard\b/i,
+    level: 'warn',
+    message: 'git reset --hard 丢弃未提交改动，需要确认',
+    category: 'git',
+  },
+  {
+    id: 'git-checkout-discard',
+    pattern: /\bgit\s+checkout\s+--\s/i,
+    level: 'warn',
+    message: 'git checkout -- 丢弃工作区改动，需要确认',
+    category: 'git',
+  },
+  {
+    id: 'git-branch-force-delete',
+    pattern: /\bgit\s+branch\s+-D\b/,
+    level: 'warn',
+    message: 'git branch -D 强制删分支（未合并提交可能丢失），需要确认',
+    category: 'git',
+  },
+  {
+    id: 'git-history-rewrite',
+    pattern: /\bgit\s+(filter-branch|filter-repo)\b/i,
+    level: 'warn',
+    message: '历史重写操作不可逆，需要确认',
+    category: 'git',
+  },
+  {
+    id: 'git-reflog-expire',
+    pattern: /\bgit\s+reflog\s+expire\b/i,
+    level: 'warn',
+    message: 'reflog expire 拆除恢复网，需要确认',
+    category: 'git',
+  },
 ];
 
 /**

package/src/index.ts

@@ -54,6 +54,26 @@ export {
 } from './core/effective-constraints';
 export type { EffectiveConfigLint } from './core/effective-constraints';
 
+// ========================================
+// 约束使用报告（退役候选诊断数据层，studio#602 E1 (a) 链路消费）
+// ========================================
+export {
+  buildConstraintsUsageReport,
+  diagnoseRetireCandidates,
+  collectUsageByConstraint,
+  readProjectTraces,
+  readProjectTracesReport,
+  CANDIDATE_KIND_LABEL,
+  DEFAULT_DIAGNOSE_THRESHOLDS,
+} from './core/constraints/usage-report';
+export type {
+  ConstraintUsageStats,
+  RetireCandidate,
+  RetireCandidateKind,
+  DiagnoseThresholds,
+  ConstraintsUsageReport,
+} from './core/constraints/usage-report';
+
 // ========================================
 // 约束检查引擎（便捷 API；options 统一签名，ADR-0003）
 // ========================================

package/src/knowledge/CONTEXT.md

@@ -17,9 +17,9 @@
 - 所有模式支持 `decayAt` 硬过期
 
 ## 核心导出
-- `KnowledgeStore`（类型面）/ `FileKnowledgeStore`（`store.ts`，barrel 与包根交出的**值**符号——store 的文件系统实现，构造收 `{ baseDir }`；仓内构造点两处：`cli/commands/knowledge-view.ts` 的 `openKnowledgeStore()`（knowledge 各子命令的取数口）与 `cli/commands/constraints-retire.ts` 的退役沉淀写入）— 知识条目 CRUD + 结构化存储；`saveAll()` 全量批量写入（循环内只更新内存索引、结束一次 writeIndex，harness#107）、`applyAll()` 按 id 部分更新的批量出口（`update(id, partial)` 的批量形，语义含未知 id 逐条跳过与空批零读写，harness#134）、`getConsumptionStats()` 读 `.consumption-stats.json` 的当日消费计数（打分核心唯一的消费统计取数口，harness#134）
+- `KnowledgeStore`（类型面）/ `FileKnowledgeStore`（`store.ts`，barrel 与包根交出的**值**符号——store 的文件系统实现，构造收 `{ baseDir }`；仓内构造点两处：`cli/commands/knowledge-view.ts` 的 `openKnowledgeStore()`（knowledge 各子命令的取数口）与 `cli/commands/constraints-retire.ts` 的退役沉淀写入）— 知识条目 CRUD + 结构化存储；`saveAll()` 全量批量写入（循环内只更新内存索引、结束一次 writeIndex，harness#107）、`applyAll()` 按 id 部分更新的批量出口（`update(id, partial)` 的批量形，语义含未知 id 逐条跳过与空批零读写，harness#134）、`getConsumptionStats()` 读 `.consumption-stats.json` 的当日消费计数（打分核心唯一的消费统计取数口，harness#134）。**写入闸（E1 复盘修正 M1）**：save/saveAll/applyAll 落盘前校验 maturity/layer 枚举（update 经 save 继承），未声明值拒写抛错不静默降级；值域正本 = `types.ts` 的 `MATURITY_LEVELS`/`STORAGE_LAYERS` 常量（不进 barrel）。批量路径先整批预校验再落盘（任一脏值全批拒写）；applyAll 批内同 id 多条按序累积合并语义不变
 - `KnowledgeQuery` — 语义搜索 + 类型/标签过滤 + `queryByMode()` + `consume(taskContext)`；`query()` 是 budget 截断管线（仅用于 prompt 注入），`search()` 是全语料文本搜索（先匹配→排序→limit，交互搜索专用，勿用 query() 代替）
-- `KnowledgeLifecycle` — per-mode 生命周期管理；缺省阈值常量 `DEFAULT_DECAY_CONFIG`（`provenDecayMonths: 12` / `verifiedDecayMonths: 6` / `draftDecayMonths: 3` / `autoPromoteSources: []`，正本 `types.ts`）经构造器 `{...DEFAULT_DECAY_CONFIG, ...config}` 合并，barrel 与包根一并交出
+- `KnowledgeLifecycle` — per-mode 生命周期管理；缺省阈值常量 `DEFAULT_DECAY_CONFIG`（`provenDecayMonths: 12` / `verifiedDecayMonths: 6` / `draftDecayMonths: 3` / `autoPromoteSources: []`，正本 `types.ts`）经构造器 `{...DEFAULT_DECAY_CONFIG, ...config}` 合并，barrel 与包根一并交出；候选判定两族同位（tryPromote 升 proven 后自动触发）：`checkSkillCandidate`（AC-8a）与 `checkConstraintCandidate`（块 3 子项 6，ADR-0033——口径 = proven + 未打标 + referencedBy≥5 + contributors≥3 个不同来源会话，打 `constraintCandidate` 标 + `constraintCandidate:marked` 事件，与 skillCandidate 互不干扰可同挂）
 - `extractCodeStructure(dir)`（`primitives/code-structure.ts`，配 `CodeStructure`/`DeclarationInfo`/`ImportInfo` 三类型对外）— 目录代码结构提取；仓内零调用方，是留给下游的公开面
 - `KnowledgeIngest` — 知识摄取引擎（含 ingest gate 质量门）+ `ingestExternal()` 外部内容摄入
 - `sanitizeExternalContent` — 外部内容安全清洗（过滤注入模式 + 长度限制）
@@ -29,7 +29,7 @@
 - `tree-walker`（包内，不进导出面）— 知识树排除口径单点（harness#134）：`isEntryFile()` / `isInfraDir()` / `INDEX_MD_FILE` / `SNAPSHOTS_DIR`，由 store 顶层扫描、migration 顶层扫描、index-generator 递归扫描三处共同消费
 - `flywheel-metrics`（包内，不进导出面）— 知识飞轮指标唯一实现：`evaluateFlywheel(env)` 出 canonical 比例、`genuineRefs()` 出 synthetic 过滤口径，audit D6 / `knowledge stats` / `knowledge health` 三处共消费（ADR-0013）
 - `ReferenceTracker` — 知识引用关系图谱
-- `KnowledgeLinter` — 知识质量检查(完整性/一致性/时效性)
+- `KnowledgeLinter` — 知识质量检查(完整性/一致性/时效性)；maturity/layer 枚举校验两个入口共用判定正本 `invalidEnumIssues`：`run()` 经 `checkInvalidEnums()` 扫存量（缺字段即脏、issue 带 entryId，`invalid_enum` 无 autoFix 分支——映射需人工裁定），`validateEntry()` 管摄入前（字段缺省跳过以兼容只传四字段的 pre-ingest 调用方）
 - `ColdStartImporter` — 冷启动知识导入
 - `KnowledgeHealthScorer` — 知识健康评分（doctor.ts）
 
@@ -43,6 +43,7 @@
 - 知识条目文件的 frontmatter 语法只由 `src/utils/frontmatter` 定义（harness#89）：缺头/空 meta = `absent`（合法输入，按非条目静默处理、不上报——migration 对 `absent` 不计 `errors`、不迁移，只计 `skipped` 保证 `total` 计数闭环，harness#161 对齐 #89 裁决 2）；未闭合/YAML 非法 = `malformed`（必须显式上报后按消费方语义恢复——migration 落 `errors`、store 与 index-generator 打一行 stderr 后跳过或走 best-effort），禁止静默丢条目；canonical 字段序是 `store.toFrontmatter` 的私有策略，`join` 只管包裹格式
 - **知识树的排除口径只有一个正本 `tree-walker`**（harness#134）：`_index.md`（索引生成物）、`.snapshots`、`.archive` / `archived`、`resolutions` 是树基建、不是条目人口。store 与 migration 的顶层扫描、index-generator 的递归扫描三处都走它；新增 walker 禁止另立排除清单。统一的是**排除口径**不是遍历深度（store/migration 顶层、index-generator 递归）。例外须原地记名理由：`import.ts` 的 docs 扫描吃的是**项目文档树**，本口径在它那里没有对应物
 - **循环内禁止逐条 `store.update()`**（harness#134）：`update()` 的形状是 get→save、`save()` 每次全量重写 index.json，N 条修复 = N 次全量重写。批量形是 `applyAll(id → partial)`；一次 `audit --fix`、一轮 `runDecayCycle()`、一次 `updateReferencedBy()` 各只重写一次索引，计数闸见 `audit-write-count.test.ts` 与 `lifecycle.test.ts` / `reference-tracker.test.ts` 的 stringify 计数项
+- **写入闸不管读**（E1 复盘修正 M1）：枚举校验只在 save/saveAll/applyAll/update 落盘前执行，读取（parseFile）不校验——盘上脏条目可读可列，但任一写入路径触及即抛错（含「只改其他字段」的部分更新），先修脏值再写；绕过本 store 直写文件的外部写入方不受闸约束
 - **审计判定脱离文件系统可测**（harness#134）：规则表与 D1–D7 打分住 `audit-scoring.ts`，零 fs（源形状闸钉在 `audit-scoring.test.ts`）；引擎 `audit.ts` 只做 store 装配，环境数据经 `store.getConsumptionStats()` / `getSurvivalRate()` 取好喂入
 - 知识条目有明确的生命周期状态（按 consumptionMode 分化）
 - 约束退役（`harness constraints retire`，人确认）时写入 KnowledgeStore：规则原文 + 退役原因 + 历史统计
@@ -56,7 +57,9 @@
 ## 注意事项
 - Phase 1+4 实现的知识引擎核心
 - 约束"退役不删除"——retire 落盘 config.yml `enabled: false` + retired 元数据，保留规则原文 + 退役原因 + 历史统计（可回滚）
-- `MaturityLevel` 包含 6 个值: draft/verified/proven/archived/active/deprecated
+- `MaturityLevel` / `StorageLayer` 的值域不抄清单——运行时正本是 `types.ts` 的 `MATURITY_LEVELS` / `STORAGE_LAYERS` 常量（写入闸与 lint 枚举校验共用）
 - `excludeArchived` 同时排除 archived 和 deprecated
+- `list()` 的过滤层是 `index.json`（tags/types 匹配都打在 IndexEntry 上），返回体才回读 .md 全文——手工清洗/直改 .md 数据区时须同步 index（`rebuildIndex()` 或同改 index.json），否则过滤口径与文件内容漂移（#614 存量 tags 清洗同步了两边）
+- tag 写入纪律（#614 审计）：凡 append tag 处先判存在或走 Set 去重——`audit.ts`/`ingest.ts` 的 low_quality 有 includes 闸、ingest 合并走 `new Set`、`lifecycle.checkSkillCandidate`/`checkConstraintCandidate` 由前置谓词挡住重复；studio 侧 rule-scanner/pattern-miner 曾因缺闸造成实盘 tags 千次重复腐蚀
 - 仍有两处按**原始** `referencedBy.length` 判定，不属飞轮指标、ADR-0013 明确列为范围外：`lifecycle.ts` 的 signal 饱和 / reference 激活（退役阈值调整另票）、`knowledge health` 的 D1「verified 零引用」线索提示（逐条 issue 线索，非聚合分子）
 - #134 收口后仍在的逐条写点（同型问题，本票裁决点名的循环之外，需要时另票）：`lint.ts` 的三处 autoFix `store.update()`、`lifecycle.recordReference()`（逐事件调用，返回更新后条目并触发回调，批量化会改它的契约）、`ingest.mergeEntries()`；`store.list()` 每条一次 `findFile()` 线性扫索引的 O(N²) 按 #134 裁决**未动**，待把知识树实际规模重新量一次再判是否单开票

package/src/knowledge/__tests__/lifecycle.test.ts

@@ -956,4 +956,85 @@ describe('KnowledgeLifecycle', () => {
       expect(lifecycle.checkEntryDecay('SIG-001')).toBeUndefined();
     });
   });
+
+  describe('checkConstraintCandidate（块 3 子项 6，ADR-0033）', () => {
+    /** 达标基线：proven + 5 条引用 + 3 个不同来源会话 */
+    const eligible = (overrides?: Partial<KnowledgeEntry>): KnowledgeEntry => makeEntry({
+      maturity: 'proven',
+      referencedBy: ['a:2026-05-01', 'b:2026-05-02', 'c:2026-05-03', 'a:2026-05-04', 'b:2026-05-05'],
+      contributors: ['a', 'b', 'c'],
+      ...overrides,
+    });
+
+    it('达标：打 constraintCandidate 标 + 触发 constraintCandidate:marked 事件，返回 true', () => {
+      const events: Array<{ entryId: string; context?: string }> = [];
+      lifecycle.onReference(e => events.push({ entryId: e.entryId, context: e.context }));
+      store.save(eligible());
+
+      expect(lifecycle.checkConstraintCandidate('DEC-001')).toBe(true);
+      expect(store.get('DEC-001')!.tags).toContain('constraintCandidate');
+      expect(events).toEqual([{ entryId: 'DEC-001', context: 'constraintCandidate:marked' }]);
+    });
+
+    it('不达标不打标：非 proven / 引用不足 5 / 来源会话不足 3', () => {
+      store.save(eligible({ id: 'E-1', maturity: 'verified' }));
+      store.save(eligible({ id: 'E-2', referencedBy: ['a:2026-05-01', 'b:2026-05-02', 'c:2026-05-03', 'a:2026-05-04'] }));
+      store.save(eligible({ id: 'E-3', contributors: ['a', 'b'] }));
+
+      for (const id of ['E-1', 'E-2', 'E-3']) {
+        expect(lifecycle.checkConstraintCandidate(id)).toBe(false);
+        expect(store.get(id)!.tags).not.toContain('constraintCandidate');
+      }
+    });
+
+    it('幂等：已打标不重复打、不重复触发事件', () => {
+      const events: string[] = [];
+      lifecycle.onReference(e => { if (e.context) events.push(e.context); });
+      store.save(eligible({ tags: ['constraintCandidate'] }));
+
+      expect(lifecycle.checkConstraintCandidate('DEC-001')).toBe(false);
+      expect(store.get('DEC-001')!.tags.filter(t => t === 'constraintCandidate')).toHaveLength(1);
+      expect(events).toEqual([]);
+    });
+
+    it('不存在的条目返回 false', () => {
+      expect(lifecycle.checkConstraintCandidate('NON-EXISTENT')).toBe(false);
+    });
+
+    it('与 skillCandidate 互不干扰：达标条目可同时挂两标', () => {
+      store.save(eligible({
+        content: 'a'.repeat(200),
+        executionResults: [
+          { contributor: 'a', success: true, timestamp: '2026-05-01' },
+          { contributor: 'b', success: true, timestamp: '2026-05-02' },
+          { contributor: 'c', success: true, timestamp: '2026-05-03' },
+          { contributor: 'a', success: true, timestamp: '2026-05-04' },
+          { contributor: 'b', success: true, timestamp: '2026-05-05' },
+        ],
+      }));
+
+      expect(lifecycle.checkSkillCandidate('DEC-001')).toBe(true);
+      expect(lifecycle.checkConstraintCandidate('DEC-001')).toBe(true);
+      const tags = store.get('DEC-001')!.tags;
+      expect(tags).toContain('skillCandidate');
+      expect(tags).toContain('constraintCandidate');
+    });
+
+    it('tryPromote 升到 proven 后自动触发判定（与 checkSkillCandidate 同位）', () => {
+      const events: string[] = [];
+      lifecycle.onReference(e => { if (e.context) events.push(e.context); });
+      store.save(makeEntry({
+        maturity: 'verified',
+        content: 'a'.repeat(100),
+        contributors: ['a', 'b', 'c'],
+        projects: ['p1', 'p2'],
+        referencedBy: ['a:2026-05-01', 'b:2026-05-02', 'c:2026-05-03', 'a:2026-05-04', 'b:2026-05-05'],
+      }));
+
+      const change = lifecycle.tryPromote('DEC-001');
+      expect(change?.to).toBe('proven');
+      expect(store.get('DEC-001')!.tags).toContain('constraintCandidate');
+      expect(events).toContain('constraintCandidate:marked');
+    });
+  });
 });

package/src/knowledge/__tests__/lint.test.ts

@@ -57,6 +57,7 @@ describe('KnowledgeLinter', () => {
       expect(report.fixed).toBe(0);
     });
 
+
     it('应该检测所有问题类型', () => {
       // 孤儿条目
       saveEntry({ id: 'orphan-1', title: 'Orphan', maturity: 'draft', contributors: [], projects: [] });
@@ -79,6 +80,39 @@ describe('KnowledgeLinter', () => {
     });
   });
 
+  // M1 收口：run() 存量扫描必须报出 maturity/layer 脏值（spec：lint 能报出存量脏条目）
+  describe('run 存量枚举校验', () => {
+    /** 绕过写入闸直写脏条目（模拟实盘直写路径） */
+    function writeDirtyFile(name: string, fm: string) {
+      const dir = path.join(tmpDir, 'knowledge');
+      fs.writeFileSync(path.join(dir, name), `---\n${fm}\n---\n\nbody content long enough.\n`, 'utf-8');
+      store.rebuildIndex();
+    }
+
+    it('盘上脏 maturity / 脏 layer 的存量条目 → run() 报 invalid_enum', () => {
+      writeDirtyFile('resolution-res_a.md',
+        'id: res_a\ntype: resolution\ntitle: Dirty M\nmaturity: pending\nlayer: project\ncreated: 2026-09-01T00:00:00.000Z');
+      writeDirtyFile('resolution-res_b.md',
+        'id: res_b\ntype: resolution\ntitle: Dirty L\nmaturity: draft\nlayer: L3_tool_behavior\ncreated: 2026-09-01T00:00:00.000Z');
+      writeDirtyFile('resolution-res_c.md',
+        'id: res_c\ntype: resolution\ntitle: Missing Layer\nmaturity: draft\ncreated: 2026-09-01T00:00:00.000Z');
+
+      const report = linter.run();
+      const enumIssues = report.issues.filter(i => i.type === 'invalid_enum');
+      expect(enumIssues).toHaveLength(3);
+      expect(enumIssues.map(i => i.entryId).sort()).toEqual(['res_a', 'res_b', 'res_c']);
+      expect(report.summary.invalid_enum).toBe(3);
+    });
+
+    it('全合法条目库 → 零 invalid_enum（存量合法条目无新噪音）', () => {
+      saveEntry({ id: 'clean-1', maturity: 'verified', layer: 'project' });
+      saveEntry({ id: 'clean-2', maturity: 'active', layer: 'tech', title: 'Another' });
+
+      const report = linter.run();
+      expect(report.summary.invalid_enum).toBe(0);
+    });
+  });
+
   describe('checkIndexConsistency', () => {
     it('应该检测索引中有但文件不存在的条目', () => {
       saveEntry({ id: 'entry-1' });
@@ -370,6 +404,56 @@ describe('KnowledgeLinter', () => {
       });
       expect(issues.some(i => i.type === 'duplicate')).toBe(true);
     });
+
+    // E1 复盘修正 M1：maturity/layer 枚举值域校验（实盘脏值：pending/canonical/L3_tool_behavior）
+    it('flags undeclared maturity value', () => {
+      const issues = linter.validateEntry({
+        title: 'Specific Entry With Valid Title',
+        content: 'This is a sufficiently long content for the enum check test case.',
+        tags: [],
+        type: 'decision',
+        maturity: 'pending',
+      });
+      const issue = issues.find(i => i.type === 'invalid_enum');
+      expect(issue).toBeDefined();
+      expect(issue!.severity).toBe('high');
+      expect(issue!.description).toContain('pending');
+    });
+
+    it('flags undeclared layer value', () => {
+      const issues = linter.validateEntry({
+        title: 'Specific Entry With Valid Title',
+        content: 'This is a sufficiently long content for the enum check test case.',
+        tags: [],
+        type: 'decision',
+        layer: 'L3_tool_behavior',
+      });
+      const issue = issues.find(i => i.type === 'invalid_enum');
+      expect(issue).toBeDefined();
+      expect(issue!.description).toContain('L3_tool_behavior');
+    });
+
+    it('accepts declared maturity/layer values', () => {
+      const issues = linter.validateEntry({
+        title: 'Specific Entry With Valid Title',
+        content: 'This is a sufficiently long content for the enum check test case.',
+        tags: [],
+        type: 'decision',
+        maturity: 'verified',
+        layer: 'project',
+      });
+      expect(issues.filter(i => i.type === 'invalid_enum')).toHaveLength(0);
+    });
+
+    it('skips enum check when maturity/layer are not provided (pre-ingest caller compat)', () => {
+      const issues = linter.validateEntry({
+        title: 'Specific Entry With Valid Title',
+        content: 'This is a sufficiently long content for the enum check test case.',
+        tags: [],
+        type: 'decision',
+      });
+      expect(issues.filter(i => i.type === 'invalid_enum')).toHaveLength(0);
+    });
   });
 
   describe('autoFix', () => {

package/src/knowledge/__tests__/store.test.ts

@@ -174,6 +174,76 @@ describe('KnowledgeStore', () => {
     });
   });
 
+  // 写入闸（E1 复盘修正 M1）：maturity/layer 是声明枚举，未声明值拒写报错，不静默降级
+  describe('schema gate: maturity/layer 枚举校验', () => {
+    it('save 拒绝未声明的 maturity 值，不落盘', () => {
+      expect(() => store.save(makeEntry({ maturity: 'pending' as KnowledgeEntry['maturity'] })))
+        .toThrow(/maturity.*pending/);
+      expect(store.get('DEC-001')).toBeUndefined();
+      expect(store.readIndex()).toHaveLength(0);
+    });
+
+    it('save 拒绝未声明的 layer 值，不落盘', () => {
+      expect(() => store.save(makeEntry({ layer: 'L3_tool_behavior' as KnowledgeEntry['layer'] })))
+        .toThrow(/layer.*L3_tool_behavior/);
+      expect(store.get('DEC-001')).toBeUndefined();
+    });
+
+    it('save 拒绝缺失 layer 的条目', () => {
+      const entry = makeEntry();
+      delete (entry as Partial<KnowledgeEntry>).layer;
+      expect(() => store.save(entry)).toThrow(/layer/);
+      expect(store.get('DEC-001')).toBeUndefined();
+    });
+
+    it('update 传入脏 maturity 值 → 拒写，既有条目不变', () => {
+      store.save(makeEntry());
+      expect(() => store.update('DEC-001', { maturity: 'canonical' as KnowledgeEntry['maturity'] }))
+        .toThrow(/maturity.*canonical/);
+      expect(store.get('DEC-001')!.maturity).toBe('draft');
+    });
+
+    it('存量脏条目（绕过闸直写文件）经 update 修补其他字段 → 拒写报错', () => {
+      // 模拟实盘脏条目：resolution.service 直写文件的形状（maturity/layer 均未声明）
+      fs.writeFileSync(
+        path.join(tempDir, 'resolution-res_1.md'),
+        '---\nid: res_1\ntype: resolution\ntitle: Dirty\nmaturity: pending\nlayer: L3_tool_behavior\ncreated: 2026-09-01T00:00:00.000Z\n---\n\nbody\n',
+        'utf-8'
+      );
+      store.rebuildIndex();
+      expect(() => store.update('res_1', { tags: ['touched'] })).toThrow(/maturity.*pending/);
+    });
+
+    it('存量脏条目经 update 把脏字段修成合法值 → 放行（清洗路径）', () => {
+      fs.writeFileSync(
+        path.join(tempDir, 'resolution-res_2.md'),
+        '---\nid: res_2\ntype: resolution\ntitle: Dirty\nmaturity: pending\nlayer: L3_tool_behavior\ncreated: 2026-09-01T00:00:00.000Z\n---\n\nbody\n',
+        'utf-8'
+      );
+      store.rebuildIndex();
+      const updated = store.update('res_2', { maturity: 'draft', layer: 'project' });
+      expect(updated!.maturity).toBe('draft');
+      expect(store.get('res_2')!.layer).toBe('project');
+    });
+
+    it('saveAll 含一条脏值 → 整批拒写（合法条目也不落盘）', () => {
+      expect(() => store.saveAll([
+        makeEntry({ id: 'DEC-001' }),
+        makeEntry({ id: 'DEC-002', layer: 'process' as KnowledgeEntry['layer'] }),
+      ])).toThrow(/layer.*process/);
+      expect(store.get('DEC-001')).toBeUndefined();
+      expect(store.readIndex()).toHaveLength(0);
+    });
+
+    it('applyAll 部分更新把 maturity 改成脏值 → 拒写', () => {
+      store.save(makeEntry());
+      expect(() => store.applyAll([
+        { id: 'DEC-001', partial: { maturity: 'pending' as KnowledgeEntry['maturity'] } },
+      ])).toThrow(/maturity.*pending/);
+      expect(store.get('DEC-001')!.maturity).toBe('draft');
+    });
+  });
+
   describe('rebuildIndex', () => {
     it('should rebuild index from files', () => {
       store.save(makeEntry({ id: 'DEC-001' }));

package/src/knowledge/lifecycle.ts

@@ -199,8 +199,10 @@ export class KnowledgeLifecycle {
     this.store.update(entryId, { maturity: target });
 
     // AC-8a: After promotion, check skillCandidate eligibility
+    // 块 3 子项 6（ADR-0033）：同位触发 constraintCandidate 判定——两标独立，可同挂
     if (target === 'proven') {
       this.checkSkillCandidate(entryId);
+      this.checkConstraintCandidate(entryId);
     }
 
     return change;
@@ -253,6 +255,53 @@ export class KnowledgeLifecycle {
     return true;
   }
 
+  /**
+   * 块 3 子项 6（ADR-0033）：Check if a proven entry qualifies as a constraintCandidate.
+   * Marks with 'constraintCandidate' tag and emits event if eligible.
+   * Returns true if newly marked.
+   *
+   * 判定口径（人类已批准，设计稿 Q4）：proven + 未打过标 + references≥5
+   * （referencedBy 条数，与 recordReference 的 refKey 口径一致）+ ≥3 个不同来源会话
+   * （contributors，与 skill 候选同字段）。与 skillCandidate 互不干扰，可同挂两标。
+   */
+  checkConstraintCandidate(entryId: string): boolean {
+    const entry = this.store.get(entryId);
+    if (!entry) return false;
+    if (!this.isConstraintCandidate(entry)) return false;
+
+    // Mark as constraintCandidate
+    this.store.update(entryId, {
+      tags: [...entry.tags, 'constraintCandidate'],
+    });
+
+    // Emit event for downstream consumers
+    const now = new Date().toISOString();
+    for (const cb of this.onReferenceCallbacks) {
+      try {
+        cb({
+          entryId,
+          contributor: 'lifecycle',
+          timestamp: now,
+          context: 'constraintCandidate:marked',
+        });
+      } catch { /* non-blocking */ }
+    }
+
+    return true;
+  }
+
+  /**
+   * 块 3 子项 6：Check if an entry meets constraintCandidate criteria.
+   */
+  private isConstraintCandidate(entry: KnowledgeEntry): boolean {
+    if (entry.maturity !== 'proven') return false;
+    if (entry.tags.includes('constraintCandidate')) return false;
+    if (entry.referencedBy.length < 5) return false;
+    if (entry.contributors.length < 3) return false;
+
+    return true;
+  }
+
   /**
    * AC-8c: Remove skillCandidate tag if success rate drops below 50%.
    * Called after execution writeback.