@dommaker/harness 1.11.0 → 1.12.0

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

@@ -3,9 +3,11 @@
  *
  * `harness constraints report` 与 `harness constraints retire`（交互模式）共用的
  * 数据层：读取项目 traces.log，与生效集（getEffectiveConstraints）对齐，
- * 产出 check 约束统计表与四类退役候选诊断。
+ * 产出 check 约束统计表、四类退役候选诊断与零拦截观察名单（ADR-0032/0033 块 3 子项 4：
+ * 零拦截先进观察名单挂一个季度，期满且样本足才转正式退役候选）。
  *
- * 只读：不创建目录、不写任何文件。
+ * 只读：不创建目录、不写任何文件。观察名单状态以快照入参进来、以 `nextWatchlist`
+ * 产物出去，持久化（`.harness/.state.json` 经 StateIO 接缝）是 cli 层调用方的职责。
  */
 
 import * as fs from 'fs';
@@ -92,6 +94,52 @@ export const DEFAULT_DIAGNOSE_THRESHOLDS: DiagnoseThresholds = {
   highNoiseMinEvaluated: 20,
 };
 
+/**
+ * 观察名单状态条目（ADR-0032 口径，块 3 子项 4）
+ *
+ * 持久化在 `.harness/.state.json` 的 `constraintWatchlist` 段（StateIO 接缝，
+ * cli 层读-改-写）；本层只认快照，不碰 fs。
+ */
+export interface WatchlistStateEntry {
+  /** 列入观察名单时刻（ISO 串，与 HarnessState 其余时间字段同形） */
+  listedAt: string;
+}
+
+/** 观察名单状态（constraintId → 条目） */
+export type ConstraintWatchlistState = Record<string, WatchlistStateEntry>;
+
+/** 观察期时长（天）：满一个季度且样本仍达标，零拦截才转正式退役候选 */
+export const WATCHLIST_PERIOD_DAYS = 90;
+
+const DAY_MS = 24 * 60 * 60 * 1000;
+
+/**
+ * report 里单独分组展示的观察名单条目
+ *
+ * 列入即进 report（告知面），但不进退役候选；观察期内再次出现 fail / 样本
+ * 跌破阈值时条目自然消失（状态段里的列入记录保留，时钟不回拨）。
+ */
+export interface WatchlistEntry {
+  id: string;
+  stats: ConstraintUsageStats;
+  /** 列入时刻（ISO 串） */
+  listedAt: string;
+  /** 剩余观察天数（观察期未满恒 > 0） */
+  remainingDays: number;
+  /** 人类可读的诊断说明（带证据数字） */
+  reason: string;
+}
+
+/**
+ * 候选诊断的观察名单上下文（不传 = 空名单 + 真实时钟）
+ */
+export interface DiagnoseWatchOptions {
+  /** 观察名单状态快照（来自 `.harness/.state.json`，缺省空） */
+  watchlist?: ConstraintWatchlistState;
+  /** 当前时刻（Unix ms），测试注入用——别在测试里等 90 天 */
+  now?: number;
+}
+
 /**
  * report 数据模型
  */
