@dommaker/harness 1.10.0 → 1.12.0

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

@@ -15,7 +15,9 @@ import {
   buildConstraintsUsageReport,
   diagnoseRetireCandidates,
   readProjectTraces,
+  WATCHLIST_PERIOD_DAYS,
 } from '../../../core/constraints/usage-report';
+import type { HarnessState, StateIO } from '../../state-io';
 import { constraintsReport, renderExportMarkdown } from '../constraints-report';
 import { createProjectFixture, writeProjectTraces } from '../../../test-setup/project-fixture';
 
@@ -126,13 +128,13 @@ describe('buildConstraintsUsageReport', () => {
     expect(noiseC?.kind).toBe('high_noise');
     expect(noiseC?.reason).toContain('83%');
 
-    // 零拦截
-    const zeroC = byId.get('no_hardcoded_credentials');
-    expect(zeroC?.kind).toBe('zero_intercept');
-    expect(zeroC?.reason).toContain('50 次评估');
+    // 零拦截：先进观察名单（ADR-0032 中间态），不直接进退役候选
+    expect(byId.get('no_hardcoded_credentials')).toBeUndefined();
+    const watched = report.watchlist.find(w => w.id === 'no_hardcoded_credentials');
+    expect(watched?.reason).toContain('50 次评估');
   });
 