@@ -100,6 +148,13 @@ export interface ConstraintsUsageReport {
   stats: ConstraintUsageStats[];
   /** 退役候选诊断（按 zero_trigger → unevaluable → high_noise → zero_intercept 排序） */
   candidates: RetireCandidate[];
+  /** 零拦截观察名单（进 report 但不进退役候选；期满且样本足才转候选） */
+  watchlist: WatchlistEntry[];
+  /**
+   * 观察名单读-改-写产物：入参快照 + 本次新列入（只增不删）。
+   * 与入参快照键数不同（有新增）时，调用方应经 StateIO 写回 `.harness/.state.json`。
+   */
+  nextWatchlist: ConstraintWatchlistState;
   /** 配置健康诊断（unknownIds 等） */
   lint: EffectiveConfigLint;
   /** trace 文件是否存在 */
@@ -176,18 +231,33 @@ function toStats(id: string, severity: Constraint['severity'], agg: { total: num
   };
 }
 
+/** 诊断完整产物（candidates + watchlist + 待写回的状态） */
+interface DiagnoseOutcome {
+  candidates: RetireCandidate[];
+  watchlist: WatchlistEntry[];
+  nextWatchlist: ConstraintWatchlistState;
+}
+
 /**
  * 退役候选诊断（纯函数）
  *
  * 每条约束最多归入一个类别，优先级：
  * zero_trigger → unevaluable → high_noise → zero_intercept
+ *
+ * zero_intercept 走观察名单中间态（ADR-0032）：命中且样本够 → 不在名单则列入
+ * （listedAt = now），进 watchlist 不进 candidates；已在名单且满 WATCHLIST_PERIOD_DAYS
+ * 且当前样本仍达标 → 转正式 zero_intercept 退役候选。其他三类不进观察名单。
  */
-export function diagnoseRetireCandidates(
+function diagnose(
   stats: ConstraintUsageStats[],
-  thresholds: Partial<DiagnoseThresholds> = {}
-): RetireCandidate[] {
-  const t = { ...DEFAULT_DIAGNOSE_THRESHOLDS, ...thresholds };
+  t: DiagnoseThresholds,
+  watch: DiagnoseWatchOptions
+): DiagnoseOutcome {
+  const now = watch.now ?? Date.now();
+  const watchlistState = watch.watchlist ?? {};
+  const nextWatchlist: ConstraintWatchlistState = { ...watchlistState };
   const candidates: RetireCandidate[] = [];
+  const watchlistEntries: WatchlistEntry[] = [];
 
   for (const s of stats) {
     if (s.total === 0) {
@@ -224,24 +294,66 @@ export function diagnoseRetireCandidates(
     }
 
     if (s.fail === 0 && s.evaluated >= t.zeroInterceptMinEvaluated) {
-      candidates.push({
+      const listed = watchlistState[s.id];
+      const listedAtMs = listed ? Date.parse(listed.listedAt) : NaN;
+      // 列入时间损坏按未列入处理：重新列入、时钟重启（状态文件是人可手改的，不静默信脏值）
+      const isListed = listed !== undefined && Number.isFinite(listedAtMs);
+
+      if (isListed && now - listedAtMs >= WATCHLIST_PERIOD_DAYS * DAY_MS) {
+        candidates.push({
+          id: s.id,
+          kind: 'zero_intercept',
+          stats: s,
+          reason: `零拦截：观察期满（${listed.listedAt.slice(0, 10)} 列入，已满 ${WATCHLIST_PERIOD_DAYS} 天），${s.evaluated} 次评估从未 fail`,
+        });
+        continue;
+      }
+
+      const listedAt = isListed ? listed.listedAt : new Date(now).toISOString();
+      if (!isListed) {
+        nextWatchlist[s.id] = { listedAt };
+      }
+      watchlistEntries.push({
         id: s.id,
-        kind: 'zero_intercept',
         stats: s,
+        listedAt,
+        remainingDays: isListed
+          ? Math.max(0, Math.ceil((listedAtMs + WATCHLIST_PERIOD_DAYS * DAY_MS - now) / DAY_MS))
+          : WATCHLIST_PERIOD_DAYS,
         reason: `零拦截：${s.evaluated} 次评估从未 fail`,
       });
     }
   }
 
-  return candidates;
+  return { candidates, watchlist: watchlistEntries, nextWatchlist };
 }
 
 /**
- * 构建 report 数据模型（只读）
+ * 退役候选诊断（纯函数）——观察名单兼容包装
+ *
+ * 每条约束最多归入一个类别，优先级：
+ * zero_trigger → unevaluable → high_noise → zero_intercept
+ *
+ * 只返回退役候选；观察名单分组与待写回状态走 `buildConstraintsUsageReport`
+ * 的 `watchlist` / `nextWatchlist` 字段。zero_intercept 仅在观察期满且样本足时
+ * 才出现在本返回值里（ADR-0032），未期满的命中不再直接列候选。
+ */
+export function diagnoseRetireCandidates(
+  stats: ConstraintUsageStats[],
+  thresholds: Partial<DiagnoseThresholds> = {},
+  watch: DiagnoseWatchOptions = {}
+): RetireCandidate[] {
+  const t = { ...DEFAULT_DIAGNOSE_THRESHOLDS, ...thresholds };
+  return diagnose(stats, t, watch).candidates;
+}
+
+/**
+ * 构建 report 数据模型（只读；观察名单状态以快照入、以 nextWatchlist 出，不写盘）
  */
 export function buildConstraintsUsageReport(
   projectRoot: string = process.cwd(),
-  thresholds: Partial<DiagnoseThresholds> = {}
+  thresholds: Partial<DiagnoseThresholds> = {},
+  watch: DiagnoseWatchOptions = {}
 ): ConstraintsUsageReport {
   const effective = getEffectiveConstraints(projectRoot);
 
@@ -250,12 +362,15 @@ export function buildConstraintsUsageReport(
   const usage = collectUsageByConstraint(traces);
 
   const stats = effective.map(c => toStats(c.id, c.severity, usage.get(c.id)));
-  const candidates = diagnoseRetireCandidates(stats, thresholds);
+  const t = { ...DEFAULT_DIAGNOSE_THRESHOLDS, ...thresholds };
+  const outcome = diagnose(stats, t, watch);
   const lint = lintEffectiveConfig(projectRoot);
 
   return {
     stats,
-    candidates,
+    candidates: outcome.candidates,
+    watchlist: outcome.watchlist,
+    nextWatchlist: outcome.nextWatchlist,
     lint,
     traceFileExists: fs.existsSync(tracePath),
     skippedLines,

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/knowledge/CONTEXT.md

@@ -19,7 +19,7 @@
 ## 核心导出
 - `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` — 外部内容安全清洗（过滤注入模式 + 长度限制）
@@ -59,5 +59,7 @@
 - 约束"退役不删除"——retire 落盘 config.yml `enabled: false` + retired 元数据，保留规则原文 + 退役原因 + 历史统计（可回滚）
 - `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/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.

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

@@ -32,16 +32,17 @@ describe('预设数据', () => {
   describe('RELAXED_PRESET', () => {
     it('应该只启用核心约束', () => {
       expect(RELAXED_PRESET.name).toBe('relaxed');
-      expect(RELAXED_PRESET.errors).toHaveLength(1);
-      expect(RELAXED_PRESET.warnings).toHaveLength(1);
+      expect(RELAXED_PRESET.errors).toHaveLength(2);
+      expect(RELAXED_PRESET.warnings).toHaveLength(0);
     });
 
     it('应该包含 no_completion_without_verification', () => {
       expect(RELAXED_PRESET.errors).toContain('no_completion_without_verification');
     });
 
-    it('应该包含 no_hardcoded_credentials', () => {
-      expect(RELAXED_PRESET.warnings).toContain('no_hardcoded_credentials');
+    it('应该包含 no_hardcoded_credentials（ADR-0032 起为 error 级，同桶）', () => {
+      expect(RELAXED_PRESET.errors).toContain('no_hardcoded_credentials');
+      expect(RELAXED_PRESET.warnings).toEqual([]);
     });
   });
 

package/src/presets/standard.ts

@@ -47,16 +47,15 @@ export const STANDARD_PRESET: PresetConfig = {
 /**
  * 宽松预设
  *
- * 仅启用核心 error 级与凭证扫描
+ * 仅启用核心 error 级与凭证扫描（ADR-0032 起凭证扫描为 error 级，同桶）
  */
 export const RELAXED_PRESET: PresetConfig = {
   name: 'relaxed',
   errors: [
     'no_completion_without_verification',
-  ],
-  warnings: [
     'no_hardcoded_credentials',
   ],
+  warnings: [],
 };
 
 /**

package/src/types/constraint.ts

@@ -32,6 +32,15 @@ export type ConstraintSeverity = 'error' | 'warning' | 'info';
  */
 export type ConstraintTrigger = string;
 
+/**
+ * 约束来源（ADR-0033 两层约束模型）
+ *
+ * - builtin：内置约束（definitions/ 字面量定义，checker 按约束 id 注册查找）
+ * - app：应用层约束（应用仓 `.harness/constraints.yml` 定义，checker 按模板 id +
+ *   params 实例化）；缺省 builtin
+ */
+export type ConstraintSource = 'builtin' | 'app';
+
 /**
  * 约束定义
  */
@@ -65,6 +74,25 @@ export interface Constraint {
 
   /** 是否启用 */
   enabled?: boolean;
+
+  /**
+   * 约束来源（ADR-0033）：缺省 builtin
+   *
+   * app = 应用层约束（应用仓 `.harness/constraints.yml` 定义）；
+   * report/退休/提案据此区分来源
+   */
+  source?: ConstraintSource;
+
+  /**
+   * 填空式 checker 模板 id（仅 source='app' 使用）
+   *
+   * 内置约束省略 = checker 按约束 id 在内置注册表查找；应用层约束按模板 id
+   * 在模板注册表（checkers/index.ts TEMPLATES）查找并带 params 实例化
+   */
+  checker?: string;
+
+  /** 模板参数（仅 source='app' 使用，形状由各模板的 validateParams 校验） */
+  params?: Record<string, unknown>;
 }
 
 /**