-  it('阈值可配：放宽零拦截样本阈值后 10 次全 pass 也成为候选', () => {
+  it('阈值可配：放宽零拦截样本阈值后 10 次全 pass 进观察名单（不直接进候选）', () => {
     const root = createProjectFixture({
       name: 'harness-report-test',
       traces: tracesOf('no_hardcoded_credentials', 'pass', 10),
@@ -140,9 +142,11 @@ describe('buildConstraintsUsageReport', () => {
 
     const strict = buildConstraintsUsageReport(root);
     expect(strict.candidates.find(c => c.id === 'no_hardcoded_credentials')).toBeUndefined();
+    expect(strict.watchlist.find(w => w.id === 'no_hardcoded_credentials')).toBeUndefined();
 
     const relaxed = buildConstraintsUsageReport(root, { zeroInterceptMinEvaluated: 10 });
-    expect(relaxed.candidates.find(c => c.id === 'no_hardcoded_credentials')?.kind).toBe('zero_intercept');
+    expect(relaxed.candidates.find(c => c.id === 'no_hardcoded_credentials')).toBeUndefined();
+    expect(relaxed.watchlist.find(w => w.id === 'no_hardcoded_credentials')).toBeDefined();
   });
 
   it('diagnoseRetireCandidates 优先级：全 skip 不重复计入零拦截', () => {
@@ -286,3 +290,168 @@ describe('constraintsReport 坏行数透传（harness#100）', () => {
     expect(fs.readFileSync(path.join(clean, 'report.md'), 'utf-8')).not.toContain('损坏');
   });
 });
+
+describe('零拦截观察名单（ADR-0032，块 3 子项 4）', () => {
+  const DAY_MS = 24 * 60 * 60 * 1000;
+  // 固定时钟：观察期判定全靠注入 now，不在测试里等 90 天
+  const NOW = 1700100000000;
+  const NOW_ISO = new Date(NOW).toISOString();
+
+  /** 内存 StateIO 假件（与 status/check 测试同形） */
+  function memoryStateIO(initial: HarnessState = {}): StateIO & { snapshot(): HarnessState } {
+    let state = initial;
+    return {
+      read: () => state,
+      write: (s: HarnessState) => { state = s; },
+      snapshot: () => state,
+    };
+  }
+
+  /** 50 次全 pass 的零拦截 fixture 项目 */
+  function zeroInterceptProject(id = 'no_hardcoded_credentials', n = 50): string {
+    return createProjectFixture({
+      name: 'harness-watchlist-test',
+      traces: tracesOf(id, 'pass', n, NOW - 10 * DAY_MS),
+    });
+  }
+
+  it('命中且不在名单：列入观察名单（记列入时间），进 watchlist 分组不进退役候选', () => {
+    const root = zeroInterceptProject();
+    const report = buildConstraintsUsageReport(root, {}, { now: NOW });
+
+    expect(report.candidates.some(c => c.id === 'no_hardcoded_credentials')).toBe(false);
+    const w = report.watchlist.find(x => x.id === 'no_hardcoded_credentials');
+    expect(w).toBeDefined();
+    expect(w!.listedAt).toBe(NOW_ISO);
+    expect(w!.remainingDays).toBe(WATCHLIST_PERIOD_DAYS);
+    expect(w!.reason).toContain('50 次评估');
+    // 待写回状态只增不删
+    expect(report.nextWatchlist['no_hardcoded_credentials']).toEqual({ listedAt: NOW_ISO });
+  });
+
+  it('观察期未满：仍留名单不转候选，剩余观察期按天折算', () => {
+    const root = zeroInterceptProject();
+    const listedAt = new Date(NOW - 30 * DAY_MS).toISOString();
+    const report = buildConstraintsUsageReport(root, {}, {
+      watchlist: { no_hardcoded_credentials: { listedAt } },
+      now: NOW,
+    });
+
+    expect(report.candidates.some(c => c.id === 'no_hardcoded_credentials')).toBe(false);
+    const w = report.watchlist.find(x => x.id === 'no_hardcoded_credentials');
+    expect(w!.listedAt).toBe(listedAt);
+    expect(w!.remainingDays).toBe(WATCHLIST_PERIOD_DAYS - 30);
+    // 已列入不重复写
+    expect(report.nextWatchlist).toEqual({ no_hardcoded_credentials: { listedAt } });
+  });
+
+  it('期满且样本够：转正式 zero_intercept 退役候选', () => {
+    const root = zeroInterceptProject();
+    const listedAt = new Date(NOW - WATCHLIST_PERIOD_DAYS * DAY_MS).toISOString();
+    const report = buildConstraintsUsageReport(root, {}, {
+      watchlist: { no_hardcoded_credentials: { listedAt } },
+      now: NOW,
+    });
+
+    const c = report.candidates.find(x => x.id === 'no_hardcoded_credentials');
+    expect(c?.kind).toBe('zero_intercept');
+    expect(c?.reason).toContain('观察期满');
+    expect(report.watchlist.some(w => w.id === 'no_hardcoded_credentials')).toBe(false);
+  });
+
+  it('期满但样本不够（评估数跌破阈值）：不转候选', () => {
+    const root = zeroInterceptProject('no_hardcoded_credentials', 30);
+    const listedAt = new Date(NOW - 120 * DAY_MS).toISOString();
+    const report = buildConstraintsUsageReport(root, {}, {
+      watchlist: { no_hardcoded_credentials: { listedAt } },
+      now: NOW,
+    });
+
+    expect(report.candidates.some(c => c.id === 'no_hardcoded_credentials')).toBe(false);
+  });
+
+  it('其他三类候选不进观察名单（zero_trigger/unevaluable/high_noise 维持现状）', () => {
+    const root = createProjectFixture({ name: 'harness-watchlist-test' });
+    writeProjectTraces(root, [
+      ...tracesOf('capability_sync', 'skip', 5),                    // 不可评估
+      ...tracesOf('no_test_simplification', 'fail', 20),            // 高噪
+      ...tracesOf('no_test_simplification', 'pass', 4, 1700001000000),
+      // docs_freshness 等零触发
+    ]);
+    const report = buildConstraintsUsageReport(root, {}, { now: NOW });
+
+    expect(report.candidates.length).toBeGreaterThan(0);
+    expect(report.watchlist).toEqual([]);
+    expect(report.nextWatchlist).toEqual({});
+  });
+
+  it('diagnoseRetireCandidates 兼容签名：只回候选，观察期内的零拦截不出现', () => {
+    const stats = [{
+      id: 'x', severity: 'warning' as const,
+      total: 50, pass: 50, fail: 0, skip: 0,
+      evaluated: 50, failRate: 0,
+    }];
+    expect(diagnoseRetireCandidates(stats)).toEqual([]);
+    const listedAt = new Date(NOW - 100 * DAY_MS).toISOString();
+    const converted = diagnoseRetireCandidates(stats, {}, {
+      watchlist: { x: { listedAt } },
+      now: NOW,
+    });
+    expect(converted.map(c => c.kind)).toEqual(['zero_intercept']);
+  });
+
+  it('列入时间损坏按未列入处理：重新列入、时钟重启', () => {
+    const root = zeroInterceptProject();
+    const report = buildConstraintsUsageReport(root, {}, {
+      watchlist: { no_hardcoded_credentials: { listedAt: 'not-a-date' } },
+      now: NOW,
+    });
+
+    expect(report.candidates.some(c => c.id === 'no_hardcoded_credentials')).toBe(false);
+    expect(report.nextWatchlist['no_hardcoded_credentials']).toEqual({ listedAt: NOW_ISO });
+  });
+
+  it('CLI 级：report 经 StateIO 持久化列入，第二次运行读回仍在名单', async () => {
+    const root = zeroInterceptProject();
+    const stateIO = memoryStateIO();
+
+    await constraintsReport({ projectPath: root, stateIO, now: NOW }, io);
+    expect(stateIO.snapshot().constraintWatchlist?.['no_hardcoded_credentials']).toEqual({ listedAt: NOW_ISO });
+    expect(io.outText()).toContain('观察名单');
+    expect(io.outText()).toContain('no_hardcoded_credentials');
+
+    // 第二次：名单状态经注入面读回，不重复写、不进候选
+    const io2 = captureIO();
+    await constraintsReport({ projectPath: root, stateIO, now: NOW + 10 * DAY_MS }, io2);
+    expect(io2.outText()).toContain('剩余观察 80 天');
+    expect(io2.outText()).not.toContain('[零拦截] no_hardcoded_credentials');
+
+    // 期满：同一条转退役候选
+    const io3 = captureIO();
+    await constraintsReport({ projectPath: root, stateIO, now: NOW + WATCHLIST_PERIOD_DAYS * DAY_MS }, io3);
+    expect(io3.outText()).toContain('[零拦截] no_hardcoded_credentials');
+  });
+
+  it('StateIO 写回不动其他状态字段（读-改-写）', async () => {
+    const root = zeroInterceptProject();
+    const stateIO = memoryStateIO({ shownHints: ['trace_50'], lastStatusRun: '2026-09-01T00:00:00.000Z' });
+
+    await constraintsReport({ projectPath: root, stateIO, now: NOW }, captureIO());
+
+    const s = stateIO.snapshot();
+    expect(s.shownHints).toEqual(['trace_50']);
+    expect(s.lastStatusRun).toBe('2026-09-01T00:00:00.000Z');
+    expect(Object.keys(s.constraintWatchlist ?? {})).toEqual(['no_hardcoded_credentials']);
+  });
+
+  it('--export 脱敏摘要带观察名单分组（列入时间 + 剩余观察期）', async () => {
+    const root = zeroInterceptProject();
+    await constraintsReport({ projectPath: root, export: 'report.md', now: NOW }, captureIO());
+
+    const md = fs.readFileSync(path.join(root, 'report.md'), 'utf-8');
+    expect(md).toContain('## 观察名单');
+    expect(md).toContain('no_hardcoded_credentials');
+    expect(md).toContain(`剩余观察 ${WATCHLIST_PERIOD_DAYS} 天`);
+    expect(md).not.toContain(root);
+  });
+});

package/src/cli/commands/__tests__/constraints-retire.test.ts

@@ -14,6 +14,7 @@
 
 import * as fs from 'fs';
 import { captureIO, type CapturingIO } from '../../command-contract';
+import * as os from 'os';
 import * as path from 'path';
 import { PassThrough, Writable } from 'stream';
 import * as yaml from 'js-yaml';
@@ -21,6 +22,7 @@ import { getConstraint } from '../../../core/constraints/definitions';
 import { getEffectiveConstraints } from '../../../core/effective-constraints';
 import { FileKnowledgeStore } from '../../../knowledge/store';
 import { retireConstraint, constraintsRetire, runRetireInteractive, printRetireResult } from '../constraints-retire';
+import { openKnowledgeStore } from '../knowledge-view';
 import { createProjectFixture, writeProjectTraces } from '../../../test-setup/project-fixture';
 
 const FIXED_NOW = new Date('2026-08-08T12:00:00.000Z');
@@ -32,6 +34,12 @@ function readConfig(root: string): any {
 let io: CapturingIO;
 beforeEach(() => {
   io = captureIO();
+  // retire 的 KnowledgeStore 写口走统一解析点（harness#177）：不隔离会写进真实用户主目录
+  process.env.KNOWLEDGE_BASE_DIR = fs.mkdtempSync(path.join(os.tmpdir(), 'harness-retire-kb-'));
+});
+afterEach(() => {
+  fs.rmSync(process.env.KNOWLEDGE_BASE_DIR!, { recursive: true, force: true });
+  delete process.env.KNOWLEDGE_BASE_DIR;
 });
 
 describe('retireConstraint 执行逻辑', () => {
@@ -49,7 +57,7 @@ describe('retireConstraint 执行逻辑', () => {
     });
 
     expect(result.status).toBe('retired');
-    expect(result.isError).toBe(false);
+    expect(result.isError).toBe(true);
     expect(result.stats).toEqual({ total: 3, fail: 1, failRate: 1 / 3 });
 
     const config = readConfig(root);
@@ -77,7 +85,7 @@ describe('retireConstraint 执行逻辑', () => {
     expect(config.constraints.capability_sync.retired.reason).toBe('');
   });
 
-  it('KnowledgeStore 写入退役记录：规则原文 + 原因 + 统计 + signal 模式', () => {
+  it('KnowledgeStore 写入退役记录：规则原文 + 原因 + 统计 + signal 模式，落点为 knowledge 读口同一解析根（harness#177）', () => {
     const root = createProjectFixture({
       name: 'harness-retire-test',
       traces: [{ constraintId: 'no_completion_without_verification', result: 'fail' }],
@@ -86,8 +94,12 @@ describe('retireConstraint 执行逻辑', () => {
     const result = retireConstraint(root, 'no_completion_without_verification', { reason: '流程已内置门禁', now: FIXED_NOW });
     expect(result.status).toBe('retired');
     expect(result.knowledgeEntryId).toBe('constraint-retired-no_completion_without_verification');
+    // 写口与读口同一解析点：KNOWLEDGE_BASE_DIR 覆盖对写口同步生效
+    expect(result.knowledgeBaseDir).toBe(process.env.KNOWLEDGE_BASE_DIR);
+    // 缺省解析（无 -p/--dir）构造的 store 直接可读——修复前写口硬编码 projectRoot，此处读不到
+    expect(openKnowledgeStore({}, io).get('constraint-retired-no_completion_without_verification')).toBeDefined();
 
-    const store = new FileKnowledgeStore({ baseDir: path.join(root, '.harness', 'knowledge') });
+    const store = new FileKnowledgeStore({ baseDir: process.env.KNOWLEDGE_BASE_DIR! });
     const entry = store.get('constraint-retired-no_completion_without_verification');
     expect(entry).toBeDefined();
     expect(entry!.consumptionMode).toBe('signal');
@@ -104,7 +116,7 @@ describe('retireConstraint 执行逻辑', () => {
     expect(entry!.content).toContain(FIXED_NOW.toISOString());
   });
 
-  it('退役结果打印含回滚语义提示（恢复 = 删 config.yml 段）', () => {
+  it('退役结果打印含回滚语义提示（恢复 = constraints reactivate 命令）', () => {
     const root = createProjectFixture({ name: 'harness-retire-test' });
     const result = retireConstraint(root, 'capability_sync', { now: FIXED_NOW });
     expect(result.status).toBe('retired');
@@ -112,7 +124,38 @@ describe('retireConstraint 执行逻辑', () => {
     printRetireResult(result, io);
     const output = io.outText();
     expect(output).toContain('恢复方法');
-    expect(output).toContain('constraints.capability_sync');
+    expect(output).toContain('harness constraints reactivate capability_sync');
+  });
+
+  it('退役结果打印：git 仓内附 commit 提示，非 git 目录不提示（票 02 断点 4）', () => {
+    const gitRoot = createProjectFixture({ name: 'harness-retire-test', files: { '.git/HEAD': 'ref: refs/heads/master\n' } });
+    const inGit = retireConstraint(gitRoot, 'capability_sync', { now: FIXED_NOW });
+    printRetireResult(inGit, io, gitRoot);
+    expect(io.outText()).toContain('git add .harness/config.yml');
+
+    const plainRoot = createProjectFixture({ name: 'harness-retire-test' });
+    const plainIo = captureIO();
+    const notInGit = retireConstraint(plainRoot, 'capability_sync', { now: FIXED_NOW });
+    printRetireResult(notInGit, plainIo, plainRoot);
+    expect(plainIo.outText()).not.toContain('git add');
+  });
+
+  it('裸 disable 不吞退休：enabled:false 无墓碑时 retire 照常落墓碑 + 沉淀（ADR-0032 决策 6.6，票 02 断点 6）', () => {
+    const root = createProjectFixture({
+      name: 'harness-retire-test',
+      config: 'constraints:\n  capability_sync:\n    enabled: false\n',
+    });
+
+    const result = retireConstraint(root, 'capability_sync', { reason: '升级裸 disable 为退休', now: FIXED_NOW });
+
+    expect(result.status).toBe('retired');
+    const config = readConfig(root);
+    expect(config.constraints.capability_sync.enabled).toBe(false);
+    expect(config.constraints.capability_sync.retired.at).toBe(FIXED_NOW.toISOString());
+    expect(config.constraints.capability_sync.retired.reason).toBe('升级裸 disable 为退休');
+    // 沉淀照写，不被裸 disable 吞掉
+    const store = new FileKnowledgeStore({ baseDir: process.env.KNOWLEDGE_BASE_DIR! });
+    expect(store.get('constraint-retired-capability_sync')).toBeDefined();
   });
 
   it('重复 retire：already_retired，不覆盖原 retired 元数据', () => {
@@ -229,14 +272,14 @@ describe('constraintsRetire 非交互直达', () => {
 
   it('--yes 直达 warning 级退役：不打印 error 级警示并落盘', async () => {
     const root = createProjectFixture({ name: 'harness-retire-test' });
-    await constraintsRetire('no_hardcoded_credentials', { projectPath: root, reason: '直接退役', yes: true }, io);
+    await constraintsRetire('capability_sync', { projectPath: root, reason: '直接退役', yes: true }, io);
 
     const output = io.outText();
     expect(output).not.toContain('是一条 error 级约束');
     expect(output).toContain('已退役');
 
     const config = readConfig(root);
-    expect(config.constraints.no_hardcoded_credentials.enabled).toBe(false);
+    expect(config.constraints.capability_sync.enabled).toBe(false);
   });
 
   it('--yes 直达未知 id：明确提示', async () => {
@@ -305,7 +348,7 @@ describe('runRetireInteractive 交互流程（注入 IO 流）', () => {
       ]);
     writeProjectTraces(root, healthy);
 
-    const streams = makeIo(['no_hardcoded_credentials', '误报太多', 'y']);
+    const streams = makeIo(['capability_sync', '误报太多', 'y']);
     const printed = captureLog();
     await runRetireInteractive(root, streams);
     streams.done();
@@ -316,8 +359,8 @@ describe('runRetireInteractive 交互流程（注入 IO 流）', () => {
     expect(output).toContain('已退役');
 
     const config = readConfig(root);
-    expect(config.constraints.no_hardcoded_credentials.enabled).toBe(false);
-    expect(config.constraints.no_hardcoded_credentials.retired.reason).toBe('误报太多');
+    expect(config.constraints.capability_sync.enabled).toBe(false);
+    expect(config.constraints.capability_sync.retired.reason).toBe('误报太多');
   });
 
   it('坏行 fixture：候选列表前告知损坏行数（决策依据不完整不静默，harness#100）', async () => {
@@ -403,3 +446,85 @@ describe('runRetireInteractive 交互流程（注入 IO 流）', () => {
     expect(fs.existsSync(path.join(root, '.harness', 'config.yml'))).toBe(false);
   });
 });
+
+describe('应用层约束退休（ADR-0033 块 3 子项 3）', () => {
+  const APP_YML = [
+    'constraints:',
+    '  - id: app_no_internal_url',
+    '    rule: Web code must not contain internal URLs',
+    '    checker: regex-scan',
+    '    params:',
+    "      pattern: 'https?://10\\.'",
+    '    severity: warning',
+    '    message: 检测到内网地址',
+    '',
+  ].join('\n');
+
+  function appFixture(configYml?: string): string {
+    return createProjectFixture({
+      name: 'harness-retire-test',
+      config: configYml,
+      files: { [path.join('.harness', 'constraints.yml')]: APP_YML },
+    });
+  }
+
+  it('墓碑写 config.yml 与内置同形（enabled:false + retired），constraints.yml 条文保留不删', () => {
+    const root = appFixture();
+    const ymlBefore = fs.readFileSync(path.join(root, '.harness', 'constraints.yml'), 'utf-8');
+
+    const result = retireConstraint(root, 'app_no_internal_url', { reason: '网关统一拦截', now: FIXED_NOW });
+
+    expect(result.status).toBe('retired');
+    expect(result.isError).toBe(false); // 应用层 severity=warning
+    const config = readConfig(root);
+    const entry = config.constraints.app_no_internal_url;
+    expect(entry.enabled).toBe(false);
+    expect(entry.retired.at).toBe(FIXED_NOW.toISOString());
+    expect(entry.retired.reason).toBe('网关统一拦截');
+    // 退休=停用不是删除：定义正本逐字节不动
+    expect(fs.readFileSync(path.join(root, '.harness', 'constraints.yml'), 'utf-8')).toBe(ymlBefore);
+    // 生效集排除
+    expect(getEffectiveConstraints(root).some(c => c.id === 'app_no_internal_url')).toBe(false);
+  });
+
+  it('沉淀条目复用 saveRetireKnowledge，tags 加 source:app', () => {
+    const root = appFixture();
+    const result = retireConstraint(root, 'app_no_internal_url', { now: FIXED_NOW });
+
+    expect(result.status).toBe('retired');
+    expect(result.knowledgeEntryId).toBe('constraint-retired-app_no_internal_url');
+    const store = new FileKnowledgeStore({ baseDir: process.env.KNOWLEDGE_BASE_DIR! });
+    const entry = store.get('constraint-retired-app_no_internal_url');
+    expect(entry).toBeDefined();
+    expect(entry!.tags).toContain('constraint-retired');
+    expect(entry!.tags).toContain('constraint:app_no_internal_url');
+    expect(entry!.tags).toContain('source:app');
+    expect(entry!.content).toContain('Web code must not contain internal URLs');
+  });
+
+  it('内置退休沉淀不带 source:app（tags 形状不漂移）', () => {
+    const root = createProjectFixture({ name: 'harness-retire-test' });
+    retireConstraint(root, 'capability_sync', { now: FIXED_NOW });
+    const store = new FileKnowledgeStore({ baseDir: process.env.KNOWLEDGE_BASE_DIR! });
+    expect(store.get('constraint-retired-capability_sync')!.tags).not.toContain('source:app');
+  });
+
+  it('重复退休应用层：already_retired 幂等，不覆盖原墓碑', () => {
+    const root = appFixture();
+    retireConstraint(root, 'app_no_internal_url', { reason: '第一次', now: FIXED_NOW });
+
+    const second = retireConstraint(root, 'app_no_internal_url', {
+      reason: '第二次',
+      now: new Date('2026-08-09T00:00:00.000Z'),
+    });
+    expect(second.status).toBe('already_retired');
+    expect(readConfig(root).constraints.app_no_internal_url.retired.reason).toBe('第一次');
+  });
+
+  it('constraints.yml 里的 id 与内置都找不到 → unknown_id', () => {
+    const root = appFixture();
+    const result = retireConstraint(root, 'app_ghost', { now: FIXED_NOW });
+    expect(result.status).toBe('unknown_id');
+    expect(fs.existsSync(path.join(root, '.harness', 'config.yml'))).toBe(false);
+  });
+});

package/src/cli/commands/__tests__/init-ondisk.test.ts

@@ -156,7 +156,7 @@ describe('init 真落盘（无 IO mock）', () => {
     const hook = await read('.git/hooks/pre-commit');
     expect(hook.startsWith('#!/bin/sh\n# Harness pre-commit hook\n')).toBe(true);
     expect(hook).toContain('echo "🔍 Running harness checks..."');
-    expect(hook).toContain("grep -E 'plans/.*\\.md$|\\.plan\\.md$'");
+    expect(hook).toContain('npx @dommaker/harness check --staged');
     expect(hook.endsWith('echo "✅ All checks passed"\n')).toBe(true);
 
     // 第 9 站点（#144）：字节级冻结，改模板必须同步改这份基线（同 GITLAB_PLAIN 手法）

package/src/cli/commands/__tests__/init.test.ts

@@ -105,8 +105,7 @@ describe('init command', () => {
     it('应该输出代码片段模式', async () => {
       await init({ preset: 'standard', printSnippets: true }, io);
       expect(io.outText()).not.toBe('');
-      // 打印版与落盘版 plan 匹配模式须一致（#35：模板字面量 \. 运行期退化为 .）
-      expect(io.outText()).toContain("grep -E 'plans/.*\\.md$|\\.plan\\.md$'");
+      expect(io.outText()).toContain('npx @dommaker/harness check --staged');
     });
   });
 
@@ -153,10 +152,7 @@ describe('init command', () => {
       const hookCall = writeCalls.find((c: any[]) => String(c[0]).includes('pre-commit'));
       expect(hookCall).toBeDefined();
       expect(hookCall![1]).toContain('npx @dommaker/harness check --staged');
-      expect(hookCall![1]).toContain('npx @dommaker/harness posteval-plan');
       expect(hookCall![1]).not.toMatch(/npx harness /);
-      // plan 匹配模式须为转义点（#35：模板字面量 \. 运行期退化为 .）
-      expect(hookCall![1]).toContain("grep -E 'plans/.*\\.md$|\\.plan\\.md$'");
     });
 
     it('pre-commit 片段与落盘 hook 同源（#103：差异行并入共享片段，无第二份文本）', async () => {

package/src/cli/commands/__tests__/knowledge.test.ts

@@ -85,7 +85,8 @@ beforeEach(() => {
 });
 
 // 解析函数本体自 #133 起住 knowledge-view.ts（resolveKnowledgeBaseDir），行为面不变：
-// 这里经 knowledgeStats 观测 `-p` / KNOWLEDGE_BASE_DIR / 旧目录兜底三条路径的解析结果
+// 这里经 knowledgeStats 观测 `-p` / KNOWLEDGE_BASE_DIR / 缺省目录三条路径的解析结果
+// （ADR-0034：旧 ~/.studio/knowledge 兼容沿用已退役，不再属观测面）
 describe('getKnowledgeDir', () => {
   const fs = require('fs');
   const os = require('os');
@@ -119,34 +120,23 @@ describe('getKnowledgeDir', () => {
     }));
   });
 
-  it('should default to ~/.harness/knowledge when no env var and no legacy data', async () => {
+  it('should default to ~/.harness/knowledge when no env var', async () => {
     await knowledgeStats({ json: true }, io);
     expect(storeCtorSpy).toHaveBeenCalledWith(expect.objectContaining({
       baseDir: path.join(tmpHome, '.harness', 'knowledge'),
     }));
   });
 
-  it('should keep legacy ~/.studio/knowledge when it still has data, with deprecation notice shown once', async () => {
+  it('should NOT fall back to legacy ~/.studio/knowledge even when it has data (ADR-0034 目录收编：兼容沿用已退役)', async () => {
     const legacyDir = path.join(tmpHome, '.studio', 'knowledge');
     fs.mkdirSync(legacyDir, { recursive: true });
     fs.writeFileSync(path.join(legacyDir, 'guideline-x.md'), 'data');
     await knowledgeStats({ json: true }, io);
-    expect(storeCtorSpy).toHaveBeenCalledWith(expect.objectContaining({
-      baseDir: legacyDir,
-    }));
-    expect(io.errText()).toContain('旧目录');
-    // 闩锁：同进程重复解析只提示一次
-    await knowledgeStats({ json: true }, io);
-    const notices = io.errLines().filter(line => line.includes('旧目录'));
-    expect(notices).toHaveLength(1);
-  });
-
-  it('should ignore legacy dir when it exists but is empty', async () => {
-    fs.mkdirSync(path.join(tmpHome, '.studio', 'knowledge'), { recursive: true });
-    await knowledgeStats({ json: true }, io);
+    // 旧目录有数据也不再沿用：落缺省 ~/.harness/knowledge，无兼容提示
     expect(storeCtorSpy).toHaveBeenCalledWith(expect.objectContaining({
       baseDir: path.join(tmpHome, '.harness', 'knowledge'),
     }));
+    expect(io.errText()).not.toContain('旧目录');
   });
 
   it('should use projectPath when provided', async () => {

package/src/cli/commands/__tests__/numeric-flag-assembly.test.ts

@@ -57,7 +57,7 @@ const performanceCli = GATE_DEFINITIONS.find(g => g.id === 'performance')!.cli;
 const reviewCli = GATE_DEFINITIONS.find(g => g.id === 'review')!.cli;
 
 describe('constraints report 三阈值：装配点 fail-loud', () => {
-  const valid = { json: false, zeroInterceptMin: '50', noiseFailRate: '0.8', noiseMinTotal: '20' };
+  const valid = { jsonOutput: false, zeroInterceptMin: '50', noiseFailRate: '0.8', noiseMinTotal: '20' };
 
   it('缺省字符串 → 数值（int/int/float 各归其形）', () => {
     expect(reportDef.mapActionArgs!([], valid)).toEqual([{

package/src/cli/commands/__tests__/passes-gate-dead-options.test.ts

@@ -85,7 +85,7 @@ describe('passes-gate 重试选项已删除（A1）', () => {
   it('采集面确实覆盖三类命令位（前提，防空扫致闸失效）', () => {
     const rendered = ALL_CLI_SITES.map(s => `${s.slot} ${s.token}`);
     expect(rendered).toContain('passes-gate --coverage-threshold'); // 通用表叶子命令的旗帜
-    expect(rendered).toContain('constraints report --json'); // children 递归（嵌套命令位）
+    expect(rendered).toContain('constraints report --json-output'); // children 递归（嵌套命令位）
     expect(rendered).toContain('acceptance --task-id'); // 门禁表命令位（GATE_DEFINITIONS.cli）
     expect(rendered).toContain('check list'); // 选项路由键（commander camelCase 键位）
   });

package/src/cli/commands/__tests__/registry.test.ts

@@ -35,7 +35,7 @@ function collectRefs(defs: CommandDefinition[]): CommandImplRef[] {
 
 const EXPECTED_TOP_LEVEL_COMMANDS = [
   'check', 'validate', 'passes-gate', 'init', 'report', 'status', 'spec',
-  'sync-docs', 'knowledge', 'sdd', 'failure', 'posteval-plan',
+  'sync-docs', 'knowledge', 'sdd', 'failure',
   'release', 'constraints',
   'spec-baseline-check',
   // 6 门禁命令（GATE_DEFINITIONS 驱动）

package/src/cli/commands/__tests__/report-app-constraints.test.ts

@@ -0,0 +1,67 @@
+/**
+ * report 命令生效集口径（ADR-0033 块 3 子项 3）
+ *
+ * 缺口修复回归：report 此前跑内置全集（CONSTRAINTS），config.yml 禁用与
+ * 应用层约束（.harness/constraints.yml）都进不了报告面。修复后 collectConstraints
+ * 传 merged config（与 check.ts 同一 getMergedConstraintsConfig 入口），
+ * 应用层条目进总数、违规如实上报。
+ */
+
+import { describe, it, expect } from '@jest/globals';
+import * as path from 'path';
+import { report } from '../report';
+import { captureIO } from '../../command-contract';
+import { CONSTRAINTS } from '../../../core/constraints/definitions';
+import { createProjectFixture } from '../../../test-setup/project-fixture';
+
+const BUILTIN_TOTAL = Object.keys(CONSTRAINTS).length;
+
+/** 应用层约束：file-exists 指向一个不存在的文件（warning 级，必违规） */
+const APP_YML = [
+  'constraints:',
+  '  - id: app_required_readme',
+  '    rule: Project must keep README.app.md',
+  '    checker: file-exists',
+  '    params:',
+  '      path: README.app.md',
+  '    severity: warning',
+  '    message: 缺少 README.app.md',
+  '',
+].join('\n');
+
+function parseJsonReport(output: string) {
+  const start = output.indexOf('{');
+  const end = output.lastIndexOf('}');
+  return JSON.parse(output.slice(start, end + 1));
+}
+
+describe('report 生效集口径（含应用层）', () => {
+  it('应用层约束进报告：总数 +1，违规进 violations', async () => {
+    const root = createProjectFixture({
+      name: 'report-app-effective',
+      files: { [path.join('.harness', 'constraints.yml')]: APP_YML },
+    });
+    const io = captureIO();
+
+    await report({ format: 'json', projectPath: root }, io);
+
+    const data = parseJsonReport(io.outText());
+    expect(data.constraints.total).toBe(BUILTIN_TOTAL + 1);
+    const ids = data.constraints.violations.map((v: { id: string }) => v.id);
+    expect(ids).toContain('app_required_readme');
+    expect(data.constraints.warningViolations).toBeGreaterThanOrEqual(1);
+  });
+
+  it('config.yml 禁用内置约束后总数随生效集收窄（不再报内置全集）', async () => {
+    const root = createProjectFixture({
+      name: 'report-app-effective',
+      config: 'constraints:\n  capability_sync:\n    enabled: false\n',
+    });
+    const io = captureIO();
+
+    await report({ format: 'json', projectPath: root }, io);
+
+    const data = parseJsonReport(io.outText());
+    expect(data.constraints.total).toBe(BUILTIN_TOTAL - 1);
+  });
+});